rpc_request_task::rpc_request_task(message_ptr& request, service_node* node)
: task(task_code(request->header().local_rpc_code), request->header().client.hash, node),
_request(request)
{
dbg_dassert (TASK_TYPE_RPC_REQUEST == spec().type, "task type must be RPC_REQUEST, please use DEFINE_TASK_CODE_RPC to define the task code");
}
int replication_app_base::dispatch_rpc_call(int code, message_ptr& request, bool ack_client)
{
auto it = _handlers.find(code);
if (it != _handlers.end())
{
if (ack_client)
{
message_ptr response = request->create_response();
int err = 0;
marshall(response->writer(), err);
it->second(request, response);
}
else
{
message_ptr response(nullptr);
it->second(request, response);
}
}
else if (ack_client)
{
message_ptr response = request->create_response();
error_code err = ERR_HANDLER_NOT_FOUND;
marshall(response->writer(), (int)err);
rpc::reply(response);
}
return 0;
}
void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
client::connection_ptr con = sip_client.get_con_from_hdl(hdl);
std::cout << "Received a reply:" << std::endl;
fwrite(msg->get_payload().c_str(), msg->get_payload().size(), 1, stdout);
received=true;
}
// Define a callback to handle incoming messages
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
try {
s->send(hdl, msg->get_payload(), msg->get_opcode());
} catch (const websocketpp::lib::error_code& e) {
}
}
void on_message(connection_ptr con, message_ptr msg) {
if (con->get_resource() == "/getcasecount") {
std::cout << "detected " << msg->get_payload() << " test cases." << std::endl;
m_case_count = atoi(msg->get_payload().c_str());
} else {
con->send(msg->get_payload(),msg->get_opcode());
}
}
void rpc_server_session::on_recv_request(message_ptr& msg, int delay_ms)
{
msg->header().from_address = remote_address();
msg->header().from_address.port = msg->header().client.port;
msg->header().to_address = _net.address();
msg->server_session().reset(this);
return _net.on_recv_request(msg, delay_ms);
}
void websocketIO::on_message(websocketpp::connection_hdl hdl, message_ptr msg) {
boost::property_tree::ptree json;
std::istringstream iss(msg->get_payload());
boost::property_tree::read_json(iss, json);
std::string func = json.get<std::string> ("func");
if(messages.find(func) != messages.end()){
messages[func](this, msg->get_payload());
}
}
// Define a callback to handle incoming messages
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
std::cout << " and message: " << msg->get_payload() <<std::endl ;
std::cout << " opcode " << msg->get_opcode() <<std::endl ;
// s->send(hdl, msg->get_payload(), msg->get_opcode());
const char* msge = "{\"GESTURE\":\"Move Left\"}";
s->send(hdl, msge, websocketpp::frame::opcode::text);
}
void Handler::on_message(connection_ptr con, message_ptr msg)
{
if (msg->get_opcode() != websocketpp::frame::opcode::TEXT)
return;
Log::debug("client <%s>: <message> %s", plain(con).c_str(),
msg->get_payload().c_str());
publish(format_message(msg->get_payload()));
}
void sim_server_session::send(message_ptr& reply_msg)
{
message_ptr recv_msg(new message(reply_msg->writer().get_buffer()));
recv_msg->header().from_address = reply_msg->header().from_address;
recv_msg->header().to_address = reply_msg->header().to_address;
_client->on_recv_reply(recv_msg->header().id, recv_msg,
recv_msg->header().from_address == recv_msg->header().to_address ?
0 : (static_cast<sim_network_provider*>(&_net))->net_delay_milliseconds()
);
}
void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
client::connection_ptr con = c->get_con_from_hdl(hdl);
if (con->get_resource() == "/getCaseCount") {
std::cout << "Detected " << msg->get_payload() << " test cases."
<< std::endl;
case_count = atoi(msg->get_payload().c_str());
} else {
c->send(hdl, msg->get_payload(), msg->get_opcode());
}
}
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
std::cout << "on_message called with hdl: " << hdl.lock().get()
<< " and message: " << msg->get_payload()
<< std::endl;
try {
s->send(hdl, msg->get_payload(), msg->get_opcode());
} catch (const websocketpp::lib::error_code& e) {
std::cout << "Echo failed because: " << e
<< "(" << e.message() << ")" << std::endl;
}
}
rpc_response_task::rpc_response_task(message_ptr& request, int hash)
: task(task_spec::get(request->header().local_rpc_code)->rpc_paired_code,
hash == 0 ? request->header().client.hash : hash)
{
set_error_code(ERR_IO_PENDING);
dbg_dassert (TASK_TYPE_RPC_RESPONSE == spec().type, "task must be of RPC_RESPONSE type, please use DEFINE_TASK_CODE_RPC to define the request task code");
_request = request;
_caller_pool = task::get_current_worker() ?
task::get_current_worker()->pool() : nullptr;
}
void ReadUncompressed::handleRx(const message_ptr message)
{
if (!m_initialized)
{
m_initialized = check();
if (!m_initialized) m_error = true;
}
else
{
if (message->get_opcode() == websocketpp::frame::opcode::binary)
{
const std::string& bytes(message->get_payload());
const std::size_t rawNumBytes(bytes.size());
const std::size_t stride(m_layout->pointSize());
m_data.insert(m_data.end(), bytes.begin(), bytes.end());
const std::size_t wholePoints(m_data.size() / stride);
PointId nextId(m_view->size());
const PointId doneId(nextId + wholePoints);
const char* pos(m_data.data());
while (nextId < doneId)
{
for (const auto& dim : m_layout->dims())
{
m_view->setField(
dim,
m_layout->dimType(dim),
nextId,
pos);
pos += m_layout->dimSize(dim);
}
++nextId;
}
m_numBytesReceived += rawNumBytes;
m_data.assign(
m_data.begin() + wholePoints * stride,
m_data.end());
}
else
{
m_error = true;
}
}
}
void websocket_server::on_message(ws_socket* socket_, websocketpp::connection_hdl hdl, message_ptr msg) {
if(msg->get_payload() == "CC"){
cc_hdl_ = hdl;
clientConnected = true;
BOOST_LOG_TRIVIAL(info) << "Control Center connected via websocket";
}
else if (msg->get_payload() == "AL"){
al_hdl_ = hdl;
proxyConnected = true;
BOOST_LOG_TRIVIAL(info) << "Al-Proxy connected via websocket";
}
}
void replica::response_client_message(message_ptr& request, error_code error, decree d/* = invalid_decree*/)
{
if (nullptr == request)
return;
message_ptr resp = request->create_response();
resp->writer().write(error);
dassert(error != ERR_OK, "");
dinfo("handle replication request with rpc_id = %016llx failed, err = %s",
request->header().rpc_id, error.to_string());
rpc::reply(resp);
}
void ReadCompressed::handleRx(const message_ptr message)
{
std::lock_guard<std::mutex> lock(m_mutex);
if (!m_initialized)
{
m_initialized = check();
if (!m_initialized) m_error = true;
m_data.resize(m_numBytes);
m_decompressionThread = std::thread([this]()->void {
m_decompressor.decompress(m_data.data(), m_data.size());
const char* pos(m_data.data());
for (PointId i(0); i < m_pointsToRead; ++i)
{
for (const auto& dim : m_layout->dims())
{
m_view->setField(
dim,
m_layout->dimType(dim),
i,
pos);
pos += m_layout->dimSize(dim);
}
}
m_done = true;
m_doneCv.notify_all();
});
m_decompressionThread.detach();
}
else
{
if (message->get_opcode() == websocketpp::frame::opcode::binary)
{
const std::string& bytes(message->get_payload());
m_compressionStream.putBytes(
reinterpret_cast<const uint8_t*>(bytes.data()),
bytes.size());
}
else
{
m_error = true;
}
}
}
void chat_server_handler::on_message(connection_ptr con, message_ptr msg) {
if (msg->get_opcode() != websocketpp::frame::opcode::text) {
return;
}
std::cout << "message from client " << con << ": " << msg->get_payload() << std::endl;
// check for special command messages
if (msg->get_payload() == "/help") {
// print command list
con->send(encode_message("server","avaliable commands:<br /> /help - show this help<br /> /alias foo - set alias to foo",false));
return;
}
if (msg->get_payload().substr(0,7) == "/alias ") {
std::string response;
std::string alias;
if (msg->get_payload().size() == 7) {
response = "you must enter an alias.";
con->send(encode_message("server",response));
return;
} else {
alias = msg->get_payload().substr(7);
}
response = m_connections[con] + " is now known as "+alias;
// store alias pre-escaped so we don't have to do this replacing every time this
// user sends a message
// escape json characters
boost::algorithm::replace_all(alias,"\\","\\\\");
boost::algorithm::replace_all(alias,"\"","\\\"");
// escape html characters
boost::algorithm::replace_all(alias,"&","&");
boost::algorithm::replace_all(alias,"<","<");
boost::algorithm::replace_all(alias,">",">");
m_connections[con] = alias;
// set alias
send_to_all(serialize_state());
send_to_all(encode_message("server",response));
return;
}
// catch other slash commands
if ((msg->get_payload())[0] == '/') {
con->send(encode_message("server","unrecognized command"));
return;
}
// create json message to send based on msg
send_to_all(encode_message(m_connections[con],msg->get_payload()));
}
lib::error_code prepare_close(close::status::value code,
std::string const & reason, message_ptr out) const
{
if (!out) {
return lib::error_code(error::invalid_arguments);
}
std::string val;
val.append(1,'\xff');
val.append(1,'\x00');
out->set_payload(val);
out->set_prepared(true);
return lib::error_code();
}
void mutation::set_client_request(task_code code, message_ptr& request)
{
dassert(client_request == nullptr, "batch is not supported now");
client_request = request;
rpc_code = code;
data.updates.push_back(request->reader().get_remaining_buffer());
}
void command_manager::on_remote_cli(message_ptr& request)
{
std::string cmd;
unmarshall(request->reader(), cmd);
std::vector<std::string> args;
unmarshall(request->reader(), args);
std::string result;
run_command(cmd, args, result);
auto resp = request->create_response();
marshall(resp->writer(), result);
::dsn::service::rpc::reply(resp);
}
void WSConnection::rcvMessage (message_ptr msg, bool& msgRejected, bool& runQueue)
{
ScopedLockType sl (m_receiveQueueMutex);
if (m_isDead)
{
msgRejected = false;
runQueue = false;
return;
}
if ((m_receiveQueue.size () >= 1000) || (msg->get_payload().size() > 1000000))
{
msgRejected = true;
runQueue = false;
}
else
{
msgRejected = false;
m_receiveQueue.push_back (msg);
if (m_receiveQueueRunning)
runQueue = false;
else
{
runQueue = true;
m_receiveQueueRunning = true;
}
}
}
// Define a callback to handle incoming messages
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
std::cout << "on_message called with hdl: " << hdl.lock().get()
<< " and message: " << msg->get_payload()
<< std::endl;
// check for a special command to instruct the server to stop listening so
// it can be cleanly exited.
if (msg->get_payload() == "stop-listening") {
s->stop_listening();
return;
}
try {
s->send(hdl, msg->get_payload(), msg->get_opcode());
} catch (const websocketpp::lib::error_code& e) {
std::cout << "Echo failed because: " << e
<< "(" << e.message() << ")" << std::endl;
}
}
void on_message(ws_client* c, leveldb::DB* db,
websocketpp::connection_hdl hdl, message_ptr msg) {
static int count = 0;
ws_client::connection_ptr con = c->get_con_from_hdl(hdl);
cout << "Received: " << msg->get_payload() << endl;
leveldb::WriteOptions opts;
stringstream key;
key << (count++);
db->Put(opts, key.str(), msg->get_payload());
// if (con->get_resource() == "/getCaseCount") {
// std::cout << "Detected " << msg->get_payload() << " test cases."
// << std::endl;
// case_count = atoi(msg->get_payload().c_str());
// } else {
// c->send(hdl, msg->get_payload(), msg->get_opcode());
// }
}
bool rpc_client_session::on_recv_reply(uint64_t key, message_ptr& reply, int delay_ms)
{
if (reply != nullptr)
{
reply->header().from_address = remote_address();
reply->header().to_address = _net.address();
}
return _matcher->on_recv_reply(key, reply, delay_ms);
}
bool ConnectService::process(message_ptr const & message, connection_ptr const & connection)
{
static Engine& engine = Engine::get_instance();
if (message->type != MessageType::PING) return false;
uint32_t id;
_dec_declare2_(req, message->get_content_data(), message->get_content_size());
_dec_get_var32_(req, id);
if (!_dec_valid_(req))
{
DLOG(ERROR) << "Bad Ping format";
return true;
}
NodeConf* config = (NodeConf*) engine.get_component(COMP_SERVERCONF).get();
servernode_map::iterator it = config->nodes.find(id);
if (it != config->nodes.end())
{
servernode_ptr node = it->second;
connection->asyn = true;
connection->authenticated = true;
connection->data = node.get();
connection->type = CT_S2S;
node->connection = connection;
node->state = READY;
_enc_declare_(rep, 64);
_enc_put_msg_header_(rep, MessageType::REPLY, message->id, 0);
_enc_put_var32_(rep, ErrorCode::OK);
_enc_update_msg_size_(rep);
connection->send(_enc_data_(rep), _enc_size_(rep));
}
else
{
_enc_declare_(rep, 64);
_enc_put_msg_header_(rep, MessageType::REPLY, message->id, 0);
_enc_put_var32_(rep, ErrorCode::IS_NOT_FOUND);
_enc_update_msg_size_(rep);
connection->send(_enc_data_(rep), _enc_size_(rep));
}
return true;
}
void meta_service::on_request(message_ptr& 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_SUCCESS;
message_ptr resp = msg->create_response();
if (!is_primary)
{
rhdr.err = ERR_TALK_TO_OTHERS;
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);
return;
}
else
{
dassert(false, "unknown rpc tag %x (%s)", hdr.rpc_tag, task_code(hdr.rpc_tag).to_string());
}
rpc::reply(resp);
}
void send_reply(message_ptr msg)
{
try
{
msg->write(socket_);
//std::cout << "<";
}
catch (boost::system::system_error & e)
{
error_handler_(e.code());
}
}
void on_message(connection_ptr con, message_ptr msg) {
request r;
r.type = PERF_TEST;
r.writer = writer_ptr(new ws_writer<endpoint_type>(con));
r.req = msg->get_payload();
if (m_blocking) {
r.process(0);
} else {
m_coordinator.add_request(r);
}
}
void client_net_io::write(message_ptr& msg)
{
_sq.enqueue(msg, task_spec::get(msg->header().local_rpc_code)->priority);
// not connected
if (SS_CONNECTED != _state)
{
return;
}
do_write();
}
