// server register handler static void rpc_request_handler(dsn_message_t rpc_request, void* param) { // rpc request handler start PyGILState_STATE gstate; gstate = PyGILState_Ensure(); void* ptr; size_t size; char buffer[1000]; // parse rpc request dsn_msg_read_next(rpc_request, &ptr, &size); memcpy(buffer, ptr, size); dsn_msg_read_commit(rpc_request, size); dsn_message_t rpc_response = dsn_msg_create_response(rpc_request); PyObject* pArgs = PyTuple_New(3); PyTuple_SetItem(pArgs, 0, Py_BuildValue("s", buffer)); PyTuple_SetItem(pArgs, 1, Py_BuildValue("K", (uint64_t)(uintptr_t)rpc_response)); PyTuple_SetItem(pArgs, 2, Py_BuildValue("K", (uint64_t)(uintptr_t)param)); PyObject* pFunc = tls_get_handler_function(CT_RPC_REQUEST); PyObject* pReturn = PyEval_CallObject(pFunc, pArgs); PyGILState_Release(gstate); return; }
void mutation::add_client_request(task_code code, dsn_message_t request) { data.updates.push_back(mutation_update()); mutation_update& update = data.updates.back(); _appro_data_bytes += 32; // approximate code size if (request != nullptr) { update.code = code; dsn_msg_add_ref(request); // released on dctor void* ptr; size_t size; bool r = dsn_msg_read_next(request, &ptr, &size); dassert(r, "payload is not present"); dsn_msg_read_commit(request, 0); // so we can re-read the request buffer in replicated app update.data.assign((char*)ptr, 0, (int)size); _appro_data_bytes += sizeof(int) + (int)size; // data size } else { update.code = RPC_REPLICATION_WRITE_EMPTY; _appro_data_bytes += sizeof(int); // empty data size } client_requests.push_back(request); dassert(client_requests.size() == data.updates.size(), "size must be equal"); }
void meta_service::on_update_configuration(dsn_message_t req) { if (!_started) { configuration_update_response response; response.err = ERR_SERVICE_NOT_ACTIVE; reply(req, response); return; } if (!_failure_detector->is_primary()) { dsn_rpc_forward(req, _failure_detector->get_primary().c_addr()); return; } if (_state->freezed()) { configuration_update_request request; configuration_update_response response; ::unmarshall(req, request); response.err = ERR_STATE_FREEZED; _state->query_configuration_by_gpid(request.config.gpid, response.config); reply(req, response); return; } void* ptr; size_t sz; dsn_msg_read_next(req, &ptr, &sz); dsn_msg_read_commit(req, 0); // commit 0 so we can read again uint64_t offset; int len = (int)sz + sizeof(int32_t); char* buffer = new char[len]; *(int32_t*)buffer = (int)sz; memcpy(buffer + sizeof(int32_t), ptr, sz); auto tmp = std::shared_ptr<char>(buffer); blob bb2(tmp, 0, len); auto request = std::shared_ptr<configuration_update_request>(new configuration_update_request()); ::unmarshall(req, *request); { zauto_lock l(_log_lock); offset = _offset; _offset += len; file::write(_log, buffer, len, offset, LPC_CM_LOG_UPDATE, this, std::bind(&meta_service::on_log_completed, this, std::placeholders::_1, std::placeholders::_2, bb2, request, dsn_msg_create_response(req))); } }
DSN_PY_API void* dsn_rpc_call_wait_helper(uint64_t addr, dsn_message_t msg, char *ss) { dsn_message_t resp = dsn_rpc_call_wait(*(dsn_address_t*)&addr, msg); void* ptr; size_t size; dsn_msg_read_next(resp, &ptr, &size); memcpy(ss, ptr, size); dsn_msg_read_commit(resp, size); return (void*)ss; }
void mutation::set_client_request(dsn_task_code_t code, dsn_message_t request) { dassert(_client_request == nullptr, "batch is not supported now"); rpc_code = code; if (request != nullptr) { _client_request = request; dsn_msg_add_ref(request); // released on dctor void* ptr; size_t size; bool r = dsn_msg_read_next(request, &ptr, &size); dassert(r, "payload is not present"); dsn_msg_read_commit(request, size); blob buffer((char*)ptr, 0, (int)size); data.updates.push_back(buffer); } }
// client register rpc callback static void rpc_response_handler(dsn_error_t err, dsn_message_t rpc_request, dsn_message_t rpc_response, void* param) { // read response PyGILState_STATE gstate; gstate = PyGILState_Ensure(); void* ptr; size_t size; char buffer[1000]; dsn_msg_read_next(rpc_response, &ptr, &size); memcpy(buffer, ptr, size); dsn_msg_read_commit(rpc_response, size); PyObject* pArgs = PyTuple_New(3); PyTuple_SetItem(pArgs, 0, Py_BuildValue("s", buffer)); PyTuple_SetItem(pArgs, 1, Py_BuildValue("i", err)); PyTuple_SetItem(pArgs, 2, Py_BuildValue("K", (uint64_t)(uintptr_t)param)); PyObject* pFunc = tls_get_handler_function(CT_RPC_RESPONSE); PyObject* pReturn = PyEval_CallObject(pFunc, pArgs); PyGILState_Release(gstate); return; }