vos/corelibs/vos/site.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 _SITE_HH_
#define _SITE_HH_

/** @file
    Defines Site.
*/

#include <vos/corelibs/vos/vosdefs.hh>
#include <vos/corelibs/vos/messagecontext.hh>
#include <vos/corelibs/vos/metaobject.hh>

#define VOS_DEFAULT_PORT 4231

namespace VOS
{

    class Message;
    class MessageBlock;
    class MessageContext;

class VOS_API NotifyEvent
{
public:
    virtual ~NotifyEvent() {};
    virtual void notify() = 0;
};

/** @class MessageFilter site.hh vos/corelibs/vos/site.hh
 *
 * A message filter can be attached to any site to filter the
 *  messages passing through that site.  If you attach the filter to a
 *  remote site, you will filter outbound messages going to that
 *  remote site.  If you attach a filter to a local site, you will
 *  filter inbound messages being sent to the local site.
 */
class VOS_API MessageFilter
{
public:
    virtual ~MessageFilter();

    /** Do something with this message.  You are permitted to modify the message.
        @param m the message
        @return true to continue processing the message, false
        indicating the message should NOT be sent or delivered.
     */
    virtual bool checkMessage(Message* m) = 0;
    virtual bool checkMessage(MessageBlock* m);
};

    class ChildChangeListener;
    class ParentChangeListener;
    class TypeChangeListener;
    class VobjectEvent;
    class LocalSite;
    class RemoteSite;

class VOS_API VobjectNotifyEvent : public NotifyEvent
{
private:
    ChildChangeListener* childlistener;
    ParentChangeListener* parentlistener;
    TypeChangeListener* typelistener;
    VobjectEvent& event;

public:
    VobjectNotifyEvent(ChildChangeListener* cl, VobjectEvent& e);
    VobjectNotifyEvent(ParentChangeListener* pl, VobjectEvent& e);
    VobjectNotifyEvent(TypeChangeListener* tl, VobjectEvent& e);

    virtual ~VobjectNotifyEvent();
    virtual void notify();
};

/** @class Site site.hh vos/corelibs/vos/site.hh
 *
 *  A site is the root of any collection of Vobjects.  It is a normal
    Vobject itself, but also supports a number of other methods.
    Think of sites as the connecting lines across which a Vobject may
    exchange messages with another Vobject on another host across the
    Internet.
 */
class VOS_API Site : public virtual MetaObject
{
private:
    set<string> hostnames;
    boost::mutex hostnames_mutex;

    static map<string, Site*> siteTable;
    static boost::mutex siteTable_mutex;

    static LocalSite* defaultPeer;
    map<string, MessageBlock*> messageBlockTable;
    map<string, Message*> outgoingTraps;
    bool greeted;

protected:
    Site();
    Site(MetaObject* superobject);
    deque<MessageFilter*> messagefilters;

public:
    class NoSuchMessageBlockError : public runtime_error {
    public:
        NoSuchMessageBlockError(const string& s) : runtime_error(s) { };
    };

    MessageContext defaultContext;

    /** All sockets open to this process.  Used so that the process,
        if desired, can sleep on select(), blocking indefinitely, and
        wake up when data comes in from any open socket.
    */
    static set<int> allOpenSockets;

public:


    /** Create a new MetaObject on this site.
      @param name  Request this name for the new object. If name is 0, empty or
        contains a name already in use, a new name will be generated.
      @param type0,...    Type strings indicating type extentions to be included
        with the new objects. The list of type strings must be terminated by a 0.

      For example:
      @code
           // Create an example object with two types: 3D cube and Hypercard.
           vRef<MetaObject> obj1 = site.createMetaObject("example", "object3D:cube", typeid(Hypercard).name(), 0);

           // Create another example object with no types. Because the same
           // name an the previos object ("example") is specified, this object will be
           // renamed when created, probably to "example1" or something similiar.
           vRef<MetaObject> obj2 = site.createMetaObject("example" , 0);
      @endcode
     */
    virtual MetaObject* createMetaObject(const char* name, const char* firstType, ...) = 0;

    /** Same as the other createMetaObject method, but takes a deque of type
     * strings rather than a variable list of strings.
     * @see createMetaObject(const char*, const char*, ...)
     */
    virtual MetaObject* createMetaObject(const char* name, const deque<string>& typelist) = 0;

    /** 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
     */ 
    template<class T> T* createMetaObjectT(const char* name = 0) {
        return meta_cast<T*>(createMetaObject(name, typeid(T).name(), 0));
    }

    /** Create an object with no types */
    MetaObject* createMetaObject(const char* name = 0) {
        return createMetaObject(name, 0);
    }

    /** Generate unique object name by appending successive integers to the
     * given base (if necesary).  (Used by the createMetaObject methods).
     */
    virtual string uniqueName(const char* base);

    /// Generate random and unique numerical name. (Used by the createMetaObject methods).
    virtual string generateUniqueName();

    /** Flush any incoming buffers (eg read any data waiting in sockets).
     */
    virtual void flushIncomingBuffers() = 0;


    /** Add a host alias to this site.  A host alias is a legal name
        by which this site may be refered to.
        @param h the host alias in the form "hostname:port"
    */
    virtual void addHostAlias(const string& h);

    /** Remove a host alias of this site.
        @param h the host alias in the form "hostname:port"
    */
    virtual void removeHostAlias(const string& h);

    /** Tests for the existance of a given host alias.
        @param h the host alias
        @return true if h is a legal host alias, false if not
    */
    virtual bool hasHostAlias(const string& h);

    /** Get a list of host alias.
        @return the set of host valid host aliases.
    */
    virtual set<string>& getHostAliases();

    /** Set the base URL ("vop://host:port") that this site will use.
        @param u some URL.
    */
    virtual void setURL(const URL& u) = 0;

    /** Add a site to the master table of known sites.
        @param s the site to be added
    */
    static void addSite(Site* s);

    /** Remove a site from the master table of known sites.
        @param s the site to remove
    */
    static void removeSite(Site& s);

    /** Find a site by its host alias.  Will contact remote sites
        as necessary.
        @param s the site host alias (in the form "host:port")
        @return the site matching that host alias.   NOTE YOU MUST CALL
release() WHEN DONE OR USE A vRef<>
        @throws NoSuchSiteError if the site is not found or could not be contacted
    */
    static Site& findSite(const string& s) throw (NoSuchSiteError);

    /** Get the local site with which new remote sites will peered.
        @return the default peer.    NOTE YOU MUST CALL release() WHEN DONE OR USE A vRef<>
     */
    static LocalSite* getDefaultPeer();

    /** Set the local site with which new remote sites will peered.
        @param localsite the default peer
     */
    static void setDefaultPeer(LocalSite* localsite);

    /** Get the current table of known sites, which maps host aliases to sites.
        @return the site table
    */
    static const map<string,Site*>& getAllSites();


    /** Save a message block template for later retrival and execution.
        @param m the message block
    */
    virtual void addMessageBlock(MessageBlock* m);

    /** Remove a saved message block template.
        @param m the message block
    */
    virtual void removeMessageBlock(MessageBlock* m);

    /** Retrive a saved message block template.
        @param s the name of the message block.
        @return The message block, or 0 if not found.   NOTE YOU MUST CALL release() WHEN DONE OR USE A vRef<>
    */
    virtual MessageBlock* getMessageBlock(const string& s) throw (NoSuchMessageBlockError);

    virtual bool isConnected() = 0;

    virtual void sendMessage(Message* m);
    virtual void sendMessage(MessageBlock* m);

    virtual void trapOutgoingReply(Message* m);
    virtual bool getGreeted();
    virtual void setGreeted(bool g);
    virtual void addNotification(NotifyEvent* ev) = 0;
    virtual void flushNotifications() = 0;
    virtual void lockNotificationFlush() = 0;
    virtual void unlockNotificationFlush() = 0;

    virtual const string getType();
    virtual Site& getSite();

    virtual void insertMessageFilter(int pos, MessageFilter* mf);
    virtual void removeMessageFilter(int pos);
    virtual void removeMessageFilter(MessageFilter* m);
    virtual const deque<MessageFilter*>& getMessageFilters();

    static string detectHostname(int fd, unsigned char ipaddr[4]);
    static struct hostent* gethostbyaddr_locked(const char *addr, int len, int type);
    static struct hostent* gethostbyname_locked(const char *addr);
    static struct hostent* hostent_deepcopy(struct hostent* hp);
    static void freeHostEnt(struct hostent* hp);

    static void doSitePeering(LocalSite* ls, RemoteSite* rs, bool isspooftest, bool waitforhello);

    virtual ~Site();
};
}

#endif

---