liboh/include/sirikata/oh/HostedObject.hpp

Go to the documentation of this file.

/*  Sirikata liboh -- Object Host
 *  HostedObject.hpp
 *
 *  Copyright (c) 2009, Patrick Reiter Horn
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef _SIRIKATA_HOSTED_OBJECT_HPP_
#define _SIRIKATA_HOSTED_OBJECT_HPP_

#include <sirikata/core/util/SpaceObjectReference.hpp>
#include <sirikata/proxyobject/ProxyObject.hpp>
#include <sirikata/proxyobject/VWObject.hpp>
#include <sirikata/core/util/Platform.hpp>
#include <sirikata/core/odp/DelegateService.hpp>
#include <sirikata/oh/ObjectScriptManager.hpp>

#include <utility>

#include <sirikata/core/network/ObjectMessage.hpp>
#include <sirikata/core/odp/SST.hpp>

#include <sirikata/core/transfer/URI.hpp>

#include <sirikata/oh/ObjectHost.hpp>
#include <sirikata/oh/SimulationFactory.hpp>

//here
#include <sirikata/core/util/Platform.hpp>

#include <sirikata/core/service/Service.hpp>
#include <sirikata/core/util/Timer.hpp>
#include <sirikata/core/service/Context.hpp>

#include <sirikata/core/network/Message.hpp>

#include <boost/lexical_cast.hpp>
#include <boost/asio.hpp> //htons, ntohs


#include <sirikata/core/transfer/TransferData.hpp>
#include <sirikata/core/transfer/RemoteFileMetadata.hpp>
#include <sirikata/core/transfer/TransferPool.hpp>
#include <sirikata/core/transfer/TransferMediator.hpp>

namespace Sirikata {

class LocUpdate;

namespace Protocol {
namespace Loc {
class LocationUpdate;
class BulkLocationUpdate;
}
namespace Prox {
class ProximityUpdate;
}
}

class ProxyObject;
class ProxyObject;
struct LightInfo;
typedef std::tr1::shared_ptr<ProxyObject> ProxyObjectPtr;

class ObjectScript;
class HostedObject;
class PerPresenceData;
typedef std::tr1::weak_ptr<HostedObject> HostedObjectWPtr;
typedef std::tr1::shared_ptr<HostedObject> HostedObjectPtr;


class SIRIKATA_OH_EXPORT HostedObject
    : public VWObject,
      public Service
{
private:
  struct PrivateCallbacks;

    typedef struct OHConnectInfo{
    public:
      SpaceID spaceID;
      Location startingLocation;
      BoundingSphere3f meshBounds;
      String mesh;
      String physics;
      String query;
      ObjectReference orefID;
      int64 token;
      String zernike;
      } OHConnectInfo;
    typedef std::tr1::shared_ptr<OHConnectInfo> OHConnectInfoPtr;

protected:

    ObjectHostContext* mContext;
    const UUID mID;

    ObjectHost *mObjectHost;
    ObjectScript *mObjectScript;
    typedef std::map<SpaceObjectReference, PerPresenceData*> PresenceDataMap;
    PresenceDataMap mPresenceData;

    bool destroyed;

    ODP::DelegateService* mDelegateODPService;

    typedef boost::mutex Mutex;
    Mutex presenceDataMutex;
    Mutex notifyMutex;

    friend class ::Sirikata::SelfWeakPtr<VWObject>;
    friend class PerPresenceData;
    AtomicValue<int> mNumOutstandingConnections;
    bool mDestroyWhenConnected;

public:
    typedef SST::EndPoint<SpaceObjectReference> EndPointType;
    typedef SST::BaseDatagramLayer<SpaceObjectReference> BaseDatagramLayerType;
    typedef BaseDatagramLayerType::Ptr BaseDatagramLayerPtr;
    typedef SST::Connection<SpaceObjectReference> SSTConnection;
    typedef SSTConnection::Ptr SSTConnectionPtr;
    typedef SST::Stream<SpaceObjectReference> SSTStream;
    typedef SSTStream::Ptr SSTStreamPtr;

    virtual ~HostedObject();

    const UUID& id() const;

    // Sirikata::Service interface
    virtual void start();
    virtual void stop();

    bool stopped() const;

    typedef std::vector<SpaceObjectReference> SpaceObjRefVec;
    void getSpaceObjRefs(SpaceObjRefVec& ss) const;

    ObjectHostContext* context() { return mContext; }
    const ObjectHostContext* context() const { return mContext; }

    Time spaceTime(const SpaceID& space, const Time& t);
    Time currentSpaceTime(const SpaceID& space);
    Time localTime(const SpaceID& space, const Time& t);
    Time currentLocalTime();

    void initializeScript(const String& script_type, const String& args, const String& script);

    void destroy(bool need_self = true);
    ObjectHost *getObjectHost()const {return mObjectHost;}

    ProxyObjectPtr getProxy(const SpaceID& space, const ObjectReference& oref);

    Simulation* runSimulation(
        const SpaceObjectReference& sporef, const String& simName,
        Network::IOStrandPtr simStrand);

    void killSimulation(
        const SpaceObjectReference& sporef, const String& simName);

    virtual ProxyManagerPtr getProxyManager(const SpaceID& space,const ObjectReference& oref);

    typedef int64 PresenceToken;
    const static PresenceToken DEFAULT_PRESENCE_TOKEN = -1;

    bool connect(
        const SpaceID&spaceID,
        const Location&startingLocation,
        const BoundingSphere3f &meshBounds,
        const String& mesh,
        const String& physics,
        const String& query,
        const ObjectReference& orefID = ObjectReference::null(),
        PresenceToken token = DEFAULT_PRESENCE_TOKEN);


    void objectHostConnectIndirect(OHConnectInfoPtr oci) {
      bool ret = objectHostConnect(oci->spaceID, oci->startingLocation, oci->meshBounds,
                                   oci->mesh, oci->physics, oci->query, oci->zernike,
                                   oci->orefID, oci->token);
    }



    bool objectHostConnect(
        const SpaceID spaceID,
        const Location startingLocation,
        const BoundingSphere3f meshBounds,
        const String mesh,
        const String physics,
        const String query,
        const String zernike,
        const ObjectReference orefID,
        PresenceToken token = DEFAULT_PRESENCE_TOKEN);

    bool downloadZernikeDescriptor(OHConnectInfoPtr ocip, uint8 n_retry=0);

    void metadataDownloaded(
        OHConnectInfoPtr ocip,
        uint8 retryCount,
        std::tr1::shared_ptr<Transfer::MetadataRequest> request,
        std::tr1::shared_ptr<Transfer::RemoteFileMetadata> response);


    void disconnectFromSpace(const SpaceID &spaceID, const ObjectReference& oref);

    void receiveMessage(const SpaceID& space, const Protocol::Object::ObjectMessage* msg);


    HostedObjectPtr getSharedPtr() {
        return std::tr1::static_pointer_cast<HostedObject>(this->VWObject::getSharedPtr());
    }
    HostedObjectWPtr getWeakPtr() {
        return std::tr1::static_pointer_cast<HostedObject>(this->VWObject::getSharedPtr());
    }

    // Identification
    virtual ProxyManagerPtr presence(const SpaceObjectReference& sor);
    virtual SequencedPresencePropertiesPtr presenceRequestedLocation(const SpaceObjectReference& sor);
    virtual uint64 presenceLatestEpoch(const SpaceObjectReference& sor);

    virtual ProxyObjectPtr self(const SpaceObjectReference& sor);

    // ODP::Service Interface
    virtual ODP::Port* bindODPPort(const SpaceID& space, const ObjectReference& objref, ODP::PortID port);
    virtual ODP::Port* bindODPPort(const SpaceObjectReference& sor, ODP::PortID port);
    virtual ODP::Port* bindODPPort(const SpaceID& space, const ObjectReference& objref);
    virtual ODP::Port* bindODPPort(const SpaceObjectReference& sor);
    virtual ODP::PortID unusedODPPort(const SpaceID& space, const ObjectReference& objref);
    virtual ODP::PortID unusedODPPort(const SpaceObjectReference& sor);
    virtual void registerDefaultODPHandler(const ODP::Service::MessageHandler& cb);

    // Access to SST for this object
    ODPSST::Stream::Ptr getSpaceStream(const SpaceObjectReference& sor);

    // Movement Interface
    //note: location update services both position and velocity

    virtual void requestLocationUpdate(const SpaceID& space, const ObjectReference& oref,const TimedMotionVector3f& loc);
    virtual void requestOrientationUpdate(const SpaceID& space, const ObjectReference& oref, const TimedMotionQuaternion& orient);
    virtual void requestBoundsUpdate(const SpaceID& space, const ObjectReference& oref, const BoundingSphere3f& bounds);
    virtual void requestMeshUpdate(const SpaceID& space, const ObjectReference& oref, const String& mesh);
    virtual void requestPhysicsUpdate(const SpaceID& space, const ObjectReference& oref, const String& phy);

    virtual void requestQueryUpdate(const SpaceID& space, const ObjectReference& oref, const String& new_query);
    // Shortcut for requestQueryUpdate("")
    virtual void requestQueryRemoval(const SpaceID& space, const ObjectReference& oref);
    virtual String requestQuery(const SpaceID& space, const ObjectReference& oref);


    // ObjectQuerier Interface
    void handleProximityUpdate(const SpaceObjectReference& spaceobj, const Sirikata::Protocol::Prox::ProximityUpdate& update);
    void handleLocationUpdate(const SpaceObjectReference& spaceobj, const LocUpdate& lu);



    // Commands
    void commandPresences(
        const Command::Command& cmd, Command::Commander* cmdr, Command::CommandID cmdid);

  private:

    HostedObject(ObjectHostContext* ctx, ObjectHost*parent, const UUID &_id);

    // Because IOStrand->wrap() can't handle > 5 parameters (because the
    // underlying boost impementation doesnt), we need to handle wrapping
    // connection callbacks manually.

    void iHandleDisconnected(
        const HostedObjectWPtr& weakSelf, const SpaceObjectReference& spaceobj,
        Disconnect::Code cc);

    static void handleConnected(const HostedObjectWPtr &weakSelf, ObjectHost* parentOH, const SpaceID& space, const ObjectReference& obj, ObjectHost::ConnectionInfo info);
    static void handleConnectedIndirect(const HostedObjectWPtr &weakSelf, ObjectHost* parentOH, const SpaceID& space, const ObjectReference& obj, ObjectHost::ConnectionInfo info, const BaseDatagramLayerPtr&);

//    static bool handleEntityCreateMessage(const HostedObjectWPtr &weakSelf, const ODP::Endpoint& src, const ODP::Endpoint& dst, MemoryReference bodyData);
    static void handleMigrated(const HostedObjectWPtr &weakSelf, const SpaceID& space, const ObjectReference& obj, ServerID server);
    static void handleStreamCreated(const HostedObjectWPtr &weakSelf, const SpaceObjectReference& spaceobj, SessionManager::ConnectionEvent after, PresenceToken token);
    static void handleDisconnected(const HostedObjectWPtr &weakSelf, const SpaceObjectReference& spaceobj, Disconnect::Code cc);

    // Helper that disconnects presences that were completed after the
    // HostedObject was stopped/destroyed. Only invoke indirectly (via posting)
    // since we don't want to muck with the connection within the connection
    // callback.
    static void disconnectDeadPresence(ObjectHost* parentOH, const SpaceID& space, const ObjectReference& obj);

    ODP::DelegatePort* createDelegateODPPort(ODP::DelegateService* parentService, const SpaceObjectReference& spaceobj, ODP::PortID port);
    bool delegateODPPortSend(const ODP::Endpoint& source_ep, const ODP::Endpoint& dest_ep, MemoryReference payload);


    // Handlers for core space-managed updates
    void processLocationUpdate(const SpaceObjectReference& sporef, ProxyObjectPtr proxy_obj, const LocUpdate& update);
    void processLocationUpdate(
        const SpaceID& space, ProxyObjectPtr proxy_obj, bool predictive,
        TimedMotionVector3f* loc, uint64 loc_seqno,
        TimedMotionQuaternion* orient, uint64 orient_seqno,
        AggregateBoundingInfo* bounds, uint64 bounds_seqno,
        String* mesh, uint64 mesh_seqno,
        String* phy, uint64 phy_seqno
    );

    // Helper for creating the correct type of proxy
    ProxyObjectPtr createProxy(const SpaceObjectReference& objref, const SpaceObjectReference& owner_objref, const Transfer::URI& meshuri, TimedMotionVector3f& tmv, TimedMotionQuaternion& tmvq, const AggregateBoundingInfo& bounds, const String& physics, const String& query, bool isAggregate, uint64 seqNo);

    // Helper for constructing and sending location update
    void updateLocUpdateRequest(const SpaceID& space, const ObjectReference& oref, const TimedMotionVector3f* const loc, const TimedMotionQuaternion* const orient, const BoundingSphere3f* const bounds, const String* const mesh, const String* const phy);
    void sendLocUpdateRequest(const SpaceID& space, const ObjectReference& oref);

};

}

#endif