@Override public WriteConfiguration copy() { return config.copy(); }
@Test public void configTest() { config.set("test.key","world"); config.set("test.bar", 100); config.set("storage.xyz", true); config.set("storage.abc", Boolean.FALSE); config.set("storage.duba", new String[]{"x", "y"}); config.set("times.60m", Duration.ofMinutes(60)); config.set("obj", new Object()); // necessary for AbstractConfiguration.getSubset assertEquals("world", config.get("test.key", String.class)); assertEquals(ImmutableSet.of("test.key", "test.bar"), Sets.newHashSet(config.getKeys("test"))); // assertEquals(ImmutableSet.of("test.key", "test.bar", "test.baz"), Sets.newHashSet(config.getKeys("test"))); assertEquals(ImmutableSet.of("storage.xyz", "storage.duba", "storage.abc"), Sets.newHashSet(config.getKeys("storage"))); assertEquals(100,config.get("test.bar",Integer.class).intValue()); // assertEquals(1,config.get("test.baz",Integer.class).intValue()); assertEquals(true, config.get("storage.xyz", Boolean.class)); assertEquals(false, config.get("storage.abc", Boolean.class)); assertTrue(Arrays.equals(new String[]{"x", "y"},config.get("storage.duba",String[].class))); assertEquals(Duration.ofMinutes(60), config.get("times.60m", Duration.class)); assertTrue(Object.class.isAssignableFrom(config.get("obj", Object.class).getClass())); } }
@After public void cleanup() { config.close(); }
/** * Configures the provided configuration path to the given value. * * @param path * @param value * @return */ public Builder set(String path, Object value) { writeConfiguration.set(path, value); return this; }
@Override public <O> O get(String key, Class<O> datatype) { Object value = writtenValues.get(key); if (value!=null) return (O)value; value = readValues.get(key); if (value!=null) return (O)value; value = config.get(key,datatype); readValues.put(key,value); return (O)value; }
@Override public Set<String> keys() { return Sets.newHashSet(config.getKeys("")); }
@Override public void remove(String s) { if (s==null) throw Graph.Variables.Exceptions.variableKeyCanNotBeNull(); if (StringUtils.isEmpty(s)) throw Graph.Variables.Exceptions.variableKeyCanNotBeEmpty(); config.remove(s); }
public void commit() { for (Map.Entry<String,Object> entry : writtenValues.entrySet()) { if (config instanceof ConcurrentWriteConfiguration && readValues.containsKey(entry.getKey())) { ((ConcurrentWriteConfiguration)config) .set(entry.getKey(), entry.getValue(), readValues.get(entry.getKey())); } else { config.set(entry.getKey(),entry.getValue()); } } rollback(); }
@Override public <R> Optional<R> get(String s) { if (s==null) throw Graph.Variables.Exceptions.variableKeyCanNotBeNull(); if (StringUtils.isEmpty(s)) throw Graph.Variables.Exceptions.variableKeyCanNotBeEmpty(); Object value = config.get(s,Object.class); if (value==null) return Optional.empty(); else return Optional.of((R)value); }
@Override public Iterable<String> getKeys(final String prefix) { return Iterables.concat( Iterables.filter(writtenValues.keySet(), s -> s.startsWith(prefix)), Iterables.filter(config.getKeys(prefix), s -> !writtenValues.containsKey(s))); }
public<O> void remove(ConfigOption<O> option, String... umbrellaElements) { verifyOption(option); Preconditions.checkArgument(!option.isFixed() || !isFrozen(), "Cannot change configuration option: %s", option); String key = super.getPath(option,umbrellaElements); config.remove(key); }
public static void applyOverrides(final WriteConfiguration base) { if (null == overrides) return; for (String k : overrides.getKeys(null)) { base.set(k, overrides.get(k, Object.class)); } }
public Configuration getConfig() { return new BasicConfiguration(GraphDatabaseConfiguration.ROOT_NS, config.copy(), BasicConfiguration.Restriction.NONE); }
return; Boolean dbCache = config.get("cache.db-cache", Boolean.class); if (null == dbCache) { dbCache = false;
@Override public void set(String s, Object o) { if (s==null) throw Graph.Variables.Exceptions.variableKeyCanNotBeNull(); if (StringUtils.isEmpty(s)) throw Graph.Variables.Exceptions.variableKeyCanNotBeEmpty(); if (o==null) throw Graph.Variables.Exceptions.variableValueCanNotBeNull(); config.set(s,o); }
/** * Opens a JanusGraph graph with the previously configured options. * * @return */ public JanusGraph open() { ModifiableConfiguration mc = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS, writeConfiguration.copy(), BasicConfiguration.Restriction.NONE); return JanusGraphFactory.open(mc); }
public void freezeConfiguration() { config.set(FROZEN_KEY, Boolean.TRUE); if (!isFrozen()) setFrozen(); }
public static Backend getBackend(WriteConfiguration config, boolean initialize) throws BackendException { final ModifiableConfiguration adjustedConfig = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,config.copy(), BasicConfiguration.Restriction.NONE); adjustedConfig.set(GraphDatabaseConfiguration.LOCK_LOCAL_MEDIATOR_GROUP, "tmp"); adjustedConfig.set(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID, "inst"); final Backend backend = new Backend(adjustedConfig); if (initialize) { backend.initialize(adjustedConfig); } return backend; }
public<O> ModifiableConfiguration set(ConfigOption<O> option, O value, String... umbrellaElements) { verifyOption(option); Preconditions.checkArgument(hasUpgradeableFixed(option.getName()) || !option.isFixed() || !isFrozen(), "Cannot change configuration option: %s", option); String key = super.getPath(option,umbrellaElements); value = option.verify(value); config.set(key,value); return this; }
private Log openLog(String logManagerName, String logName) { try { final ModifiableConfiguration configuration = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,config.copy(), BasicConfiguration.Restriction.NONE); configuration.set(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID, "reader"); configuration.set(GraphDatabaseConfiguration.LOG_READ_INTERVAL, Duration.ofMillis(500L), logManagerName); if (logStoreManager==null) { logStoreManager = Backend.getStorageManager(configuration); } final StoreFeatures f = logStoreManager.getFeatures(); final boolean part = f.isDistributed() && f.isKeyOrdered(); if (part) { for (final String partitionedLogName : new String[]{USER_LOG,TRANSACTION_LOG,MANAGEMENT_LOG}) configuration.set(KCVSLogManager.LOG_MAX_PARTITIONS,8,partitionedLogName); } assert logStoreManager!=null; if (!logManagers.containsKey(logManagerName)) { //Open log manager - only supports KCVSLog final Configuration logConfig = configuration.restrictTo(logManagerName); Preconditions.checkArgument(logConfig.get(LOG_BACKEND).equals(LOG_BACKEND.getDefaultValue())); logManagers.put(logManagerName,new KCVSLogManager(logStoreManager,logConfig)); } assert logManagers.containsKey(logManagerName); return logManagers.get(logManagerName).openLog(logName); } catch (final BackendException e) { throw new JanusGraphException("Could not open log: "+ logName,e); } }