DSN_API void dsn_rpc_forward(dsn_message_t request, dsn_address_t addr)
{
// TODO: enable real forwarding
auto resp = dsn_msg_create_response(request);
::marshall(resp, addr);
::dsn::task::get_current_rpc()->reply((::dsn::message_ex*)resp, ::dsn::ERR_FORWARD_TO_OTHERS);
}
// 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 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)));
}
}
void replica::response_client_message(dsn_message_t request, error_code error)
{
if (nullptr == request)
{
error.end_tracking();
return;
}
ddebug("%s: reply client read/write, err = %s", name(), error.to_string());
dsn_rpc_reply(dsn_msg_create_response(request), error);
}
error_code replication_app_base::write_internal(mutation_ptr& mu)
{
dassert (mu->data.header.decree == last_committed_decree() + 1, "");
dassert(mu->client_requests.size() == mu->data.updates.size()
&& mu->client_requests.size() > 0,
"data inconsistency in mutation");
int count = static_cast<int>(mu->client_requests.size());
_batch_state = (count == 1 ? BS_NOT_BATCH : BS_BATCH);
for (int i = 0; i < count; i++)
{
if (_batch_state == BS_BATCH && i + 1 == count)
{
_batch_state = BS_BATCH_LAST;
}
auto& r = mu->client_requests[i];
if (r.code != RPC_REPLICATION_WRITE_EMPTY)
{
dinfo("%s: mutation %s dispatch rpc call: %s",
_replica->name(), mu->name(), dsn_task_code_to_string(r.code));
binary_reader reader(mu->data.updates[i]);
dsn_message_t resp = (r.req ? dsn_msg_create_response(r.req) : nullptr);
uint64_t now = dsn_now_ns();
dispatch_rpc_call(r.code, reader, resp);
now = dsn_now_ns() - now;
_app_commit_latency.set(now);
}
else
{
// empty mutation write
}
if (_physical_error != 0)
{
derror("%s: physical error %d occurs in replication local app %s",
_replica->name(), _physical_error, data_dir().c_str());
return ERR_LOCAL_APP_FAILURE;
}
}
++_last_committed_decree;
_replica->update_commit_statistics(count);
_app_commit_throughput.add((uint64_t)count);
_app_commit_decree.increment();
return ERR_OK;
}
void command_manager::on_remote_cli(dsn_message_t req)
{
rpc_read_stream reader(req);
std::string cmd;
unmarshall(reader, cmd);
std::vector<std::string> args;
unmarshall(reader, args);
std::string result;
run_command(cmd, args, result);
auto resp = dsn_msg_create_response(req);
::marshall(resp, result);
dsn_rpc_reply(resp);
}
void command_manager::on_remote_cli(dsn_message_t req)
{
::dsn::command cmd;
safe_string result;
::dsn::unmarshall(req, cmd);
safe_vector<safe_string> args;
for (auto& e : cmd.arguments)
{
args.emplace_back(e.c_str());
}
run_command(cmd.cmd.c_str(), args, result);
auto resp = dsn_msg_create_response(req);
std::string r2 = result.c_str();
::dsn::marshall(resp, r2);
dsn_rpc_reply(resp);
}
error_code replication_app_base::write_internal(mutation_ptr& mu)
{
dassert (mu->data.header.decree == last_committed_decree() + 1, "");
if (mu->rpc_code != RPC_REPLICATION_WRITE_EMPTY)
{
binary_reader reader(mu->data.updates[0]);
dsn_message_t resp = (mu->client_msg() ? dsn_msg_create_response(mu->client_msg()) : nullptr);
dispatch_rpc_call(mu->rpc_code, reader, resp);
}
else
{
on_empty_write();
}
if (_physical_error != 0)
{
derror("physical error %d occurs in replication local app %s", _physical_error, data_dir().c_str());
}
return _physical_error == 0 ? ERR_OK : ERR_LOCAL_APP_FAILURE;
}
void meta_service::on_request(dsn_message_t msg)
{
meta_request_header hdr;
::unmarshall(msg, hdr);
meta_response_header rhdr;
bool is_primary = _state->get_meta_server_primary(rhdr.primary_address);
if (is_primary) is_primary = (primary_address() == rhdr.primary_address);
rhdr.err = ERR_OK;
::dsn::rpc_address faddr;
dsn_msg_from_address(msg, faddr.c_addr_ptr());
dinfo("recv meta request %s from %s:%hu",
dsn_task_code_to_string(hdr.rpc_tag),
faddr.name(),
faddr.port()
);
dsn_message_t resp = dsn_msg_create_response(msg);
if (!is_primary)
{
rhdr.err = ERR_TALK_TO_OTHERS;
::marshall(resp, rhdr);
}
else if (!_started)
{
rhdr.err = ERR_SERVICE_NOT_ACTIVE;
::marshall(resp, rhdr);
}
else if (hdr.rpc_tag == RPC_CM_QUERY_NODE_PARTITIONS)
{
configuration_query_by_node_request request;
configuration_query_by_node_response response;
::unmarshall(msg, request);
query_configuration_by_node(request, response);
::marshall(resp, rhdr);
::marshall(resp, response);
}
else if (hdr.rpc_tag == RPC_CM_QUERY_PARTITION_CONFIG_BY_INDEX)
{
configuration_query_by_index_request request;
configuration_query_by_index_response response;
unmarshall(msg, request);
query_configuration_by_index(request, response);
::marshall(resp, rhdr);
::marshall(resp, response);
}
else if (hdr.rpc_tag == RPC_CM_UPDATE_PARTITION_CONFIGURATION)
{
update_configuration(msg, resp);
rhdr.err.end_tracking();
return;
}
else
{
dassert(false, "unknown rpc tag %x (%s)", hdr.rpc_tag, dsn_task_code_to_string(hdr.rpc_tag));
}
dsn_rpc_reply(resp);
}
