vos/corelibs/vos/localsite.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/
#ifndef _LOCALSITE_HH_
#define _LOCALSITE_HH_

#include <vos/corelibs/vos/vosdefs.hh>
#include <vos/corelibs/vos/site.hh>
#include <vos/corelibs/vos/localmetaobject.hh>

#include <map>
#include <queue>
#include <iostream>

namespace VOS
{
    class RemoteSite;
    class RemoteSocketSite; // Why does localsite use both remotesocketsite and remotesite?

typedef MetaObject* (*metaobject_extender_t)(MetaObject* superobject, const string& type);

/** @class LocalSite localsite.hh vos/corelibs/vos/localsite.hh
 *
 * A site which is local to your application.  This acts as the
    communication point between your application and other VOS
    applications, managing the delivery of incoming messages as well
    as servicing certain types of requests about your local Vobjects.
    All Vobjects are associated with some site.
*/
class VOS_API LocalSite : public virtual Site, public virtual LocalMetaObject
{
private:
    typedef multimap<string, metaobject_extender_t>::iterator MI;
    static multimap<string, metaobject_extender_t> localObjectExtensionTable;
public:
    class PortBindingError : public runtime_error {
    public:
        PortBindingError(const string& s) : runtime_error(s) { }
    };
protected:
    struct SiteTableEntry {
        string localPeerName;
        MessageBlock* partialMessage;
    };
    int iteratorsUsingPeerSites;

    /** The following three data structures are used to buffer changes
       to peerSites when we have an active iterator using peerSites.
       This is to avoid invalidating the iterator (ye gods that was an
       obnoxious bug to track down.)  The alternative would have to be
       to make a complete copy of the peerSites deque every time we
       want to copy it (ewww...)

       @note although peerSitesBuffer_rs and peerSitesBuffer_st could
       be combined into a single structure like deque<
       pair<RemoteSite*, struct SiteTableEntry*> > BUT that causes an
       internal compiler error when compiling site.cc!  So instead we
       do it this way.  Bleh.
    */
    deque<RemoteSite*> peerSitesBuffer_rs;
    deque<struct SiteTableEntry*> peerSitesBuffer_st;
    deque<RemoteSite*> peerSitesBuffer_remove;

    boost::mutex peerSitesBuffer_mutex;

    /** List of remote sites we are peers with. */
    map<RemoteSite*, struct SiteTableEntry*> peerSites;

    /** The current message schedule. */
    map<double, list<Message*> > siteMessageQueue;
    list<Message*> msgsReady;
    list<Message*> prioritizedQueue;

    struct ::timeval* selectwait;

    map<string, RemoteSite*> prioritized;

public:
    
    /** Timer callback type for a global C function. Register the callback
     * using addCallback. 
     */
    typedef void (*callback_t)(void* userdata);
    
    /** Timer callback listener type. Register an instance of this class
     * using addCallback.
     */
    class CallbackListener {
    public:
        virtual void notifySiteCallback() = 0;
    };

protected:
    struct CallbackInfo {
        bool repeat;    // callback should be performed repeatedly
        double timeout; // amount of time to wait between repeated callbacks
        callback_t callback;    // if null, try listener
        void* userdata;
        CallbackListener* listener; // if null, try callback function.
    };

    bool callbacklock;
    map<double, CallbackInfo> callbacks;
    queue<pair<double, CallbackInfo> > callbackaddqueue;
    queue<callback_t> callbackremovequeue;
    queue<CallbackListener*> callback_listener_remove_queue;
    void scheduleCallback(callback_t callback, CallbackListener* listener, void* userdata, double timeout, bool repeat);

    queue<NotifyEvent*> notifyEvents;
    bool notifyflushlock;

    map<string, string> antiSpoofMap;

    void verifyCheckIDPair(RemoteSocketSite* rss, const string& spoofID);

    struct ValidationEntry
    {
        string checkid;
        string hostalias;
        vRef<RemoteSocketSite> realsite;
        bool favored;
    };
    map<RemoteSocketSite*, ValidationEntry> pendingValidations;
    set<string> pendingValidationHosts;

    list< pair<string, RemoteSite*> > needSpoofIDreply;

    /** constructor */
    LocalSite();
public:
    /** destructor */
    virtual ~LocalSite();

    virtual void flushIncomingBuffers() = 0;

    /** Schedule a message block for delivery.  Special message types like include
        will be processed.
        @param mb The message block
        @param mc The enclosing message context
        @param ss The source site
        @param plustime This value will be added to the delivery time
        @param extradependency This dependency string will added to each message
    */
    virtual void scheduleMessageBlock(MessageBlock* mb, MessageContext* mc, Site* ss,
                                      double plustime=0.0, const char* extradependency=0);

    /** Execute the current schedule.  */
    virtual void runSchedule();

    /** Run pending callbacks. */
    void doCallbacks();

    /** Register a periodic or timed callback listener. Callbacks are 
     * checked each time flushIncomingBuffers is called. 
    */
    void addCallback(CallbackListener* listener, double timeout, bool repeat = true);

    /** Register a simple global function as a timer callback. */
    void addCallback(callback_t callback, void* userdata, double timeout, bool repeat = true);

    /** Remove a callback. (see addCallback)*/
    void removeCallback(callback_t callback);

    /** Remove a callback. (see addCallback)*/
    void removeCallback(CallbackListener* listener);

    /** Remove the peering relationship with a remote site. */
    virtual void removeRemotePeer(RemoteSite* rs);

    /** Check if any messages in the schedule have "site" as a source
        site.  Mainly used when a site disconnects and its pending
        messages need to be flushed...
    */
    virtual bool checkScheduleHoldsSite(Site* site);

    virtual void sendMessage(Message* m);
    virtual void sendMessage(MessageBlock* m);
    virtual void setURL(const URL& u);

    /** Always true. */
    virtual bool isConnected() {
        return true;
    }

    virtual Site& getSite() { return Site::getSite(); }

    /** When select() is called to test file descriptors, this sets maximum amount of time
        to wait before returning if there is no data available.  This primarily applies
        to LocalSite::flushIncomingBuffers().
        @param sec the time to wait, in seconds.  This may be zero, in
        which case a flushIncomingBuffers() call will return
        immediately if there is no pending data.  If "sec" is
        negative, select will sleep indefinitely until data is
        received on any of the sockets or the process catches a
        signal.
    */
    void setTimeoutOnSelect(double sec);

    /** Get the select wait time.
        @return the maximum time (in seconds) that select will wait,
        or -1 if select will block indefinately. */
    double getTimeoutOnSelect();

    virtual void addPrioritizedNonce(const string& nonce, RemoteSite* source);
    virtual void removePrioritizedNonce(const string& nonce, RemoteSite* source);

    /** Use this site to extend a LocalMetaObject with for a new type. */
    static void extendMetaObject(LocalMetaObject* root, const char* type);

    /** Create meta objects with the given name and types, and the default
        access control for this site.  */
    //@{
    /** Use 0 to terminate the list of type strings. */
    virtual MetaObject* createMetaObject(const char* name, const char* type0, ...);
    virtual MetaObject* createMetaObject(const char* name, const deque<string>& typelist);
    //@}

    /** Create a new local metaobject, with the supplied access control (ar
     * defoult site AC if 0).
     * @sa createMetaObject(const char*, const char*, ...)
     */
    virtual MetaObject* createMetaObject(const char* name, VobjectAccessControl* ac, const char* type0, ...);


    /** Create a new local metaobject, with the supplied access control (ar
     * defoult site AC if 0).
     * @sa createMetaObject(const char*, const char*, ...)
     */
    virtual MetaObject* createMetaObject(const char* name, VobjectAccessControl* ac, const deque<string>& typelist);


    /** Create a new metaobject with one type, and cast it to that type.
     * @param T     Desired MetaObject subclass
     * @param name  If given, site-name of the new object
     * @param ac    Primary access control on the new object
     */ 
    template<class T> T* createMetaObject(const char* name = 0, VobjectAccessControl* ac = 0) {
        if(ac)
            return meta_cast<T*>(createMetaObject(name, ac, typeid(T).name(), 0));
        else
            return meta_cast<T*>(createMetaObject(name, typeid(T).name(), 0));
    }


    static void addLocalObjectExtension(const char* type, metaobject_extender_t newmethod);
    static void removeLocalObjectExtension(const char* type, metaobject_extender_t oldmethod);

    static void printExtensionTable(ostream& stream = std::cerr);

    /** Add a notification event to be called during
        flushIncomingBuffers().  A notification event is called once
        and then destroyed.
     */
    virtual void addNotification(NotifyEvent* ev);

    /** Execute any pending notification events. */
    virtual void flushNotifications();

    /** Calling this will cause flushNotifications() to do nothing
        (and hence no notifications will be processed) until
        unlockNotificationFlush is called. */
    virtual void lockNotificationFlush();

    /** Allow notifcations to be processed again. */
    virtual void unlockNotificationFlush();

    virtual void insertChild(int position, const string& contextual_name, Vobject* child)
        throw (AccessControlError, RemoteError);
    virtual void setChild(int position, const string& contextual_name, Vobject* child)
        throw (AccessControlError, RemoteError);
    virtual void removeChild(int position)
        throw (AccessControlError, RemoteError);

    /** Maps a received anti-spoof ID to the one sent to that site. */
    void setAntiSpoofIDMapping(const string& recv, const string& sent) { antiSpoofMap[recv] = sent; }

    /** Maps a received anti-spoof ID to the one sent to that site. */
    const string& getAntiSpoofIDMapping(const string& recv) { return antiSpoofMap[recv]; }

    /** Any messages belonging to site "was" will be reassigned to
        site "now".  This only affects the source site field of the
        message object.
    */
    void takeOverMessages(Site* was, Site* now);

    /** Set the hostname we will prefer to use.
        @param s the DNS hostname or dotted quad IP address */
    virtual void setPrimaryHostname(string s);

    friend void Site::doSitePeering(LocalSite* localsite, RemoteSite* remotesite, bool isspooftest, bool waitforhello);
};
}

#endif

---