CassCluster* create_cluster() {
CassCluster* cluster = cass_cluster_new();
cass_cluster_set_contact_points(cluster, "127.0.0.1");
cass_cluster_set_credentials(cluster, "cassandra", "cassandra");
cass_cluster_set_num_threads_io(cluster, NUM_IO_WORKER_THREADS);
cass_cluster_set_queue_size_io(cluster, 10000);
cass_cluster_set_pending_requests_low_water_mark(cluster, 5000);
cass_cluster_set_pending_requests_high_water_mark(cluster, 10000);
cass_cluster_set_core_connections_per_host(cluster, 1);
cass_cluster_set_max_connections_per_host(cluster, 2);
cass_cluster_set_max_requests_per_flush(cluster, 10000);
return cluster;
}
MultipleNodesTest::MultipleNodesTest(unsigned int num_nodes_dc1, unsigned int num_nodes_dc2, unsigned int protocol_version, bool isSSL /* = false */)
: conf(cql::get_ccm_bridge_configuration()) {
boost::debug::detect_memory_leaks(false);
ccm = cql::cql_ccm_bridge_t::create_and_start(conf, "test", num_nodes_dc1, num_nodes_dc2, isSSL);
version = ccm->version();
uuid_gen = cass_uuid_gen_new();
cluster = cass_cluster_new();
initialize_contact_points(cluster, conf.ip_prefix(), num_nodes_dc1, num_nodes_dc2);
cass_cluster_set_connect_timeout(cluster, 10 * ONE_SECOND_IN_MICROS);
cass_cluster_set_request_timeout(cluster, 30 * ONE_SECOND_IN_MICROS);
cass_cluster_set_core_connections_per_host(cluster, 2);
cass_cluster_set_max_connections_per_host(cluster, 4);
cass_cluster_set_num_threads_io(cluster, 4);
cass_cluster_set_max_concurrent_creation(cluster, 8);
cass_cluster_set_protocol_version(cluster, protocol_version);
}
void CassDriver::CreateCluster() {
int pos = FLAGS_contact_ip_and_port.find(':');
if (pos == std::string::npos) {
printf("Wrong format in contact_ip_and_port, use ip:port !\n");
return;
}
std::string contact_point = FLAGS_contact_ip_and_port.substr(0, pos);
std::string str_port = FLAGS_contact_ip_and_port.substr(pos + 1);
int port = std::atoi(str_port.c_str());
cluster_ = cass_cluster_new();
cass_cluster_set_contact_points(cluster_, contact_point.c_str());
cass_cluster_set_port(cluster_, port);
cass_cluster_set_log_level(cluster_, ParseLogLevel(FLAGS_log_level));
cass_cluster_set_num_threads_io(cluster_, FLAGS_num_threads_io);
cass_cluster_set_queue_size_io(cluster_, FLAGS_queue_size_io);
cass_cluster_set_pending_requests_low_water_mark(cluster_,
FLAGS_pending_req_low);
cass_cluster_set_pending_requests_high_water_mark(cluster_,
FLAGS_pending_req_high);
cass_cluster_set_core_connections_per_host(cluster_, FLAGS_core_connections);
cass_cluster_set_max_connections_per_host(cluster_, FLAGS_max_connections);
}
/**
* Create the Cassandra cluster, initialize the cpp-driver cluster, and create
* the connection to the cluster.
*
* @param is_ssl True if SSL should be enabled on Cassandra cluster; false
* otherwise (default: true)
* @param is_client_authentication True if client authentication should be
* enabled on Cassandra cluster; false otherwise
* (default: false)
* @param is_failure True if test is supposed to fail; false otherwise
* (default: false)
* @param nodes Number of nodes for the cluster (default: 1)
*/
void setup(bool is_ssl = true, bool is_client_authentication = false, bool is_failure = false, unsigned int nodes = 1) {
//Create a n-node cluster
ccm_->create_cluster(nodes, 0, false, is_ssl, is_client_authentication);
ccm_->start_cluster();
//Initialize the cpp-driver
cluster_ = cass_cluster_new();
test_utils::initialize_contact_points(cluster_, ccm_->get_ip_prefix(), nodes);
cass_cluster_set_connect_timeout(cluster_, 10000);
cass_cluster_set_request_timeout(cluster_, 10000);
cass_cluster_set_num_threads_io(cluster_, 1);
cass_cluster_set_core_connections_per_host(cluster_, 2);
cass_cluster_set_max_connections_per_host(cluster_, 4);
cass_cluster_set_ssl(cluster_, ssl_);
//Establish the connection (if ssl)
session_ = cass_session_new();
connect_future_ = cass_session_connect(session_, cluster_);
if (!is_failure) {
test_utils::wait_and_check_error(connect_future_);
} else {
BOOST_REQUIRE(!cass_future_wait_timed(connect_future_, 2000)); //Ensure the wait is long enough for slow machines
}
}
