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