import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ListMultimap;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import com.typesafe.config.ConfigObject;
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;
public class ConfigurationImpl implements Configuration {
- private final List<ModuleShard> moduleShards = new ArrayList<>();
+ private final List<ModuleShard> moduleShards;
- private final List<Module> modules = new ArrayList<>();
+ private final List<Module> modules;
private static final Logger
LOG = LoggerFactory.getLogger(DistributedDataStore.class);
// key = shardName, value = list of replicaNames (replicaNames are the same as memberNames)
private final Map<String, List<String>> shardReplicaNames = new HashMap<>();
+ private final ListMultimap<String, String> moduleNameToShardName;
+ private final Map<String, ShardStrategy> moduleNameToStrategy;
+ private final Map<String, String> namespaceToModuleName;
+ private final Set<String> allShardNames;
public ConfigurationImpl(final String moduleShardsConfigPath,
modulesConfig = ConfigFactory.load(modulesConfigPath);
}
- readModuleShards(moduleShardsConfig);
+ this.moduleShards = readModuleShards(moduleShardsConfig);
+ this.modules = readModules(modulesConfig);
- readModules(modulesConfig);
+ this.allShardNames = createAllShardNames(moduleShards);
+ this.moduleNameToShardName = createModuleNameToShardName(moduleShards);
+ this.moduleNameToStrategy = createModuleNameToStrategy(modules);
+ this.namespaceToModuleName = createNamespaceToModuleName(modules);
+ }
+
+ private static Set<String> createAllShardNames(Iterable<ModuleShard> moduleShards) {
+ final com.google.common.collect.ImmutableSet.Builder<String> b = ImmutableSet.builder();
+ for(ModuleShard ms : moduleShards){
+ for(Shard s : ms.getShards()) {
+ b.add(s.getName());
+ }
+ }
+ return b.build();
+ }
+
+ private static Map<String, ShardStrategy> createModuleNameToStrategy(Iterable<Module> modules) {
+ final com.google.common.collect.ImmutableMap.Builder<String, ShardStrategy> b = ImmutableMap.builder();
+ for (Module m : modules) {
+ b.put(m.getName(), m.getShardStrategy());
+ }
+ return b.build();
+ }
+
+ private static Map<String, String> createNamespaceToModuleName(Iterable<Module> modules) {
+ final com.google.common.collect.ImmutableMap.Builder<String, String> b = ImmutableMap.builder();
+ for (Module m : modules) {
+ b.put(m.getNameSpace(), m.getName());
+ }
+ return b.build();
+ }
+
+ private static ListMultimap<String, String> createModuleNameToShardName(Iterable<ModuleShard> moduleShards) {
+ final com.google.common.collect.ImmutableListMultimap.Builder<String, String> b = ImmutableListMultimap.builder();
+
+ for (ModuleShard m : moduleShards) {
+ for (Shard s : m.getShards()) {
+ b.put(m.getModuleName(), s.getName());
+ }
+ }
+
+ return b.build();
}
@Override public List<String> getMemberShardNames(final String memberName){
}
- @Override public Optional<String> getModuleNameFromNameSpace(final String nameSpace) {
-
+ @Override
+ public Optional<String> 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();
+ return Optional.fromNullable(namespaceToModuleName.get(nameSpace));
}
- @Override public Map<String, ShardStrategy> getModuleNameToShardStrategyMap() {
- Map<String, ShardStrategy> map = new HashMap<>();
- for(Module m : modules){
- map.put(m.getName(), m.getShardStrategy());
- }
- return map;
+ @Override
+ public Map<String, ShardStrategy> getModuleNameToShardStrategyMap() {
+ return moduleNameToStrategy;
}
- @Override public List<String> getShardNamesFromModuleName(final String moduleName) {
-
+ @Override
+ public List<String> getShardNamesFromModuleName(final String moduleName) {
Preconditions.checkNotNull(moduleName, "moduleName should not be null");
-
- for(ModuleShard m : moduleShards){
- if(m.getModuleName().equals(moduleName)){
- List<String> l = new ArrayList<>();
- for(Shard s : m.getShards()){
- l.add(s.getName());
- }
- return l;
- }
- }
-
- return Collections.emptyList();
+ return moduleNameToShardName.get(moduleName);
}
@Override public List<String> getMembersFromShardName(final String shardName) {
return Collections.emptyList();
}
- @Override public Set<String> getAllShardNames() {
- Set<String> shardNames = new LinkedHashSet<>();
- for(ModuleShard ms : moduleShards){
- for(Shard s : ms.getShards()) {
- shardNames.add(s.getName());
- }
- }
- return shardNames;
+ @Override
+ public Set<String> getAllShardNames() {
+ return allShardNames;
}
-
-
- private void readModules(final Config modulesConfig) {
+ private List<Module> readModules(final Config modulesConfig) {
List<? extends ConfigObject> modulesConfigObjectList =
modulesConfig.getObjectList("modules");
+ final Builder<Module> b = ImmutableList.builder();
for(ConfigObject o : modulesConfigObjectList){
ConfigObjectWrapper w = new ConfigObjectWrapper(o);
- modules.add(new Module(w.stringValue("name"), w.stringValue(
+ b.add(new Module(w.stringValue("name"), w.stringValue(
"namespace"), w.stringValue("shard-strategy")));
}
+
+ return b.build();
}
- private void readModuleShards(final Config moduleShardsConfig) {
+ private static List<ModuleShard> readModuleShards(final Config moduleShardsConfig) {
List<? extends ConfigObject> moduleShardsConfigObjectList =
moduleShardsConfig.getObjectList("module-shards");
+ final Builder<ModuleShard> b = ImmutableList.builder();
for(ConfigObject moduleShardConfigObject : moduleShardsConfigObjectList){
String moduleName = moduleShardConfigObject.get("name").unwrapped().toString();
shards.add(new Shard(shardName, replicas));
}
- this.moduleShards.add(new ModuleShard(moduleName, shards));
+ b.add(new ModuleShard(moduleName, shards));
}
- }
+ return b.build();
+ }
- private class ModuleShard {
+ private static class ModuleShard {
private final String moduleName;
private final List<Shard> shards;
}
}
- private class Shard {
+ private static class Shard {
private final String name;
private final List<String> replicas;
if(ModuleShardStrategy.NAME.equals(shardStrategy)){
this.shardStrategy = new ModuleShardStrategy(name, ConfigurationImpl.this);
} else {
- this.shardStrategy = new DefaultShardStrategy();
+ this.shardStrategy = DefaultShardStrategy.getInstance();
}
}