static lcb_error_t
dset_ctx_schedule(lcb_MULTICMD_CTX *mctx, const void *cookie)
{
unsigned ii;
char *kptr;
lcb_DURSET *dset = CTX_FROM_MULTI(mctx);
kptr = dset->kvbufs.base;
for (ii = 0; ii < dset->nentries; ii++) {
lcb_DURITEM *ent = dset->entries + ii;
RESFLD(ent, key) = kptr;
kptr += RESFLD(ent, nkey);
if (ent->hashkey.contig.nbytes) {
ent->hashkey.contig.bytes = kptr;
kptr += ent->hashkey.contig.nbytes;
}
if (dset->ht) {
int mt = genhash_update(dset->ht, RESFLD(ent, key),
RESFLD(ent, nkey), ent, 0);
if (mt != NEW) {
lcb_durability_dset_destroy(dset);
return LCB_DUPLICATE_COMMANDS;
}
}
}
dset_ref(dset);
dset->cookie = cookie;
dset->nremaining = dset->nentries;
lcb_aspend_add(&dset->instance->pendops, LCB_PENDTYPE_DURABILITY, dset);
return poll_once(dset, 1);
}
lcb_error_t
lcb_bootstrap_common(lcb_t instance, int options)
{
struct lcb_BOOTSTRAP *bs = instance->bootstrap;
hrtime_t now = gethrtime();
if (!bs) {
bs = calloc(1, sizeof(*instance->bootstrap));
if (!bs) {
return LCB_CLIENT_ENOMEM;
}
bs->tm = lcbio_timer_new(instance->iotable, bs, initial_timeout);
instance->bootstrap = bs;
bs->parent = instance;
lcb_confmon_add_listener(instance->confmon, &bs->listener);
}
if (lcb_confmon_is_refreshing(instance->confmon)) {
return LCB_SUCCESS;
}
if (options & LCB_BS_REFRESH_THROTTLE) {
/* Refresh throttle requested. This is not true if options == ALWAYS */
hrtime_t next_ts;
unsigned errthresh = LCBT_SETTING(instance, weird_things_threshold);
if (options & LCB_BS_REFRESH_INCRERR) {
bs->errcounter++;
}
next_ts = bs->last_refresh;
next_ts += LCB_US2NS(LCBT_SETTING(instance, weird_things_delay));
if (now < next_ts && bs->errcounter < errthresh) {
lcb_log(LOGARGS(instance, INFO),
"Not requesting a config refresh because of throttling parameters. Next refresh possible in %ums or %u errors. "
"See LCB_CNTL_CONFDELAY_THRESH and LCB_CNTL_CONFERRTHRESH to modify the throttling settings",
LCB_NS2US(next_ts-now)/1000, (unsigned)errthresh-bs->errcounter);
return LCB_SUCCESS;
}
}
if (options == LCB_BS_REFRESH_INITIAL) {
lcb_confmon_prepare(instance->confmon);
bs->listener.callback = config_callback;
lcbio_timer_set_target(bs->tm, initial_timeout);
lcbio_timer_rearm(bs->tm, LCBT_SETTING(instance, config_timeout));
lcb_aspend_add(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
} else {
/** No initial timer */
bs->listener.callback = async_step_callback;
}
/* Reset the counters */
bs->errcounter = 0;
if (options != LCB_BS_REFRESH_INITIAL) {
bs->last_refresh = now;
}
return lcb_confmon_start(instance->confmon);
}
LCB_INTERNAL_API
lcb_timer_t lcb_timer_create2(lcbio_TABLE *io,
const void *cookie,
lcb_uint32_t usec,
lcb_timer_options options,
lcb_timer_callback callback,
lcb_t instance,
lcb_error_t *error)
{
lcb_timer_t tmr = calloc(1, sizeof(struct lcb_timer_st));
tmr->io = io;
if (!tmr) {
*error = LCB_CLIENT_ENOMEM;
return NULL;
}
if (!callback) {
*error = LCB_EINVAL;
return NULL;
}
if (! (options & LCB_TIMER_STANDALONE)) {
lcb_assert(instance);
}
lcbio_table_ref(tmr->io);
tmr->instance = instance;
tmr->callback = callback;
tmr->cookie = cookie;
tmr->options = options;
tmr->event = io->timer.create(io->p);
if (tmr->event == NULL) {
free(tmr);
*error = LCB_CLIENT_ENOMEM;
return NULL;
}
if ( (options & LCB_TIMER_STANDALONE) == 0) {
lcb_aspend_add(&instance->pendops, LCB_PENDTYPE_TIMER, tmr);
}
lcb_timer_rearm(tmr, usec);
*error = LCB_SUCCESS;
return tmr;
}
static lcb_error_t
dset_ctx_schedule(lcb_MULTICMD_CTX *mctx, const void *cookie)
{
size_t ii;
lcb_error_t err;
lcb_DURSET *dset = CTX_FROM_MULTI(mctx);
char *kptr = dset->kvbufs.base;
if (!DSET_COUNT(dset)) {
lcbdur_destroy(dset);
return LCB_EINVAL;
}
for (ii = 0; ii < DSET_COUNT(dset); ii++) {
lcb_DURITEM *ent = DSET_ENTRIES(dset) + ii;
RESFLD(ent, key) = kptr;
kptr += RESFLD(ent, nkey);
}
if (DSET_PROCS(dset)->schedule) {
err = DSET_PROCS(dset)->schedule(dset);
if (err != LCB_SUCCESS) {
lcbdur_destroy(dset);
return err;
}
}
lcbdur_ref(dset);
dset->cookie = cookie;
dset->nremaining = DSET_COUNT(dset);
dset->ns_timeout = gethrtime() + LCB_US2NS(DSET_OPTFLD(dset, timeout));
lcb_aspend_add(&dset->instance->pendops, LCB_PENDTYPE_DURABILITY, dset);
lcbdur_switch_state(dset, LCBDUR_STATE_INIT);
return LCB_SUCCESS;
}
