Java EmbeddedCassandraServerHelper.startEmbeddedCassandra方法代码示例

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@Override
protected void before() throws Throwable {

	if (runtimeMode == RuntimeMode.REQUIRE_RUNNING_INSTANCE) {
		if (!CassandraSocket.isConnectable(getHost(), getPort())) {
			throw new AssumptionViolatedException(
					String.format("Cassandra is not reachable at %s:%s.", getHost(), getPort()));
		}
	}

	if (runtimeMode == RuntimeMode.EMBEDDED_IF_NOT_RUNNING) {
		if (CassandraSocket.isConnectable(getHost(), getPort())) {
			return;
		}
	}

	EmbeddedCassandraServerHelper.startEmbeddedCassandra("embedded-cassandra.yaml");
	super.before();
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException, URISyntaxException  {
    if (! started) {
        EmbeddedCassandraServerHelper.startEmbeddedCassandra(CASSANDRA_UNIT_RANDOM_PORT_YAML, CASSANDRA_TIMEOUT);
        Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(getNativeTransportPort()).build();
        Session session = cluster.connect();
        String createQuery = "CREATE KEYSPACE " + CASSANDRA_UNIT_KEYSPACE + " WITH replication={'class' : 'SimpleStrategy', 'replication_factor':1}";
        session.execute(createQuery);
        String useKeyspaceQuery = "USE " + CASSANDRA_UNIT_KEYSPACE;
        session.execute(useKeyspaceQuery);
        CQLDataLoader dataLoader = new CQLDataLoader(session);
        applyScripts(dataLoader, "config/cql/changelog/", "*.cql");
        started = true;
    }
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(9142).build();
    Session session = cluster.connect();
    CQLDataLoader dataLoader = new CQLDataLoader(session);
    dataLoader.load(new ClassPathCQLDataSet("config/cql/create-tables.cql", true, "cassandra_unit_keyspace"));
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
/**
 * Ensures that the Mock Cassandra instance is up and running. Will reinit
 * the database every time it is called.
 *
 * @param cassandraKeyspace Cassandra keyspace to setup.
 * @return A cluster object.
 * @throws ConfigurationException
 * @throws IOException
 * @throws InterruptedException
 * @throws TTransportException
 */
public static Cluster ensureMockCassandraRunningAndEstablished(String cassandraKeyspace) throws ConfigurationException, IOException, InterruptedException, TTransportException
{
    Cluster cluster;
    long timeout = 60000;
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(timeout);
    cluster = Cluster.builder().addContactPoints("127.0.0.1").withPort(9142).build();
    //Thread.sleep(20000);//time to let cassandra startup
    final Metadata metadata = cluster.getMetadata();

    Session session = cluster.connect();
    Utils.initDatabase(DB_CQL, session);
    session = cluster.connect(cassandraKeyspace);

    logger.info("Connected to cluster: " + metadata.getClusterName() + '\n');
    return cluster;
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeMethod(groups = {"system"})
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();

    // default to using cassandra on localhost, but can be overridden with a system property
    String cassandraHostsString = System.getProperty(CASSANDRA_HOSTS_SYSTEM_PROPERTY, LOCALHOST_IP);
    String[] cassandraHosts = StringUtils.split(cassandraHostsString, ',');
    Cluster.Builder clusterBuilder = Cluster.builder();
    for (String host : cassandraHosts) {
        clusterBuilder.addContactPoint(host);
    }
    cluster = clusterBuilder.withPort(9142).build();
    dropAndCreateSchema();

    // get new session using a default keyspace that we now know exists
    session = cluster.connect(TEST_KEYSPACE);
    session = spy(session);
    daoSupport = new CqlStructuredDataSupport<UUID>(tableName, ConsistencyLevel.QUORUM, session);
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception {
    // default to using cassandra on localhost, but can be overridden with a system property
    String cassandraHosts = System.getProperty(CASSANDRA_HOSTS_SYSTEM_PROPERTY, EMBEDDED_CASSANDRA_HOST);
    String[] hosts = StringUtils.split(cassandraHosts, ",");
    numHosts = hosts.length;

    if (EMBEDDED_CASSANDRA_HOST.equals(cassandraHosts)) {
        EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    }

    // default cluster name can also be overridden with a system property
    String clusterName = System.getProperty(CLUSTER_NAME_PROPERTY, TEST_CLUSTER);

    hostConfigurator = new CassandraHostConfigurator(cassandraHosts);
    cluster = HFactory.getOrCreateCluster(clusterName, hostConfigurator);
    keyspace = HFactory.createKeyspace(TEST_KEYSPACE, cluster);

    dropAndCreateSchema();
    sleepAfterSchemaChangeIfNecessary();
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void initTest() throws Exception {

    //this test will be slow because it needs to start Casssandra embedded server.
    // For the test to be run on slow machines,
    // the embedded cassandra start timeout is set bellow to 32s ! (which is pretty slow for a unit test)
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(32000L);
    cluster = new Cluster.Builder().addContactPoint("localhost").withPort(9142).build();
    session = cluster.connect();
    createKeyspace();
    personCassandraDao = new PersonCassandraDao("localhost", "9142", CASS_KEYSPACE);
    personCassandraDao.init(Person.class);
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void setUpClass() throws InterruptedException, TTransportException, IOException {
	System.setProperty("para.cassandra.port", "9142");
	System.setProperty("para.app_name", ROOT_APP_NAME);
	System.setProperty("para.cluster_name", ROOT_APP_NAME);
	EmbeddedCassandraServerHelper.startEmbeddedCassandra(15 * 1000);
	CassandraUtils.createTable(ROOT_APP_NAME);
	CassandraUtils.createTable(appid1);
	CassandraUtils.createTable(appid2);
	CassandraUtils.createTable(appid3);
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException, URISyntaxException  {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(9142).build();
    Session session = cluster.connect();
    CQLDataLoader dataLoader = new CQLDataLoader(session);
    dataLoader.load(new ClassPathCQLDataSet("config/cql/create-tables.cql", true, CASSANDRA_UNIT_KEYSPACE));
    applyScripts(dataLoader, "config/cql/changelog/", "*.cql");
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void startServer() throws InterruptedException, TTransportException, ConfigurationException, IOException, URISyntaxException  {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(CASSANDRA_TIMEOUT);
    Cluster cluster = new Cluster.Builder().addContactPoints("127.0.0.1").withPort(9142).build();
    Session session = cluster.connect();
    String createQuery = "CREATE KEYSPACE " + CASSANDRA_UNIT_KEYSPACE + " WITH replication={'class' : 'SimpleStrategy', 'replication_factor':1}";
    session.execute(createQuery);
    String useKeyspaceQuery = "USE " + CASSANDRA_UNIT_KEYSPACE;
    session.execute(useKeyspaceQuery);
    CQLDataLoader dataLoader = new CQLDataLoader(session);
    applyScripts(dataLoader, "config/cql/changelog/", "*.cql");
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
private static Session startEmbeddedCassandra(boolean disableCassandra) {
    if (disableCassandra) {
        logger.warn("Embedded cassandra is NOT starting up because your app configuration explicitly requests "
                    + "that it be disabled.");
        return null;
    }

    if (cassandraSession == null) {
        File cassandraWorkDir = new File(embeddedClusterWorkDirectory);
        if (!cassandraWorkDir.exists()) {
            logger.info("Creating the  embedded Cassandra folders...{}", cassandraWorkDir.getAbsolutePath());
            //noinspection ResultOfMethodCallIgnored
            cassandraWorkDir.mkdirs();
        }
        // Start embedded cassandra
        logger.info("Finished Creating the  embedded Cassandra folders...{}",
                    cassandraWorkDir.getAbsolutePath());
        logger.info("Starting embedded Cassandra");

        try {
            EmbeddedCassandraServerHelper.startEmbeddedCassandra(cassandraYamlFile,
                                                                 embeddedClusterWorkDirectory);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }

        Cluster cassandraCluster = Cluster.builder()
                                          .addContactPoint(embeddedClusterContactPointHost)
                                          .withPort(embeddedClusterContactPointPort)
                                          .build();
        cassandraSession = cassandraCluster.connect();
    }

    return cassandraSession;
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void setUp() throws Exception {
    // create the embedded cassandra instance and connect to it
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();
    sut.host = "localhost";
    sut.port = 9142;
    sut.connect();
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public void setup()
        throws Exception
{
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();

    initializeTestData(DATE);

    String connectorId = "cassandra-test";
    CassandraConnectorFactory connectorFactory = new CassandraConnectorFactory(
            connectorId,
            ImmutableMap.<String, String>of());

    Connector connector = connectorFactory.create(connectorId, ImmutableMap.of(
            "cassandra.contact-points", HOSTNAME,
            "cassandra.native-protocol-port", Integer.toString(PORT)));

    metadata = connector.getMetadata(CassandraTransactionHandle.INSTANCE);
    assertInstanceOf(metadata, CassandraMetadata.class);

    splitManager = connector.getSplitManager();
    assertInstanceOf(splitManager, CassandraSplitManager.class);

    recordSetProvider = connector.getRecordSetProvider();
    assertInstanceOf(recordSetProvider, CassandraRecordSetProvider.class);

    database = KEYSPACE_NAME.toLowerCase();
    table = new SchemaTableName(database, TABLE_NAME.toLowerCase());
    tableUnpartitioned = new SchemaTableName(database, "presto_test_unpartitioned");
    invalidTable = new SchemaTableName(database, "totally_invalid_table_name");
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
public static DistributedQueryRunner createCassandraQueryRunner(Iterable<TpchTable<?>> tables)
        throws Exception
{
    EmbeddedCassandraServerHelper.startEmbeddedCassandra();

    try (Cluster cluster = CassandraTestingUtils.getCluster();
            com.datastax.driver.core.Session session = cluster.connect()) {
        createOrReplaceKeyspace(session, "tpch");
        createOrReplaceKeyspace(session, "tpch_sampled");
    }

    DistributedQueryRunner queryRunner = new DistributedQueryRunner(createSession(), 4);

    queryRunner.installPlugin(new TpchPlugin());
    queryRunner.createCatalog("tpch", "tpch");

    queryRunner.installPlugin(new SampledTpchPlugin());
    queryRunner.createCatalog("tpch_sampled", "tpch_sampled");

    queryRunner.installPlugin(new CassandraPlugin());
    queryRunner.createCatalog("cassandra", "cassandra", ImmutableMap.of(
            "cassandra.contact-points", "localhost",
            "cassandra.native-protocol-port", "9142",
            "cassandra.allow-drop-table", "true"));

    copyTpchTables(queryRunner, "tpch", TINY_SCHEMA_NAME, createSession(), tables);
    copyTpchTables(queryRunner, "tpch_sampled", TINY_SCHEMA_NAME, createSampledSession(), tables);

    return queryRunner;
}
 

import org.cassandraunit.utils.EmbeddedCassandraServerHelper; //导入方法依赖的package包/类
@BeforeClass
public static void setupCassandra() throws ConfigurationException, IOException, TTransportException, InterruptedException {
    EmbeddedCassandraServerHelper.startEmbeddedCassandra(EmbeddedCassandraServerHelper.CASSANDRA_RNDPORT_YML_FILE);
    binaryPort = EmbeddedCassandraServerHelper.getNativeTransportPort();

    cluster = Cluster.builder()
            .addContactPoints(CASSANDRA_HOSTS)
            .withPort(binaryPort)
            .withCredentials(username, password)
            .build();
    session = cluster.connect();
}