int
pycbc_tc_simple_encode(PyObject **p,
void *buf,
size_t *nbuf,
lcb_uint32_t flags)
{
return encode_common(p, buf, nbuf, flags);
}
int
pycbc_tc_encode_key(pycbc_Bucket *conn,
PyObject **key,
void **buf,
size_t *nbuf)
{
int rv;
Py_ssize_t plen;
PyObject *orig_key;
PyObject *new_key = NULL;
if (!conn->tc) {
return encode_common(key, buf, nbuf, PYCBC_FMT_UTF8);
}
orig_key = *key;
pycbc_assert(orig_key);
rv = do_call_tc(conn, orig_key, NULL, &new_key, ENCODE_KEY);
if (new_key == NULL || rv < 0) {
return -1;
}
rv = PyBytes_AsStringAndSize(new_key, (char**)buf, &plen);
if (rv == -1) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING,
0,
"Couldn't convert encoded key to bytes. It is "
"possible that the Transcoder.encode_key method "
"returned an unexpected value",
new_key);
Py_XDECREF(new_key);
return -1;
}
if (plen == 0) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING,
0,
"Transcoder.encode_key returned an empty string",
new_key);
Py_XDECREF(new_key);
return -1;
}
*nbuf = plen;
*key = new_key;
return 0;
}
int
pycbc_tc_encode_key(pycbc_Bucket *conn, PyObject *src, pycbc_pybuffer *dst)
{
int rv;
Py_ssize_t plen;
if (!conn->tc) {
rv = encode_common(src, dst, PYCBC_FMT_UTF8);
if (rv == 0 && dst->length == 0) {
PYCBC_EXCTHROW_EMPTYKEY();
rv = -1;
}
return rv;
}
/* Swap out key and new key. Assign back later on */
rv = do_call_tc(conn, src, NULL, &dst->pyobj, ENCODE_KEY);
if (dst->pyobj == NULL || rv < 0) {
dst->pyobj = NULL;
return -1;
}
rv = PyBytes_AsStringAndSize(dst->pyobj, (char**)&dst->buffer, &plen);
if (rv == -1) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING,
0,
"Couldn't convert encoded key to bytes. It is "
"possible that the Transcoder.encode_key method "
"returned an unexpected value", dst->pyobj);
PYCBC_PYBUF_RELEASE(dst);
return -1;
}
if (plen == 0) {
PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING,
0,
"Transcoder.encode_key returned an empty string",
dst->pyobj);
PYCBC_PYBUF_RELEASE(dst);
return -1;
}
dst->length = plen;
return 0;
}
/** lebf_encode_resp()
*
* encodes a response structure
*
* returns 0 on success, -errno on failure
*/
static int lebf_encode_resp(
struct PVFS_server_resp *resp,
struct PINT_encoded_msg *target_msg)
{
int ret;
char **p;
ret = encode_common(target_msg, max_size_array[resp->op].resp);
if (ret)
goto out;
gossip_debug(GOSSIP_ENDECODE_DEBUG,"lebf_encode_resp\n");
/** every response has these fields */
p = &target_msg->ptr_current;
encode_PVFS_server_resp(p, resp);
#define CASE(tag,var) \
case tag: encode_PVFS_servresp_##var(p,&resp->u.var); break
/** we stand a good chance of segfaulting if we try to encode the response
* after something bad happened reading data from disk. */
if (resp->status == 0)
{
/** extra encoding rules for particular responses */
switch (resp->op) {
/** call standard function defined in headers */
CASE(PVFS_SERV_GETCONFIG, getconfig);
CASE(PVFS_SERV_LOOKUP_PATH, lookup_path);
CASE(PVFS_SERV_CREATE, create);
CASE(PVFS_SERV_MIRROR, mirror);
CASE(PVFS_SERV_UNSTUFF, unstuff);
CASE(PVFS_SERV_BATCH_CREATE, batch_create);
CASE(PVFS_SERV_IO, io);
CASE(PVFS_SERV_SMALL_IO, small_io);
CASE(PVFS_SERV_GETATTR, getattr);
CASE(PVFS_SERV_RMDIRENT, rmdirent);
CASE(PVFS_SERV_CHDIRENT, chdirent);
CASE(PVFS_SERV_MKDIR, mkdir);
CASE(PVFS_SERV_READDIR, readdir);
CASE(PVFS_SERV_STATFS, statfs);
CASE(PVFS_SERV_MGMT_PERF_MON, mgmt_perf_mon);
CASE(PVFS_SERV_MGMT_ITERATE_HANDLES, mgmt_iterate_handles);
CASE(PVFS_SERV_MGMT_DSPACE_INFO_LIST, mgmt_dspace_info_list);
CASE(PVFS_SERV_MGMT_EVENT_MON, mgmt_event_mon);
CASE(PVFS_SERV_WRITE_COMPLETION, write_completion);
CASE(PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, mgmt_get_dirdata_handle);
CASE(PVFS_SERV_GETEATTR, geteattr);
CASE(PVFS_SERV_LISTEATTR, listeattr);
CASE(PVFS_SERV_LISTATTR, listattr);
CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size);
CASE(PVFS_SERV_MGMT_GET_UID, mgmt_get_uid);
case PVFS_SERV_REMOVE:
case PVFS_SERV_MGMT_REMOVE_OBJECT:
case PVFS_SERV_MGMT_REMOVE_DIRENT:
case PVFS_SERV_TREE_REMOVE:
case PVFS_SERV_SETATTR:
case PVFS_SERV_SETEATTR:
case PVFS_SERV_DELEATTR:
case PVFS_SERV_CRDIRENT:
case PVFS_SERV_TRUNCATE:
case PVFS_SERV_FLUSH:
case PVFS_SERV_MGMT_NOOP:
case PVFS_SERV_BATCH_REMOVE:
case PVFS_SERV_PROTO_ERROR:
case PVFS_SERV_IMM_COPIES:
case PVFS_SERV_MGMT_SETPARAM:
/** nothing else */
break;
case PVFS_SERV_INVALID:
case PVFS_SERV_PERF_UPDATE:
case PVFS_SERV_PRECREATE_POOL_REFILLER:
case PVFS_SERV_JOB_TIMER:
case PVFS_SERV_NUM_OPS: /** sentinel */
gossip_err("%s: invalid operation %d\n", __func__, resp->op);
ret = -PVFS_ENOSYS;
break;
}
}
#undef CASE
/** although much more may have been allocated */
target_msg->total_size = target_msg->ptr_current
- (char *) target_msg->buffer_list[0];
target_msg->size_list[0] = target_msg->total_size;
if (target_msg->total_size > max_size_array[resp->op].resp) {
ret = -PVFS_ENOMEM;
gossip_err("%s: op %d needed %lld bytes but alloced only %d\n",
__func__, resp->op, lld(target_msg->total_size),
max_size_array[resp->op].resp);
}
out:
return ret;
}
/** lebf_encode_req()
*
* encodes a request structure
*
* returns 0 on success, -errno on failure
*/
static int lebf_encode_req(
struct PVFS_server_req *req,
struct PINT_encoded_msg *target_msg)
{
int ret = 0;
char **p;
gossip_debug(GOSSIP_ENDECODE_DEBUG,"Executing lebf_encode_req...\n");
gossip_debug(GOSSIP_ENDECODE_DEBUG,"\treq->op:%d\n",req->op);
ret = encode_common(target_msg, max_size_array[req->op].req);
if (ret)
goto out;
gossip_debug(GOSSIP_ENDECODE_DEBUG,"lebf_encode_req\n");
/** every request has these fields */
p = &target_msg->ptr_current;
encode_PVFS_server_req(p, req);
#define CASE(tag,var) \
case tag: encode_PVFS_servreq_##var(p,&req->u.var); break
switch (req->op) {
/** call standard function defined in headers */
CASE(PVFS_SERV_LOOKUP_PATH, lookup_path);
CASE(PVFS_SERV_CREATE, create);
CASE(PVFS_SERV_MIRROR, mirror);
CASE(PVFS_SERV_UNSTUFF, unstuff);
CASE(PVFS_SERV_BATCH_CREATE, batch_create);
CASE(PVFS_SERV_BATCH_REMOVE, batch_remove);
CASE(PVFS_SERV_REMOVE, remove);
CASE(PVFS_SERV_MGMT_REMOVE_OBJECT, mgmt_remove_object);
CASE(PVFS_SERV_MGMT_REMOVE_DIRENT, mgmt_remove_dirent);
CASE(PVFS_SERV_TREE_REMOVE, tree_remove);
CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size);
CASE(PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, mgmt_get_dirdata_handle);
CASE(PVFS_SERV_IO, io);
CASE(PVFS_SERV_SMALL_IO, small_io);
CASE(PVFS_SERV_GETATTR, getattr);
CASE(PVFS_SERV_SETATTR, setattr);
CASE(PVFS_SERV_CRDIRENT, crdirent);
CASE(PVFS_SERV_RMDIRENT, rmdirent);
CASE(PVFS_SERV_CHDIRENT, chdirent);
CASE(PVFS_SERV_TRUNCATE, truncate);
CASE(PVFS_SERV_MKDIR, mkdir);
CASE(PVFS_SERV_READDIR, readdir);
CASE(PVFS_SERV_FLUSH, flush);
CASE(PVFS_SERV_STATFS, statfs);
CASE(PVFS_SERV_MGMT_SETPARAM, mgmt_setparam);
CASE(PVFS_SERV_MGMT_PERF_MON, mgmt_perf_mon);
CASE(PVFS_SERV_MGMT_ITERATE_HANDLES, mgmt_iterate_handles);
CASE(PVFS_SERV_MGMT_DSPACE_INFO_LIST, mgmt_dspace_info_list);
CASE(PVFS_SERV_MGMT_EVENT_MON, mgmt_event_mon);
CASE(PVFS_SERV_GETEATTR, geteattr);
CASE(PVFS_SERV_SETEATTR, seteattr);
CASE(PVFS_SERV_DELEATTR, deleattr);
CASE(PVFS_SERV_LISTEATTR, listeattr);
CASE(PVFS_SERV_LISTATTR, listattr);
CASE(PVFS_SERV_MGMT_GET_UID, mgmt_get_uid);
case PVFS_SERV_GETCONFIG:
case PVFS_SERV_MGMT_NOOP:
case PVFS_SERV_PROTO_ERROR:
case PVFS_SERV_IMM_COPIES:
/** nothing else */
break;
case PVFS_SERV_INVALID:
case PVFS_SERV_WRITE_COMPLETION:
case PVFS_SERV_PERF_UPDATE:
case PVFS_SERV_PRECREATE_POOL_REFILLER:
case PVFS_SERV_JOB_TIMER:
case PVFS_SERV_NUM_OPS: /** sentinel */
gossip_err("%s: invalid operation %d\n", __func__, req->op);
ret = -PVFS_ENOSYS;
break;
}
#undef CASE
/** although much more may have been allocated */
target_msg->total_size = target_msg->ptr_current
- (char *) target_msg->buffer_list[0];
target_msg->size_list[0] = target_msg->total_size;
if (target_msg->total_size > max_size_array[req->op].req)
{
ret = -PVFS_ENOMEM;
gossip_err("%s: op %d needed %lld bytes but alloced only %d\n",
__func__, req->op, lld(target_msg->total_size),
max_size_array[req->op].req);
}
out:
return ret;
}
int
pycbc_tc_encode_value(pycbc_Bucket *conn,
PyObject **value,
PyObject *flag_v,
void **buf,
size_t *nbuf,
lcb_uint32_t *flags)
{
PyObject *flags_obj;
PyObject *orig_value;
PyObject *new_value = NULL;
PyObject *result_tuple = NULL;
lcb_uint32_t flags_stackval;
int rv;
Py_ssize_t plen;
orig_value = *value;
if (!flag_v) {
flag_v = conn->dfl_fmt;
}
if (!conn->tc) {
if (flag_v == pycbc_helpers.fmt_auto) {
flag_v = pycbc_tc_determine_format(*value);
}
rv = pycbc_get_u32(flag_v, &flags_stackval);
if (rv < 0) {
PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0,
"Bad value for flags",
flag_v);
return -1;
}
*flags = flags_stackval;
return encode_common(value, buf, nbuf, flags_stackval);
}
/**
* Calling into Transcoder
*/
rv = do_call_tc(conn, orig_value, flag_v, &result_tuple, ENCODE_VALUE);
if (rv < 0) {
return -1;
}
if (!PyTuple_Check(result_tuple) || PyTuple_GET_SIZE(result_tuple) != 2) {
PYCBC_EXC_WRAP_EX(PYCBC_EXC_ENCODING, 0,
"Expected return of (bytes, flags)",
orig_value,
result_tuple);
Py_XDECREF(result_tuple);
return -1;
}
new_value = PyTuple_GET_ITEM(result_tuple, 0);
flags_obj = PyTuple_GET_ITEM(result_tuple, 1);
if (new_value == NULL || flags_obj == NULL) {
PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_INTERNAL, 0, "Tuple GET_ITEM had NULL",
result_tuple);
Py_XDECREF(result_tuple);
return -1;
}
rv = pycbc_get_u32(flags_obj, &flags_stackval);
if (rv < 0) {
Py_XDECREF(result_tuple);
PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0,
"Transcoder.encode_value() returned a bad "
"value for flags", orig_value);
return -1;
}
*flags = flags_stackval;
rv = PyBytes_AsStringAndSize(new_value, (char**)buf, &plen);
if (rv == -1) {
Py_XDECREF(result_tuple);
PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0,
"Value returned by Transcoder.encode_value() "
"could not be converted to bytes",
orig_value);
return -1;
}
*value = new_value;
*nbuf = plen;
Py_INCREF(new_value);
Py_XDECREF(result_tuple);
return 0;
}
int
pycbc_tc_encode_value(pycbc_Bucket *conn, PyObject *srcbuf, PyObject *srcflags,
pycbc_pybuffer *dstbuf, lcb_U32 *dstflags)
{
PyObject *flags_obj;
PyObject *new_value = NULL;
PyObject *result_tuple = NULL;
lcb_U32 flags_stackval;
int rv;
Py_ssize_t plen;
if (!srcflags) {
srcflags = conn->dfl_fmt;
}
if (!conn->tc) {
if (srcflags == pycbc_helpers.fmt_auto) {
srcflags = pycbc_tc_determine_format(srcbuf);
}
rv = pycbc_get_u32(srcflags, &flags_stackval);
if (rv < 0) {
PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0,
"Bad value for flags", srcflags);
return -1;
}
*dstflags = flags_stackval;
return encode_common(srcbuf, dstbuf, flags_stackval);
}
/**
* Calling into Transcoder
*/
rv = do_call_tc(conn, srcbuf, srcflags, &result_tuple, ENCODE_VALUE);
if (rv < 0) {
return -1;
}
if (!PyTuple_Check(result_tuple) || PyTuple_GET_SIZE(result_tuple) != 2) {
PYCBC_EXC_WRAP_EX(PYCBC_EXC_ENCODING, 0,
"Expected return of (bytes, flags)",
srcbuf, result_tuple);
Py_XDECREF(result_tuple);
return -1;
}
new_value = PyTuple_GET_ITEM(result_tuple, 0);
flags_obj = PyTuple_GET_ITEM(result_tuple, 1);
if (new_value == NULL || flags_obj == NULL) {
PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_INTERNAL, 0, "Tuple GET_ITEM had NULL",
result_tuple);
Py_XDECREF(result_tuple);
return -1;
}
rv = pycbc_get_u32(flags_obj, &flags_stackval);
if (rv < 0) {
Py_XDECREF(result_tuple);
PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0,
"Transcoder.encode_value() returned a bad "
"value for flags", srcbuf);
return -1;
}
*dstflags = flags_stackval;
rv = PyBytes_AsStringAndSize(new_value, (char**)&dstbuf->buffer, &plen);
if (rv == -1) {
Py_XDECREF(result_tuple);
PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0,
"Value returned by Transcoder.encode_value() "
"could not be converted to bytes", srcbuf);
return -1;
}
dstbuf->pyobj = new_value;
dstbuf->length = plen;
Py_INCREF(new_value);
Py_XDECREF(result_tuple);
return 0;
}
int
pycbc_tc_simple_encode(PyObject *src, pycbc_pybuffer *dst, lcb_U32 flags)
{
return encode_common(src, dst, flags);
}
