osg::ClusterServer Class Reference
[Cluster]

Cluster rendering server. More...

#include <OSGClusterServer.h>

List of all members.

Public Member Functions
Constructors
	ClusterServer (WindowPtr window, const std::string &serviceName, const std::string &connectionType="StreamSock", const std::string &address="", UInt32 servicePort=8437, const std::string &serviceGroup="")
Destructor
virtual	~ClusterServer (void)
server actions
void	start (void)
void	stop (void)
void	render (RenderActionBase *action)
void	doSync (bool applyToChangelist)
void	doRender (RenderActionBase *action)
void	doSwap (void)
window access
WindowPtr	getClusterWindow (void)
WindowPtr	getServerWindow (void)
RemoteAspect *	getRemoteAspect (void) const
set
void	setInterface (const std::string &interf)
Protected Member Functions
ClusterWindow changed function
bool	windowChanged (FieldContainerPtr &fcp, RemoteAspect *)
Protected Attributes
Member
WindowPtr	_window
PointConnection *	_connection
std::string	_requestAddress
std::string	_boundAddress
ClusterWindowPtr	_clusterWindow
RemoteAspect *	_aspect
std::string	_serviceName
std::string	_connectionType
UInt32	_servicePort
std::string	_serviceGroup
UInt32	_serverId
std::string	_interface
Private Member Functions
	ClusterServer (const ClusterServer &source)
	prohibit default function (move to 'public' if needed)
void	operator= (const ClusterServer &source)
	prohibit default function (move to 'public' if needed)
helper function
void	acceptClient ()

---

Detailed Description

A ClusterServer is responsible for syncronizing all client changes. Each cluster renderer can offer it's service by a symbolic name. So it is possible to have a server called "left" or "right". The server uses a local Qt or GLUT window for rendering.

 // create a server
 GLUTWindowPtr window=GLUTWindowcreate();
 server = new ClusterServer(window,"server1","Multicast");
 // wait for clients to connect
 server->init();
 ...
 // render
 server->render(ract);
 

Definition at line 59 of file OSGClusterServer.h.

---

Constructor & Destructor Documentation

ClusterServer::ClusterServer	(	WindowPtr	window,
		const std::string &	serviceName,
		const std::string &	connectionType = "StreamSock",
		const std::string &	address = "",
		UInt32	servicePort = 8437,
		const std::string &	serviceGroup = ""
	)

Constructor

Parameters:

	window	rendering window. e.g. a Qt or GLUT window
	serviceName	wait for connections that request this name
	connectionType	network type. e.g. "Multicast"
	address	address to wait for connections
	servicePort	port to wait for connections

Definition at line 88 of file OSGClusterServer.cpp.

References _requestAddress, _serviceName, and osg::osgGetHostname().

                                                              :
    _window(window),
    _connection(NULL),
    _requestAddress(address),
    _boundAddress(""),
    _clusterWindow(),
    _aspect(NULL),
    _serviceName(serviceName),
    _connectionType(connectionType),
    _servicePort(servicePort),
    _serviceGroup(serviceGroup),
    _serverId(0),
    _interface("")
{
    char localhost[256];

    // default is hostname
    if(_serviceName.empty())
    {
        osgGetHostname(localhost,255);
        _serviceName = localhost;
    }
    // if service contains ":" than treat as address
    if(_requestAddress.empty())
    {
        if(strstr(_serviceName.c_str(),":"))
            _requestAddress = _serviceName;
    }
}

ClusterServer::~ClusterServer

(

void

)

[virtual]

Destructor. Disconnect from all connected rendering servers

Definition at line 128 of file OSGClusterServer.cpp.

References _aspect, and _connection.

{
    try
    {
        if(_connection)
            delete _connection;
        if(_aspect)
            delete _aspect;
    }
    catch(...)
    {
    }
}

osg::ClusterServer::ClusterServer

(

const ClusterServer &

source

)

[private]

---

Member Function Documentation

void ClusterServer::start

(

void

)

start server

Start cluster server and wait for a client to connect. This method will return after a client connection or an error situation.

Definition at line 151 of file OSGClusterServer.cpp.

References _aspect, _connection, acceptClient(), osg::BinaryDataHandler::flush(), osg::ClusterWindowBase::getClassType(), osg::BinaryDataHandler::getValue(), osg::osgTypedMethodFunctor2ObjPtrCPtrRef(), osg::BinaryDataHandler::putValue(), osg::RemoteAspect::registerChanged(), osg::Connection::selectChannel(), osg::BinaryDataHandler::setNetworkOrder(), and windowChanged().

{
    OSG::FieldContainerType *fct;

    // reset conneciton
    if(_connection)
        delete _connection;
    _connection = NULL;

    // create aspect
    _aspect = new RemoteAspect();

    // register interrest for all changed cluster windows
    for(UInt32 i = 0; i < OSG::TypeFactory::the()->getNumTypes(); ++i)
    {
        fct=OSG::FieldContainerFactory::the()->findType(i);
        if(fct && fct->isDerivedFrom(ClusterWindow::getClassType()))
        {
            _aspect->registerChanged(
                *fct,
                osgTypedMethodFunctor2ObjPtrCPtrRef
                <
                bool,
                ClusterServer,
                FieldContainerPtr,
                RemoteAspect     *
                >(this,&ClusterServer::windowChanged));
        }
    }
    // accept incomming connections
    try {
        UInt8                    forceNetworkOrder;
#if BYTE_ORDER == LITTLE_ENDIAN
        UInt8                    littleEndian = true;
#else
        UInt8                    littleEndian = false;
#endif

        // accept
        acceptClient();
        // determine network order
        _connection->putValue(littleEndian);
        _connection->flush();
        _connection->selectChannel();
        _connection->getValue(forceNetworkOrder);
        _connection->setNetworkOrder((forceNetworkOrder != 0));
    } 
    catch(...)
    {
        throw;
    }
}

void ClusterServer::stop

(

void

)

Stop cluster server, remove current remote aspect and all its field containers.

Definition at line 207 of file OSGClusterServer.cpp.

References _aspect, _clusterWindow, _connection, and osg::NullFC.

{
    // get aspect ownership
    if(_clusterWindow != NullFC)
    {
        _aspect=_clusterWindow->getNetwork()->getAspect();
        _clusterWindow->getNetwork()->setAspect(NULL);
    }
    // destroy connection
    try
    {
        if(_connection)
            delete _connection;
        _connection = NULL;
    }
    catch(...)
    {
    }
    // destroy aspect
    if(_aspect)
        delete _aspect;
    // reset 
    _connection=NULL;
    _aspect=NULL;
    _clusterWindow=NullFC;
}

void ClusterServer::render

(

RenderActionBase *

action

)

sync with client and render scenegraph

Definition at line 236 of file OSGClusterServer.cpp.

References doRender(), doSwap(), and doSync().

{
    doSync(false);
    doRender(action);
    doSwap();
}

void ClusterServer::doSync

(

bool

applyToChangelist

)

Synchronize all field containers with the client and call serverInit, serverRender and serverSwap for the cluster window. The cluster server uses the first synced ClusterWindow that contains the name of this server. serverInit is called after the first ClusterWindow sync.

todo: Sync RenderAciton contents

Definition at line 252 of file OSGClusterServer.cpp.

References _aspect, _clusterWindow, _connection, _serverId, _serviceName, _window, osg::NullFC, osg::RemoteAspect::receiveSync(), osg::SHLChunk::setClusterId(), and SINFO.

Referenced by render().

{
    // do we have a cluster window?
    if(_clusterWindow==NullFC)
    {
        do
        {
            // recive 
            _aspect->receiveSync(*_connection,applyToChangelist);
        }
        while(_clusterWindow==NullFC);
        // get server id
        for(_serverId=0;
            _clusterWindow->getServers()[_serverId] != _serviceName &&
                _serverId<_clusterWindow->getServers().size();
            _serverId++);
        // server connected and cluster window found
        SINFO << "Start server " << _serviceName 
              << " with id "     << _serverId 
              << std::endl;
        // now the window is responsible for connection and aspect
        _clusterWindow->getNetwork()->setMainConnection(_connection);
        _clusterWindow->getNetwork()->setAspect        (_aspect);
        _connection=NULL;
        _aspect=NULL;
        SHLChunk::setClusterId(Int32(_serverId));
        _clusterWindow->serverInit(_window,_serverId);
    }

    RemoteAspect *aspect=_clusterWindow->getNetwork()->getAspect();
    Connection   *connection=_clusterWindow->getNetwork()->getMainConnection();

    // sync with render clinet
    aspect->receiveSync(*connection,applyToChangelist);

    // sync with render client
    if(_clusterWindow->getInterleave())
    {
        // if the reminder of the division of interleave and 
        // framecount is equal to the servers id, the right
        // sync point for the current render frame is reached
        while( (_clusterWindow->getFrameCount()%
                _clusterWindow->getInterleave())
               !=
               (_serverId%_clusterWindow->getInterleave()) ) 
        {
            aspect->receiveSync(*connection,applyToChangelist);
        }
    }
}

void ClusterServer::doRender

(

RenderActionBase *

action

)

render server window

Definition at line 305 of file OSGClusterServer.cpp.

References _clusterWindow, _serverId, and _window.

Referenced by render().

{
    _clusterWindow->serverRender( _window,_serverId,action );
}

void ClusterServer::doSwap

(

void

)

swap server window

Definition at line 312 of file OSGClusterServer.cpp.

References _clusterWindow, _serverId, and _window.

Referenced by render().

{
    _clusterWindow->serverSwap  ( _window,_serverId );
}

WindowPtr ClusterServer::getClusterWindow

(

void

)

return the cluster window received from the client

Definition at line 319 of file OSGClusterServer.cpp.

References _clusterWindow.

{
    return _clusterWindow;
}

WindowPtr ClusterServer::getServerWindow

(

void

)

return the window used for rendering

Definition at line 326 of file OSGClusterServer.cpp.

References _window.

{
    return _window;
}

RemoteAspect * osg::ClusterServer::getRemoteAspect

(

void

)

const [inline]

return the cluster window received from the client

Definition at line 46 of file OSGClusterServer.inl.

References _aspect.

{
    return _aspect;
}

void osg::ClusterServer::setInterface

(

const std::string &

interf

)

[inline]

Definition at line 52 of file OSGClusterServer.inl.

References _interface.

{
    _interface = interf;
}

bool ClusterServer::windowChanged	(	FieldContainerPtr &	fcp,
		RemoteAspect *
	)			[protected]

clusterWindow changed callback. This is a callback functor. It is called for each change of a ClusterWindow.

Definition at line 334 of file OSGClusterServer.cpp.

References _clusterWindow, _serviceName, osg::AttachmentContainerPtr::dcast(), osg::NullFC, and SWARNING.

Referenced by start().

{
    if(_clusterWindow != NullFC)
        return true;

    ClusterWindowPtr window=ClusterWindowPtr::dcast(fcp);

    if(window->getServers().size())
    {
        if(window->getServers().find(_serviceName) == 
           window->getServers().end())
        {
            SWARNING << "wrong window" << std::endl;
        }
        else
        {
            _clusterWindow=window;
        }
    }
    return true;
}

void ClusterServer::acceptClient

(

)

[private]

Wait for incomming clients. A client can send a request for a special connection type or it can try to connect it it knows the servers address.

Definition at line 361 of file OSGClusterServer.cpp.

References _boundAddress, _connection, _connectionType, _interface, _requestAddress, _serviceGroup, _serviceName, _servicePort, osg::PointConnection::acceptGroup(), osg::SocketAddress::ANY, osg::Socket::bind(), osg::Connection::bind(), osg::BinaryMessage::clear(), osg::DgramSocket::close(), osg::ConnectionType::getName(), osg::BinaryMessage::getString(), osg::PointConnection::getType(), osg::SocketAddress::isMulticast(), osg::DgramSocket::join(), osg::DgramSocket::open(), osg::BinaryMessage::putString(), osg::DgramSocket::recvFrom(), osg::DgramSocket::sendTo(), osg::Connection::setInterface(), osg::Socket::setReusePort(), SINFO, SWARNING, osg::ConnectionFactory::the(), osg::Socket::waitReadable(), and osg::Exception::what().

Referenced by start().

{
    BinaryMessage  msg;
    DgramSocket    serviceSock;
    SocketAddress  addr;
    std::string    service;
    std::string    connectionType;
    UInt32         readable;
    bool           connected=false;
    std::string    address;
    bool           bound = false;

    SINFO << "Waiting for request of "
          << _serviceName
          << std::endl;

    try
    {
        if(!_requestAddress.empty())
        {            
            // create connection
            _connection = ConnectionFactory::the().
                createPoint(_connectionType);
            if(_connection)
            {
                // set interface
                _connection->setInterface(_interface);
                // bind connection
                try 
                {
                    // bind to requested address
                    _boundAddress = _connection->bind(_requestAddress);
                    bound = true;
                }
                catch(...)
                {
                    SINFO << "Unable to bind, use name as symbolic service name" 
                          << std::endl;
                }
            }
        }
        serviceSock.open();
        serviceSock.setReusePort(true);
        // join to multicast group
        if(!_serviceGroup.empty())
        {
            SocketAddress groupAddress = SocketAddress(
                _serviceGroup.c_str(),
                _servicePort);
            if(groupAddress.isMulticast())
            {
                SINFO << "wait for request on multicast:" << 
                    _serviceGroup << std::endl;
                serviceSock.bind(SocketAddress(SocketAddress::ANY,
                                               _servicePort));
                serviceSock.join(SocketAddress(groupAddress));
            }
            else
            {
                SINFO << "wait for request by broadcast:" << 
                    _serviceGroup << std::endl;
                serviceSock.bind(SocketAddress(groupAddress));
            }
        }
        else
        {
            SINFO << "wait for request by broadcast" << std::endl;
            serviceSock.bind(SocketAddress(SocketAddress::ANY,
                                           _servicePort));
        }

        while(!connected)
        {
            try
            {
                if(_connection) 
                    readable = serviceSock.waitReadable(.01);
                else
                    readable = true;
                if(readable)
                {
                    serviceSock.recvFrom(msg,addr);

                    service        = msg.getString();
                    connectionType = msg.getString();

                    SINFO << "Request for " 
                          << service << " " 
                          << connectionType 
                          << std::endl;
                    
                    if(service == _serviceName)
                    {
                        // remove old connection if typename missmaches
                        if(_connection && 
                           _connection->getType()->getName() != connectionType)
                        {
                            delete _connection;
                            _connection = NULL;
                        }
                        // try to create connection
                        if(!_connection)
                        {
                            // create connection
                            _connection = ConnectionFactory::the().
                                createPoint(connectionType);
                            if(_connection)
                            {
                                // set interface
                                _connection->setInterface(_interface);
                                // bind connection
                                _boundAddress = _connection->bind(_requestAddress);
                                bound = true;
                            } 
                            else
                            {
                                SINFO << "Unknown connection type '" 
                                      << connectionType << "'" << std::endl;
                            }
                        }
                        if(_connection)
                        {
                            msg.clear    (             );
                            msg.putString(_serviceName );
                            msg.putString(_boundAddress);
                            serviceSock.sendTo(msg, addr);
                            SINFO << "Response " 
                                  << connectionType << ":"
                                  << _boundAddress 
                                  << std::endl;
                        }
                    }
                }
            }
            catch(SocketConnReset &e)
            {
                // ignore if there is a connection. This can happen, if
                // a client has send a request. The server has send an
                // answer meanwile the client has send a second request
                // the client gets the answer to the first request and
                // the server tries to send a second answer. The second
                // answer can not be delivered because the client has
                // closed its service port. This is a win-socket problem.

                SWARNING << e.what() << std::endl;

                // if there is no connection, then its a real problem
                if(!_connection)
                    throw;
            }
            catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
            {
                SWARNING << e.what() << std::endl;
            }
            try 
            {
                // try to accept
                if(bound && _connection && _connection->acceptGroup(0.2) >= 0)
                {
                    connected = true;
                    SINFO << "Connection accepted " << _boundAddress << std::endl;
                }
            }
            catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
            {
                SWARNING << e.what() << std::endl;
            }
        }
        serviceSock.close();
    }
    catch(OSG_STDEXCEPTION_NAMESPACE::exception &e)
    {
        throw;
    }
}

void osg::ClusterServer::operator=

(

const ClusterServer &

source

)

[private]

---

Member Data Documentation

WindowPtr osg::ClusterServer::_window [protected]

Definition at line 127 of file OSGClusterServer.h.

Referenced by doRender(), doSwap(), doSync(), and getServerWindow().

PointConnection* osg::ClusterServer::_connection [protected]

Definition at line 128 of file OSGClusterServer.h.

Referenced by acceptClient(), doSync(), start(), stop(), and ~ClusterServer().

std::string osg::ClusterServer::_requestAddress [protected]

Definition at line 129 of file OSGClusterServer.h.

Referenced by acceptClient(), and ClusterServer().

std::string osg::ClusterServer::_boundAddress [protected]

Definition at line 130 of file OSGClusterServer.h.

Referenced by acceptClient().

ClusterWindowPtr osg::ClusterServer::_clusterWindow [protected]

Definition at line 131 of file OSGClusterServer.h.

Referenced by doRender(), doSwap(), doSync(), getClusterWindow(), stop(), and windowChanged().

RemoteAspect* osg::ClusterServer::_aspect [protected]

Definition at line 132 of file OSGClusterServer.h.

Referenced by doSync(), getRemoteAspect(), start(), stop(), and ~ClusterServer().

std::string osg::ClusterServer::_serviceName [protected]

Definition at line 133 of file OSGClusterServer.h.

Referenced by acceptClient(), ClusterServer(), doSync(), and windowChanged().

std::string osg::ClusterServer::_connectionType [protected]

Definition at line 134 of file OSGClusterServer.h.

Referenced by acceptClient().

UInt32 osg::ClusterServer::_servicePort [protected]

Definition at line 135 of file OSGClusterServer.h.

Referenced by acceptClient().

std::string osg::ClusterServer::_serviceGroup [protected]

Definition at line 136 of file OSGClusterServer.h.

Referenced by acceptClient().

UInt32 osg::ClusterServer::_serverId [protected]

Definition at line 137 of file OSGClusterServer.h.

Referenced by doRender(), doSwap(), and doSync().

std::string osg::ClusterServer::_interface [protected]

Definition at line 138 of file OSGClusterServer.h.

Referenced by acceptClient(), and setInterface().

---

The documentation for this class was generated from the following files:

• OSGClusterServer.h
• OSGClusterServer.cpp
• OSGClusterServer.inl