static void arithmetic_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_arithmetic_resp_t resp;
lcb_uint64_t value = 0;
struct lcb_command_data_st *command_data = &info->ct;
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
return ;
}
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
memcpy(&value, info->payload, sizeof(value));
value = ntohll(value);
}
setup_lcb_arithmetic_resp_t(&resp, key, nkey, value, PACKET_CAS(info));
PACKET_TRACE(TRACE_ARITHMETIC_END, info, rc, &resp);
root->callbacks.arithmetic(root, command_data->cookie, rc, &resp);
release_key(server, packet);
}
static void
H_getreplica(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_error_t rc;
lcb_get_resp_t resp;
lcb_t instance = pipeline->parent->instance;
void *freeptr = NULL;
MK_RESPKEY(&resp, 0, request);
MK_ERROR(instance, rc, response, immerr);
resp.version = 0;
if (rc == LCB_SUCCESS) {
const protocol_binary_response_get *get = PACKET_EPHEMERAL_START(response);
resp.v.v0.cas = PACKET_CAS(response);
resp.v.v0.datatype = PACKET_DATATYPE(response);
resp.v.v0.flags = ntohl(get->message.body.flags);
resp.v.v0.bytes = PACKET_VALUE(response);
resp.v.v0.nbytes = PACKET_NVALUE(response);
}
maybe_decompress(instance, response, &resp, &freeptr);
request->u_rdata.exdata->callback(pipeline, request, rc, &resp);
free(freeptr);
}
static void getq_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_error_t rc;
lcb_get_resp_t resp;
fprintf(stderr, "\n The datatype is ...%d", PACKET_DATATYPE(info));
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
return;
} else if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
const protocol_binary_response_getq *getq = PACKET_EPHEMERAL_START(info);
rc = LCB_SUCCESS;
setup_lcb_get_resp_t(&resp, key, nkey,
PACKET_VALUE(info), PACKET_NVALUE(info),
ntohl(getq->message.body.flags),
PACKET_CAS(info),
PACKET_DATATYPE(info));
} else {
rc = map_error(root, PACKET_STATUS(info));
setup_lcb_get_resp_t(&resp, key, nkey, NULL, 0, 0, 0, 0);
}
root->callbacks.get(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
static void
init_resp3(lcb_t instance, const packet_info *mc_resp, const mc_PACKET *req,
lcb_error_t immerr, lcb_RESPBASE *resp)
{
MK_ERROR(instance, resp, mc_resp, immerr);
resp->cas = PACKET_CAS(mc_resp);
resp->cookie = (void *)MCREQ_PKT_COOKIE(req);
mcreq_get_key(req, &resp->key, &resp->nkey);
}
static void store_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_storage_t op;
char *packet;
lcb_uint16_t nkey;
lcb_error_t rc;
lcb_uint16_t status = PACKET_STATUS(info);
const char *key = get_key(server, &nkey, &packet);
if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
rc = LCB_SUCCESS;
} else {
rc = map_error(root, status);
}
switch (PACKET_OPCODE(info)) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
/*
** It is impossible to get here (since we're called from our
** lookup table... If we _DO_ get here, it must be a development
** version where the developer isn't done yet (and should be
** forced to think about what to do...)
*/
lcb_error_handler(root, LCB_EINTERNAL,
"Internal error. Received an illegal command opcode");
abort();
}
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_store_resp_t resp;
setup_lcb_store_resp_t(&resp, key, nkey, PACKET_CAS(info));
PACKET_TRACE(TRACE_STORE_END, info, rc, &resp);
root->callbacks.store(root, info->ct.cookie, op, rc, &resp);
release_key(server, packet);
}
}
static void
H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_touch_resp_t resp;
lcb_error_t rc;
MK_ERROR(root, rc, response, immerr);
MK_RESPKEY(&resp, 0, request);
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
resp.version = 0;
root->callbacks.touch(root, MCREQ_PKT_RDATA(request)->cookie, rc, &resp);
}
static void
H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_error_t rc;
lcb_remove_resp_t resp;
resp.version = 0;
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
MK_RESPKEY(&resp, 0, packet);
MK_ERROR(root, rc, response, immerr);
INVOKE_CALLBACK(packet, root->callbacks.remove,
(root, MCREQ_PKT_COOKIE(packet), rc, &resp));
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPCOUNTER resp = { 0 };
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&resp);
if (resp.rc == LCB_SUCCESS) {
memcpy(&resp.value, PACKET_VALUE(response), sizeof(resp.value));
resp.value = lcb_ntohll(resp.value);
handle_synctoken(root, response, request, &resp.synctoken);
}
resp.cas = PACKET_CAS(response);
TRACE_ARITHMETIC_END(response, &resp);
INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_COUNTER);
}
static void delete_response_handler(lcb_server_t *server, packet_info *info)
{
lcb_t root = server->instance;
lcb_error_t rc = map_error(root, PACKET_STATUS(info));
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
} else {
lcb_remove_resp_t resp;
setup_lcb_remove_resp_t(&resp, key, nkey, PACKET_CAS(info));
root->callbacks.remove(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
respack_COUNTER w = { { 0 } };
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&w.resp);
if (w.resp.rc == LCB_SUCCESS) {
memcpy(&w.resp.value, PACKET_VALUE(response), sizeof(w.resp.value));
w.resp.value = lcb_ntohll(w.resp.value);
w.resp.rflags |= LCB_RESP_F_EXTDATA;
handle_mutation_token(root, response, request, &w.mt);
}
w.resp.cas = PACKET_CAS(response);
TRACE_ARITHMETIC_END(response, &w.resp);
INVOKE_CALLBACK3(request, &w.resp, root, LCB_CALLBACK_COUNTER);
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_error_t rc;
lcb_arithmetic_resp_t resp;
MK_ERROR(root, rc, response, immerr);
if (rc == LCB_SUCCESS) {
memcpy(&resp.v.v0.value, response->payload, sizeof(resp.v.v0.value));
resp.v.v0.value = ntohll(resp.v.v0.value);
}
MK_RESPKEY(&resp, 0, request);
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
INVOKE_CALLBACK(request, root->callbacks.arithmetic,
(root, MCREQ_PKT_COOKIE(request), rc, &resp));
}
static void touch_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
char *packet;
lcb_uint16_t nkey;
const char *key = get_key(server, &nkey, &packet);
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
if (key == NULL) {
lcb_error_handler(server->instance, LCB_EINTERNAL,
NULL);
} else {
lcb_touch_resp_t resp;
setup_lcb_touch_resp_t(&resp, key, nkey, PACKET_CAS(info));
PACKET_TRACE(TRACE_TOUCH_END, info, rc, &resp);
root->callbacks.touch(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
}
}
static void
H_store(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_storage_t op;
lcb_error_t rc;
lcb_store_resp_t resp;
MK_ERROR(root, rc, response, immerr);
switch (PACKET_OPCODE(response)) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
abort();
break;
}
resp.version = 0;
MK_RESPKEY(&resp, 0, request);
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
INVOKE_CALLBACK(request, root->callbacks.store,
(root, MCREQ_PKT_COOKIE(request), op, rc, &resp));
}
static void
H_get(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_error_t rc;
lcb_t o;
lcb_get_resp_t resp;
void *freeptr = NULL;
o = pipeline->parent->instance;
MK_RESPKEY(&resp, 0, request);
MK_ERROR(o, rc, response, immerr);
resp.version = 0;
if (rc == LCB_SUCCESS) {
const protocol_binary_response_getq *getq =
PACKET_EPHEMERAL_START(response);
resp.v.v0.cas = PACKET_CAS(response);
resp.v.v0.datatype = PACKET_DATATYPE(response);
resp.v.v0.flags = ntohl(getq->message.body.flags);
resp.v.v0.bytes = PACKET_VALUE(response);
resp.v.v0.nbytes = PACKET_NVALUE(response);
rc = LCB_SUCCESS;
} else {
resp.v.v0.cas = 0;
resp.v.v0.nbytes = 0;
resp.v.v0.bytes = NULL;
resp.v.v0.flags = 0;
}
maybe_decompress(o, response, &resp, &freeptr);
INVOKE_CALLBACK(request, o->callbacks.get,
(o, MCREQ_PKT_COOKIE(request), rc, &resp));
free(freeptr);
}
static void get_replica_response_handler(lcb_server_t *server,
packet_info *info)
{
lcb_t root = server->instance;
lcb_uint16_t nkey;
const char *key;
char *packet;
lcb_uint16_t status = PACKET_STATUS(info);
lcb_error_t rc = map_error(root, status);
/**
* Success? always perform the callback
*/
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
const protocol_binary_response_get *get = PACKET_EPHEMERAL_START(info);
lcb_get_resp_t resp;
setup_lcb_get_resp_t(&resp,
PACKET_KEY(info), PACKET_NKEY(info),
PACKET_VALUE(info), PACKET_NVALUE(info),
ntohl(get->message.body.flags),
PACKET_CAS(info),
PACKET_DATATYPE(info));
root->callbacks.get(root, info->ct.cookie, rc, &resp);
return;
}
key = get_key(server, &nkey, &packet);
/**
* Following code handles errors.
*/
if (info->ct.replica == -1) {
/* Perform the callback. Either SELECT or ALL */
lcb_get_resp_t resp;
setup_lcb_get_resp_t(&resp, key, nkey, NULL, 0, 0, 0, 0);
PACKET_TRACE(TRACE_GET_END, info, rc, &resp);
root->callbacks.get(root, info->ct.cookie, rc, &resp);
release_key(server, packet);
return;
}
/** LCB_REPLICA_FIRST */
if (status == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
/**
* the config was updated, start from first replica.
* Reset the iteration count
*/
info->ct.replica = 0;
} else {
info->ct.replica++;
}
if (info->ct.replica < root->nreplicas) {
/* try next replica */
protocol_binary_request_get req;
lcb_server_t *new_server;
int idx = vbucket_get_replica(root->vbucket_config,
info->ct.vbucket,
info->ct.replica);
if (idx < 0 || idx > (int)root->nservers) {
lcb_error_handler(root, LCB_NETWORK_ERROR,
"GET_REPLICA: missing server");
release_key(server, packet);
return;
}
new_server = root->servers + idx;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.opcode = CMD_GET_REPLICA;
req.message.header.request.keylen = ntohs((lcb_uint16_t)nkey);
req.message.header.request.vbucket = ntohs(info->ct.vbucket);
req.message.header.request.bodylen = ntohl((lcb_uint32_t)nkey);
req.message.header.request.opaque = ++root->seqno;
TRACE_GET_BEGIN(&req, key, nkey, 0);
lcb_server_retry_packet(new_server, &info->ct,
req.bytes, sizeof(req.bytes));
lcb_server_write_packet(new_server, key, nkey);
lcb_server_end_packet(new_server);
lcb_server_send_packets(new_server);
} else {
/* give up and report the error */
lcb_get_resp_t resp;
setup_lcb_get_resp_t(&resp, key, nkey, NULL, 0, 0, 0, 0);
PACKET_TRACE(TRACE_GET_END, info, rc, &resp)
root->callbacks.get(root, info->ct.cookie, rc, &resp);
}
release_key(server, packet);
}
