static int
chain_endure(PLCB_t *obj, AV *resobj, const lcb_RESPSTORE *resp)
{
lcb_MULTICMD_CTX *mctx = NULL;
lcb_CMDENDURE dcmd = { 0 };
lcb_durability_opts_t dopts = { 0 };
char persist_to = 0, replicate_to = 0;
lcb_error_t err = LCB_SUCCESS;
SV *optsv;
optsv = *av_fetch(resobj, PLCB_RETIDX_OPTIONS, 1);
if (!SvIOK(optsv)) {
return 0;
}
PLCB_GETDURABILITY(SvUVX(optsv), persist_to, replicate_to);
if (persist_to == 0 && replicate_to == 0) {
return 0;
}
if (persist_to < 0 || replicate_to < 0) {
dopts.v.v0.cap_max = 1;
}
dopts.v.v0.persist_to = persist_to;
dopts.v.v0.replicate_to = replicate_to;
LCB_CMD_SET_KEY(&dcmd, resp->key, resp->nkey);
dcmd.cas = resp->cas;
mctx = lcb_endure3_ctxnew(obj->instance, &dopts, &err);
if (mctx == NULL) {
plcb_doc_set_err(obj, resobj, err);
return 0;
}
err = mctx->addcmd(mctx, (lcb_CMDBASE *)&dcmd);
if (err != LCB_SUCCESS) {
mctx->fail(mctx);
return 0;
}
lcb_sched_enter(obj->instance);
err = mctx->done(mctx, resp->cookie);
if (err != LCB_SUCCESS) {
plcb_doc_set_err(obj, resobj, err);
return 0;
}
lcb_sched_leave(obj->instance);
return 1;
}
LIBCOUCHBASE_API
lcb_error_t
lcb_durability_poll(lcb_t instance, const void *cookie,
const lcb_durability_opts_t *options, lcb_size_t ncmds,
const lcb_durability_cmd_t *const *cmds)
{
lcb_MULTICMD_CTX *mctx;
unsigned ii;
lcb_error_t err;
if (ncmds == 0) {
return LCB_EINVAL;
}
mctx = lcb_endure3_ctxnew(instance, options, &err);
if (!mctx) {
return err;
}
for (ii = 0; ii < ncmds; ii++) {
lcb_CMDENDURE cmd = { 0 };
const lcb_DURABILITYCMDv0 *src = &cmds[ii]->v.v0;
cmd.key.contig.bytes = src->key;
cmd.key.contig.nbytes = src->nkey;
cmd._hashkey.contig.bytes = src->hashkey;
cmd._hashkey.contig.nbytes = src->nhashkey;
cmd.cas = src->cas;
err = mctx->addcmd(mctx, (lcb_CMDBASE*)&cmd);
if (err != LCB_SUCCESS) {
mctx->fail(mctx);
return err;
}
}
lcb_sched_enter(instance);
err = mctx->done(mctx, cookie);
if (err != LCB_SUCCESS) {
lcb_sched_fail(instance);
return err;
} else {
lcb_sched_leave(instance);
SYNCMODE_INTERCEPT(instance)
}
}
static void
dur_chain2(pycbc_Bucket *conn,
pycbc_MultiResult *mres,
pycbc_OperationResult *res, int cbtype, const lcb_RESPBASE *resp)
{
lcb_error_t err;
lcb_durability_opts_t dopts = { 0 };
lcb_CMDENDURE cmd = { 0 };
lcb_MULTICMD_CTX *mctx = NULL;
int is_delete = cbtype == LCB_CALLBACK_REMOVE;
res->rc = resp->rc;
if (resp->rc == LCB_SUCCESS) {
const lcb_MUTATION_TOKEN *mutinfo = lcb_resp_get_mutation_token(cbtype, resp);
Py_XDECREF(res->mutinfo);
if (mutinfo && LCB_MUTATION_TOKEN_ISVALID(mutinfo)) {
/* Create the mutation token tuple: (vb,uuid,seqno) */
res->mutinfo = Py_BuildValue("HKKO",
LCB_MUTATION_TOKEN_VB(mutinfo),
LCB_MUTATION_TOKEN_ID(mutinfo),
LCB_MUTATION_TOKEN_SEQ(mutinfo),
conn->bucket);
} else {
Py_INCREF(Py_None);
res->mutinfo = Py_None;
}
res->cas = resp->cas;
}
/** For remove, we check quiet */
maybe_push_operr(mres, (pycbc_Result*)res, resp->rc, is_delete ? 1 : 0);
if ((mres->mropts & PYCBC_MRES_F_DURABILITY) == 0 || resp->rc != LCB_SUCCESS) {
operation_completed(conn, mres);
CB_THR_BEGIN(conn);
return;
}
if (conn->dur_testhook && conn->dur_testhook != Py_None) {
invoke_endure_test_notification(conn, (pycbc_Result *)res);
}
/** Setup global options */
dopts.v.v0.persist_to = mres->dur.persist_to;
dopts.v.v0.replicate_to = mres->dur.replicate_to;
dopts.v.v0.timeout = conn->dur_timeout;
dopts.v.v0.check_delete = is_delete;
if (mres->dur.persist_to < 0 || mres->dur.replicate_to < 0) {
dopts.v.v0.cap_max = 1;
}
lcb_sched_enter(conn->instance);
mctx = lcb_endure3_ctxnew(conn->instance, &dopts, &err);
if (mctx == NULL) {
goto GT_DONE;
}
cmd.cas = resp->cas;
LCB_CMD_SET_KEY(&cmd, resp->key, resp->nkey);
err = mctx->addcmd(mctx, (lcb_CMDBASE*)&cmd);
if (err != LCB_SUCCESS) {
goto GT_DONE;
}
err = mctx->done(mctx, mres);
if (err == LCB_SUCCESS) {
mctx = NULL;
lcb_sched_leave(conn->instance);
}
GT_DONE:
if (mctx) {
mctx->fail(mctx);
}
if (err != LCB_SUCCESS) {
res->rc = err;
maybe_push_operr(mres, (pycbc_Result*)res, err, 0);
operation_completed(conn, mres);
}
CB_THR_BEGIN(conn);
}
PyObject *
pycbc_Bucket_endure_multi(pycbc_Bucket *self, PyObject *args, PyObject *kwargs)
{
int rv;
Py_ssize_t ncmds;
pycbc_seqtype_t seqtype;
char persist_to = 0, replicate_to = 0;
lcb_durability_opts_t dopts = { 0 };
PyObject *keys;
PyObject *is_delete_O = Py_False;
lcb_error_t err;
float timeout = 0.0;
float interval = 0.0;
struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT;
static char *kwlist[] = {
"keys",
"persist_to",
"replicate_to",
"check_removed",
"timeout",
"interval",
NULL
};
rv = PyArg_ParseTupleAndKeywords(args, kwargs, "OBB|Off", kwlist,
&keys,
&persist_to, &replicate_to,
&is_delete_O, &timeout, &interval);
if (!rv) {
PYCBC_EXCTHROW_ARGS();
return NULL;
}
rv = pycbc_oputil_check_sequence(keys, 1, &ncmds, &seqtype);
if (rv < 0) {
return NULL;
}
rv = pycbc_common_vars_init(&cv, self, PYCBC_ARGOPT_MULTI, ncmds, 0);
if (rv < 0) {
return NULL;
}
dopts.v.v0.cap_max = persist_to < 0 || replicate_to < 0;
dopts.v.v0.check_delete = is_delete_O && PyObject_IsTrue(is_delete_O);
dopts.v.v0.timeout = (lcb_uint32_t)(timeout * 1000000.0);
dopts.v.v0.interval = (lcb_uint32_t)(interval * 1000000.0);
dopts.v.v0.persist_to = persist_to;
dopts.v.v0.replicate_to = replicate_to;
cv.mctx = lcb_endure3_ctxnew(self->instance, &dopts, &err);
if (cv.mctx == NULL) {
PYCBC_EXCTHROW_SCHED(err);
goto GT_DONE;
}
rv = pycbc_oputil_iter_multi(self, seqtype, keys, &cv, PYCBC_CMD_ENDURE,
handle_single_keyop, NULL);
if (rv < 0) {
goto GT_DONE;
}
if (-1 == pycbc_common_vars_wait(&cv, self)) {
goto GT_DONE;
}
GT_DONE:
pycbc_common_vars_finalize(&cv, self);
return cv.ret;
}
/** Observe stuff */
static void
handle_dur_storecb(mc_PIPELINE *pl, mc_PACKET *pkt,
lcb_error_t err, const void *arg)
{
lcb_RESPCALLBACK cb;
lcb_RESPSTOREDUR resp = { 0 };
lcb_CMDENDURE dcmd = { 0 };
DURSTORECTX *dctx = (DURSTORECTX *)pkt->u_rdata.exdata;
lcb_MULTICMD_CTX *mctx;
lcb_durability_opts_t opts = { 0 };
const lcb_RESPSTORE *sresp = (const lcb_RESPSTORE *)arg;
if (err != LCB_SUCCESS) {
goto GT_BAIL;
}
if (sresp->rc != LCB_SUCCESS) {
err = sresp->rc;
goto GT_BAIL;
}
resp.store_ok = 1;
LCB_CMD_SET_KEY(&dcmd, sresp->key, sresp->nkey);
dcmd.cas = sresp->cas;
if (LCB_SYNCTOKEN_ISVALID(&sresp->synctoken)) {
dcmd.synctoken = &sresp->synctoken;
}
/* Set the options.. */
opts.v.v0.persist_to = dctx->persist_to;
opts.v.v0.replicate_to = dctx->replicate_to;
mctx = lcb_endure3_ctxnew(dctx->instance, &opts, &err);
if (mctx == NULL) {
goto GT_BAIL;
}
lcbdurctx_set_durstore(mctx, 1);
err = mctx->addcmd(mctx, (lcb_CMDBASE*)&dcmd);
if (err != LCB_SUCCESS) {
mctx->fail(mctx);
goto GT_BAIL;
}
lcb_sched_enter(dctx->instance);
err = mctx->done(mctx, sresp->cookie);
lcb_sched_leave(dctx->instance);
if (err == LCB_SUCCESS) {
/* Everything OK? */
free(dctx);
return;
}
GT_BAIL:
{
lcb_RESPENDURE dresp = { 0 };
resp.key = sresp->key;
resp.nkey = sresp->nkey;
resp.cookie = sresp->cookie;
resp.rc = err;
resp.dur_resp = &dresp;
cb = lcb_find_callback(dctx->instance, LCB_CALLBACK_STOREDUR);
cb(dctx->instance, LCB_CALLBACK_STOREDUR, (const lcb_RESPBASE*)&resp);
free(dctx);
}
(void)pl;
}
