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(); }