void
lcbdur_prepare_item(lcb_DURITEM *ent, lcb_U16 *ixarray, size_t *nitems)
{
size_t ii, oix = 0, maxix = 0;
lcb_DURSET *dset = ent->parent;
lcb_t instance = dset->instance;
lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
RESFLD(ent, persisted_master) = 0;
RESFLD(ent, exists_master) = 0;
RESFLD(ent, npersisted) = 0;
RESFLD(ent, nreplicated) = 0;
RESFLD(ent, cas) = 0;
RESFLD(ent, rc) = LCB_SUCCESS;
if (DSET_OPTFLD(dset, persist_to) == 1 &&
DSET_OPTFLD(dset, replicate_to) == 0) {
maxix = 1; /* Only master! */
} else {
maxix = LCBT_NREPLICAS(instance) + 1;
}
for (ii = 0; ii < maxix; ii++) {
int cur_ix;
lcbdur_SERVINFO *info = &ent->sinfo[ii];
const mc_SERVER *s_exp;
cur_ix = lcbvb_vbserver(vbc, ent->vbid, ii);
if (cur_ix < 0) {
memset(info, 0, sizeof(*info));
continue;
}
s_exp = LCBT_GET_SERVER(instance, cur_ix);
if (s_exp != info->server) {
memset(info, 0, sizeof(*info));
} else if (server_criteria_satisfied(ent, info, ii==0)) {
/* Update counters as required */
if (ii == 0) {
RESFLD(ent, exists_master) = 1;
} else {
RESFLD(ent, nreplicated)++;
}
if (info->persisted) {
RESFLD(ent, npersisted)++;
if (ii == 0) {
RESFLD(ent, persisted_master) = 1;
}
}
continue;
}
/* Otherwise, write the expected server out */
ixarray[oix++] = s_exp->pipeline.index;
}
*nitems = oix;
}
LIBCOUCHBASE_API
void
lcb_sched_flush(lcb_t instance)
{
unsigned ii;
for (ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
mc_SERVER *server = LCBT_GET_SERVER(instance, ii);
if (!mcserver_has_pending(server)) {
continue;
}
server->pipeline.flush_start(&server->pipeline);
}
}
static void
maybe_reset_timeouts(lcb_t instance)
{
size_t ii;
lcb_U64 now;
if (!LCBT_SETTING(instance, readj_ts_wait)) {
return;
}
now = lcb_nstime();
for (ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
mc_SERVER *ss = LCBT_GET_SERVER(instance, ii);
mcreq_reset_timeouts(&ss->pipeline, now);
}
lcb_retryq_reset_timeouts(instance->retryq, now);
}
void
lcbdur_update_item(lcb_DURITEM *item, int flags, int srvix)
{
lcbdur_SERVINFO *info;
lcb_t instance;
int is_master;
const mc_SERVER *server;
if (!flags || item->done) {
return;
}
info = lcbdur_ent_getinfo(item, srvix);
if (!info) {
lcb_log(LOGARGS(item->parent, DEBUG), "Ignoring response from server %d. Not a master or replica for vBucket %d", srvix, item->vbid);
return;
}
instance = item->parent->instance;
is_master = lcbvb_vbmaster(LCBT_VBCONFIG(instance), item->vbid) == srvix;
server = LCBT_GET_SERVER(instance, srvix);
memset(info, 0, sizeof(*info));
info->server = server;
if (flags & LCBDUR_UPDATE_PERSISTED) {
info->persisted = 1;
RESFLD(item, npersisted)++;
if (is_master) {
RESFLD(item, persisted_master) = 1;
}
}
if (flags & LCBDUR_UPDATE_REPLICATED) {
info->exists = 1;
if (is_master) {
RESFLD(item, exists_master) = 1;
} else {
RESFLD(item, nreplicated)++;
}
}
if (lcbdur_ent_check_done(item)) {
RESFLD(item, rc) = LCB_SUCCESS;
lcbdur_ent_finish(item);
}
}
static int
has_pending(lcb_t instance)
{
unsigned ii;
if (!lcb_retryq_empty(instance->retryq)) {
return 1;
}
if (lcb_aspend_pending(&instance->pendops)) {
return 1;
}
for (ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
mc_SERVER *ss = LCBT_GET_SERVER(instance, ii);
if (mcserver_has_pending(ss)) {
return 1;
}
}
return 0;
}
static lcb_U8
get_poll_meth(lcb_t instance, const lcb_DURABILITYOPTSv0 *options)
{
/* Need to call this first, so we can actually allocate the appropriate
* data for this.. */
lcb_U8 meth = options->pollopts;
if (meth == LCB_DURABILITY_MODE_DEFAULT) {
meth = LCB_DURABILITY_MODE_CAS;
if (LCBT_SETTING(instance, fetch_mutation_tokens) &&
LCBT_SETTING(instance, dur_mutation_tokens)) {
size_t ii;
for (ii = 0; ii < LCBT_NSERVERS(instance); ii++) {
mc_SERVER *s = LCBT_GET_SERVER(instance, ii);
if (s->mutation_tokens) {
meth = LCB_DURABILITY_MODE_SEQNO;
break;
}
}
}
}
return meth;
}
LIBCOUCHBASE_API
const char *
lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
{
if (type & LCB_NODE_HTCONFIG) {
if (type & LCB_NODE_CONNECTED) {
const lcb_host_t *host = lcb_confmon_get_rest_host(instance->confmon);
if (host) {
return mk_scratch_host(instance, host);
} else {
return return_badhost(type);
}
} else {
/* Retrieve one from the vbucket configuration */
lcbvb_CONFIG *vbc = LCBT_VBCONFIG(instance);
lcbvb_SVCMODE mode;
const char *hp = NULL;
if (LCBT_SETTING(instance, sslopts) & LCB_SSL_ENABLED) {
mode = LCBVB_SVCMODE_SSL;
} else {
mode = LCBVB_SVCMODE_PLAIN;
}
if (instance->type == LCB_TYPE_BUCKET) {
if (vbc) {
ix %= LCBVB_NSERVERS(vbc);
hp = lcbvb_get_hostport(vbc, ix, LCBVB_SVCTYPE_MGMT, mode);
} else if ((type & LCB_NODE_NEVERNULL) == 0) {
return NULL;
}
}
if (hp == NULL && instance->ht_nodes && instance->ht_nodes->nentries) {
ix %= instance->ht_nodes->nentries;
hostlist_ensure_strlist(instance->ht_nodes);
hp = instance->ht_nodes->slentries[ix];
}
if (!hp) {
if ((hp = return_badhost(type)) == NULL) {
return NULL;
}
}
if (!ensure_scratch(instance, strlen(hp)+1)) {
return NULL;
}
lcb_string_appendz(instance->scratch, hp);
return instance->scratch->base;
}
} else if (type & (LCB_NODE_DATA|LCB_NODE_VIEWS)) {
const mc_SERVER *server;
ix %= LCBT_NSERVERS(instance);
server = LCBT_GET_SERVER(instance, ix);
if ((type & LCB_NODE_CONNECTED) && server->connctx == NULL) {
return return_badhost(type);
}
if (server->curhost == NULL) {
return return_badhost(type);
}
/* otherwise, return the actual host:port of the server */
if (type & LCB_NODE_DATA) {
return mk_scratch_host(instance, server->curhost);
} else {
return server->viewshost;
}
} else {
return NULL; /* don't know the type */
}
}
