static PyObject * set_common(pycbc_Bucket *self, PyObject *args, PyObject *kwargs, const lcb_storage_t operation, int argopts) { int rv; Py_ssize_t ncmds = 0; PyObject *ttl_O = NULL; PyObject *dict = NULL; PyObject *key; PyObject *value; pycbc_seqtype_t seqtype; struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT; struct storecmd_vars scv = { 0 }; char persist_to = 0, replicate_to = 0; static char *kwlist_multi[] = { "kv", "ttl", "format", "persist_to", "replicate_to", NULL }; static char *kwlist_single[] = { "key", "value", "cas", "ttl", "format", "persist_to", "replicate_to", NULL }; scv.operation = operation; if (argopts & PYCBC_ARGOPT_MULTI) { rv = PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOBB", kwlist_multi, &dict, &ttl_O, &scv.flagsobj, &persist_to, &replicate_to); } else { rv = PyArg_ParseTupleAndKeywords(args, kwargs, "OO|KOOBB", kwlist_single, &key, &value, &scv.single_cas, &ttl_O, &scv.flagsobj, &persist_to, &replicate_to); } if (!rv) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "couldn't parse arguments"); return NULL; } rv = pycbc_get_ttl(ttl_O, &scv.ttl, 1); if (rv < 0) { return NULL; } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_check_sequence(dict, 0, &ncmds, &seqtype); if (rv < 0) { return NULL; } } else { ncmds = 1; } if (operation == LCB_APPEND || operation == LCB_PREPEND) { rv = handle_append_flags(self, &scv.flagsobj); if (rv < 0) { return NULL; } } else if (scv.flagsobj == NULL || scv.flagsobj == Py_None) { scv.flagsobj = self->dfl_fmt; } rv = pycbc_common_vars_init(&cv, self, argopts, ncmds, 1); if (rv < 0) { return NULL; } rv = pycbc_handle_durability_args(self, &cv.mres->dur, persist_to, replicate_to); if (rv == 1) { cv.mres->mropts |= PYCBC_MRES_F_DURABILITY; } else if (rv == -1) { goto GT_DONE; } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_iter_multi(self, seqtype, dict, &cv, 0, handle_single_kv, &scv); } else { rv = handle_single_kv(self, &cv, 0, key, value, NULL, NULL, &scv); } 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; }
static int handle_item_kv(pycbc_Item *itm, PyObject *options, const struct storecmd_vars *scv, struct single_key_context *skc) { int rv; PyObject *ttl_O = NULL, *flagsobj_Oalt = NULL, *igncas_O = NULL; PyObject *frag_O = NULL; static char *itm_optlist[] = { "ttl", "format", "ignore_cas", "fragment", NULL }; lcb_cas_t itmcas = itm->cas; skc->value = itm->value; if (options) { rv = PyArg_ParseTupleAndKeywords(pycbc_DummyTuple, options, "|OOOO", itm_optlist, &ttl_O, &flagsobj_Oalt, &igncas_O, &frag_O); if (!rv) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Couldn't parse item options"); return -1; } if (ttl_O) { if (-1 == pycbc_get_ttl(ttl_O, &skc->ttl, 1)) { return -1; } if (!skc->ttl) { skc->ttl = scv->ttl; } } if (flagsobj_Oalt && flagsobj_Oalt != Py_None) { skc->flagsobj = flagsobj_Oalt; } if (igncas_O && PyObject_IsTrue(igncas_O)) { itmcas = 0; } if (frag_O == NULL) { if (scv->operation == LCB_APPEND || scv->operation == LCB_PREPEND) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "append/prepend must provide options with 'fragment' specifier"); return -1; } } else { if (scv->operation != LCB_APPEND && scv->operation != LCB_PREPEND) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "'fragment' only valid for append/prepend"); return -1; } skc->value = frag_O; } } else { if (scv->operation == LCB_APPEND || scv->operation == LCB_PREPEND) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "append/prepend must provide options with 'fragment' specifier"); return -1; } } if (!skc->value) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0, "Value is empty", skc->value); return -1; } skc->cas = itmcas; return 0; }
static int handle_single_key(pycbc_Connection *self, PyObject *curkey, PyObject *curval, unsigned long ttl, int ii, int optype, struct pycbc_common_vars *cv) { int rv; char *key; size_t nkey; unsigned int lock = 0; rv = pycbc_tc_encode_key(self, &curkey, (void**)&key, &nkey); if (rv == -1) { return -1; } cv->enckeys[ii] = curkey; if (curval) { static char *kwlist[] = { "ttl", NULL }; PyObject *ttl_O = NULL; if (ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Both global and single TTL specified"); return -1; } if (PyDict_Check(curval)) { rv = PyArg_ParseTupleAndKeywords(pycbc_DummyTuple, curval, "|O", kwlist, &ttl_O); if (!rv) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS, 0, "Couldn't get sub-parmeters for key", curkey); return -1; } } else { ttl_O = curval; } rv = pycbc_get_ttl(ttl_O, &ttl, 1); if (rv < 0) { return -1; } } switch (optype) { case PYCBC_CMD_GAT: if (!ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "GAT must have positive TTL"); return -1; } goto GT_GET; case PYCBC_CMD_LOCK: if (!ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Lock must have an expiry"); } lock = 1; goto GT_GET; case PYCBC_CMD_GET: GT_GET: { lcb_get_cmd_t *gcmd = cv->cmds.get + ii; gcmd->v.v0.lock = lock; gcmd->v.v0.key = key; gcmd->v.v0.nkey = nkey; gcmd->v.v0.exptime = ttl; cv->cmdlist.get[ii] = gcmd; } break; case PYCBC_CMD_TOUCH: { lcb_touch_cmd_t *tcmd = cv->cmds.touch + ii; tcmd->v.v0.key = key; tcmd->v.v0.nkey = nkey; tcmd->v.v0.exptime = ttl; cv->cmdlist.touch[ii] = tcmd; break; } } return 0; }
static char *kwlist[] = { "keys", "ttl", "quiet", NULL }; rv = PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO", kwlist, &kobj, &ttl_O, &is_quiet); if (!rv) { PYCBC_EXCTHROW_ARGS() return NULL; } rv = pycbc_get_ttl(ttl_O, &ttl, 1); if (rv < 0) { return NULL; } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_check_sequence(kobj, optype, &ncmds, &seqtype); if (rv < 0) { return NULL; } } else { ncmds = 1;
static int handle_single_key(pycbc_Connection *self, struct pycbc_common_vars *cv, int optype, PyObject *curkey, PyObject *curval, PyObject *options, pycbc_Item *itm, int ii, void *arg) { int rv; char *key; size_t nkey; unsigned int lock = 0; struct getcmd_vars_st *gv = (struct getcmd_vars_st *)arg; unsigned long ttl = gv->u.ttl; (void)itm; rv = pycbc_tc_encode_key(self, &curkey, (void**)&key, &nkey); if (rv == -1) { return -1; } cv->enckeys[ii] = curkey; if (!nkey) { PYCBC_EXCTHROW_EMPTYKEY(); return -1; } if (curval && gv->allow_dval && options == NULL) { options = curval; } if (options) { static char *kwlist[] = { "ttl", NULL }; PyObject *ttl_O = NULL; if (gv->u.ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Both global and single TTL specified"); return -1; } if (PyDict_Check(curval)) { rv = PyArg_ParseTupleAndKeywords(pycbc_DummyTuple, curval, "|O", kwlist, &ttl_O); if (!rv) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ARGUMENTS, 0, "Couldn't get sub-parmeters for key", curkey); return -1; } } else { ttl_O = curval; } rv = pycbc_get_ttl(ttl_O, &ttl, 1); if (rv < 0) { return -1; } } switch (optype) { case PYCBC_CMD_GAT: if (!ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "GAT must have positive TTL"); return -1; } goto GT_GET; case PYCBC_CMD_LOCK: if (!ttl) { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Lock must have an expiry"); return -1; } lock = 1; goto GT_GET; case PYCBC_CMD_GET: GT_GET: { lcb_get_cmd_t *gcmd = cv->cmds.get + ii; gcmd->v.v0.lock = lock; gcmd->v.v0.key = key; gcmd->v.v0.nkey = nkey; gcmd->v.v0.exptime = ttl; cv->cmdlist.get[ii] = gcmd; } break; case PYCBC_CMD_TOUCH: { lcb_touch_cmd_t *tcmd = cv->cmds.touch + ii; tcmd->v.v0.key = key; tcmd->v.v0.nkey = nkey; tcmd->v.v0.exptime = ttl; cv->cmdlist.touch[ii] = tcmd; break; } case PYCBC_CMD_GETREPLICA: case PYCBC_CMD_GETREPLICA_INDEX: case PYCBC_CMD_GETREPLICA_ALL: { lcb_get_replica_cmd_t *rcmd = cv->cmds.replica + ii; rcmd->version = 1; rcmd->v.v1.key = key; rcmd->v.v1.nkey = nkey; rcmd->v.v1.nkey = nkey; rcmd->v.v1.strategy = gv->u.replica.strategy; rcmd->v.v1.index = gv->u.replica.index; cv->cmdlist.replica[ii] = rcmd; break; } } return 0; }
"O|OOOO", kwlist, &kobj, &ttl_O, &is_quiet, &replica_O, &nofmt_O); if (!rv) { PYCBC_EXCTHROW_ARGS() return NULL; } gv.optype = optype; rv = pycbc_get_ttl(ttl_O, &gv.u.ttl, 1); if (rv < 0) { return NULL; } if (replica_O && replica_O != Py_None && replica_O != Py_False) { if (-1 == handle_replica_options(&optype, &gv, replica_O)) { return NULL; } } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_check_sequence(kobj, optype, &ncmds, &seqtype);
PyObject * arithmetic_common(pycbc_Bucket *self, PyObject *args, PyObject *kwargs, int optype, int argopts) { int rv; Py_ssize_t ncmds; struct arithmetic_common_vars global_params = { 0 }; pycbc_seqtype_t seqtype; PyObject *all_initial_O = NULL; PyObject *all_ttl_O = NULL; PyObject *collection; lcb_error_t err; struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT; static char *kwlist[] = { "keys", "delta", "initial", "ttl", NULL }; global_params.delta = 1; rv = PyArg_ParseTupleAndKeywords(args, kwargs, "O|LOO", kwlist, &collection, &global_params.delta, &all_initial_O, &all_ttl_O); if (!rv) { PYCBC_EXCTHROW_ARGS(); return NULL; } rv = pycbc_get_ttl(all_ttl_O, &global_params.ttl, 1); if (rv < 0) { return NULL; } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_check_sequence(collection, 1, &ncmds, &seqtype); if (rv < 0) { return NULL; } } else { ncmds = 1; } if (all_initial_O && PyNumber_Check(all_initial_O)) { global_params.create = 1; global_params.initial = pycbc_IntAsULL(all_initial_O); } rv = pycbc_common_vars_init(&cv, self, argopts, ncmds, sizeof(lcb_arithmetic_cmd_t), 0); if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_iter_multi(self, seqtype, collection, &cv, optype, handle_single_arith, &global_params); } else { rv = handle_single_arith(self, &cv, optype, collection, NULL, NULL, NULL, 0, &global_params); } if (rv < 0) { goto GT_DONE; } err = lcb_arithmetic(self->instance, cv.mres, ncmds, cv.cmdlist.arith); if (err != LCB_SUCCESS) { PYCBC_EXCTHROW_SCHED(err); 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; }