ColCOWS_NodeServant.hh

//===========================================================================//
//    
//    Description: Implementation of ColCOWS Node interface 
//    Filename: colcows/ColCOWS_NodeServant.hh
//    Authors: Michael Dussere and Aurélien Esnard
//    
//===========================================================================//
//    
//    Copyright (C) 2003 INRIA and CNRS
//    
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//    
//    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//    
//===========================================================================//


#ifndef __COLCOWS_NODE_IMPL_HH__
#define __COLCOWS_NODE_IMPL_HH__

//---------------------------------------------------------------------------//
#include "ColCOWS_Include.hh"
#include "ColCOWS_Debug.hh" 
#include "ColCOWS_Corba.hh"
//---------------------------------------------------------------------------//

__COLCOWS_BEGIN__

//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlWorkspaceDesc& wsdesc);
//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlWorkspaceDescSeq& wsdesc_seq);

//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlNodeDesc& wsnode);
//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlNodeDescSeq& wsnode_seq);

//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlObjectDesc& ref);
//! standard output stream operator
std::ostream& operator <<(std::ostream& stream, const IdlObjectDescSeq& ref_seq);

//===========================================================================//
//                       collective node class                               //
//===========================================================================//

class Node;


//! ColCOWS node interface implementation
/** 
 * The NodeServant is the implementation of the NodeInterface defined in the IDL.
 * This class is in charge of the operations between the nodes of a workspace as well
 * as the operations between workspaces.
 */
class NodeServant : 
  public virtual POA_ColCOWS::NodeInterface,
  public virtual PortableServer::RefCountServantBase
{

  //=========== friend classes ===========//
  friend class Node;

  //================================================//
  //=========== class standard interface ===========//
public:
  
  //! constructor
  NodeServant();
  
  //! destructor
  virtual ~NodeServant();

  static NodeServant * New(const char* ws_id, 
                           const char* ws_kind, 
                           const char* node_kind, 
                           unsigned long num_node, 
                           unsigned long max_descendant, 
                           unsigned long nb_nodes,
                           unsigned long num_father,
                           CORBA::ORB_ptr orbp  ) ;

 //=========================================//
  //=========== public  interface ===========//
public:

  //! print self
  virtual void printself(std::ostream & stream) const;  

  //! standard output stream operator
  friend std::ostream& operator <<(std::ostream& stream, const NodeServant& _this);

  //! lock children mutex
  inline void lockChildrenMutex() { pthread_mutex_lock(&_children_mut); }

  //! unlock children mutex
  inline void unlockChildrenMutex() { pthread_mutex_unlock(&_children_mut); }

  //! lock activation mutex
  inline void lockActivationMutex() { pthread_mutex_lock(&_activation_mut); }

  //! unlock activation mutex
  inline void unlockActivationMutex() { pthread_mutex_unlock(&_activation_mut); }

protected:

  //! activate this node
  void activate( ) ;

  //! deactivate this node
  void deactivate( ) ;

  //! connect a remote workspace identified with an ID and a Kind on another NameService
  unsigned long connect( const std::string & ws_id, const std::string & ws_kind, const std::string & nameservice_str) ;

  //! connect a remote workspace
  void disconnect( unsigned long num_connection ) ;

  //! connect a remote workspace
  void disconnectAll( ) ;

  //! register this node to his father
  bool registerToFather( unsigned long max_retry = 0 ) ;

private:

  //! get the storage index of the connection
  long indexConnection( CORBA::ULong num_connection );  

  //==============================================//
  //=========== public corba interface ===========//
public:

  //! set the workspace description [public]
  virtual void setWorkspace(const IdlWorkspaceDesc& ws_desc);

  //! set child node description 
  virtual void setChildNode(const IdlNodeDesc& node_desc) throw (CorbaException) ;

  //=======================================//

  //! test if the collective node is activated
  virtual CORBA::Boolean isActivated() throw (CorbaException) ;

  //! test if the workspace is ready to receive connections [public]  
  virtual CORBA::Boolean isReady() throw (CorbaException) ;

  //! test if the connection exists
  virtual CORBA::Boolean isConnected( CORBA::ULong num_connection ) throw (CorbaException) ;

  //! test if the collective node id is connected
  virtual CORBA::ULong getNumConnection(const char* ws_id, const char * ws_kind ) throw (CorbaException) ;

  //! get a unige connection number
  virtual void getCommonNumConnection( CORBA::ULong & num_connection_proposal )throw (CorbaException)  ;

  //=======================================//
    
  //! get a node description 
  virtual void getNode(CORBA::ULong num_node, IdlNodeDesc_out node_desc) throw (CorbaException) ;

  //! get the workspace description [public]
  virtual void getWorkspace(IdlWorkspaceDesc_out ws_desc) throw (CorbaException) ;

  //! get the remote workspace description [public]
  virtual void getRemoteWorkspace(CORBA::ULong num_connection, IdlWorkspaceDesc_out ws_desc) throw (CorbaException) ;
    
  //! set the remote workspace description [public]
  virtual void setRemoteWorkspace(CORBA::ULong num_connection, 
                                  const IdlWorkspaceDesc& ws_desc, 
                                  CORBA::Boolean connection_initiator);

   //! remove the remote workspace description [public]
   virtual void releaseRemoteWorkspace( CORBA::ULong num_connection );

  //=======================================//
  //=========== internal fields ===========//
protected:

  //! Description of this Workspace Node
  IdlNodeDesc_var        _my_node;
  //! Description of the father Workspace Node
  IdlNodeDesc_var        _father_node;
  //! Descriptions of the children Workspace Nodes
  //! \bug suppress _children_nodes and use directly _my_node->children_seq
  IdlNodeDescSeq_var     _children_nodes;

  //! Description of the local Workspace 
  IdlWorkspaceDesc_var     _local_workspace;
  //! Description of the connected Workspaces
  IdlWorkspaceDescSeq_var  _remote_workspaces;


protected:

  //! Pointer on the ORB
  CORBA::ORB_ptr _orbp;

  // root context of the Naming Service
  CosNaming::NamingContext_var _naming_ctxt;

  //! POA
  PortableServer::POA_var _root_poa;

  //! POA
  PortableServer::POA_var _colcows_poa;

  //! POA manager
  PortableServer::POAManager_var  _colcows_pman;
  
  //! ready to receive connections
  bool _ready;

  //! need auto-activation
  bool _auto_activation;

  //! is registred to father
  bool _registred_to_father;

  //! next number of connection
  unsigned long _current_num_connection;

  //! access to children desc mutex
  pthread_mutex_t _children_mut;

  //! activation mutex
  pthread_mutex_t _activation_mut;

  //! activation condition variable
  pthread_cond_t _activation_cond;

  //! associated Node
  Node * _colcows_node;
};

__COLCOWS_END__

#endif // __COLCOWS_NODE_IMPL_HH__

// EOF

---