LatencyAwarePolicyTest()
: ccm_(new CCM::Bridge("config.txt"))
, cluster_(cass_cluster_new())
, thread_() {
uv_mutex_init(&lock_);
uv_cond_init(&condition_);
// Create the cluster
if (ccm_->create_cluster(3)) {
ccm_->start_cluster();
}
// Initialize the cluster for latency aware
cass_cluster_set_reconnect_wait_time(cluster_.get(), 1);
cass_cluster_set_connect_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
cass_cluster_set_request_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 3, 0);
cass_cluster_set_latency_aware_routing(cluster_.get(), cass_true);
cass_cluster_set_latency_aware_routing_settings(cluster_.get(), 1e6, 1, 1, 1, 1);
// Handle deprecated and removed protocol versions [CASSANDRA-10146]
// https://issues.apache.org/jira/browse/CASSANDRA-10146
int protocol_version = 1;
if (test_utils::get_version() >= "3.0.0") {
protocol_version = 3;
}
cass_cluster_set_protocol_version(cluster_.get(), protocol_version); // Protocol for this test doesn't matter so simply support all C* versions
// Connect to the cluster
session_ = test_utils::create_session(cluster_.get());
}
void invalid_credentials(int protocol_version, const char* username,
const char* password, const char* expected_error,
CassError expected_code) {
test_utils::CassLog::reset(expected_error);
cass_cluster_set_protocol_version(cluster.get(), protocol_version);
cass_cluster_set_credentials(cluster.get(), username, password);
{
CassError code;
test_utils::CassSessionPtr temp_session(test_utils::create_session(cluster.get(), &code));
BOOST_CHECK_EQUAL(expected_code, code);
}
BOOST_CHECK(test_utils::CassLog::message_count() > 0);
}
void auth(int protocol_version) {
cass_cluster_set_protocol_version(cluster.get(), protocol_version);
cass_cluster_set_credentials(cluster.get(), "cassandra", "cassandra");
test_utils::CassSessionPtr session(test_utils::create_session(cluster.get()));
test_utils::CassResultPtr result;
std::stringstream query;
query << "SELECT * FROM " << (version >= "3.0.0" ? "system_schema.keyspaces" : "system.schema_keyspaces");
test_utils::execute_query(session.get(), query.str().c_str(), &result);
BOOST_CHECK(cass_result_row_count(result.get()) > 0);
}
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);
}
int main(int argc, char* argv[]) {
CassCluster* cluster = NULL;
CassSession* session = cass_session_new();
CassFuture* close_future = NULL;
char* hosts = "127.0.0.1";
const char* items[] = { "apple", "orange", "banana", "mango", NULL };
cass_cluster_set_protocol_version(cluster, 2);
if (argc > 1) {
hosts = argv[1];
}
cluster = create_cluster(hosts);
if (connect_session(session, cluster) != CASS_OK) {
cass_cluster_free(cluster);
cass_session_free(session);
return -1;
}
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '1' };");
execute_query(session,
"CREATE TABLE examples.collections (key text, \
items set<text>, \
PRIMARY KEY (key))");
insert_into_collections(session, "test", items);
select_from_collections(session, "test");
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
bool Connection::open()
{
if (_is_open) {
return true;
}
CassCluster* cluster = cass_cluster_new();
cass_cluster_set_protocol_version(cluster, 2);
cass_cluster_set_contact_points(cluster, _host_string);
cass_cluster_set_port(cluster, _port);
CassFuture* future = cass_cluster_connect(cluster);
_session = cass_future_get_session(future);
_is_open = cass_future_error_code(future) == CASS_OK && _session != nullptr;
cass_future_free(future);
cass_cluster_free(cluster);
return _is_open;
}
LatencyAwarePolicyTest()
: ccm_(new CCM::Bridge("config.txt"))
, cluster_(cass_cluster_new())
, thread_() {
uv_mutex_init(&lock_);
uv_cond_init(&condition_);
// Create the cluster
if (ccm_->create_cluster(3)) {
ccm_->start_cluster();
}
// Initialize the cluster for latency aware
cass_cluster_set_reconnect_wait_time(cluster_.get(), 1);
cass_cluster_set_connect_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
cass_cluster_set_request_timeout(cluster_.get(), 240 * test_utils::ONE_SECOND_IN_MICROS);
test_utils::initialize_contact_points(cluster_.get(), ccm_->get_ip_prefix(), 3, 0);
cass_cluster_set_latency_aware_routing(cluster_.get(), cass_true);
cass_cluster_set_latency_aware_routing_settings(cluster_.get(), 1e6, 1, 1, 1, 1);
cass_cluster_set_protocol_version(cluster_.get(), 1); // Protocol for this test doesn't matter so simply support all C* versions
// Connect to the cluster
session_ = test_utils::create_session(cluster_.get());
}
/**
* Assign the use of a particular binary protocol version; driver will
* automatically downgrade to the lowest server supported version on
* connection
*
* @param protocol_version Binary protocol version
* @return Cluster object
*/
Cluster& with_protocol_version(int protocol_version) {
EXPECT_EQ(CASS_OK, cass_cluster_set_protocol_version(get(),
protocol_version));
return *this;
}
