server/node.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 EQSERVER_NODE_H
#define EQSERVER_NODE_H

#include "config.h"                // used in inline method
#include "connectionDescription.h" // used in inline method

#include <eq/client/node.h> // enum eq::Node::IAttribute

#include <eq/net/barrier.h>
#include <eq/net/bufferConnection.h>
#include <eq/net/node.h>

#include <vector>

namespace eq
{
namespace server
{
    class ConstNodeVisitor;
    class NodeVisitor;
    struct ChannelPath;
    struct NodePath;

    class Node : public net::Object
    {
    public:
        enum State
        {
            STATE_STOPPED = 0,  // next: INITIALIZING
            STATE_INITIALIZING, // next: INIT_FAILED or INIT_SUCCESS
            STATE_INIT_SUCCESS, // next: RUNNING
            STATE_INIT_FAILED,  // next: EXITING
            STATE_RUNNING,      // next: EXITING
            STATE_EXITING,      // next: EXIT_FAILED or EXIT_SUCCESS
            STATE_EXIT_SUCCESS, // next: STOPPED
            STATE_EXIT_FAILED,  // next: STOPPED
        };

        EQSERVER_EXPORT Node();

        Node( const Node& from, Config* config );

        Config* getConfig() const { return _config; }
        Server* getServer() const
            { return _config ? _config->getServer() : 0; }

        net::NodePtr getNode() const { return _node; }
        void setNode( net::NodePtr node ) { _node = node; }
        bool isApplicationNode() const
            { return (this == _config->getApplicationNode( )); }

        NodePath getPath() const;

        Channel* getChannel( const ChannelPath& path );

        State getState()    const { return _state.get(); }

        net::CommandQueue* getServerThreadQueue()
            { return _config->getServerThreadQueue(); }
        net::CommandQueue* getCommandThreadQueue()
            { return _config->getCommandThreadQueue(); }

        uint32_t getFinishedFrame() const { return _finishedFrame; }

        EQSERVER_EXPORT void addPipe( Pipe* pipe );

        bool removePipe( Pipe* pipe );

        const PipeVector& getPipes() const { return _pipes; }

        VisitorResult accept( NodeVisitor& visitor );
        VisitorResult accept( ConstNodeVisitor& visitor ) const;

        void activate();

        void deactivate();

        bool isActive() const { return ( _active != 0 ); }

        void addTasks( const uint32_t tasks ) { _tasks |= tasks; }

        void setName( const std::string& name ) { _name = name; }
        const std::string& getName() const      { return _name; }

        void setLastDrawPipe( const Pipe* pipe )
            { _lastDrawPipe = pipe; }
        const Pipe* getLastDrawPipe() const { return _lastDrawPipe;}

        void updateRunning( const uint32_t initID, const uint32_t frameNumber );

        bool syncRunning();

        void update( const uint32_t frameID, const uint32_t frameNumber );

        void flushFrames( const uint32_t frameNumber );

        void finishFrame( const uint32_t frame );


        void setIAttribute( const eq::Node::IAttribute attr, 
                            const int32_t value )
            { _iAttributes[attr] = value; }
        int32_t  getIAttribute( const eq::Node::IAttribute attr ) const
            { return _iAttributes[attr]; }

        net::Barrier* getBarrier();

        void releaseBarrier( net::Barrier* barrier );

        void send( net::SessionPacket& packet ) 
            { 
                packet.sessionID = _config->getID(); 
                _bufferedTasks.send( packet );
            }
        void send( net::SessionPacket& packet, const std::string& string ) 
            {
                packet.sessionID = _config->getID(); 
                _bufferedTasks.send( packet, string );
            }
        template< typename T >
        void send( net::SessionPacket &packet, const std::vector<T>& data )
            {
                packet.sessionID = _config->getID(); 
                _bufferedTasks.send( packet, data );
            }

        void flushSendBuffer();

        void addConnectionDescription( ConnectionDescriptionPtr desc )
            { _connectionDescriptions.push_back( desc ); }
        
        void removeConnectionDescription( const uint32_t index );

        const ConnectionDescriptionVector& getConnectionDescriptions()
            const { return _connectionDescriptions; }

        const std::string& getErrorMessage() const { return _error; }

    protected:
        virtual ~Node();

        base::RequestHandler _requestHandler;

        virtual void attachToSession( const uint32_t id, 
                                      const uint32_t instanceID, 
                                      net::Session* session );
    private:
        std::string _name;

        int32_t _iAttributes[eq::Node::IATTR_ALL];

        Config* _config;
        friend class Config;

        PipeVector _pipes;

        std::string _error;

        uint32_t _active;

        net::NodePtr _node;

        ConnectionDescriptionVector _connectionDescriptions;

        std::map< uint32_t, uint32_t > _frameIDs;

        uint32_t _flushedFrame;

        uint32_t _finishedFrame;

        uint32_t _tasks;

        base::Monitor< State > _state;
            
        std::vector<net::Barrier*> _barriers;

        net::BufferConnection _bufferedTasks;

        const Pipe* _lastDrawPipe;

        union // placeholder for binary-compatible changes
        {
            char dummy[64];
        };

        void _construct();

        void _configInit( const uint32_t initID, const uint32_t frameNumber );
        bool _syncConfigInit();
        void _configExit();
        bool _syncConfigExit();

        uint32_t _getFinishLatency() const;
        void _finish( const uint32_t currentFrame );

        void _flushBarriers();

        void _send( net::ObjectPacket& packet ) 
            { packet.objectID = getID(); send( packet ); }
        void _send( net::ObjectPacket& packet, const std::string& string ) 
            { packet.objectID = getID(); send( packet, string ); }

        void _sendFrameFinish( const uint32_t frameNumber );

        virtual void getInstanceData( net::DataOStream& os ) { EQDONTCALL }
        virtual void applyInstanceData( net::DataIStream& is ) { EQDONTCALL }

        /* Command handler functions. */
        net::CommandResult _cmdConfigInitReply( net::Command& command );
        net::CommandResult _cmdConfigExitReply( net::Command& command );
        net::CommandResult _cmdFrameFinishReply( net::Command& command );
    };

    std::ostream& operator << ( std::ostream& os, const Node* node );
}
}
#endif // EQSERVER_NODE_H