C++ RoutableMessageHeader类代码示例

 /**
  * Process a message that may be meant for the proximity system
  */
 virtual void processMessage(const RoutableMessageHeader& mesg,
                             MemoryReference message_body) {
     internalProcessOpaqueProximityMessage(mesg.has_source_object()?&mesg.source_object():NULL,
                                           mesg,
                                           message_body.data(),
                                           message_body.size(),true);
 }

void Space::processMessage(const ObjectReference*ref,MemoryReference message){
    
    RoutableMessageHeader hdr;
    MemoryReference message_body=hdr.ParseFromArray(message.data(),message.size());
    if (!hdr.has_source_object()&&ref) {
        hdr.set_source_object(*ref);
    }
    this->processMessage(hdr,message_body);
}

 virtual DidAlterMessage addressMessage(RoutableMessageHeader&output,
                             const ObjectReference*source,
                             const ObjectReference*destination) {
     return UNSPOILED_MESSAGE;
     if (0) {//you might want to do this if you are a forwarding class or something more advanced
         if (source)
             output.set_source_object(*source);
         if (destination)
             output.set_destination_object(*destination);
     }
 }

    void go() {
        mSuccess = false;
        Persistence::Protocol::ReadWriteSet rws;
        Persistence::Protocol::IStorageElement el = rws.add_reads();
        el.set_field_name("ObjectList");
//        el.set_object_uuid(UUID::null());
//        el.set_field_id(0);
        RoutableMessageHeader hdr;
        hdr.set_source_object(ObjectReference::spaceServiceID());
        hdr.set_source_port(mPort);
        hdr.set_destination_port(Services::PERSISTENCE);
        hdr.set_destination_object(ObjectReference::spaceServiceID());
        std::string body;
        rws.SerializeToString(&body);
        mObjectHost->processMessage(hdr, MemoryReference(body));
    }

void QueryTracker::processMessage(const RoutableMessageHeader &msgHeader, MemoryReference body) {
    if (!msgHeader.has_reply_id()) {
        SILOG(cppoh, error, "QueryTracker::processMessage called for non-reply");
        return; // Not a response message--shouldn't have gotten here.
    }
    // This is a response message;
    int64 id = msgHeader.reply_id();
    SentMessageMap::iterator iter = mSentMessages.find(id);
    if (iter != mSentMessages.end()) {
        if ((!iter->second->header().has_destination_space() ||
             iter->second->header().destination_space() == msgHeader.destination_space()) &&
            iter->second->getRecipient() == msgHeader.source_object())
        {
            iter->second->processMessage(msgHeader, body);
        } else {
            ObjectReference dest(ObjectReference::null());
            if (msgHeader.has_destination_object()) {
                dest = msgHeader.destination_object();
            }
            std::ostringstream os;
            os << "Response message with ID "<<id<<" to object "<<dest<<
                " should come from "<<iter->second->getRecipient() <<
                " but instead came from " <<msgHeader.source_object();
            SILOG(cppoh, warning, os.str());
        }
    } else {
        SILOG(cppoh, warning, "Got a reply for unknown query ID "<<id);
    }
}

void MonoVWObjectScript::processMessage(const RoutableMessageHeader&receivedHeader , MemoryReference body){
    std::string header;
    receivedHeader.SerializeToString(&header);
    MonoContext::getSingleton().push(MonoContextData());
    MonoContext::getSingleton().setVWObject(mParent,mDomain);
    try {
        Mono::Object retval=mObject.send("processMessage",mDomain.ByteArray(header.data(),(unsigned int)header.size()),mDomain.ByteArray((const char*)body.data(),(unsigned int)body.size()));
    }catch (Mono::Exception&e) {
        SILOG(mono,debug,"Message Exception "<<e);
    }
    MonoContext::getSingleton().pop();
}

 void processMessage(const RoutableMessageHeader &hdr, MemoryReference body) {
     Persistence::Protocol::Response resp;
     resp.ParseFromArray(body.data(), body.length());
     if (hdr.has_return_status() || resp.has_return_status()) {
         SILOG(cppoh,info,"Failed to connect to database: "<<hdr.has_return_status()<<", "<<resp.has_return_status());
         mSuccess = true;
         return;
     }
     Protocol::UUIDListProperty uuidList;
     if (resp.reads(0).has_return_status()) {
         SILOG(cppoh,info,"Failed to find ObjectList in database.");
         mSuccess = true;
         return;
     }
     uuidList.ParseFromString(resp.reads(0).data());
     for (int i = 0; i < uuidList.value_size(); i++) {
         SILOG(cppoh,info,"Loading object "<<ObjectReference(uuidList.value(i)));
         HostedObjectPtr obj = HostedObject::construct<HostedObject>(mObjectHost, uuidList.value(i));
         obj->initializeRestoreFromDatabase(mSpace, HostedObjectPtr());
     }
     mSuccess = true;
 }

void SingleStreamProximityConnection::processMessage(const RoutableMessageHeader&hdr,
                                                     MemoryReference message_body) {
    ObjectStreamMap::iterator where=mObjectStreams.find(hdr.has_source_object()?hdr.source_object():ObjectReference::null());
    if (where==mObjectStreams.end()) {
        where=mObjectStreams.find(hdr.has_destination_object()?hdr.destination_object():ObjectReference::null());
    }
    if (where==mObjectStreams.end()) {
        SILOG(proximity,error,"Cannot locate object with OR "<<hdr.source_object()<<" in the proximity connection map: "<<hdr.has_source_object());
    } else {
        std::string data;
        RoutableMessageHeader rmh;
        rmh.SerializeToString(&data);
        where->second->send(MemoryReference(data),message_body,Network::ReliableOrdered);
    }
}

bool MonoVWObjectScript::processRPC(const RoutableMessageHeader &receivedHeader, const std::string &name, MemoryReference args, MemoryBuffer &returnValue){
    MonoContext::getSingleton().push(MonoContextData());
    MonoContext::getSingleton().setVWObject(mParent,mDomain);
    std::string header;
    receivedHeader.SerializeToString(&header);
    try {
        Mono::Object retval=mObject.send("processRPC",mDomain.ByteArray(header.data(),(unsigned int)header.size()),mDomain.String(name),mDomain.ByteArray((const char*)args.data(),(int)args.size()));
        if (!retval.null()) {
            returnValue=retval.unboxByteArray();
            MonoContext::getSingleton().pop();
            return true;
        }
        MonoContext::getSingleton().pop();
        return false;
    }catch (Mono::Exception&e) {
        SILOG(mono,debug,"RPC Exception "<<e);
        MonoContext::getSingleton().pop();
        return false;        
    }
    MonoContext::getSingleton().pop();
    return true;
}

 void timedOut(const boost::system::error_code &error) {
     std::auto_ptr<TimerHandler> scopedDestructor(this);
     if (error == boost::asio::error::operation_aborted) {
         return; // don't care if the timer was cancelled.
     }
     RoutableMessageHeader msg;
     if (mSentMessage->header().has_destination_object()) {
         msg.set_source_object(mSentMessage->header().destination_object());
     }
     if (mSentMessage->header().has_destination_space()) {
         msg.set_source_space(mSentMessage->header().destination_space());
     }
     msg.set_source_port(mSentMessage->header().destination_port());
     msg.set_return_status(RoutableMessageHeader::TIMEOUT_FAILURE);
     msg.set_reply_id(mSentMessage->getId());
     mSentMessage->mTimerHandle=NULL;
     mSentMessage->mResponseCallback(mSentMessage, msg, MemoryReference(NULL,0));
     //formerly called this, but that asked asio to unset an ignored callback mSentMessage->processMessage(msg, MemoryReference(NULL,0));
 }

    /**
     * Process a message that may be meant for the proximity system
     * \returns true if object was deleted
     */
    OpaqueMessageReturnValue internalProcessOpaqueProximityMessage(
                                               const ObjectReference*object,
                                               const RoutableMessageHeader& hdr,
                                               const void *serializedMessageBody,
                                               size_t serializedMessageBodySize,
                                               bool trusted) {
        try {
            RoutableMessage msg(hdr,serializedMessageBody,serializedMessageBodySize);
            MessageBundle sendState=DELIVER_TO_UNKNOWN;
            bool deliverAllMessages=true;
            int len=msg.body().message_size();
            OpaqueMessageReturnValue obj_is_deleted=OBJECT_NOT_DESTROYED;
            bool disconnection=false;
            bool registration=false;
            for (int i=0;i<len;++i) {
                if (trusted||(hdr.has_source_object()&&hdr.source_object()==ObjectReference::spaceServiceID()&&hdr.source_port()==mRegistrationPort)) {
                    if(msg.body().message_names(i)=="DelObj") {
                        disconnection=true;
                        obj_is_deleted=OBJECT_DELETED;
                    }
                    if(msg.body().message_names(i)=="RetObj") {
                        registration=true;
                        Sirikata::Protocol::RetObj ro;
                        ro.ParseFromString(msg.body().message_arguments(i));
                        newObj(ro,msg.body().message_arguments(i).data(),msg.body().message_arguments(i).size());
                    }
                }
                if (!forwardThisName(disconnection,msg.body().message_names(i))) {
                    if (len==1) return obj_is_deleted;
                    deliverAllMessages=false;
                }else {
                    if (msg.body().message_names(i)==proxCallbackName()) {
                        if (sendState==DELIVER_TO_UNKNOWN||sendState==DELIVER_TO_OBJECT)
                            sendState=DELIVER_TO_OBJECT;
                        else 
                            sendState=DELIVER_TO_BOTH;
                    }else{
                        if (sendState==DELIVER_TO_UNKNOWN||sendState==DELIVER_TO_PROX)
                            sendState=DELIVER_TO_PROX;
                        else 
                            sendState=DELIVER_TO_BOTH;
                    }
                }
            }
            if (sendState==DELIVER_TO_UNKNOWN)
                return obj_is_deleted;//no messages considered worth forwarding to the proximity system
            if (sendState==DELIVER_TO_BOTH) {
                SILOG(prox,info,"Message with recipients both proximity and object bundled into the same message: not delivering.");
                return obj_is_deleted;
            }
/* NOT SURE THIS IS NECESSARY -- do these messages already have addresses on them?*/
            DidAlterMessage alteration;
            if (sendState==DELIVER_TO_PROX) 
                alteration=addressMessage(msg,object,NULL);
            else
                alteration=addressMessage(msg,NULL,object);
            if (deliverAllMessages&&sendState==DELIVER_TO_PROX) {
                sendMessage(*object,msg,serializedMessageBody,serializedMessageBodySize);
            } else if (deliverAllMessages&&sendState==DELIVER_TO_OBJECT) {
                deliverMessage(*object,msg,serializedMessageBody,serializedMessageBodySize);
            }else {
                //some messages are not considered worth forwarding to the proximity system or there's a mishmash of destinations
                if (msg.body().message_size()<len) {
                    len=msg.body().message_size();
                }
                RoutableMessage newMsg (msg);
                newMsg.body().clear_message();
                for (int i=0;i<len;++i) {
                    if (forwardThisName(registration||disconnection,msg.body().message_names(i))) {
                        newMsg.body().add_message(msg.body().message_names(i), msg.body().message_arguments(i));
                    }
                }
                if (sendState==DELIVER_TO_OBJECT)
                    deliverMessage(*object,newMsg,NULL,0);
                if (sendState==DELIVER_TO_PROX)
                    sendMessage(*object,newMsg,NULL,0);
                
            }
            return obj_is_deleted;
        }catch(std::invalid_argument&ia) {
            SILOG(proximity,warning,"Could not parse message");
            return OBJECT_NOT_DESTROYED;
        }

    }