void lcb_cccp_update2(const void *cookie, lcb_error_t err,
const void *bytes, lcb_size_t nbytes,
const lcb_host_t *origin)
{
cccp_cookie *ck = (cccp_cookie *)cookie;
cccp_provider *cccp = ck->parent;
if (err == LCB_SUCCESS) {
lcb_string ss;
lcb_string_init(&ss);
lcb_string_append(&ss, bytes, nbytes);
err = lcb_cccp_update(&cccp->base, origin->host, &ss);
lcb_string_release(&ss);
if (err != LCB_SUCCESS && ck->ignore_errors == 0) {
mcio_error(cccp, err);
}
} else if (!ck->ignore_errors) {
mcio_error(cccp, err);
}
if (ck == cccp->cmdcookie) {
cccp->cmdcookie = NULL;
}
free(ck);
}
/**
* Invoked when get a NOT_MY_VBUCKET response. If the response contains a JSON
* payload then we refresh the configuration with it.
*
* This function returns 1 if the operation was successfully rescheduled;
* otherwise it returns 0. If it returns 0 then we give the error back to the
* user.
*/
static int
handle_nmv(mc_SERVER *oldsrv, packet_info *resinfo, mc_PACKET *oldpkt)
{
mc_PACKET *newpkt;
protocol_binary_request_header hdr;
lcb_error_t err = LCB_ERROR;
lcb_t instance = oldsrv->instance;
lcb_U16 vbid;
clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
LCB_CLCONFIG_CCCP);
mcreq_read_hdr(oldpkt, &hdr);
vbid = ntohs(hdr.request.vbucket);
lcb_log(LOGARGS(oldsrv, WARN), LOGFMT "NOT_MY_VBUCKET. Packet=%p (S=%u). VBID=%u", LOGID(oldsrv), (void*)oldpkt, oldpkt->opaque, vbid);
/* Notify of new map */
lcb_vbguess_remap(instance, vbid, oldsrv->pipeline.index);
if (PACKET_NBODY(resinfo) && cccp->enabled) {
lcb_string s;
lcb_string_init(&s);
lcb_string_append(&s, PACKET_VALUE(resinfo), PACKET_NVALUE(resinfo));
err = lcb_cccp_update(cccp, mcserver_get_host(oldsrv), &s);
lcb_string_release(&s);
}
if (err != LCB_SUCCESS) {
int bs_options;
if (instance->cur_configinfo->origin == LCB_CLCONFIG_CCCP) {
/**
* XXX: Not enough to see if cccp was enabled, since cccp might
* be requested by a user, but would still not actually be active
* for clusters < 2.5 If our current config is from CCCP
* then we can be fairly certain that CCCP is indeed working.
*
* For this reason, we don't use if (cccp->enabled) {...}
*/
bs_options = LCB_BS_REFRESH_THROTTLE;
} else {
bs_options = LCB_BS_REFRESH_ALWAYS;
}
lcb_bootstrap_common(instance, bs_options);
}
if (!lcb_should_retry(oldsrv->settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
return 0;
}
/** Reschedule the packet again .. */
newpkt = mcreq_renew_packet(oldpkt);
newpkt->flags &= ~MCREQ_STATE_FLAGS;
lcb_retryq_nmvadd(instance->retryq, (mc_EXPACKET*)newpkt);
return 1;
}
/**
* Invoked when get a NOT_MY_VBUCKET response. If the response contains a JSON
* payload then we refresh the configuration with it.
*
* This function returns 1 if the operation was successfully rescheduled;
* otherwise it returns 0. If it returns 0 then we give the error back to the
* user.
*/
static int
handle_nmv(mc_SERVER *oldsrv, packet_info *resinfo, mc_PACKET *oldpkt)
{
mc_PACKET *newpkt;
protocol_binary_request_header hdr;
lcb_error_t err = LCB_ERROR;
lcb_t instance = oldsrv->instance;
lcb_U16 vbid;
int tmpix;
clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
LCB_CLCONFIG_CCCP);
mcreq_read_hdr(oldpkt, &hdr);
vbid = ntohs(hdr.request.vbucket);
lcb_log(LOGARGS(oldsrv, WARN), LOGFMT "NOT_MY_VBUCKET. Packet=%p (S=%u). VBID=%u", LOGID(oldsrv), (void*)oldpkt, oldpkt->opaque, vbid);
/* Notify of new map */
tmpix = lcb_vbguess_remap(LCBT_VBCONFIG(instance),
instance->vbguess, vbid, oldsrv->pipeline.index);
if (tmpix > -1 && tmpix != oldsrv->pipeline.index) {
lcb_log(LOGARGS(oldsrv, TRACE), LOGFMT "Heuristically set IX=%d as master for VBID=%u", LOGID(oldsrv), tmpix, vbid);
}
if (PACKET_NBODY(resinfo) && cccp->enabled) {
lcb_string s;
lcb_string_init(&s);
lcb_string_append(&s, PACKET_VALUE(resinfo), PACKET_NVALUE(resinfo));
err = lcb_cccp_update(cccp, mcserver_get_host(oldsrv), &s);
lcb_string_release(&s);
}
if (err != LCB_SUCCESS) {
lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
}
if (!lcb_should_retry(oldsrv->settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
return 0;
}
/** Reschedule the packet again .. */
newpkt = mcreq_renew_packet(oldpkt);
newpkt->flags &= ~MCREQ_STATE_FLAGS;
lcb_retryq_add(instance->retryq, (mc_EXPACKET*)newpkt, LCB_NOT_MY_VBUCKET);
return 1;
}
static void io_read_handler(lcb_connection_t conn)
{
packet_info pi;
cccp_provider *cccp = conn->data;
lcb_string jsonstr;
lcb_error_t err;
int rv;
lcb_host_t curhost;
memset(&pi, 0, sizeof(pi));
rv = lcb_packet_read_ringbuffer(&pi, conn->input);
if (rv < 0) {
LOG(cccp, ERR, "Couldn't parse packet!?");
mcio_error(cccp, LCB_EINTERNAL);
return;
} else if (rv == 0) {
lcb_sockrw_set_want(conn, LCB_READ_EVENT, 1);
lcb_sockrw_apply_want(conn);
return;
}
if (PACKET_STATUS(&pi) != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
lcb_log(LOGARGS(cccp, ERR),
"CCCP Packet responded with 0x%x; nkey=%d, nbytes=%lu, cmd=0x%x, seq=0x%x",
PACKET_STATUS(&pi),
PACKET_NKEY(&pi),
PACKET_NBODY(&pi),
PACKET_OPCODE(&pi),
PACKET_OPAQUE(&pi));
switch (PACKET_STATUS(&pi)) {
case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
mcio_error(cccp, LCB_NOT_SUPPORTED);
break;
default:
mcio_error(cccp, LCB_PROTOCOL_ERROR);
break;
}
return;
}
if (!PACKET_NBODY(&pi)) {
mcio_error(cccp, LCB_PROTOCOL_ERROR);
return;
}
if (lcb_string_init(&jsonstr)) {
mcio_error(cccp, LCB_CLIENT_ENOMEM);
return;
}
if (lcb_string_append(&jsonstr, PACKET_BODY(&pi), PACKET_NBODY(&pi))) {
mcio_error(cccp, LCB_CLIENT_ENOMEM);
return;
}
curhost = *lcb_connection_get_host(&cccp->connection);
lcb_packet_release_ringbuffer(&pi, conn->input);
release_socket(cccp, 1);
err = lcb_cccp_update(&cccp->base, curhost.host, &jsonstr);
lcb_string_release(&jsonstr);
if (err == LCB_SUCCESS) {
lcb_timer_disarm(cccp->timer);
cccp->server_active = 0;
} else {
schedule_next_request(cccp, LCB_PROTOCOL_ERROR, 0);
}
}
/**
* Returns 1 if retried, 0 if the command should fail, -1 for an internal
* error
*/
static int handle_not_my_vbucket(lcb_server_t *c,
packet_info *resinfo,
protocol_binary_request_header *oldreq,
struct lcb_command_data_st *oldct)
{
int idx;
char *body;
lcb_size_t nbody, nr;
lcb_server_t *new_srv;
struct lcb_command_data_st ct;
protocol_binary_request_header req;
hrtime_t now;
lcb_string config_string;
lcb_error_t err = LCB_ERROR;
lcb_log(LOGARGS(c, WARN),
"NOT_MY_VBUCKET; Server=%p,ix=%d,real_start=%lu,vb=%d",
(void *)c, c->index,
(unsigned long)oldct->real_start,
(int)ntohs(oldreq->request.vbucket));
lcb_string_init(&config_string);
if (PACKET_NBODY(resinfo)) {
lcb_string_append(&config_string,
PACKET_VALUE(resinfo),
PACKET_NVALUE(resinfo));
err = lcb_cccp_update(lcb_confmon_get_provider(c->instance->confmon,
LCB_CLCONFIG_CCCP),
c->curhost.host,
&config_string);
}
lcb_string_release(&config_string);
if (err != LCB_SUCCESS) {
lcb_bootstrap_refresh(c->instance);
}
/* re-schedule command to new server */
if (!c->instance->settings.vb_noguess) {
idx = vbucket_found_incorrect_master(c->instance->vbucket_config,
ntohs(oldreq->request.vbucket),
(int)c->index);
} else {
idx = c->index;
}
if (idx == -1) {
lcb_log(LOGARGS(c, ERR), "no alternate server");
return 0;
}
lcb_log(LOGARGS(c, INFO), "Mapped key to new server %d -> %d",
c->index, idx);
now = gethrtime();
if (oldct->real_start) {
hrtime_t min_ok = now - MCSERVER_TIMEOUT(c) * 1000;
if (oldct->real_start < min_ok) {
/** Timed out in a 'natural' manner */
return 0;
}
}
req = *oldreq;
lcb_assert((lcb_size_t)idx < c->instance->nservers);
new_srv = c->instance->servers + idx;
nr = ringbuffer_read(&c->cmd_log, req.bytes, sizeof(req));
lcb_assert(nr == sizeof(req));
req.request.opaque = ++c->instance->seqno;
nbody = ntohl(req.request.bodylen);
body = malloc(nbody);
if (body == NULL) {
lcb_error_handler(c->instance, LCB_CLIENT_ENOMEM, NULL);
return -1;
}
nr = ringbuffer_read(&c->cmd_log, body, nbody);
lcb_assert(nr == nbody);
nr = ringbuffer_read(&c->output_cookies, &ct, sizeof(ct));
lcb_assert(nr == sizeof(ct));
/* Preserve the cookie and reset timestamp for the command. This
* means that the library will retry the command until it will
* get code different from LCB_NOT_MY_VBUCKET */
if (!ct.real_start) {
ct.real_start = ct.start;
}
ct.start = now;
lcb_server_retry_packet(new_srv, &ct, &req, sizeof(req));
/* FIXME dtrace instrumentation */
lcb_server_write_packet(new_srv, body, nbody);
lcb_server_end_packet(new_srv);
lcb_server_send_packets(new_srv);
free(body);
return 1;
}