server/config.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_CONFIG_H
#define EQSERVER_CONFIG_H

#include "base.h"
#include "types.h"
#include "server.h"        // used in inline method
#include "visitorResult.h" // enum

#include <eq/net/session.h>

#include <iostream>
#include <vector>

namespace eq
{
namespace server
{
    class ConfigSerializer;
    class ConfigVisitor;
    class ConstConfigVisitor;
    struct CanvasPath;
    struct ChannelPath;
    struct LayoutPath;
    struct ObserverPath;
    struct SegmentPath;
    struct ViewPath;

    class Config : public net::Session
    {
    public:
        EQSERVER_EXPORT Config();
        virtual ~Config();

        Config( const Config& from );
        
        Server* getServer() { return _server; }
        
        Channel* getChannel( const ChannelPath& path );
        Canvas* getCanvas( const CanvasPath& path );
        Segment* getSegment( const SegmentPath& path );
        Layout* getLayout( const LayoutPath& path );
        Observer* getObserver( const ObserverPath& path );
        View* getView( const ViewPath& path );

        bool    isRunning() const { return ( _state == STATE_RUNNING ); }

        net::CommandQueue* getServerThreadQueue()
            { EQASSERT( _server ); return _server->getServerThreadQueue(); }
        
        void setName( const std::string& name ) { _name = name; }
        const std::string& getName() const      { return _name; }

        EQSERVER_EXPORT void addNode( Node* node );

        bool removeNode( Node* node );

        const NodeVector& getNodes() const { return _nodes; }

        void addObserver( Observer* observer );

        bool removeObserver( Observer* observer );

        const ObserverVector& getObservers() const { return _observers; }

        Observer* findObserver( const std::string& name );
        const Observer* findObserver( const std::string& name ) const;

        Observer* findObserver( const uint32_t id );

        EQSERVER_EXPORT void addLayout( Layout* layout );

        bool removeLayout( Layout* layout );

        const LayoutVector& getLayouts() const { return _layouts; }

        Layout* findLayout( const std::string& name );
        const Layout* findLayout( const std::string& name ) const;

        Layout* findLayout( const uint32_t id );

        View* findView( const std::string& name );
        const View* findView( const std::string& name ) const;

        EQSERVER_EXPORT void addCanvas( Canvas* canvas );

        bool removeCanvas( Canvas* canvas );

        const CanvasVector& getCanvases() const { return _canvases; }

        Canvas* findCanvas( const std::string& name );
        const Canvas* findCanvas( const std::string& name ) const;

        Segment* findSegment( const std::string& name );
        const Segment* findSegment( const std::string& name ) const;

        EQSERVER_EXPORT void addCompound( Compound* compound );

        bool removeCompound( Compound* compound );

        const CompoundVector& getCompounds() const { return _compounds; }

        EQSERVER_EXPORT Channel* findChannel( const std::string& name );
        const Channel* findChannel( const std::string& name ) const;

        Channel* findChannel( const Segment* segment, const View* view );

        VisitorResult accept( ConfigVisitor& visitor );
        VisitorResult accept( ConstConfigVisitor& visitor ) const;

        void setLatency( const uint32_t latency ) { _latency = latency; }

        uint32_t getLatency() const { return _latency; }

        uint32_t getFinishedFrame() const { return _finishedFrame; }
        void setApplicationName( const std::string& name )  { _appName = name; }

        void addApplicationNode( Node* node );

        Node* getApplicationNode() { return _appNode; }

        bool isApplicationNode( const Node* node ) const
            { return (_appNode == node); }

        void setApplicationNetNode( net::NodePtr node );

        void setRenderClient( const std::string& rc ){ _renderClient = rc; }

        void setWorkDir( const std::string& workDir ){ _workDir = workDir; }

        void notifyNodeFrameFinished( const uint32_t frameNumber );

        // Used by Server::releaseConfig() to make sure config is exited
        bool exit();

        void unmap();
        
        // Note: also update string array initialization in config.cpp
        enum FAttribute
        {
            FATTR_EYE_BASE,
            FATTR_VERSION,
            FATTR_FILL1,
            FATTR_FILL2,
            FATTR_ALL
        };
        
        void setFAttribute( const FAttribute attr, const float value )
            { _fAttributes[attr] = value; }
        float getFAttribute( const FAttribute attr ) const
            { return _fAttributes[attr]; }
        static const std::string&  getFAttributeString( const FAttribute attr )
            { return _fAttributeStrings[attr]; }
 
        const std::string& getErrorMessage() const { return _error; }

        uint32_t getDistributorID();

        uint32_t getInitID(){ return _initID; }

    protected:
        virtual void notifyMapped( net::NodePtr node );

    private:
        std::string _name;

        uint32_t _initID;
        
        float _fAttributes[FATTR_ALL];

        static std::string _fAttributeStrings[FATTR_ALL];

        Server* _server;
        friend class Server;

        NodeVector _nodes;

        ObserverVector _observers;

        LayoutVector _layouts;

        CanvasVector _canvases;

        CompoundVector _compounds;

        std::string            _error;

        std::string _appName;

        Node*       _appNode;

        net::NodePtr _appNetNode;

        std::string _renderClient;

        std::string _workDir;

        uint32_t _latency;

        uint32_t _currentFrame;

        uint32_t _finishedFrame;

        enum State
        {
            STATE_STOPPED = 0,  // next: INITIALIZING
            STATE_INITIALIZING, // next: RUNNING
            STATE_RUNNING,      // next: EXITING
            STATE_EXITING,      // next: STOPPED
        }
        _state;

        ConfigSerializer* _serializer;

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

        void _construct();

        bool _updateRunning();
        bool   _connectNodes();
        bool     _connectNode( Node* node );
        bool     _syncConnectNode( Node* node );
        void   _startNodes();
        uint32_t _createConfig( Node* node );
        void   _stopNodes();
        void   _syncClock();

        bool _init( const uint32_t initID );

        bool _startFrame( const uint32_t frameID );
        void _flushAllFrames();

        net::CommandResult _cmdInit( net::Command& command );
        net::CommandResult _cmdExit( net::Command& command );
        net::CommandResult _cmdStartFrame( net::Command& command );
        net::CommandResult _cmdFinishAllFrames( net::Command& command ); 
        net::CommandResult _cmdCreateReply( net::Command& command );
        net::CommandResult _cmdFreezeLoadBalancing( net::Command& command );
        net::CommandResult _cmdUnmapReply( net::Command& command );
    };

    std::ostream& operator << ( std::ostream& os, const Config* config );
}
}
#endif // EQSERVER_CONFIG_H