void P2PNetworkInterface::send() {
MessagePtr msg;
stringstream info;
uint64_t transmissionDuration;
double rate;
if (!connectedInterface) {
info << "*** WARNING *** [block " << hostBlock->blockId << ",interface " << globalId <<"] : trying to send a Message but no interface connected";
BaseSimulator::getScheduler()->trace(info.str());
return;
}
if (outgoingQueue.size()==0) {
info << "*** ERROR *** [block " << hostBlock->blockId << ",interface " << globalId <<"] : The outgoing buffer of this interface should not be empty !";
BaseSimulator::getScheduler()->trace(info.str());
exit(EXIT_FAILURE);
}
msg = outgoingQueue.front();
outgoingQueue.pop_front();
rate = dataRate - dataRateVariability + (generator()/(double)RAND_MAX) * 2 * dataRateVariability;
transmissionDuration = (msg->size()*8000000ULL)/rate;
messageBeingTransmitted = msg;
messageBeingTransmitted->sourceInterface = this;
messageBeingTransmitted->destinationInterface = connectedInterface;
availabilityDate = BaseSimulator::getScheduler()->now()+transmissionDuration;
//info << "*** sending (interface " << localId << " of block " << hostBlock->blockId << ")";
//getScheduler()->trace(info.str());
BaseSimulator::getScheduler()->schedule(new NetworkInterfaceStopTransmittingEvent(BaseSimulator::getScheduler()->now()+transmissionDuration, this));
}
void Client::receiveMessages()
{
while(d->msgqueue->isPending()) {
MessagePtr msg = d->msgqueue->getPending();
if(d->session.isNull()) {
// No session? We must be in the login phase
if(msg->type() == protocol::MSG_COMMAND)
emit loginMessage(msg);
else
log(Log().about(Log::Level::Warn, Log::Topic::RuleBreak).message(
QString("Got non-login message (type=%1) in login state").arg(msg->type())
));
} else {
// Enforce origin ID, except when receiving a snapshot
if(d->session->initUserId() != d->id)
msg->setContextId(d->id);
if(isHoldLocked())
d->holdqueue << msg;
else
d->session->handleClientMessage(*this, msg);
}
}
}
void AprilServer::onProtobufMessage(const muduo::net::TcpConnectionPtr& conn,
const MessagePtr& message,
muduo::Timestamp time)
{
const google::protobuf::Descriptor* descriptor = message->GetDescriptor();
const google::protobuf::FieldDescriptor* id_field = descriptor->FindFieldByName("id");
const google::protobuf::FieldDescriptor* sync_field = descriptor->FindFieldByName("sync");
const google::protobuf::Reflection* reflection = message->GetReflection();
int32_t id = reflection->GetInt32(*message, id_field);
bool sync = reflection->GetBool(*message, sync_field);
LOG_INFO << "receive - id " << id << " sync " << sync;
if (_sync && sync) {
_dict->swap_dict();
_sync = false;
}
april::response mess;
int value = 0;
_dict->seek(id, &value);
mess.set_id(value);
mess.set_sync(_sync);
_codec.send(conn, mess);
}
Arcus::PythonMessage::PythonMessage(const MessagePtr& message)
{
_shared_message = message;
_message = message.get();
_reflection = message->GetReflection();
_descriptor = message->GetDescriptor();
}
void ProxyServer::sendMsgQueue(const MessagePtr& message,std::string title)
{
std::string msgname = message->GetTypeName();
std::string titlename = "push:" + msgname;
std::string value = message->DebugString();
LOG4CXX_INFO(log4cxx::Logger::getLogger(PROXYSERVER),value);
}
LocalFork::MessageAction LocalFork::handleReceivedMessage(MessagePtr msg, const AffectedArea &area)
{
// No local fork: nothing to do. It is possible that we get a message from ourselves
// that is not in the local fork, but this is not an error. It could happen when
// playing back recordings, for example.
if(_messages.isEmpty())
return CONCURRENT;
// Check if this is our own message that has finished its roundtrip
if(msg->contextId() == _messages.first()->contextId()) {
if(msg.equals(_messages.first())) {
_messages.removeFirst();
_areas.removeFirst();
return ALREADYDONE;
} else {
// Unusual, but not an error. This can happen when the layer is locked while drawing
// or when an operator performs some function on behalf the user.
qWarning("local fork out of sync: discarding...");
clear();
return ROLLBACK;
}
}
// OK, so this is another user's message. Check if it is concurrent
for(const AffectedArea &a : _areas) {
if(!area.isConcurrentWith(a)) {
return ROLLBACK;
}
}
return CONCURRENT;
}
void Client::flush()
{
while (mRunning)
{
// waits for messages to send
boost::unique_lock<boost::mutex> lock(mWMutex);
while (mWriteQ.empty() && mRunning)
mWCond.wait(lock);
if (mRunning)
{
// get and remove next item
MessagePtr msg = mWriteQ.front();
mWriteQ.pop_front();
// send it to the thread, but wait for other writes to finish
mWSMutex.lock();
boost::asio::async_write(mSocket,
boost::asio::buffer(msg->raw(),
msg->rawLength()),
boost::bind(&Client::onWritten,
this,
boost::asio::placeholders::error));
}
}
printf("Done flushing...\n");
}
void
api ()
{
if ((current_.status == Protocol::TS_COMMITED ||
current_.status == Protocol::TS_ABORTED) &&
separation_duration_ == 0) // no transaction in progress
{
// start new transaction
// Note that in_ is already locked by Scheduler
MessagePtr m (in_.front ());
in_.pop ();
if (typeid (*m) == typeid (Send))
{
send_ = SendPtr (dynamic_cast<Send*> (m.release ()));
}
else
{
// cerr << "Expecting Send but received " << typeid (*m).name ()
// << endl;
::abort ();
}
current_.id++;
current_.status = Protocol::TS_BEGIN;
initiated_ = true;
// if (trace_) cerr << "starting transaction with id " << current_.id
// << endl;
}
}
void Server::OnMessage(ConnectionHandle connection, MessagePtr data)
{
Urho3D::MutexLock lock(mutexEvents_);
ConnectionPtr connectionPtr = server_->get_con_from_hdl(connection);
if (data->get_opcode() == websocketpp::frame::opcode::TEXT)
{
String textMsg(data->get_payload().c_str());
LogInfo("[WebSocketServer]: on_utf8_message: size=" + String(textMsg.Length()) + " msg=" + textMsg);
}
else if (data->get_opcode() == websocketpp::frame::opcode::BINARY)
{
const std::string &payload = data->get_payload();
if (payload.size() == 0)
{
LogError("[WebSocketServer]: Received 0 sized payload, ignoring");
return;
}
SocketEvent *event = new SocketEvent(connectionPtr, SocketEvent::Data);
event->data = DataSerializerPtr(new kNet::DataSerializer(payload.size()));
event->data->AddAlignedByteArray(&payload[0], payload.size());
events_.Push(event);
}
}
void print_introspection(MessagePtr message, const std::string& prefix) {
if (!message->hasInstance()) {
std::cout << "No instance!" << std::endl;
}
for(Message::const_iterator it = message->begin(); it != message->end(); ++it) {
FieldPtr field = *it;
std::cout << prefix << std::string(field->getDataType()) << " " << std::string(field->getName()) << " = ";
if (field->isContainer()) std::cout << "[";
if (field->isMessage()) {
std::cout << std::endl;
for(std::size_t i = 0; i < field->size(); i++) {
MessagePtr expanded = field->expand(i);
if (!expanded) {
std::cout << prefix << " (unknown)" << std::endl;
continue;
}
print_introspection(expanded, prefix + " ");
}
std::cout << prefix;
} else {
for(std::size_t i = 0; i < field->size(); i++) {
if (i > 0) std::cout << ", ";
std::cout << field->as<std::string>(i);
}
}
if (field->isContainer()) std::cout << "]";
std::cout << std::endl;
}
}
void
NetServer::onStateMessage( MessagePtr m )
{
K_ASSERT( m.Get() != 0 );
NetStateMessage* nsm = static_cast<NetStateMessage*>( m.Get() );
switch ( nsm->state )
{
case NetStateMessage::TCP_CLOSED:
{
NetGroupMap::iterator i = m_groups.find( nsm->groupId );
if ( i != m_groups.end() )
{
NetGroup* group = i->second;
if ( group != 0 )
{
group->Leave( nsm->connectionId );
}
}
}
break;
}
m_listener->Notify( m );
}
void Peer::HandleResponses(WMessagePtr pWMsg)
{
MessagePtr pMsg = pWMsg->GetMsg();
// get the peer list if given in message
std::vector<RemotePeers> peerList = pMsg->m_peerList;
if( peerList.size() > 0 ) {
long ts = pMsg->m_timestamp;
this->HandlePeerList(peerList, ts);
}
// see if it is a task message
if( pMsg->IsTaskMessage() ) {
int msgTaskId = pMsg->m_taskId;
// get the task and forward the message
std::map<int, TaskPtr>::iterator it;
it = m_taskList.find(msgTaskId);
if( it != m_taskList.end() ) {
TaskPtr pTask = (*it).second;
pTask->GetMessageQueue()->PutMessage(pWMsg);
}
else {
Log(CONSOLE, L"No Task Related to Task Response Message Received for taskId: %d\n", msgTaskId);
}
return;
}
switch(pMsg->m_respType) {
case GET_ONLINE_RESP:
HandleOnlineResp(pMsg);
break;
default:
break;
}
}
void send_all(const T& value) {
MessagePtr msg = std::make_shared<Message>(sizeof(T));
msg->set_body_length(sizeof(T));
std::memcpy(msg->body(), &value, sizeof(T));
msg->encode_header();
send_all(msg);
}
void ArcnetIO::writeMessage( const MessagePtr& msg )
{
if ( !isEnabled_ )
{
THROW_ERROR("Arcnet subsystem has not been enabled.");
}
this->send( msg->msg(), msg->length() );
}
MessagePtr Message::Alloc(const char* data, uint32_t len)
{
MessagePtr msg;
if (len > 0)
{
msg.reset(new Message(data, len));
}
return msg;
}
MessagePtr Message::Alloc(uint32_t len)
{
MessagePtr msg;
if (len > 0)
{
msg.reset(new Message(len));
}
return msg;
}
void Host::handleReceiveEvent(ENetEvent* event)
{
ENetPacket* packet = event->packet;
PeerPtr peer = (Peer*) event->peer->data;
MessagePtr message = MessageCreate(0);
message->setPacket(packet);
onMessage(peer, message);
}
void AsyncConnection::HandleConnect(const MessagePtr msg, const boost::system::error_code& e)
{
if (!e)
{
m_app->HandleConnect(Connection::shared_from_this());
Start();
async_send(boost::asio::buffer(msg->Data(), msg->Length()),
m_strand.wrap(boost::bind(&AsyncConnection::HandleSend, this,
msg, boost::asio::placeholders::error, false)));
}
}
void send(int conn_idx, const T& value) {
// hack
// MessagePtr msg = std::make_shared<Message>(sizeof(T));
MessagePtr msg = scene_write_msg;
msg->set_body_length(sizeof(T));
std::memcpy(msg->body(), &value, sizeof(T));
msg->encode_header();
send(conn_idx, msg);
}
void LocalRulesManager::sendMessage(MessagePtr msg, enet_uint32 reliability)
{
unsigned char* buf = m_buffer;
msg->addToBuffer(buf);
ENetPacket * packet = enet_packet_create (m_buffer,
msg->getSize(),
reliability);
enet_host_broadcast (m_server, 0, packet);
enet_host_flush (m_server);
}
void RemoteRulesManager::sendMessage(MessagePtr msg, enet_uint32 reliability)
{
unsigned char* buf = m_buffer;
msg->addToBuffer(buf);
ENetPacket * packet = enet_packet_create (m_buffer,
msg->getSize(),
reliability);
enet_peer_send (m_peer, 0, packet);
enet_host_flush (m_client);
}
static MessagePtr Parse(const char* buf, int len, ErrorCode* error)
{
MessagePtr message;
typedef google::protobuf::int32 int32;
// check sum
int32 expectedCheckSum = async::detail::AsInt32(buf + len - kHeaderLen);
int32 checkSum = static_cast<int32>(0
/*::adler32(1,
reinterpret_cast<const Bytef*>(buf),
static_cast<int>(len - kHeaderLen))*/);
if (checkSum == expectedCheckSum)
{
// get message type name
int32 nameLen = async::detail::AsInt32(buf);
if (nameLen >= 2 && nameLen <= len - 2 * kHeaderLen)
{
std::string typeName(buf + kHeaderLen, buf + kHeaderLen + nameLen - 1);
// create message object
message.reset(CreateMessage(typeName));
if (message)
{
// parse from buffer
const char* data = buf + kHeaderLen + nameLen;
int32 dataLen = len - nameLen - 2 * kHeaderLen;
if (message->ParseFromArray(data, dataLen))
{
*error = kNoError;
}
else
{
*error = kParseError;
}
}
else
{
*error = kUnknownMessageType;
}
}
else
{
*error = kInvalidNameLen;
}
}
else
{
*error = kCheckSumError;
}
return message;
}
void Peer::queueMessage(const MessagePtr& message, uint8 channel)
{
if( !message ) return;
message->prepare();
int status = enet_peer_send(peer, channel, message->getPacket());
if(status != 0)
{
LogWarn("Error sending packet to peer '%s'", getHostName().c_str());
return;
}
}
void RcfProtoServer::ProtoRpcEndCpp(
std::pair<MessagePtr, MessagePtr> requestResponsePair,
RcfProtoControllerPtr controllerPtr)
{
MessagePtr requestPtr = requestResponsePair.first;
MessagePtr responsePtr = requestResponsePair.second;
RcfProtoSession & context = * controllerPtr->mpRcfSession;
int byteSize = responsePtr->ByteSize();
context.mResponseBuffer = RCF::ByteBuffer(byteSize);
responsePtr->SerializeToArray(context.mResponseBuffer.getPtr(), (int) context.mResponseBuffer.getLength());
context._Commit();
}
void Actor::Main() {
is_working_ = true;
MessagePtr msg;
while (mailbox_->Pop(msg)) {
if (handlers_.find(msg->type()) != handlers_.end()) {
handlers_[msg->type()](msg);
} else if (handlers_.find(MsgType::Default) != handlers_.end()) {
handlers_[MsgType::Default](msg);
} else {
Log::Fatal("Unexpected msg type\n");
}
}
}
//-----------------------------------------------------------------------
MessageResultPtr MessageResult::create(
MessagePtr requestOrNotify,
WORD errorCode,
const char *reason
)
{
MessageResultPtr pThis(new MessageResult);
pThis->mID = requestOrNotify->messageID();
pThis->mOriginalMethod = requestOrNotify->method();
pThis->mTime = zsLib::now();
pThis->mErrorCode = errorCode,
pThis->mErrorReason = String(reason ? reason : "");
return pThis;
}
void AsyncConnection::Send(const MessagePtr msg)
{
if (is_open())
{
async_send(boost::asio::buffer(msg->Data(), msg->Length()),
m_strand.wrap(boost::bind(&AsyncConnection::HandleSend, this,
msg, boost::asio::placeholders::error, true)));
}
else
{
boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::address::from_string(m_ip), m_port);
async_connect(endpoint, m_strand.wrap(boost::bind(&AsyncConnection::HandleConnect, this,
msg, boost::asio::placeholders::error)));
}
}
void Client::receiveMessages()
{
while(_msgqueue->isPending()) {
MessagePtr msg = _msgqueue->getPending();
if(_state == LOGIN) {
if(msg->type() == protocol::MSG_LOGIN)
emit loginMessage(msg);
else
logger::notice() << this << "Got non-login message (type=" << msg->type() << ") in login state";
} else {
handleSessionMessage(msg);
}
}
}
void
NetClient::Send( MessagePtr m )
{
K_ASSERT( m.Get() != 0 );
m_sendQ.Put( m );
}
void
NetServer::Send( MessagePtr m )
{
K_ASSERT( m.Get() != 0 );
m_sendQ.Put( m );
}
