diff options
Diffstat (limited to 'config/src')
144 files changed, 859 insertions, 717 deletions
diff --git a/config/src/apps/vespa-get-config/getconfig.cpp b/config/src/apps/vespa-get-config/getconfig.cpp index e6375ac9c47..9bbc14552b0 100644 --- a/config/src/apps/vespa-get-config/getconfig.cpp +++ b/config/src/apps/vespa-get-config/getconfig.cpp @@ -2,10 +2,10 @@ #include <vespa/fnet/frt/supervisor.h> #include <vespa/fnet/frt/target.h> -#include <vespa/config/config.h> #include <vespa/config/frt/frtconfigrequestfactory.h> #include <vespa/config/frt/frtconnection.h> #include <vespa/config/common/payload_converter.h> +#include <vespa/config/common/configvalue.h> #include <vespa/fastos/app.h> #include <string> @@ -92,8 +92,8 @@ GetConfig::Main() bool debugging = false; int c = -1; - std::vector<vespalib::string> defSchema; - const char *schema = nullptr; + StringVector defSchema; + const char *schemaString = nullptr; const char *defName = nullptr; const char *defMD5 = ""; std::string defNamespace("config"); @@ -119,7 +119,7 @@ GetConfig::Main() int retval = 1; switch (c) { case 'a': - schema = optArg; + schemaString = optArg; break; case 'n': defName = optArg; @@ -184,17 +184,32 @@ GetConfig::Main() defNamespace = std::string(tmp, defName - tmp - 1); } - if (schema != nullptr) { - std::ifstream is; - is.open(schema); - std::string item; - while (std::getline(is, item)) { - if (item.find("namespace=") == std::string::npos) { - defSchema.push_back(item); - } - } - is.close(); + std::string schema; + if (schemaString == nullptr) { + std::ostringstream tmp; + tmp << getenv("VESPA_HOME"); + tmp << "/share/vespa/configdefinitions/"; + tmp << defNamespace; + tmp << "."; + tmp << defName; + tmp << ".def"; + schema = tmp.str(); + } else { + schema = schemaString; } + if (debugging) { + printf("Using schema in %s\n", schema.c_str()); + } + std::ifstream is; + is.open(schema); + std::string item; + while (std::getline(is, item)) { + if (item.find("namespace=") == std::string::npos) { + defSchema.push_back(item); + } + } + is.close(); + std::ostringstream tmp; tmp << "tcp/"; tmp << serverHost; @@ -228,8 +243,8 @@ GetConfig::Main() } else { response->fill(); ConfigKey rKey(response->getKey()); - ConfigState rState(response->getConfigState()); - ConfigValue rValue(response->getValue()); + const ConfigState & rState = response->getConfigState(); + const ConfigValue & rValue = response->getValue(); if (debugging) { printf("defName %s\n", rKey.getDefName().c_str()); printf("defMD5 %s\n", rKey.getDefMd5().c_str()); @@ -247,7 +262,7 @@ GetConfig::Main() if (printAsJson) { printf("%s\n", rValue.asJson().c_str()); } else { - std::vector<vespalib::string> lines = rValue.getLegacyFormat(); + StringVector lines = rValue.getLegacyFormat(); for (uint32_t j = 0; j < lines.size(); j++) { printf("%s\n", lines[j].c_str()); } diff --git a/config/src/main/java/com/yahoo/config/subscription/CfgConfigPayloadBuilder.java b/config/src/main/java/com/yahoo/config/subscription/CfgConfigPayloadBuilder.java index 1a110fe8e6c..7d3fdad43c7 100644 --- a/config/src/main/java/com/yahoo/config/subscription/CfgConfigPayloadBuilder.java +++ b/config/src/main/java/com/yahoo/config/subscription/CfgConfigPayloadBuilder.java @@ -17,7 +17,9 @@ import static java.util.logging.Level.FINEST; * Deserializes config payload (cfg format) to a ConfigPayload. * * @author hmusum + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class CfgConfigPayloadBuilder { private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(CfgConfigPayloadBuilder.class.getName()); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigDebug.java b/config/src/main/java/com/yahoo/config/subscription/ConfigDebug.java index 85aa7a05e17..2fcbdce7030 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigDebug.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigDebug.java @@ -9,6 +9,7 @@ import java.util.logging.Logger; import static java.util.logging.Level.INFO; // Debug class that provides useful helper routines +@Deprecated(forRemoval = true, since = "7") public class ConfigDebug { public static void logDebug(Logger logger, long timestamp, ConfigKey<?> key, String logmessage) { if (key.getConfigId().matches(".*container.?\\d+.*") || key.getConfigId().matches(".*doc.api.*")) { diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigGetter.java b/config/src/main/java/com/yahoo/config/subscription/ConfigGetter.java index f349c8fe47d..305ecbd6483 100755 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigGetter.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigGetter.java @@ -34,7 +34,10 @@ public class ConfigGetter<T extends ConfigInstance> { * * @param source a {@link ConfigSource} * @param clazz a config class + * + * @deprecated Config should always be injected via the component class constructor. For unit tests, use config builders. */ + @Deprecated(forRemoval = true, since = "7") public ConfigGetter(ConfigSource source, Class<T> clazz) { this.clazz = clazz; this.source = source; @@ -74,7 +77,10 @@ public class ConfigGetter<T extends ConfigInstance> { * @param configId a config id to use when getting the config * @param source a {@link ConfigSource} * @return an instance of a config class + * + * @deprecated Config should always be injected via the component class constructor. For unit tests, use config builders. */ + @Deprecated(forRemoval = true, since = "7") public static <T extends ConfigInstance> T getConfig(Class<T> c, String configId, ConfigSource source) { ConfigGetter<T> getter = new ConfigGetter<>(source, c); return getter.getConfig(configId); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigHandle.java b/config/src/main/java/com/yahoo/config/subscription/ConfigHandle.java index c0eff773bac..6b832205211 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigHandle.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigHandle.java @@ -10,7 +10,9 @@ import com.yahoo.config.subscription.impl.ConfigSubscription; * * @param <T> the type of the config * @author vegardh + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigHandle<T extends ConfigInstance> { private final ConfigSubscription<T> sub; diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceSerializer.java b/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceSerializer.java index e035991abf4..d8062a9f95b 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceSerializer.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceSerializer.java @@ -9,7 +9,9 @@ import com.yahoo.slime.Slime; * Implements a config instance serializer, serializing a config instance to a slime object. * * @author Ulf Lilleengen + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigInstanceSerializer implements Serializer { private final Slime slime; private final Cursor root; diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceUtil.java b/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceUtil.java index f1b7952f3b1..5831753eacb 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceUtil.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigInstanceUtil.java @@ -14,7 +14,9 @@ import com.yahoo.vespa.config.*; /** * @author gjoranv + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigInstanceUtil { /** diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigInterruptedException.java b/config/src/main/java/com/yahoo/config/subscription/ConfigInterruptedException.java index a7c2c2d9127..050b7a81fa2 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigInterruptedException.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigInterruptedException.java @@ -4,8 +4,10 @@ package com.yahoo.config.subscription; /** * This exception is thrown when any blocking call within the Config API is interrupted. * @author Ulf Lilleengen + * @deprecated Will be removed in Vespa 8. Only for internal use. */ @SuppressWarnings("serial") +@Deprecated(forRemoval = true, since = "7") public class ConfigInterruptedException extends RuntimeException { public ConfigInterruptedException(Throwable cause) { super(cause); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigSet.java b/config/src/main/java/com/yahoo/config/subscription/ConfigSet.java index 02cc87f65d7..36d9047aa87 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigSet.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigSet.java @@ -11,7 +11,9 @@ import com.yahoo.vespa.config.ConfigKey; * Config source as a programmatically built set of {@link com.yahoo.config.ConfigInstance}s * * @author Vegard Havdal + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigSet implements ConfigSource { private final Map<ConfigKey<?>, ConfigInstance.Builder> configs = new ConcurrentHashMap<>(); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigSource.java b/config/src/main/java/com/yahoo/config/subscription/ConfigSource.java index 5814a004216..b8abeb48c3d 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigSource.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigSource.java @@ -5,7 +5,9 @@ package com.yahoo.config.subscription; * A type of source of config * * @author Vegard Havdal + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public interface ConfigSource { } diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigSourceSet.java b/config/src/main/java/com/yahoo/config/subscription/ConfigSourceSet.java index 81aeda52b54..37f91605a54 100755 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigSourceSet.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigSourceSet.java @@ -18,7 +18,9 @@ import static java.util.logging.Level.INFO; * upper/lower-casing and whitespaces. * * @author gjoranv + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigSourceSet implements ConfigSource { private static final Logger log = Logger.getLogger(ConfigSourceSet.class.getName()); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigSubscriber.java b/config/src/main/java/com/yahoo/config/subscription/ConfigSubscriber.java index 4bf442a0890..ee6ce37036c 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigSubscriber.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigSubscriber.java @@ -28,7 +28,9 @@ import static java.util.stream.Collectors.toList; * {@link ConfigHandle} which {@link #subscribe(Class, String)} returned. * * @author Vegard Havdal + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigSubscriber implements AutoCloseable { private static final Logger log = Logger.getLogger(ConfigSubscriber.class.getName()); @@ -154,6 +156,7 @@ public class ConfigSubscriber implements AutoCloseable { * false if this is for reconfiguration * @return true if a config/reconfig of your system should happen * @throws ConfigInterruptedException if thread performing this call interrupted. + * @throws SubscriberClosedException if subscriber is closed */ public boolean nextConfig(boolean isInitializing) { return nextConfig(TimingValues.defaultNextConfigTimeout, isInitializing); @@ -185,6 +188,7 @@ public class ConfigSubscriber implements AutoCloseable { * false if this is for reconfiguration * @return true if a config/reconfig of your system should happen * @throws ConfigInterruptedException if thread performing this call interrupted. + * @throws SubscriberClosedException if subscriber is closed */ public boolean nextConfig(long timeoutMillis, boolean isInitializing) { return acquireSnapshot(timeoutMillis, true, isInitializing); @@ -216,6 +220,7 @@ public class ConfigSubscriber implements AutoCloseable { * false if this is for reconfiguration * @return true if generations for all configs have been updated. * @throws ConfigInterruptedException if thread performing this call interrupted. + * @throws SubscriberClosedException if subscriber is closed */ public boolean nextGeneration(boolean isInitializing) { return nextGeneration(TimingValues.defaultNextConfigTimeout, isInitializing); @@ -247,6 +252,7 @@ public class ConfigSubscriber implements AutoCloseable { * false if this is for reconfiguration * @return true if generations for all configs have been updated. * @throws ConfigInterruptedException if thread performing this call interrupted. + * @throws SubscriberClosedException if subscriber is closed */ public boolean nextGeneration(long timeoutMillis, boolean isInitializing) { return acquireSnapshot(timeoutMillis, false, isInitializing); @@ -269,11 +275,12 @@ public class ConfigSubscriber implements AutoCloseable { private boolean acquireSnapshot(long timeoutInMillis, boolean requireChange, boolean isInitializing) { boolean applyOnRestartOnly; synchronized (monitor) { - if (state == State.CLOSED) return false; + if (state == State.CLOSED) throw new SubscriberClosedException(); state = State.FROZEN; applyOnRestartOnly = applyOnRestart; } - long started = System.currentTimeMillis(); + boolean expiredOnEntry = (timeoutInMillis <= 0); + long started = now(expiredOnEntry); long timeLeftMillis = timeoutInMillis; boolean anyConfigChanged = false; @@ -302,7 +309,7 @@ public class ConfigSubscriber implements AutoCloseable { allGenerationsChanged &= config.isGenerationChanged(); anyConfigChanged |= config.isConfigChanged(); applyOnRestartOnly |= config.applyOnRestart(); - timeLeftMillis = timeoutInMillis + started - System.currentTimeMillis(); + timeLeftMillis = timeoutInMillis + started - now(expiredOnEntry); } reconfigDue = (isInitializing || !applyOnRestartOnly) && (anyConfigChanged || !requireChange) && allGenerationsChanged && allGenerationsTheSame; @@ -329,6 +336,10 @@ public class ConfigSubscriber implements AutoCloseable { return reconfigDue; } + private long now(boolean alreadyExpired) { + return alreadyExpired ? 0 : System.currentTimeMillis(); + } + private void sleep(long timeLeftMillis) { try { Thread.sleep(Math.min(10, timeLeftMillis)); diff --git a/config/src/main/java/com/yahoo/config/subscription/ConfigURI.java b/config/src/main/java/com/yahoo/config/subscription/ConfigURI.java index 6053ba5303a..46db3c6c83a 100644 --- a/config/src/main/java/com/yahoo/config/subscription/ConfigURI.java +++ b/config/src/main/java/com/yahoo/config/subscription/ConfigURI.java @@ -10,7 +10,9 @@ import com.yahoo.config.subscription.impl.JRTConfigRequester; * object to simplify parameter passing. * * @author Ulf Lilleengen + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class ConfigURI { private String configId; diff --git a/config/src/main/java/com/yahoo/config/subscription/DirSource.java b/config/src/main/java/com/yahoo/config/subscription/DirSource.java index 240d1b8e81d..48d52bd49f3 100644 --- a/config/src/main/java/com/yahoo/config/subscription/DirSource.java +++ b/config/src/main/java/com/yahoo/config/subscription/DirSource.java @@ -6,8 +6,9 @@ import java.io.File; /** * Source specifying config from a local directory * @author Vegard Havdal - * + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class DirSource implements ConfigSource { private final File dir; diff --git a/config/src/main/java/com/yahoo/config/subscription/FileSource.java b/config/src/main/java/com/yahoo/config/subscription/FileSource.java index 2178c64cca3..bbad7286b4c 100644 --- a/config/src/main/java/com/yahoo/config/subscription/FileSource.java +++ b/config/src/main/java/com/yahoo/config/subscription/FileSource.java @@ -7,7 +7,9 @@ import java.io.File; * Source specifying config from one local file * * @author Vegard Havdal + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class FileSource implements ConfigSource { private final File file; diff --git a/config/src/main/java/com/yahoo/config/subscription/JarSource.java b/config/src/main/java/com/yahoo/config/subscription/JarSource.java index e367f78c31f..f39ee5e9262 100644 --- a/config/src/main/java/com/yahoo/config/subscription/JarSource.java +++ b/config/src/main/java/com/yahoo/config/subscription/JarSource.java @@ -6,8 +6,9 @@ import java.util.jar.JarFile; /** * Source specifying config as a jar file entry * @author Vegard Havdal - * + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class JarSource implements ConfigSource { private final String path; private final JarFile jarFile; diff --git a/config/src/main/java/com/yahoo/config/subscription/RawSource.java b/config/src/main/java/com/yahoo/config/subscription/RawSource.java index 8b73d2058f5..28b249c6ece 100644 --- a/config/src/main/java/com/yahoo/config/subscription/RawSource.java +++ b/config/src/main/java/com/yahoo/config/subscription/RawSource.java @@ -5,7 +5,9 @@ package com.yahoo.config.subscription; * Source specifying raw config, where payload is given programmatically * * @author Vegard Havdal + * @deprecated Will be removed in Vespa 8. Only for internal use. */ +@Deprecated(forRemoval = true, since = "7") public class RawSource implements ConfigSource { public final String payload; diff --git a/config/src/main/java/com/yahoo/config/subscription/SubscriberClosedException.java b/config/src/main/java/com/yahoo/config/subscription/SubscriberClosedException.java new file mode 100644 index 00000000000..f7051ab1b38 --- /dev/null +++ b/config/src/main/java/com/yahoo/config/subscription/SubscriberClosedException.java @@ -0,0 +1,11 @@ +// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.config.subscription; + +/** + * Thrown when {@link ConfigSubscriber} is closed + * + * @author bjorncs + * @deprecated Will be removed in Vespa 8. Only for internal use. + */ +@Deprecated(forRemoval = true, since = "7") +public class SubscriberClosedException extends RuntimeException {} diff --git a/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSetSubscription.java b/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSetSubscription.java index 85bb1cd4ca7..68f1dc2df17 100644 --- a/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSetSubscription.java +++ b/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSetSubscription.java @@ -29,23 +29,31 @@ public class ConfigSetSubscription<T extends ConfigInstance> extends ConfigSubsc setGeneration(0L); } + private boolean hasConfigChanged() { + T myInstance = getNewInstance(); + ConfigState<T> configState = getConfigState(); + // User forced reload + if (checkReloaded()) { + setConfigIfChanged(myInstance); + return true; + } + if (!myInstance.equals(configState.getConfig())) { + setConfigIncGen(myInstance); + return true; + } + return false; + } + @Override public boolean nextConfig(long timeout) { - long end = System.currentTimeMillis() + timeout; + if (hasConfigChanged()) return true; + if (timeout <= 0) return false; + + long end = System.nanoTime() + timeout * 1_000_000; do { - T myInstance = getNewInstance(); - ConfigState<T> configState = getConfigState(); - // User forced reload - if (checkReloaded()) { - setConfigIfChanged(myInstance); - return true; - } - if (!myInstance.equals(configState.getConfig())) { - setConfigIncGen(myInstance); - return true; - } sleep(); - } while (System.currentTimeMillis() < end); + if (hasConfigChanged()) return true; + } while (System.nanoTime() < end); return false; } diff --git a/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSubscription.java b/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSubscription.java index f8a45a11b70..caa11b211ac 100644 --- a/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSubscription.java +++ b/config/src/main/java/com/yahoo/config/subscription/impl/ConfigSubscription.java @@ -10,6 +10,7 @@ import com.yahoo.config.subscription.DirSource; import com.yahoo.config.subscription.FileSource; import com.yahoo.config.subscription.JarSource; import com.yahoo.config.subscription.RawSource; +import com.yahoo.text.internal.SnippetGenerator; import com.yahoo.vespa.config.ConfigKey; import com.yahoo.vespa.config.PayloadChecksums; import com.yahoo.vespa.config.TimingValues; @@ -198,13 +199,14 @@ public abstract class ConfigSubscription<T extends ConfigInstance> { } void setConfigAndGeneration(Long generation, boolean applyOnRestart, T config, PayloadChecksums payloadChecksums) { - ConfigState<T> prev = this.config.get(); - boolean configChanged = !Objects.equals(prev.getConfig(), config); - String message = "Config has changed unexpectedly for " + key + ", generation " + generation; - if (configChanged) { - if (log.isLoggable(Level.FINE)) - message = message + ", config in state :" + prev.getConfig() + ", new config: " + config; - log.log(Level.WARNING, message); + T previousConfig = this.config.get().getConfig(); + boolean configChanged = ! Objects.equals(previousConfig, config); + if (previousConfig != null && configChanged) { + SnippetGenerator generator = new SnippetGenerator(); + int sizeHint = 500; + log.log(Level.WARNING, "Config has changed unexpectedly for " + key + ", generation " + generation + + ", config in state :" + generator.makeSnippet(previousConfig.toString(), sizeHint) + ", new config: " + + generator.makeSnippet(config.toString(), sizeHint)); } this.config.set(new ConfigState<>(true, generation, applyOnRestart, configChanged, config, payloadChecksums)); } diff --git a/config/src/main/java/com/yahoo/config/subscription/impl/JRTConfigSubscription.java b/config/src/main/java/com/yahoo/config/subscription/impl/JRTConfigSubscription.java index a18f1b4b260..90c538ac19b 100644 --- a/config/src/main/java/com/yahoo/config/subscription/impl/JRTConfigSubscription.java +++ b/config/src/main/java/com/yahoo/config/subscription/impl/JRTConfigSubscription.java @@ -72,12 +72,12 @@ public class JRTConfigSubscription<T extends ConfigInstance> extends ConfigSubsc JRTClientConfigRequest response = pollQueue(timeoutMillis); // There might be more than one response on the queue, so empty queue by polling with // 0 timeout until queue is empty (returned value is null) - JRTClientConfigRequest temp; - do { + JRTClientConfigRequest temp = response; + while (temp != null) { temp = pollQueue(0); if (temp != null) response = temp; - } while (temp != null); + } return response; } diff --git a/config/src/main/java/com/yahoo/vespa/config/ConfigKey.java b/config/src/main/java/com/yahoo/vespa/config/ConfigKey.java index 9a7ac58e339..2fccabe111b 100755 --- a/config/src/main/java/com/yahoo/vespa/config/ConfigKey.java +++ b/config/src/main/java/com/yahoo/vespa/config/ConfigKey.java @@ -108,16 +108,7 @@ public class ConfigKey<CONFIGCLASS extends ConfigInstance> implements Comparable return configClass; } - public String toString() { - StringBuilder sb = new StringBuilder(); - sb.append("name="); - sb.append(name); - sb.append(",namespace="); - sb.append(namespace); - sb.append(",configId="); - sb.append(configId); - return sb.toString(); - } + public String toString() { return "name=" + namespace + "." + name + ",configId=" + configId; } public static ConfigKey<?> createFull(String name, String configId, String namespace) { return new ConfigKey<>(name, configId, namespace, null); diff --git a/config/src/test/java/com/yahoo/config/subscription/ConfigSetTest.java b/config/src/test/java/com/yahoo/config/subscription/ConfigSetTest.java index c9e7bb23402..c141ed8403c 100644 --- a/config/src/test/java/com/yahoo/config/subscription/ConfigSetTest.java +++ b/config/src/test/java/com/yahoo/config/subscription/ConfigSetTest.java @@ -18,7 +18,7 @@ public class ConfigSetTest { ConfigSet set = new ConfigSet(); SimpletypesConfig.Builder builder = new SimpletypesConfig.Builder(); set.addBuilder("foo", builder); - assertTrue(Pattern.matches("name=simpletypes,namespace=foo,configId=foo=>com.yahoo.foo.SimpletypesConfig.*", + assertTrue(Pattern.matches("name=foo.simpletypes,configId=foo=>com.yahoo.foo.SimpletypesConfig.*", set.toString())); } } diff --git a/config/src/tests/api/api.cpp b/config/src/tests/api/api.cpp index 9cf6ea610bf..3377d256b97 100644 --- a/config/src/tests/api/api.cpp +++ b/config/src/tests/api/api.cpp @@ -1,8 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/configcontext.h> #include <config-my.h> +#include <vespa/config/subscription/configsubscriber.hpp> using namespace config; diff --git a/config/src/tests/configagent/configagent.cpp b/config/src/tests/configagent/configagent.cpp index 3fbbee8c601..10f321c181d 100644 --- a/config/src/tests/configagent/configagent.cpp +++ b/config/src/tests/configagent/configagent.cpp @@ -1,11 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> -#include <vespa/config/raw/rawsource.h> #include <vespa/config/common/misc.h> #include <vespa/config/common/configrequest.h> #include <vespa/config/common/timingvalues.h> #include <vespa/config/common/trace.h> +#include <vespa/config/common/configkey.h> +#include <vespa/config/common/configholder.h> #include <vespa/config/frt/frtconfigagent.h> #include <config-my.h> @@ -30,10 +30,10 @@ public: class MyConfigResponse : public ConfigResponse { public: - MyConfigResponse(const ConfigKey & key, const ConfigValue & value, bool valid, int64_t timestamp, + MyConfigResponse(const ConfigKey & key, ConfigValue value, bool valid, int64_t timestamp, const vespalib::string & xxhash64, const std::string & errorMsg, int errorC0de, bool iserror) : _key(key), - _value(value), + _value(std::move(value)), _fillCalled(false), _valid(valid), _state(xxhash64, timestamp, false), @@ -83,10 +83,8 @@ public: class MyHolder : public IConfigHolder { public: - MyHolder() - : _update() - { - } + MyHolder() noexcept = default; + ~MyHolder() = default; std::unique_ptr<ConfigUpdate> provide() override { @@ -116,7 +114,7 @@ private: ConfigValue createValue(const std::string & myField, const std::string & xxhash64) { - std::vector< vespalib::string > lines; + StringVector lines; lines.push_back("myField \"" + myField + "\""); return ConfigValue(lines, xxhash64); } @@ -135,7 +133,7 @@ static TimingValues testTimingValues( 2000); // maxDelayMultiplier TEST("require that agent returns correct values") { - FRTConfigAgent handler(IConfigHolder::SP(new MyHolder()), testTimingValues); + FRTConfigAgent handler(std::make_shared<MyHolder>(), testTimingValues); ASSERT_EQUAL(500u, handler.getTimeout()); ASSERT_EQUAL(0u, handler.getWaitTime()); ConfigState cs; @@ -147,12 +145,12 @@ TEST("require that agent returns correct values") { TEST("require that successful request is delivered to holder") { const ConfigKey testKey(ConfigKey::create<MyConfig>("mykey")); const ConfigValue testValue(createValue("l33t", "a")); - IConfigHolder::SP latch(new MyHolder()); + auto latch = std::make_shared<MyHolder>(); FRTConfigAgent handler(latch, testTimingValues); handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue)); ASSERT_TRUE(latch->poll()); - ConfigUpdate::UP update(latch->provide()); + std::unique_ptr<ConfigUpdate> update(latch->provide()); ASSERT_TRUE(update); ASSERT_TRUE(update->hasChanged()); MyConfig cfg(update->getValue()); @@ -163,13 +161,13 @@ TEST("require that important(the change) request is delivered to holder even if const ConfigKey testKey(ConfigKey::create<MyConfig>("mykey")); const ConfigValue testValue1(createValue("l33t", "a")); const ConfigValue testValue2(createValue("l34t", "b")); - IConfigHolder::SP latch(new MyHolder()); + auto latch = std::make_shared<MyHolder>(); FRTConfigAgent handler(latch, testTimingValues); handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue1, 1, testValue1.getXxhash64())); ASSERT_TRUE(latch->poll()); - ConfigUpdate::UP update(latch->provide()); + std::unique_ptr<ConfigUpdate> update(latch->provide()); ASSERT_TRUE(update); ASSERT_TRUE(update->hasChanged()); MyConfig cfg(update->getValue()); @@ -190,7 +188,7 @@ TEST("require that important(the change) request is delivered to holder even if TEST("require that successful request sets correct wait time") { const ConfigKey testKey(ConfigKey::create<MyConfig>("mykey")); const ConfigValue testValue(createValue("l33t", "a")); - IConfigHolder::SP latch(new MyHolder()); + auto latch = std::make_shared<MyHolder>(); FRTConfigAgent handler(latch, testTimingValues); handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createOKResponse(testKey, testValue)); @@ -203,7 +201,7 @@ TEST("require that successful request sets correct wait time") { TEST("require that bad config response returns false") { const ConfigKey testKey(ConfigKey::create<MyConfig>("mykey")); const ConfigValue testValue(createValue("myval", "a")); - IConfigHolder::SP latch(new MyHolder()); + auto latch = std::make_shared<MyHolder>(); FRTConfigAgent handler(latch, testTimingValues); handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createConfigErrorResponse(testKey, testValue)); @@ -241,10 +239,9 @@ TEST("require that bad config response returns false") { TEST("require that bad response returns false") { const ConfigKey testKey(ConfigKey::create<MyConfig>("mykey")); - std::vector<vespalib::string> lines; - const ConfigValue testValue(lines, "a"); + const ConfigValue testValue(StringVector(), "a"); - IConfigHolder::SP latch(new MyHolder()); + auto latch = std::make_shared<MyHolder>(); FRTConfigAgent handler(latch, testTimingValues); handler.handleResponse(MyConfigRequest(testKey), MyConfigResponse::createServerErrorResponse(testKey, testValue)); diff --git a/config/src/tests/configfetcher/configfetcher.cpp b/config/src/tests/configfetcher/configfetcher.cpp index 4782557338d..6142f9469fc 100644 --- a/config/src/tests/configfetcher/configfetcher.cpp +++ b/config/src/tests/configfetcher/configfetcher.cpp @@ -1,6 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/helper/configfetcher.h> +#include <vespa/config/helper/configfetcher.hpp> #include <vespa/config/common/configcontext.h> #include <vespa/vespalib/util/exception.h> #include "config-my.h" @@ -125,7 +125,7 @@ namespace { struct ConfigFixture { MyConfigBuilder builder; ConfigSet set; - ConfigContext::SP context; + std::shared_ptr<ConfigContext> context; ConfigFixture() : builder(), set(), context() { set.addBuilder("cfgid", &builder); context = std::make_shared<ConfigContext>(set); diff --git a/config/src/tests/configformat/configformat.cpp b/config/src/tests/configformat/configformat.cpp index 6623e2ee254..65c40eaea8d 100644 --- a/config/src/tests/configformat/configformat.cpp +++ b/config/src/tests/configformat/configformat.cpp @@ -1,6 +1,5 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/print/fileconfigformatter.h> #include <vespa/vespalib/data/slime/slime.h> diff --git a/config/src/tests/configgen/configgen.cpp b/config/src/tests/configgen/configgen.cpp index b7113dec972..2d08b526e8d 100644 --- a/config/src/tests/configgen/configgen.cpp +++ b/config/src/tests/configgen/configgen.cpp @@ -1,7 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/helper/configgetter.hpp> #include "config-motd.h" diff --git a/config/src/tests/configgen/map_inserter.cpp b/config/src/tests/configgen/map_inserter.cpp index 2a37d401792..bf1b856972e 100644 --- a/config/src/tests/configgen/map_inserter.cpp +++ b/config/src/tests/configgen/map_inserter.cpp @@ -1,8 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/configgen/map_inserter.h> #include <vespa/vespalib/data/slime/slime.h> +#include <vespa/config/configgen/map_inserter.hpp> using namespace config; using namespace config::internal; diff --git a/config/src/tests/configgen/vector_inserter.cpp b/config/src/tests/configgen/vector_inserter.cpp index b8611317650..80ebf0fc95f 100644 --- a/config/src/tests/configgen/vector_inserter.cpp +++ b/config/src/tests/configgen/vector_inserter.cpp @@ -1,7 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/configgen/vector_inserter.h> +#include <vespa/config/common/types.h> +#include <vespa/config/configgen/vector_inserter.hpp> #include <vespa/vespalib/data/slime/slime.h> using namespace config; @@ -27,7 +28,7 @@ TEST("require that vector of ints can be inserted") { root.addLong(3); root.addLong(2); root.addLong(6); - VectorInserter<int32_t> inserter(vector); + VectorInserter inserter(vector); root.traverse(inserter); ASSERT_EQUAL(3u, vector.size()); ASSERT_EQUAL(3, vector[0]); @@ -45,7 +46,7 @@ TEST("require that vector of struct can be inserted") { Cursor & two = root.addObject(); two.setLong("foo", 1); two.setLong("bar", 6); - VectorInserter<MyType> inserter(typeVector); + VectorInserter inserter(typeVector); root.traverse(inserter); ASSERT_EQUAL(2u, typeVector.size()); ASSERT_EQUAL(3, typeVector[0].foo); @@ -61,7 +62,7 @@ TEST("require that vector of long can be inserted") { root.addLong(3); root.addLong(2); root.addLong(6); - VectorInserter<int64_t> inserter(vector); + VectorInserter inserter(vector); root.traverse(inserter); ASSERT_EQUAL(3u, vector.size()); ASSERT_EQUAL(3, vector[0]); @@ -76,7 +77,7 @@ TEST("require that vector of double can be inserted") { root.addDouble(3.1); root.addDouble(2.4); root.addDouble(6.6); - VectorInserter<double> inserter(vector); + VectorInserter inserter(vector); root.traverse(inserter); ASSERT_EQUAL(3u, vector.size()); ASSERT_EQUAL(3.1, vector[0]); @@ -91,7 +92,7 @@ TEST("require that vector of bool can be inserted") { root.addBool(true); root.addBool(false); root.addBool(true); - VectorInserter<bool> inserter(vector); + VectorInserter inserter(vector); root.traverse(inserter); ASSERT_EQUAL(3u, vector.size()); ASSERT_TRUE(vector[0]); @@ -99,14 +100,15 @@ TEST("require that vector of bool can be inserted") { ASSERT_TRUE(vector[2]); } -TEST("require that vector of string can be inserted") { - std::vector<vespalib::string> vector; +template<typename V> +void +verify_vector_strings_can_be_inserted(V vector) { Slime slime; Cursor & root = slime.setArray(); root.addString("foo"); root.addString("bar"); root.addString("baz"); - VectorInserter<vespalib::string> inserter(vector); + VectorInserter inserter(vector); root.traverse(inserter); ASSERT_EQUAL(3u, vector.size()); ASSERT_EQUAL("foo", vector[0]); @@ -114,4 +116,9 @@ TEST("require that vector of string can be inserted") { ASSERT_EQUAL("baz", vector[2]); } +TEST("require that different vectors of strings can be inserted") { + verify_vector_strings_can_be_inserted(std::vector<vespalib::string>()); + verify_vector_strings_can_be_inserted(StringVector()); +} + TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/config/src/tests/configholder/configholder.cpp b/config/src/tests/configholder/configholder.cpp index db32cc2e309..b2f6cd83693 100644 --- a/config/src/tests/configholder/configholder.cpp +++ b/config/src/tests/configholder/configholder.cpp @@ -14,8 +14,8 @@ constexpr vespalib::duration ONE_MINUTE = 60s; TEST("Require that element order is correct") { - ConfigValue value(std::vector<vespalib::string>(), "foo"); - ConfigValue value2(std::vector<vespalib::string>(), "bar"); + ConfigValue value(StringVector(), "foo"); + ConfigValue value2(StringVector(), "bar"); ConfigHolder holder; holder.handle(std::make_unique<ConfigUpdate>(value, true, 0)); diff --git a/config/src/tests/configmanager/configmanager.cpp b/config/src/tests/configmanager/configmanager.cpp index 2cc5d4fad4f..a7171b11137 100644 --- a/config/src/tests/configmanager/configmanager.cpp +++ b/config/src/tests/configmanager/configmanager.cpp @@ -1,11 +1,12 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/vespalib/util/noncopyable.hpp> #include <vespa/config/common/configmanager.h> #include <vespa/config/common/exceptions.h> #include <vespa/config/common/timingvalues.h> #include <vespa/config/subscription/sourcespec.h> +#include <vespa/config/common/iconfigholder.h> + #include <vespa/config/raw/rawsource.h> #include "config-my.h" @@ -16,7 +17,7 @@ namespace { ConfigValue createValue(const std::string & myField, const std::string & md5) { - std::vector< vespalib::string > lines; + StringVector lines; lines.push_back("myField \"" + myField + "\""); return ConfigValue(lines, md5); } @@ -36,12 +37,12 @@ namespace { class MySource : public Source { public: - MySource(TestContext * data, const IConfigHolder::SP & holder) : _holder(holder), _data(data) { } + MySource(TestContext * data, std::shared_ptr<IConfigHolder> holder) : _holder(std::move(holder)), _data(data) { } void getConfig() override { _data->numGetConfig++; if (_data->respond) { - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(), true, _data->generation))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(), true, _data->generation)); } } void reload(int64_t generation) override @@ -53,7 +54,7 @@ namespace { { _data->numClose++; } - IConfigHolder::SP _holder; + std::shared_ptr<IConfigHolder> _holder; TestContext * _data; }; @@ -61,10 +62,10 @@ namespace { { public: MySourceFactory(TestContext * d) : data(d) { } - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override { (void) key; - return Source::UP(new MySource(data, holder)); + return std::make_unique<MySource>(data, std::move(holder)); } TestContext * data; }; @@ -78,9 +79,9 @@ namespace { { } SourceSpecKey createKey() const { return SourceSpecKey(_key); } - SourceFactory::UP createSourceFactory(const TimingValues & timingValues) const override { + std::unique_ptr<SourceFactory> createSourceFactory(const TimingValues & timingValues) const override { (void) timingValues; - return SourceFactory::UP(new MySourceFactory(_data)); + return std::make_unique<MySourceFactory>(_data); } SourceSpec * clone() const { return new MySpec(*this); } private: diff --git a/config/src/tests/configparser/configparser.cpp b/config/src/tests/configparser/configparser.cpp index 965c2a5a312..32043ae79dc 100644 --- a/config/src/tests/configparser/configparser.cpp +++ b/config/src/tests/configparser/configparser.cpp @@ -1,8 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/configparser.h> #include <vespa/config/common/exceptions.h> +#include <vespa/config/common/configvalue.h> +#include <vespa/config/common/misc.h> #include "config-foo.h" #include <fstream> #include <vespa/vespalib/stllike/asciistream.h> @@ -23,7 +24,7 @@ namespace { ConfigValue readConfig(const vespalib::string & fileName) { asciistream is(asciistream::createFromFile(fileName)); - return ConfigValue(is.getlines(), ""); + return ConfigValue(getlines(is), ""); } } @@ -102,14 +103,14 @@ TEST("require that array lengths may be specified") } TEST("require that escaped values are properly unescaped") { - std::vector<vespalib::string> payload; + StringVector payload; payload.push_back("foo \"a\\nb\\rc\\\\d\\\"e\x42g\""); vespalib::string value(ConfigParser::parse<vespalib::string>("foo", payload)); ASSERT_EQUAL("a\nb\rc\\d\"eBg", value); } TEST("verify that locale does not affect double parsing") { - std::vector<vespalib::string> payload; + StringVector payload; setlocale(LC_NUMERIC, "nb_NO.UTF-8"); payload.push_back("foo 3,14"); ASSERT_EXCEPTION(ConfigParser::parse<double>("foo", payload), InvalidConfigException, "Value 3,14 is not a legal double"); @@ -127,7 +128,7 @@ TEST("require that maps can be parsed") } TEST("handles quotes for bool values") { - std::vector<vespalib::string> payload; + StringVector payload; payload.push_back("foo \"true\""); payload.push_back("bar \"123\""); payload.push_back("baz \"1234\""); diff --git a/config/src/tests/configretriever/configretriever.cpp b/config/src/tests/configretriever/configretriever.cpp index 1c39b20a1ff..fdd106e44f2 100644 --- a/config/src/tests/configretriever/configretriever.cpp +++ b/config/src/tests/configretriever/configretriever.cpp @@ -14,6 +14,8 @@ #include <vespa/config/subscription/configsubscription.h> #include <vespa/config/subscription/sourcespec.h> #include <vespa/config/common/exceptions.h> +#include <vespa/config/frt/protocol.h> +#include <vespa/config/retriever/configsnapshot.hpp> #include <thread> #include <atomic> @@ -34,7 +36,7 @@ struct ConfigTestFixture { BootstrapConfigBuilder bootstrapBuilder; map<std::string, ComponentFixture::SP> componentConfig; ConfigSet set; - IConfigContext::SP context; + std::shared_ptr<IConfigContext> context; int idcounter; ConfigTestFixture(const std::string & id) @@ -115,11 +117,11 @@ struct MySource : public Source struct SubscriptionFixture { - IConfigHolder::SP holder; - ConfigSubscription::SP sub; + std::shared_ptr<IConfigHolder> holder; + std::shared_ptr<ConfigSubscription> sub; SubscriptionFixture(const ConfigKey & key, const ConfigValue value) - : holder(new ConfigHolder()), - sub(new ConfigSubscription(0, key, holder, Source::UP(new MySource()))) + : holder(std::make_shared<ConfigHolder>()), + sub(std::make_shared<ConfigSubscription>(0, key, holder, std::make_unique<MySource>())) { holder->handle(std::make_unique<ConfigUpdate>(value, 3, 3)); ASSERT_TRUE(sub->nextUpdate(0, 0ms)); @@ -215,7 +217,7 @@ TEST("require that SimpleConfigRetriever usage works") { barBuilder.barValue = "fooz"; set.addBuilder("id", &fooBuilder); set.addBuilder("id", &barBuilder); - IConfigContext::SP ctx(new ConfigContext(set)); + auto ctx = std::make_shared<ConfigContext>(set); ConfigKeySet sub; sub.add<FooConfig>("id"); sub.add<BarConfig>("id"); @@ -281,7 +283,7 @@ TEST_F("require that SimpleConfigurer usage works", ConfigurableFixture()) { barBuilder.barValue = "fooz"; set.addBuilder("id", &fooBuilder); set.addBuilder("id", &barBuilder); - IConfigContext::SP ctx(new ConfigContext(set)); + auto ctx = std::make_shared<ConfigContext>(set); ConfigKeySet sub; sub.add<FooConfig>("id"); sub.add<BarConfig>("id"); @@ -351,8 +353,8 @@ TEST_FF("require that snapshots throws exception if invalid key", ConfigTestFixt f1.addComponent("c3", "foo3", "bar3"); ConfigSnapshot snap1 = f2.retriever->getBootstrapConfigs(); ASSERT_FALSE(snap1.hasConfig<BarConfig>("doesnotexist")); - ASSERT_EXCEPTION(snap1.getConfig<BarConfig>("doesnotexist"), IllegalConfigKeyException, "Unable to find config for key name=bar,namespace=config,configId=doesnotexist"); - ASSERT_EXCEPTION(snap1.isChanged<BarConfig>("doesnotexist", 0), IllegalConfigKeyException, "Unable to find config for key name=bar,namespace=config,configId=doesnotexist"); + ASSERT_EXCEPTION(snap1.getConfig<BarConfig>("doesnotexist"), IllegalConfigKeyException, "Unable to find config for key name=config.bar,configId=doesnotexist"); + ASSERT_EXCEPTION(snap1.isChanged<BarConfig>("doesnotexist", 0), IllegalConfigKeyException, "Unable to find config for key name=config.bar,configId=doesnotexist"); ASSERT_TRUE(snap1.hasConfig<BootstrapConfig>("myid")); } diff --git a/config/src/tests/configuri/configuri_test.cpp b/config/src/tests/configuri/configuri_test.cpp index 1089886cb1d..e4b3ea06195 100644 --- a/config/src/tests/configuri/configuri_test.cpp +++ b/config/src/tests/configuri/configuri_test.cpp @@ -1,7 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/configcontext.h> +#include <vespa/config/subscription/configsubscriber.hpp> +#include <vespa/config/subscription/configuri.h> #include "config-my.h" using namespace config; @@ -47,7 +48,7 @@ TEST("Require that URI can be created from instance") { } -TEST_F("Require that URI can be \"forked\"", IConfigContext::SP(new ConfigContext())) { +TEST_F("Require that URI can be \"forked\"", std::shared_ptr<IConfigContext>(std::make_shared<ConfigContext>())) { assertConfigId("baz", ConfigUri("foo/bar").createWithNewId("baz")); ConfigUri parent("foo", f1); ConfigUri child = parent.createWithNewId("baz"); diff --git a/config/src/tests/failover/failover.cpp b/config/src/tests/failover/failover.cpp index 4bac1fb9062..e342a477b13 100644 --- a/config/src/tests/failover/failover.cpp +++ b/config/src/tests/failover/failover.cpp @@ -1,10 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/common/misc.h> #include <vespa/config/frt/protocol.h> -#include <vespa/config/config.h> #include <vespa/config/common/configcontext.h> +#include <vespa/config/subscription/configsubscriber.hpp> #include <vespa/fnet/frt/supervisor.h> #include <vespa/fnet/frt/rpcrequest.h> @@ -189,7 +188,7 @@ TimingValues testTimingValues( 1200); // fatalDelay struct ConfigCheckFixture { - IConfigContext::SP ctx; + std::shared_ptr<IConfigContext> ctx; NetworkFixture & nf; ConfigCheckFixture(NetworkFixture & f2) @@ -221,7 +220,7 @@ struct ConfigCheckFixture { }; struct ConfigReloadFixture { - IConfigContext::SP ctx; + std::shared_ptr<IConfigContext> ctx; NetworkFixture & nf; ConfigSubscriber s; ConfigHandle<MyConfig>::UP handle; diff --git a/config/src/tests/file_subscription/file_subscription.cpp b/config/src/tests/file_subscription/file_subscription.cpp index 1201f72f90e..2d1a8498ba5 100644 --- a/config/src/tests/file_subscription/file_subscription.cpp +++ b/config/src/tests/file_subscription/file_subscription.cpp @@ -1,8 +1,7 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> +#include <vespa/config/subscription/configsubscriber.hpp> #include <vespa/config/common/configholder.h> -#include <vespa/config/file/filesource.h> #include <vespa/config/common/exceptions.h> #include <vespa/config/common/sourcefactory.h> #include <vespa/config/common/configcontext.h> @@ -63,12 +62,12 @@ TEST("requireThatFileSpecGivesCorrectSource") { SourceFactory::UP factory(spec.createSourceFactory(TimingValues())); ASSERT_TRUE(factory); auto holder = std::make_shared<ConfigHolder>(); - Source::UP src = factory->createSource(holder, ConfigKey("my", "my", "bar", "foo")); + std::unique_ptr<Source> src = factory->createSource(holder, ConfigKey("my", "my", "bar", "foo")); ASSERT_TRUE(src); src->getConfig(); ASSERT_TRUE(holder->poll()); - ConfigUpdate::UP update(holder->provide()); + std::unique_ptr<ConfigUpdate> update(holder->provide()); ASSERT_TRUE(update); const ConfigValue & value(update->getValue()); ASSERT_EQUAL(1u, value.numLines()); diff --git a/config/src/tests/frt/frt.cpp b/config/src/tests/frt/frt.cpp index 54adbf4d787..0a0c3262b84 100644 --- a/config/src/tests/frt/frt.cpp +++ b/config/src/tests/frt/frt.cpp @@ -16,6 +16,8 @@ #include <vespa/fnet/frt/error.h> #include <vespa/fnet/frt/supervisor.h> #include <vespa/config/frt/protocol.h> +#include <vespa/config/common/configvalue.hpp> + #include <lz4.h> #include <thread> @@ -29,15 +31,15 @@ using namespace config::protocol::v3; namespace { struct UpdateFixture : public IConfigHolder { - ConfigUpdate::UP update; + std::unique_ptr<ConfigUpdate> update; bool notified; UpdateFixture() : update(), notified(false) { } - ConfigUpdate::UP provide() override { return ConfigUpdate::UP(); } - void handle(ConfigUpdate::UP u) override { update = std::move(u); } + std::unique_ptr<ConfigUpdate> provide() override { return std::unique_ptr<ConfigUpdate>(); } + void handle(std::unique_ptr<ConfigUpdate> u) override { update = std::move(u); } bool wait(milliseconds timeoutInMillis) override { (void) timeoutInMillis; return notified; } bool poll() override { return notified; } void interrupt() override { } @@ -75,7 +77,7 @@ namespace { const vespalib::string & configXxhash64="", int changed=0, long generation=0, - const std::vector<vespalib::string> & payload = std::vector<vespalib::string>(), + const StringVector & payload = StringVector(), const vespalib::string & ns = "") { FRT_RPCRequest * req = new FRT_RPCRequest(); diff --git a/config/src/tests/functiontest/functiontest.cpp b/config/src/tests/functiontest/functiontest.cpp index 80433b0382c..333645176a0 100644 --- a/config/src/tests/functiontest/functiontest.cpp +++ b/config/src/tests/functiontest/functiontest.cpp @@ -1,13 +1,14 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <vespa/config/config.h> -#include <vespa/config/common/exceptions.h> #include "config-function-test.h" - -#include <fstream> -#include <vespa/log/log.h> +#include <vespa/config/common/exceptions.h> +#include <vespa/config/configgen/configpayload.h> +#include <vespa/config/subscription/configsubscriber.hpp> #include <vespa/vespalib/data/slime/slime.h> #include <vespa/vespalib/testkit/test_kit.h> +#include <fstream> + +#include <vespa/log/log.h> LOG_SETUP("functiontest_test"); diff --git a/config/src/tests/getconfig/getconfig.cpp b/config/src/tests/getconfig/getconfig.cpp index 4081ce2f1d6..a9598df9be9 100644 --- a/config/src/tests/getconfig/getconfig.cpp +++ b/config/src/tests/getconfig/getconfig.cpp @@ -12,7 +12,7 @@ namespace { struct ConfigFixture { MyConfigBuilder builder; ConfigSet set; - ConfigContext::SP context; + std::shared_ptr<IConfigContext> context; ConfigFixture() : builder(), set(), context() { set.addBuilder("cfgid", &builder); context = std::make_shared<ConfigContext>(set); diff --git a/config/src/tests/legacysubscriber/legacysubscriber.cpp b/config/src/tests/legacysubscriber/legacysubscriber.cpp index 51a32731b0e..7b5f2e2fc0e 100644 --- a/config/src/tests/legacysubscriber/legacysubscriber.cpp +++ b/config/src/tests/legacysubscriber/legacysubscriber.cpp @@ -1,6 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/helper/legacysubscriber.h> +#include <vespa/config/helper/legacysubscriber.hpp> #include <fstream> #include <config-my.h> #include <config-foo.h> diff --git a/config/src/tests/misc/configsystem.cpp b/config/src/tests/misc/configsystem.cpp index c02e27ca989..db3d0a80706 100644 --- a/config/src/tests/misc/configsystem.cpp +++ b/config/src/tests/misc/configsystem.cpp @@ -44,7 +44,7 @@ TEST("require that correct pid file succeeds") { FastOS_File::MakeDirIfNotPresentOrExit("var/run"); FastOS_File pid_file("var/run/configproxy.pid"); pid_file.OpenWriteOnlyTruncate(); - pid_file.Close(); + ASSERT_TRUE(pid_file.Close()); ASSERT_EQUAL(0, setenv(VESPA_HOME, cwd, 1)); vespa::Defaults::bootstrap(cwd); diff --git a/config/src/tests/misc/misc.cpp b/config/src/tests/misc/misc.cpp index 25b6cf36326..25c6762326d 100644 --- a/config/src/tests/misc/misc.cpp +++ b/config/src/tests/misc/misc.cpp @@ -3,6 +3,7 @@ #include <vespa/config/common/configupdate.h> #include <vespa/config/common/misc.h> #include <vespa/config/common/configvalue.h> +#include <vespa/config/common/configkey.h> #include <vespa/config/common/errorcode.h> #include <vespa/config/common/vespa_version.h> #include <vespa/config/subscription/sourcespec.h> @@ -12,7 +13,7 @@ using namespace config; TEST("requireThatConfigUpdateWorks") { - std::vector<vespalib::string> lines; + StringVector lines; lines.push_back("foo"); ConfigUpdate up(ConfigValue(lines, "myxxhash"), true, 1337); @@ -25,13 +26,13 @@ TEST("requireThatConfigUpdateWorks") { } TEST("requireThatConfigValueWorks") { - std::vector<vespalib::string> lines; + StringVector lines; lines.push_back("myFooField \"bar\""); - ConfigValue v1(lines, calculateContentXxhash64(lines)); - ConfigValue v2(lines, calculateContentXxhash64(lines)); - ConfigValue v3(lines, calculateContentXxhash64(lines)); + ConfigValue v1(lines); + ConfigValue v2(lines); + ConfigValue v3(lines); lines.push_back("myFooField \"bar2\""); - ConfigValue v4(lines, calculateContentXxhash64(lines)); + ConfigValue v4(lines); ASSERT_TRUE(v1 == v2); ASSERT_TRUE(v1 == v3); } @@ -108,11 +109,11 @@ TEST("requireThatConfigKeyWorks") { TEST("require that config key initializes schema") { - std::vector<vespalib::string> schema; + StringVector schema; schema.push_back("foo"); schema.push_back("bar"); ConfigKey key("id1", "def1", "namespace1", "xxhash1", schema); - const std::vector<vespalib::string> &vref(key.getDefSchema()); + const StringVector &vref(key.getDefSchema()); for (size_t i = 0; i < schema.size(); i++) { ASSERT_EQUAL(schema[i], vref[i]); } diff --git a/config/src/tests/payload_converter/payload_converter.cpp b/config/src/tests/payload_converter/payload_converter.cpp index 2ecb2062944..d5212048b2e 100644 --- a/config/src/tests/payload_converter/payload_converter.cpp +++ b/config/src/tests/payload_converter/payload_converter.cpp @@ -19,7 +19,7 @@ TEST("require that v2 payload leaf values can be converted to cfg format") { root.setDouble("baz", 3.1); root.setBool("quux", true); PayloadConverter converter(root); - std::vector<vespalib::string> lines(converter.convert()); + StringVector lines(converter.convert()); std::sort(lines.begin(), lines.end()); ASSERT_EQUAL(4u, lines.size()); @@ -36,7 +36,7 @@ TEST("require that v2 payload struct values can be converted to cfg format") { inner.setString("foo", "bar"); inner.setLong("bar", 8); PayloadConverter converter(root); - std::vector<vespalib::string> lines(converter.convert()); + StringVector lines(converter.convert()); std::sort(lines.begin(), lines.end()); ASSERT_EQUAL(2u, lines.size()); @@ -51,7 +51,7 @@ TEST("require that v2 payload array values can be converted to cfg format") { inner.addString("foo"); inner.addLong(8); PayloadConverter converter(root); - std::vector<vespalib::string> lines(converter.convert()); + StringVector lines(converter.convert()); ASSERT_EQUAL(2u, lines.size()); EXPECT_EQUAL("arr[0] \"foo\"", lines[0]); EXPECT_EQUAL("arr[1] 8", lines[1]); @@ -72,7 +72,7 @@ TEST("require that v2 payload nested structures can be converted to cfg format") Cursor & innerArr2(innerobj.setArray("arr2")); innerArr2.addString("muhaha"); PayloadConverter converter(root); - std::vector<vespalib::string> lines(converter.convert()); + StringVector lines(converter.convert()); std::sort(lines.begin(), lines.end()); ASSERT_EQUAL(3u, lines.size()); EXPECT_EQUAL("arr[0].foo \"bar\"", lines[0]); diff --git a/config/src/tests/print/print.cpp b/config/src/tests/print/print.cpp index 325b8dc28fa..fa20482cf0a 100644 --- a/config/src/tests/print/print.cpp +++ b/config/src/tests/print/print.cpp @@ -1,11 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/print.h> -#include <vespa/config/print/fileconfigreader.h> -#include <vespa/config/print/istreamconfigreader.h> +#include <vespa/config/print/fileconfigreader.hpp> +#include <vespa/config/print/istreamconfigreader.hpp> #include <vespa/config/helper/configgetter.hpp> +#include <vespa/vespalib/util/exceptions.h> #include "config-my.h" #include "config-motd.h" #include <sys/stat.h> diff --git a/config/src/tests/raw_subscription/raw_subscription.cpp b/config/src/tests/raw_subscription/raw_subscription.cpp index 7141a21d35d..da35d10da52 100644 --- a/config/src/tests/raw_subscription/raw_subscription.cpp +++ b/config/src/tests/raw_subscription/raw_subscription.cpp @@ -1,9 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/configholder.h> #include <vespa/config/common/sourcefactory.h> -#include <vespa/config/raw/rawsource.h> +#include <vespa/config/subscription/configsubscriber.hpp> #include "config-my.h" using namespace config; @@ -13,13 +12,13 @@ TEST("require that raw spec can create source factory") RawSpec spec("myField \"foo\"\n"); auto raw = spec.createSourceFactory(TimingValues()); ASSERT_TRUE(raw); - IConfigHolder::SP holder(new ConfigHolder()); - Source::UP src = raw->createSource(holder, ConfigKey("myid", "my", "bar", "foo")); + std::shared_ptr<IConfigHolder> holder(new ConfigHolder()); + std::unique_ptr<Source> src = raw->createSource(holder, ConfigKey("myid", "my", "bar", "foo")); ASSERT_TRUE(src); src->getConfig(); ASSERT_TRUE(holder->poll()); - ConfigUpdate::UP update(holder->provide()); + std::unique_ptr<ConfigUpdate> update(holder->provide()); ASSERT_TRUE(update); const ConfigValue & value(update->getValue()); ASSERT_EQUAL(1u, value.numLines()); diff --git a/config/src/tests/subscriber/subscriber.cpp b/config/src/tests/subscriber/subscriber.cpp index 5871add2618..68e211ec3f8 100644 --- a/config/src/tests/subscriber/subscriber.cpp +++ b/config/src/tests/subscriber/subscriber.cpp @@ -3,11 +3,12 @@ #include "config-bar.h" #include "config-baz.h" #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/misc.h> #include <vespa/config/common/configholder.h> -#include <vespa/config/subscription/configsubscription.h> #include <vespa/config/common/exceptions.h> +#include <vespa/config/common/iconfigmanager.h> +#include <vespa/config/common/iconfigcontext.h> +#include <vespa/config/subscription/configsubscriber.hpp> #include <thread> using namespace config; @@ -18,9 +19,9 @@ namespace { ConfigValue createValue(const std::string & value) { - std::vector< vespalib::string > lines; + StringVector lines; lines.push_back(value); - return ConfigValue(lines, calculateContentXxhash64(lines)); + return ConfigValue(std::move(lines)); } ConfigValue createFooValue(const std::string & value) @@ -40,13 +41,13 @@ namespace { void verifyConfig(const std::string & expected, std::unique_ptr<FooConfig> cfg) { - ASSERT_TRUE(cfg.get() != NULL); + ASSERT_TRUE(cfg); ASSERT_EQUAL(expected, cfg->fooValue); } void verifyConfig(const std::string & expected, std::unique_ptr<BarConfig> cfg) { - ASSERT_TRUE(cfg.get() != NULL); + ASSERT_TRUE(cfg); ASSERT_EQUAL(expected, cfg->barValue); } @@ -72,7 +73,7 @@ namespace { SubscriptionId idCounter; - std::vector<IConfigHolder::SP> _holders; + std::vector<std::shared_ptr<IConfigHolder>> _holders; int numCancel; @@ -80,7 +81,7 @@ namespace { ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis) override { (void) timeoutInMillis; - IConfigHolder::SP holder(new ConfigHolder()); + auto holder = std::make_shared<ConfigHolder>(); _holders.push_back(holder); return std::make_shared<ConfigSubscription>(0, key, holder, std::make_unique<MySource>()); @@ -116,16 +117,18 @@ namespace { { public: MyManager & _m; - APIFixture(MyManager & m) + APIFixture(MyManager & m) noexcept : _m(m) { } - APIFixture(const APIFixture & rhs) + APIFixture(const APIFixture & rhs) noexcept : IConfigContext(rhs), _m(rhs._m) { } + ~APIFixture() override = default; + IConfigManager & getManagerInstance() override { return _m; } @@ -144,7 +147,7 @@ namespace { ConfigHandle<FooConfig>::UP h1; ConfigHandle<BarConfig>::UP h2; - StandardFixture(MyManager & F1, APIFixture & F2) : f1(F1), s(IConfigContext::SP(new APIFixture(F2))) + StandardFixture(MyManager & F1, APIFixture & F2) : f1(F1), s(std::make_shared<APIFixture>(F2)) { h1 = s.subscribe<FooConfig>("myid"); h2 = s.subscribe<BarConfig>("myid"); @@ -206,7 +209,7 @@ TEST_F("requireThatSubscriptionsCannotBeAddedWhenFrozen", SimpleFixture()) { } TEST_FF("requireThatNextConfigReturnsFalseUntilSubscriptionHasSucceeded", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid"); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid"); ASSERT_FALSE(s.nextConfigNow()); @@ -335,7 +338,7 @@ TEST_MT_FFF("requireThatNextConfigIsInterruptedOnClose", 2, MyManager, APIFixtur } TEST_FF("requireThatHandlesAreMarkedAsChanged", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid2"); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2"); EXPECT_FALSE(s.nextConfigNow()); @@ -357,7 +360,7 @@ TEST_FF("requireThatHandlesAreMarkedAsChanged", MyManager, APIFixture(f1)) { } TEST_FF("requireThatNextGenerationMarksChanged", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid2"); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2"); f1.updateValue(0, createFooValue("foo"), 1); @@ -380,7 +383,7 @@ TEST_FF("requireThatNextGenerationMarksChanged", MyManager, APIFixture(f1)) { } TEST_FF("requireThatgetGenerationIsSet", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid2"); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid2"); f1.updateValue(0, createFooValue("foo"), 1); @@ -407,7 +410,7 @@ TEST_FFF("requireThatConfigHandleStillHasConfigOnTimestampUpdate", MyManager, AP } TEST_FF("requireThatTimeStamp0Works", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid"); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid"); ConfigHandle<BazConfig>::UP h3 = s.subscribe<BazConfig>("myid"); @@ -421,7 +424,7 @@ TEST_FF("requireThatTimeStamp0Works", MyManager, APIFixture(f1)) { } TEST_FF("requireThatNextGenerationWorksWithManyConfigs", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<BarConfig>::UP h2 = s.subscribe<BarConfig>("myid"); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid"); ConfigHandle<BazConfig>::UP h3 = s.subscribe<BazConfig>("myid"); @@ -483,7 +486,7 @@ TEST_FF("requireThatNextGenerationWorksWithManyConfigs", MyManager, APIFixture(f } TEST_FF("requireThatConfigSubscriberHandlesProxyCache", MyManager, APIFixture(f1)) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid"); f1.updateValue(0, createFooValue("foo"), 1); f1.updateGeneration(0, 2); @@ -501,7 +504,7 @@ TEST_FF("requireThatConfigSubscriberHandlesProxyCache", MyManager, APIFixture(f1 TEST_MT_FF("requireThatConfigSubscriberWaitsUntilNextConfigSucceeds", 2, MyManager, APIFixture(f1)) { if (thread_id == 0) { - ConfigSubscriber s(IConfigContext::SP(new APIFixture(f2))); + ConfigSubscriber s(std::make_shared<APIFixture>(f2)); ConfigHandle<FooConfig>::UP h1 = s.subscribe<FooConfig>("myid"); f1.updateValue(0, createFooValue("foo"), 1); ASSERT_TRUE(s.nextConfigNow()); diff --git a/config/src/tests/subscription/subscription.cpp b/config/src/tests/subscription/subscription.cpp index a65528d67ee..f35ea3c6cef 100644 --- a/config/src/tests/subscription/subscription.cpp +++ b/config/src/tests/subscription/subscription.cpp @@ -38,12 +38,12 @@ namespace { struct SubscriptionFixture { - IConfigHolder::SP holder; + std::shared_ptr<IConfigHolder> holder; ConfigSubscription sub; SourceFixture src; SubscriptionFixture(const ConfigKey & key) : holder(new ConfigHolder()), - sub(0, key, holder, Source::UP(new MySource(&src))) + sub(0, key, holder, std::make_unique<MySource>(&src)) { } }; @@ -100,11 +100,11 @@ TEST_MT_F("requireThatNextUpdateReturnsInterrupted", 2, SubscriptionFixture(Conf TEST_F("Require that isChanged takes generation into account", SubscriptionFixture(ConfigKey::create<MyConfig>("myid"))) { - f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::vector<vespalib::string>(), "a"), true, 1)); + f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(StringVector(), "a"), true, 1)); ASSERT_TRUE(f1.sub.nextUpdate(0, 0ms)); f1.sub.flip(); ASSERT_EQUAL(1, f1.sub.getLastGenerationChanged()); - f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::vector<vespalib::string>(), "b"), true, 2)); + f1.holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(StringVector(), "b"), true, 2)); ASSERT_TRUE(f1.sub.nextUpdate(1, 0ms)); f1.sub.flip(); ASSERT_EQUAL(2, f1.sub.getLastGenerationChanged()); diff --git a/config/src/tests/unittest/unittest.cpp b/config/src/tests/unittest/unittest.cpp index 1ba11db89b9..207a139f31d 100644 --- a/config/src/tests/unittest/unittest.cpp +++ b/config/src/tests/unittest/unittest.cpp @@ -1,11 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include <vespa/vespalib/testkit/test_kit.h> -#include <vespa/config/config.h> #include <vespa/config/common/configcontext.h> #include "config-my.h" #include "config-foo.h" #include "config-bar.h" +#include <vespa/config/subscription/configsubscriber.hpp> #include <vespa/log/log.h> LOG_SETUP("unittest"); diff --git a/config/src/vespa/config/common/cancelhandler.h b/config/src/vespa/config/common/cancelhandler.h index 7641b774fbf..8dde83ba7d9 100644 --- a/config/src/vespa/config/common/cancelhandler.h +++ b/config/src/vespa/config/common/cancelhandler.h @@ -13,9 +13,9 @@ struct CancelHandler * * @param subscription ConfigSubscription to cancel */ - virtual void unsubscribe(const ConfigSubscription::SP & subscription) = 0; + virtual void unsubscribe(const std::shared_ptr<ConfigSubscription> & subscription) = 0; - virtual ~CancelHandler() { } + virtual ~CancelHandler() = default; }; } diff --git a/config/src/vespa/config/common/configdefinition.cpp b/config/src/vespa/config/common/configdefinition.cpp index 21bafcda8f6..a02460f8e64 100644 --- a/config/src/vespa/config/common/configdefinition.cpp +++ b/config/src/vespa/config/common/configdefinition.cpp @@ -12,8 +12,8 @@ ConfigDefinition::ConfigDefinition() : _schema() {} -ConfigDefinition::ConfigDefinition(const std::vector<vespalib::string> & schema) - : _schema(schema) +ConfigDefinition::ConfigDefinition(StringVector schema) + : _schema(std::move(schema)) {} void @@ -36,8 +36,8 @@ vespalib::string ConfigDefinition::asString() const { vespalib::asciistream as; - for (auto it(_schema.begin()), mt(_schema.end()); it != mt; it++) { - as << *it; + for (const auto & line : _schema) { + as << line; } return as.str(); } diff --git a/config/src/vespa/config/common/configdefinition.h b/config/src/vespa/config/common/configdefinition.h index 78ab7877394..5ef87cbe7f7 100644 --- a/config/src/vespa/config/common/configdefinition.h +++ b/config/src/vespa/config/common/configdefinition.h @@ -1,8 +1,7 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <vespa/vespalib/stllike/string.h> -#include <vector> +#include "types.h" namespace vespalib::slime { struct Cursor; @@ -16,12 +15,12 @@ namespace config { class ConfigDefinition { public: ConfigDefinition(); - ConfigDefinition(const std::vector<vespalib::string> & schema); + ConfigDefinition(StringVector schema); void deserialize(const vespalib::slime::Inspector & inspector); void serialize(vespalib::slime::Cursor & cursor) const; vespalib::string asString() const; private: - std::vector<vespalib::string> _schema; + StringVector _schema; }; } //namespace config diff --git a/config/src/vespa/config/common/configholder.cpp b/config/src/vespa/config/common/configholder.cpp index f16d70f11b1..41c88e13b06 100644 --- a/config/src/vespa/config/common/configholder.cpp +++ b/config/src/vespa/config/common/configholder.cpp @@ -13,7 +13,7 @@ ConfigHolder::ConfigHolder() ConfigHolder::~ConfigHolder() = default; -ConfigUpdate::UP +std::unique_ptr<ConfigUpdate> ConfigHolder::provide() { std::lock_guard guard(_lock); @@ -21,7 +21,7 @@ ConfigHolder::provide() } void -ConfigHolder::handle(ConfigUpdate::UP update) +ConfigHolder::handle(std::unique_ptr<ConfigUpdate> update) { std::lock_guard guard(_lock); if (_current) { diff --git a/config/src/vespa/config/common/configholder.h b/config/src/vespa/config/common/configholder.h index 75324bd9d2e..c9b5a37765a 100644 --- a/config/src/vespa/config/common/configholder.h +++ b/config/src/vespa/config/common/configholder.h @@ -16,15 +16,15 @@ public: ConfigHolder(); ~ConfigHolder() override; - ConfigUpdate::UP provide() override; - void handle(ConfigUpdate::UP update) override; + std::unique_ptr<ConfigUpdate> provide() override; + void handle(std::unique_ptr<ConfigUpdate> update) override; bool wait(milliseconds timeoutInMillis) override; bool poll() override; void interrupt() override; public: - std::mutex _lock; - std::condition_variable _cond; - ConfigUpdate::UP _current; + std::mutex _lock; + std::condition_variable _cond; + std::unique_ptr<ConfigUpdate> _current; }; } // namespace config diff --git a/config/src/vespa/config/common/configkey.cpp b/config/src/vespa/config/common/configkey.cpp index 248890b05f9..f81e5fbcb87 100644 --- a/config/src/vespa/config/common/configkey.cpp +++ b/config/src/vespa/config/common/configkey.cpp @@ -20,7 +20,7 @@ ConfigKey::ConfigKey(vespalib::stringref configId, vespalib::stringref defName, vespalib::stringref defNamespace, vespalib::stringref defMd5, - const std::vector<vespalib::string> & defSchema) + const StringVector & defSchema) : _configId(configId), _defName(defName), _defNamespace(defNamespace), @@ -30,19 +30,12 @@ ConfigKey::ConfigKey(vespalib::stringref configId, { } -ConfigKey::ConfigKey() - : _configId(), - _defName(), - _defNamespace(), - _defMd5(), - _defSchema(), - _key() -{} - +ConfigKey::ConfigKey() = default; ConfigKey::ConfigKey(const ConfigKey &) = default; ConfigKey & ConfigKey::operator = (const ConfigKey &) = default; - -ConfigKey::~ConfigKey() { } +ConfigKey::ConfigKey(ConfigKey &&) noexcept = default; +ConfigKey & ConfigKey::operator = (ConfigKey &&) noexcept = default; +ConfigKey::~ConfigKey() = default; bool ConfigKey::operator<(const ConfigKey & rhs) const @@ -66,16 +59,16 @@ const vespalib::string & ConfigKey::getDefName() const { return _defName; } const vespalib::string & ConfigKey::getConfigId() const { return _configId; } const vespalib::string & ConfigKey::getDefNamespace() const { return _defNamespace; } const vespalib::string & ConfigKey::getDefMd5() const { return _defMd5; } -const std::vector<vespalib::string> & ConfigKey::getDefSchema() const { return _defSchema; } +const StringVector & ConfigKey::getDefSchema() const { return _defSchema; } const vespalib::string ConfigKey::toString() const { vespalib::string s; s.append("name="); - s.append(_defName); - s.append(",namespace="); s.append(_defNamespace); + s.append("."); + s.append(_defName); s.append(",configId="); s.append(_configId); return s; diff --git a/config/src/vespa/config/common/configkey.h b/config/src/vespa/config/common/configkey.h index 96b7ada92e4..2b8d2fc70b3 100644 --- a/config/src/vespa/config/common/configkey.h +++ b/config/src/vespa/config/common/configkey.h @@ -1,8 +1,7 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <vespa/vespalib/stllike/string.h> -#include <vector> +#include "types.h" namespace config { @@ -17,12 +16,12 @@ public: vespalib::stringref defName, vespalib::stringref defNamespace, vespalib::stringref defMd5, - const std::vector<vespalib::string> & defSchema); + const StringVector & defSchema); ConfigKey(const ConfigKey &); ConfigKey & operator = (const ConfigKey &); - ConfigKey(ConfigKey &&) = default; - ConfigKey & operator = (ConfigKey &&) = default; + ConfigKey(ConfigKey &&) noexcept; + ConfigKey & operator = (ConfigKey &&) noexcept; ConfigKey(); ~ConfigKey(); @@ -34,7 +33,7 @@ public: const vespalib::string & getConfigId() const; const vespalib::string & getDefNamespace() const; const vespalib::string & getDefMd5() const; - const std::vector<vespalib::string> & getDefSchema() const; + const StringVector & getDefSchema() const; template <typename ConfigType> static const ConfigKey create(vespalib::stringref configId) @@ -51,7 +50,7 @@ private: vespalib::string _defName; vespalib::string _defNamespace; vespalib::string _defMd5; - std::vector<vespalib::string> _defSchema; + StringVector _defSchema; vespalib::string _key; }; diff --git a/config/src/vespa/config/common/configmanager.cpp b/config/src/vespa/config/common/configmanager.cpp index fb082b8479a..d982a77bd1c 100644 --- a/config/src/vespa/config/common/configmanager.cpp +++ b/config/src/vespa/config/common/configmanager.cpp @@ -31,7 +31,7 @@ ConfigManager::subscribe(const ConfigKey & key, milliseconds timeoutInMillis) SubscriptionId id(_idGenerator.fetch_add(1)); auto holder = std::make_shared<ConfigHolder>(); - Source::UP source = _sourceFactory->createSource(holder, key); + std::unique_ptr<Source> source = _sourceFactory->createSource(holder, key); source->reload(_generation); source->getConfig(); diff --git a/config/src/vespa/config/common/configparser.cpp b/config/src/vespa/config/common/configparser.cpp index a8785642ca7..97373071ed5 100644 --- a/config/src/vespa/config/common/configparser.cpp +++ b/config/src/vespa/config/common/configparser.cpp @@ -123,11 +123,10 @@ getValueForKey(vespalib::stringref key, vespalib::stringref line, } -std::vector<vespalib::string> -ConfigParser::getLinesForKey(vespalib::stringref key, - const vsvector & lines) +StringVector +ConfigParser::getLinesForKey(vespalib::stringref key, Cfg lines) { - vsvector retval; + StringVector retval; for (uint32_t i = 0; i < lines.size(); i++) { vespalib::string value; @@ -140,6 +139,18 @@ ConfigParser::getLinesForKey(vespalib::stringref key, return retval; } +std::set<vespalib::string> +ConfigParser::getUniqueNonWhiteSpaceLines(Cfg config) { + std::set<vespalib::string> unique; + for (uint32_t i = 0; i < config.size(); i++) { + vespalib::string line = stripWhitespace(config[i]); + if (!line.empty()) { + unique.insert(line); + } + } + return unique; +} + void ConfigParser::stripLinesForKey(vespalib::stringref key, std::set<vespalib::string>& config) @@ -155,10 +166,10 @@ ConfigParser::stripLinesForKey(vespalib::stringref key, } } -std::map<vespalib::string, ConfigParser::vsvector> -ConfigParser::splitMap(const vsvector & config) +std::map<vespalib::string, StringVector> +ConfigParser::splitMap(Cfg config) { - std::map<vespalib::string, vsvector> items; + std::map<vespalib::string, StringVector> items; vespalib::string lastValue; @@ -178,7 +189,7 @@ ConfigParser::splitMap(const vsvector & config) vespalib::string value = config[i].substr(pos + 1); if (key != lastValue) { - items[key] = vsvector(); + items[key] = StringVector(); lastValue = key; } @@ -191,10 +202,10 @@ ConfigParser::splitMap(const vsvector & config) return items; } -std::vector<ConfigParser::vsvector> -ConfigParser::splitArray(const vsvector & config) +std::vector<StringVector> +ConfigParser::splitArray(Cfg config) { - std::vector<vsvector> items; + std::vector<StringVector> items; vespalib::string lastValue; @@ -214,7 +225,7 @@ ConfigParser::splitArray(const vsvector & config) vespalib::string value = config[i].substr(pos + 1); if (key != lastValue) { - items.push_back(vsvector()); + items.push_back(StringVector()); lastValue = key; } @@ -266,7 +277,7 @@ ConfigParser::stripWhitespace(vespalib::stringref source) } vespalib::string -ConfigParser::arrayToString(const vsvector & array) +ConfigParser::arrayToString(Cfg array) { vespalib::asciistream ost; if (array.size() == 0) { @@ -281,13 +292,13 @@ ConfigParser::arrayToString(const vsvector & array) template<> bool -ConfigParser::convert<bool>(const vsvector & config) +ConfigParser::convert<bool>(const StringVector & config) { if (config.size() != 1) { throw InvalidConfigException("Expected single line with bool value, " "got " + arrayToString(config), VESPA_STRLOC); } - std::string value = stripWhitespace(deQuote(config[0])); + vespalib::string value = stripWhitespace(deQuote(config[0])); if (value == "true") { return true; @@ -301,13 +312,13 @@ ConfigParser::convert<bool>(const vsvector & config) template<> int32_t -ConfigParser::convert<int32_t>(const vsvector & config) +ConfigParser::convert<int32_t>(const StringVector & config) { if (config.size() != 1) { throw InvalidConfigException("Expected single line with int32_t value, " "got " + arrayToString(config), VESPA_STRLOC); } - std::string value(deQuote(stripWhitespace(config[0]))); + vespalib::string value(deQuote(stripWhitespace(config[0]))); const char *startp = value.c_str(); char *endp; @@ -321,13 +332,13 @@ ConfigParser::convert<int32_t>(const vsvector & config) template<> int64_t -ConfigParser::convert<int64_t>(const vsvector & config) +ConfigParser::convert<int64_t>(const StringVector & config) { if (config.size() != 1) { throw InvalidConfigException("Expected single line with int64_t value, " "got " + arrayToString(config), VESPA_STRLOC); } - std::string value(deQuote(stripWhitespace(config[0]))); + vespalib::string value(deQuote(stripWhitespace(config[0]))); const char *startp = value.c_str(); char *endp; @@ -341,13 +352,13 @@ ConfigParser::convert<int64_t>(const vsvector & config) template<> double -ConfigParser::convert<double>(const vsvector & config) +ConfigParser::convert<double>(const StringVector & config) { if (config.size() != 1) { throw InvalidConfigException("Expected single line with double value, " "got " + arrayToString(config), VESPA_STRLOC); } - std::string value(deQuote(stripWhitespace(config[0]))); + vespalib::string value(deQuote(stripWhitespace(config[0]))); const char *startp = value.c_str(); char *endp; @@ -362,14 +373,14 @@ ConfigParser::convert<double>(const vsvector & config) template<> vespalib::string -ConfigParser::convert<vespalib::string>(const vsvector & config) +ConfigParser::convert<vespalib::string>(const StringVector & config) { if (config.size() != 1) { throw InvalidConfigException("Expected single line with string value, " "got " + arrayToString(config), VESPA_STRLOC); } - std::string value = stripWhitespace(config[0]); + vespalib::string value = stripWhitespace(config[0]); return deQuote(value); } diff --git a/config/src/vespa/config/common/configparser.h b/config/src/vespa/config/common/configparser.h index b96bf77fd77..42ee684eb59 100644 --- a/config/src/vespa/config/common/configparser.h +++ b/config/src/vespa/config/common/configparser.h @@ -1,12 +1,10 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once +#include "types.h" #include <vespa/vespalib/util/stringfmt.h> -#include <map> #include <set> -#include <vector> #include <cerrno> -#include <cstdint> namespace config { @@ -16,69 +14,83 @@ namespace config { */ class ConfigParser { public: - typedef std::vector<vespalib::string> vsvector; + class Cfg { + public: + Cfg(const std::vector<vespalib::string> & v) + : _cfg(&v[0]), _sz(v.size()) + { } + Cfg(const std::vector<vespalib::string, vespalib::allocator_large<vespalib::string>> & v) : + _cfg(&v[0]), + _sz(v.size()) + { } + size_t size() const { return _sz; } + const vespalib::string & operator[] (size_t idx) const { return _cfg[idx]; } + private: + const vespalib::string * _cfg; + size_t _sz; + }; private: - static vsvector getLinesForKey(vespalib::stringref key, const vsvector & config); + static StringVector getLinesForKey(vespalib::stringref key, Cfg config); - static std::vector<vsvector> splitArray( const vsvector & config); - static std::map<vespalib::string, vsvector> splitMap( const vsvector & config); + static std::vector<StringVector> splitArray(Cfg config); + static std::map<vespalib::string, StringVector> splitMap(Cfg config); static vespalib::string deQuote(const vespalib::string & source); static void throwNoDefaultValue(vespalib::stringref key); template<typename T> - static T convert(const vsvector &); + static T convert(const StringVector & config); - static vespalib::string arrayToString(const vsvector &); + static vespalib::string arrayToString(Cfg config); - template<typename T, typename V> - static T parseInternal(vespalib::stringref key, const V & config); - template<typename T, typename V> - static T parseInternal(vespalib::stringref key, const V & config, T defaultValue); + template<typename T> + static T parseInternal(vespalib::stringref key, Cfg config); + template<typename T> + static T parseInternal(vespalib::stringref key, Cfg config, T defaultValue); - template<typename T, typename V> - static std::vector<T> parseArrayInternal(vespalib::stringref key, const V & config); - template<typename T, typename V> - static std::map<vespalib::string, T> parseMapInternal(vespalib::stringref key, const V & config); - template<typename T, typename V> - static T parseStructInternal(vespalib::stringref key, const V & config); + template<typename V> + static V parseArrayInternal(vespalib::stringref key, Cfg config); + template<typename T> + static std::map<vespalib::string, T> parseMapInternal(vespalib::stringref key, Cfg config); + template<typename T> + static T parseStructInternal(vespalib::stringref key, Cfg config); public: - static void stripLinesForKey(vespalib::stringref key, - std::set<vespalib::string>& config); + static void stripLinesForKey(vespalib::stringref key, std::set<vespalib::string>& config); + static std::set<vespalib::string> getUniqueNonWhiteSpaceLines(Cfg config); static vespalib::string stripWhitespace(vespalib::stringref source); template<typename T> - static T parse(vespalib::stringref key, const vsvector & config) { - return parseInternal<T, vsvector>(key, config); + static T parse(vespalib::stringref key, Cfg config) { + return parseInternal<T>(key, config); } template<typename T> - static T parse(vespalib::stringref key, const vsvector & config, T defaultValue) { + static T parse(vespalib::stringref key, Cfg config, T defaultValue) { return parseInternal(key, config, defaultValue); } - template<typename T> - static std::vector<T> parseArray(vespalib::stringref key, const vsvector & config) { - return parseArrayInternal<T, vsvector>(key, config); + template<typename V> + static V parseArray(vespalib::stringref key, Cfg config) { + return parseArrayInternal<V>(key, config); } template<typename T> - static std::map<vespalib::string, T> parseMap(vespalib::stringref key, const vsvector & config) { - return parseMapInternal<T, vsvector>(key, config); + static std::map<vespalib::string, T> parseMap(vespalib::stringref key, Cfg config) { + return parseMapInternal<T>(key, config); } template<typename T> - static T parseStruct(vespalib::stringref key, const vsvector & config) { - return parseStructInternal<T, vsvector>(key, config); + static T parseStruct(vespalib::stringref key, Cfg config) { + return parseStructInternal<T>(key, config); } }; -template<typename T, typename V> +template<typename T> T -ConfigParser::parseInternal(vespalib::stringref key, const V & config) +ConfigParser::parseInternal(vespalib::stringref key, Cfg config) { - V lines = getLinesForKey(key, config); + StringVector lines = getLinesForKey(key, config); if (lines.size() == 0) { throwNoDefaultValue(key); @@ -86,11 +98,11 @@ ConfigParser::parseInternal(vespalib::stringref key, const V & config) return convert<T>(lines); } -template<typename T, typename V> +template<typename T> T -ConfigParser::parseInternal(vespalib::stringref key, const V & config, T defaultValue) +ConfigParser::parseInternal(vespalib::stringref key, Cfg config, T defaultValue) { - V lines = getLinesForKey(key, config); + StringVector lines = getLinesForKey(key, config); if (lines.size() == 0) { return defaultValue; @@ -101,67 +113,68 @@ ConfigParser::parseInternal(vespalib::stringref key, const V & config, T default template<typename T> T -ConfigParser::convert(const vsvector & lines) { +ConfigParser::convert(const StringVector & lines) { return T(lines); } -template<typename T, typename V> +template<typename T> std::map<vespalib::string, T> -ConfigParser::parseMapInternal(vespalib::stringref key, const V & config) +ConfigParser::parseMapInternal(vespalib::stringref key, Cfg config) { - V lines = getLinesForKey(key, config); - typedef std::map<vespalib::string, V> SplittedMap; + StringVector lines = getLinesForKey(key, config); + using SplittedMap = std::map<vespalib::string, StringVector>; SplittedMap s = splitMap(lines); std::map<vespalib::string, T> retval; - for (typename SplittedMap::iterator it(s.begin()), mt(s.end()); it != mt; it++) { - retval[it->first] = convert<T>(it->second); + for (const auto & e : s) { + retval[e.first] = convert<T>(e.second); } return retval; } -template<typename T, typename V> -std::vector<T> -ConfigParser::parseArrayInternal(vespalib::stringref key, const V & config) +template<typename V> +V +ConfigParser::parseArrayInternal(vespalib::stringref key, Cfg config) { - V lines = getLinesForKey(key, config); - std::vector<V> split = splitArray(lines); + StringVector lines = getLinesForKey(key, config); + std::vector<StringVector> split = splitArray(lines); - std::vector<T> retval; + V retval; + retval.reserve(split.size()); for (uint32_t i = 0; i < split.size(); i++) { - retval.push_back(convert<T>(split[i])); + retval.push_back(convert<typename V::value_type>(split[i])); } return retval; } -template<typename T, typename V> +template<typename T> T -ConfigParser::parseStructInternal(vespalib::stringref key, const V & config) +ConfigParser::parseStructInternal(vespalib::stringref key, Cfg config) { - V lines = getLinesForKey(key, config); + StringVector lines = getLinesForKey(key, config); return convert<T>(lines); } template<> bool -ConfigParser::convert<bool>(const vsvector & config); +ConfigParser::convert<bool>(const StringVector & config); template<> int32_t -ConfigParser::convert<int32_t>(const vsvector & config); +ConfigParser::convert<int32_t>(const StringVector & config); template<> int64_t -ConfigParser::convert<int64_t>(const vsvector & config); +ConfigParser::convert<int64_t>(const StringVector & config); template<> double -ConfigParser::convert<double>(const vsvector & config); +ConfigParser::convert<double>(const StringVector & config); template<> vespalib::string -ConfigParser::convert<vespalib::string>(const vsvector & config); +ConfigParser::convert<vespalib::string>(const StringVector & config); } // config diff --git a/config/src/vespa/config/common/configstate.h b/config/src/vespa/config/common/configstate.h index a0229f85cd5..0895517343c 100644 --- a/config/src/vespa/config/common/configstate.h +++ b/config/src/vespa/config/common/configstate.h @@ -1,7 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <vespa/vespalib/stllike/string.h> #include "misc.h" namespace config { diff --git a/config/src/vespa/config/common/configupdate.cpp b/config/src/vespa/config/common/configupdate.cpp index e46dd781b2d..55f12775a46 100644 --- a/config/src/vespa/config/common/configupdate.cpp +++ b/config/src/vespa/config/common/configupdate.cpp @@ -3,13 +3,13 @@ namespace config { -ConfigUpdate::ConfigUpdate(const ConfigValue & value, bool changed, int64_t generation) - : _value(value), +ConfigUpdate::ConfigUpdate(ConfigValue value, bool changed, int64_t generation) + : _value(std::move(value)), _hasChanged(changed), _generation(generation) { } - +ConfigUpdate::~ConfigUpdate() = default; const ConfigValue & ConfigUpdate::getValue() const { return _value; } bool ConfigUpdate::hasChanged() const { return _hasChanged; } int64_t ConfigUpdate::getGeneration() const { return _generation; } diff --git a/config/src/vespa/config/common/configupdate.h b/config/src/vespa/config/common/configupdate.h index 571b32a97dc..35d641615a0 100644 --- a/config/src/vespa/config/common/configupdate.h +++ b/config/src/vespa/config/common/configupdate.h @@ -1,7 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <memory> #include "configvalue.h" namespace config { @@ -13,17 +12,18 @@ namespace config { class ConfigUpdate { public: - typedef std::unique_ptr<ConfigUpdate> UP; - ConfigUpdate(const ConfigValue & value, bool changed, int64_t generation); - + ConfigUpdate(ConfigValue value, bool changed, int64_t generation); + ConfigUpdate(const ConfigUpdate &) = delete; + ConfigUpdate & operator = (const ConfigUpdate &) = delete; + ~ConfigUpdate(); const ConfigValue & getValue() const; bool hasChanged() const; int64_t getGeneration() const; void merge(const ConfigUpdate & b) { _hasChanged = _hasChanged || b.hasChanged(); } private: ConfigValue _value; - bool _hasChanged; - int64_t _generation; + bool _hasChanged; + int64_t _generation; }; } // namespace config diff --git a/config/src/vespa/config/common/configvalue.cpp b/config/src/vespa/config/common/configvalue.cpp index da1cbfc792c..586ada889bc 100644 --- a/config/src/vespa/config/common/configvalue.cpp +++ b/config/src/vespa/config/common/configvalue.cpp @@ -2,16 +2,23 @@ #include "configvalue.h" #include "payload_converter.h" #include "misc.h" +#include <vespa/config/frt/protocol.h> #include <vespa/vespalib/data/slime/slime.h> namespace config { -ConfigValue::ConfigValue(const std::vector<vespalib::string> & lines, const vespalib::string & xxhash) +ConfigValue::ConfigValue(StringVector lines, const vespalib::string & xxhash) : _payload(), - _lines(lines), + _lines(std::move(lines)), _xxhash64(xxhash) { } +ConfigValue::ConfigValue(StringVector lines) + : _payload(), + _lines(std::move(lines)), + _xxhash64(calculateContentXxhash64(_lines)) +{ } + ConfigValue::ConfigValue() : _payload(), _lines(), @@ -26,7 +33,6 @@ ConfigValue::ConfigValue(PayloadPtr payload, const vespalib::string & xxhash) ConfigValue::ConfigValue(const ConfigValue &) = default; ConfigValue & ConfigValue::operator = (const ConfigValue &) = default; - ConfigValue::~ConfigValue() = default; int @@ -41,10 +47,10 @@ ConfigValue::operator!=(const ConfigValue & rhs) const return (!(*this == rhs)); } -std::vector<vespalib::string> +StringVector ConfigValue::getLegacyFormat() const { - std::vector<vespalib::string> lines; + StringVector lines; if (_payload) { const vespalib::slime::Inspector & payload(_payload->getSlimePayload()); PayloadConverter converter(payload); @@ -69,7 +75,7 @@ void ConfigValue::serializeV1(vespalib::slime::Cursor & cursor) const { // TODO: Remove v1 when we can bump disk format. - std::vector<vespalib::string> lines(getLegacyFormat()); + StringVector lines(getLegacyFormat()); for (size_t i = 0; i < lines.size(); i++) { cursor.addString(vespalib::Memory(lines[i])); } diff --git a/config/src/vespa/config/common/configvalue.h b/config/src/vespa/config/common/configvalue.h index bf4c320c061..c071b3cfd7c 100644 --- a/config/src/vespa/config/common/configvalue.h +++ b/config/src/vespa/config/common/configvalue.h @@ -1,15 +1,12 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <vespa/config/frt/protocol.h> -#include <vespa/config/configgen/configpayload.h> -#include <vespa/vespalib/stllike/string.h> -#include <vector> +#include <vespa/config/common/types.h> #include <memory> #include <climits> namespace vespalib::slime { struct Cursor; } - +namespace config::protocol { struct Payload; } namespace config { typedef std::shared_ptr<const protocol::Payload> PayloadPtr; @@ -20,10 +17,12 @@ typedef std::shared_ptr<const protocol::Payload> PayloadPtr; */ class ConfigValue { public: - typedef std::unique_ptr<ConfigValue> UP; - ConfigValue(const std::vector<vespalib::string> & lines, const vespalib::string & xxhash); + explicit ConfigValue(StringVector lines); + ConfigValue(StringVector lines, const vespalib::string & xxhash); ConfigValue(PayloadPtr data, const vespalib::string & xxhash); ConfigValue(); + ConfigValue(ConfigValue &&) noexcept = default; + ConfigValue & operator = (ConfigValue &&) noexcept = default; ConfigValue(const ConfigValue &); ConfigValue & operator = (const ConfigValue &); ~ConfigValue(); @@ -33,8 +32,8 @@ public: size_t numLines() const { return _lines.size(); } const vespalib::string & getLine(int i) const { return _lines.at(i); } - const std::vector<vespalib::string> & getLines() const { return _lines; } - std::vector<vespalib::string> getLegacyFormat() const; + const StringVector & getLines() const { return _lines; } + StringVector getLegacyFormat() const; vespalib::string asJson() const; const vespalib::string& getXxhash64() const { return _xxhash64; } @@ -45,12 +44,9 @@ public: std::unique_ptr<ConfigType> newInstance() const; private: - PayloadPtr _payload; - std::vector<vespalib::string> _lines; + PayloadPtr _payload; + StringVector _lines; vespalib::string _xxhash64; }; } //namespace config - -#include "configvalue.hpp" - diff --git a/config/src/vespa/config/common/configvalue.hpp b/config/src/vespa/config/common/configvalue.hpp index 665ce69c7a5..89177454dc3 100644 --- a/config/src/vespa/config/common/configvalue.hpp +++ b/config/src/vespa/config/common/configvalue.hpp @@ -1,5 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#include "configvalue.h" +#include <vespa/config/configgen/configpayload.h> +#include <vespa/config/frt/protocol.h> + namespace config { template <typename ConfigType> @@ -8,9 +12,9 @@ ConfigValue::newInstance() const { if (_payload) { const vespalib::slime::Inspector & payload(_payload->getSlimePayload()); - return std::unique_ptr<ConfigType>(new ConfigType(::config::ConfigPayload(payload))); + return std::make_unique<ConfigType>(::config::ConfigPayload(payload)); } else { - return std::unique_ptr<ConfigType>(new ConfigType(*this)); + return std::make_unique<ConfigType>(*this); } } diff --git a/config/src/vespa/config/common/iconfigcontext.h b/config/src/vespa/config/common/iconfigcontext.h index acc97a7cb8c..71be1dec715 100644 --- a/config/src/vespa/config/common/iconfigcontext.h +++ b/config/src/vespa/config/common/iconfigcontext.h @@ -15,8 +15,6 @@ class IConfigManager; class IConfigContext { public: - typedef std::shared_ptr<IConfigContext> SP; - /** * Get an instance of the config manager. * @@ -29,7 +27,7 @@ public: */ virtual void reload() = 0; - virtual ~IConfigContext() { } + virtual ~IConfigContext() = default; }; } // namespace diff --git a/config/src/vespa/config/common/iconfigholder.h b/config/src/vespa/config/common/iconfigholder.h index ff8e117cb37..9b474ccf70b 100644 --- a/config/src/vespa/config/common/iconfigholder.h +++ b/config/src/vespa/config/common/iconfigholder.h @@ -17,8 +17,7 @@ class IConfigHolder : public ConfigHandler, public Interruptable { public: - typedef std::shared_ptr<IConfigHolder> SP; - virtual ~IConfigHolder() { } + virtual ~IConfigHolder() = default; }; } // namespace config diff --git a/config/src/vespa/config/common/iconfigmanager.h b/config/src/vespa/config/common/iconfigmanager.h index ab0576428f1..3f5304b075f 100644 --- a/config/src/vespa/config/common/iconfigmanager.h +++ b/config/src/vespa/config/common/iconfigmanager.h @@ -12,7 +12,7 @@ class IConfigManager : public SubscribeHandler, public ReloadHandler { public: - virtual ~IConfigManager() { } + virtual ~IConfigManager() = default; }; } // namespace config diff --git a/config/src/vespa/config/common/misc.cpp b/config/src/vespa/config/common/misc.cpp index 34985d19c68..31c66cd4eb8 100644 --- a/config/src/vespa/config/common/misc.cpp +++ b/config/src/vespa/config/common/misc.cpp @@ -14,7 +14,7 @@ using vespalib::Memory; namespace config { vespalib::string -calculateContentXxhash64(const std::vector<vespalib::string> & fileContents) +calculateContentXxhash64(const StringVector & fileContents) { vespalib::string normalizedLines; XXH64_hash_t xxhash64; @@ -39,6 +39,16 @@ calculateContentXxhash64(const std::vector<vespalib::string> & fileContents) return ss.str(); } +StringVector +getlines(vespalib::asciistream & is, char delim) +{ + StringVector lines; + while (!is.eof()) { + lines.push_back(is.getline(delim)); + } + return lines; +} + bool isGenerationNewer(int64_t newGen, int64_t oldGen) { diff --git a/config/src/vespa/config/common/misc.h b/config/src/vespa/config/common/misc.h index 06546a85292..584a7ca527b 100644 --- a/config/src/vespa/config/common/misc.h +++ b/config/src/vespa/config/common/misc.h @@ -1,12 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include "configkey.h" -#include <vespa/vespalib/stllike/string.h> -#include <vector> +#include "types.h" #include <memory> namespace vespalib { + class asciistream; class Slime; namespace slime { struct Inspector; @@ -19,7 +18,7 @@ namespace config { /** * Miscellaneous utility functions specific to config. */ -vespalib::string calculateContentXxhash64(const std::vector<vespalib::string> & fileContents); +vespalib::string calculateContentXxhash64(const StringVector & fileContents); bool isGenerationNewer(int64_t newGen, int64_t oldGen); @@ -34,4 +33,6 @@ typedef std::shared_ptr<const vespalib::Slime> SlimePtr; */ void copySlimeObject(const vespalib::slime::Inspector & src, vespalib::slime::Cursor & dest); +StringVector getlines(vespalib::asciistream & is, char delim='\n'); + } diff --git a/config/src/vespa/config/common/payload_converter.cpp b/config/src/vespa/config/common/payload_converter.cpp index 3cdc745c77a..2ab6f6607ea 100644 --- a/config/src/vespa/config/common/payload_converter.cpp +++ b/config/src/vespa/config/common/payload_converter.cpp @@ -12,9 +12,9 @@ PayloadConverter::PayloadConverter(const Inspector & inspector) _lines() {} -PayloadConverter::~PayloadConverter() { } +PayloadConverter::~PayloadConverter() = default; -const std::vector<vespalib::string> & +const StringVector & PayloadConverter::convert() { _lines.clear(); diff --git a/config/src/vespa/config/common/payload_converter.h b/config/src/vespa/config/common/payload_converter.h index 504fb06cf0a..1bf239b4a97 100644 --- a/config/src/vespa/config/common/payload_converter.h +++ b/config/src/vespa/config/common/payload_converter.h @@ -1,9 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once +#include "types.h" #include <vespa/vespalib/data/slime/object_traverser.h> #include <vespa/vespalib/data/slime/array_traverser.h> -#include <vespa/vespalib/stllike/string.h> #include <vespa/vespalib/stllike/asciistream.h> namespace config { @@ -16,7 +16,7 @@ class PayloadConverter : public vespalib::slime::ObjectTraverser, public vespali public: PayloadConverter(const vespalib::slime::Inspector & inspector); ~PayloadConverter(); - const std::vector<vespalib::string> & convert(); + const StringVector & convert(); void field(const vespalib::Memory & symbol, const vespalib::slime::Inspector & inspector) override; void entry(size_t idx, const vespalib::slime::Inspector & inspector) override; private: @@ -38,11 +38,11 @@ private: Node(int idx) : name(""), arrayIndex(idx) {} Node(const vespalib::string & nm) : name(nm), arrayIndex(-1) {} }; + using NodeStack = std::vector<Node>; const vespalib::slime::Inspector & _inspector; - std::vector<vespalib::string> _lines; - typedef std::vector<Node> NodeStack; - NodeStack _nodeStack; - vespalib::asciistream _buf; + StringVector _lines; + NodeStack _nodeStack; + vespalib::asciistream _buf; }; } // namespace config diff --git a/config/src/vespa/config/common/source.h b/config/src/vespa/config/common/source.h index f3014d0854c..1e1f39fd07e 100644 --- a/config/src/vespa/config/common/source.h +++ b/config/src/vespa/config/common/source.h @@ -11,13 +11,11 @@ namespace config { */ class Source { public: - typedef std::unique_ptr<Source> UP; - virtual void getConfig() = 0; virtual void reload(int64_t generation) = 0; virtual void close() = 0; - virtual ~Source() { } + virtual ~Source() = default; }; } // namespace common diff --git a/config/src/vespa/config/common/sourcefactory.h b/config/src/vespa/config/common/sourcefactory.h index de97977c924..0236bea2802 100644 --- a/config/src/vespa/config/common/sourcefactory.h +++ b/config/src/vespa/config/common/sourcefactory.h @@ -1,21 +1,21 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <memory> #include "source.h" #include "configkey.h" -#include "iconfigholder.h" namespace config { +class IConfigHolder; + /* * Source factory, creating possible config sources. */ class SourceFactory { public: typedef std::unique_ptr<SourceFactory> UP; - virtual Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const = 0; - virtual ~SourceFactory() { } + virtual std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const = 0; + virtual ~SourceFactory() = default; }; } // namespace common diff --git a/config/src/vespa/config/common/subscribehandler.h b/config/src/vespa/config/common/subscribehandler.h index 5ab70677996..da8bdfadcf2 100644 --- a/config/src/vespa/config/common/subscribehandler.h +++ b/config/src/vespa/config/common/subscribehandler.h @@ -2,10 +2,11 @@ #pragma once #include "configkey.h" -#include <vespa/config/subscription/configsubscription.h> namespace config { +class ConfigSubscription; + struct SubscribeHandler { using milliseconds = std::chrono::milliseconds; @@ -18,8 +19,8 @@ struct SubscribeHandler * @param timeoutInMillis the timeout of the subscribe call. * @return subscription object containing data relevant to client */ - virtual ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis) = 0; - virtual ~SubscribeHandler() { } + virtual std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, milliseconds timeoutInMillis) = 0; + virtual ~SubscribeHandler() = default; }; } diff --git a/config/src/vespa/config/common/types.h b/config/src/vespa/config/common/types.h new file mode 100644 index 00000000000..7bec2666db7 --- /dev/null +++ b/config/src/vespa/config/common/types.h @@ -0,0 +1,22 @@ +// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include <vespa/vespalib/stllike/string.h> +#include <vespa/vespalib/stllike/allocator.h> +#include <vector> +#include <map> + +namespace config { + +using StringVector = std::vector<vespalib::string, vespalib::allocator_large<vespalib::string>>; +using BoolVector = std::vector<bool>; +using DoubleVector = std::vector<double>; +using LongVector = std::vector<int64_t>; +using IntVector = std::vector<int32_t>; +using StringMap = std::map<vespalib::string, vespalib::string>; +using BoolMap = std::map<vespalib::string, bool>; +using DoubleMap = std::map<vespalib::string, double>; +using LongMap = std::map<vespalib::string, int64_t>; +using IntMap = std::map<vespalib::string, int32_t>; + +} diff --git a/config/src/vespa/config/config.h b/config/src/vespa/config/config.h deleted file mode 100644 index 6c383f4fef3..00000000000 --- a/config/src/vespa/config/config.h +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#pragma once - -#include <vespa/config/subscription/configsubscriber.h> -#include <vespa/config/subscription/confighandle.h> -#include <vespa/config/subscription/sourcespec.h> -#include <vespa/config/subscription/configuri.h> -#include <vespa/config/helper/configgetter.h> -#include <vespa/config/helper/configfetcher.h> -#include <vespa/config/common/misc.h> -#include <vespa/config/retriever/configretriever.h> - -/*! \mainpage Cloud Config API for C++ - * - * /section Introduction - * - * This document is provided as an API reference to use when developing with the - * C++ config API. - */ - -/** - * @section DESCRIPTION - * - * This file contains all necessary includes as well as functions used to - * subscribe to and retrieve config. - */ - diff --git a/config/src/vespa/config/configgen/configinstance.h b/config/src/vespa/config/configgen/configinstance.h index f25c0536ac6..21acf15859b 100644 --- a/config/src/vespa/config/configgen/configinstance.h +++ b/config/src/vespa/config/configgen/configinstance.h @@ -22,7 +22,7 @@ public: virtual void serialize(ConfigDataBuffer & buffer) const = 0; - virtual ~ConfigInstance() { } + virtual ~ConfigInstance() = default; }; } // namespace config diff --git a/config/src/vespa/config/configgen/map_inserter.h b/config/src/vespa/config/configgen/map_inserter.h index 9f596912c5f..e35ee8cb0ac 100644 --- a/config/src/vespa/config/configgen/map_inserter.h +++ b/config/src/vespa/config/configgen/map_inserter.h @@ -4,12 +4,9 @@ #include "value_converter.h" #include <vespa/vespalib/data/slime/object_traverser.h> #include <vespa/vespalib/stllike/string.h> - #include <map> -namespace config { - -namespace internal { +namespace config::internal { template<typename T, typename Converter = config::internal::ValueConverter<T> > class MapInserter : public ::vespalib::slime::ObjectTraverser { @@ -20,9 +17,4 @@ private: std::map<vespalib::string, T> & _map; }; -} // namespace internal - -} // namespace config - -#include "map_inserter.hpp" - +} diff --git a/config/src/vespa/config/configgen/map_inserter.hpp b/config/src/vespa/config/configgen/map_inserter.hpp index 6ffdb0e893b..9bd04c95b11 100644 --- a/config/src/vespa/config/configgen/map_inserter.hpp +++ b/config/src/vespa/config/configgen/map_inserter.hpp @@ -1,7 +1,10 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -namespace config { -namespace internal { +#pragma once + +#include "map_inserter.h" + +namespace config::internal { template<typename T, typename Converter> MapInserter<T, Converter>::MapInserter(std::map<vespalib::string, T> & map) @@ -16,6 +19,4 @@ MapInserter<T, Converter>::field(const ::vespalib::Memory & symbol, const ::vesp _map[symbol.make_string()] = converter(inspector); } -} // namespace internal - } diff --git a/config/src/vespa/config/configgen/value_converter.cpp b/config/src/vespa/config/configgen/value_converter.cpp index 4b25c6040da..36843456b25 100644 --- a/config/src/vespa/config/configgen/value_converter.cpp +++ b/config/src/vespa/config/configgen/value_converter.cpp @@ -54,7 +54,7 @@ template<> vespalib::string convertValue(const ::vespalib::slime::Inspector & __inspector) { return __inspector.asString().make_string(); } void -requireValid(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector) { +requireValid(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector) { if (!__inspector.valid()) { throw ::config::InvalidConfigException("Value for '" + __fieldName + "' required but not found"); } diff --git a/config/src/vespa/config/configgen/value_converter.h b/config/src/vespa/config/configgen/value_converter.h index 695e798b015..c583f1595dc 100644 --- a/config/src/vespa/config/configgen/value_converter.h +++ b/config/src/vespa/config/configgen/value_converter.h @@ -7,7 +7,7 @@ namespace config::internal { -void requireValid(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector); +void requireValid(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector); template<typename T> T convertValue(const ::vespalib::slime::Inspector & __inspector) { return T(::config::ConfigPayload(__inspector)); } @@ -29,7 +29,7 @@ vespalib::string convertValue(const ::vespalib::slime::Inspector & __inspector); template<typename T> struct ValueConverter { - T operator()(const vespalib::string & __fieldName, const ::vespalib::slime::Inspector & __inspector) { + T operator()(vespalib::stringref __fieldName, const ::vespalib::slime::Inspector & __inspector) { requireValid(__fieldName, __inspector); return convertValue<T>(__inspector); } diff --git a/config/src/vespa/config/configgen/vector_inserter.h b/config/src/vespa/config/configgen/vector_inserter.h index 3c5a406ef67..4b8c7a5e0a1 100644 --- a/config/src/vespa/config/configgen/vector_inserter.h +++ b/config/src/vespa/config/configgen/vector_inserter.h @@ -5,22 +5,15 @@ #include <vespa/vespalib/data/slime/array_traverser.h> #include <vespa/vespalib/stllike/string.h> -namespace config { +namespace config::internal { -namespace internal { - -template<typename T, typename Converter = ::config::internal::ValueConverter<T> > +template<typename V, typename Converter = ::config::internal::ValueConverter<typename V::value_type> > class VectorInserter : public ::vespalib::slime::ArrayTraverser { public: - VectorInserter(std::vector<T> & vector); + VectorInserter(V & vector); void entry(size_t idx, const ::vespalib::slime::Inspector & inspector) override; private: - std::vector<T> & _vector; + V & _vector; }; -} // namespace internal - -} // namespace config - -#include "vector_inserter.hpp" - +} diff --git a/config/src/vespa/config/configgen/vector_inserter.hpp b/config/src/vespa/config/configgen/vector_inserter.hpp index ed43dda07d6..31c3c52a358 100644 --- a/config/src/vespa/config/configgen/vector_inserter.hpp +++ b/config/src/vespa/config/configgen/vector_inserter.hpp @@ -1,22 +1,23 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -namespace config { -namespace internal { +#pragma once -template<typename T, typename Converter> -VectorInserter<T, Converter>::VectorInserter(std::vector<T> & vector) +#include "vector_inserter.h" + +namespace config::internal { + +template<typename V, typename Converter> +VectorInserter<V, Converter>::VectorInserter(V & vector) : _vector(vector) {} -template<typename T, typename Converter> +template<typename V, typename Converter> void -VectorInserter<T, Converter>::entry(size_t idx, const ::vespalib::slime::Inspector & inspector) +VectorInserter<V, Converter>::entry(size_t idx, const ::vespalib::slime::Inspector & inspector) { (void) idx; Converter converter; _vector.push_back(converter(inspector)); } -} // namespace internal - } diff --git a/config/src/vespa/config/file/filesource.cpp b/config/src/vespa/config/file/filesource.cpp index 83a7e10716f..011868f7c06 100644 --- a/config/src/vespa/config/file/filesource.cpp +++ b/config/src/vespa/config/file/filesource.cpp @@ -3,34 +3,34 @@ #include "filesource.h" #include <vespa/config/subscription/sourcespec.h> #include <vespa/config/common/misc.h> -#include <vespa/vespalib/io/fileutil.h> +#include <vespa/config/common/iconfigholder.h> #include <vespa/vespalib/stllike/asciistream.h> -#include <sys/types.h> #include <sys/stat.h> -#include <unistd.h> using vespalib::asciistream; namespace config { -FileSource::FileSource(const IConfigHolder::SP & holder, const vespalib::string & fileName) - : _holder(holder), +FileSource::FileSource(std::shared_ptr<IConfigHolder> holder, const vespalib::string & fileName) + : _holder(std::move(holder)), _fileName(fileName), _lastLoaded(-1), _generation(1) { } +FileSource::~FileSource() = default; + void FileSource::getConfig() { - std::vector<vespalib::string> lines(readConfigFile(_fileName)); + StringVector lines(readConfigFile(_fileName)); int64_t last = getLast(_fileName); if (last > _lastLoaded) { - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(lines, calculateContentXxhash64(lines)), true, _generation))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(lines), true, _generation)); _lastLoaded = last; } else { - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(lines, calculateContentXxhash64(lines)), false, _generation))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(lines), false, _generation)); } } @@ -49,11 +49,11 @@ FileSource::getLast(const vespalib::string & fileName) return filestat.st_mtime; } -std::vector<vespalib::string> +StringVector FileSource::readConfigFile(const vespalib::string & fileName) { asciistream is(asciistream::createFromFile(fileName)); - return is.getlines(); + return getlines(is); } void diff --git a/config/src/vespa/config/file/filesource.h b/config/src/vespa/config/file/filesource.h index 5ed673a445c..f355cd2159b 100644 --- a/config/src/vespa/config/file/filesource.h +++ b/config/src/vespa/config/file/filesource.h @@ -2,29 +2,30 @@ #pragma once #include <vespa/config/common/source.h> -#include <vespa/config/common/iconfigholder.h> -#include <vespa/vespalib/stllike/string.h> -#include <vespa/vespalib/util/noncopyable.hpp> +#include <vespa/config/common/types.h> namespace config { class FileSpec; class DirSpec; +class IConfigHolder; -class FileSource : public Source, - public vespalib::noncopyable +class FileSource : public Source { private: - IConfigHolder::SP _holder; + std::shared_ptr<IConfigHolder> _holder; const vespalib::string _fileName; int64_t _lastLoaded; int64_t _generation; - std::vector<vespalib::string> readConfigFile(const vespalib::string & fileName); + StringVector readConfigFile(const vespalib::string & fileName); int64_t getLast(const vespalib::string & fileName); public: - FileSource(const IConfigHolder::SP & holder, const vespalib::string & fileName); + FileSource(std::shared_ptr<IConfigHolder> holder, const vespalib::string & fileName); + FileSource(const FileSource &) = delete; + FileSource & operator = (const FileSource &) = delete; + ~FileSource() override; void getConfig() override; void close() override; void reload(int64_t generation) override; diff --git a/config/src/vespa/config/file/filesourcefactory.cpp b/config/src/vespa/config/file/filesourcefactory.cpp index 8d8979dd553..09f1d23ed17 100644 --- a/config/src/vespa/config/file/filesourcefactory.cpp +++ b/config/src/vespa/config/file/filesourcefactory.cpp @@ -1,7 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "filesourcefactory.h" #include "filesource.h" -#include <vespa/config/common/exceptions.h> #include <vespa/config/subscription/sourcespec.h> #include <vespa/vespalib/io/fileutil.h> #include <vespa/vespalib/stllike/asciistream.h> @@ -23,8 +22,8 @@ DirSourceFactory::DirSourceFactory(const DirSpec & dirSpec) } } -Source::UP -DirSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +std::unique_ptr<Source> +DirSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { vespalib::string fileId(key.getDefName()); if (!key.getConfigId().empty()) { @@ -45,7 +44,7 @@ DirSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey vespalib::string fName = _dirName; if (!fName.empty()) fName += "/"; fName += fileId; - return Source::UP(new FileSource(holder, fName)); + return std::make_unique<FileSource>(std::move(holder), fName); } FileSourceFactory::FileSourceFactory(const FileSpec & fileSpec) @@ -53,11 +52,11 @@ FileSourceFactory::FileSourceFactory(const FileSpec & fileSpec) { } -Source::UP -FileSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +std::unique_ptr<Source> +FileSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { (void) key; - return Source::UP(new FileSource(holder, _fileName)); + return std::make_unique<FileSource>(std::move(holder), _fileName); } } // namespace config diff --git a/config/src/vespa/config/file/filesourcefactory.h b/config/src/vespa/config/file/filesourcefactory.h index c5ba5769a53..d751d499d95 100644 --- a/config/src/vespa/config/file/filesourcefactory.h +++ b/config/src/vespa/config/file/filesourcefactory.h @@ -2,7 +2,7 @@ #pragma once #include <vespa/config/common/sourcefactory.h> -#include <vespa/vespalib/stllike/string.h> +#include <vespa/config/common/types.h> namespace config { @@ -20,7 +20,7 @@ public: /** * Create source handling config described by key. */ - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: vespalib::string _fileName; }; @@ -36,10 +36,10 @@ public: /** * Create source handling config described by key. */ - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: vespalib::string _dirName; - std::vector<vespalib::string> _fileNames; + StringVector _fileNames; }; diff --git a/config/src/vespa/config/frt/frtconfigagent.cpp b/config/src/vespa/config/frt/frtconfigagent.cpp index 827ef75251b..b6014a1d668 100644 --- a/config/src/vespa/config/frt/frtconfigagent.cpp +++ b/config/src/vespa/config/frt/frtconfigagent.cpp @@ -2,14 +2,15 @@ #include "frtconfigagent.h" #include "frtconfigrequestv3.h" #include <vespa/config/common/trace.h> +#include <vespa/config/common/iconfigholder.h> #include <vespa/log/log.h> LOG_SETUP(".config.frt.frtconfigagent"); namespace config { -FRTConfigAgent::FRTConfigAgent(const IConfigHolder::SP & holder, const TimingValues & timingValues) - : _holder(holder), +FRTConfigAgent::FRTConfigAgent(std::shared_ptr<IConfigHolder> holder, const TimingValues & timingValues) + : _holder(std::move(holder)), _timingValues(timingValues), _configState(), _latest(), diff --git a/config/src/vespa/config/frt/frtconfigagent.h b/config/src/vespa/config/frt/frtconfigagent.h index b4303537d38..c69f4204168 100644 --- a/config/src/vespa/config/frt/frtconfigagent.h +++ b/config/src/vespa/config/frt/frtconfigagent.h @@ -3,12 +3,14 @@ #include <vespa/config/common/configstate.h> #include <vespa/config/common/timingvalues.h> -#include <vespa/config/common/iconfigholder.h> #include <vespa/config/common/configresponse.h> #include <vespa/config/common/configrequest.h> +#include <vespa/config/common/configvalue.h> namespace config { +class IConfigHolder; + class ConfigAgent { public: @@ -19,14 +21,14 @@ public: virtual uint64_t getWaitTime() const = 0; virtual const ConfigState & getConfigState() const = 0; - virtual ~ConfigAgent() { } + virtual ~ConfigAgent() = default; }; class FRTConfigAgent : public ConfigAgent { public: - FRTConfigAgent(const IConfigHolder::SP & holder, const TimingValues & timingValues); - ~FRTConfigAgent(); + FRTConfigAgent(std::shared_ptr<IConfigHolder> holder, const TimingValues & timingValues); + ~FRTConfigAgent() override; void handleResponse(const ConfigRequest & request, ConfigResponse::UP response) override; uint64_t getTimeout() const override; uint64_t getWaitTime() const override; @@ -37,14 +39,14 @@ private: void handleErrorResponse(const ConfigRequest & request, ConfigResponse::UP response); void setWaitTime(uint64_t delay, int multiplier); - IConfigHolder::SP _holder; + std::shared_ptr<IConfigHolder> _holder; const TimingValues _timingValues; - ConfigState _configState; - ConfigValue _latest; - uint64_t _waitTime; - uint64_t _numConfigured; - unsigned int _failedRequests; - uint64_t _nextTimeout; + ConfigState _configState; + ConfigValue _latest; + uint64_t _waitTime; + uint64_t _numConfigured; + unsigned int _failedRequests; + uint64_t _nextTimeout; }; } diff --git a/config/src/vespa/config/frt/frtsourcefactory.cpp b/config/src/vespa/config/frt/frtsourcefactory.cpp index c8331cfa815..259098edb90 100644 --- a/config/src/vespa/config/frt/frtsourcefactory.cpp +++ b/config/src/vespa/config/frt/frtsourcefactory.cpp @@ -11,10 +11,11 @@ FRTSourceFactory::FRTSourceFactory(ConnectionFactory::UP connectionFactory, cons { } -Source::UP -FRTSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +std::unique_ptr<Source> +FRTSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { - return std::make_unique<FRTSource>(_connectionFactory, _requestFactory, std::make_unique<FRTConfigAgent>(holder, _timingValues), key); + return std::make_unique<FRTSource>(_connectionFactory, _requestFactory, + std::make_unique<FRTConfigAgent>(std::move(holder), _timingValues), key); } } // namespace config diff --git a/config/src/vespa/config/frt/frtsourcefactory.h b/config/src/vespa/config/frt/frtsourcefactory.h index 23595c0d70f..4331c6411dc 100644 --- a/config/src/vespa/config/frt/frtsourcefactory.h +++ b/config/src/vespa/config/frt/frtsourcefactory.h @@ -19,7 +19,7 @@ public: /** * Create source handling config described by key. */ - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: ConnectionFactory::SP _connectionFactory; diff --git a/config/src/vespa/config/helper/configfetcher.cpp b/config/src/vespa/config/helper/configfetcher.cpp index d85308bbcbb..b2cf6e1955d 100644 --- a/config/src/vespa/config/helper/configfetcher.cpp +++ b/config/src/vespa/config/helper/configfetcher.cpp @@ -1,9 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "configfetcher.h" +#include "configpoller.h" #include <vespa/config/common/exceptions.h> #include <vespa/config/common/configcontext.h> #include <vespa/vespalib/util/thread.h> + #include <vespa/log/log.h> LOG_SETUP(".config.helper.configfetcher"); @@ -11,19 +13,16 @@ namespace config { VESPA_THREAD_STACK_TAG(config_fetcher_thread); -ConfigFetcher::ConfigFetcher(const IConfigContext::SP & context) - : _poller(context), - _thread(std::make_unique<vespalib::Thread>(_poller, config_fetcher_thread)), +ConfigFetcher::ConfigFetcher(std::shared_ptr<IConfigContext> context) + : _poller(std::make_unique<ConfigPoller>(std::move(context))), + _thread(std::make_unique<vespalib::Thread>(*_poller, config_fetcher_thread)), _closed(false), _started(false) { } ConfigFetcher::ConfigFetcher(const SourceSpec & spec) - : _poller(std::make_shared<ConfigContext>(spec)), - _thread(std::make_unique<vespalib::Thread>(_poller, config_fetcher_thread)), - _closed(false), - _started(false) + : ConfigFetcher(std::make_shared<ConfigContext>(spec)) { } @@ -32,8 +31,8 @@ ConfigFetcher::start() { if (!_closed) { LOG(debug, "Polling for config"); - _poller.poll(); - if (_poller.getGeneration() == -1) { + _poller->poll(); + if (_poller->getGeneration() == -1) { throw ConfigTimeoutException("ConfigFetcher::start timed out getting initial config"); } LOG(debug, "Starting fetcher thread..."); @@ -48,11 +47,16 @@ ConfigFetcher::~ConfigFetcher() close(); } +int64_t +ConfigFetcher::getGeneration() const { + return _poller->getGeneration(); +} + void ConfigFetcher::close() { if (!_closed) { - _poller.close(); + _poller->close(); if (_started) _thread->join(); } diff --git a/config/src/vespa/config/helper/configfetcher.h b/config/src/vespa/config/helper/configfetcher.h index e8cd6a66ebc..8891f0989e5 100644 --- a/config/src/vespa/config/helper/configfetcher.h +++ b/config/src/vespa/config/helper/configfetcher.h @@ -1,14 +1,18 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include "configpoller.h" #include <vespa/config/common/timingvalues.h> +#include <vespa/config/helper/ifetchercallback.h> +#include <vespa/config/subscription/sourcespec.h> #include <atomic> namespace vespalib { class Thread; } namespace config { +class ConfigPoller; +class IConfigContext; + /** * A config fetcher subscribes to a config and notifies a callback when done */ @@ -16,7 +20,7 @@ class ConfigFetcher { public: using milliseconds = std::chrono::milliseconds; - ConfigFetcher(const IConfigContext::SP & context); + ConfigFetcher(std::shared_ptr<IConfigContext> context); ConfigFetcher(const SourceSpec & spec = ServerSpec()); ~ConfigFetcher(); @@ -25,16 +29,12 @@ public: void start(); void close(); - int64_t getGeneration() const { return _poller.getGeneration(); } + int64_t getGeneration() const; private: - ConfigPoller _poller; + std::unique_ptr<ConfigPoller> _poller; std::unique_ptr<vespalib::Thread> _thread; std::atomic<bool> _closed; std::atomic<bool> _started; }; } // namespace config - - -#include "configfetcher.hpp" - diff --git a/config/src/vespa/config/helper/configfetcher.hpp b/config/src/vespa/config/helper/configfetcher.hpp index 9123c54797e..585a798b2ba 100644 --- a/config/src/vespa/config/helper/configfetcher.hpp +++ b/config/src/vespa/config/helper/configfetcher.hpp @@ -1,12 +1,17 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include "configfetcher.h" +#include "configpoller.hpp" + namespace config { template <typename ConfigType> void ConfigFetcher::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout) { - _poller.subscribe<ConfigType>(configId, callback, subscribeTimeout); + _poller->subscribe<ConfigType>(configId, callback, subscribeTimeout); } } // namespace config diff --git a/config/src/vespa/config/helper/configgetter.h b/config/src/vespa/config/helper/configgetter.h index fab8ee98da4..dfb61da3c6f 100644 --- a/config/src/vespa/config/helper/configgetter.h +++ b/config/src/vespa/config/helper/configgetter.h @@ -19,9 +19,9 @@ class ConfigGetter public: using milliseconds = std::chrono::milliseconds; static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, const SourceSpec & spec = ServerSpec()); - static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, const std::shared_ptr<IConfigContext> & context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); + static std::unique_ptr<ConfigType> getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); static std::unique_ptr<ConfigType> getConfig(const std::string & configId, const SourceSpec & spec = ServerSpec()); - static std::unique_ptr<ConfigType> getConfig(const std::string & configId, const std::shared_ptr<IConfigContext> & context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); + static std::unique_ptr<ConfigType> getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); }; } // namespace config diff --git a/config/src/vespa/config/helper/configgetter.hpp b/config/src/vespa/config/helper/configgetter.hpp index 0a757ada83e..b01781ee313 100644 --- a/config/src/vespa/config/helper/configgetter.hpp +++ b/config/src/vespa/config/helper/configgetter.hpp @@ -1,7 +1,7 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "configgetter.h" -#include <vespa/config/subscription/configsubscriber.h> +#include <vespa/config/subscription/configsubscriber.hpp> namespace config { @@ -18,9 +18,9 @@ ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & con template <typename ConfigType> std::unique_ptr<ConfigType> -ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & configId, const IConfigContext::SP & context, milliseconds subscribeTimeout) +ConfigGetter<ConfigType>::getConfig(int64_t &generation, const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout) { - ConfigSubscriber s(context); + ConfigSubscriber s(std::move(context)); std::unique_ptr< ConfigHandle<ConfigType> > h = s.subscribe<ConfigType>(configId, subscribeTimeout); s.nextConfigNow(); generation = s.getGeneration(); @@ -37,10 +37,10 @@ ConfigGetter<ConfigType>::getConfig(const std::string & configId, const SourceSp template <typename ConfigType> std::unique_ptr<ConfigType> -ConfigGetter<ConfigType>::getConfig(const std::string & configId, const IConfigContext::SP & context, milliseconds subscribeTimeout) +ConfigGetter<ConfigType>::getConfig(const std::string & configId, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout) { int64_t ignoreGeneration; - return getConfig(ignoreGeneration, configId, context, subscribeTimeout); + return getConfig(ignoreGeneration, configId, std::move(context), subscribeTimeout); } } // namespace config diff --git a/config/src/vespa/config/helper/configpoller.cpp b/config/src/vespa/config/helper/configpoller.cpp index 879c21bea8c..e9ed0af6b5e 100644 --- a/config/src/vespa/config/helper/configpoller.cpp +++ b/config/src/vespa/config/helper/configpoller.cpp @@ -2,15 +2,16 @@ #include "configpoller.h" #include <vespa/config/common/exceptions.h> +#include <vespa/config/subscription/configsubscriber.h> #include <vespa/log/log.h> LOG_SETUP(".config.helper.configpoller"); namespace config { -ConfigPoller::ConfigPoller(const IConfigContext::SP & context) +ConfigPoller::ConfigPoller(std::shared_ptr<IConfigContext> context) : _generation(-1), - _subscriber(context), + _subscriber(std::make_unique<ConfigSubscriber>(std::move(context))), _handleList(), _callbackList() { @@ -22,7 +23,7 @@ void ConfigPoller::run() { try { - while (!_subscriber.isClosed()) { + while (!_subscriber->isClosed()) { poll(); } } catch (config::InvalidConfigException & e) { @@ -35,11 +36,11 @@ void ConfigPoller::poll() { LOG(debug, "Checking for new config"); - if (_subscriber.nextGeneration()) { - if (_subscriber.isClosed()) + if (_subscriber->nextGeneration()) { + if (_subscriber->isClosed()) return; LOG(debug, "Got new config, reconfiguring"); - _generation = _subscriber.getGeneration(); + _generation = _subscriber->getGeneration(); for (size_t i = 0; i < _handleList.size(); i++) { ICallback * callback(_callbackList[i]); if (_handleList[i]->isChanged()) @@ -53,7 +54,7 @@ ConfigPoller::poll() void ConfigPoller::close() { - _subscriber.close(); + _subscriber->close(); } } diff --git a/config/src/vespa/config/helper/configpoller.h b/config/src/vespa/config/helper/configpoller.h index 40fa1784f59..44d3a51595d 100644 --- a/config/src/vespa/config/helper/configpoller.h +++ b/config/src/vespa/config/helper/configpoller.h @@ -3,12 +3,15 @@ #include "ifetchercallback.h" #include "ihandle.h" -#include <vespa/config/subscription/configsubscriber.h> #include <vespa/config/common/timingvalues.h> #include <vespa/vespalib/util/runnable.h> +#include <vector> namespace config { +class IConfigContext; +class ConfigSubscriber; + /** * A config poller runs a polling sequence on a set of configs that it has * subscribed to. @@ -16,8 +19,8 @@ namespace config { class ConfigPoller : public vespalib::Runnable { public: using milliseconds = std::chrono::milliseconds; - ConfigPoller(const IConfigContext::SP & context); - ~ConfigPoller(); + ConfigPoller(std::shared_ptr<IConfigContext> context); + ~ConfigPoller() override; void run() override; template <typename ConfigType> void subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); @@ -26,11 +29,9 @@ public: int64_t getGeneration() const { return _generation; } private: int64_t _generation; - ConfigSubscriber _subscriber; - std::vector<IHandle::UP> _handleList; - std::vector<ICallback *> _callbackList; + std::unique_ptr<ConfigSubscriber> _subscriber; + std::vector<IHandle::UP> _handleList; + std::vector<ICallback *> _callbackList; }; } // namespace config - -#include "configpoller.hpp" diff --git a/config/src/vespa/config/helper/configpoller.hpp b/config/src/vespa/config/helper/configpoller.hpp index 4088a311609..540ea160e7e 100644 --- a/config/src/vespa/config/helper/configpoller.hpp +++ b/config/src/vespa/config/helper/configpoller.hpp @@ -1,12 +1,34 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include "configpoller.h" +#include <vespa/config/subscription/configsubscriber.hpp> + namespace config { template <typename ConfigType> +class GenericHandle : public IHandle +{ +public: + GenericHandle(std::unique_ptr<ConfigHandle<ConfigType> > handle) + : _handle(std::move(handle)) + { + } + + std::unique_ptr<const ConfigInstance> getConfig() override { + return std::unique_ptr<const ConfigInstance>(_handle->getConfig().release()); + } + bool isChanged() override { return _handle->isChanged(); } +private: + std::unique_ptr<ConfigHandle <ConfigType> > _handle; +}; + +template <typename ConfigType> void ConfigPoller::subscribe(const std::string & configId, IFetcherCallback<ConfigType> * callback, milliseconds subscribeTimeout) { - std::unique_ptr<ConfigHandle<ConfigType> > handle(_subscriber.subscribe<ConfigType>(configId, subscribeTimeout)); + std::unique_ptr<ConfigHandle<ConfigType> > handle(_subscriber->subscribe<ConfigType>(configId, subscribeTimeout)); _handleList.emplace_back(std::make_unique<GenericHandle<ConfigType>>(std::move(handle))); _callbackList.push_back(callback); } diff --git a/config/src/vespa/config/helper/ihandle.h b/config/src/vespa/config/helper/ihandle.h index 4d8de8243d0..271b9f9051d 100644 --- a/config/src/vespa/config/helper/ihandle.h +++ b/config/src/vespa/config/helper/ihandle.h @@ -1,34 +1,19 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once -#include <vespa/config/subscription/confighandle.h> +#include <memory> namespace config { +class ConfigInstance; + class IHandle { public: typedef std::unique_ptr<IHandle> UP; virtual std::unique_ptr<const ConfigInstance> getConfig() = 0; virtual bool isChanged() = 0; - virtual ~IHandle() { } -}; - -template <typename ConfigType> -class GenericHandle : public IHandle -{ -public: - GenericHandle(std::unique_ptr<ConfigHandle<ConfigType> > handle) - : _handle(std::move(handle)) - { - } - - std::unique_ptr<const ConfigInstance> getConfig() override { - return std::unique_ptr<const ConfigInstance>(_handle->getConfig().release()); - } - bool isChanged() override { return _handle->isChanged(); } -private: - std::unique_ptr<ConfigHandle <ConfigType> > _handle; + virtual ~IHandle() = default; }; } diff --git a/config/src/vespa/config/helper/legacysubscriber.h b/config/src/vespa/config/helper/legacysubscriber.h index 5e370a3a6c2..0389c346096 100644 --- a/config/src/vespa/config/helper/legacysubscriber.h +++ b/config/src/vespa/config/helper/legacysubscriber.h @@ -3,7 +3,6 @@ #include "legacy.h" #include "configfetcher.h" -#include <vespa/config/subscription/sourcespec.h> namespace config { @@ -27,6 +26,3 @@ private: }; } // namespace config - -#include "legacysubscriber.hpp" - diff --git a/config/src/vespa/config/helper/legacysubscriber.hpp b/config/src/vespa/config/helper/legacysubscriber.hpp index 9610f8f78db..c11f97e81b7 100644 --- a/config/src/vespa/config/helper/legacysubscriber.hpp +++ b/config/src/vespa/config/helper/legacysubscriber.hpp @@ -1,5 +1,9 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include "legacysubscriber.h" +#include "configfetcher.hpp" #include <vespa/config/common/configcontext.h> namespace config { diff --git a/config/src/vespa/config/print/asciiconfigreader.h b/config/src/vespa/config/print/asciiconfigreader.h index 11a9da2da4e..5be777386b4 100644 --- a/config/src/vespa/config/print/asciiconfigreader.h +++ b/config/src/vespa/config/print/asciiconfigreader.h @@ -2,11 +2,11 @@ #pragma once #include "configreader.h" -#include "configformatter.h" -#include <vespa/vespalib/stllike/asciistream.h> namespace config { +class ConfigFormatter; + /** * Read a config from istream */ @@ -22,6 +22,3 @@ private: }; } // namespace config - -#include "asciiconfigreader.hpp" - diff --git a/config/src/vespa/config/print/asciiconfigreader.hpp b/config/src/vespa/config/print/asciiconfigreader.hpp index 3a76f7536b9..6f9919e6f71 100644 --- a/config/src/vespa/config/print/asciiconfigreader.hpp +++ b/config/src/vespa/config/print/asciiconfigreader.hpp @@ -1,5 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include "asciiconfigreader.h" +#include <vespa/config/common/types.h> +#include <vespa/config/common/configvalue.h> + namespace config { template <typename ConfigType> @@ -15,19 +21,19 @@ AsciiConfigReader<ConfigType>::read(const ConfigFormatter & formatter) ConfigDataBuffer buffer; buffer.setEncodedString(_is.str()); formatter.decode(buffer); - return std::unique_ptr<ConfigType>(new ConfigType(buffer)); + return std::make_unique<ConfigType>(buffer); } template <typename ConfigType> std::unique_ptr<ConfigType> AsciiConfigReader<ConfigType>::read() { - std::vector<vespalib::string> lines; + StringVector lines; vespalib::string line; while (getline(_is, line)) { lines.push_back(line); } - return std::unique_ptr<ConfigType>(new ConfigType(ConfigValue(lines, calculateContentXxhash64(lines)))); + return std::make_unique<ConfigType>(ConfigValue(std::move(lines))); } } // namespace config diff --git a/config/src/vespa/config/print/fileconfigreader.h b/config/src/vespa/config/print/fileconfigreader.h index 1d47d9c04a7..ca794f6c8a6 100644 --- a/config/src/vespa/config/print/fileconfigreader.h +++ b/config/src/vespa/config/print/fileconfigreader.h @@ -24,6 +24,3 @@ private: }; } // namespace config - -#include "fileconfigreader.hpp" - diff --git a/config/src/vespa/config/print/fileconfigreader.hpp b/config/src/vespa/config/print/fileconfigreader.hpp index dec390ef358..b4d0dac86f5 100644 --- a/config/src/vespa/config/print/fileconfigreader.hpp +++ b/config/src/vespa/config/print/fileconfigreader.hpp @@ -29,14 +29,14 @@ FileConfigReader<ConfigType>::read(const ConfigFormatter & formatter) buf << file.rdbuf(); buffer.setEncodedString(buf.str()); formatter.decode(buffer); - return std::unique_ptr<ConfigType>(new ConfigType(buffer)); + return std::make_unique<ConfigType>(buffer); } template <typename ConfigType> std::unique_ptr<ConfigType> FileConfigReader<ConfigType>::read() { - std::vector<vespalib::string> lines; + StringVector lines; std::ifstream f(_fileName.c_str()); if (f.fail()) throw vespalib::IllegalArgumentException(std::string("Unable to open file ") + _fileName); @@ -44,7 +44,7 @@ FileConfigReader<ConfigType>::read() for (std::getline(f, line); f; std::getline(f, line)) { lines.push_back(line); } - return std::unique_ptr<ConfigType>(new ConfigType(ConfigValue(lines, calculateContentXxhash64(lines)))); + return std::make_unique<ConfigType>(ConfigValue(std::move(lines))); } } // namespace config diff --git a/config/src/vespa/config/print/istreamconfigreader.h b/config/src/vespa/config/print/istreamconfigreader.h index 511fbe2f538..d941d1582ac 100644 --- a/config/src/vespa/config/print/istreamconfigreader.h +++ b/config/src/vespa/config/print/istreamconfigreader.h @@ -21,6 +21,3 @@ private: }; } // namespace config - -#include "istreamconfigreader.hpp" - diff --git a/config/src/vespa/config/print/istreamconfigreader.hpp b/config/src/vespa/config/print/istreamconfigreader.hpp index 11b41ddbe2f..1cc0d975919 100644 --- a/config/src/vespa/config/print/istreamconfigreader.hpp +++ b/config/src/vespa/config/print/istreamconfigreader.hpp @@ -1,6 +1,7 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include <istream> +#include "istreamconfigreader.h" +#include <sstream> namespace config { @@ -19,19 +20,19 @@ IstreamConfigReader<ConfigType>::read(const ConfigFormatter & formatter) buf << _is.rdbuf(); buffer.setEncodedString(buf.str()); formatter.decode(buffer); - return std::unique_ptr<ConfigType>(new ConfigType(buffer)); + return std::make_unique<ConfigType>(buffer); } template <typename ConfigType> std::unique_ptr<ConfigType> IstreamConfigReader<ConfigType>::read() { - std::vector<vespalib::string> lines; + StringVector lines; std::string line; while (getline(_is, line)) { lines.push_back(line); } - return std::unique_ptr<ConfigType>(new ConfigType(ConfigValue(lines, calculateContentXxhash64(lines)))); + return std::make_unique<ConfigType>(ConfigValue(std::move(lines))); } } // namespace config diff --git a/config/src/vespa/config/raw/rawsource.cpp b/config/src/vespa/config/raw/rawsource.cpp index af3d7f6f7f5..cf551106405 100644 --- a/config/src/vespa/config/raw/rawsource.cpp +++ b/config/src/vespa/config/raw/rawsource.cpp @@ -1,13 +1,16 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "rawsource.h" #include <vespa/config/common/misc.h> +#include <vespa/config/common/iconfigholder.h> +#include <vespa/config/common/configvalue.h> #include <vespa/vespalib/stllike/asciistream.h> namespace config { +RawSource::~RawSource() = default; -RawSource::RawSource(const IConfigHolder::SP & holder, const vespalib::string & payload) - : _holder(holder), +RawSource::RawSource(std::shared_ptr<IConfigHolder> holder, const vespalib::string & payload) + : _holder(std::move(holder)), _payload(payload) { } @@ -15,9 +18,7 @@ RawSource::RawSource(const IConfigHolder::SP & holder, const vespalib::string & void RawSource::getConfig() { - auto lines(readConfig()); - ConfigValue value(lines, calculateContentXxhash64(lines)); - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(value, true, 1))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(readConfig()), true, 1)); } void @@ -31,11 +32,11 @@ RawSource::close() { } -std::vector<vespalib::string> +StringVector RawSource::readConfig() { vespalib::asciistream is(_payload); - return is.getlines(); + return getlines(is); } } diff --git a/config/src/vespa/config/raw/rawsource.h b/config/src/vespa/config/raw/rawsource.h index 2b15e459de4..a6e1e806cbf 100644 --- a/config/src/vespa/config/raw/rawsource.h +++ b/config/src/vespa/config/raw/rawsource.h @@ -2,24 +2,26 @@ #pragma once #include <vespa/config/common/source.h> -#include <vespa/config/common/iconfigholder.h> -#include <vespa/vespalib/stllike/string.h> - +#include <vespa/config/common/types.h> namespace config { +class IConfigHolder; + /** * Class for sending and receiving config request from a raw string. */ class RawSource : public Source { public: - RawSource(const IConfigHolder::SP & holder, const vespalib::string & payload); - + RawSource(std::shared_ptr<IConfigHolder> holder, const vespalib::string & payload); + RawSource(const RawSource &) = delete; + RawSource & operator = (const RawSource &) = delete; + ~RawSource() override; void getConfig() override; void reload(int64_t generation) override; void close() override; private: - IConfigHolder::SP _holder; - std::vector<vespalib::string> readConfig(); + std::shared_ptr<IConfigHolder> _holder; + StringVector readConfig(); const vespalib::string _payload; }; diff --git a/config/src/vespa/config/raw/rawsourcefactory.cpp b/config/src/vespa/config/raw/rawsourcefactory.cpp index d6f3dfd6be9..396ee8b7c27 100644 --- a/config/src/vespa/config/raw/rawsourcefactory.cpp +++ b/config/src/vespa/config/raw/rawsourcefactory.cpp @@ -6,11 +6,11 @@ namespace config { -Source::UP -RawSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +std::unique_ptr<Source> +RawSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { (void) key; - return Source::UP(new RawSource(holder, _payload)); + return std::make_unique<RawSource>(std::move(holder), _payload); } } diff --git a/config/src/vespa/config/raw/rawsourcefactory.h b/config/src/vespa/config/raw/rawsourcefactory.h index 191547b5d8c..3b8d8986625 100644 --- a/config/src/vespa/config/raw/rawsourcefactory.h +++ b/config/src/vespa/config/raw/rawsourcefactory.h @@ -14,7 +14,7 @@ public: : _payload(payload) { } - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: const vespalib::string _payload; }; diff --git a/config/src/vespa/config/retriever/configretriever.cpp b/config/src/vespa/config/retriever/configretriever.cpp index 20c81742821..125d8ef3012 100644 --- a/config/src/vespa/config/retriever/configretriever.cpp +++ b/config/src/vespa/config/retriever/configretriever.cpp @@ -13,7 +13,7 @@ namespace config { const milliseconds ConfigRetriever::DEFAULT_NEXTGENERATION_TIMEOUT(60000); ConfigRetriever::ConfigRetriever(const ConfigKeySet & bootstrapSet, - const IConfigContext::SP & context, + std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout) : _bootstrapSubscriber(bootstrapSet, context, subscribeTimeout), _configSubscriber(), diff --git a/config/src/vespa/config/retriever/configretriever.h b/config/src/vespa/config/retriever/configretriever.h index ad57f4887fc..8a47ad825cb 100644 --- a/config/src/vespa/config/retriever/configretriever.h +++ b/config/src/vespa/config/retriever/configretriever.h @@ -27,7 +27,7 @@ class ConfigRetriever public: using milliseconds = std::chrono::milliseconds; ConfigRetriever(const ConfigKeySet & bootstrapSet, - const IConfigContext::SP & context, + std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); ~ConfigRetriever(); @@ -93,13 +93,13 @@ public: static const milliseconds DEFAULT_SUBSCRIBE_TIMEOUT; static const milliseconds DEFAULT_NEXTGENERATION_TIMEOUT; private: - FixedConfigSubscriber _bootstrapSubscriber; - std::unique_ptr<GenericConfigSubscriber> _configSubscriber; - std::mutex _lock; - std::vector<ConfigSubscription::SP> _subscriptionList; - ConfigKeySet _lastKeySet; - IConfigContext::SP _context; - std::unique_ptr<SourceSpec> _spec; + FixedConfigSubscriber _bootstrapSubscriber; + std::unique_ptr<GenericConfigSubscriber> _configSubscriber; + std::mutex _lock; + std::vector<std::shared_ptr<ConfigSubscription>> _subscriptionList; + ConfigKeySet _lastKeySet; + std::shared_ptr<IConfigContext> _context; + std::unique_ptr<SourceSpec> _spec; bool _closed; int64_t _generation; milliseconds _subscribeTimeout; diff --git a/config/src/vespa/config/retriever/configsnapshot.cpp b/config/src/vespa/config/retriever/configsnapshot.cpp index e999538e713..293a90ebbba 100644 --- a/config/src/vespa/config/retriever/configsnapshot.cpp +++ b/config/src/vespa/config/retriever/configsnapshot.cpp @@ -5,6 +5,7 @@ #include <vespa/config/print/configdatabuffer.h> #include <vespa/config/common/exceptions.h> #include <vespa/config/common/misc.h> +#include <vespa/config/frt/protocol.h> #include <vespa/vespalib/data/slime/slime.h> #include <vespa/vespalib/stllike/asciistream.h> @@ -41,8 +42,9 @@ ConfigSnapshot::swap(ConfigSnapshot &rhs) { } ConfigSnapshot::ConfigSnapshot(const SubscriptionList &subscriptionList, int64_t generation) - : _valueMap(), - _generation(generation) { + : _valueMap(), + _generation(generation) +{ for (SubscriptionList::const_iterator it(subscriptionList.begin()), mt(subscriptionList.end()); it != mt; it++) { _valueMap[(*it)->getKey()] = Value((*it)->getLastGenerationChanged(), (*it)->getConfig()); } @@ -66,10 +68,10 @@ ConfigSnapshot ConfigSnapshot::subset(const ConfigKeySet & keySet) const { ValueMap subSet; - for (ConfigKeySet::const_iterator it(keySet.begin()), mt(keySet.end()); it != mt; it++) { - ValueMap::const_iterator found(_valueMap.find(*it)); + for (const ConfigKey & key : keySet) { + ValueMap::const_iterator found(_valueMap.find(key)); if (found != _valueMap.end()) { - subSet[*it] = found->second; + subSet[key] = found->second; } } return ConfigSnapshot(subSet, _generation); @@ -127,15 +129,13 @@ ConfigSnapshot::serializeV2(Cursor & root) const void ConfigSnapshot::serializeKeyV1(Cursor & cursor, const ConfigKey & key) const { - typedef std::vector<vespalib::string> SchemaVector; cursor.setString("configId", Memory(key.getConfigId())); cursor.setString("defName", Memory(key.getDefName())); cursor.setString("defNamespace", Memory(key.getDefNamespace())); cursor.setString("defMd5", Memory(key.getDefMd5())); Cursor & defSchema(cursor.setArray("defSchema")); - const SchemaVector & vec(key.getDefSchema()); - for (SchemaVector::const_iterator it(vec.begin()), mt(vec.end()); it != mt; it++) { - defSchema.addString(vespalib::Memory(*it)); + for (const vespalib::string & line : key.getDefSchema()) { + defSchema.addString(vespalib::Memory(line)); } } @@ -203,7 +203,7 @@ ConfigSnapshot::deserializeV2(Inspector & root) ConfigKey ConfigSnapshot::deserializeKeyV1(Inspector & inspector) const { - std::vector<vespalib::string> schema; + StringVector schema; Inspector & s(inspector["defSchema"]); for (size_t i = 0; i < s.children(); i++) { schema.push_back(s[i].asString().make_string()); @@ -219,13 +219,13 @@ ConfigSnapshot::deserializeKeyV1(Inspector & inspector) const std::pair<int64_t, ConfigValue> ConfigSnapshot::deserializeValueV1(Inspector & inspector) const { - std::vector<vespalib::string> payload; + StringVector payload; int64_t lastChanged = static_cast<int64_t>(inspector["lastChanged"].asDouble()); Inspector & s(inspector["lines"]); for (size_t i = 0; i < s.children(); i++) { payload.push_back(s[i].asString().make_string()); } - return Value(lastChanged, ConfigValue(payload, calculateContentXxhash64(payload))); + return Value(lastChanged, ConfigValue(payload)); } namespace { diff --git a/config/src/vespa/config/retriever/configsnapshot.h b/config/src/vespa/config/retriever/configsnapshot.h index b7d49ca2584..8393fd38ed3 100644 --- a/config/src/vespa/config/retriever/configsnapshot.h +++ b/config/src/vespa/config/retriever/configsnapshot.h @@ -3,8 +3,7 @@ #include "configkeyset.h" #include <vespa/config/common/configvalue.h> -#include <vespa/vespalib/stllike/string.h> -#include <map> +#include <vespa/config/common/misc.h> namespace config { @@ -18,7 +17,7 @@ class ConfigDataBuffer; class ConfigSnapshot { public: - typedef std::vector<std::shared_ptr<ConfigSubscription>> SubscriptionList; + using SubscriptionList = std::vector<std::shared_ptr<ConfigSubscription>>; /** * Construct an empty config snapshot. @@ -95,8 +94,8 @@ public: void serialize(ConfigDataBuffer & buffer) const; void deserialize(const ConfigDataBuffer & buffer); private: - typedef std::pair<int64_t, ConfigValue> Value; - typedef std::map<ConfigKey, Value> ValueMap; + using Value = std::pair<int64_t, ConfigValue>; + using ValueMap = std::map<ConfigKey, Value>; const static int64_t SNAPSHOT_FORMAT_VERSION; ConfigSnapshot(const ValueMap & valueMap, int64_t generation); @@ -121,5 +120,3 @@ private: }; } // namespace config - -#include "configsnapshot.hpp" diff --git a/config/src/vespa/config/retriever/configsnapshot.hpp b/config/src/vespa/config/retriever/configsnapshot.hpp index 387fc9712e0..5513eaa9d65 100644 --- a/config/src/vespa/config/retriever/configsnapshot.hpp +++ b/config/src/vespa/config/retriever/configsnapshot.hpp @@ -1,5 +1,10 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include "configsnapshot.h" +#include <vespa/config/common/configvalue.hpp> + namespace config { template <typename ConfigType> diff --git a/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp b/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp index 07049a8ac2b..da199c2e298 100644 --- a/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp +++ b/config/src/vespa/config/retriever/fixedconfigsubscriber.cpp @@ -3,9 +3,9 @@ namespace config { FixedConfigSubscriber::FixedConfigSubscriber(const ConfigKeySet & keySet, - const IConfigContext::SP & context, + std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout) - : _set(context), + : _set(std::move(context)), _subscriptionList() { for (const ConfigKey & key : keySet) { diff --git a/config/src/vespa/config/retriever/fixedconfigsubscriber.h b/config/src/vespa/config/retriever/fixedconfigsubscriber.h index 5ae684db782..1ca4d8cf0b3 100644 --- a/config/src/vespa/config/retriever/fixedconfigsubscriber.h +++ b/config/src/vespa/config/retriever/fixedconfigsubscriber.h @@ -15,14 +15,14 @@ class FixedConfigSubscriber { public: using milliseconds = std::chrono::milliseconds; - FixedConfigSubscriber(const ConfigKeySet & keySet, const IConfigContext::SP & context, milliseconds subscribeTimeout); + FixedConfigSubscriber(const ConfigKeySet & keySet, std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout); bool nextGeneration(milliseconds timeoutInMillis); void close(); int64_t getGeneration() const; ConfigSnapshot getConfigSnapshot() const; private: ConfigSubscriptionSet _set; - std::vector<ConfigSubscription::SP> _subscriptionList; + std::vector<std::shared_ptr<ConfigSubscription>> _subscriptionList; }; } // namespace config diff --git a/config/src/vespa/config/retriever/genericconfigsubscriber.cpp b/config/src/vespa/config/retriever/genericconfigsubscriber.cpp index 96146bb8927..4190c404d04 100644 --- a/config/src/vespa/config/retriever/genericconfigsubscriber.cpp +++ b/config/src/vespa/config/retriever/genericconfigsubscriber.cpp @@ -3,8 +3,8 @@ namespace config { -GenericConfigSubscriber::GenericConfigSubscriber(const IConfigContext::SP & context) - : _set(context) +GenericConfigSubscriber::GenericConfigSubscriber(std::shared_ptr<IConfigContext> context) + : _set(std::move(context)) { } bool @@ -13,7 +13,7 @@ GenericConfigSubscriber::nextGeneration(milliseconds timeoutInMillis) return _set.acquireSnapshot(timeoutInMillis, true); } -ConfigSubscription::SP +std::shared_ptr<ConfigSubscription> GenericConfigSubscriber::subscribe(const ConfigKey & key, milliseconds timeoutInMillis) { return _set.subscribe(key, timeoutInMillis); diff --git a/config/src/vespa/config/retriever/genericconfigsubscriber.h b/config/src/vespa/config/retriever/genericconfigsubscriber.h index 17d37ffb7ff..b2b7be5b9e4 100644 --- a/config/src/vespa/config/retriever/genericconfigsubscriber.h +++ b/config/src/vespa/config/retriever/genericconfigsubscriber.h @@ -14,9 +14,9 @@ class GenericConfigSubscriber { public: using milliseconds = std::chrono::milliseconds; - GenericConfigSubscriber(const IConfigContext::SP & context); + GenericConfigSubscriber(std::shared_ptr<IConfigContext> context); bool nextGeneration(milliseconds timeoutInMillis); - ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis); + std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, milliseconds timeoutInMillis); void close(); int64_t getGeneration() const; private: diff --git a/config/src/vespa/config/retriever/simpleconfigretriever.cpp b/config/src/vespa/config/retriever/simpleconfigretriever.cpp index fc4f21718af..43dad7d9429 100644 --- a/config/src/vespa/config/retriever/simpleconfigretriever.cpp +++ b/config/src/vespa/config/retriever/simpleconfigretriever.cpp @@ -3,7 +3,7 @@ namespace config { SimpleConfigRetriever::SimpleConfigRetriever(const ConfigKeySet & keySet, - const IConfigContext::SP & context, + std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout) : _set(context), _subscriptionList() diff --git a/config/src/vespa/config/retriever/simpleconfigretriever.h b/config/src/vespa/config/retriever/simpleconfigretriever.h index 1e19789db9f..2650532cda2 100644 --- a/config/src/vespa/config/retriever/simpleconfigretriever.h +++ b/config/src/vespa/config/retriever/simpleconfigretriever.h @@ -20,7 +20,7 @@ public: using milliseconds = std::chrono::milliseconds; SimpleConfigRetriever(const ConfigKeySet & keySet, - const IConfigContext::SP & context, + std::shared_ptr<IConfigContext> context, milliseconds subscribeTimeout = DEFAULT_SUBSCRIBE_TIMEOUT); /** @@ -35,7 +35,7 @@ public: private: ConfigSubscriptionSet _set; - std::vector<ConfigSubscription::SP> _subscriptionList; + std::vector<std::shared_ptr<ConfigSubscription>> _subscriptionList; }; } // namespace config diff --git a/config/src/vespa/config/set/configinstancesourcefactory.cpp b/config/src/vespa/config/set/configinstancesourcefactory.cpp index 3ed0fdc932e..15a6125d096 100644 --- a/config/src/vespa/config/set/configinstancesourcefactory.cpp +++ b/config/src/vespa/config/set/configinstancesourcefactory.cpp @@ -1,26 +1,25 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "configinstancesourcefactory.h" +#include <vespa/config/common/iconfigholder.h> namespace { class ConfigInstanceSource : public config::Source { public: - ConfigInstanceSource(const config::IConfigHolder::SP & holder, const vespalib::asciistream & buffer) - : _holder(holder), - _buffer(buffer), + ConfigInstanceSource(std::shared_ptr<config::IConfigHolder> holder, vespalib::asciistream buffer) + : _holder(std::move(holder)), + _buffer(std::move(buffer)), _generation(-1) { } void close() override { } void getConfig() override { - std::vector<vespalib::string> lines(_buffer.getlines()); - std::string currentXxhash64(config::calculateContentXxhash64(lines)); - _holder->handle(config::ConfigUpdate::UP(new config::ConfigUpdate(config::ConfigValue(lines, currentXxhash64), true, _generation))); + _holder->handle(std::make_unique<config::ConfigUpdate>(config::ConfigValue(config::getlines(_buffer)), true, _generation)); } void reload(int64_t generation) override { _generation = generation; } private: - config::IConfigHolder::SP _holder; + std::shared_ptr<config::IConfigHolder> _holder; vespalib::asciistream _buffer; int64_t _generation; }; @@ -29,18 +28,18 @@ private: namespace config { -ConfigInstanceSourceFactory::ConfigInstanceSourceFactory(const ConfigKey & key, const vespalib::asciistream & buffer) +ConfigInstanceSourceFactory::ConfigInstanceSourceFactory(const ConfigKey & key, vespalib::asciistream buffer) : _key(key), - _buffer(buffer) + _buffer(std::move(buffer)) { } -Source::UP -ConfigInstanceSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +std::unique_ptr<Source> +ConfigInstanceSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { (void) key; // TODO: Check key against _key - return Source::UP(new ConfigInstanceSource(holder, _buffer)); + return std::make_unique<ConfigInstanceSource>(std::move(holder), _buffer); } } // namespace config diff --git a/config/src/vespa/config/set/configinstancesourcefactory.h b/config/src/vespa/config/set/configinstancesourcefactory.h index 279da055d91..bff81a457c4 100644 --- a/config/src/vespa/config/set/configinstancesourcefactory.h +++ b/config/src/vespa/config/set/configinstancesourcefactory.h @@ -17,12 +17,12 @@ class ConfigKey; class ConfigInstanceSourceFactory : public SourceFactory { public: - ConfigInstanceSourceFactory(const ConfigKey & key, const vespalib::asciistream & buffer); + ConfigInstanceSourceFactory(const ConfigKey & key, vespalib::asciistream buffer); /** * Create source handling config described by key. */ - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: const ConfigKey _key; vespalib::asciistream _buffer; diff --git a/config/src/vespa/config/set/configsetsource.cpp b/config/src/vespa/config/set/configsetsource.cpp index c60126b17e7..41886a12d01 100644 --- a/config/src/vespa/config/set/configsetsource.cpp +++ b/config/src/vespa/config/set/configsetsource.cpp @@ -2,6 +2,7 @@ #include "configsetsource.h" #include <vespa/config/print/asciiconfigwriter.h> +#include <vespa/config/common/iconfigholder.h> #include <vespa/config/common/exceptions.h> #include <vespa/log/log.h> @@ -9,17 +10,17 @@ LOG_SETUP(".config.set.configsetsource"); namespace config { -ConfigSetSource::ConfigSetSource(const IConfigHolder::SP & holder, const ConfigKey & key, const BuilderMapSP & builderMap) - : _holder(holder), +ConfigSetSource::ConfigSetSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key, BuilderMapSP builderMap) + : _holder(std::move(holder)), _key(key), _generation(1), - _builderMap(builderMap) + _builderMap(std::move(builderMap)) { if (!validRequest(key)) throw ConfigRuntimeException("Invalid subscribe for key " + key.toString() + ", not builder found"); } -ConfigSetSource::~ConfigSetSource() { } +ConfigSetSource::~ConfigSetSource() = default; void ConfigSetSource::getConfig() @@ -29,17 +30,17 @@ ConfigSetSource::getConfig() vespalib::asciistream ss; AsciiConfigWriter writer(ss); writer.write(*instance); - std::vector<vespalib::string> lines(ss.getlines()); - std::string currentXxhash64(calculateContentXxhash64(lines)); + StringVector lines(getlines(ss)); + vespalib::string currentXxhash64(calculateContentXxhash64(lines)); if (isGenerationNewer(_generation, _lastState.generation) && currentXxhash64.compare(_lastState.xxhash64) != 0) { LOG(debug, "New generation, updating"); - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(lines, currentXxhash64), true, _generation))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::move(lines), currentXxhash64), true, _generation)); _lastState.xxhash64 = currentXxhash64; _lastState.generation = _generation; } else { LOG(debug, "Sending timestamp update"); - _holder->handle(ConfigUpdate::UP(new ConfigUpdate(ConfigValue(lines, currentXxhash64), false, _generation))); + _holder->handle(std::make_unique<ConfigUpdate>(ConfigValue(std::move(lines), currentXxhash64), false, _generation)); _lastState.generation = _generation; } } diff --git a/config/src/vespa/config/set/configsetsource.h b/config/src/vespa/config/set/configsetsource.h index aa9e8425f96..95cc0049a7a 100644 --- a/config/src/vespa/config/set/configsetsource.h +++ b/config/src/vespa/config/set/configsetsource.h @@ -3,13 +3,13 @@ #include <vespa/config/common/source.h> #include <vespa/config/common/configkey.h> -#include <vespa/config/common/iconfigholder.h> #include <vespa/config/common/configstate.h> #include <map> namespace config { class ConfigInstance; +class IConfigHolder; /** * Class for sending and receiving config request from a raw string. @@ -18,18 +18,20 @@ class ConfigSetSource : public Source { public: typedef std::map<ConfigKey, ConfigInstance *> BuilderMap; typedef std::shared_ptr<BuilderMap> BuilderMapSP; - ConfigSetSource(const IConfigHolder::SP & holder, const ConfigKey & key, const BuilderMapSP & builderMap); + ConfigSetSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key, BuilderMapSP builderMap); + ConfigSetSource(const ConfigSetSource &) = delete; + ConfigSetSource & operator =(const ConfigSetSource &) = delete; ~ConfigSetSource(); void getConfig() override; void reload(int64_t generation) override; void close() override; private: - IConfigHolder::SP _holder; + std::shared_ptr<IConfigHolder> _holder; const ConfigKey _key; - int64_t _generation; - BuilderMapSP _builderMap; - ConfigState _lastState; + int64_t _generation; + BuilderMapSP _builderMap; + ConfigState _lastState; bool validRequest(const ConfigKey & key); }; diff --git a/config/src/vespa/config/set/configsetsourcefactory.cpp b/config/src/vespa/config/set/configsetsourcefactory.cpp index b2ca99879cb..9d443cdaabc 100644 --- a/config/src/vespa/config/set/configsetsourcefactory.cpp +++ b/config/src/vespa/config/set/configsetsourcefactory.cpp @@ -3,15 +3,17 @@ namespace config { -ConfigSetSourceFactory::ConfigSetSourceFactory(const BuilderMapSP & builderMap) - : _builderMap(builderMap) +ConfigSetSourceFactory::ConfigSetSourceFactory(BuilderMapSP builderMap) + : _builderMap(std::move(builderMap)) { } -Source::UP -ConfigSetSourceFactory::createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const +ConfigSetSourceFactory::~ConfigSetSourceFactory() = default; + +std::unique_ptr<Source> +ConfigSetSourceFactory::createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const { - return Source::UP(new ConfigSetSource(holder, key, _builderMap)); + return std::make_unique<ConfigSetSource>(std::move(holder), key, _builderMap); } } // namespace config diff --git a/config/src/vespa/config/set/configsetsourcefactory.h b/config/src/vespa/config/set/configsetsourcefactory.h index 88e2eedb255..c42e14a7c84 100644 --- a/config/src/vespa/config/set/configsetsourcefactory.h +++ b/config/src/vespa/config/set/configsetsourcefactory.h @@ -16,14 +16,10 @@ class ConfigKey; class ConfigSetSourceFactory : public SourceFactory { public: - typedef ConfigSetSource::BuilderMap BuilderMap; - typedef ConfigSetSource::BuilderMapSP BuilderMapSP; - ConfigSetSourceFactory(const BuilderMapSP & builderMap); - - /** - * Create source handling config described by key. - */ - Source::UP createSource(const IConfigHolder::SP & holder, const ConfigKey & key) const override; + using BuilderMapSP = ConfigSetSource::BuilderMapSP; + explicit ConfigSetSourceFactory(BuilderMapSP builderMap); + ~ConfigSetSourceFactory() override; + std::unique_ptr<Source> createSource(std::shared_ptr<IConfigHolder> holder, const ConfigKey & key) const override; private: BuilderMapSP _builderMap; }; diff --git a/config/src/vespa/config/subscription/confighandle.h b/config/src/vespa/config/subscription/confighandle.h index 69532e5ba48..98a3e844acd 100644 --- a/config/src/vespa/config/subscription/confighandle.h +++ b/config/src/vespa/config/subscription/confighandle.h @@ -2,10 +2,11 @@ #pragma once #include <memory> -#include <vespa/config/subscription/configsubscription.h> namespace config { +class ConfigSubscription; + /** * A ConfigHandle is a subscription handle that is capable of looking up config * objects of a generic type. @@ -16,7 +17,8 @@ class ConfigHandle public: typedef std::unique_ptr<ConfigHandle <ConfigType> > UP; - ConfigHandle(const ConfigSubscription::SP & subscription); + explicit ConfigHandle(std::shared_ptr<ConfigSubscription> subscription); + ~ConfigHandle(); /** * Return the currently available config known to the ConfigHandle. Throws @@ -38,10 +40,8 @@ public: */ bool isChanged() const; private: - ConfigSubscription::SP _subscription; + std::shared_ptr<ConfigSubscription> _subscription; }; } // namespace config -#include "confighandle.hpp" - diff --git a/config/src/vespa/config/subscription/confighandle.hpp b/config/src/vespa/config/subscription/confighandle.hpp index 9ce94808601..9ad27a5cb3f 100644 --- a/config/src/vespa/config/subscription/confighandle.hpp +++ b/config/src/vespa/config/subscription/confighandle.hpp @@ -1,15 +1,20 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#include "confighandle.h" +#include <vespa/config/common/configvalue.hpp> namespace config { template <typename ConfigType> -ConfigHandle<ConfigType>::ConfigHandle(const ConfigSubscription::SP & subscription) - : _subscription(subscription) +ConfigHandle<ConfigType>::ConfigHandle(std::shared_ptr<ConfigSubscription> subscription) + : _subscription(std::move(subscription)) { } template <typename ConfigType> +ConfigHandle<ConfigType>::~ConfigHandle() = default; + +template <typename ConfigType> std::unique_ptr<ConfigType> ConfigHandle<ConfigType>::getConfig() const { diff --git a/config/src/vespa/config/subscription/configinstancespec.h b/config/src/vespa/config/subscription/configinstancespec.h index 2294b37e1d1..32ee78b1d71 100644 --- a/config/src/vespa/config/subscription/configinstancespec.h +++ b/config/src/vespa/config/subscription/configinstancespec.h @@ -15,6 +15,9 @@ class ConfigInstanceSpec : public SourceSpec { public: ConfigInstanceSpec(const ConfigInstance & instance); + ConfigInstanceSpec(const ConfigInstanceSpec &) = delete; + ConfigInstanceSpec & operator =(const ConfigInstanceSpec &) = delete; + ~ConfigInstanceSpec() override; std::unique_ptr<SourceFactory> createSourceFactory(const TimingValues & timingValues) const override; private: const ConfigKey _key; diff --git a/config/src/vespa/config/subscription/configsubscriber.cpp b/config/src/vespa/config/subscription/configsubscriber.cpp index 2627b479df9..0645481a1f5 100644 --- a/config/src/vespa/config/subscription/configsubscriber.cpp +++ b/config/src/vespa/config/subscription/configsubscriber.cpp @@ -6,8 +6,8 @@ namespace config { -ConfigSubscriber::ConfigSubscriber(const IConfigContext::SP & context) - : _set(context) +ConfigSubscriber::ConfigSubscriber(std::shared_ptr<IConfigContext> context) + : _set(std::move(context)) { } @@ -15,6 +15,8 @@ ConfigSubscriber::ConfigSubscriber(const SourceSpec & spec) : _set(std::make_shared<ConfigContext>(spec)) { } +ConfigSubscriber::~ConfigSubscriber() = default; + bool ConfigSubscriber::nextConfig(milliseconds timeoutInMillis) { diff --git a/config/src/vespa/config/subscription/configsubscriber.h b/config/src/vespa/config/subscription/configsubscriber.h index 1cc82b6db8c..fd6497155fc 100644 --- a/config/src/vespa/config/subscription/configsubscriber.h +++ b/config/src/vespa/config/subscription/configsubscriber.h @@ -45,7 +45,10 @@ public: * * @param context A ConfigContext shared between all subscribers. */ - ConfigSubscriber(const IConfigContext::SP & context); + explicit ConfigSubscriber(std::shared_ptr<IConfigContext> context); + ConfigSubscriber(const ConfigSubscriber &) = delete; + ConfigSubscriber & operator= (const ConfigSubscriber &) = delete; + ~ConfigSubscriber(); /** * Checks if one or more of the configs in the set is updated or not. @@ -106,6 +109,3 @@ private: }; } // namespace config - -#include "configsubscriber.hpp" - diff --git a/config/src/vespa/config/subscription/configsubscriber.hpp b/config/src/vespa/config/subscription/configsubscriber.hpp index 28c54240748..ca890f8e35d 100644 --- a/config/src/vespa/config/subscription/configsubscriber.hpp +++ b/config/src/vespa/config/subscription/configsubscriber.hpp @@ -1,5 +1,8 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#include "configsubscriber.h" +#include "confighandle.hpp" + namespace config { template <typename ConfigType> @@ -7,7 +10,7 @@ std::unique_ptr<ConfigHandle<ConfigType> > ConfigSubscriber::subscribe(const std::string & configId, milliseconds timeoutInMillis) { const ConfigKey key(ConfigKey::create<ConfigType>(configId)); - return std::unique_ptr<ConfigHandle<ConfigType> >(new ConfigHandle<ConfigType>(_set.subscribe(key, timeoutInMillis))); + return std::make_unique<ConfigHandle<ConfigType> >(_set.subscribe(key, timeoutInMillis)); } } diff --git a/config/src/vespa/config/subscription/configsubscription.cpp b/config/src/vespa/config/subscription/configsubscription.cpp index 9790541906b..d49c5c32478 100644 --- a/config/src/vespa/config/subscription/configsubscription.cpp +++ b/config/src/vespa/config/subscription/configsubscription.cpp @@ -1,16 +1,19 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#include "configsubscription.h" +#include <vespa/config/common/configupdate.h> +#include <vespa/config/common/iconfigholder.h> #include <vespa/config/common/exceptions.h> #include <vespa/config/common/misc.h> -#include "configsubscription.h" namespace config { -ConfigSubscription::ConfigSubscription(const SubscriptionId & id, const ConfigKey & key, const IConfigHolder::SP & holder, Source::UP source) +ConfigSubscription::ConfigSubscription(const SubscriptionId & id, const ConfigKey & key, + std::shared_ptr<IConfigHolder> holder, std::unique_ptr<Source> source) : _id(id), _key(key), _source(std::move(source)), - _holder(holder), + _holder(std::move(holder)), _next(), _current(), _isChanged(false), diff --git a/config/src/vespa/config/subscription/configsubscription.h b/config/src/vespa/config/subscription/configsubscription.h index 08dcac6a580..05c03736fa3 100644 --- a/config/src/vespa/config/subscription/configsubscription.h +++ b/config/src/vespa/config/subscription/configsubscription.h @@ -1,15 +1,17 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once #include "subscriptionid.h" -#include <vespa/config/common/iconfigholder.h> #include <vespa/config/common/configkey.h> #include <vespa/config/common/source.h> - #include <atomic> #include <chrono> namespace config { +class IConfigHolder; +class ConfigUpdate; +class ConfigValue; + /** * A subscription can be polled for config updates, and handles interruption of * the nextUpdate call. @@ -20,7 +22,7 @@ public: typedef std::unique_ptr<ConfigSubscription> UP; typedef std::shared_ptr<ConfigSubscription> SP; - ConfigSubscription(const SubscriptionId & id, const ConfigKey & key, const IConfigHolder::SP & holder, Source::UP source); + ConfigSubscription(const SubscriptionId & id, const ConfigKey & key, std::shared_ptr<IConfigHolder> holder, std::unique_ptr<Source> source); ~ConfigSubscription(); /** @@ -57,15 +59,15 @@ public: void reload(int64_t generation); private: - const SubscriptionId _id; - const ConfigKey _key; - Source::UP _source; - IConfigHolder::SP _holder; - ConfigUpdate::UP _next; - ConfigUpdate::UP _current; - bool _isChanged; - int64_t _lastGenerationChanged; - std::atomic<bool> _closed; + const SubscriptionId _id; + const ConfigKey _key; + std::unique_ptr<Source> _source; + std::shared_ptr<IConfigHolder> _holder; + std::unique_ptr<ConfigUpdate> _next; + std::unique_ptr<ConfigUpdate> _current; + bool _isChanged; + int64_t _lastGenerationChanged; + std::atomic<bool> _closed; }; typedef std::vector<ConfigSubscription::SP> SubscriptionList; diff --git a/config/src/vespa/config/subscription/configsubscriptionset.cpp b/config/src/vespa/config/subscription/configsubscriptionset.cpp index 63c9f287350..9ad4dfe3f9d 100644 --- a/config/src/vespa/config/subscription/configsubscriptionset.cpp +++ b/config/src/vespa/config/subscription/configsubscriptionset.cpp @@ -1,8 +1,11 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #include "configsubscriptionset.h" +#include "configsubscription.h" #include <vespa/config/common/exceptions.h> #include <vespa/config/common/misc.h> +#include <vespa/config/common/iconfigmanager.h> +#include <vespa/config/common/iconfigcontext.h> #include <thread> #include <vespa/log/log.h> @@ -13,9 +16,9 @@ using namespace std::chrono; namespace config { -ConfigSubscriptionSet::ConfigSubscriptionSet(const IConfigContext::SP & context) - : _context(context), - _mgr(context->getManagerInstance()), +ConfigSubscriptionSet::ConfigSubscriptionSet(std::shared_ptr<IConfigContext> context) + : _context(std::move(context)), + _mgr(_context->getManagerInstance()), _currentGeneration(-1), _subscriptionList(), _state(OPEN) @@ -119,7 +122,7 @@ ConfigSubscriptionSet::isClosed() const return (_state.load(std::memory_order_relaxed) == CLOSED); } -ConfigSubscription::SP +std::shared_ptr<ConfigSubscription> ConfigSubscriptionSet::subscribe(const ConfigKey & key, milliseconds timeoutInMillis) { if (_state != OPEN) { @@ -127,7 +130,7 @@ ConfigSubscriptionSet::subscribe(const ConfigKey & key, milliseconds timeoutInMi } LOG(debug, "Subscribing with config Id(%s), defName(%s)", key.getConfigId().c_str(), key.getDefName().c_str()); - ConfigSubscription::SP s = _mgr.subscribe(key, timeoutInMillis); + std::shared_ptr<ConfigSubscription> s = _mgr.subscribe(key, timeoutInMillis); _subscriptionList.push_back(s); return s; } diff --git a/config/src/vespa/config/subscription/configsubscriptionset.h b/config/src/vespa/config/subscription/configsubscriptionset.h index ea37a133ef8..89c74a97be2 100644 --- a/config/src/vespa/config/subscription/configsubscriptionset.h +++ b/config/src/vespa/config/subscription/configsubscriptionset.h @@ -2,16 +2,19 @@ // #pragma once -#include "confighandle.h" #include "subscriptionid.h" -#include "configsubscription.h" -#include "configprovider.h" -#include <vespa/config/common/iconfigcontext.h> -#include <vespa/config/common/iconfigmanager.h> #include <atomic> +#include <chrono> +#include <memory> +#include <vector> namespace config { +class IConfigContext; +class IConfigManager; +class ConfigSubscription; +class ConfigKey; + /** * A ConfigSubscriptionSet is a set of configs that can be subscribed to. */ @@ -25,8 +28,10 @@ public: * * @param context A ConfigContext shared between all subscriptions. */ - ConfigSubscriptionSet(const IConfigContext::SP & context); + explicit ConfigSubscriptionSet(std::shared_ptr<IConfigContext> context); + ConfigSubscriptionSet(const ConfigSubscriptionSet &) = delete; + ConfigSubscriptionSet & operator= (const ConfigSubscriptionSet &) = delete; ~ConfigSubscriptionSet(); /** @@ -48,7 +53,7 @@ public: bool isClosed() const; // Helpers for doing the subscription - ConfigSubscription::SP subscribe(const ConfigKey & key, milliseconds timeoutInMillis); + std::shared_ptr<ConfigSubscription> subscribe(const ConfigKey & key, milliseconds timeoutInMillis); // Tries to acquire a new snapshot of config within the timeout bool acquireSnapshot(milliseconds timeoutInMillis, bool requireDifference); @@ -56,13 +61,13 @@ public: private: // Describes the state of the subscriber. enum SubscriberState { OPEN, FROZEN, CONFIGURED, CLOSED }; + using SubscriptionList = std::vector<std::shared_ptr<ConfigSubscription>>; - IConfigContext::SP _context; // Context to keep alive managers. - IConfigManager & _mgr; // The config manager that we use. - int64_t _currentGeneration; // Holds the current config generation. - SubscriptionList _subscriptionList; // List of current subscriptions. - - std::atomic<SubscriberState> _state; // Current state of this subscriber. + std::shared_ptr<IConfigContext> _context; // Context to keep alive managers. + IConfigManager & _mgr; // The config manager that we use. + int64_t _currentGeneration; // Holds the current config generation. + SubscriptionList _subscriptionList; // List of current subscriptions. + std::atomic<SubscriberState> _state; // Current state of this subscriber. }; } // namespace config diff --git a/config/src/vespa/config/subscription/configuri.cpp b/config/src/vespa/config/subscription/configuri.cpp index 001e7adbb8b..edb06f8b237 100644 --- a/config/src/vespa/config/subscription/configuri.cpp +++ b/config/src/vespa/config/subscription/configuri.cpp @@ -18,7 +18,7 @@ ConfigUri::ConfigUri(const vespalib::string &configId) { } -ConfigUri::ConfigUri(const vespalib::string &configId, IConfigContext::SP context) +ConfigUri::ConfigUri(const vespalib::string &configId, std::shared_ptr<IConfigContext> context) : _configId(configId), _context(std::move(context)), _empty(false) @@ -34,7 +34,7 @@ ConfigUri::createWithNewId(const vespalib::string & configId) const } const vespalib::string & ConfigUri::getConfigId() const { return _configId; } -const IConfigContext::SP & ConfigUri::getContext() const { return _context; } +const std::shared_ptr<IConfigContext> & ConfigUri::getContext() const { return _context; } ConfigUri ConfigUri::createFromInstance(const ConfigInstance & instance) diff --git a/config/src/vespa/config/subscription/configuri.h b/config/src/vespa/config/subscription/configuri.h index 7fe32312d30..d8472d9a637 100644 --- a/config/src/vespa/config/subscription/configuri.h +++ b/config/src/vespa/config/subscription/configuri.h @@ -46,7 +46,7 @@ public: * @param configId The config id. * @param context A context object that can be shared with multiple URIs. */ - ConfigUri(const vespalib::string &configId, IConfigContext::SP context); + ConfigUri(const vespalib::string &configId, std::shared_ptr<IConfigContext> context); ~ConfigUri(); @@ -90,7 +90,7 @@ public: * Get the context for this uri. Used by subscriber. * @return The context. */ - const IConfigContext::SP & getContext() const; + const std::shared_ptr<IConfigContext> & getContext() const; /** * Empty if the original id was empty or created with createEmpty @@ -99,9 +99,9 @@ public: bool empty() const { return _empty; } private: - vespalib::string _configId; - IConfigContext::SP _context; - bool _empty; + vespalib::string _configId; + std::shared_ptr<IConfigContext> _context; + bool _empty; }; } // namespace config diff --git a/config/src/vespa/config/subscription/sourcespec.cpp b/config/src/vespa/config/subscription/sourcespec.cpp index c8fd577935d..8009cdfd217 100644 --- a/config/src/vespa/config/subscription/sourcespec.cpp +++ b/config/src/vespa/config/subscription/sourcespec.cpp @@ -153,7 +153,9 @@ ConfigInstanceSpec::ConfigInstanceSpec(const ConfigInstance& instance) writer.write(instance); } -SourceFactory::UP +ConfigInstanceSpec::~ConfigInstanceSpec() = default; + +std::unique_ptr<SourceFactory> ConfigInstanceSpec::createSourceFactory(const TimingValues& ) const { return std::make_unique<ConfigInstanceSourceFactory>(_key, _buffer); diff --git a/config/src/vespa/config/subscription/sourcespec.h b/config/src/vespa/config/subscription/sourcespec.h index 040c16204e3..a57b22ca322 100644 --- a/config/src/vespa/config/subscription/sourcespec.h +++ b/config/src/vespa/config/subscription/sourcespec.h @@ -37,7 +37,7 @@ public: * @return An std::unique_ptr<Source> that can be used to ask for config. */ virtual SourceFactorySP createSourceFactory(const TimingValues & timingValues) const = 0; - virtual ~SourceSpec() { } + virtual ~SourceSpec() = default; }; @@ -131,7 +131,7 @@ class ServerSpec : public SourceSpec { public: /// A list of host specifications - typedef std::vector<vespalib::string> HostSpecList; + using HostSpecList = std::vector<vespalib::string>; /** * Construct a ServerSpec that fetches the host specs from the |