bool protocol_stats_merge_line(genhash_t *merger, char *line) {
int nline;
token_t tokens[MAX_TOKENS];
int ntokens;
char *name;
int name_len;
cb_assert(merger != NULL);
cb_assert(line != NULL);
nline = strlen(line); /* Ex: "STATS uptime 123455" */
if (nline <= 0 ||
nline >= MERGE_BUF_SIZE) {
return false;
}
ntokens = scan_tokens(line, tokens, MAX_TOKENS, NULL);
if (ntokens != 4) { /* 3 + 1 for the terminal token. */
return false;
}
name = tokens[NAME_TOKEN].value;
name_len = tokens[NAME_TOKEN].length;
if (name == NULL ||
name_len <= 0 ||
tokens[VALUE_TOKEN].value == NULL ||
tokens[VALUE_TOKEN].length <= 0 ||
tokens[VALUE_TOKEN].length >= MERGE_BUF_SIZE) {
return false;
}
return protocol_stats_merge_name_val(merger,
tokens[PREFIX_TOKEN].value,
tokens[PREFIX_TOKEN].length,
name, name_len,
tokens[VALUE_TOKEN].value,
tokens[VALUE_TOKEN].length);
}
/* We reach here after nread'ing a header+body into an item.
*/
void cproxy_process_b2b_downstream_nread(conn *c) {
conn *uc;
item *it;
downstream *d;
protocol_binary_response_header *header;
int extlen;
int keylen;
uint32_t bodylen;
int status;
int opcode;
cb_assert(c != NULL);
cb_assert(c->cmd >= 0);
cb_assert(c->next == NULL);
cb_assert(c->cmd_start == NULL);
cb_assert(IS_BINARY(c->protocol));
cb_assert(IS_PROXY(c->protocol));
header = (protocol_binary_response_header *) &c->binary_header;
extlen = header->response.extlen;
keylen = header->response.keylen;
bodylen = header->response.bodylen;
status = ntohs(header->response.status);
opcode = header->response.opcode;
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_b2b_downstream_nread %x %x %d %d %u %d %x\n",
c->sfd, c->cmd, opcode, extlen, keylen, bodylen, c->noreply, status);
}
d = c->extra;
cb_assert(d != NULL);
cb_assert(d->ptd != NULL);
cb_assert(d->ptd->proxy != NULL);
/* TODO: Need to handle quiet binary command error response, */
/* in the right order. */
/* TODO: Need to handle not-my-vbucket error during a quiet cmd. */
uc = d->upstream_conn;
it = c->item;
/* Clear c->item because we either move it to the upstream or */
/* item_remove() it on error. */
c->item = NULL;
cb_assert(it != NULL);
cb_assert(it->refcount == 1);
if (cproxy_binary_ignore_reply(c, header, it)) {
return;
}
if (c->noreply) {
conn_set_state(c, conn_new_cmd);
} else {
conn_set_state(c, conn_pause);
if (opcode == PROTOCOL_BINARY_CMD_NOOP ||
opcode == PROTOCOL_BINARY_CMD_FLUSH) {
goto done;
}
if (opcode == PROTOCOL_BINARY_CMD_STAT) {
if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
if (keylen > 0) {
if (d->merger != NULL) {
char *key = (ITEM_data(it)) + sizeof(*header) + extlen;
char *val = key + keylen;
protocol_stats_merge_name_val(d->merger, "STAT", 4,
key, keylen,
val, bodylen - keylen - extlen);
}
conn_set_state(c, conn_new_cmd); /* Get next STATS response. */
}
}
goto done;
}
/* If the client is still there, we should handle */
/* a not-my-vbucket error with a possible retry. */
if (uc != NULL &&
status == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
int max_retries;
protocol_binary_request_header *req;
int vbucket;
int sindex;
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_b2b_downstream_nread not-my-vbucket, "
"cmd: %x %d\n",
c->sfd, header->response.opcode, uc->item != NULL);
}
cb_assert(uc->item != NULL);
req = (protocol_binary_request_header *)ITEM_data((item*)uc->item);
vbucket = ntohs(req->request.reserved);
sindex = downstream_conn_index(d, c);
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_b2b_downstream_nread not-my-vbucket, "
"cmd: %x not multi-key get, sindex %d, vbucket %d, retries %d\n",
c->sfd, header->response.opcode,
sindex, vbucket, uc->cmd_retries);
}
mcs_server_invalid_vbucket(&d->mst, sindex, vbucket);
/* As long as the upstream is still open and we haven't */
/* retried too many times already. */
max_retries = cproxy_max_retries(d);
if (uc->cmd_retries < max_retries) {
uc->cmd_retries++;
d->upstream_retry++;
d->ptd->stats.stats.tot_retry_vbucket++;
goto done;
}
if (settings.verbose > 2) {
moxi_log_write("%d: cproxy_process_b2b_downstream_nread not-my-vbucket, "
"cmd: %x skipping retry %d >= %d\n",
c->sfd, header->response.opcode, uc->cmd_retries,
max_retries);
}
}
}
/* Write the response to the upstream connection. */
if (uc != NULL) {
if (settings.verbose > 2) {
moxi_log_write("<%d cproxy_process_b2b_downstream_nread got %u\n",
c->sfd, it->nbytes);
cproxy_dump_header(c->sfd, ITEM_data(it));
}
if (add_conn_item(uc, it) == true) {
it->refcount++;
if (add_iov(uc, ITEM_data(it), it->nbytes) == 0) {
/* If we got a quiet response, however, don't change the */
/* upstream connection's state (should be in paused state), */
/* as we expect the downstream server to provide a */
/* verbal/non-quiet response that moves the downstream */
/* conn through the conn_pause countdown codepath. */
if (c->noreply == false) {
cproxy_update_event_write(d, uc);
conn_set_state(uc, conn_mwrite);
}
goto done;
}
}
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(uc);
}
done:
if (it != NULL) {
item_remove(it);
}
}
