/**
* Removes (drops) a secondary index.
*
* ~~~~~~~~~~{.c}
* if ( aerospike_index_remove(&as, &err, NULL, "test", idx_test_demo_bin1") != AEROSPIKE_OK ) {
* fprintf(stderr, "error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
* }
* ~~~~~~~~~~
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param ns The namespace containing the index to be removed.
* @param name The name of the index to be removed.
*
* @return AEROSPIKE_OK if successful or index does not exist. Otherwise an error.
*
* @ingroup index_operations
*/
as_status aerospike_index_remove(
aerospike * as, as_error * err, const as_policy_info * policy,
const char * ns, const char * name)
{
as_error_reset(err);
char ddl[1024];
sprintf(ddl, "sindex-delete:ns=%s;indexname=%s", ns, name);
char* response = NULL;
as_status status = aerospike_info_any(as, err, policy, ddl, &response);
switch (status) {
case AEROSPIKE_OK:
cf_free(response);
break;
case AEROSPIKE_ERR_INDEX_NOT_FOUND:
status = AEROSPIKE_OK;
as_error_reset(err);
break;
default:
break;
}
return status;
}
/**
* Create a new secondary index.
*
* @param as - the aerospike cluster to connect to.
* @param err - the error is populated if the return value is not AEROSPIKE_OK.
* @param policy - the policy to use for this operation. If NULL, then the default policy will be used.
* @param ns - the namespace to be indexed
* @param set - the set to be indexed
* @param bin - the bin to be indexed
* @param type - the type of the bin to be indexed
* @param name - the name of the index
*
* @return AEROSPIKE_OK if successful. AEROSPIKE_ERR_INDEX_FOUND if the index already exists. Otherwise an error.
*/
static as_status aerospike_index_create(
aerospike * as, as_error * err, const as_policy_info * policy,
const char * ns, const char * set, const char * bin, const char * type, const char * name)
{
as_error_reset(err);
char * response = NULL;
int rc = citrusleaf_secondary_index_create(as->cluster, ns, set, name, bin, type, &response);
switch ( rc ) {
case CITRUSLEAF_OK:
as_error_reset(err);
break;
case CITRUSLEAF_FAIL_INDEX_FOUND:
as_error_update(err, AEROSPIKE_ERR_INDEX_FOUND, "Index already exists");
break;
default:
as_error_update(err, AEROSPIKE_ERR_INDEX, "Failure creating index: %s", response);
break;
}
if ( response != NULL ) {
free(response);
response = NULL;
}
return err->code;
}
as_status
aerospike_job_info(
aerospike* as, as_error* err, const as_policy_info* policy, const char* module, uint64_t job_id,
bool stop_if_in_progress, as_job_info* info)
{
as_error_reset(err);
if (! policy) {
policy = &as->config.policies.info;
}
char command[128];
sprintf(command, "jobs:module=%s;cmd=get-job;trid=%" PRIu64 "\n", module, job_id);
info->status = AS_JOB_STATUS_UNDEF;
info->progress_pct = 0;
info->records_read = 0;
as_status status = AEROSPIKE_ERR_CLUSTER;
uint64_t deadline = as_socket_deadline(policy->timeout);
as_cluster* cluster = as->cluster;
as_nodes* nodes = as_nodes_reserve(cluster);
for (uint32_t i = 0; i < nodes->size; i++) {
as_node* node = nodes->array[i];
struct sockaddr_in* sa_in = as_node_get_address(node);
char* response = 0;
status = as_info_command_host(cluster, err, sa_in, command, true, deadline, &response);
if (status == AEROSPIKE_OK) {
as_job_process(response, info);
free(response);
if (stop_if_in_progress && info->status == AS_JOB_STATUS_INPROGRESS) {
break;
}
}
else if (status == AEROSPIKE_ERR_RECORD_NOT_FOUND) {
if (info->status == AS_JOB_STATUS_UNDEF) {
info->status = AS_JOB_STATUS_COMPLETED;
}
as_error_reset(err);
status = AEROSPIKE_OK;
}
else {
if (status != AEROSPIKE_ERR_CLUSTER) {
break;
}
}
}
as_nodes_release(nodes);
return status;
}
/**
* Execute a query and call the callback function for each result item.
*
* @param as - the aerospike cluster to connect to.
* @param err - the error is populated if the return value is not AEROSPIKE_OK.
* @param policy - the policy to use for this operation. If NULL, then the default policy will be used.
* @param query - the query to execute against the cluster
* @param udata - user-data to be passed to the callback
* @param callback - the callback function to call for each result item.
*
* @return AEROSPIKE_OK on success, otherwise an error.
*/
as_status aerospike_query_foreach(
aerospike * as, as_error * err, const as_policy_query * policy,
const as_query * query,
aerospike_query_foreach_callback callback, void * udata)
{
// we want to reset the error so, we have a clean state
as_error_reset(err);
// resolve policies
// as_policy_query p;
// as_policy_query_resolve(&p, &as->config.policies, policy);
if ( aerospike_query_init(as, err) != AEROSPIKE_OK ) {
return err->code;
}
cl_query * clquery = as_query_toclquery(query);
clquery_bridge bridge = {
.udata = udata,
.callback = callback
};
cl_rv rc = citrusleaf_query_foreach(as->cluster, clquery, &bridge, clquery_callback);
cl_query_destroy(clquery);
return as_error_fromrc(err, rc);
}
as_status
aerospike_change_password(aerospike* as, as_error* err, const as_policy_admin* policy, const char* user, const char* password)
{
as_error_reset(err);
char hash[AS_PASSWORD_HASH_SIZE];
as_password_get_constant_hash(password, hash);
if (! user) {
user = as->cluster->user;
}
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, CHANGE_PASSWORD, 3);
p = as_admin_write_field_string(p, USER, user);
p = as_admin_write_field_string(p, OLD_PASSWORD, as->cluster->password);
p = as_admin_write_field_string(p, PASSWORD, hash);
int status = as_admin_execute(as, err, policy, buffer, p);
if (status == 0) {
as_cluster_change_password(as->cluster, user, hash);
}
return status;
}
/**
* Send an info request to the entire cluster.
*
* ~~~~~~~~~~{.c}
* if ( aerospike_info_foreach(&as, &err, NULL, "info", callback, NULL) != AEROSPIKE_OK ) {
* // handle error
* }
* ~~~~~~~~~~
*
* The callback takes a response string. The caller should not free this string.
*
* ~~~~~~~~~~{.c}
* bool callback(const as_error * err, const char * node, char * res, void * udata) {
* // handle response
* }
* ~~~~~~~~~~
*
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param req The info request to send.
* @param callback The function to call when a response is received.
* @param udata User-data to send to the callback.
*
* @return AEROSPIKE_OK on success. Otherwise an error.
*
* @ingroup info_operations
*/
as_status aerospike_info_foreach(
aerospike * as, as_error * err, const as_policy_info * policy,
const char * req,
aerospike_info_foreach_callback callback, void * udata)
{
// we want to reset the error so, we have a clean state
as_error_reset(err);
// resolve policies
as_policy_info p;
as_policy_info_resolve(&p, &as->config.policies, policy);
if ( !as ) {
return AEROSPIKE_ERR;
}
citrusleaf_info_cluster_foreach_data data = {
.callback = callback,
.udata = udata
};
char* error = 0;
int rc = citrusleaf_info_cluster_foreach(
as->cluster, req, p.send_as_is, p.check_bounds, p.timeout, (void *) &data, &error,
citrusleaf_info_cluster_foreach_callback);
if (rc) {
as_strncpy(err->message, error, sizeof(err->message));
free(error);
return as_error_fromrc(err, rc);
}
return AEROSPIKE_OK;
}
/**
* Send an info request to a specific host. The response must be freed by the caller on success.
*
* ~~~~~~~~~~{.c}
* char * res = NULL;
* if ( aerospike_info_host(&as, &err, NULL, "127.0.0.1", 3000, "info", &res) != AEROSPIKE_OK ) {
* // handle error
* }
* else {
* // handle response
* free(res);
* res = NULL;
* }
* ~~~~~~~~~~
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param addr The IP address or hostname to send the request to.
* @param port The port to send the request to.
* @param req The info request to send.
* @param res The response from the node. The response will be a NULL terminated string, allocated by the function, and must be freed by the caller.
*
* @return AEROSPIKE_OK on success. Otherwise an error.
*
* @ingroup info_operations
*/
as_status aerospike_info_host(
aerospike * as, as_error * err, const as_policy_info * policy,
const char * addr, uint16_t port, const char * req,
char ** res)
{
// we want to reset the error so, we have a clean state
as_error_reset(err);
// resolve policies
as_policy_info p;
as_policy_info_resolve(&p, &as->config.policies, policy);
if (! as) {
return AEROSPIKE_ERR;
}
cl_rv rc = citrusleaf_info_auth(as->cluster, (char *) addr, port, (char *) req, res, p.timeout);
if (rc) {
as_strncpy(err->message, *res, sizeof(err->message));
free(*res);
return as_error_fromrc(err, rc);
}
return AEROSPIKE_OK;
}
static bool after(atf_plan * plan) {
if ( ! as ) {
error("aerospike was not initialized");
return false;
}
as_error err;
as_error_reset(&err);
as_status status = aerospike_close(as, &err);
aerospike_destroy(as);
if (g_use_async) {
as_event_close_loops();
}
if (status == AEROSPIKE_OK) {
debug("disconnected from %s:%d", g_host, g_port);
return true;
}
else {
error("%s @ %s[%s:%d]", g_host, g_port, err.message, err.func, err.file, err.line);
return false;
}
}
as_status
aerospike_query_users(aerospike* as, as_error* err, const as_policy_admin* policy, as_user*** users, int* users_size)
{
as_error_reset(err);
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, QUERY_USERS, 0);
as_vector list;
as_vector_init(&list, sizeof(as_user*), 100);
as_status status = as_admin_read_list(as, err, policy, buffer, p, as_parse_users, &list);
if (status == AEROSPIKE_OK) {
// Transfer array to output argument. Do not destroy vector.
*users_size = list.size;
*users = list.list;
}
else {
*users_size = 0;
*users = 0;
as_free_users(&list, 0);
}
return status;
}
static bool after(atf_plan * plan) {
if ( ! as ) {
error("aerospike was not initialized");
return false;
}
as_error err;
as_error_reset(&err);
if ( aerospike_close(as, &err) == AEROSPIKE_OK ) {
info("disconnected from %s:%d", g_host, g_port);
aerospike_destroy(as);
return true;
}
else {
error("%s @ %s[%s:%d]", g_host, g_port, err.message, err.func, err.file, err.line);
aerospike_destroy(as);
return false;
}
return true;
}
as_status
aerospike_scan_async(
aerospike* as, as_error* err, const as_policy_scan* policy, const as_scan* scan, uint64_t* scan_id,
as_async_scan_listener listener, void* udata, as_event_loop* event_loop
)
{
as_error_reset(err);
as_nodes* nodes = as_nodes_reserve(as->cluster);
uint32_t n_nodes = nodes->size;
if (n_nodes == 0) {
as_nodes_release(nodes);
return as_error_set_message(err, AEROSPIKE_ERR_SERVER, "Scan command failed because cluster is empty.");
}
// Reserve each node in cluster.
for (uint32_t i = 0; i < n_nodes; i++) {
as_node_reserve(nodes->array[i]);
}
as_status status = as_scan_async(as, err, policy, scan, scan_id, listener, udata, event_loop, nodes->array, n_nodes);
as_nodes_release(nodes);
return status;
}
static bool after(atf_suite * suite) {
as_error err;
as_error_reset(&err);
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_geo");
return true;
}
/**
* Scan the records in the specified namespace and set for a single node.
*
* The callback function will be called for each record scanned. When all records have
* been scanned, then callback will be called with a NULL value for the record.
*
* ~~~~~~~~~~{.c}
* char* node_names = NULL;
* int n_nodes = 0;
* as_cluster_get_node_names(as->cluster, &n_nodes, &node_names);
*
* if (n_nodes <= 0)
* return <error>;
*
* as_scan scan;
* as_scan_init(&scan, "test", "demo");
*
* if (aerospike_scan_node(&as, &err, NULL, &scan, node_names[0], callback, NULL) != AEROSPIKE_OK ) {
* fprintf(stderr, "error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
* }
*
* free(node_names);
* as_scan_destroy(&scan);
* ~~~~~~~~~~
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param scan The scan to execute against the cluster.
* @param node_name The node name to scan.
* @param callback The function to be called for each record scanned.
* @param udata User-data to be passed to the callback.
*
* @return AEROSPIKE_OK on success. Otherwise an error occurred.
*/
as_status aerospike_scan_node(
aerospike * as, as_error * err, const as_policy_scan * policy,
const as_scan * scan, const char* node_name,
aerospike_scan_foreach_callback callback, void * udata)
{
as_error_reset(err);
if (! policy) {
policy = &as->config.policies.scan;
}
// Retrieve node.
as_node* node = as_node_get_by_name(as->cluster, node_name);
if (! node) {
return as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid node name: %s", node_name);
}
// Create scan command
uint64_t task_id = cf_get_rand64() / 2;
as_buffer argbuffer;
uint16_t n_fields = 0;
size_t size = as_scan_command_size(scan, &n_fields, &argbuffer);
uint8_t* cmd = as_command_init(size);
size = as_scan_command_init(cmd, policy, scan, task_id, n_fields, &argbuffer);
// Initialize task.
uint32_t error_mutex = 0;
as_scan_task task;
task.node = node;
task.cluster = as->cluster;
task.policy = policy;
task.scan = scan;
task.callback = callback;
task.udata = udata;
task.err = err;
task.complete_q = 0;
task.error_mutex = &error_mutex;
task.task_id = task_id;
task.cmd = cmd;
task.cmd_size = size;
// Run scan.
as_status status = as_scan_command_execute(&task);
// Free command memory.
as_command_free(cmd, size);
// Release node.
as_node_release(node);
// If completely successful, make the callback that signals completion.
if (callback && status == AEROSPIKE_OK) {
callback(NULL, udata);
}
return status;
}
as_status aerospike_lset_exists(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
as_boolean *exists)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !exists) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSET) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not lset type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val ); // bump the ref count
as_arraylist_append(&arglist, (as_val *)val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSET_PACKAGE, LDT_SET_OP_EXISTS,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
as_boolean_init(exists, ival==1 ? true: false);
return err->code;
} // aerospike_lset_exists()
// =======================================================================
// Pass in a value into the UDF -- and then get it back. Simple.
// This is used to measure the performance of the end to end
// call infrastructure.
// Pass in LDT Bin and Value.
// Return Value.
// =======================================================================
as_status aerospike_lstack_same(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t in_val,
uint32_t * out_valp)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !out_valp) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/out_valp cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not LSTACK type");
}
// stack allocate the arg list.
// Pass in the LDT Bin and the IN VALUE.
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_arraylist_append_int64(&arglist, in_val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, LDT_STACK_OP_SAME,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
if (ival !=0 ) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"same() Function Failed");
}
*out_valp = (uint32_t)ival;
return err->code;
} // end as_status aerospike_lstack_same()
// =======================================================================
as_status aerospike_lstack_set_capacity(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t elements_capacity
)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !elements_capacity) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/capacity cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_arraylist_append_int64(&arglist, elements_capacity);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, LDT_STACK_OP_CAPACITY_SET,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
if (ival !=0 ) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"capacity setting failed");
}
return err->code;
}
// =======================================================================
static as_status aerospike_lstack_push_internal(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
const char *operation)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !val) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, ldt->module[0] == 0 ? 2 : 3);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val );
as_arraylist_append(&arglist, (as_val *) val);
if (ldt->module[0] != 0) {
as_string ldt_module;
as_string_init(&ldt_module, (char *)ldt->module, false);
as_arraylist_append_string(&arglist, &ldt_module);
}
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, operation,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
// return value is the input
if (p_return_val) {
as_val_destroy(p_return_val);
}
return err->code;
} // end aerospike_lstack_push_internal()
// =======================================================================
// Internal function to handle all of the functions that get an int back
// from a call.
// size()
// one()
// =======================================================================
as_status aerospike_lstack_ask_internal(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, uint32_t *n, const char *operation )
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !n) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/n cannot be null");
}
if (ldt->type != AS_LDT_LSTACK) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not stack type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
// All we need to pass in is the LDT Bin Name
as_arraylist arglist;
as_arraylist_inita(&arglist, 1);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSTACK_PACKAGE, operation,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
int64_t ival = as_integer_getorelse(as_integer_fromval(p_return_val), -1);
as_val_destroy(p_return_val);
if (ival == -1) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"value returned from server not parse-able");
}
*n = (uint32_t)ival;
return err->code;
} // end as_status aerospike_lstack_ask_internal()
as_status
aerospike_drop_role(aerospike* as, as_error* err, const as_policy_admin* policy, const char* role)
{
as_error_reset(err);
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, DROP_ROLE, 1);
p = as_admin_write_field_string(p, ROLE, role);
return as_admin_execute(as, err, policy, buffer, p);
}
as_status
aerospike_revoke_roles(aerospike* as, as_error* err, const as_policy_admin* policy, const char* user, const char** roles, int roles_size)
{
as_error_reset(err);
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, REVOKE_ROLES, 2);
p = as_admin_write_field_string(p, USER, user);
p = as_admin_write_roles(p, roles, roles_size);
return as_admin_execute(as, err, policy, buffer, p);
}
as_status aerospike_llist_find(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * search_val,
as_list ** elements )
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !search_val || !elements) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/search_val/elements cannot be null");
}
if (ldt->type != AS_LDT_LLIST) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not llist type");
}
int list_argc = 2;
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, list_argc);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( search_val ); // bump the ref count so the arraylist_destroy will not reset the search_val
as_arraylist_append(&arglist, (as_val *) search_val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LLIST_PACKAGE, LDT_LIST_OP_FIND,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (!p_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
*elements = (as_list *)p_return_val;
return err->code;
} // aerospike_llist_find()
/**
* Send an info request to a specific socket address. The response must be freed by the caller on success.
*
* ~~~~~~~~~~{.c}
* char * res = NULL;
* if ( aerospike_info_socket_address(&as, &err, NULL, &socket_addr, "info", &res) != AEROSPIKE_OK ) {
* // handle error
* }
* else {
* // handle response
* free(res);
* res = NULL;
* }
* ~~~~~~~~~~
*
* @param as The aerospike instance to use for this operation.
* @param err The as_error to be populated if an error occurs.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param sa_in The IP address and port to send the request to.
* @param req The info request to send.
* @param res The response from the node. The response will be a NULL terminated string, allocated by the function, and must be freed by the caller.
*
* @return AEROSPIKE_OK on success. Otherwise an error.
*
* @ingroup info_operations
*/
as_status aerospike_info_socket_address(
aerospike * as, as_error * err, const as_policy_info * policy,
struct sockaddr_in* sa_in, const char * req,
char ** res)
{
as_error_reset(err);
if (! policy) {
policy = &as->config.policies.info;
}
uint64_t deadline = as_socket_deadline(policy->timeout);
return as_info_command_host(as->cluster, err, sa_in, (char*)req, policy->send_as_is, deadline, res);
}
bool citrusleaf_info_cluster_foreach_callback(const as_node * node, const char * req, char * res, void * udata)
{
if ( ! node ) {
return FALSE;
}
as_error err;
as_error_reset(&err);
citrusleaf_info_cluster_foreach_data * data = (citrusleaf_info_cluster_foreach_data *) udata;
bool result = (data->callback)(&err, node, req, res, data->udata);
return result;
}
/**
* Removes (drops) a secondary index.
*
* @param as The aerospike cluster to connect to.
* @param err The error is populated if the return value is not AEROSPIKE_OK.
* @param policy The policy to use for this operation. If NULL, then the default policy will be used.
* @param ns The namespace of the index to be removed
* @param name The name of the index to be removed
*
* @return AEROSPIKE_OK if successful. Otherwise an error.
*/
as_status aerospike_index_remove(
aerospike * as, as_error * err, const as_policy_info * policy,
const char * ns, const char * name)
{
as_error_reset(err);
char * response = NULL;
int rc = citrusleaf_secondary_index_drop(as->cluster, ns, name, &response);
if ( response != NULL ) {
free(response);
}
return as_error_fromrc(err, rc);
}
bool udf_put(const char * filename) {
FILE * file = fopen(filename,"r");
if ( !file ) {
error("cannot open script file %s : %s", filename, strerror(errno));
return -1;
}
uint8_t * content = (uint8_t *) malloc(SCRIPT_LEN_MAX);
if ( content == NULL ) {
error("malloc failed");
return -1;
}
int size = 0;
uint8_t * buff = content;
int read = (int)fread(buff, 1, 512, file);
while ( read ) {
size += read;
buff += read;
read = (int)fread(buff, 1, 512, file);
}
fclose(file);
as_bytes udf_content;
as_bytes_init_wrap(&udf_content, content, size, true);
as_error err;
as_error_reset(&err);
as_string filename_string;
const char * base = as_basename(&filename_string, filename);
if ( aerospike_udf_put(as, &err, NULL, base, AS_UDF_TYPE_LUA, &udf_content) == AEROSPIKE_OK ) {
aerospike_udf_put_wait(as, &err, NULL, base, 100);
}
else {
error("error caused by aerospike_udf_put(): (%d) %s @ %s[%s:%d]", err.code, err.message, err.func, err.file, err.line);
}
as_string_destroy(&filename_string);
as_val_destroy(&udf_content);
return err.code == AEROSPIKE_OK;
}
/**
* Destroy 9 indexes.
*/
bool query_foreach_destroy()
{
as_error err;
as_error_reset(&err);
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_a");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_b");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_c");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_d");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_x");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_y");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_y1");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
aerospike_index_remove(as, &err, NULL, NAMESPACE, "idx_test_z");
if ( err.code != AEROSPIKE_OK ) {
info("error(%d): %s", err.code, err.message);
}
return true;
}
as_status
aerospike_create_role(aerospike* as, as_error* err, const as_policy_admin* policy, const char* role, as_privilege** privileges, int privileges_size)
{
as_error_reset(err);
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, CREATE_ROLE, 2);
p = as_admin_write_field_string(p, ROLE, role);
as_status status = as_admin_write_privileges(&p, err, privileges, privileges_size);
if (status) {
return status;
}
return as_admin_execute(as, err, policy, buffer, p);
}
as_status
aerospike_create_user(aerospike* as, as_error* err, const as_policy_admin* policy, const char* user, const char* password, const char** roles, int roles_size)
{
as_error_reset(err);
char hash[AS_PASSWORD_HASH_SIZE];
as_password_get_constant_hash(password, hash);
uint8_t buffer[AS_STACK_BUF_SIZE];
uint8_t* p = buffer + 8;
p = as_admin_write_header(p, CREATE_USER, 3);
p = as_admin_write_field_string(p, USER, user);
p = as_admin_write_field_string(p, PASSWORD, hash);
p = as_admin_write_roles(p, roles, roles_size);
return as_admin_execute(as, err, policy, buffer, p);
}
as_status aerospike_llist_remove(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val *val
)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/capacity cannot be null");
}
if (ldt->type != AS_LDT_LLIST) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not llist type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val );
as_arraylist_append(&arglist, (as_val *) val);
as_val* p_return_val = NULL;
aerospike_key_apply(
as, err, policy, key, DEFAULT_LLIST_PACKAGE, LDT_LIST_OP_REMOVE,
(as_list *)&arglist, &p_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (p_return_val != NULL) {
as_val_destroy(p_return_val);
}
return err->code;
}
as_status aerospike_lset_get(
aerospike * as, as_error * err, const as_policy_apply * policy,
const as_key * key, const as_ldt * ldt, const as_val * val,
as_val **pp_return_val)
{
if ( !err ) {
return AEROSPIKE_ERR_PARAM;
}
as_error_reset(err);
if (!as || !key || !ldt || !pp_return_val) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"as/key/ldt/return cannot be null");
}
if (ldt->type != AS_LDT_LSET) {
return as_error_set(err, AEROSPIKE_ERR_PARAM, "invalid parameter. "
"not lset type");
}
/* stack allocate the arg list */
as_string ldt_bin;
as_string_init(&ldt_bin, (char *)ldt->name, false);
as_arraylist arglist;
as_arraylist_inita(&arglist, 2);
as_arraylist_append_string(&arglist, &ldt_bin);
as_val_reserve( val ); // bump the ref count
as_arraylist_append(&arglist, (as_val *)val);
aerospike_key_apply(
as, err, policy, key, DEFAULT_LSET_PACKAGE, LDT_SET_OP_GET,
(as_list *)&arglist, pp_return_val);
as_arraylist_destroy(&arglist);
if (ldt_parse_error(err) != AEROSPIKE_OK) {
return err->code;
}
if (! *pp_return_val) {
return as_error_set(err, AEROSPIKE_ERR_LDT_INTERNAL,
"no value returned from server");
}
return err->code;
} // aerospike_lset_get()
