[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/localvipsite.hh

Go to the documentation of this file.

#ifndef _LOCALVIPSITE_HH_
#define _LOCALVIPSITE_HH_

#include <stdexcept>
#include <set>

namespace VOS {
    class LocalVipSiteExtension;
}

#include <vos/vip/socketmultiplexer.hh>
#include <vos/vos/siteextension.hh>
#include <vos/vos/remotevipsite.hh>
#include <vos/vos/iterator.hh>
#include <vos/vos/sitepeering.hh>

#define VOS_DEFAULT_PORT 4231

namespace VOS {
    /** @class RVSEIterator localvipsite.hh vos/vos/localvipsite.hh
        @ingroup libvos

        Iterator subclass used to iterate over pointers to
        RemoteVipSiteExtension objects.
    */
    class VOS_API RVSEIterator : public VUtil::Iterator<RemoteVipSiteExtension*>
    {
    public:
        RVSEIterator(const RVSEIterator& i) : VUtil::Iterator<RemoteVipSiteExtension*>(i) { }
        RVSEIterator(const std::set<RemoteVipSiteExtension*>& rsses) {
            items->resize(rsses.size());
            int n = 0;
            for(std::set<RemoteVipSiteExtension*>::const_iterator i = rsses.begin();
                i != rsses.end();
                i++)
            {
                (*items)[n] = *i;
                n++;
            }
        }

        RemoteVipSiteExtension* operator*() {
            if(pos < items->size()) return (*items)[pos];
            else return 0;
        }
    };


    /** @class LocalVipSiteExtension localvipsite.hh vos/vos/localvipsite.hh
        @ingroup libvos

        This class sets up the actual vip that the VOS site will
        listen on and manages a list of the remote sites we are
        connected to.
    */
    class VOS_API LocalVipSiteExtension : public LocalSiteExtension, public VIP::NewConnectionCallback
    {
    private:
        unsigned short int listenport;

        VUtil::read_write_mutex remoteSites_mutex;
        std::set<RemoteVipSiteExtension*> remoteSites;

        VUtil::vRef<VIP::SocketMultiplexer> sktmpx;

        void init(const std::string& defaultHostname, unsigned short int port);
    public:
        /** When creating an outgoing connection, the remote site will
            be peered with this local site.
         */
        static LocalVipSiteExtension* defaultLocalVipSite;

        /** Default constructor.  This will attempt to autodetect your
            hostname.  It will listen on the first available port it
            finds, starting from 4231 and working its way upward.
            This will use the VOS_HOSTNAME environment variable (in
            the form hostname:port) to define the hostname and port.
         */
        LocalVipSiteExtension();

        /** Use the supplied hostname and port.
            @param defaultHostname the canonical hostname for this site
            @param port the TCP port for the site to listen on
            @throw PortBindingError if the port is not available.
         */
        LocalVipSiteExtension(const std::string& defaultHostname, unsigned short int port);

        /** Use the supplied hostname.  Will use the first available
            port, starting from 4231 and working upward.
            @param defaultHostname the canonical hostname for this site
         */
        LocalVipSiteExtension(const std::string& defaultHostname);

        /** Use the supplied port.  Will autodetect hostname, or take
            the canonical hostname from VOS_HOSTNAME (ignoring the
            port!)

            @param port the TCP port to listen on
            @throw PortBindingError if the port is not available.
         */
        LocalVipSiteExtension(unsigned short int port);

        /** Destructor */
        virtual ~LocalVipSiteExtension();

        /** Add a remote site that we're peered with.
            @param rs the RemoteVipSiteExtension object
            representing the connection to the remote site
         */
        virtual void addRemoteSite(VOS::RemoteSiteExtension* rs);

        /** Remove a remote site that we're peered with.
            @param rs the RemoteVipSiteExtension object
            representing the connection to the remote site
         */
        virtual void removeRemoteSite(VOS::RemoteSiteExtension* rs);

        /** @return the remote sites we are peered with */
        RVSEIterator getRemoteSites();

        /** Called by the Site object indicating that this extension
            has been attached to that site.
        */
        virtual void siteExtensionAttachedTo(Site* st);

        VUtil::vRef<VIP::SocketMultiplexer> getSocketMultiplexer()
            { return sktmpx; }

        virtual void notifyNewConnection(VIP::Connection* m, bool inbound);
    };

    class VOS_API VipSitePeeringThread : public SitePeeringThread
    {
    private:
        LocalVipSiteExtension* lvse;
        RemoteVipSiteExtension* rvse;
        std::string host;
        int port;
        VUtil::vRef<VIP::Connection> conn;

    public:

        /** Construct object and initialize it so that
            SitePeeringThread::operator()() will use the supplied
            existing vip.

            @param l the local vip site that is the local peer
            @param sock the vip file descriptor
            @param sd the vip address of the remote site, used to
            do a reverse-lookup and figure out the hostname
            @param isClient are we a client?  default false
         */
        VipSitePeeringThread(LocalVipSiteExtension* l, VIP::Connection* c,
                             bool isClient = false);

        /** Construct object and initialize it so that
            SitePeeringThread::operator()() will attempt an outgoing
            connection on the supplied host and port.

            @param l the local vip site that is the local peer
            @param host the host to connect to
            @param port the port to connect on
            @param isClient are we a client?  default true
         */
        VipSitePeeringThread(LocalVipSiteExtension* l,
                             const std::string& host,
                             int port, bool isClient = true);

        /** Copy constructor, required because boost::thread makes a
            copy of the thread object it runs.
         */
        VipSitePeeringThread(const VipSitePeeringThread& spt);

        virtual void init();

        virtual void done();
    };

}

#endif