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;
}
