/**
*******************************************************************************************************
* Revokes roles of a user in the Aerospike DB.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Admin_Revoke_Roles( AerospikeClient *self, PyObject *args, PyObject *kwds )
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
PyObject * py_user = NULL;
PyObject * py_roles = NULL;
as_policy_admin admin_policy;
as_policy_admin *admin_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"user", "roles", "policy", NULL};
// Python Function Argument Parsing
if (PyArg_ParseTupleAndKeywords(args, kwds, "OO|O:admin_revoke_roles", kwlist,
&py_user, &py_roles, &py_policy) == false) {
return NULL;
}
// Aerospike Operation Arguments
char *user = NULL;
int roles_size = 0;
char **roles = NULL;
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python object to array of roles
if (PyList_Check(py_roles)) {
roles_size = PyList_Size(py_roles);
roles = alloca(sizeof(char *) * roles_size);
for (int i = 0; i < roles_size; i++) {
roles[i] = cf_malloc(sizeof(char) * AS_ROLE_SIZE);
memset(roles[i], 0, sizeof(char) * AS_ROLE_SIZE);
}
}
pyobject_to_strArray(&err, py_roles, roles, AS_ROLE_SIZE);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
if (py_policy == Py_None) {
py_policy = PyDict_New();
}
// Convert python object to username string
if (!PyString_Check(py_user)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Username should be a string");
goto CLEANUP;
}
user = PyString_AsString(py_user);
// Convert python object to policy_admin
pyobject_to_policy_admin(&err, py_policy, &admin_policy, &admin_policy_p,
&self->as->config.policies.admin);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_revoke_roles(self->as, &err, admin_policy_p, user, (const char**)roles, roles_size);
Py_END_ALLOW_THREADS
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
for (int i = 0; i < roles_size; i++) {
if (roles[i])
cf_free(roles[i]);
}
if (err.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
********************************************************************************************************
* Add a list of objects to the map.
*
* @param self AerospikeLMap object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLMap_Put_Many(AerospikeLMap * self, PyObject * args, PyObject * kwds)
{
PyObject* py_values = NULL;
PyObject* py_policy = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_map* map_values = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_error err;
as_error_init(&err);
static char * kwlist[] = {"values", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:put_many", kwlist,
&py_values, &py_policy)== false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
if (!PyDict_Check(py_values)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid argument(type)");
goto CLEANUP;
}
/*
* Convert python map to as map
*/
pyobject_to_map(self->client, &err, py_values, &map_values, &static_pool, SERIALIZER_PYTHON);
if (err.code != AEROSPIKE_OK) {
map_values = NULL;
goto CLEANUP;
}
aerospike_lmap_put_all(self->client->as, &err, apply_policy_p,
&self->key, &self->lmap, map_values);
if(err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (map_values) {
as_map_destroy(map_values);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if(PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyStr_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
********************************************************************************************************
* Delete the entire set(LDT Remove).
*
* @param self AerospikeLSet object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLSet_Destroy(AerospikeLSet * self, PyObject * args, PyObject * kwds)
{
PyObject* py_policy = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_error err;
as_error_init(&err);
static char * kwlist[] = {"policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "|O:destroy", kwlist,
&py_policy) == false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
aerospike_lset_destroy(self->client->as, &err, apply_policy_p, &self->key,
&self->lset);
if( err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if(PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyString_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Callback for as_info_foreach().
*
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param node The current as_node object for which the
* callback is fired by c client.
* @param req The info request string.
* @param res The info response string for current node.
* @pram udata The callback udata containing the host_lookup
* array and the return zval to be populated with
* an entry for current node's info response with
* the node's ID as the key.
*
* Returns true if callback is successful, Otherwise false.
*******************************************************************************************************
*/
static bool AerospikeClient_Info_each(as_error * err, const as_node * node, const char * req, char * res, void * udata)
{
PyObject * py_err = NULL;
PyObject * py_ustr = NULL;
PyObject * py_out = NULL;
foreach_callback_info_udata* udata_ptr = (foreach_callback_info_udata *) udata;
struct sockaddr_in* addr = NULL;
if ( err && err->code != AEROSPIKE_OK ) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
else if ( res != NULL ) {
char * out = strchr(res,'\t');
if ( out != NULL ) {
out++;
py_out = PyString_FromString(out);
}
else {
py_out = PyString_FromString(res);
}
}
if ( py_err == NULL ) {
Py_INCREF(Py_None);
py_err = Py_None;
}
if ( py_out == NULL ) {
Py_INCREF(Py_None);
py_out = Py_None;
}
PyObject * py_res = PyTuple_New(2);
PyTuple_SetItem(py_res, 0, py_err);
PyTuple_SetItem(py_res, 1, py_out);
if(udata_ptr->host_lookup_p) {
PyObject * py_hosts = (PyObject *)udata_ptr->host_lookup_p;
if ( py_hosts && PyList_Check(py_hosts) ) {
addr = as_node_get_address((as_node *)node);
int size = (int) PyList_Size(py_hosts);
for ( int i = 0; i < size && i < AS_CONFIG_HOSTS_SIZE; i++ ) {
char * host_addr = NULL;
int port = -1;
PyObject * py_host = PyList_GetItem(py_hosts, i);
if ( PyTuple_Check(py_host) && PyTuple_Size(py_host) == 2 ) {
PyObject * py_addr = PyTuple_GetItem(py_host,0);
PyObject * py_port = PyTuple_GetItem(py_host,1);
if (PyUnicode_Check(py_addr)) {
py_ustr = PyUnicode_AsUTF8String(py_addr);
host_addr = PyString_AsString(py_ustr);
} else if ( PyString_Check(py_addr) ) {
host_addr = PyString_AsString(py_addr);
} else {
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Host address is of type incorrect");
if (py_res) {
Py_DECREF(py_res);
}
return false;
}
if ( PyInt_Check(py_port) ) {
port = (uint16_t) PyInt_AsLong(py_port);
}
else if ( PyLong_Check(py_port) ) {
port = (uint16_t) PyLong_AsLong(py_port);
} else {
break;
}
char ip_port[IP_PORT_MAX_LEN];
inet_ntop(addr->sin_family, &(addr->sin_addr), ip_port, INET_ADDRSTRLEN);
if( (!strcmp(host_addr,ip_port)) && (port
== ntohs(addr->sin_port))) {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
}
}
} else if ( !PyList_Check( py_hosts )){
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Hosts should be specified in a list.");
goto CLEANUP;
}
} else {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
Py_DECREF(py_res);
CLEANUP:
if ( udata_ptr->error.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject( &udata_ptr->error, &py_err);
PyObject *exception_type = raise_exception(&udata_ptr->error);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return true;
}
AerospikeScan * AerospikeScan_Select(AerospikeScan * self, PyObject * args, PyObject * kwds)
{
TRACE();
char * bin = NULL;
PyObject * py_ustr = NULL;
as_error err;
as_error_init(&err);
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
int nbins = (int) PyTuple_Size(args);
as_scan_select_init(&self->scan, nbins);
for ( int i = 0; i < nbins; i++ ) {
PyObject * py_bin = PyTuple_GetItem(args, i);
if ( py_bin) {
TRACE();
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
} else {
TRACE();
}
as_scan_select(&self->scan, bin);
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
Py_INCREF(self);
return self;
}
/**
*******************************************************************************************************
* Multiple operations on a single record
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns tuple of bins on success if read operation is given.
* Otherwise returns 0 on success for other operations.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Operate(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_key = NULL;
PyObject * py_list = NULL;
PyObject * py_policy = NULL;
PyObject * py_result = NULL;
PyObject * py_meta = NULL;
as_key key;
as_policy_operate operate_policy;
as_policy_operate *operate_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"key", "list", "meta", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:operate", kwlist,
&py_key, &py_list, &py_meta, &py_policy) == false ) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err,
py_key, py_policy, &key, &operate_policy, &operate_policy_p);
if (!py_result) {
goto CLEANUP;
} else {
Py_DECREF(py_result);
}
if ( py_list != NULL && PyList_Check(py_list) ) {
py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list, py_meta, operate_policy_p);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Operations should be of type list");
goto CLEANUP;
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_result;
}
PyObject * AerospikeQuery_Foreach(AerospikeQuery * self, PyObject * args, PyObject * kwds)
{
// Python Function Arguments
PyObject * py_callback = NULL;
PyObject * py_policy = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"callback", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:foreach", kwlist, &py_callback, &py_policy) == false ) {
as_query_destroy(&self->query);
return NULL;
}
// Initialize callback user data
LocalData data;
data.callback = py_callback;
as_error_init(&data.error);
// Aerospike Client Arguments
as_error err;
as_policy_query query_policy;
as_policy_query * query_policy_p = NULL;
// Initialize error
as_error_init(&err);
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_exists
pyobject_to_policy_query(&err, py_policy, &query_policy, &query_policy_p,
&self->client->as->config.policies.query);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// We are spawning multiple threads
PyThreadState * _save = PyEval_SaveThread();
// Invoke operation
aerospike_query_foreach(self->client->as, &err, query_policy_p, &self->query, each_result, &data);
// We are done using multiple threads
PyEval_RestoreThread(_save);
if (data.error.code != AEROSPIKE_OK) {
goto CLEANUP;
}
CLEANUP:
if ( self->query.apply.arglist ){
as_arraylist_destroy( (as_arraylist *) self->query.apply.arglist );
}
self->query.apply.arglist = NULL;
if ( err.code != AEROSPIKE_OK || data.error.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
if ( err.code != AEROSPIKE_OK ){
error_to_pyobject(&err, &py_err);
}
if ( data.error.code != AEROSPIKE_OK ){
error_to_pyobject(&data.error, &py_err);
}
PyErr_SetObject(PyExc_Exception, py_err);
Py_DECREF(py_err);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
/**
********************************************************************************************************
* Select values from the end of list up to a maximum count.
*
* @param self AerospikeLList object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns a list of ldt contents.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLList_Find_Last(AerospikeLList * self, PyObject * args, PyObject * kwds)
{
PyObject* py_count = NULL;
PyObject* py_policy = NULL;
PyObject* py_elements_list = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_list* elements_list = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_error err;
as_error_init(&err);
static char * kwlist[] = {"count", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find_last", kwlist,
&py_count, &py_policy)== false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
uint32_t count = 0;
if ( PyInt_Check(py_count)) {
count = PyInt_AsLong(py_count);
} else if( PyLong_Check(py_count) ) {
count = PyLong_AsLong(py_count);
if (count == (uint32_t)-1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long");
goto CLEANUP;
}
Py_BEGIN_ALLOW_THREADS
aerospike_llist_find_last(self->client->as, &err, apply_policy_p, &self->key, &self->llist, count, &elements_list);
Py_END_ALLOW_THREADS
if(err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
list_to_pyobject(self->client, &err, elements_list, &py_elements_list);
CLEANUP:
if (elements_list) {
as_list_destroy(elements_list);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if (PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if (PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyStr_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_elements_list;
}
/**
*******************************************************************************************************
* This function applies a registered udf module on a particular record.
*
* @param self AerospikeClient object
* @param py_key The key under which to store the record.
* @param py_module The module name.
* @param py_function The UDF function to be applied on a record.
* @param py_arglist The arguments to the UDF function
* @param py_policy The optional policy parameters
*
* Returns the result of UDF function.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Apply_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_module, PyObject * py_function,
PyObject * py_arglist, PyObject * py_policy)
{
// Python Return Value
PyObject * py_result = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_apply apply_policy;
as_policy_apply * apply_policy_p = NULL;
as_key key;
char * module = NULL;
char * function = NULL;
as_list * arglist = NULL;
as_val * result = NULL;
PyObject * py_umodule = NULL;
PyObject * py_ufunction = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
// Initialisation flags
bool key_initialised = false;
// Initialize error
as_error_init(&err);
if( !PyList_Check(py_arglist) ){
PyErr_SetString(PyExc_TypeError, "expected UDF method arguments in a 'list'");
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
self->is_client_put_serializer = false;
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Key is initialiased successfully
key_initialised = true;
// Convert python list to as_list
pyobject_to_list(self, &err, py_arglist, &arglist, &static_pool, SERIALIZER_PYTHON);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
if ( PyUnicode_Check(py_module) ){
py_umodule = PyUnicode_AsUTF8String(py_module);
module = PyString_AsString(py_umodule);
}
else if ( PyString_Check(py_module) ) {
module = PyString_AsString(py_module);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string or unicode string");
goto CLEANUP;
}
if ( PyUnicode_Check(py_function) ){
py_ufunction = PyUnicode_AsUTF8String(py_function);
function = PyString_AsString(py_ufunction);
}
else if ( PyString_Check(py_function) ) {
function = PyString_AsString(py_function);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "function name must be a string or unicode string");
goto CLEANUP;
}
// Invoke operation
aerospike_key_apply(self->as, &err, apply_policy_p, &key, module, function, arglist, &result);
if ( err.code == AEROSPIKE_OK ) {
val_to_pyobject(self, &err, result, &py_result);
} else {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (py_umodule) {
Py_DECREF(py_umodule);
}
if (py_ufunction) {
Py_DECREF(py_ufunction);
}
if (key_initialised == true){
// Destroy the key if it is initialised successfully.
as_key_destroy(&key);
}
as_list_destroy(arglist);
as_val_destroy(result);
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
if(PyObject_HasAttrString(exception_type, "module")) {
PyObject_SetAttrString(exception_type, "module", py_module);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", py_function);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_result;
}
/**
*******************************************************************************************************
* This function invokes csdk's API to remove particular record.
*
* @param self AerospikeClient object
* @param py_key The key under which to store the record
* @param generation The generation value
* @param py_policy The optional policy parameters
*
* Returns 0 on success.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Remove_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_meta, PyObject * py_policy)
{
// Aerospike Client Arguments
as_error err;
as_policy_remove remove_policy;
as_policy_remove * remove_policy_p = NULL;
as_key key;
// Initialisation flags
bool key_initialised = false;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Key is initialised successfully
key_initialised = true;
// Convert python policy object to as_policy_exists
if (py_policy) {
pyobject_to_policy_remove(&err, py_policy, &remove_policy, &remove_policy_p,
&self->as->config.policies.remove);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
} else {
if ( py_meta && PyDict_Check(py_meta) ) {
PyObject * py_gen = PyDict_GetItemString(py_meta, "gen");
if( py_gen != NULL ){
if ( PyInt_Check(py_gen) ) {
remove_policy_p->generation = (uint16_t) PyInt_AsLong(py_gen);
} else if ( PyLong_Check(py_gen) ) {
remove_policy_p->generation = (uint16_t) PyLong_AsLongLong(py_gen);
if((uint16_t)-1 == remove_policy_p->generation) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value for gen exceeds sys.maxsize");
goto CLEANUP;
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Generation should be an int or long");
}
}
}
}
}
// Invoke operation
aerospike_key_remove(self->as, &err, remove_policy_p, &key);
if(err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (key_initialised == true){
// Destroy the key if it is initialised successfully.
as_key_destroy(&key);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
********************************************************************************************************
* Select values from a begin key to end key corresponding to a value up to a maximum count applying a lua filter.
*
* @param self AerospikeLList object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns a list of ldt contents.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLList_Range_Limit(AerospikeLList * self, PyObject * args, PyObject * kwds)
{
char* filter_name = NULL;
PyObject* py_count = NULL;
PyObject * py_args = NULL;
PyObject* py_policy = NULL;
PyObject* py_from_value = NULL;
PyObject* py_end_value = NULL;
PyObject* py_elements_list = NULL;
PyObject* py_filter_name = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_list* arg_list = NULL;
as_list* elements_list = NULL;
as_val* from_val = NULL;
as_val* end_val = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_error err;
as_error_init(&err);
static char * kwlist[] = {"start_value", "end_value", "count", "function", "args", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OOO:range_limit", kwlist,
&py_from_value, &py_end_value, &py_count, &py_filter_name, &py_args, &py_policy)== false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
uint32_t count = 0;
if (PyInt_Check(py_count)) {
count = PyInt_AsLong(py_count);
} else if (PyLong_Check(py_count)) {
count = PyLong_AsLong(py_count);
if (count == (uint32_t)-1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long");
goto CLEANUP;
}
if(py_filter_name) {
if(PyStr_Check(py_filter_name)) {
filter_name = PyStr_AsString(py_filter_name);
} else if(py_filter_name != Py_None) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter name should be string or None");
goto CLEANUP;
}
}
if ( py_args && !py_filter_name) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name");
goto CLEANUP;
}
if ( !PyList_Check(py_args) && (py_args != Py_None)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)");
goto CLEANUP;
}
if (py_args != Py_None) {
pyobject_to_list(self->client, &err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON);
}
if( py_from_value != Py_None && py_end_value != Py_None ) {
pyobject_to_val(self->client, &err, py_from_value, &from_val, &static_pool, SERIALIZER_PYTHON);
pyobject_to_val(self->client, &err, py_end_value, &end_val, &static_pool, SERIALIZER_PYTHON);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Begin or end key cannot be None");
goto CLEANUP;
}
Py_BEGIN_ALLOW_THREADS
aerospike_llist_range_limit(self->client->as, &err, apply_policy_p, &self->key, &self->llist, from_val, end_val, count, filter_name, arg_list, &elements_list);
Py_END_ALLOW_THREADS
if(err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
list_to_pyobject(self->client, &err, elements_list, &py_elements_list);
CLEANUP:
if (elements_list) {
as_list_destroy(elements_list);
}
if(from_val) {
as_val_destroy(from_val);
}
if(end_val) {
as_val_destroy(end_val);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if (PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if (PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyStr_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_elements_list;
}
/**
*******************************************************************************************************
* Drop a role in the Aerospike DB.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Admin_Drop_Role(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
PyObject * py_role = NULL;
as_policy_admin admin_policy;
as_policy_admin *admin_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"role", "policy", NULL};
// Python Function Argument Parsing
if (PyArg_ParseTupleAndKeywords(args, kwds, "O|O:admin_drop_role", kwlist,
&py_role, &py_policy) == false) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
pyobject_to_policy_admin( &err, py_policy, &admin_policy, &admin_policy_p,
&self->as->config.policies.admin);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
char *role = NULL;
if (PyString_Check(py_role)) {
role = PyString_AsString(py_role);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Role name should be a string");
goto CLEANUP;
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_drop_role(self->as, &err, admin_policy_p, role);
Py_END_ALLOW_THREADS
CLEANUP:
if (err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Create a role in the Aerospike DB.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Admin_Create_Role(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
PyObject * py_role = NULL;
PyObject * py_privileges = NULL;
as_policy_admin admin_policy;
as_policy_admin *admin_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"role", "privileges", "policy", NULL};
// Python Function Argument Parsing
if (PyArg_ParseTupleAndKeywords(args, kwds, "OO|O:admin_create_role", kwlist,
&py_role, &py_privileges, &py_policy) == false) {
return NULL;
}
// Aerospike Operation Arguments
int privileges_size = 0;
as_privilege **privileges = NULL;
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python object to an array of privileges
if (!PyList_Check(py_privileges)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Privileges should be a list");
goto CLEANUP;
}
privileges_size = PyList_Size(py_privileges);
privileges = (as_privilege **)alloca(sizeof(as_privilege *) * privileges_size);
pyobject_to_as_privileges(&err, py_privileges, privileges, privileges_size);
pyobject_to_policy_admin( &err, py_policy, &admin_policy, &admin_policy_p,
&self->as->config.policies.admin);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
char *role = NULL;
if (PyString_Check(py_role)) {
role = PyString_AsString(py_role);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Role name should be a string");
goto CLEANUP;
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_create_role(self->as, &err, admin_policy_p, role, privileges, privileges_size);
Py_END_ALLOW_THREADS
CLEANUP:
if (privileges) {
for (int i = 0; i < privileges_size; i++) {
if (privileges[i])
cf_free(privileges[i]);
}
}
if (err.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Queries all users in the Aerospike DB.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Admin_Query_Users( AerospikeClient * self, PyObject * args, PyObject *kwds )
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
// Python Function Result
PyObject * py_users = NULL;
as_policy_admin admin_policy;
as_policy_admin *admin_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"policy", NULL};
// Python Function Argument Parsing
if (PyArg_ParseTupleAndKeywords(args, kwds, "|O:admin_query_users", kwlist, &py_policy) == false) {
return NULL;
}
// Aerospike Operation Arguments
int users_size = 0;
as_user **users = NULL;
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python object to policy_admin
pyobject_to_policy_admin(&err, py_policy, &admin_policy, &admin_policy_p,
&self->as->config.policies.admin);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_query_users(self->as, &err, admin_policy_p, &users, &users_size);
Py_END_ALLOW_THREADS
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
// Convert returned array of as_user structs into python object;
as_user_array_to_pyobject(&err, users, &py_users, users_size);
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (users) {
as_users_destroy(users, users_size);
}
if (err.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_users;
}
/**
*******************************************************************************************************
* This function invokes csdk's API's.
*
* @param self AerospikeClient object
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param key The C client's as_key that identifies the record.
* @param py_list The list containing op, bin and value.
* @param py_meta The metadata for the operation.
* @param operate_policy_p The value for operate policy.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_Operate_Invoke(
AerospikeClient * self, as_error *err,
as_key * key, PyObject * py_list, PyObject * py_meta,
as_policy_operate * operate_policy_p)
{
as_val* put_val = NULL;
char* bin = NULL;
char* val = NULL;
long offset = 0;
uint32_t ttl = 0;
long operation = 0;
int i = 0;
PyObject * py_rec = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
PyObject * py_bin = NULL;
as_record * rec = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_operations ops;
Py_ssize_t size = PyList_Size(py_list);
as_operations_inita(&ops, size);
if (!self || !self->as) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if(py_meta) {
AerospikeClient_CheckForMeta(py_meta, &ops, err);
}
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
for ( i = 0; i < size; i++) {
PyObject * py_val = PyList_GetItem(py_list, i);
operation = -1;
offset = 0;
if ( PyDict_Check(py_val) ) {
PyObject *key_op = NULL, *value = NULL;
PyObject * py_value = NULL;
Py_ssize_t pos = 0;
while (PyDict_Next(py_val, &pos, &key_op, &value)) {
if ( ! PyString_Check(key_op) ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "A operation key must be a string.");
goto CLEANUP;
} else {
char * name = PyString_AsString(key_op);
if(!strcmp(name,"op") && (PyInt_Check(value) || PyLong_Check(value))) {
operation = PyInt_AsLong(value);
} else if (!strcmp(name, "bin")) {
py_bin = value;
} else if(!strcmp(name, "val")) {
py_value = value;
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "operation can contain only op, bin and val keys");
goto CLEANUP;
}
}
}
if (py_bin) {
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
goto CLEANUP;
}
} else if (!py_bin && operation != AS_OPERATOR_TOUCH) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin is not given");
goto CLEANUP;
}
if (py_value) {
if (check_type(py_value, operation, err)) {
goto CLEANUP;
} else if (PyString_Check(py_value) && (operation == AS_OPERATOR_INCR)) {
char * incr_string = PyString_AsString(py_value);
int incr_value = 0, sign = 1;
if (strlen(incr_string) > 15) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported string length for increment operation");
goto CLEANUP;
}
if (*incr_string == '-') {
incr_string = incr_string + 1;
sign = -1;
} else if (*incr_string == '+') {
incr_string = incr_string + 1;
sign = 1;
}
while (*incr_string != '\0') {
if (*incr_string >= 48 && *incr_string <= 57) {
incr_value = (incr_value * 10) + (*incr_string ^ 0x30);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported operand type(s) for +: 'int' and 'str'");
goto CLEANUP;
}
incr_string = incr_string + 1;
}
incr_value = incr_value * sign;
py_value = PyInt_FromLong(incr_value);
}
} else if ((!py_value) && (operation != AS_OPERATOR_READ)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Value should be given");
goto CLEANUP;
}
switch(operation) {
case AS_OPERATOR_APPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_append_str(&ops, bin, val);
break;
case AS_OPERATOR_PREPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_prepend_str(&ops, bin, val);
break;
case AS_OPERATOR_INCR:
if (PyInt_Check(py_value)) {
offset = PyInt_AsLong(py_value);
} else if ( PyLong_Check(py_value) ) {
offset = PyLong_AsLong(py_value);
if(-1 == offset) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
as_operations_add_incr(&ops, bin, offset);
break;
case AS_OPERATOR_TOUCH:
if (PyInt_Check(py_value)) {
ops.ttl = PyInt_AsLong(py_value);
} else if ( PyLong_Check(py_value) ) {
ttl = PyLong_AsLong(py_value);
if((uint32_t)-1 == ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
ops.ttl = ttl;
}
as_operations_add_touch(&ops);
break;
case AS_OPERATOR_READ:
as_operations_add_read(&ops, bin);
break;
case AS_OPERATOR_WRITE:
pyobject_to_astype_write(err, bin, py_value, &put_val, &ops,
&static_pool, SERIALIZER_PYTHON);
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_operations_add_write(&ops, bin, (as_bin_value *) put_val);
break;
default:
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid operation given");
}
}
}
// Initialize record
as_record_init(rec, 0);
aerospike_key_operate(self->as, err, operate_policy_p, key, &ops, &rec);
if (err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
if(rec) {
record_to_pyobject(err, rec, key, &py_rec);
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
if (rec) {
as_record_destroy(rec);
}
if (key->valuep) {
as_key_destroy(key);
}
if (put_val) {
as_val_destroy(put_val);
}
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if (py_rec) {
return py_rec;
} else {
return PyLong_FromLong(0);
}
}
static PyObject * AerospikePredicates_GeoWithin_Radius(PyObject * self, PyObject * args)
{
PyObject * py_bin = NULL;
PyObject * py_lat = NULL;
PyObject * py_long = NULL;
PyObject * py_radius = NULL;
PyObject * py_geo_object = NULL;
PyObject * py_shape = NULL;
as_error err;
as_error_init(&err);
py_geo_object = PyDict_New();
if (PyArg_ParseTuple(args, "OOOO:geo_within_radius",
&py_bin, &py_lat, &py_long, &py_radius) == false) {
goto CLEANUP;
}
PyObject *py_circle = PyString_FromString("AeroCircle");
PyDict_SetItemString(py_geo_object, "type", py_circle);
Py_DECREF(py_circle);
if (PyString_Check(py_bin) && PyFloat_Check(py_lat) && PyFloat_Check(py_long) && PyFloat_Check(py_radius)) {
PyObject * py_outer_list = PyList_New(2);
PyObject * py_inner_list = PyList_New(2);
PyList_SetItem(py_inner_list, 0, py_lat);
PyList_SetItem(py_inner_list, 1, py_long);
PyList_SetItem(py_outer_list, 0, py_inner_list);
PyList_SetItem(py_outer_list, 1, py_radius);
PyDict_SetItemString(py_geo_object, "coordinates", py_outer_list);
py_shape = AerospikeGeospatial_DoDumps(py_geo_object, &err);
if (!py_shape) {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Unable to call dumps function");
goto CLEANUP;
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Latitude, longitude and radius should be of double type, bin of string type");
goto CLEANUP;
}
return Py_BuildValue("iiOO", AS_PREDICATE_RANGE, AS_INDEX_GEO2DSPHERE, py_bin, py_shape);
CLEANUP:
// If an error occurred, tell Python.
if (err.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
/**
*******************************************************************************************************
* Increments a numeric value in a bin.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Increment(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_key = NULL;
PyObject * py_policy = NULL;
PyObject * py_result = NULL;
PyObject * py_bin = NULL;
PyObject * py_meta = NULL;
PyObject * py_offset_value = 0;
as_key key;
as_policy_operate operate_policy;
as_policy_operate *operate_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"key", "bin", "offset", "meta",
"policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OO:increment", kwlist,
&py_key, &py_bin, &py_offset_value, &py_meta,
&py_policy) == false ) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err,
py_key, py_policy, &key, &operate_policy, &operate_policy_p);
if (!py_result) {
goto CLEANUP;
} else {
Py_DECREF(py_result);
}
PyObject * py_list = NULL;
py_list = create_pylist(py_list, AS_OPERATOR_INCR, py_bin, py_offset_value);
py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list,
py_meta, operate_policy_p);
if (py_list) {
Py_DECREF(py_list);
}
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
} else if (py_result == NULL) {
return NULL;
} else {
Py_DECREF(py_result);
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", py_bin);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
AerospikeQuery * AerospikeQuery_Where(AerospikeQuery * self, PyObject * args)
{
as_error err;
int rc = 0;
PyObject * py_arg1 = NULL;
PyObject * py_arg2 = NULL;
PyObject * py_arg3 = NULL;
PyObject * py_arg4 = NULL;
PyObject * py_arg5 = NULL;
PyObject * py_arg6 = NULL;
if ( PyArg_ParseTuple(args, "O|OOOOO:where", &py_arg1, &py_arg2, &py_arg3, &py_arg4, &py_arg5, &py_arg6) == false ) {
return NULL;
}
as_error_init(&err);
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
if ( PyTuple_Check(py_arg1) ) {
Py_ssize_t size = PyTuple_Size(py_arg1);
if ( size < 1 ) {
// If it ain't atleast 1, then raise error
return NULL;
}
PyObject * py_op = PyTuple_GetItem(py_arg1, 0);
PyObject * py_op_data = PyTuple_GetItem(py_arg1, 1);
if ( PyInt_Check(py_op) && PyInt_Check(py_op_data)) {
as_predicate_type op = (as_predicate_type) PyInt_AsLong(py_op);
as_index_datatype op_data = (as_index_datatype) PyInt_AsLong(py_op_data);
rc = AerospikeQuery_Where_Add(
self,
op,
op_data,
size > 2 ? PyTuple_GetItem(py_arg1, 2) : Py_None,
size > 3 ? PyTuple_GetItem(py_arg1, 3) : Py_None,
size > 4 ? PyTuple_GetItem(py_arg1, 4) : Py_None,
size > 5 ? PyInt_AsLong(PyTuple_GetItem(py_arg1, 5)) : 0
);
}
}
else if ( (py_arg1) && PyString_Check(py_arg1) && (py_arg2) && PyString_Check(py_arg2) ) {
char * op = PyString_AsString(py_arg2);
if ( strcmp(op, "equals") == 0 ) {
if ( PyInt_Check(py_arg3) || PyLong_Check(py_arg3) ) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_EQUAL,
AS_INDEX_NUMERIC,
py_arg1,
py_arg3,
Py_None,
0
);
}
else if ( PyString_Check(py_arg3) || PyUnicode_Check(py_arg3) ) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_EQUAL,
AS_INDEX_STRING,
py_arg1,
py_arg3,
Py_None,
0
);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'equals' expects a bin and string value.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
rc = 1;
}
}
else if ( strcmp(op, "between") == 0 ) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_RANGE,
AS_INDEX_NUMERIC,
py_arg1,
py_arg3,
py_arg4,
0
);
}
else if ( strcmp(op, "contains") == 0 ) {
int index_type;
int type;
if(PyInt_Check(py_arg3)) {
index_type = PyInt_AsLong(py_arg3);
} else if (PyLong_Check(py_arg3)) {
index_type = PyLong_AsLongLong(py_arg3);
}
if(PyInt_Check(py_arg4)) {
type = PyInt_AsLong(py_arg4);
} else if ( PyLong_Check(py_arg4) ) {
type = PyLong_AsLongLong(py_arg4);
}
if ( (PyInt_Check(py_arg5) || PyLong_Check(py_arg5)) && type == 1) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_EQUAL,
AS_INDEX_NUMERIC,
py_arg1,
py_arg5,
Py_None,
index_type
);
}
else if ( (PyString_Check(py_arg5) || PyUnicode_Check(py_arg5)) && type == 0) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_EQUAL,
AS_INDEX_STRING,
py_arg1,
py_arg5,
Py_None,
index_type
);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'contains' expects a bin and a string or int value.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
rc = 1;
}
}
else if ( strcmp(op, "range") == 0 ) {
int index_type;
if(PyInt_Check(py_arg3)) {
index_type = PyInt_AsLong(py_arg3);
} else if (PyLong_Check(py_arg3)) {
index_type = PyLong_AsLongLong(py_arg3);
}
if ( PyInt_Check(py_arg4) || PyLong_Check(py_arg4)) {
rc = AerospikeQuery_Where_Add(
self,
AS_PREDICATE_RANGE,
AS_INDEX_NUMERIC,
py_arg1,
py_arg5,
py_arg6,
index_type
);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'range' expects a bin and two numeric values.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
rc = 1;
}
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate '%s' is invalid.", op);
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
rc = 1;
}
// if ( PyInt_Check(py_op) ) {
// rc = AerospikeQuery_Where_Add(
// &self->query,
// PyInt_AsLong(py_op),
// size > 1 ? PyTuple_GetItem(py_predicate, 1) : Py_None,
// size > 2 ? PyTuple_GetItem(py_predicate, 2) : Py_None,
// size > 3 ? PyTuple_GetItem(py_predicate, 3) : Py_None
// );
// }
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate is invalid.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
Py_DECREF(py_err);
as_query_destroy(&self->query);
rc = 1;
}
CLEANUP:
if ( rc == 1 ) {
return NULL;
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
TRACE();
return NULL;
}
Py_INCREF(self);
return self;
}
/**
*********************************************************************
* This function will invoke aerospike_batch_get_bins to get filtered
* bins from all the records in a batches.
*
* @param self AerospikeClient object
* @param py_keys List of keys passed on by user
* @param py_bins List of filter bins passed on by user
* @param py_policy User specified Policy dictionary
*
*********************************************************************
**/
static
PyObject * AerospikeClient_Select_Many_Invoke(
AerospikeClient * self,
PyObject * py_keys, PyObject * py_bins, PyObject * py_policy)
{
// Python Return Value
PyObject * py_recs = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_batch policy;
as_policy_batch * batch_policy_p = NULL;
Py_ssize_t bins_size = 0;
char **filter_bins = NULL;
bool has_batch_index = false;
// Unicode object's pool
UnicodePyObjects u_objs;
u_objs.size = 0;
int i = 0;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Check the type of bins and get it's size
// i.e. number of bins provided
if (py_bins != NULL && PyList_Check(py_bins)) {
bins_size = PyList_Size(py_bins);
}
else if (py_bins != NULL && PyTuple_Check(py_bins)) {
bins_size = PyTuple_Size(py_bins);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter bins should be specified as a list or tuple.");
goto CLEANUP;
}
filter_bins = (char **)malloc(sizeof(long int) * bins_size);
for (i = 0; i < bins_size; i++) {
PyObject *py_bin = NULL;
if(PyList_Check(py_bins)) {
py_bin = PyList_GetItem(py_bins, i);
}
if(PyTuple_Check(py_bins)) {
py_bin = PyTuple_GetItem(py_bins, i);
}
if (PyUnicode_Check(py_bin)) {
// Store the unicode object into a pool
// It is DECREFed at later stages
// So, no need of DECREF here.
filter_bins[i] = PyStr_AsString(
store_unicode_bins(&u_objs, PyUnicode_AsUTF8String(py_bin)));
}
else if (PyStr_Check(py_bin)) {
filter_bins[i] = PyStr_AsString(py_bin);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Bin name should be a string or unicode string.");
goto CLEANUP;
}
}
// Convert python policy object to as_policy_batch
pyobject_to_policy_batch(&err, py_policy, &policy, &batch_policy_p,
&self->as->config.policies.batch);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
has_batch_index = aerospike_has_batch_index(self->as);
if (has_batch_index) {
py_recs = batch_select_aerospike_batch_read(&err, self, py_keys, batch_policy_p, filter_bins, bins_size);
} else {
py_recs = batch_select_aerospike_batch_get(&err, self, py_keys, batch_policy_p, filter_bins, bins_size);
}
CLEANUP:
if (filter_bins != NULL) {
free(filter_bins);
}
// DECREFed all the unicode objects stored in Pool
for ( i = 0; i< u_objs.size; i++) {
Py_DECREF(u_objs.ob[i]);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_keys);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_recs;
}
/*
static char * pyobject_to_str(PyObject * py_obj)
{
if ( PyString_Check(py_obj) ) {
return PyString_AsString(py_obj);
}
else {
return NULL;
}
}
*/
static int AerospikeQuery_Where_Add(AerospikeQuery * self, as_predicate_type predicate, as_index_datatype in_datatype, PyObject * py_bin, PyObject * py_val1, PyObject * py_val2, int index_type)
{
as_error err;
char * val = NULL, * bin = NULL;
PyObject * py_ubin = NULL;
switch (predicate) {
case AS_PREDICATE_EQUAL: {
if ( in_datatype == AS_INDEX_STRING ){
if (PyUnicode_Check(py_bin)){
py_ubin = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ubin);
} else if (PyString_Check(py_bin) ){
bin = PyString_AsString(py_bin);
}
else {
return 1;
}
if (PyUnicode_Check(py_val1)){
val = PyString_AsString(
StoreUnicodePyObject( self,
PyUnicode_AsUTF8String(py_val1) ));
} else if (PyString_Check(py_val1) ){
val = PyString_AsString(py_val1);
}
else {
return 1;
}
as_query_where_init(&self->query, 1);
if(index_type == 0) {
as_query_where(&self->query, bin, as_equals( STRING, val ));
} else if(index_type == 1) {
as_query_where(&self->query, bin, as_contains( LIST, STRING, val ));
} else if(index_type == 2) {
as_query_where(&self->query, bin, as_contains( MAPKEYS, STRING, val ));
} else if(index_type == 3) {
as_query_where(&self->query, bin, as_contains( MAPVALUES, STRING, val ));
} else {
return 1;
}
if (py_ubin){
Py_DECREF(py_ubin);
py_ubin = NULL;
}
}
else if ( in_datatype == AS_INDEX_NUMERIC ){
if (PyUnicode_Check(py_bin)){
py_ubin = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ubin);
} else if (PyString_Check(py_bin) ){
bin = PyString_AsString(py_bin);
}
else {
return 1;
}
int64_t val = pyobject_to_int64(py_val1);
as_query_where_init(&self->query, 1);
if(index_type == 0) {
as_query_where(&self->query, bin, as_equals( NUMERIC, val ));
} else if(index_type == 1) {
as_query_where(&self->query, bin, as_contains( LIST, NUMERIC, val ));
} else if(index_type == 2) {
as_query_where(&self->query, bin, as_contains( MAPKEYS, NUMERIC, val ));
} else if(index_type == 3) {
as_query_where(&self->query, bin, as_contains( MAPVALUES, NUMERIC, val ));
} else {
return 1;
}
if (py_ubin){
Py_DECREF(py_ubin);
py_ubin = NULL;
}
}
else {
// If it ain't expected, raise and error
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'equals' expects a string or integer value.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
return 1;
}
break;
}
case AS_PREDICATE_RANGE: {
if ( in_datatype == AS_INDEX_NUMERIC) {
if (PyUnicode_Check(py_bin)){
py_ubin = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ubin);
} else if (PyString_Check(py_bin)){
bin = PyString_AsString(py_bin);
}
else {
return 1;
}
int64_t min = pyobject_to_int64(py_val1);
int64_t max = pyobject_to_int64(py_val2);
as_query_where_init(&self->query, 1);
if(index_type == 0) {
as_query_where(&self->query, bin, as_range( DEFAULT, NUMERIC, min, max ));
} else if(index_type == 1) {
as_query_where(&self->query, bin, as_range( LIST, NUMERIC, min, max ));
} else if(index_type == 2) {
as_query_where(&self->query, bin, as_range( MAPKEYS, NUMERIC, min, max ));
} else if(index_type == 3) {
as_query_where(&self->query, bin, as_range( MAPVALUES, NUMERIC, min, max ));
} else {
return 1;
}
if (py_ubin){
Py_DECREF(py_ubin);
py_ubin = NULL;
}
}
else if ( in_datatype == AS_INDEX_STRING) {
// NOT IMPLEMENTED
}
else {
// If it ain't right, raise and error
as_error_update(&err, AEROSPIKE_ERR_PARAM, "predicate 'between' expects two integer values.");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
return 1;
}
break;
}
default: {
// If it ain't supported, raise and error
as_error_update(&err, AEROSPIKE_ERR_PARAM, "unknown predicate type");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
return 1;
}
}
return 0;
}
/**
*******************************************************************************************************
* Sends an info request to all the nodes in a cluster.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns a server response for the particular request string.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Info(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
PyObject * py_req = NULL;
PyObject * py_policy = NULL;
PyObject * py_hosts = NULL;
PyObject * py_nodes = NULL;
PyObject * py_ustr = NULL;
foreach_callback_info_udata info_callback_udata;
static char * kwlist[] = {"command", "hosts", "policy", NULL};
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:info", kwlist, &py_req, &py_hosts, &py_policy) == false ) {
return NULL;
}
as_error err;
as_error_init(&err);
as_policy_info info_policy;
as_policy_info* info_policy_p = NULL;
py_nodes = PyDict_New();
info_callback_udata.udata_p = py_nodes;
info_callback_udata.host_lookup_p = py_hosts;
as_error_init(&info_callback_udata.error);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_info
pyobject_to_policy_info(&err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
char * req = NULL;
if ( PyUnicode_Check(py_req)) {
py_ustr = PyUnicode_AsUTF8String(py_req);
req = PyString_AsString(py_ustr);
} else if( PyString_Check(py_req) ) {
req = PyString_AsString(py_req);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Request must be a string");
goto CLEANUP;
}
aerospike_info_foreach(self->as, &err, info_policy_p, req,
(aerospike_info_foreach_callback)AerospikeClient_Info_each,
&info_callback_udata);
if (&info_callback_udata.error.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if ( info_callback_udata.error.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&info_callback_udata.error, &py_err);
PyObject *exception_type = raise_exception(&info_callback_udata.error);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
if (py_nodes) {
Py_DECREF(py_nodes);
}
return NULL;
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
if (py_nodes) {
Py_DECREF(py_nodes);
}
return NULL;
}
return info_callback_udata.udata_p;
}
/**
*******************************************************************************************************
* This function invokes csdk's API's.
*
* @param self AerospikeClient object
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param key The C client's as_key that identifies the record.
* @param py_list The list containing op, bin and value.
* @param py_meta The metadata for the operation.
* @param operate_policy_p The value for operate policy.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_Operate_Invoke(
AerospikeClient * self, as_error *err,
as_key * key, PyObject * py_list, PyObject * py_meta,
as_policy_operate * operate_policy_p)
{
as_val* put_val = NULL;
char* bin = NULL;
char* val = NULL;
long offset = 0;
double double_offset = 0.0;
uint32_t ttl = 0;
long operation = 0;
int i = 0;
PyObject * py_rec = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
PyObject * py_bin = NULL;
as_record * rec = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_operations ops;
Py_ssize_t size = PyList_Size(py_list);
as_operations_inita(&ops, size);
if (!self || !self->as) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if(py_meta) {
AerospikeClient_CheckForMeta(py_meta, &ops, err);
}
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
for ( i = 0; i < size; i++) {
PyObject * py_val = PyList_GetItem(py_list, i);
operation = -1;
offset = 0;
double_offset = 0.0;
if ( PyDict_Check(py_val) ) {
PyObject *key_op = NULL, *value = NULL;
PyObject * py_value = NULL;
Py_ssize_t pos = 0;
while (PyDict_Next(py_val, &pos, &key_op, &value)) {
if ( ! PyString_Check(key_op) ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "A operation key must be a string.");
goto CLEANUP;
} else {
char * name = PyString_AsString(key_op);
if(!strcmp(name,"op") && (PyInt_Check(value) || PyLong_Check(value))) {
operation = PyInt_AsLong(value);
} else if (!strcmp(name, "bin")) {
py_bin = value;
} else if(!strcmp(name, "val")) {
py_value = value;
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "operation can contain only op, bin and val keys");
goto CLEANUP;
}
}
}
if (py_bin) {
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else if (PyByteArray_Check(py_bin)) {
bin = PyByteArray_AsString(py_bin);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
goto CLEANUP;
}
if (self->strict_types) {
if (strlen(bin) > AS_BIN_NAME_MAX_LEN) {
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
as_error_update(err, AEROSPIKE_ERR_BIN_NAME, "A bin name should not exceed 14 characters limit");
goto CLEANUP;
}
}
} else if (!py_bin && operation != AS_OPERATOR_TOUCH) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin is not given");
goto CLEANUP;
}
if (py_value) {
if (self->strict_types) {
if (check_type(self, py_value, operation, err)) {
goto CLEANUP;
}
}
} else if ((!py_value) && (operation != AS_OPERATOR_READ && operation != AS_OPERATOR_TOUCH)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Value should be given");
goto CLEANUP;
}
switch(operation) {
case AS_OPERATOR_APPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
as_operations_add_append_str(&ops, bin, val);
} else if (PyString_Check(py_value)) {
val = PyString_AsString(py_value);
as_operations_add_append_str(&ops, bin, val);
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, &static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_operations_add_append_raw(&ops, bin, bytes->value, bytes->size);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_APPEND;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_PREPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
as_operations_add_prepend_str(&ops, bin, val);
} else if (PyString_Check(py_value)) {
val = PyString_AsString(py_value);
as_operations_add_prepend_str(&ops, bin, val);
} else if (PyByteArray_Check(py_value)) {
as_bytes *bytes;
GET_BYTES_POOL(bytes, &static_pool, err);
serialize_based_on_serializer_policy(self, SERIALIZER_PYTHON, &bytes, py_value, err);
as_operations_add_prepend_raw(&ops, bin, bytes->value, bytes->size);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_PREPEND;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_INCR:
if (PyInt_Check(py_value)) {
offset = PyInt_AsLong(py_value);
as_operations_add_incr(&ops, bin, offset);
} else if ( PyLong_Check(py_value) ) {
offset = PyLong_AsLong(py_value);
if (offset == -1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
}
as_operations_add_incr(&ops, bin, offset);
} else if (PyFloat_Check(py_value)) {
double_offset = PyFloat_AsDouble(py_value);
as_operations_add_incr_double(&ops, bin, double_offset);
} else {
if (!self->strict_types || !strcmp(py_value->ob_type->tp_name, "aerospike.null")) {
as_operations *pointer_ops = &ops;
as_binop *binop = &pointer_ops->binops.entries[pointer_ops->binops.size++];
binop->op = AS_OPERATOR_INCR;
initialize_bin_for_strictypes(self, err, py_value, binop, bin, &static_pool);
}
}
break;
case AS_OPERATOR_TOUCH:
ops.ttl = 0;
if (py_value && PyInt_Check(py_value)) {
ops.ttl = PyInt_AsLong(py_value);
} else if (py_value && PyLong_Check(py_value)) {
ttl = PyLong_AsLong(py_value);
if((uint32_t)-1 == ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
ops.ttl = ttl;
}
as_operations_add_touch(&ops);
break;
case AS_OPERATOR_READ:
as_operations_add_read(&ops, bin);
break;
case AS_OPERATOR_WRITE:
pyobject_to_astype_write(self, err, bin, py_value, &put_val, &ops,
&static_pool, SERIALIZER_PYTHON);
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_operations_add_write(&ops, bin, (as_bin_value *) put_val);
break;
default:
if (self->strict_types) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid operation given");
goto CLEANUP;
}
}
}
}
// Initialize record
as_record_init(rec, 0);
Py_BEGIN_ALLOW_THREADS
aerospike_key_operate(self->as, err, operate_policy_p, key, &ops, &rec);
Py_END_ALLOW_THREADS
if (err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
if(rec) {
record_to_pyobject(self, err, rec, key, &py_rec);
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
if (rec) {
as_record_destroy(rec);
}
if (key->valuep) {
as_key_destroy(key);
}
if (put_val) {
as_val_destroy(put_val);
}
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if (py_rec) {
return py_rec;
} else {
return PyLong_FromLong(0);
}
}
/**
*******************************************************************************************************
* This function applies a registered udf module on a particular record.
*
* @param self AerospikeClient object
* @param py_key The key under which the record is stored.
* @param py_policy The dictionary of policies
*
* Returns a tuple of record having key and meta sequentially.
*******************************************************************************************************
*/
extern PyObject * AerospikeClient_Exists_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_policy)
{
// Python Return Value
PyObject * py_result = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_read read_policy;
as_policy_read * read_policy_p = NULL;
as_key key;
as_record * rec = NULL;
// Initialisation flags
bool key_initialised = false;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// key is initialised successfully
key_initialised = true;
// Convert python policy object to as_policy_exists
pyobject_to_policy_read(&err, py_policy, &read_policy, &read_policy_p,
&self->as->config.policies.read);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_key_exists(self->as, &err, read_policy_p, &key, &rec);
Py_END_ALLOW_THREADS
if ( err.code == AEROSPIKE_OK ) {
PyObject * py_result_key = NULL;
PyObject * py_result_meta = NULL;
key_to_pyobject(&err, &key, &py_result_key);
metadata_to_pyobject(&err, rec, &py_result_meta);
py_result = PyTuple_New(2);
PyTuple_SetItem(py_result, 0, py_result_key);
PyTuple_SetItem(py_result, 1, py_result_meta);
}
else {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (key_initialised == true){
// Destroy the key if it is initialised successfully.
as_key_destroy(&key);
}
as_record_destroy(rec);
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
}
return py_result;
}
/*
*******************************************************************************************************
* If serialize_flag == true, executes the passed user_serializer_callback,
* by creating as_bytes (bytes) from the passed Py_Object (value).
* Else executes the passed user_deserializer_callback,
* by passing the as_bytes (bytes) to the deserializer and getting back
* the corresponding Py_Object (value).
*
* @param user_callback_info The user_serializer_callback for the user
* callback to be executed.
* @param bytes The as_bytes to be stored/retrieved.
* @param value The value to be retrieved/stored.
* @param serialize_flag The flag which indicates
* serialize/deserialize.
* @param error_p The as_error to be populated by the
* function with encountered error if any.
*******************************************************************************************************
*/
void execute_user_callback(user_serializer_callback *user_callback_info,
as_bytes **bytes,
PyObject **value,
bool serialize_flag,
as_error *error_p)
{
PyObject * py_return = NULL;
PyObject * py_value = NULL;
PyObject * py_arglist = PyTuple_New(1);
int len;
if (serialize_flag) {
Py_XINCREF(*value);
if( PyTuple_SetItem(py_arglist, 0 , *value) != 0){
Py_DECREF(py_arglist);
goto CLEANUP;
}
} else {
as_bytes * bytes_pointer = *bytes;
char* bytes_val_p = (char*)bytes_pointer->value;
py_value = PyStr_FromStringAndSize(bytes_val_p, as_bytes_size(*bytes));
if (PyTuple_SetItem(py_arglist, 0 , py_value) != 0){
Py_DECREF(py_arglist);
goto CLEANUP;
}
}
Py_INCREF(user_callback_info -> callback);
py_return = PyEval_CallObject(user_callback_info->callback, py_arglist);
Py_DECREF(user_callback_info -> callback);
Py_DECREF(py_arglist);
if (py_return) {
if (serialize_flag) {
char * py_val = PyStr_AsString(py_return);
len = PyBytes_Size(py_return);
set_as_bytes(bytes, (uint8_t *) py_val,
len, AS_BYTES_BLOB, error_p);
Py_DECREF(py_return);
} else {
*value = py_return;
}
} else {
if (serialize_flag) {
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to call user's registered serializer callback");
goto CLEANUP;
} else {
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to call user's registered deserializer callback");
goto CLEANUP;
}
}
CLEANUP:
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
}
}
/**
*******************************************************************************************************
* This function read a record with a given key, and return the record.
*
* @param self AerospikeClient object
* @param py_key The key under which to store the record.
* @param py_policy The dictionary of policies to be given while
* reading a record.
*
* Returns the record on success.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Get_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_policy)
{
// Python Return Value
PyObject * py_rec = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_read read_policy;
as_policy_read * read_policy_p = NULL;
as_key key;
as_record * rec = NULL;
// Initialised flags
bool key_initialised = false;
bool record_initialised = false;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Key is successfully initialised.
key_initialised = true;
// Convert python policy object to as_policy_exists
pyobject_to_policy_read(&err, py_policy, &read_policy, &read_policy_p,
&self->as->config.policies.read);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Initialize record
as_record_init(rec, 0);
// Record initialised successfully.
record_initialised = true;
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_key_get(self->as, &err, read_policy_p, &key, &rec);
Py_END_ALLOW_THREADS
if ( err.code == AEROSPIKE_OK ) {
record_to_pyobject(self, &err, rec, &key, &py_rec);
if ( read_policy_p == NULL ||
( read_policy_p != NULL && read_policy_p->key == AS_POLICY_KEY_DIGEST)){
// This is a special case.
// C-client returns NULL key, so to the user
// response will be (<ns>, <set>, None, <digest>)
// Using the same input key, just making primary key part to be None
// Only in case of POLICY_KEY_DIGEST or no policy specified
PyObject * p_key = PyTuple_GetItem( py_rec, 0 );
Py_INCREF(Py_None);
PyTuple_SetItem(p_key, 2, Py_None);
}
}
else {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (key_initialised == true){
// Destroy key only if it is initialised.
as_key_destroy(&key);
}
if (record_initialised == true){
// Destroy record only if it is initialised.
as_record_destroy(rec);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_rec;
}
/*
*******************************************************************************************************
* Checks serializer_policy.
* Serializes Py_Object (value) into as_bytes using serialization logic
* based on serializer_policy.
*
* @param serializer_policy The serializer_policy to be used to handle
* the serialization.
* @param bytes The as_bytes to be set.
* @param value The value to be serialized.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * serialize_based_on_serializer_policy(AerospikeClient * self,
int32_t serializer_policy,
as_bytes **bytes,
PyObject *value,
as_error *error_p)
{
uint8_t use_client_serializer = true;
PyObject* initresult = NULL;
if (self->is_client_put_serializer) {
if (serializer_policy == SERIALIZER_USER) {
if (!self->user_serializer_call_info.callback) {
use_client_serializer = false;
}
}
} else if (self->user_serializer_call_info.callback) {
serializer_policy = SERIALIZER_USER;
}
switch(serializer_policy) {
case SERIALIZER_NONE:
as_error_update(error_p, AEROSPIKE_ERR_PARAM,
"Cannot serialize: SERIALIZER_NONE selected");
goto CLEANUP;
case SERIALIZER_PYTHON:
{
/*
* Serialize bytearray as is and store them into database with
* type AS_BYTES_BLOB, unlike other values in case of
* SERIALIZER_PYTHON.
* This is a special case.
* Refer: AER-3589 for more details.
*/
if (PyByteArray_Check(value)) {
uint8_t *bytes_array = (uint8_t *) PyByteArray_AsString(value);
uint32_t bytes_array_len = (uint32_t) PyByteArray_Size(value);
set_as_bytes(bytes, bytes_array, bytes_array_len, AS_BYTES_BLOB, error_p);
} else {
/* get the sys.modules dictionary */
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
PyObject * py_funcname = PyStr_FromString("dumps");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module,
py_funcname, value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call dumps function");
goto CLEANUP;
} else {
Py_INCREF(initresult);
char *return_value = PyStr_AsString(initresult);
Py_ssize_t len = PyBytes_GET_SIZE(initresult);
set_as_bytes(bytes, (uint8_t *) return_value,
len, AS_BYTES_PYTHON, error_p);
Py_DECREF(initresult);
}
}
Py_XDECREF(cpickle_module);
}
}
break;
case SERIALIZER_JSON:
/*
* TODO:
* Handle JSON serialization after support for AS_BYTES_JSON
* is added in aerospike-client-c
*/
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to serialize using standard json serializer");
goto CLEANUP;
case SERIALIZER_USER:
if (use_client_serializer) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
if (is_user_serializer_registered) {
execute_user_callback(&user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else if (self->user_serializer_call_info.callback) {
execute_user_callback(&self->user_serializer_call_info, bytes, &value, true, error_p);
if (AEROSPIKE_OK != (error_p->code)) {
goto CLEANUP;
}
} else {
as_error_update(error_p, AEROSPIKE_ERR,
"No serializer callback registered");
goto CLEANUP;
}
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unsupported serializer");
goto CLEANUP;
}
CLEANUP:
Py_XDECREF(initresult);
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
********************************************************************************************************
* Scan the set and apply a predicate filter.
*
* @param self AerospikeLSet object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns a list of elements from the set after applying predicate.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLSet_Filter(AerospikeLSet * self, PyObject * args, PyObject * kwds)
{
char* filter_name = NULL;
PyObject * py_args = NULL;
PyObject* py_policy = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_list* arg_list = NULL;
as_list* elements_list = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_error err;
as_error_init(&err);
static char * kwlist[] = {"udf_function_name", "args", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "|sOO:filter", kwlist,
&filter_name, &py_args, &py_policy) == false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
if ( py_args && !filter_name) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name");
goto CLEANUP;
}
if ( py_args && !PyList_Check(py_args)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)");
goto CLEANUP;
}
if (py_args) {
pyobject_to_list(self->client, &err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON);
}
aerospike_lset_filter(self->client->as, &err, apply_policy_p, &self->key,
&self->lset, filter_name, arg_list, &elements_list);
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
PyObject* py_list = NULL;
list_to_pyobject(&err, elements_list, &py_list);
CLEANUP:
if (elements_list) {
as_list_destroy(elements_list);
}
if (arg_list) {
as_list_destroy(arg_list);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if(PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyString_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_list;
}
/*
*******************************************************************************************************
* Checks as_bytes->type.
* Deserializes as_bytes into Py_Object (retval) using deserialization logic
* based on as_bytes->type.
*
* @param bytes The as_bytes to be deserialized.
* @param retval The return zval to be populated with the
* deserialized value of the input as_bytes.
* @param error_p The as_error to be populated by the function
* with encountered error if any.
*******************************************************************************************************
*/
extern PyObject * deserialize_based_on_as_bytes_type(AerospikeClient * self,
as_bytes *bytes,
PyObject **retval,
as_error *error_p)
{
switch(as_bytes_get_type(bytes)) {
case AS_BYTES_PYTHON: {
PyObject* sysmodules = PyImport_GetModuleDict();
PyObject* cpickle_module = NULL;
if(PyMapping_HasKeyString(sysmodules, "cPickle")) {
cpickle_module = PyMapping_GetItemString(sysmodules, "cPickle");
} else {
cpickle_module = PyImport_ImportModule("cPickle");
}
PyObject* initresult = NULL;
if(!cpickle_module) {
/* insert error handling here! and exit this function */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to load cpickle module");
goto CLEANUP;
} else {
char* bytes_val_p = (char*)bytes->value;
PyObject *py_value = PyStr_FromStringAndSize(bytes_val_p, as_bytes_size(bytes));
PyObject *py_funcname = PyStr_FromString("loads");
Py_INCREF(cpickle_module);
initresult = PyObject_CallMethodObjArgs(cpickle_module, py_funcname, py_value, NULL);
Py_DECREF(cpickle_module);
Py_DECREF(py_funcname);
Py_DECREF(py_value);
if(!initresult) {
/* more error handling &c */
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to call loads function");
goto CLEANUP;
} else {
*retval = initresult;
}
}
Py_XDECREF(cpickle_module);
}
break;
case AS_BYTES_BLOB: {
if (self->user_deserializer_call_info.callback) {
execute_user_callback(&self->user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
as_error_update(error_p, AEROSPIKE_OK, NULL);
}
} else {
if (is_user_deserializer_registered) {
execute_user_callback(&user_deserializer_call_info, &bytes, retval, false, error_p);
if(AEROSPIKE_OK != (error_p->code)) {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
as_error_update(error_p, AEROSPIKE_OK, NULL);
*retval = py_val;
}
} else {
uint32_t bval_size = as_bytes_size(bytes);
PyObject *py_val = PyByteArray_FromStringAndSize((char *) as_bytes_get(bytes), bval_size);
if (!py_val) {
as_error_update(error_p, AEROSPIKE_ERR_CLIENT, "Unable to deserialize bytes");
goto CLEANUP;
}
*retval = py_val;
}
}
}
break;
case AS_BYTES_LDT: {
Py_INCREF(Py_None);
*retval = Py_None;
}
break;
default:
as_error_update(error_p, AEROSPIKE_ERR,
"Unable to deserialize bytes");
goto CLEANUP;
}
CLEANUP:
if ( error_p->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(error_p, &py_err);
PyObject *exception_type = raise_exception(error_p);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
********************************************************************************************************
* Test existence of an object in the set.
*
* @param self AerospikeLSet object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns true on success, Otherwise false is returned.
* In case of error,appropriate exceptions will be raised.
********************************************************************************************************
*/
PyObject * AerospikeLSet_Exists(AerospikeLSet * self, PyObject * args, PyObject * kwds)
{
PyObject * py_value = NULL;
PyObject* py_policy = NULL;
as_policy_apply apply_policy;
as_policy_apply* apply_policy_p = NULL;
as_val * val = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_error err;
as_error_init(&err);
static char * kwlist[] = {"value", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:exists", kwlist,
&py_value, &py_policy) == false ) {
return NULL;
}
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->client->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
pyobject_to_val(self->client, &err, py_value, &val, &static_pool, SERIALIZER_PYTHON);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_boolean exists;
as_boolean_init(&exists, false);
aerospike_lset_exists(self->client->as, &err, apply_policy_p, &self->key,
&self->lset, val, &exists);
if( err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (val) {
as_val_destroy(val);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL, *py_key = NULL;
PyObject *exception_type = raise_exception(&err);
error_to_pyobject(&err, &py_err);
if(PyObject_HasAttrString(exception_type, "key")) {
key_to_pyobject(&err, &self->key, &py_key);
PyObject_SetAttrString(exception_type, "key", py_key);
Py_DECREF(py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject *py_bins = PyString_FromString((char *)&self->bin_name);
PyObject_SetAttrString(exception_type, "bin", py_bins);
Py_DECREF(py_bins);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if (as_boolean_get(&exists))
return Py_True;
else
return Py_False;
}
/**
*******************************************************************************************************
* Changes the password of a particular user in the Aerospike DB.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Admin_Change_Password( AerospikeClient *self, PyObject *args, PyObject *kwds )
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
PyObject * py_user = NULL;
PyObject * py_password = NULL;
as_policy_admin admin_policy;
as_policy_admin *admin_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"user", "password", "policy", NULL};
// Python Function Argument Parsing
if (PyArg_ParseTupleAndKeywords(args, kwds, "OO|O:admin_change_password", kwlist,
&py_user, &py_password, &py_policy) == false) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Aerospike Operation Arguments
char *user = NULL, *password = NULL;
// Convert python object to policy_admin
pyobject_to_policy_admin(&err, py_policy, &admin_policy, &admin_policy_p,
&self->as->config.policies.admin);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
// Convert python objects into username and password strings
if (!PyString_Check(py_user)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Username should be a string");
goto CLEANUP;
}
user = PyString_AsString(py_user);
if (!PyString_Check(py_password)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Password should be a string");
goto CLEANUP;
}
password = PyString_AsString(py_password);
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_change_password( self->as, &err, admin_policy_p, user, password );
Py_END_ALLOW_THREADS
char *alias_to_search = NULL;
alias_to_search = return_search_string(self->as);
PyObject *py_persistent_item = NULL;
py_persistent_item = PyDict_GetItemString(py_global_hosts, alias_to_search);
if (py_persistent_item) {
PyDict_DelItemString(py_global_hosts, alias_to_search);
AerospikeGlobalHosts_Del(py_persistent_item);
}
PyMem_Free(alias_to_search);
alias_to_search = NULL;
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (err.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}