/**
*******************************************************************************************************
* 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 = PyStr_AsString(py_ustr);
} else if( PyStr_Check(py_req) ) {
req = PyStr_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;
}
/**
*******************************************************************************************************
* Gets the code for a UDF module registered with the server
*
* @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 the content of the UDF module.
*******************************************************************************************************
*/
PyObject * AerospikeClient_UDF_Get_UDF(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_module = NULL;
PyObject * py_policy = NULL;
long language = 0;
bool init_udf_file = false;
PyObject * udf_content = NULL;
PyObject * py_ustr = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"module", "language", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|lO:udf_get", kwlist,
&py_module ,&language, &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;
}
if(language != AS_UDF_TYPE_LUA)
{
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Invalid language");
goto CLEANUP;
}
char* strModule = NULL;
if ( PyUnicode_Check(py_module) ) {
py_ustr = PyUnicode_AsUTF8String(py_module);
strModule = PyString_AsString(py_ustr);
}
else if ( PyString_Check(py_module)){
strModule = PyString_AsString(py_module);
}
else
{
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Module name should be a string or unicode string.");
goto CLEANUP;
}
// Convert python object to policy_info
as_policy_info *info_policy_p = NULL, info_policy;
pyobject_to_policy_info( &err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
as_udf_file file;
as_udf_file_init(&file);
init_udf_file=true;
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_udf_get(self->as, &err, info_policy_p, strModule, (language - AS_UDF_TYPE_LUA) , &file);
Py_END_ALLOW_THREADS
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
udf_content = Py_BuildValue("s#", file.content.bytes, file.content.size);
CLEANUP:
if (py_ustr){
Py_DECREF(py_ustr);
}
if(init_udf_file)
{
as_udf_file_destroy(&file);
}
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, "module")) {
PyObject_SetAttrString(exception_type, "module", py_module);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return udf_content;
}
/**
*******************************************************************************************************
* Registers a UDF module with 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_UDF_Put(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_filename = NULL;
long language = 0;
PyObject * py_udf_type = NULL;
PyObject * py_policy = NULL;
PyObject * py_ustr = NULL;
uint8_t * bytes = NULL;
as_policy_info info_policy;
as_policy_info *info_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"filename", "udf_type", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|lO:udf_put", kwlist,
&py_filename, &language, &py_policy) == false ) {
return NULL;
}
if(language != AS_UDF_TYPE_LUA)
{
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Invalid UDF language");
goto CLEANUP;
}
py_udf_type = PyLong_FromLong(language);
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 PyObject into a filename string
char *filename = NULL;
if (PyUnicode_Check(py_filename)) {
py_ustr = PyUnicode_AsUTF8String(py_filename);
filename = PyString_AsString(py_ustr);
} else if (PyString_Check(py_filename)) {
filename = PyString_AsString(py_filename);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filename should be a string");
goto CLEANUP;
}
// Convert python object to 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;
}
as_udf_type udf_type = (as_udf_type)PyInt_AsLong(py_udf_type);
// Convert lua file to content
as_bytes content;
FILE * file_p = fopen(filename,"r");
FILE * copy_file_p = NULL;
char copy_filepath[AS_CONFIG_PATH_MAX_LEN] = {0};
uint32_t user_path_len = strlen(self->as->config.lua.user_path);
memcpy( copy_filepath,
self->as->config.lua.user_path,
user_path_len);
if ( self->as->config.lua.user_path[user_path_len-1] != '/' ) {
memcpy( copy_filepath + user_path_len, "/", 1);
user_path_len = user_path_len + 1;
}
char* extracted_filename = strrchr(filename, '/');
if (extracted_filename) {
memcpy( copy_filepath + user_path_len, extracted_filename + 1, strlen(extracted_filename) - 1);
copy_filepath[user_path_len + strlen(extracted_filename) - 1] = '\0';
} else {
memcpy( copy_filepath + user_path_len, filename, strlen(filename));
copy_filepath[user_path_len + strlen(filename)] = '\0';
}
if ( !file_p ) {
as_error_update(&err, AEROSPIKE_ERR_LUA_FILE_NOT_FOUND, "cannot open script file");
goto CLEANUP;
}
bytes = (uint8_t *) malloc(SCRIPT_LEN_MAX);
if ( bytes == NULL ) {
as_error_update(&err, errno, "malloc failed");
goto CLEANUP;
}
int size = 0;
uint8_t * buff = bytes;
if (access(self->as->config.lua.user_path, W_OK) == 0) {
copy_file_p = fopen(copy_filepath, "r");
if (!copy_file_p) {
copy_file_p = fopen(copy_filepath, "w+");
int read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p);
if (read && fwrite(buff, 1, read, copy_file_p)) {
while (read) {
size += read;
buff += read;
read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p);
if (!fwrite(buff, 1, read, copy_file_p)) {
break;
}
}
} else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Write of lua file to user path failed");
goto CLEANUP;
}
} else {
int read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p);
while (read) {
size += read;
buff += read;
read = (int)fread(buff, 1, LUA_FILE_BUFFER_FRAME, file_p);
}
}
} else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "No permissions to write lua file to user path");
goto CLEANUP;
}
if (file_p) {
fclose(file_p);
}
if (copy_file_p) {
fclose(copy_file_p);
}
as_bytes_init_wrap(&content, bytes, size, true);
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_udf_put(self->as, &err, info_policy_p, filename, udf_type, &content);
Py_END_ALLOW_THREADS
if( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
} else {
aerospike_udf_put_wait(self->as, &err, info_policy_p, as_basename(NULL, filename), 2000);
}
CLEANUP:
if(bytes) {
free(bytes);
}
if (py_ustr) {
Py_DECREF(py_ustr);
}
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, "module")) {
PyObject_SetAttrString(exception_type, "module", Py_None);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Lists the UDF modules registered with the server
*
* @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 list of modules that are registered with Aerospike DB.
*******************************************************************************************************
*/
PyObject * AerospikeClient_UDF_List(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
int init_udf_files = 0;
// Python Function Arguments
PyObject * py_policy = NULL;
as_policy_info info_policy;
as_policy_info *info_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "|O:udf_list", kwlist, &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;
}
// Convert python object to 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;
}
as_udf_files files;
as_udf_files_init(&files, 0);
init_udf_files = 1;
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_udf_list(self->as, &err, info_policy_p, &files);
Py_END_ALLOW_THREADS
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
// Convert as_udf_files struct into python object
PyObject * py_files;
as_udf_files_to_pyobject(&err, &files, &py_files);
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (init_udf_files) {
as_udf_files_destroy(&files);
}
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, "module")) {
PyObject_SetAttrString(exception_type, "module", Py_None);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_files;
}
/**
*******************************************************************************************************
* Removes a UDF module from 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_UDF_Remove(AerospikeClient * self, PyObject *args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_policy = NULL;
PyObject * py_filename = NULL;
PyObject * py_ustr = NULL;
as_policy_info info_policy;
as_policy_info *info_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"filename", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:udf_remove", kwlist,
&py_filename, &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;
}
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Convert PyObject into a filename string
char *filename = NULL;
if (PyUnicode_Check(py_filename)) {
py_ustr = PyUnicode_AsUTF8String(py_filename);
filename = PyString_AsString(py_ustr);
} else if (PyString_Check(py_filename)) {
filename = PyString_AsString(py_filename);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filename should be a string");
goto CLEANUP;
}
// Convert python object to policy_info
pyobject_to_policy_info( &err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_udf_remove(self->as, &err, info_policy_p, filename);
Py_END_ALLOW_THREADS
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
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, "module")) {
PyObject_SetAttrString(exception_type, "module", py_filename);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
* Scans a set in the Aerospike DB and applies UDF on it.
*
* @param self The c client's aerospike object.
* @param namespace_p The namespace to scan.
* @param set_p The set to scan.
* @param module_p The name of UDF module containing the
* function to execute.
* @param function_p The name of the function to be applied
* to the record.
* @param py_args An array of arguments for the UDF.
* @py_policy The optional policy.
* @py_options The optional scan options to set.
*/
static
PyObject * AerospikeClient_ScanApply_Invoke(
AerospikeClient * self,
char* namespace_p, PyObject * py_set, PyObject * py_module, PyObject * py_function,
PyObject * py_args, PyObject * py_policy, PyObject * py_options, bool block)
{
as_list* arglist = NULL;
as_policy_scan scan_policy;
as_policy_scan* scan_policy_p = NULL;
as_policy_info info_policy;
as_policy_info* info_policy_p = NULL;
as_error err;
as_scan scan;
uint64_t scan_id = 0;
bool is_scan_init = false;
PyObject *py_ustr1 = NULL;
PyObject *py_ustr2 = NULL;
PyObject *py_ustr3 = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
// 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;
}
self->is_client_put_serializer = false;
if (!(namespace_p) || !(py_set) || !(py_module) || !(py_function)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Parameter should not be null");
goto CLEANUP;
}
if (!PyList_Check(py_args)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Arguments should be a list");
goto CLEANUP;
}
char *set_p = NULL;
if (PyUnicode_Check(py_set)) {
py_ustr1 = PyUnicode_AsUTF8String(py_set);
set_p = PyString_AsString(py_ustr1);
} else if (PyString_Check(py_set)) {
set_p = PyString_AsString(py_set);
} else if( Py_None != py_set ) {
// Scan whole namespace if set is 'None' else error
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Set name should be string");
goto CLEANUP;
}
as_scan_init(&scan, namespace_p, set_p);
is_scan_init = true;
if (py_policy) {
pyobject_to_policy_scan(&err, py_policy, &scan_policy, &scan_policy_p,
&self->as->config.policies.scan);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
}
if (py_options && PyDict_Check(py_options)) {
set_scan_options(&err, &scan, py_options);
}
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
char *module_p = NULL;
if (PyUnicode_Check(py_module)) {
py_ustr2 = PyUnicode_AsUTF8String(py_module);
module_p = PyString_AsString(py_ustr2);
} else if (PyString_Check(py_module)) {
module_p = PyString_AsString(py_module);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Module name should be string");
goto CLEANUP;
}
char *function_p = NULL;
if (PyUnicode_Check(py_function)) {
py_ustr3 = PyUnicode_AsUTF8String(py_function);
function_p = PyString_AsString(py_ustr3);
} else if (PyString_Check(py_function)) {
function_p = PyString_AsString(py_function);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Function name should be string");
goto CLEANUP;
}
pyobject_to_list(self, &err, py_args, &arglist, &static_pool,
SERIALIZER_PYTHON);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
if (!as_scan_apply_each(&scan, module_p, function_p, arglist)) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Unable to apply UDF on the scan");
goto CLEANUP;
}
Py_BEGIN_ALLOW_THREADS
aerospike_scan_background(self->as, &err, scan_policy_p, &scan, &scan_id);
Py_END_ALLOW_THREADS
arglist = NULL;
if(err.code == AEROSPIKE_OK) {
if(block) {
if (py_policy) {
pyobject_to_policy_info(&err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
}
Py_BEGIN_ALLOW_THREADS
aerospike_scan_wait(self->as, &err, info_policy_p, scan_id, 0);
Py_END_ALLOW_THREADS
if(err.code != AEROSPIKE_OK) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Unable to perform scan_wait on the scan");
}
}
} else {
goto CLEANUP;
static PyObject * AerospikeClient_InfoAll_Invoke(AerospikeClient * self, PyObject* py_request, PyObject* py_policy) {
PyObject * py_nodes = NULL;
PyObject * py_ustr = NULL;
foreach_callback_info_udata info_callback_udata;
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 = NULL;
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 * request = NULL;
if (PyUnicode_Check(py_request)) {
py_ustr = PyUnicode_AsUTF8String(py_request);
request = PyBytes_AsString(py_ustr);
} else if (PyString_Check(py_request)) {
request = PyString_AsString(py_request);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Request must be a string");
goto CLEANUP;
}
Py_BEGIN_ALLOW_THREADS
aerospike_info_foreach(self->as, &err, info_policy_p, request,
(aerospike_info_foreach_callback)AerospikeClient_InfoAll_each,
&info_callback_udata);
Py_END_ALLOW_THREADS
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;
}
/**
******************************************************************************************************
* Returns data for a particular request string to AerospikeClient_InfoNode
*
* @param self AerospikeClient object
* @param request_str_p Request string sent from the python client
* @param py_host Optional host sent from the python client
* @param py_policy The policy sent from the python client
*
* Returns information about a host.
********************************************************************************************************/
static PyObject * AerospikeClient_InfoNode_Invoke(
AerospikeClient * self,
PyObject * py_request_str, PyObject * py_host, PyObject * py_policy) {
PyObject * py_response = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
as_policy_info info_policy;
as_policy_info* info_policy_p = NULL;
char* address = (char *) self->as->config.hosts[0].addr;
long port_no = self->as->config.hosts[0].port;
char* response_p = NULL;
as_status status = AEROSPIKE_OK;
as_error err;
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;
}
if (py_policy) {
if( PyDict_Check(py_policy) ) {
pyobject_to_policy_info(&err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
if (err.code != AEROSPIKE_OK) {
goto CLEANUP;
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Policy should be a dictionary");
goto CLEANUP;
}
}
if ( py_host ) {
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 ( PyString_Check(py_addr) ) {
address = PyString_AsString(py_addr);
} else if (PyUnicode_Check(py_addr)) {
py_ustr = PyUnicode_AsUTF8String(py_addr);
address = PyString_AsString(py_ustr);
}
if ( PyInt_Check(py_port) ) {
port_no = (uint16_t) PyInt_AsLong(py_port);
}
else if ( PyLong_Check(py_port) ) {
port_no = (uint16_t) PyLong_AsLong(py_port);
}
} else if ( !PyTuple_Check(py_host)){
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Host should be a specified in form of Tuple.");
goto CLEANUP;
}
}
char * request_str_p = NULL;
if (PyUnicode_Check(py_request_str)) {
py_ustr1 = PyUnicode_AsUTF8String(py_request_str);
request_str_p = PyString_AsString(py_ustr1);
} else if (PyString_Check(py_request_str)) {
request_str_p = PyString_AsString(py_request_str);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Request should be of string type");
goto CLEANUP;
}
status = aerospike_info_host(self->as, &err, info_policy_p,
(const char *) address, (uint16_t) port_no, request_str_p,
&response_p);
if( err.code == AEROSPIKE_OK ) {
if (response_p && status == AEROSPIKE_OK){
py_response = PyString_FromString(response_p);
free(response_p);
} else if ( response_p == NULL){
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Invalid info operation");
goto CLEANUP;
} else if ( status != AEROSPIKE_OK ){
as_error_update(&err, status, "Info operation failed");
goto CLEANUP;
}
} else {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
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_response;
}
