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;
}
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 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 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());
}
}
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;
}
}
void WebClient::onMessage(Client* c, websocketpp::connection_hdl hdl, message_ptr pMsg) {
Client::connection_ptr con = c->get_con_from_hdl(hdl);
std::string res_s = con->get_resource();
if (res_s != "/codenjoy-contest/ws?user="******"WebClient::onMessage(...) Server answer is not right: " + res_s;
throw std::runtime_error(res_s.c_str());
}
std::string buffer_got = pMsg->get_payload();
String boardString;
#ifdef _WIN32
boardString.resize(MultiByteToWideChar(CP_UTF8, 0, &buffer_got[0], buffer_got.length(),
NULL, 0));
MultiByteToWideChar(CP_UTF8, 0, &buffer_got[0], buffer_got.length(),
&boardString[0], boardString.capacity());
#else //Assume linux
boardString = buffer_got;
#endif
if (boardString.substr(0, 6) == LL("board=")) {
boardString = boardString.substr(6, boardString.length() - 6);
while (*boardString.rbegin() == LL('\0')) {
boardString.pop_back();
}
Board b(boardString);
String answer = solver->get(b);
std::string utf_answer;
#ifdef _WIN32
utf_answer.resize(WideCharToMultiByte(CP_UTF8, 0, &answer[0], answer.length(),
NULL, 0, NULL, NULL));
WideCharToMultiByte(CP_UTF8, 0, &answer[0], answer.length(),
&utf_answer[0], utf_answer.capacity(), NULL, NULL);
if (utf_answer == "") { // This happens if bomberman's still dead
if (answer != LL("")) {
throw std::runtime_error("WebClient::onMessage(...): Conversion from Char to utf8 error!");
}
return;
}
#else // Assume linux
utf_answer = answer;
#endif
pMsg->set_opcode(websocketpp::frame::opcode::text);
pMsg->set_payload(utf_answer);
std::cout << "Sending ACTION: " << pMsg->get_payload() << std::endl;
websocketpp::lib::error_code err;
c->send(hdl, pMsg->get_payload(), pMsg->get_opcode(), err);
}
}
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 on_message(connection_ptr con, message_ptr msg) {
if(msg->get_payload()=="skeleton") {
con->send(getImageData(),msg->get_opcode());
} else if(msg->get_payload()=="depth") {
con->send(getDepthMap(true),msg->get_opcode());
} else if(msg->get_payload()=="rgb") {
con->send(getRGBImage(true),msg->get_opcode());
} else if(msg->get_payload()=="savergb") {
con->send(saveRGBImage(),msg->get_opcode());
} else if(msg->get_payload()=="savedepth") {
con->send(saveDepthMap(),msg->get_opcode());
} else {
con->send("Unknown client request",msg->get_opcode());
}
}
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) {
try {
s->send(hdl, msg->get_payload(), msg->get_opcode());
} catch (const websocketpp::lib::error_code& e) {
}
}
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()));
}
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());
// }
}
// 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;
}
}
// 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 on_message(connection_ptr con,message_ptr msg) {
int value = atoi(msg->get_payload().c_str());
if (value == 0) {
con->send("invalid sleep value.");
} else {
request r;
r.con = con;
r.value = value;
m_coordinator.add_request(r);
}
}
void on_message(connection_ptr con,message_ptr msg) {
int value = atoi(msg->get_payload().c_str());
if (value == 0) {
con->send("Invalid sleep value.");
} else {
request r;
r.con = con;
r.value = value;
r.process();
}
}
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 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 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 WebSocketManager::on_message(connection_ptr con, message_ptr msg)
{
LogDebug("Got message: " + msg->get_payload());
ptree pt;
//Parses the message as JSON
if(parseJson(msg->get_payload(), pt) != -1) {
//Checking if JSON string has event information and data
QString event = QString::fromStdString(pt.get<string>("event", "empty"));
if (event == "empty")
return;
QString data = QString::fromStdString(pt.get<string>("data", "empty"));
if (data == "empty")
return;
emit gotEvent(event, data, QString::fromStdString(getConId(con)));
}
}
void on_message(connection_ptr con,message_ptr msg) {
con->send(msg->get_payload(),msg->get_opcode());
}
void on_message(connection_ptr con, message_ptr msg)
{
const QString payload = QString::fromStdString(msg->get_payload());
pimpl->receivedMessage(payload);
qDebug() << "Got Message:" << payload;
}
void on_message(websocketpp::connection_hdl, message_ptr msg) {
m_messages.push_back(msg->get_payload());
}
void on_message(connection_ptr con, message_ptr msg) {
std::cout << msg->get_payload() << std::endl;
received=true;
}
/* handler library*/
void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
s->send(hdl, msg->get_payload(), msg->get_opcode());
}
void StreamClient::on_message(websocketpp::connection_hdl hdl, message_ptr msg)
{
OnMessage(msg->get_payload());
}
void
manager::on_message(connection_ptr conn, message_ptr msg)
{
const string content(msg->get_payload());
Value ret;
cleanup(); // do some maintenance
if(read(content, ret) && is_obj(ret)) {
Object obj(ret.get_obj());
Value type(get_field_from_obj(obj, "msg"));
if(is_string(type)) {
const string& str(type.get_str());
if(str == "next") {
client *cl(get_client(conn));
cl->counter++;
} else if(str == "load_temp") {
Value filev(get_field_from_obj(obj, "file"));
string file(filev.get_str());
if(valid_temp_file(file)) {
client *cl(get_client(conn));
cl->done = false;
cl->counter = 0;
if(cl->th != NULL) {
delete cl->th;
cl->th = NULL;
}
boost::thread *th = new boost::thread(boost::bind(&ui::manager::start_file, this, file, cl, true));
cl->th = th;
}
} else if(str == "load" || str == "load_temp") {
Value filev(get_field_from_obj(obj, "file"));
string file(filev.get_str());
client *cl(get_client(conn));
cl->done = false;
cl->counter = 0;
if(cl->th != NULL) {
delete cl->th;
cl->th = NULL;
}
boost::thread *th = new boost::thread(boost::bind(&ui::manager::start_file, this, file, cl, false));
cl->th = th;
} else if(str == "jump") {
Value node(get_field_from_obj(obj, "steps"));
if(is_int(node)) {
const int steps(node.get_int());
client *cl(get_client(conn));
cl->counter += steps;
}
} else if(str == "get_node") {
Value node(get_field_from_obj(obj, "node"));
if(is_int(node)) {
db::node::node_id id((db::node::node_id)node.get_int());
DECLARE_JSON("node");
ADD_FIELD("node", (int)id);
ADD_FIELD("info", sched::serial_ui_local::dump_node(id));
SEND_JSON(conn);
}
} else if(str == "change_node") {
Value node(get_field_from_obj(obj, "node"));
if(is_int(node)) {
db::node::node_id id((db::node::node_id)node.get_int());
sched::serial_ui_local::change_node(id);
DECLARE_JSON("changed_node");
ADD_FIELD("node", (int)id);
SEND_JSON(conn);
}
} else if(str == "terminate") {
client* cl(get_client(conn));
cl->done = true;
} else {
cerr << "Message not recognized: " << str << endl;
}
}
}
}
// got a new message from server
void on_message(connection_ptr con, message_ptr msg){
//https://github.com/LearnBoost/socket.io-spec#Encoding
/* 0 Disconnect
1:: Connect
2:: Heartbeat
3:: Message
4:: Json Message
5:: Event
6 Ack
7 Error
8 noop
*/
std::string strm = msg->get_payload();
char f = strm[0];
std::string::size_type p = 1;
for(int i = 0 ; i < 2; i++){
p = strm.find_first_of(':',p+1);
}
std::string data = strm.substr(p+1);
con->alog().at(log::alevel::DEVEL)<<"revc: "<< strm <<log::endl;
con->alog().at(log::alevel::DEVEL)<<"type: "<< f <<" data: "<< data <<log::endl;
Json::Reader r;
Json::Value v;
switch(f){
case '0':
close();
break;
case '1':
on_connect(con);
break;
case '2':
con->send_heartbeat();
break;
case '3':
on_strmessage(data,msg);
break;
case '4':
on_jsonmessage(data,msg);
/*
var fe:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.MSG_JSON);
fe.data = JSON.decode(dm.msg);
dispatchEvent(fe);
*/
break;
case '5':
if(r.parse(data,v)){
on_event(v["name"].asString(),v["args"],msg);
}else{
con->alog().at(log::alevel::DEVEL)<<"parse json failed error "<< data <<log::endl;
}
/*
var m:Object = JSON.decode(dm.msg);
var e:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.EVENT);
e.data = m;
dispatchEvent(e);
*/
break;
case '7':
//on_fail();
/*
var m:Object = JSON.decode(dm.msg);
var e:FlashSocketEvent = new FlashSocketEvent(FlashSocketEvent.CONNECT_ERROR);
e.data = dm.msg;
dispatchEvent(e);
*/
break;
default:
break;
}
}
void WebSocketWorker::on_message(websocketpp::connection_hdl /*hdl*/, message_ptr msg)
{
std::string s = msg->get_payload();
QByteArray result(s.data(), s.length());
Q_EMIT messageReceived(result);
}
