CassandraFuture connectToCluster(const std::string &contactPoints) const {
/* Add contact points */
cass_cluster_set_contact_points(cluster_.get(), contactPoints.c_str());
/* Provide the cluster object as configuration to connect the session */
return createFuture(cass_session_connect(session_.get(), cluster_.get()));
}
int main(int argc, char* argv[]) {
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cass_cluster_set_contact_points(cluster, hosts);
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
print_keyspace(session, "examples");
execute_query(session,
"CREATE TABLE examples.schema_meta (key text, \
value bigint, \
PRIMARY KEY (key));");
execute_query(session,
"CREATE FUNCTION examples.avg_state(state tuple<int, bigint>, val int) \
CALLED ON NULL INPUT RETURNS tuple<int, bigint> \
LANGUAGE java AS \
'if (val != null) { \
state.setInt(0, state.getInt(0) + 1); \
state.setLong(1, state.getLong(1) + val.intValue()); \
} \
/**
* Open a session and add it to the list of sessions opened
*
* @param arg Session container to add session
*/
static void open_session(void* arg) {
SessionContainer* sessions = static_cast<SessionContainer*>(arg);
test_utils::CassSessionPtr session(cass_session_new());
test_utils::CassFuturePtr session_future(cass_session_connect(session.get(), sessions->cluster));
test_utils::wait_and_check_error(session_future.get(), 20 * test_utils::ONE_SECOND_IN_MICROS);
sessions->add_session(session);
}
int main() {
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
cass_cluster_set_contact_points(cluster, "127.0.0.1");
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
execute_query(session,
"CREATE KEYSPACE examples WITH replication = { \
'class': 'SimpleStrategy', 'replication_factor': '3' };");
print_keyspace(session, "examples");
execute_query(session,
"CREATE TABLE examples.schema_meta (key text, \
value bigint, \
PRIMARY KEY (key));");
print_table(session, "examples", "schema_meta");
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
void DbCassandra::Initialize( const std::string &configPath )
{
ParseConfig( configPath );
const std::string remotes = config_.get<std::string>( "remotes" );
db_ = std::make_shared<DbConnection>();
auto cluster = cass_cluster_new();
db_->SetCluster( cluster );
auto session = cass_session_new();
db_->SetSession( session );
cass_cluster_set_contact_points( cluster, remotes.c_str() );
CassFuture *connect_future = cass_session_connect( session, cluster );
const CassError err = cass_future_error_code( connect_future );
cass_future_free( connect_future );
if ( err != CASS_OK )
throw std::logic_error( cass_error_desc( err ) );
const CassPrepared *prepared = nullptr;
if ( PrepareQuery( session, "INSERT INTO prun.jobs (job_id, job_descr) VALUES (?, ?);", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK )
throw std::logic_error( cass_error_desc( err ) );
db_->SetPreparedInsert( prepared );
if ( PrepareQuery( session, "DELETE FROM prun.jobs WHERE job_id = ?;", reinterpret_cast<const CassPrepared**>( &prepared ) ) != CASS_OK )
throw std::logic_error( cass_error_desc( err ) );
db_->SetPreparedDelete( prepared );
}
CassSessionPtr create_session(CassCluster* cluster, CassError* code, cass_duration_t timeout) {
test_utils::CassSessionPtr session(cass_session_new());
test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster));
if (code) {
*code = test_utils::wait_and_return_error(connect_future.get(), timeout);
}
return session;
}
CassError connect_session(CassSession* session, const CassCluster* cluster) {
CassError rc = CASS_OK;
CassFuture* future = cass_session_connect(session, cluster);
cass_future_wait(future);
rc = cass_future_error_code(future);
if (rc != CASS_OK) {
print_error(future);
}
cass_future_free(future);
return rc;
}
void CCassandraLogAgent::ensureDefaultKeySpace()
{
CassandraSession s(cass_session_new());
CassandraFuture future1(cass_session_connect(s, cassSession->queryCluster()));
future1.wait("connect without keyspace");
VStringBuffer st("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '1' };",
defaultDB.str());
CassandraStatement statement(cass_statement_new(st.str(), 0));
CassandraFuture future2(cass_session_execute(s, statement));
future2.wait("execute");
s.set(NULL);
}
void prepare_alter_schema_version_session() {
// Create a new session for altering node2 and node3 system tables
std::string ip_prefix = inst.ccm->get_ip_prefix();
std::stringstream whitelist_hosts;
whitelist_hosts << ip_prefix << "2," << ip_prefix << "3";
cass_cluster_set_whitelist_filtering(inst.cluster, whitelist_hosts.str().c_str());
schema_alter_session = cass_session_new();
test_utils::CassFuturePtr connect_future(cass_session_connect(schema_alter_session, inst.cluster));
test_utils::wait_and_check_error(connect_future.get());
std::string update_peer("UPDATE system.peers SET schema_version=? WHERE peer='" + ip_prefix + "1'");
test_utils::CassFuturePtr prepared_future(cass_session_prepare_n(schema_alter_session, update_peer.data(), update_peer.size()));
test_utils::wait_and_check_error(prepared_future.get());
schema_alter_prepared = test_utils::CassPreparedPtr(cass_future_get_prepared(prepared_future.get()));
}
/**
* Create the session
*
* @param is_timeout True if for timeout tests; false otherwise
*/
void create_session(bool is_timeout = false) {
close_session();
test_utils::CassSessionPtr session(cass_session_new());
test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster_.get()));
CassError error_code = test_utils::wait_and_return_error(connect_future.get());
session_ = test_utils::create_session(cluster_.get(), &error_code);
if (error_code != CASS_OK) {
if (is_timeout) {
if (error_code == CASS_ERROR_LIB_NO_HOSTS_AVAILABLE) {
return;
}
}
CassString message;
cass_future_error_message(connect_future.get(), &message.data, &message.length);
BOOST_FAIL(std::string(message.data, message.length) << "' (" << cass_error_desc(error_code) << ")");
}
}
//Keep this for now just in case. We may remove after a few releases.
void CCassandraLogAgent::ensureKeySpace()
{
CassandraSession s(cass_session_new());
CassandraFuture future(cass_session_connect(s, cassSession->queryCluster()));
future.wait("connect without keyspace");
VStringBuffer createKeySpace("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '1' };",
cassSession->queryKeySpace());
executeSimpleStatement(createKeySpace.str());
s.set(NULL);
//prepare transSeedTable
StringBuffer transSeedTableKeys;
StringArray transSeedTableColumnNames, transSeedTableColumnTypes;
transSeedTableColumnNames.append("id");
transSeedTableColumnTypes.append("int");
transSeedTableColumnNames.append("application");
transSeedTableColumnTypes.append("varchar");
transSeedTableColumnNames.append("update_time");
transSeedTableColumnTypes.append("timestamp");
transSeedTableKeys.set("application");
cassSession->connect();
createTable("transactions", transSeedTableColumnNames, transSeedTableColumnTypes, transSeedTableKeys.str());
//prepare log tables
ForEachItemIn(i, logDBTables)
{
CDBTable& table = logDBTables.item(i);
StringBuffer logTableKeys;
StringArray logTableColumnNames, logTableColumnTypes;
DBFieldMap* fieldMap = table.getFieldMap();
StringArray& logTableColumnNameArray = fieldMap->getMapToNames();
logTableColumnNames.append("log_id");
logTableColumnTypes.append("varchar");
ForEachItemIn(ii, logTableColumnNameArray)
{
logTableColumnNames.append(logTableColumnNameArray.item(ii));
logTableColumnTypes.append(fieldMap->getMapToTypes().item(ii));
}
CassError CassandraClient::connect(const std::string nodes) {
CassError rc = CASS_OK;
logger.information("Connecting to " + nodes);
cluster = cass_cluster_new();
session = cass_session_new();
CassFuture* connect_future = NULL;
// Optional: use multiple nodes for better load balancing. Just enter more IPs here /re
// cass_cluster_set_contact_points(cluster, "127.0.0.1");
cass_cluster_set_contact_points(cluster, nodes.c_str());
connect_future = cass_session_connect(session, cluster);
cass_future_wait(connect_future);
rc = cass_future_error_code(connect_future);
if (rc == CASS_OK) {
logger.information("Connected!");
} else {
return printError(rc);
}
cass_future_free(connect_future);
return rc;
}
/**
* 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
}
}
PHP_METHOD(DefaultCluster, connectAsync)
{
char* hash_key;
int hash_key_len = 0;
char* keyspace = NULL;
int keyspace_len;
cassandra_cluster* cluster = NULL;
cassandra_future_session* future = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &keyspace, &keyspace_len) == FAILURE) {
return;
}
cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC);
object_init_ex(return_value, cassandra_future_session_ce);
future = (cassandra_future_session*) zend_object_store_get_object(return_value TSRMLS_CC);
future->persist = cluster->persist;
if (cluster->persist) {
zend_rsrc_list_entry *le;
hash_key_len = spprintf(&hash_key, 0,
"%s:session:%s", cluster->hash_key, SAFE_STR(keyspace));
future->hash_key = hash_key;
future->hash_key_len = hash_key_len;
if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS) {
if (Z_TYPE_P(le) == php_le_cassandra_session()) {
cassandra_psession* psession = (cassandra_psession*) le->ptr;
future->session = psession->session;
future->future = psession->future;
return;
}
}
}
future->session = cass_session_new();
if (keyspace) {
future->future = cass_session_connect_keyspace(future->session, cluster->cluster, keyspace);
} else {
future->future = cass_session_connect(future->session, cluster->cluster);
}
if (cluster->persist) {
zend_rsrc_list_entry le;
cassandra_psession* psession =
(cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1);
psession->session = future->session;
psession->future = future->future;
le.type = php_le_cassandra_session();
le.ptr = psession;
zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &le, sizeof(zend_rsrc_list_entry), NULL);
CASSANDRA_G(persistent_sessions)++;
}
}
void new_session() {
close_session();
session = cass_session_new();
test_utils::CassFuturePtr connect_future(cass_session_connect(session, inst.cluster));
test_utils::wait_and_check_error(connect_future.get());
}
PHP_METHOD(DefaultCluster, connect)
{
CassFuture *future = NULL;
char *hash_key;
php5to7_size hash_key_len = 0;
char *keyspace = NULL;
php5to7_size keyspace_len;
zval *timeout = NULL;
cassandra_psession *psession;
cassandra_cluster *cluster = NULL;
cassandra_session *session = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) {
return;
}
cluster = PHP_CASSANDRA_GET_CLUSTER(getThis());
object_init_ex(return_value, cassandra_default_session_ce);
session = PHP_CASSANDRA_GET_SESSION(return_value);
session->default_consistency = cluster->default_consistency;
session->default_page_size = cluster->default_page_size;
session->persist = cluster->persist;
if (!PHP5TO7_ZVAL_IS_UNDEF(session->default_timeout)) {
PHP5TO7_ZVAL_COPY(PHP5TO7_ZVAL_MAYBE_P(session->default_timeout),
PHP5TO7_ZVAL_MAYBE_P(cluster->default_timeout));
}
if (session->persist) {
php5to7_zend_resource_le *le;
hash_key_len = spprintf(&hash_key, 0, "%s:session:%s",
cluster->hash_key, SAFE_STR(keyspace));
if (PHP5TO7_ZEND_HASH_FIND(&EG(persistent_list), hash_key, hash_key_len + 1, le) &&
Z_RES_P(le)->type == php_le_cassandra_session()) {
psession = (cassandra_psession *) Z_RES_P(le)->ptr;
session->session = psession->session;
future = psession->future;
}
}
if (future == NULL) {
php5to7_zend_resource_le resource;
session->session = cass_session_new();
if (keyspace) {
future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace);
} else {
future = cass_session_connect(session->session, cluster->cluster);
}
if (session->persist) {
psession = (cassandra_psession *) pecalloc(1, sizeof(cassandra_psession), 1);
psession->session = session->session;
psession->future = future;
#if PHP_MAJOR_VERSION >= 7
ZVAL_NEW_PERSISTENT_RES(&resource, 0, psession, php_le_cassandra_session());
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, &resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#else
resource.type = php_le_cassandra_session();
resource.ptr = psession;
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#endif
}
}
if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) {
if (session->persist) {
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) {
if (session->persist) {
if (PHP5TO7_ZEND_HASH_DEL(&EG(persistent_list), hash_key, hash_key_len + 1)) {
session->session = NULL;
}
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (session->persist)
efree(hash_key);
}
void SingleSessionTest::create_session() {
session = cass_session_new();
test_utils::CassFuturePtr connect_future(cass_session_connect(session, cluster));
test_utils::wait_and_check_error(connect_future.get());
}
int main(int argc, char* argv[]) {
/* Setup and connect to cluster */
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
CassSsl* ssl = cass_ssl_new();
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
cass_cluster_set_contact_points(cluster, hosts);
/* Only verify the certification and not the identity */
cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_PEER_CERT);
if (!load_trusted_cert_file("cert.pem", ssl)) {
fprintf(stderr, "Failed to load certificate disabling peer verification\n");
cass_ssl_set_verify_flags(ssl, CASS_SSL_VERIFY_NONE);
}
cass_cluster_set_ssl(cluster, ssl);
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
/* Build statement and execute query */
const char* query = "SELECT release_version FROM system.local";
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* result_future = cass_session_execute(session, statement);
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and get the first row */
const CassResult* result = cass_future_get_result(result_future);
const CassRow* row = cass_result_first_row(result);
if (row) {
const CassValue* value = cass_row_get_column_by_name(row, "release_version");
const char* release_version;
size_t release_version_length;
cass_value_get_string(value, &release_version, &release_version_length);
printf("release_version: '%.*s'\n", (int)release_version_length,
release_version);
}
cass_result_free(result);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(result_future, &message, &message_length);
fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
message);
}
cass_statement_free(statement);
cass_future_free(result_future);
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(connect_future, &message, &message_length);
fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
message);
}
cass_future_free(connect_future);
cass_cluster_free(cluster);
cass_session_free(session);
cass_ssl_free(ssl);
return 0;
}
CassSessionPtr create_session(CassCluster* cluster, cass_duration_t timeout) {
test_utils::CassSessionPtr session(cass_session_new());
test_utils::CassFuturePtr connect_future(cass_session_connect(session.get(), cluster));
test_utils::wait_and_check_error(connect_future.get(), timeout);
return session;
}
int main(int argc, char* argv[]) {
/* Setup and connect to cluster */
CassFuture* connect_future = NULL;
CassCluster* cluster = cass_cluster_new();
CassSession* session = cass_session_new();
char* hosts = "127.0.0.1";
if (argc > 1) {
hosts = argv[1];
}
/* Add contact points */
cass_cluster_set_contact_points(cluster, hosts);
/* Provide the cluster object as configuration to connect the session */
connect_future = cass_session_connect(session, cluster);
if (cass_future_error_code(connect_future) == CASS_OK) {
CassFuture* close_future = NULL;
/* Build statement and execute query */
const char* query = "SELECT keyspace_name "
"FROM system.schema_keyspaces;";
CassStatement* statement = cass_statement_new(query, 0);
CassFuture* result_future = cass_session_execute(session, statement);
if (cass_future_error_code(result_future) == CASS_OK) {
/* Retrieve result set and iterate over the rows */
const CassResult* result = cass_future_get_result(result_future);
CassIterator* rows = cass_iterator_from_result(result);
while (cass_iterator_next(rows)) {
const CassRow* row = cass_iterator_get_row(rows);
const CassValue* value = cass_row_get_column_by_name(row, "keyspace_name");
const char* keyspace_name;
size_t keyspace_name_length;
cass_value_get_string(value, &keyspace_name, &keyspace_name_length);
printf("keyspace_name: '%.*s'\n", (int)keyspace_name_length,
keyspace_name);
}
cass_result_free(result);
cass_iterator_free(rows);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(result_future, &message, &message_length);
fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length,
message);
}
cass_statement_free(statement);
cass_future_free(result_future);
/* Close the session */
close_future = cass_session_close(session);
cass_future_wait(close_future);
cass_future_free(close_future);
} else {
/* Handle error */
const char* message;
size_t message_length;
cass_future_error_message(connect_future, &message, &message_length);
fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length,
message);
}
cass_future_free(connect_future);
cass_cluster_free(cluster);
cass_session_free(session);
return 0;
}
/* functions implementing storage api */
static int
librdf_storage_cassandra_init(librdf_storage* storage, const char *name,
librdf_hash* options)
{
char *name_copy;
librdf_storage_cassandra_instance* context;
if(!name) {
if(options)
librdf_free_hash(options);
return 1;
}
context = LIBRDF_CALLOC(librdf_storage_cassandra_instance*, 1,
sizeof(*context));
if(!context) {
if(options)
librdf_free_hash(options);
return 1;
}
librdf_storage_set_instance(storage, context);
context->storage = storage;
context->name_len = strlen(name);
// context->transaction = 0;
name_copy = LIBRDF_MALLOC(char*, context->name_len + 1);
if(!name_copy) {
if(options)
librdf_free_hash(options);
return 1;
}
strcpy(name_copy, name);
context->name = name_copy;
// Add options here.
/* no more options, might as well free them now */
if(options)
librdf_free_hash(options);
// FIXME: Hard-coded;
context->session = cass_session_new();
context->cluster = cass_cluster_new();
cass_cluster_set_contact_points(context->cluster, name);
CassFuture* future = cass_session_connect(context->session,
context->cluster);
CassError rc = cass_future_error_code(future);
if (rc != CASS_OK) {
fprintf(stderr, "Cassandra: %s\n", cass_error_desc(rc));
cass_cluster_free(context->cluster);
cass_session_free(context->session);
free(context->name);
free(context);
return 1;
}
cass_future_free(future);
return 0;
}
void connect_session(CassSession* session, const CassCluster* cluster, CassFutureCallback callback) {
CassFuture* future = cass_session_connect(session, cluster);
cass_future_set_callback(future, callback, session);
cass_future_free(future);
}
PHP_METHOD(DefaultCluster, connect)
{
CassFuture* future = NULL;
char* hash_key;
int hash_key_len = 0;
char* keyspace = NULL;
int keyspace_len;
zval* timeout = NULL;
cassandra_psession* psession;
cassandra_cluster* cluster = NULL;
cassandra_session* session = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sz", &keyspace, &keyspace_len, &timeout) == FAILURE) {
return;
}
cluster = (cassandra_cluster*) zend_object_store_get_object(getThis() TSRMLS_CC);
object_init_ex(return_value, cassandra_default_session_ce);
session = (cassandra_session*) zend_object_store_get_object(return_value TSRMLS_CC);
session->default_consistency = cluster->default_consistency;
session->default_page_size = cluster->default_page_size;
session->default_timeout = cluster->default_timeout;
session->persist = cluster->persist;
if (session->default_timeout) {
Z_ADDREF_P(session->default_timeout);
}
if (session->persist) {
zend_rsrc_list_entry *le;
hash_key_len = spprintf(&hash_key, 0, "%s:session:%s",
cluster->hash_key, SAFE_STR(keyspace));
if (zend_hash_find(&EG(persistent_list), hash_key, hash_key_len + 1, (void **)&le) == SUCCESS &&
Z_TYPE_P(le) == php_le_cassandra_session()) {
psession = (cassandra_psession*) le->ptr;
session->session = psession->session;
future = psession->future;
}
}
if (future == NULL) {
session->session = cass_session_new();
if (keyspace) {
future = cass_session_connect_keyspace(session->session, cluster->cluster, keyspace);
} else {
future = cass_session_connect(session->session, cluster->cluster);
}
if (session->persist) {
zend_rsrc_list_entry pe;
psession = (cassandra_psession*) pecalloc(1, sizeof(cassandra_psession), 1);
psession->session = session->session;
psession->future = future;
pe.type = php_le_cassandra_session();
pe.ptr = psession;
zend_hash_update(&EG(persistent_list), hash_key, hash_key_len + 1, &pe, sizeof(zend_rsrc_list_entry), NULL);
CASSANDRA_G(persistent_sessions)++;
}
}
if (php_cassandra_future_wait_timed(future, timeout TSRMLS_CC) == FAILURE) {
if (session->persist) {
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (php_cassandra_future_is_error(future TSRMLS_CC) == FAILURE) {
if (session->persist) {
if (zend_hash_del(&EG(persistent_list), hash_key, hash_key_len + 1) == SUCCESS) {
session->session = NULL;
}
efree(hash_key);
} else {
cass_future_free(future);
}
return;
}
if (session->persist)
efree(hash_key);
}
PHP_METHOD(DefaultCluster, connectAsync)
{
char *hash_key;
php5to7_size hash_key_len = 0;
char *keyspace = NULL;
php5to7_size keyspace_len;
cassandra_cluster *cluster = NULL;
cassandra_future_session *future = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &keyspace, &keyspace_len) == FAILURE) {
return;
}
cluster = PHP_CASSANDRA_GET_CLUSTER(getThis());
object_init_ex(return_value, cassandra_future_session_ce);
future = PHP_CASSANDRA_GET_FUTURE_SESSION(return_value);
future->persist = cluster->persist;
if (cluster->persist) {
php5to7_zend_resource_le *le;
hash_key_len = spprintf(&hash_key, 0,
"%s:session:%s", cluster->hash_key, SAFE_STR(keyspace));
future->hash_key = hash_key;
future->hash_key_len = hash_key_len;
if (PHP5TO7_ZEND_HASH_FIND(&EG(persistent_list), hash_key, hash_key_len + 1, le)) {
if (Z_TYPE_P(le) == php_le_cassandra_session()) {
cassandra_psession *psession = (cassandra_psession *) Z_RES_P(le)->ptr;
future->session = psession->session;
future->future = psession->future;
return;
}
}
}
future->session = cass_session_new();
if (keyspace) {
future->future = cass_session_connect_keyspace(future->session, cluster->cluster, keyspace);
} else {
future->future = cass_session_connect(future->session, cluster->cluster);
}
if (cluster->persist) {
php5to7_zend_resource_le resource;
cassandra_psession *psession =
(cassandra_psession *) pecalloc(1, sizeof(cassandra_psession), 1);
psession->session = future->session;
psession->future = future->future;
#if PHP_MAJOR_VERSION >= 7
ZVAL_NEW_PERSISTENT_RES(&resource, 0, psession, php_le_cassandra_session());
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, &resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#else
resource.type = php_le_cassandra_session();
resource.ptr = psession;
PHP5TO7_ZEND_HASH_UPDATE(&EG(persistent_list), hash_key, hash_key_len + 1, resource, sizeof(php5to7_zend_resource_le));
CASSANDRA_G(persistent_sessions)++;
#endif
}
}
StressTests() : MultipleNodesTest(3, 0) {
session = cass_session_new();
test_utils::CassFuturePtr session_future(cass_session_connect(session, cluster));
test_utils::wait_and_check_error(session_future.get());
}
