static int do_send_data(libcouchbase_server_t *c)
{
do {
struct libcouchbase_iovec_st iov[2];
libcouchbase_ssize_t nw;
ringbuffer_get_iov(&c->output, RINGBUFFER_READ, iov);
nw = c->instance->io->sendv(c->instance->io, c->sock, iov, 2);
if (nw == -1) {
switch (c->instance->io->error) {
case EINTR:
/* retry */
break;
case EWOULDBLOCK:
return 0;
default:
libcouchbase_failout_server(c, LIBCOUCHBASE_NETWORK_ERROR);
return -1;
}
} else {
ringbuffer_consumed(&c->output, (libcouchbase_size_t)nw);
}
} while (c->output.nbytes > 0);
return 0;
}
lcb_sockrw_status_t lcb_sockrw_v0_write(lcb_connection_t conn,
ringbuffer_t *buf)
{
lcb_io_opt_t io = conn->io;
while (buf->nbytes > 0) {
struct lcb_iovec_st iov[2];
lcb_ssize_t nw;
ringbuffer_get_iov(buf, RINGBUFFER_READ, iov);
nw = io->v.v0.sendv(io, conn->sockfd, iov, 2);
if (nw == -1) {
switch (io->v.v0.error) {
case EINTR:
/* retry */
break;
case EWOULDBLOCK:
#ifdef USE_EAGAIN
case EAGAIN:
#endif
return LCB_SOCKRW_WOULDBLOCK;
default:
return LCB_SOCKRW_IO_ERROR;
}
} else if (nw > 0) {
ringbuffer_consumed(buf, (lcb_size_t)nw);
}
}
return LCB_SOCKRW_WROTE;
}
static void swallow_command(lcb_server_t *c,
const protocol_binary_response_header *header,
int was_connected)
{
lcb_size_t nr;
protocol_binary_request_header req;
if (was_connected &&
(header->response.opcode != PROTOCOL_BINARY_CMD_STAT ||
header->response.keylen == 0)) {
nr = ringbuffer_read(&c->cmd_log, req.bytes, sizeof(req));
lcb_assert(nr == sizeof(req));
ringbuffer_consumed(&c->cmd_log, ntohl(req.request.bodylen));
ringbuffer_consumed(&c->output_cookies,
sizeof(struct lcb_command_data_st));
}
}
void ringbuffer_reset(ringbuffer_t *buffer)
{
ringbuffer_consumed(buffer,
ringbuffer_get_nbytes(buffer));
}
/*
* Drop all packets with sequence number less than specified.
*
* The packets are considered as stale and the caller will receive
* appropriate error code in the operation callback.
*
* Returns 0 on success
*/
int lcb_server_purge_implicit_responses(lcb_server_t *c,
lcb_uint32_t seqno,
hrtime_t end,
int all)
{
protocol_binary_request_header req;
/** Instance level allocated buffers */
ringbuffer_t *cmdlog, *cookies;
lcb_size_t nr = ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req));
/* There should at _LEAST_ be _ONE_ message in here if we're not
* trying to purge _ALL_ of the messages in the queue
*/
if (all && nr == 0) {
return 0;
}
/**
* Reading the command log is not re-entrant safe, as an additional
* command to the same server may result in the command log being modified.
* To this end, we must first buffer all the commands in a separate
* ringbuffer (or simple buffer) for that matter, and only *then*
* invoke the callbacks
*/
lcb_assert(nr == sizeof(req));
if (req.request.opaque >= seqno) {
return 0;
}
cmdlog = &c->instance->purged_buf;
cookies = &c->instance->purged_cookies;
ringbuffer_reset(cmdlog);
ringbuffer_reset(cookies);
/**
* Move all the commands we want to purge into the relevant ("local") buffers.
* We will later read from these local buffers
*/
while (req.request.opaque < seqno) {
lcb_size_t packetsize = ntohl(req.request.bodylen) + (lcb_uint32_t)sizeof(req);
ringbuffer_memcpy(cmdlog, &c->cmd_log, packetsize);
ringbuffer_consumed(&c->cmd_log, packetsize);
ringbuffer_memcpy(cookies, &c->output_cookies, sizeof(struct lcb_command_data_st));
ringbuffer_consumed(&c->output_cookies, sizeof(struct lcb_command_data_st));
nr = ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req.bytes));
if (!nr) {
break;
}
lcb_assert(nr == sizeof(req));
}
nr = ringbuffer_peek(cmdlog, req.bytes, sizeof(req));
lcb_assert(nr == sizeof(req));
if (!all) {
lcb_assert(c->cmd_log.nbytes);
}
do {
struct lcb_command_data_st ct;
char *packet = cmdlog->read_head;
lcb_size_t packetsize = ntohl(req.request.bodylen) + (lcb_uint32_t)sizeof(req);
char *keyptr;
union {
lcb_get_resp_t get;
lcb_store_resp_t store;
lcb_remove_resp_t remove;
lcb_touch_resp_t touch;
lcb_unlock_resp_t unlock;
lcb_arithmetic_resp_t arithmetic;
lcb_observe_resp_t observe;
} resp;
nr = ringbuffer_read(cookies, &ct, sizeof(ct));
lcb_assert(nr == sizeof(ct));
if (c->instance->histogram) {
lcb_record_metrics(c->instance, end - ct.start, req.request.opcode);
}
if (!ringbuffer_is_continous(cmdlog, RINGBUFFER_READ, packetsize)) {
packet = malloc(packetsize);
if (packet == NULL) {
lcb_error_handler(c->instance, LCB_CLIENT_ENOMEM, NULL);
return -1;
}
nr = ringbuffer_peek(cmdlog, packet, packetsize);
if (nr != packetsize) {
lcb_error_handler(c->instance, LCB_EINTERNAL, NULL);
free(packet);
return -1;
}
}
switch (req.request.opcode) {
case PROTOCOL_BINARY_CMD_GATQ:
case PROTOCOL_BINARY_CMD_GETQ:
keyptr = packet + sizeof(req) + req.request.extlen;
setup_lcb_get_resp_t(&resp.get, keyptr, ntohs(req.request.keylen),
NULL, 0, 0, 0, 0);
TRACE_GET_END(req.request.opaque, ntohs(req.request.vbucket),
req.request.opcode, LCB_KEY_ENOENT, &resp.get);
c->instance->callbacks.get(c->instance, ct.cookie, LCB_KEY_ENOENT, &resp.get);
break;
case CMD_OBSERVE:
lcb_failout_observe_request(c, &ct, packet,
sizeof(req.bytes) + ntohl(req.request.bodylen),
LCB_SERVER_BUG);
break;
case PROTOCOL_BINARY_CMD_NOOP:
break;
default: {
char errinfo[128] = { '\0' };
snprintf(errinfo, 128, "Unknown implicit send message op=%0x", req.request.opcode);
lcb_error_handler(c->instance, LCB_EINTERNAL, errinfo);
return -1;
}
}
if (packet != cmdlog->read_head) {
free(packet);
}
ringbuffer_consumed(cmdlog, packetsize);
nr = ringbuffer_peek(cmdlog, req.bytes, sizeof(req));
if (nr == 0) {
return 0;
}
lcb_assert(nr == sizeof(req));
} while (1); /* CONSTCOND */
return 0;
}
static void purge_single_server(lcb_server_t *server, lcb_error_t error,
hrtime_t min_nonstale,
hrtime_t *tmo_next)
{
protocol_binary_request_header req;
struct lcb_command_data_st ct;
lcb_size_t nr;
char *packet;
lcb_size_t packetsize;
char *keyptr;
ringbuffer_t rest;
ringbuffer_t *stream = &server->cmd_log;
ringbuffer_t *cookies;
ringbuffer_t *mirror = NULL; /* mirror buffer should be purged with main stream */
lcb_connection_t conn = &server->connection;
lcb_size_t send_size = 0;
lcb_size_t stream_size = ringbuffer_get_nbytes(stream);
hrtime_t now = gethrtime();
if (server->connection_ready) {
cookies = &server->output_cookies;
} else {
cookies = &server->pending_cookies;
mirror = &server->pending;
}
if (conn->output) {
/* This will usually be false for v1 */
send_size = ringbuffer_get_nbytes(conn->output);
}
lcb_assert(ringbuffer_initialize(&rest, 1024));
do {
int allocated = 0;
lcb_uint32_t headersize;
lcb_uint16_t nkey;
nr = ringbuffer_peek(cookies, &ct, sizeof(ct));
if (nr != sizeof(ct)) {
break;
}
nr = ringbuffer_peek(stream, req.bytes, sizeof(req));
if (nr != sizeof(req)) {
break;
}
packetsize = (lcb_uint32_t)sizeof(req) + ntohl(req.request.bodylen);
if (stream->nbytes < packetsize) {
break;
}
if (min_nonstale && ct.start >= min_nonstale) {
lcb_log(LOGARGS(server, INFO),
"Still have %d ms remaining for command",
(ct.start - min_nonstale) / 1000000);
if (tmo_next) {
*tmo_next = (ct.start - min_nonstale) + 1;
}
break;
}
lcb_log(LOGARGS(server, INFO),
"Command with cookie=%p timed out from server %s:%s",
ct.cookie,
server->curhost.host,
server->curhost.port);
ringbuffer_consumed(cookies, sizeof(ct));
lcb_assert(nr == sizeof(req));
packet = stream->read_head;
if (server->instance->histogram) {
lcb_record_metrics(server->instance, now - ct.start,
req.request.opcode);
}
if (server->connection_ready &&
stream_size > send_size && (stream_size - packetsize) < send_size) {
/* Copy the rest of the current packet into the
temporary stream */
/* I do believe I have some IOV functions to do that? */
lcb_size_t nbytes = packetsize - (stream_size - send_size);
lcb_assert(ringbuffer_memcpy(&rest,
conn->output,
nbytes) == 0);
ringbuffer_consumed(conn->output, nbytes);
send_size -= nbytes;
}
stream_size -= packetsize;
headersize = (lcb_uint32_t)sizeof(req) + req.request.extlen + htons(req.request.keylen);
if (!ringbuffer_is_continous(stream, RINGBUFFER_READ, headersize)) {
packet = malloc(headersize);
if (packet == NULL) {
lcb_error_handler(server->instance, LCB_CLIENT_ENOMEM, NULL);
abort();
}
nr = ringbuffer_peek(stream, packet, headersize);
if (nr != headersize) {
lcb_error_handler(server->instance, LCB_EINTERNAL, NULL);
free(packet);
abort();
}
allocated = 1;
}
keyptr = packet + sizeof(req) + req.request.extlen;
nkey = ntohs(req.request.keylen);
failout_single_request(server, &req, &ct, error, keyptr, nkey, packet);
if (allocated) {
free(packet);
}
ringbuffer_consumed(stream, packetsize);
if (mirror) {
ringbuffer_consumed(mirror, packetsize);
}
} while (1); /* CONSTCOND */
if (server->connection_ready && conn->output) {
/* Preserve the rest of the stream */
lcb_size_t nbytes = ringbuffer_get_nbytes(stream);
send_size = ringbuffer_get_nbytes(conn->output);
if (send_size >= nbytes) {
ringbuffer_consumed(conn->output, send_size - nbytes);
lcb_assert(ringbuffer_memcpy(&rest, conn->output, nbytes) == 0);
}
ringbuffer_reset(conn->output);
ringbuffer_append(&rest, conn->output);
}
ringbuffer_destruct(&rest);
lcb_maybe_breakout(server->instance);
}
static int parse_single(libcouchbase_server_t *c, hrtime_t stop)
{
protocol_binary_request_header req;
protocol_binary_response_header header;
libcouchbase_size_t nr;
char *packet;
libcouchbase_size_t packetsize;
struct libcouchbase_command_data_st ct;
nr = ringbuffer_peek(&c->input, header.bytes, sizeof(header));
if (nr < sizeof(header)) {
return 0;
}
packetsize = ntohl(header.response.bodylen) + (libcouchbase_uint32_t)sizeof(header);
if (c->input.nbytes < packetsize) {
return 0;
}
/* Is it already timed out? */
nr = ringbuffer_peek(&c->cmd_log, req.bytes, sizeof(req));
if (nr < sizeof(req) || /* the command log doesn't know about it */
(header.response.opaque < req.request.opaque &&
header.response.opaque > 0)) { /* sasl comes with zero opaque */
/* already processed. */
ringbuffer_consumed(&c->input, packetsize);
return 1;
}
packet = c->input.read_head;
/* we have everything! */
if (!ringbuffer_is_continous(&c->input, RINGBUFFER_READ,
packetsize)) {
/* The buffer isn't continous.. for now just copy it out and
** operate on the copy ;)
*/
if ((packet = malloc(packetsize)) == NULL) {
libcouchbase_error_handler(c->instance, LIBCOUCHBASE_CLIENT_ENOMEM, NULL);
return -1;
}
nr = ringbuffer_read(&c->input, packet, packetsize);
if (nr != packetsize) {
libcouchbase_error_handler(c->instance, LIBCOUCHBASE_EINTERNAL,
NULL);
free(packet);
return -1;
}
}
nr = ringbuffer_peek(&c->output_cookies, &ct, sizeof(ct));
if (nr != sizeof(ct)) {
libcouchbase_error_handler(c->instance, LIBCOUCHBASE_EINTERNAL,
NULL);
if (packet != c->input.read_head) {
free(packet);
}
return -1;
}
ct.vbucket = ntohs(req.request.vbucket);
switch (header.response.magic) {
case PROTOCOL_BINARY_REQ:
c->instance->request_handler[header.response.opcode](c, &ct, (void *)packet);
break;
case PROTOCOL_BINARY_RES: {
int was_connected = c->connected;
if (libcouchbase_server_purge_implicit_responses(c, header.response.opaque, stop) != 0) {
if (packet != c->input.read_head) {
free(packet);
}
return -1;
}
if (c->instance->histogram) {
libcouchbase_record_metrics(c->instance, stop - ct.start,
header.response.opcode);
}
if (ntohs(header.response.status) != PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET
|| header.response.opcode == CMD_GET_REPLICA) {
c->instance->response_handler[header.response.opcode](c, &ct, (void *)packet);
/* keep command and cookie until we get complete STAT response */
if (was_connected &&
(header.response.opcode != PROTOCOL_BINARY_CMD_STAT || header.response.keylen == 0)) {
nr = ringbuffer_read(&c->cmd_log, req.bytes, sizeof(req));
assert(nr == sizeof(req));
ringbuffer_consumed(&c->cmd_log, ntohl(req.request.bodylen));
ringbuffer_consumed(&c->output_cookies, sizeof(ct));
}
} else {
int idx;
char *body;
libcouchbase_size_t nbody;
libcouchbase_server_t *new_srv;
/* re-schedule command to new server */
nr = ringbuffer_read(&c->cmd_log, req.bytes, sizeof(req));
assert(nr == sizeof(req));
idx = vbucket_found_incorrect_master(c->instance->vbucket_config,
ntohs(req.request.vbucket),
(int)c->index);
assert((libcouchbase_size_t)idx < c->instance->nservers);
new_srv = c->instance->servers + idx;
req.request.opaque = ++c->instance->seqno;
nbody = ntohl(req.request.bodylen);
body = malloc(nbody);
if (body == NULL) {
libcouchbase_error_handler(c->instance, LIBCOUCHBASE_CLIENT_ENOMEM, NULL);
return -1;
}
nr = ringbuffer_read(&c->cmd_log, body, nbody);
assert(nr == nbody);
nr = ringbuffer_read(&c->output_cookies, &ct, sizeof(ct));
assert(nr == sizeof(ct));
/* Preserve the cookie and timestamp for the command. This means
* that the library will retry the command until its time will
* out and the client will get LIBCOUCHBASE_ETIMEDOUT error in
* command callback */
libcouchbase_server_retry_packet(new_srv, &ct, &req, sizeof(req));
libcouchbase_server_write_packet(new_srv, body, nbody);
libcouchbase_server_end_packet(new_srv);
libcouchbase_server_send_packets(new_srv);
free(body);
}
break;
}
default:
libcouchbase_error_handler(c->instance,
LIBCOUCHBASE_PROTOCOL_ERROR,
NULL);
if (packet != c->input.read_head) {
free(packet);
}
return -1;
}
if (packet != c->input.read_head) {
free(packet);
} else {
ringbuffer_consumed(&c->input, packetsize);
}
return 1;
}
