public static ModifiableConfiguration getConfig(WriteConfiguration config) { return new ModifiableConfiguration(ROOT_NS,config, BasicConfiguration.Restriction.NONE); }
public static ModifiableConfiguration getGlobalSystemConfig(Backend backend) { return new ModifiableConfiguration(ROOT_NS, backend.getGlobalSystemConfig(), BasicConfiguration.Restriction.GLOBAL); }
/** * 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); }
@Override public WriteConfiguration getConfiguration() { WriteConfiguration config = getBaseConfiguration(); ModifiableConfiguration modifiableConfiguration = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,config, BasicConfiguration.Restriction.NONE); // Let GraphDatabaseConfiguration's config freezer set CLUSTER_PARTITION //modifiableConfiguration.set(GraphDatabaseConfiguration.CLUSTER_PARTITION,true); modifiableConfiguration.set(GraphDatabaseConfiguration.CLUSTER_MAX_PARTITIONS,numPartitions); //uses SimpleBulkPlacementStrategy by default modifiableConfiguration.set(SimpleBulkPlacementStrategy.CONCURRENT_PARTITIONS,3*numPartitions); return config; }
private static ReadConfiguration getLocalConfiguration(String shortcutOrFile) { File file = new File(shortcutOrFile); if (file.exists()) return getLocalConfiguration(file); else { int pos = shortcutOrFile.indexOf(':'); if (pos<0) pos = shortcutOrFile.length(); String backend = shortcutOrFile.substring(0,pos); Preconditions.checkArgument(StandardStoreManager.getAllManagerClasses().containsKey(backend.toLowerCase()), "Backend shorthand unknown: %s", backend); String secondArg = null; if (pos+1<shortcutOrFile.length()) secondArg = shortcutOrFile.substring(pos + 1).trim(); BaseConfiguration config = new BaseConfiguration(); ModifiableConfiguration writeConfig = new ModifiableConfiguration(ROOT_NS,new CommonsConfiguration(config), BasicConfiguration.Restriction.NONE); writeConfig.set(STORAGE_BACKEND,backend); ConfigOption option = Backend.getOptionForShorthand(backend); if (option==null) { Preconditions.checkArgument(secondArg==null); } else if (option==STORAGE_DIRECTORY || option==STORAGE_CONF_FILE) { Preconditions.checkArgument(StringUtils.isNotBlank(secondArg),"Need to provide additional argument to initialize storage backend"); writeConfig.set(option,getAbsolutePath(secondArg)); } else if (option==STORAGE_HOSTS) { Preconditions.checkArgument(StringUtils.isNotBlank(secondArg),"Need to provide additional argument to initialize storage backend"); writeConfig.set(option,new String[]{secondArg}); } else throw new IllegalArgumentException("Invalid configuration option for backend "+option); return new CommonsConfiguration(config); } }
public JanusGraph getForceIndexGraph() throws BackendException { final ModifiableConfiguration adjustedConfig = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,getConfiguration(), BasicConfiguration.Restriction.NONE); adjustedConfig.set(GraphDatabaseConfiguration.FORCE_INDEX_USAGE, true); final WriteConfiguration writeConfig = adjustedConfig.getConfiguration(); TestGraphConfigs.applyOverrides(writeConfig); Preconditions.checkNotNull(writeConfig); return JanusGraphFactory.open(writeConfig); }
@Override public WriteConfiguration getConfiguration() { WriteConfiguration config = getBaseConfiguration(); ModifiableConfiguration modifiableConfiguration = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,config, BasicConfiguration.Restriction.NONE); modifiableConfiguration.set(BASIC_METRICS,true); modifiableConfiguration.set(METRICS_MERGE_STORES,false); modifiableConfiguration.set(PROPERTY_PREFETCHING,false); modifiableConfiguration.set(DB_CACHE, false); return config; }
public ManagementSystem(StandardJanusGraph graph, KCVSConfiguration config, Log sysLog, ManagementLogger managementLogger, SchemaCache schemaCache) { Preconditions.checkArgument(config != null && graph != null && sysLog != null && managementLogger != null); this.graph = graph; this.sysLog = sysLog; this.managementLogger = managementLogger; this.schemaCache = schemaCache; this.transactionalConfig = new TransactionalConfiguration(config); this.modifyConfig = new ModifiableConfiguration(ROOT_NS, transactionalConfig, BasicConfiguration.Restriction.GLOBAL); this.userConfig = new UserModifiableConfiguration(modifyConfig, configVerifier); this.updatedTypes = new HashSet<>(); this.evictGraphFromCache = false; this.updatedTypeTriggers = new ArrayList<>(); this.graphShutdownRequired = false; this.transaction = (StandardJanusGraphTx) graph.buildTransaction().disableBatchLoading().start(); this.txStartTime = graph.getConfiguration().getTimestampProvider().getTime(); this.isOpen = true; }
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 static ModifiableConfiguration buildGraphConfiguration() { return new ModifiableConfiguration(ROOT_NS, new CommonsConfiguration(new BaseConfiguration()), BasicConfiguration.Restriction.NONE); }
public static ModifiableConfiguration buildJobConfiguration() { return new ModifiableConfiguration(JOB_NS, new CommonsConfiguration(new BaseConfiguration()), BasicConfiguration.Restriction.NONE); }
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); } }
public void clopen(Object... settings) { config = getConfiguration(); if (mgmt!=null && mgmt.isOpen()) mgmt.rollback(); if (null != tx && tx.isOpen()) tx.commit(); if (settings!=null && settings.length>0) { final Map<TestConfigOption,Object> options = validateConfigOptions(settings); JanusGraphManagement janusGraphManagement = null; final ModifiableConfiguration modifiableConfiguration = new ModifiableConfiguration(GraphDatabaseConfiguration.ROOT_NS,config, BasicConfiguration.Restriction.LOCAL); for (final Map.Entry<TestConfigOption,Object> option : options.entrySet()) { if (option.getKey().option.isLocal()) { modifiableConfiguration.set(option.getKey().option,option.getValue(),option.getKey().umbrella); } else { if (janusGraphManagement==null) janusGraphManagement = graph.openManagement(); janusGraphManagement.set(ConfigElement.getPath(option.getKey().option,option.getKey().umbrella),option.getValue()); } } if (janusGraphManagement!=null) janusGraphManagement.commit(); modifiableConfiguration.close(); } if (null != graph && null != graph.tx() && graph.tx().isOpen()) graph.tx().commit(); if (null != graph && graph.isOpen()) graph.close(); Preconditions.checkNotNull(config); open(config); }
/** * Opens a {@link JanusGraph} database configured according to the provided configuration. * This method shouldn't be called by end users; it is used by internal server processes to * open graphs defined at server start that do not include the graphname property. * * @param configuration Configuration for the graph database * @param backupName Backup name for graph * @return JanusGraph graph database */ public static JanusGraph open(ReadConfiguration configuration, String backupName) { final ModifiableConfiguration config = new ModifiableConfiguration(ROOT_NS, (WriteConfiguration) configuration, BasicConfiguration.Restriction.NONE); final String graphName = config.has(GRAPH_NAME) ? config.get(GRAPH_NAME) : backupName; final JanusGraphManager jgm = JanusGraphManagerUtility.getInstance(); if (null != graphName) { Preconditions.checkState(jgm != null, JANUS_GRAPH_MANAGER_EXPECTED_STATE_MSG); return (JanusGraph) jgm.openGraph(graphName, gName -> new StandardJanusGraph(new GraphDatabaseConfiguration(configuration))); } else { if (jgm != null) { log.warn("You should supply \"graph.graphname\" in your .properties file configuration if you are opening " + "a graph that has not already been opened at server start, i.e. it was " + "defined in your YAML file. This will ensure the graph is tracked by the JanusGraphManager, " + "which will enable autocommit and rollback functionality upon all gremlin script executions. " + "Note that JanusGraphFactory#open(String === shortcut notation) does not support consuming the property " + "\"graph.graphname\" so these graphs should be accessed dynamically by supplying a .properties file here " + "or by using the ConfiguredGraphFactory."); } return new StandardJanusGraph(new GraphDatabaseConfiguration(configuration)); } }
public static Configuration getJobConf(List<SliceQuery> queries, Long modulus, Long modVal) { ModifiableConfiguration conf2 = new ModifiableConfiguration(SimpleScanJob.ROOT_NS, new CommonsConfiguration(new BaseConfiguration()), BasicConfiguration.Restriction.NONE); if (null != queries) conf2.set(HEX_QUERIES, encodeQueries(queries)); if (null != modulus) conf2.set(KEY_FILTER_ID_MODULUS, modulus); if (null != modVal) conf2.set(KEY_FILTER_ID_MODULAR_VALUE, modVal); return conf2; } }
ModifiableConfiguration overwrite = new ModifiableConfiguration(ROOT_NS,new CommonsConfiguration(), BasicConfiguration.Restriction.NONE); localConfiguration = new ModifiableConfiguration(ROOT_NS, new CommonsConfiguration(), BasicConfiguration.Restriction.LOCAL); localConfiguration.setAll(getLocalSubset(localBasicConfiguration.getAll())); ModifiableConfiguration globalWrite = new ModifiableConfiguration(ROOT_NS,keyColumnValueStoreConfiguration, BasicConfiguration.Restriction.GLOBAL);
public static ModifiableConfiguration prefixView(ConfigNamespace newRoot, ConfigNamespace prefixRoot, ModifiableHadoopConfiguration mc) { HadoopConfiguration prefixConf = new HadoopConfiguration(mc.getHadoopConfiguration(), ConfigElement.getPath(prefixRoot, true) + "."); return new ModifiableConfiguration(newRoot, prefixConf, Restriction.NONE); }
public static ModifiableConfiguration prefixView(ConfigNamespace newRoot, ConfigNamespace prefixRoot, ModifiableHadoopConfiguration mc) { HadoopConfiguration prefixConf = new HadoopConfiguration(mc.getHadoopConfiguration(), ConfigElement.getPath(prefixRoot, true) + "."); return new ModifiableConfiguration(newRoot, prefixConf, Restriction.NONE); }
private static ModifiableConfiguration getIndexJobConf(String indexName, String relationType) { ModifiableConfiguration mc = new ModifiableConfiguration(GraphDatabaseConfiguration.JOB_NS, new CommonsConfiguration(new BaseConfiguration()), BasicConfiguration.Restriction.NONE); mc.set(org.janusgraph.graphdb.olap.job.IndexUpdateJob.INDEX_NAME, indexName); mc.set(org.janusgraph.graphdb.olap.job.IndexUpdateJob.INDEX_RELATION_TYPE, relationType); mc.set(GraphDatabaseConfiguration.JOB_START_TIME, System.currentTimeMillis()); return mc; }
private static ModifiableConfiguration getIndexJobConf(String indexName, String relationType) { ModifiableConfiguration mc = new ModifiableConfiguration(GraphDatabaseConfiguration.JOB_NS, new CommonsConfiguration(new BaseConfiguration()), BasicConfiguration.Restriction.NONE); mc.set(org.janusgraph.graphdb.olap.job.IndexUpdateJob.INDEX_NAME, indexName); mc.set(org.janusgraph.graphdb.olap.job.IndexUpdateJob.INDEX_RELATION_TYPE, relationType); mc.set(GraphDatabaseConfiguration.JOB_START_TIME, System.currentTimeMillis()); return mc; }