static as_status
as_admin_read_blocks(as_error* err, int fd, uint64_t deadline_ms, as_admin_parse_fn parse_fn, as_vector* list)
{
as_status status = AEROSPIKE_OK;
uint8_t* buf = 0;
size_t capacity = 0;
while (true) {
// Read header
as_proto proto;
status = as_socket_read_deadline(err, fd, (uint8_t*)&proto, sizeof(as_proto), deadline_ms);
if (status) {
break;
}
as_proto_swap_from_be(&proto);
size_t size = proto.sz;
if (size > 0) {
// Prepare buffer
if (size > capacity) {
as_command_free(buf, capacity);
capacity = size;
buf = as_command_init(capacity);
}
// Read remaining message bytes in group
status = as_socket_read_deadline(err, fd, buf, size, deadline_ms);
if (status) {
break;
}
status = parse_fn(err, buf, size, list);
if (status != AEROSPIKE_OK) {
if (status == AEROSPIKE_QUERY_END) {
status = AEROSPIKE_OK;
}
else {
as_error_set_message(err, status, as_error_string(status));
}
break;
}
}
}
as_command_free(buf, capacity);
return status;
}
static as_status
as_scan_parse(as_error* err, int fd, uint64_t deadline_ms, void* udata)
{
as_scan_task* task = udata;
as_status status = AEROSPIKE_OK;
uint8_t* buf = 0;
size_t capacity = 0;
while (true) {
// Read header
as_proto proto;
status = as_socket_read_deadline(err, fd, (uint8_t*)&proto, sizeof(as_proto), deadline_ms);
if (status) {
break;
}
as_proto_swap_from_be(&proto);
size_t size = proto.sz;
if (size > 0) {
// Prepare buffer
if (size > capacity) {
as_command_free(buf, capacity);
capacity = size;
buf = as_command_init(capacity);
}
// Read remaining message bytes in group
status = as_socket_read_deadline(err, fd, buf, size, deadline_ms);
if (status) {
break;
}
status = as_scan_parse_records(buf, size, task, err);
if (status != AEROSPIKE_OK) {
if (status == AEROSPIKE_NO_MORE_RECORDS) {
status = AEROSPIKE_OK;
}
break;
}
}
}
as_command_free(buf, capacity);
return status;
}
/**
* 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
as_command_parse_success_failure(as_error* err, int fd, uint64_t deadline_ms, void* user_data)
{
// Read header
as_proto_msg msg;
as_status status = as_socket_read_deadline(err, fd, (uint8_t*)&msg, sizeof(as_proto_msg), deadline_ms);
if (status) {
return status;
}
as_proto_swap_from_be(&msg.proto);
as_msg_swap_header_from_be(&msg.m);
size_t size = msg.proto.sz - msg.m.header_sz;
uint8_t* buf = 0;
if (size > 0) {
// Read remaining message bytes.
buf = as_command_init(size);
status = as_socket_read_deadline(err, fd, buf, size, deadline_ms);
if (status) {
as_command_free(buf, size);
return status;
}
}
as_val** val = user_data;
// Parse result code and record.
status = msg.m.result_code;
switch (status) {
case AEROSPIKE_OK: {
uint8_t* p = buf;
status = as_command_parse_success_failure_bins(&p, err, &msg.m, val);
if (status != AEROSPIKE_OK) {
if (val) {
*val = 0;
}
}
break;
}
case AEROSPIKE_ERR_UDF: {
status = as_command_parse_udf_failure(buf, err, &msg.m, status);
if (val) {
*val = 0;
}
break;
}
default:
as_error_set_message(err, status, as_error_string(status));
if (val) {
*val = 0;
}
break;
}
as_command_free(buf, size);
return status;
}
as_status
as_command_parse_result(as_error* err, int fd, uint64_t deadline_ms, void* user_data)
{
// Read header
as_proto_msg msg;
as_status status = as_socket_read_deadline(err, fd, (uint8_t*)&msg, sizeof(as_proto_msg), deadline_ms);
if (status) {
return status;
}
as_proto_swap_from_be(&msg.proto);
as_msg_swap_header_from_be(&msg.m);
size_t size = msg.proto.sz - msg.m.header_sz;
uint8_t* buf = 0;
if (size > 0) {
// Read remaining message bytes.
buf = as_command_init(size);
status = as_socket_read_deadline(err, fd, buf, size, deadline_ms);
if (status) {
as_command_free(buf, size);
return status;
}
}
// Parse result code and record.
status = msg.m.result_code;
as_command_parse_result_data* data = user_data;
switch (status) {
case AEROSPIKE_OK: {
if (data->record) {
as_record* rec = *data->record;
if (rec) {
if (msg.m.n_ops > rec->bins.capacity) {
if (rec->bins._free) {
free(rec->bins.entries);
}
rec->bins.capacity = msg.m.n_ops;
rec->bins.size = 0;
rec->bins.entries = malloc(sizeof(as_bin) * msg.m.n_ops);
rec->bins._free = true;
}
}
else {
rec = as_record_new(msg.m.n_ops);
*data->record = rec;
}
rec->gen = msg.m.generation;
rec->ttl = cf_server_void_time_to_ttl(msg.m.record_ttl);
uint8_t* p = as_command_ignore_fields(buf, msg.m.n_fields);
as_command_parse_bins(rec, p, msg.m.n_ops, data->deserialize);
}
break;
}
case AEROSPIKE_ERR_UDF: {
status = as_command_parse_udf_failure(buf, err, &msg.m, status);
break;
}
default:
as_error_set_message(err, status, as_error_string(status));
break;
}
as_command_free(buf, size);
return status;
}
static as_status
as_scan_generic(
aerospike* as, as_error* err, const as_policy_scan* policy, const as_scan* scan,
aerospike_scan_foreach_callback callback, void* udata, uint64_t* task_id_ptr)
{
as_error_reset(err);
if (! policy) {
policy = &as->config.policies.scan;
}
as_cluster* cluster = as->cluster;
as_nodes* nodes = as_nodes_reserve(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]);
}
uint64_t task_id;
if (task_id_ptr) {
if (*task_id_ptr == 0) {
*task_id_ptr = cf_get_rand64() / 2;
}
task_id = *task_id_ptr;
}
else {
task_id = cf_get_rand64() / 2;
}
// Create scan command
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.cluster = as->cluster;
task.policy = policy;
task.scan = scan;
task.callback = callback;
task.udata = udata;
task.err = err;
task.error_mutex = &error_mutex;
task.task_id = task_id;
task.cmd = cmd;
task.cmd_size = size;
as_status status = AEROSPIKE_OK;
if (scan->concurrent) {
uint32_t n_wait_nodes = n_nodes;
task.complete_q = cf_queue_create(sizeof(as_scan_complete_task), true);
// Run node scans in parallel.
for (uint32_t i = 0; i < n_nodes; i++) {
// Stack allocate task for each node. It should be fine since the task
// only needs to be valid within this function.
as_scan_task* task_node = alloca(sizeof(as_scan_task));
memcpy(task_node, &task, sizeof(as_scan_task));
task_node->node = nodes->array[i];
int rc = as_thread_pool_queue_task(&cluster->thread_pool, as_scan_worker, task_node);
if (rc) {
// Thread could not be added. Abort entire scan.
if (ck_pr_fas_32(task.error_mutex, 1) == 0) {
status = as_error_update(task.err, AEROSPIKE_ERR_CLIENT, "Failed to add scan thread: %d", rc);
}
// Reset node count to threads that were run.
n_wait_nodes = i;
break;
}
}
// Wait for tasks to complete.
for (uint32_t i = 0; i < n_wait_nodes; i++) {
as_scan_complete_task complete;
cf_queue_pop(task.complete_q, &complete, CF_QUEUE_FOREVER);
if (complete.result != AEROSPIKE_OK && status == AEROSPIKE_OK) {
status = complete.result;
}
}
// Release temporary queue.
cf_queue_destroy(task.complete_q);
}
else {
task.complete_q = 0;
// Run node scans in series.
for (uint32_t i = 0; i < n_nodes && status == AEROSPIKE_OK; i++) {
task.node = nodes->array[i];
status = as_scan_command_execute(&task);
}
}
// Release each node in cluster.
for (uint32_t i = 0; i < n_nodes; i++) {
as_node_release(nodes->array[i]);
}
// Release nodes array.
as_nodes_release(nodes);
// Free command memory.
as_command_free(cmd, size);
// If user aborts query, command is considered successful.
if (status == AEROSPIKE_ERR_CLIENT_ABORT) {
status = AEROSPIKE_OK;
}
// If completely successful, make the callback that signals completion.
if (callback && status == AEROSPIKE_OK) {
callback(NULL, udata);
}
return status;
}