session.h

/* Copyright (c) 2005-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQNET_SESSION_H
#define EQNET_SESSION_H

#include <eq/net/dispatcher.h>  // base class
#include <eq/net/object.h>      // Object::VERSION_NONE enum

#include <eq/base/base.h>
#include <eq/base/idPool.h>
#include <eq/base/requestHandler.h>

namespace eq
{
namespace net
{
    class Session : public Dispatcher
    {
    public:
        EQ_EXPORT Session();

        EQ_EXPORT virtual ~Session();

        uint32_t getID() const { return _id; }

        NodePtr getLocalNode(){ return _localNode; }

        EQ_EXPORT CommandQueue* getCommandThreadQueue();

        NodePtr getServer(){ return _server; }



        EQ_EXPORT virtual bool dispatchCommand( Command& packet );

        EQ_EXPORT virtual CommandResult invokeCommand( Command& packet );


        EQ_EXPORT uint32_t genIDs( const uint32_t range );

        EQ_EXPORT void freeIDs( const uint32_t start, const uint32_t range );

        EQ_EXPORT void setIDMaster( const uint32_t id, const NodeID& master );

        EQ_EXPORT void unsetIDMaster( const uint32_t id );

        EQ_EXPORT const NodeID& getIDMaster( const uint32_t id );


        EQ_EXPORT bool registerObject( Object* object );

        EQ_EXPORT void deregisterObject( Object* object );

        EQ_EXPORT bool mapObject( Object* object, const uint32_t id, 
                        const uint32_t version = Object::VERSION_OLDEST );

        EQ_EXPORT uint32_t mapObjectNB( Object* object, const uint32_t id, 
                              const uint32_t version = Object::VERSION_OLDEST );
        EQ_EXPORT bool mapObjectSync( const uint32_t requestID );

        EQ_EXPORT void unmapObject( Object* object );

        EQ_EXPORT void attachObject( Object* object, const uint32_t id, 
                           const uint32_t instanceID );

        EQ_EXPORT void detachObject( Object* object );


        EQ_EXPORT virtual void notifyMapped( NodePtr node );

    protected:
        void send( NodePtr node, SessionPacket& packet )
            {
                packet.sessionID = _id;
                node->send( packet );
            }

        void send( SessionPacket& packet )
            { 
                packet.sessionID = _id;
                _server->send( packet );
            }

        template< typename T >
        void send( SessionPacket& packet, const std::vector<T>& data )
            { 
                packet.sessionID = _id;
                _server->send( packet, data );
            }


        void send( NodePtr node, SessionPacket& packet, 
                   const std::string& text )
            {
                packet.sessionID = _id;
                node->send( packet, text );
            }

        void send( NodePtr node, SessionPacket& packet, 
                   const void* data, const uint64_t size )
            {
                packet.sessionID = _id;
                node->send( packet, data, size );
            }

        base::RequestHandler _requestHandler;

    private:
        void _setLocalNode( NodePtr node );

        friend class Node;
        NodePtr _localNode;

        NodePtr _server;

        uint32_t _id;

        bool _isMaster;

        base::IDPool _idPool;

        uint32_t _instanceIDs;

        typedef stde::hash_map< uint32_t, NodeID > NodeIDHash;
        NodeIDHash _idMasters;
        base::Lock _idMasterMutex;
        
        ObjectVectorHash _objects;
        base::Lock       _objectsMutex;

        const NodeID& _pollIDMaster( const uint32_t id ) const;
        NodePtr _pollIDMasterNode( const uint32_t id ) const;

        void _registerThreadObject( Object* object, const uint32_t id );

        void _sendLocal( SessionPacket& packet )
            {
                packet.sessionID = _id;
                _localNode->send( packet );
            }

        CommandResult _invokeObjectCommand( Command& packet );
        void _attachObject( Object* object, const uint32_t id, 
                            const uint32_t instanceID );
        void _detachObject( Object* object );

        uint32_t _setIDMasterNB( const uint32_t id, const NodeID& master );
        void _setIDMasterSync( const uint32_t requestID );


        CommandResult _cmdAckRequest( Command& packet );
        CommandResult _cmdGenIDs( Command& packet );
        CommandResult _cmdGenIDsReply( Command& packet );
        CommandResult _cmdSetIDMaster( Command& packet );
        CommandResult _cmdGetIDMaster( Command& packet );
        CommandResult _cmdGetIDMasterReply( Command& packet );
        CommandResult _cmdAttachObject( Command& command );
        CommandResult _cmdDetachObject( Command& command );
        CommandResult _cmdMapObject( Command& command );
        CommandResult _cmdSubscribeObject( Command& command );
        CommandResult _cmdSubscribeObjectSuccess( Command& command );
        CommandResult _cmdSubscribeObjectReply( Command& command );
        CommandResult _cmdUnsubscribeObject( Command& command );

        CHECK_THREAD_DECLARE( _receiverThread );
        CHECK_THREAD_DECLARE( _commandThread );
    };

    std::ostream& operator << ( std::ostream& os, Session* session );
}
}
#endif // EQNET_SESSION_H