X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FConfigurationImpl.java;h=061e1ab448f97ce9ad08541be9b0b1b6d4e73c30;hb=dd32d3d246ebad8b7c76afb93239a4462f329a6b;hp=c8c82997dfc0c38bb551049d3a810f33c5cfb417;hpb=af255d4824ce1290d6e6b4c669a5d9b0c5960f34;p=controller.git diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java index c8c82997df..061e1ab448 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java @@ -8,31 +8,86 @@ package org.opendaylight.controller.cluster.datastore; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; import com.typesafe.config.Config; import com.typesafe.config.ConfigFactory; import com.typesafe.config.ConfigObject; - +import java.io.File; import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; +import java.util.Set; +import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy; +import org.opendaylight.controller.cluster.datastore.shardstrategy.ModuleShardStrategy; +import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class ConfigurationImpl implements Configuration { + private final List moduleShards = new ArrayList<>(); + private final List modules = new ArrayList<>(); + private static final Logger + LOG = LoggerFactory.getLogger(DistributedDataStore.class); + + // Look up maps to speed things up + + // key = memberName, value = list of shardNames + private final Map> memberShardNames = new HashMap<>(); + + // key = shardName, value = list of replicaNames (replicaNames are the same as memberNames) + private final Map> shardReplicaNames = new HashMap<>(); + - public ConfigurationImpl(String moduleShardsConfigPath, - String modulesConfigPath){ - Config moduleShardsConfig = ConfigFactory.load(moduleShardsConfigPath); - Config modulesConfig = ConfigFactory.load(modulesConfigPath); + public ConfigurationImpl(final String moduleShardsConfigPath, + + final String modulesConfigPath){ + + Preconditions.checkNotNull(moduleShardsConfigPath, "moduleShardsConfigPath should not be null"); + Preconditions.checkNotNull(modulesConfigPath, "modulesConfigPath should not be null"); + + + File moduleShardsFile = new File("./configuration/initial/" + moduleShardsConfigPath); + File modulesFile = new File("./configuration/initial/" + modulesConfigPath); + + Config moduleShardsConfig = null; + if(moduleShardsFile.exists()) { + LOG.info("module shards config file exists - reading config from it"); + moduleShardsConfig = ConfigFactory.parseFile(moduleShardsFile); + } else { + LOG.warn("module shards configuration read from resource"); + moduleShardsConfig = ConfigFactory.load(moduleShardsConfigPath); + } + + Config modulesConfig = null; + if(modulesFile.exists()) { + LOG.info("modules config file exists - reading config from it"); + modulesConfig = ConfigFactory.parseFile(modulesFile); + } else { + LOG.warn("modules configuration read from resource"); + modulesConfig = ConfigFactory.load(modulesConfigPath); + } readModuleShards(moduleShardsConfig); readModules(modulesConfig); } - public List getMemberShardNames(String memberName){ + @Override public List getMemberShardNames(final String memberName){ + + Preconditions.checkNotNull(memberName, "memberName should not be null"); + + if(memberShardNames.containsKey(memberName)){ + return memberShardNames.get(memberName); + } - List shards = new ArrayList(); + List shards = new ArrayList<>(); for(ModuleShard ms : moduleShards){ for(Shard s : ms.getShards()){ for(String m : s.getReplicas()){ @@ -42,23 +97,95 @@ public class ConfigurationImpl implements Configuration { } } } + + memberShardNames.put(memberName, shards); + return shards; } + @Override public Optional getModuleNameFromNameSpace(final String nameSpace) { + + Preconditions.checkNotNull(nameSpace, "nameSpace should not be null"); + + for(Module m : modules){ + if(m.getNameSpace().equals(nameSpace)){ + return Optional.of(m.getName()); + } + } + return Optional.absent(); + } + + @Override public Map getModuleNameToShardStrategyMap() { + Map map = new HashMap<>(); + for(Module m : modules){ + map.put(m.getName(), m.getShardStrategy()); + } + return map; + } + + @Override public List getShardNamesFromModuleName(final String moduleName) { + + Preconditions.checkNotNull(moduleName, "moduleName should not be null"); + + for(ModuleShard m : moduleShards){ + if(m.getModuleName().equals(moduleName)){ + List l = new ArrayList<>(); + for(Shard s : m.getShards()){ + l.add(s.getName()); + } + return l; + } + } + + return Collections.emptyList(); + } + + @Override public List getMembersFromShardName(final String shardName) { + + Preconditions.checkNotNull(shardName, "shardName should not be null"); - private void readModules(Config modulesConfig) { + if(shardReplicaNames.containsKey(shardName)){ + return shardReplicaNames.get(shardName); + } + + for(ModuleShard ms : moduleShards){ + for(Shard s : ms.getShards()) { + if(s.getName().equals(shardName)){ + List replicas = s.getReplicas(); + shardReplicaNames.put(shardName, replicas); + return replicas; + } + } + } + shardReplicaNames.put(shardName, Collections.emptyList()); + return Collections.emptyList(); + } + + @Override public Set getAllShardNames() { + Set shardNames = new LinkedHashSet<>(); + for(ModuleShard ms : moduleShards){ + for(Shard s : ms.getShards()) { + shardNames.add(s.getName()); + } + } + return shardNames; + } + + + + private void readModules(final Config modulesConfig) { List modulesConfigObjectList = modulesConfig.getObjectList("modules"); for(ConfigObject o : modulesConfigObjectList){ ConfigObjectWrapper w = new ConfigObjectWrapper(o); modules.add(new Module(w.stringValue("name"), w.stringValue( - "namespace"), w.stringValue("sharding-strategy"))); + "namespace"), w.stringValue("shard-strategy"))); } } - private void readModuleShards(Config moduleShardsConfig) { + private void readModuleShards(final Config moduleShardsConfig) { List moduleShardsConfigObjectList = moduleShardsConfig.getObjectList("module-shards"); @@ -82,11 +209,11 @@ public class ConfigurationImpl implements Configuration { } - public static class ModuleShard { + private class ModuleShard { private final String moduleName; private final List shards; - public ModuleShard(String moduleName, List shards) { + public ModuleShard(final String moduleName, final List shards) { this.moduleName = moduleName; this.shards = shards; } @@ -100,11 +227,11 @@ public class ConfigurationImpl implements Configuration { } } - public static class Shard { + private class Shard { private final String name; private final List replicas; - Shard(String name, List replicas) { + Shard(final String name, final List replicas) { this.name = name; this.replicas = replicas; } @@ -118,16 +245,20 @@ public class ConfigurationImpl implements Configuration { } } - public static class Module { + private class Module { private final String name; private final String nameSpace; - private final String shardingStrategy; + private final ShardStrategy shardStrategy; - Module(String name, String nameSpace, String shardingStrategy) { + Module(final String name, final String nameSpace, final String shardStrategy) { this.name = name; this.nameSpace = nameSpace; - this.shardingStrategy = shardingStrategy; + if(ModuleShardStrategy.NAME.equals(shardStrategy)){ + this.shardStrategy = new ModuleShardStrategy(name, ConfigurationImpl.this); + } else { + this.shardStrategy = new DefaultShardStrategy(); + } } public String getName() { @@ -138,8 +269,8 @@ public class ConfigurationImpl implements Configuration { return nameSpace; } - public String getShardingStrategy() { - return shardingStrategy; + public ShardStrategy getShardStrategy() { + return shardStrategy; } } @@ -148,11 +279,11 @@ public class ConfigurationImpl implements Configuration { private final ConfigObject configObject; - ConfigObjectWrapper(ConfigObject configObject){ + ConfigObjectWrapper(final ConfigObject configObject){ this.configObject = configObject; } - public String stringValue(String name){ + public String stringValue(final String name){ return configObject.get(name).unwrapped().toString(); } }