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