Java GraphDatabaseConfiguration.buildConfiguration方法代码示例

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Override
public StoreFeatures getFeatures() {

    Configuration c = GraphDatabaseConfiguration.buildConfiguration();

    StandardStoreFeatures.Builder fb = new StandardStoreFeatures.Builder()
            .orderedScan(true).unorderedScan(true).batchMutation(true)
            .multiQuery(true).distributed(true).keyOrdered(true).storeTTL(true)
            .timestamps(true).preferredTimestamps(PREFERRED_TIMESTAMPS)
            .locking(true)
            .keyConsistent(c);

    try {
        fb.localKeyPartition(getDeployment() == Deployment.LOCAL);
    } catch (Exception e) {
        logger.warn("Unexpected exception during getDeployment()", e);
    }

    return fb.build();
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Test
public void testWriteConsistencyLevel() {
    int levelsChecked = 0;

    // Test whether CassandraTransaction honors the write consistency level option
    for (CLevel writeLevel : CLevel.values()) {
        StandardBaseTransactionConfig.Builder b = new StandardBaseTransactionConfig.Builder();
        ModifiableConfiguration mc = GraphDatabaseConfiguration.buildConfiguration();
        mc.set(CASSANDRA_WRITE_CONSISTENCY, writeLevel.name());
        b.customOptions(mc);
        b.timestampProvider(Timestamps.MICRO);
        CassandraTransaction ct = new CassandraTransaction(b.build());
        assertEquals(writeLevel, ct.getWriteConsistencyLevel());
        levelsChecked++;
    }

    // Sanity check: if CLevel.values was empty, something is wrong with the test
    Preconditions.checkState(0 < levelsChecked);
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Test
public void testReadConsistencyLevel() {
    int levelsChecked = 0;

    // Test whether CassandraTransaction honors the write consistency level option
    for (CLevel writeLevel : CLevel.values()) {
        StandardBaseTransactionConfig.Builder b = new StandardBaseTransactionConfig.Builder();
        ModifiableConfiguration mc = GraphDatabaseConfiguration.buildConfiguration();
        mc.set(CASSANDRA_READ_CONSISTENCY, writeLevel.name());
        b.timestampProvider(Timestamps.MICRO);
        b.customOptions(mc);
        CassandraTransaction ct = new CassandraTransaction(b.build());
        assertEquals(writeLevel, ct.getReadConsistencyLevel());
        levelsChecked++;
    }

    // Sanity check: if CLevel.values was empty, something is wrong with the test
    Preconditions.checkState(0 < levelsChecked);
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
/**
 * Constructs a new TitanTransaction configuration with default configuration parameters.
 */
public StandardTransactionBuilder(GraphDatabaseConfiguration graphConfig, StandardTitanGraph graph) {
    Preconditions.checkNotNull(graphConfig);
    Preconditions.checkNotNull(graph);
    if (graphConfig.isReadOnly()) readOnly();
    if (graphConfig.isBatchLoading()) enableBatchLoading();
    this.graph = graph;
    this.defaultSchemaMaker = graphConfig.getDefaultSchemaMaker();
    this.assignIDsImmediately = graphConfig.hasFlushIDs();
    this.forceIndexUsage = graphConfig.hasForceIndexUsage();
    this.groupName = graphConfig.getMetricsPrefix();
    this.logIdentifier = null;
    this.propertyPrefetching = graphConfig.hasPropertyPrefetching();
    this.writableCustomOptions = GraphDatabaseConfiguration.buildConfiguration();
    this.customOptions = new MergedConfiguration(writableCustomOptions, graphConfig.getConfiguration());
    setVertexCacheSize(graphConfig.getTxVertexCacheSize());
    setDirtyVertexSize(graphConfig.getTxDirtyVertexSize());
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
public VertexIDAssignerTest(Boolean partition, int partitionMax, int[] localPartition) {
    MockIDAuthority idAuthority = new MockIDAuthority(11, partitionMax);

    StandardStoreFeatures.Builder fb = new StandardStoreFeatures.Builder();

    if (null != localPartition) {
        fb.localKeyPartition(true);
        idAuthority.setLocalPartition(localPartition);
    }
    StoreFeatures features = fb.build();

    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(GraphDatabaseConfiguration.CLUSTER_PARTITION,partition);
    config.set(GraphDatabaseConfiguration.CLUSTER_MAX_PARTITIONS,1024);
    idAssigner = new VertexIDAssigner(config, idAuthority, features);
    System.out.println("Partition: " + partition);
    System.out.println("partitionMax: " + partitionMax);
    System.out.println("localPartition: " + Arrays.toString(localPartition));
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Override
public StoreFeatures getFeatures() {

    Configuration c = GraphDatabaseConfiguration.buildConfiguration();

    StandardStoreFeatures.Builder fb = new StandardStoreFeatures.Builder()
            .orderedScan(true).unorderedScan(true).batchMutation(true)
            .multiQuery(true).distributed(true).keyOrdered(true).storeTTL(true)
            .timestamps(true).preferredTimestamps(PREFERRED_TIMESTAMPS)
            .keyConsistent(c);

    try {
        fb.localKeyPartition(getDeployment() == Deployment.LOCAL);
    } catch (Exception e) {
        logger.warn("Unexpected exception during getDeployment()", e);
    }

    return fb.build();
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Test
public void testLocalNodeUsingYaml() throws BackendException, InterruptedException {

    String baseDir = Joiner.on("/").join("target", "es", "jvmlocal_yml");

    assertFalse(new File(baseDir + File.separator + "data").exists());

    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(INTERFACE, ElasticSearchSetup.NODE, INDEX_NAME);
    config.set(INDEX_CONF_FILE,
            Joiner.on(File.separator).join("target", "test-classes", "es_jvmlocal.yml"), INDEX_NAME);
    Configuration indexConfig = config.restrictTo(INDEX_NAME);
    IndexProvider idx = new ElasticSearchIndex(indexConfig);
    simpleWriteAndQuery(idx);
    idx.close();

    assertTrue(new File(baseDir + File.separator + "data").exists());
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Override
public LogManager openLogManager(String senderId) throws BackendException {
    storeManager = openStorageManager();
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID,senderId);
    config.set(GraphDatabaseConfiguration.LOG_READ_INTERVAL, new StandardDuration(500L, TimeUnit.MILLISECONDS), LOG_NAME);
    return new KCVSLogManager(storeManager,config.restrictTo(LOG_NAME));
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
private Configuration getLocalSolrTestConfig() {
    final String index = "solr";
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();

    config.set(SolrIndex.ZOOKEEPER_URL, SolrRunner.getMiniCluster().getZkServer().getZkAddress(), index);

    return config.restrictTo(index);
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
public void open() throws BackendException {
    manager = new KeyColumnValueStoreManager[CONCURRENCY];
    tx = new StoreTransaction[CONCURRENCY][NUM_TX];
    store = new KeyColumnValueStore[CONCURRENCY];

    for (int i = 0; i < CONCURRENCY; i++) {
        manager[i] = openStorageManager(i);
        StoreFeatures storeFeatures = manager[i].getFeatures();
        store[i] = manager[i].openDatabase(DB_NAME);
        for (int j = 0; j < NUM_TX; j++) {
            tx[i][j] = manager[i].beginTransaction(getTxConfig());
            log.debug("Began transaction of class {}", tx[i][j].getClass().getCanonicalName());
        }

        ModifiableConfiguration sc = GraphDatabaseConfiguration.buildConfiguration();
        sc.set(GraphDatabaseConfiguration.LOCK_LOCAL_MEDIATOR_GROUP,concreteClassName + i);
        sc.set(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID,"inst"+i);
        sc.set(GraphDatabaseConfiguration.LOCK_RETRY,10);
        sc.set(GraphDatabaseConfiguration.LOCK_EXPIRE, new StandardDuration(EXPIRE_MS, TimeUnit.MILLISECONDS));

        if (!storeFeatures.hasLocking()) {
            Preconditions.checkArgument(storeFeatures.isKeyConsistent(),"Store needs to support some form of locking");
            KeyColumnValueStore lockerStore = manager[i].openDatabase(DB_NAME + "_lock_");
            ConsistentKeyLocker c = new ConsistentKeyLocker.Builder(lockerStore, manager[i]).fromConfig(sc).mediatorName(concreteClassName + i).build();
            store[i] = new ExpectedValueCheckingStore(store[i], c);
            for (int j = 0; j < NUM_TX; j++)
                tx[i][j] = new ExpectedValueCheckingTransaction(tx[i][j], manager[i].beginTransaction(getConsistentTxConfig(manager[i])), GraphDatabaseConfiguration.STORAGE_READ_WAITTIME.getDefaultValue());
        }
    }
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
public static ModifiableConfiguration getHBaseConfiguration() {
        ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
        config.set(GraphDatabaseConfiguration.STORAGE_BACKEND, "hbase");
        config.set(GraphDatabaseConfiguration.CLUSTER_PARTITION, true);
        config.set(GraphDatabaseConfiguration.TIMESTAMP_PROVIDER, HBaseStoreManager.PREFERRED_TIMESTAMPS);
        config.set(SimpleBulkPlacementStrategy.CONCURRENT_PARTITIONS, 1);
//        config.set(GraphDatabaseConfiguration.STORAGE_NS.getName()+"."+HBaseStoreManager.HBASE_CONFIGURATION_NAMESPACE+
//                    ".hbase.zookeeper.quorum","localhost");
//        config.set(GraphDatabaseConfiguration.STORAGE_NS.getName()+"."+HBaseStoreManager.HBASE_CONFIGURATION_NAMESPACE+
//                "hbase.zookeeper.property.clientPort",2181);
        return config;
    }
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Before
public void initialize() {
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(GraphDatabaseConfiguration.STORAGE_BACKEND,"inmemory");
    config.set(GraphDatabaseConfiguration.ATTRIBUTE_ALLOW_ALL_SERIALIZABLE,false);
    graph = (StandardTitanGraph) TitanFactory.open(config);
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Override
public WriteConfiguration getBaseConfiguration() {
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(GraphDatabaseConfiguration.STORAGE_BACKEND,"inmemory");
    config.set(GraphDatabaseConfiguration.CLUSTER_PARTITION,true);
    config.set(GraphDatabaseConfiguration.IDS_FLUSH,false);
    return config.getConfiguration();
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
public static final Configuration getLocalESTestConfig() {
    final String index = "es";
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(LOCAL_MODE, true, index);
    config.set(CLIENT_ONLY, false, index);
    config.set(TTL_INTERVAL, "5s", index);
    config.set(GraphDatabaseConfiguration.INDEX_DIRECTORY, StorageSetup.getHomeDir("es"), index);
    return config.restrictTo(index);
}
 

import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration; //导入方法依赖的package包/类
@Test
public void testConfigurationFile() throws BackendException {
    final String index = "es";
    ModifiableConfiguration config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(LOCAL_MODE, true, index);
    config.set(CLIENT_ONLY, true, index);
    config.set(INDEX_CONF_FILE, Joiner.on(File.separator).join("target", "test-classes", "es_nodename_foo.yml"), index);
    config.set(GraphDatabaseConfiguration.INDEX_DIRECTORY, StorageSetup.getHomeDir("es"), index);
    Configuration indexConfig = config.restrictTo(index);

    ElasticSearchIndex idx = new ElasticSearchIndex(indexConfig); // Shouldn't throw exception
    idx.close();

    assertEquals("foo", idx.getNode().settings().get("node.name"));

    config = GraphDatabaseConfiguration.buildConfiguration();
    config.set(LOCAL_MODE, true, index);
    config.set(CLIENT_ONLY, true, index);
    config.set(INDEX_CONF_FILE, Joiner.on(File.separator).join("target", "test-classes", "es_nodename_bar.yml"), index);
    config.set(GraphDatabaseConfiguration.INDEX_DIRECTORY, StorageSetup.getHomeDir("es"), index);
    indexConfig = config.restrictTo(index);

    idx = new ElasticSearchIndex(indexConfig); // Shouldn't throw exception
    idx.close();

    assertEquals("bar", idx.getNode().settings().get("node.name"));
}