vos/corelibs/vos/typingtweaks/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, 2002 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_

#ifndef _VOS_HH_
#error Please only include "vos.hh"!
#endif

/** @file
    Defines LocalSite.
*/

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

/** A site which is local to your application.  It is to one of these
    where you will attach all of your own local objects.  It listens
    on a single TCP socket for incoming connections from remote sites
    (this connection process is called @em site @em peering).
*/
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;

    struct ::timeval* selectwait;

    map<string, RemoteSite*> prioritized;

    typedef void (*callback_t)(void* userdata);
    struct Callback {
        bool repeat;    // callback should be performed repeatedly
        double timeout; // amount of time to wait between repeated callbacks
        callback_t callback;
        void* userdata;
    };

    bool callbacklock;
    map<double, Callback> callbacks;
    queue<pair<double, Callback> > callbackaddqueue;
    queue<callback_t> callbackremovequeue;

    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();

    void doCallbacks();
    void addCallback(callback_t callback, void* userdata, double timeout, bool repeat);
    void removeCallback(callback_t callback);

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

    virtual bool checkScheduleHoldsSite(Site* site);

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

    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
        it will return immediately.  If the time 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);

    static void extendMetaObject(LocalMetaObject* root, const char* type);
//    static void extendMetaObjectV(LocalMetaObject* root, va_list ap);


    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);

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

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

    virtual void addNotification(NotifyEvent* ev);
    virtual void flushNotifications();
    virtual void lockNotificationFlush();
    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]; }

    void takeOverMessages(Site* was, Site* now);

    virtual void setPrimaryHostname(string s);

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

#endif

---