LIBCOUCHBASE_API
lcb_error_t lcb_unlock(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_unlock_cmd_t *const *items)
{
lcb_size_t ii;
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
for (ii = 0; ii < num; ++ii) {
lcb_server_t *server;
protocol_binary_request_no_extras req;
int vb, idx;
const void *hashkey = items[ii]->v.v0.hashkey;
lcb_size_t nhashkey = items[ii]->v.v0.nhashkey;
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
lcb_cas_t cas = items[ii]->v.v0.cas;
if (nhashkey == 0) {
hashkey = key;
nhashkey = nkey;
}
(void)vbucket_map(instance->vbucket_config, hashkey, nhashkey,
&vb, &idx);
if (idx < 0 || idx > (int)instance->nservers) {
return lcb_synchandler_return(instance, LCB_NO_MATCHING_SERVER);
}
server = instance->servers + idx;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.vbucket = ntohs((lcb_uint16_t)vb);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)(nkey));
req.message.header.request.cas = cas;
req.message.header.request.opaque = ++instance->seqno;
req.message.header.request.opcode = CMD_UNLOCK_KEY;
lcb_server_start_packet(server, command_cookie, req.bytes,
sizeof(req.bytes));
lcb_server_write_packet(server, key, nkey);
lcb_server_end_packet(server);
lcb_server_send_packets(server);
}
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
LIBCOUCHBASE_API
lcb_error_t lcb_compact(lcb_t instance,
const void *command_cookie, uint16_t vb, uint64_t purge_before_ts, uint64_t purge_before_seq, uint8_t drop_deletes)
{
fprintf(stderr,"inside compact method..\n");
lcb_server_t *server;
protocol_binary_request_hello req;
lcb_size_t headersize;
server = instance->servers;
uint16_t keylen = 0;
uint32_t bodylen = 0;
//const void *key = useragent;
fprintf(stderr,"setting the useragent..\n");
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_COMPACTDB;
req.message.header.request.keylen = ntohs(keylen);
req.message.header.request.extlen = 24;
req.message.header.request.vbucket = ntohs((lcb_uint16_t)vb);
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.opaque = ++instance->seqno;
struct compact_st {
uint64_t pbs;
uint64_t pbseq;
uint8_t dds;
uint8_t bytes[7];
};
struct compact_st* compact_t;
compact_t = malloc(sizeof(struct compact_st));
compact_t->pbs = htonll(purge_before_ts);
compact_t->pbseq = htonll(purge_before_seq);
compact_t->dds = drop_deletes;
//uint8_t bytes[24];
// Make it known that this was a success.
lcb_error_handler(instance, LCB_SUCCESS, NULL);
req.message.header.request.bodylen = htonl(bodylen);
//fprintf(stderr,"after setting bodylen..");
lcb_server_start_packet(server, NULL, &req, sizeof(req.message.header));
//fprintf(stderr,"after starting packet..");
lcb_server_write_packet(server, compact_t, (lcb_size_t)sizeof(struct compact_st));
//fprintf(stderr,"after writing key..");
// lcb_server_write_packet(server, compact_t, (lcb_size_t)sizeof(bytes));
//fprintf(stderr,"after writing feature..");
lcb_server_end_packet(server);
//fprintf(stderr,"after end packet..");
lcb_server_send_packets(server);
//fprintf(stderr,"after sending packet..");
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
static lcb_error_t schedule_next_request(cccp_provider *cccp,
lcb_error_t err,
int can_rollover)
{
lcb_server_t *server = NULL;
lcb_size_t ii;
lcb_host_t *next_host = hostlist_shift_next(cccp->nodes, can_rollover);
if (!next_host) {
lcb_timer_disarm(cccp->timer);
lcb_confmon_provider_failed(&cccp->base, err);
cccp->server_active = 0;
return err;
}
/** See if we can find a server */
for (ii = 0; ii < cccp->instance->nservers; ii++) {
lcb_server_t *cur = cccp->instance->servers + ii;
if (lcb_host_equals(&cur->curhost, next_host)) {
server = cur;
break;
}
}
if (server) {
protocol_binary_request_get_cluster_config req;
cccp_cookie *cookie = calloc(1, sizeof(*cookie));
lcb_log(LOGARGS(cccp, INFO),
"Re-Issuing CCCP Command on server struct %p", server);
cookie->parent = cccp;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.opcode = CMD_GET_CLUSTER_CONFIG;
req.message.header.request.opaque = ++cccp->instance->seqno;
lcb_server_start_packet(server, cookie, &req, sizeof(req.bytes));
lcb_server_end_packet(server);
lcb_server_send_packets(server);
lcb_timer_rearm(cccp->timer, PROVIDER_SETTING(&cccp->base,
config_node_timeout));
} else {
cccp->cur_connreq = calloc(1, sizeof(*cccp->cur_connreq));
connmgr_req_init(cccp->cur_connreq, next_host->host, next_host->port,
socket_connected);
cccp->cur_connreq->data = cccp;
connmgr_get(cccp->instance->memd_sockpool, cccp->cur_connreq,
PROVIDER_SETTING(&cccp->base, config_node_timeout));
}
cccp->server_active = 1;
return LCB_SUCCESS;
}
LIBCOUCHBASE_API
lcb_error_t lcb_hello(lcb_t instance,
const void *command_cookie)
{
fprintf(stderr,"inside hello method..\n");
lcb_server_t *server;
protocol_binary_request_hello req;
lcb_size_t headersize;
lcb_size_t bodylen;
server = instance->servers;
const char *useragent = "my prototype";
uint16_t feature = htons(PROTOCOL_BINARY_FEATURE_DATATYPE);
/*const void *key = useragent;*/
fprintf(stderr,"setting the useragent..\n");
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_HELLO;
req.message.header.request.keylen = ntohs(strlen(useragent));
req.message.header.request.extlen = 0;
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.opaque = ++instance->seqno;
/* Make it known that this was a success. */
lcb_error_handler(instance, LCB_SUCCESS, NULL);
req.message.header.request.bodylen = htonl((uint32_t)(strlen(useragent) + sizeof(feature)));
/*fprintf(stderr,"after setting bodylen..");*/
lcb_server_start_packet(server, NULL, &req, sizeof(req.message.header));
/*fprintf(stderr,"after starting packet..");*/
lcb_server_write_packet(server, useragent, (lcb_size_t)strlen(useragent));
/*fprintf(stderr,"after writing key.."); */
lcb_server_write_packet(server, &feature, (lcb_size_t)sizeof(feature));
/*fprintf(stderr,"after writing feature.."); */
lcb_server_end_packet(server);
/*fprintf(stderr,"after end packet.."); */
lcb_server_send_packets(server);
/*fprintf(stderr,"after sending packet.."); */
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
/**
* Spool a store request
*
* @author Trond Norbye
* @todo add documentation
* @todo fix the expiration so that it works relative/absolute etc..
* @todo we might want to wait to write the data to the sockets if the
* user want to run a batch of store requests?
*/
LIBCOUCHBASE_API
lcb_error_t lcb_store(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_store_cmd_t *const *items)
{
lcb_size_t ii;
lcb_error_t err;
vbcheck_ctx vbc;
VBC_SANITY(instance);
err = vbcheck_ctx_init(&vbc, instance, num);
if (err != LCB_SUCCESS) {
return lcb_synchandler_return(instance, err);
}
for (ii = 0; ii < num; ii++) {
const void *k;
lcb_size_t n;
VBC_GETK0(items[ii], k, n);
err = vbcheck_populate(&vbc, instance, ii, k, n);
if (err != LCB_SUCCESS) {
vbcheck_ctx_clean(&vbc);
return lcb_synchandler_return(instance, err);
}
}
for (ii = 0; ii < num; ++ii) {
lcb_server_t *server;
protocol_binary_request_set req;
lcb_size_t headersize;
lcb_size_t bodylen;
lcb_storage_t operation = items[ii]->v.v0.operation;
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
lcb_cas_t cas = items[ii]->v.v0.cas;
lcb_uint32_t flags = items[ii]->v.v0.flags;
lcb_time_t exp = items[ii]->v.v0.exptime;
const void *bytes = items[ii]->v.v0.bytes;
lcb_size_t nbytes = items[ii]->v.v0.nbytes;
vbcheck_keyinfo *ki = vbc.ptr_ki + ii;
server = instance->servers + ki->ix;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.extlen = 8;
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.vbucket = ntohs(ki->vb);
req.message.header.request.opaque = ++instance->seqno;
req.message.header.request.cas = cas;
req.message.body.flags = htonl(flags);
req.message.body.expiration = htonl((lcb_uint32_t)exp);
headersize = sizeof(req.bytes);
switch (operation) {
case LCB_ADD:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_ADD;
break;
case LCB_REPLACE:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_REPLACE;
break;
case LCB_SET:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_SET;
break;
case LCB_APPEND:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_APPEND;
req.message.header.request.extlen = 0;
headersize -= 8;
break;
case LCB_PREPEND:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_PREPEND;
req.message.header.request.extlen = 0;
headersize -= 8;
break;
default:
/* We were given an unknown storage operation. */
return lcb_synchandler_return(instance,
lcb_error_handler(instance, LCB_EINVAL,
"Invalid value passed as storage operation"));
}
/* Make it known that this was a success. */
lcb_error_handler(instance, LCB_SUCCESS, NULL);
bodylen = nkey + nbytes + req.message.header.request.extlen;
req.message.header.request.bodylen = htonl((lcb_uint32_t)bodylen);
lcb_server_start_packet(server, command_cookie, &req, headersize);
lcb_server_write_packet(server, key, nkey);
lcb_server_write_packet(server, bytes, nbytes);
lcb_server_end_packet(server);
}
for (ii = 0; ii < instance->nservers; ii++) {
if (vbc.ptr_srv[ii]) {
lcb_server_send_packets(instance->servers + ii);
}
}
vbcheck_ctx_clean(&vbc);
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
/**
* Spool a store request
*
* @author Trond Norbye
* @todo add documentation
* @todo fix the expiration so that it works relative/absolute etc..
* @todo we might want to wait to write the data to the sockets if the
* user want to run a batch of store requests?
*/
LIBCOUCHBASE_API
lcb_error_t lcb_store(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_store_cmd_t *const *items)
{
lcb_size_t ii;
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
for (ii = 0; ii < num; ++ii) {
lcb_server_t *server;
protocol_binary_request_set req;
lcb_size_t headersize;
lcb_size_t bodylen;
int vb, idx;
lcb_storage_t operation = items[ii]->v.v0.operation;
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
lcb_cas_t cas = items[ii]->v.v0.cas;
lcb_uint32_t flags = items[ii]->v.v0.flags;
lcb_time_t exp = items[ii]->v.v0.exptime;
const void *bytes = items[ii]->v.v0.bytes;
lcb_size_t nbytes = items[ii]->v.v0.nbytes;
const void *hashkey = items[ii]->v.v0.hashkey;
lcb_size_t nhashkey = items[ii]->v.v0.nhashkey;
if (nhashkey == 0) {
hashkey = key;
nhashkey = nkey;
}
(void)vbucket_map(instance->vbucket_config, hashkey, nhashkey,
&vb, &idx);
if (idx < 0 || idx > (int)instance->nservers) {
return lcb_synchandler_return(instance, LCB_NO_MATCHING_SERVER);
}
server = instance->servers + idx;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.extlen = 8;
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.vbucket = ntohs((lcb_uint16_t)vb);
req.message.header.request.opaque = ++instance->seqno;
req.message.header.request.cas = cas;
req.message.body.flags = htonl(flags);
req.message.body.expiration = htonl((lcb_uint32_t)exp);
headersize = sizeof(req.bytes);
switch (operation) {
case LCB_ADD:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_ADD;
break;
case LCB_REPLACE:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_REPLACE;
break;
case LCB_SET:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_SET;
break;
case LCB_APPEND:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_APPEND;
req.message.header.request.extlen = 0;
headersize -= 8;
break;
case LCB_PREPEND:
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_PREPEND;
req.message.header.request.extlen = 0;
headersize -= 8;
break;
default:
/* We were given an unknown storage operation. */
return lcb_synchandler_return(instance,
lcb_error_handler(instance, LCB_EINVAL,
"Invalid value passed as storage operation"));
}
/* Make it known that this was a success. */
lcb_error_handler(instance, LCB_SUCCESS, NULL);
bodylen = nkey + nbytes + req.message.header.request.extlen;
req.message.header.request.bodylen = htonl((lcb_uint32_t)bodylen);
TRACE_STORE_BEGIN(&req, key, nkey, bytes, nbytes, flags, exp);
lcb_server_start_packet(server, command_cookie, &req, headersize);
lcb_server_write_packet(server, key, nkey);
lcb_server_write_packet(server, bytes, nbytes);
lcb_server_end_packet(server);
lcb_server_send_packets(server);
}
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
/**
* Send a preformatted packet to the cluster
* This prototype copies the buffers into the internal structures
* instead of just keeping a reference...
*/
LIBCOUCHBASE_API
lcb_error_t lcb_forward_packet(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_packet_fwd_cmd_t *const *commands)
{
lcb_size_t ii;
lcb_error_handler(instance, LCB_SUCCESS, NULL);
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
/* Now handle all of the requests */
for (ii = 0; ii < num; ++ii) {
lcb_server_t *server;
protocol_binary_request_no_extras *req;
int idx;
int vb = 0;
/* @todo ensure that we support the current command */
/* @todo currently the entire header needs to be in the first
* chunk */
assert(commands[ii]->v.v0.buffer.iov[0].iov_len >= 24);
/* I need to update the sequence number in the packet! */
req = (void *)commands[ii]->v.v0.buffer.iov[0].iov_base;
vb = ntohs(req->message.header.request.vbucket);
if (commands[ii]->v.v0.to_master) {
idx = vbucket_get_master(instance->vbucket_config, vb);
} else {
idx = vbucket_get_replica(instance->vbucket_config, vb,
commands[ii]->v.v0.replica_index);
}
if (idx < 0 || idx > (int)instance->nservers) {
return lcb_synchandler_return(instance, LCB_NO_MATCHING_SERVER);
}
server = instance->servers + idx;
++instance->seqno;
/* avoid alignment crash by using memcpy */
memcpy(&req->message.header.request.opaque, &instance->seqno, 4);
lcb_server_start_packet(server, command_cookie,
commands[ii]->v.v0.buffer.iov[0].iov_base,
commands[ii]->v.v0.buffer.iov[0].iov_len);
lcb_server_write_packet(server,
commands[ii]->v.v0.buffer.iov[1].iov_base,
commands[ii]->v.v0.buffer.iov[1].iov_len);
lcb_server_end_packet(server);
lcb_server_send_packets(server);
}
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
static lcb_error_t multi_get(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_get_cmd_t *const *items)
{
lcb_server_t *server = NULL;
protocol_binary_request_noop noop;
lcb_size_t ii, *affected_servers = NULL;
struct server_info_st *servers = NULL;
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
affected_servers = calloc(instance->nservers, sizeof(lcb_size_t));
if (affected_servers == NULL) {
return lcb_synchandler_return(instance, LCB_CLIENT_ENOMEM);
}
servers = malloc(num * sizeof(struct server_info_st));
if (servers == NULL) {
free(affected_servers);
return lcb_synchandler_return(instance, LCB_CLIENT_ENOMEM);
}
for (ii = 0; ii < num; ++ii) {
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
const void *hashkey = items[ii]->v.v0.hashkey;
lcb_size_t nhashkey = items[ii]->v.v0.nhashkey;
if (nhashkey == 0) {
hashkey = key;
nhashkey = nkey;
}
(void)vbucket_map(instance->vbucket_config, hashkey, nhashkey,
&servers[ii].vb, &servers[ii].idx);
if (servers[ii].idx < 0 || servers[ii].idx > (int)instance->nservers) {
free(servers);
free(affected_servers);
return lcb_synchandler_return(instance, LCB_NO_MATCHING_SERVER);
}
affected_servers[servers[ii].idx]++;
}
for (ii = 0; ii < num; ++ii) {
protocol_binary_request_gat req;
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
lcb_time_t exp = items[ii]->v.v0.exptime;
lcb_size_t nreq = sizeof(req.bytes);
int vb;
server = instance->servers + servers[ii].idx;
vb = servers[ii].vb;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.vbucket = ntohs((lcb_uint16_t)vb);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)(nkey));
req.message.header.request.opaque = ++instance->seqno;
if (!exp) {
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_GETQ;
nreq -= 4;
} else {
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_GATQ;
req.message.header.request.extlen = 4;
req.message.body.expiration = ntohl((lcb_uint32_t)exp);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)(nkey) + 4);
}
if (items[ii]->v.v0.lock) {
/* the expiration is optional for GETL command */
req.message.header.request.opcode = CMD_GET_LOCKED;
}
lcb_server_start_packet(server, command_cookie, req.bytes, nreq);
lcb_server_write_packet(server, key, nkey);
lcb_server_end_packet(server);
}
free(servers);
memset(&noop, 0, sizeof(noop));
noop.message.header.request.magic = PROTOCOL_BINARY_REQ;
noop.message.header.request.opcode = PROTOCOL_BINARY_CMD_NOOP;
noop.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
/*
** We don't know which server we sent the data to, so examine
** where to send the noop
*/
for (ii = 0; ii < instance->nservers; ++ii) {
if (affected_servers[ii]) {
server = instance->servers + ii;
noop.message.header.request.opaque = ++instance->seqno;
lcb_server_complete_packet(server, command_cookie,
noop.bytes, sizeof(noop.bytes));
lcb_server_send_packets(server);
}
}
free(affected_servers);
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
static lcb_error_t single_get(lcb_t instance,
const void *command_cookie,
const lcb_get_cmd_t *item)
{
lcb_server_t *server;
protocol_binary_request_gat req;
int vb, idx;
lcb_size_t nbytes;
const void *hashkey = item->v.v0.hashkey;
lcb_size_t nhashkey = item->v.v0.nhashkey;
const void *key = item->v.v0.key;
lcb_size_t nkey = item->v.v0.nkey;
lcb_time_t exp = item->v.v0.exptime;
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
if (nhashkey == 0) {
hashkey = key;
nhashkey = nkey;
}
(void)vbucket_map(instance->vbucket_config, hashkey, nhashkey,
&vb, &idx);
if (idx < 0 || idx > (int)instance->nservers) {
return lcb_synchandler_return(instance, LCB_NO_MATCHING_SERVER);
}
server = instance->servers + idx;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.vbucket = ntohs((lcb_uint16_t)vb);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)(nkey));
req.message.header.request.opaque = ++instance->seqno;
if (!exp) {
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_GET;
nbytes = sizeof(req.bytes) - 4;
} else {
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_GAT;
req.message.header.request.extlen = 4;
req.message.body.expiration = ntohl((lcb_uint32_t)exp);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)(nkey) + 4);
nbytes = sizeof(req.bytes);
}
if (item->v.v0.lock) {
/* the expiration is optional for GETL command */
req.message.header.request.opcode = CMD_GET_LOCKED;
}
lcb_server_start_packet(server, command_cookie, req.bytes, nbytes);
lcb_server_write_packet(server, key, nkey);
lcb_server_end_packet(server);
lcb_server_send_packets(server);
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
LIBCOUCHBASE_API
lcb_error_t lcb_observe(lcb_t instance,
const void *command_cookie,
lcb_size_t num,
const lcb_observe_cmd_t *const *items)
{
int vbid, idx, jj;
lcb_size_t ii;
lcb_uint32_t opaque;
struct observe_st *requests;
/* we need a vbucket config before we can start getting data.. */
if (instance->vbucket_config == NULL) {
switch (instance->type) {
case LCB_TYPE_CLUSTER:
return lcb_synchandler_return(instance, LCB_EBADHANDLE);
case LCB_TYPE_BUCKET:
default:
return lcb_synchandler_return(instance, LCB_CLIENT_ETMPFAIL);
}
}
if (instance->dist_type != VBUCKET_DISTRIBUTION_VBUCKET) {
return lcb_synchandler_return(instance, LCB_NOT_SUPPORTED);
}
/* the list of pointers to body buffers for each server */
requests = calloc(instance->nservers, sizeof(struct observe_st));
opaque = ++instance->seqno;
for (ii = 0; ii < num; ++ii) {
const void *key = items[ii]->v.v0.key;
lcb_size_t nkey = items[ii]->v.v0.nkey;
const void *hashkey = items[ii]->v.v0.hashkey;
lcb_size_t nhashkey = items[ii]->v.v0.nhashkey;
if (nhashkey == 0) {
hashkey = key;
nhashkey = nkey;
}
vbid = vbucket_get_vbucket_by_key(instance->vbucket_config, hashkey,
nhashkey);
for (jj = -1; jj < instance->nreplicas; ++jj) {
struct observe_st *rr;
/* it will increment jj to get server index, so (-1 + 1) = 0 (master) */
idx = vbucket_get_replica(instance->vbucket_config, vbid, jj);
if ((idx < 0 || idx > (int)instance->nservers)) {
/* the config says that there is no server yet at that position (-1) */
if (jj == -1) {
/* master node must be available */
destroy_requests(requests, instance->nservers);
return lcb_synchandler_return(instance, LCB_NETWORK_ERROR);
} else {
continue;
}
}
rr = requests + idx;
if (!rr->allocated) {
if (!init_request(rr)) {
destroy_requests(requests, instance->nservers);
return lcb_synchandler_return(instance, LCB_CLIENT_ENOMEM);
}
rr->req.message.header.request.magic = PROTOCOL_BINARY_REQ;
rr->req.message.header.request.opcode = CMD_OBSERVE;
rr->req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
rr->req.message.header.request.opaque = opaque;
}
{
lcb_uint16_t vb = htons((lcb_uint16_t)vbid);
lcb_uint16_t len = htons((lcb_uint16_t)nkey);
ringbuffer_ensure_capacity(&rr->body, sizeof(vb) + sizeof(len) + nkey);
rr->nbody += ringbuffer_write(&rr->body, &vb, sizeof(vb));
rr->nbody += ringbuffer_write(&rr->body, &len, sizeof(len));
rr->nbody += ringbuffer_write(&rr->body, key, nkey);
}
}
}
for (ii = 0; ii < instance->nservers; ++ii) {
struct observe_st *rr = requests + ii;
lcb_server_t *server = instance->servers + ii;
if (rr->allocated) {
char *tmp;
rr->req.message.header.request.bodylen = ntohl((lcb_uint32_t)rr->nbody);
lcb_server_start_packet(server, command_cookie, rr->req.bytes, sizeof(rr->req.bytes));
if (ringbuffer_is_continous(&rr->body, RINGBUFFER_READ, rr->nbody)) {
tmp = ringbuffer_get_read_head(&rr->body);
TRACE_OBSERVE_BEGIN(&rr->req, server->authority, tmp, rr->nbody);
lcb_server_write_packet(server, tmp, rr->nbody);
} else {
tmp = malloc(ringbuffer_get_nbytes(&rr->body));
if (!tmp) {
/* FIXME by this time some of requests might be scheduled */
destroy_requests(requests, instance->nservers);
return lcb_synchandler_return(instance, LCB_CLIENT_ENOMEM);
} else {
ringbuffer_read(&rr->body, tmp, rr->nbody);
TRACE_OBSERVE_BEGIN(&rr->req, server->authority, tmp, rr->nbody);
lcb_server_write_packet(server, tmp, rr->nbody);
}
}
lcb_server_end_packet(server);
lcb_server_send_packets(server);
}
}
destroy_requests(requests, instance->nservers);
return lcb_synchandler_return(instance, LCB_SUCCESS);
}
