ColCOWS_Node.cc

//===========================================================================//
//    
//    Description: ColCOWS Nodes
//    Filename: colcows/ColCOWS_Node.cc
//    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
//    
//===========================================================================//


#include "ColCOWS_Node.hh"
#include "ColCOWS_Corba.hh"
#include "ColCOWS_EventHandlerManager.hh" 
#include "ColCOWS_EventHandler.hh" 
#include "ColCOWS_NodeServant.hh" 

using namespace std;

__COLCOWS_BEGIN__

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

unsigned long Node::calculNumFather(unsigned long min, unsigned long max, unsigned long num_child, unsigned long base) 
{
  COLCOWS_IN_DEBUG();

  COLCOWS_DEBUG( dblAccessory,"min : " << min );
  COLCOWS_DEBUG( dblAccessory,"max : " << max );
  COLCOWS_DEBUG( dblAccessory,"num_child : " << num_child );
  COLCOWS_DEBUG( dblAccessory,"base : " << base );
  
  //  min is either num_child, his father or one of its ancestors
  //  max is the max descendant of min
  //  base is the max number of branches of one node of the tree
  
  
  if ((num_child <=  min) || (num_child > max))
    return 0;
  
  
  unsigned long nb_descendants = max - min;
  
  if ( nb_descendants <= base )
    return min;
  
  unsigned long sub_min = 0;
  unsigned long sub_max = min;
  
  for (unsigned long i = 0; i < base; i++ ){
    sub_min = sub_max + 1;
    
    if (i < nb_descendants%base )
      sub_max += nb_descendants/base + 1;
    else
      sub_max += nb_descendants/base;
    
    if (num_child == sub_min)
      return min;
    
    else if ((num_child > sub_min)&&(num_child <= sub_max))
      return calculNumFather(sub_min, sub_max, num_child, base);
  }
  
  COLCOWS_OUT_DEBUG();  
  return 0;
  
}

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

unsigned long Node::calculMaxDescend(unsigned long min, unsigned long max, unsigned long num_child, unsigned long base) 
{
  COLCOWS_IN_DEBUG();

  COLCOWS_DEBUG( dblAccessory,"min : " << min );
  COLCOWS_DEBUG( dblAccessory,"max : " << max );
  COLCOWS_DEBUG( dblAccessory,"num_child : " << num_child );
  COLCOWS_DEBUG( dblAccessory,"base : " << base );
  
  //  min is either num_child, his father or one of its ancestors
  //  max is the max descendant of min
  //  base is the max number of branches of one node of the tree
  
  if ((num_child <  min) || (num_child > max))
    return 0;
  
  if (num_child ==  min)
    return max;
  
  unsigned long nb_descendants = max - min;
  if ( nb_descendants <= base )
    return num_child;
  
  unsigned long sub_min = 0;
  unsigned long sub_max = min;
  
  for (unsigned long i = 0; i < base; i++ ){
    sub_min = sub_max + 1;
    
    if (i < nb_descendants%base )
      sub_max += nb_descendants/base + 1;
    else
      sub_max += nb_descendants/base;
    
    if (num_child == sub_min)
      return sub_max;
    else if ((num_child > sub_min)&&(num_child <= sub_max))
      return calculMaxDescend(sub_min, sub_max, num_child, base);
    
  }
  
  COLCOWS_OUT_DEBUG();  
  return 0;
  
}

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


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

Node::Node()
{
  COLCOWS_IN_DEBUG();
  
  _event_handler_manager  = new EventHandlerManager( );
  _event_handler_manager->setColCOWSNode(this);

  pthread_mutex_init(&_event_mut, NULL);
  pthread_cond_init (&_event_cond, NULL);

  _local_workspace = new WorkspaceDesc();
  _remote_workspace_manager = new RemoteWorkspaceManager();

  _fully_activated = false;

  _node_servant   = NULL;
  
}

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

Node::~Node()
{
  COLCOWS_IN_DEBUG();
  
  delete _event_handler_manager;
  delete _local_workspace;
  delete _remote_workspace_manager;

  pthread_mutex_destroy(&_event_mut);
  pthread_cond_destroy(&_event_cond);

  if ( _node_servant != NULL ) {
    COLCOWS_DEBUG( dblTest, "delete _node_servant" );
    delete _node_servant;
  }
  
}

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

Node * Node::New(std::string ws_id, 
                 std::string ws_kind, 
                 std::string node_kind, 
                 unsigned long num_node, 
                 unsigned long max_descendant, 
                 unsigned long nb_nodes,
                 unsigned long num_father,
                 CORBA::ORB * orbp ) 
{
  COLCOWS_IN_DEBUG();
  
  Node * new_object = NULL;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
    
  NodeServant * new_node_servant = NULL;
  
    new_object = new Node;
    new_object->_orbp = orbp;

    new_object->getLocalWorkspace()->setId(ws_id);
    new_object->getLocalWorkspace()->setKind(ws_kind);
    new_object->getLocalWorkspace()->setNbNodes(nb_nodes);
    new_object->getLocalWorkspace()->setActivated(false);

    new_object->setKind(node_kind);
    new_object->setNumNode(num_node);
    new_object->setMaxDescendant(max_descendant);
    new_object->setActivated(false);

    new_node_servant = NodeServant::New(ws_id.c_str(),  
                                        ws_kind.c_str(), 
                                        node_kind.c_str(), 
                                        num_node, 
                                        max_descendant, 
                                        nb_nodes,
                                        num_father,
                                        orbp );
    
    // set NodeServant pointer in Node members
    new_object->_node_servant = new_node_servant;
    
    // set Node pointer in NodeServant members
    new_node_servant->_colcows_node = new_object;
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  COLCOWS_OUT_DEBUG();  
  return new_object;
}

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

Node * Node::NewHierachical(std::string ws_id,
                            std::string ws_kind, 
                            unsigned long num_node, 
                            unsigned long nb_nodes,
                            unsigned long base,
                            CORBA::ORB * orbp )  
{
  COLCOWS_IN_DEBUG();
  
  Node * new_object = NULL;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
    
  NodeServant * new_node_servant = NULL;
  
    new_object = new Node;
    new_object->_orbp = orbp;

    new_object->getLocalWorkspace()->setId(ws_id);
    new_object->getLocalWorkspace()->setKind(ws_kind);
    new_object->getLocalWorkspace()->setNbNodes(nb_nodes);
    new_object->getLocalWorkspace()->setActivated(false);

    new_object->setKind("Hierachical");
    new_object->setNumNode(num_node);
    new_object->setMaxDescendant(calculMaxDescend(0, nb_nodes-1, num_node, base));
    new_object->setActivated(false);

    new_node_servant = NodeServant::New(ws_id.c_str(), 
                                        ws_kind.c_str(), 
                                        "Hierachical",
                                        num_node,
                                        calculMaxDescend(0, nb_nodes-1, num_node, base),
                                        nb_nodes, 
                                        calculNumFather(0, nb_nodes-1, num_node, base),
                                        orbp );
    
    // set NodeServant pointer
    new_object->_node_servant = new_node_servant;
    
    // set Node pointer
    new_node_servant->_colcows_node = new_object;
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__   

  COLCOWS_OUT_DEBUG();  
  return new_object;
  
}

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

Node * Node::NewProxy(std::string ws_id,
                      std::string ws_kind, 
                      unsigned long nb_nodes,
                      CORBA::ORB * orbp )  
{
  COLCOWS_IN_DEBUG();
  
  Node * new_object = NULL;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  NodeServant * new_node_servant = NULL;
      
    new_object = new Node;
    new_object->_orbp = orbp;

    new_object->getLocalWorkspace()->setId(ws_id);
    new_object->getLocalWorkspace()->setKind(ws_kind);
    new_object->getLocalWorkspace()->setNbNodes(nb_nodes+1);
    new_object->getLocalWorkspace()->setActivated(false);

    new_object->setKind("Proxy");
    new_object->setNumNode(0);
    new_object->setMaxDescendant(nb_nodes);
    new_object->setActivated(false);

    new_node_servant = NodeServant::New(ws_id.c_str(), 
                                        ws_kind.c_str(), 
                                        "Proxy",
                                        0,
                                        nb_nodes,
                                        nb_nodes+1, 
                                        0,
                                        orbp );
    
    // set NodeServant pointer
    new_object->_node_servant = new_node_servant;
    
    // set Node pointer
    new_node_servant->_colcows_node = new_object;
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__   

  COLCOWS_OUT_DEBUG();  
  return new_object;
  
}


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

Node * Node::NewPort(std::string ws_id,
                     std::string ws_kind, 
                     unsigned long num_node, 
                     unsigned long nb_nodes,
                     CORBA::ORB * orbp)  
{
  COLCOWS_IN_DEBUG();
  
  Node * new_object = NULL;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
    
  NodeServant * new_node_servant = NULL;
  
    new_object = new Node;
    new_object->_orbp = orbp;
    
    new_object->getLocalWorkspace()->setId(ws_id);
    new_object->getLocalWorkspace()->setKind(ws_kind);
    new_object->getLocalWorkspace()->setNbNodes(nb_nodes+1);
    new_object->getLocalWorkspace()->setActivated(false);

    new_object->setKind("Node");
    new_object->setNumNode(num_node+1);
    new_object->setMaxDescendant(num_node + 1);
    new_object->setActivated(false);

    new_node_servant = NodeServant::New(ws_id.c_str(), 
                                        ws_kind.c_str(),
                                        "Node",
                                        num_node + 1,
                                        num_node + 1,
                                        nb_nodes + 1, 
                                        0,
                                        orbp );
    
    // set NodeServant pointer
    new_object->_node_servant = new_node_servant;
    
    // set Node pointer
    new_node_servant->_colcows_node = new_object;
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__   

  COLCOWS_OUT_DEBUG();  
  return new_object;
  
}

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

Node * Node::NewNode(std::string ws_id,
                     std::string ws_kind, 
                     std::string node_kind, 
                     unsigned long num_node, 
                     unsigned long nb_nodes,
                     CORBA::ORB * orbp)  
{
  COLCOWS_IN_DEBUG();
  
  Node * new_object = NULL;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
    
  NodeServant * new_node_servant = NULL;
  
    new_object = new Node;
    new_object->_orbp = orbp;

    new_object->getLocalWorkspace()->setId(ws_id);
    new_object->getLocalWorkspace()->setKind(ws_kind);
    new_object->getLocalWorkspace()->setNbNodes(nb_nodes);
    new_object->getLocalWorkspace()->setActivated(false);

    new_object->setKind(node_kind);
    new_object->setNumNode(num_node);
    new_object->setActivated(false);

    if (num_node == 0) {
      new_node_servant = NodeServant::New(ws_id.c_str(), 
                                          ws_kind.c_str(),
                                          node_kind.c_str(),
                                          num_node,
                                          nb_nodes - 1,
                                          nb_nodes, 
                                          0,
                                          orbp );
      new_object->setMaxDescendant(nb_nodes - 1);
    }
    else {
      new_node_servant = NodeServant::New(ws_id.c_str(), 
                                          ws_kind.c_str(),
                                          node_kind.c_str(),
                                          num_node,
                                          num_node,
                                          nb_nodes, 
                                          0,
                                          orbp );      
      new_object->setMaxDescendant(num_node);
    }

    // set NodeServant pointer
    new_object->_node_servant = new_node_servant;
    
    // set Node pointer
    new_node_servant->_colcows_node = new_object;
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__ 
  
  COLCOWS_OUT_DEBUG();  
  return new_object;
  
}

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

unsigned long Node::connect( const std::string & ws_id, const std::string & ws_kind, const std::string & nameservice_str) 
{
  COLCOWS_IN_DEBUG();
  unsigned long is_connected;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  is_connected = _node_servant->connect( ws_id , ws_kind, nameservice_str );

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__ 
  
  COLCOWS_OUT_DEBUG();  
  return is_connected;
}

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

//! disconnect a remote workspace
void Node::disconnect( unsigned long num_connection ) 
{
  COLCOWS_IN_DEBUG();
  
  COLCOWS_ASSERT( isConnected(num_connection) ,"No connection with num " << num_connection);
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  _node_servant->disconnect( num_connection );

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__ 
  
  COLCOWS_OUT_DEBUG();  
  return ;
  
}

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

//! disconnect a remote workspace
void Node::disconnectAll( ) 
{
  COLCOWS_IN_DEBUG();
 
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  _node_servant->disconnectAll( );
  
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return ;
  
}

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

unsigned long Node::getRemoteNbNodes( unsigned long num_connection, std::string node_kind )
{
  COLCOWS_IN_DEBUG();

  unsigned long nb_nodes = 0;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  if ( _remote_workspace_manager->find(num_connection) ==  _remote_workspace_manager->end() ) {
    COLCOWS_DEBUG( dblWarning,"No connection with num " << num_connection );
  }
  else if ( node_kind.empty() ) {
    nb_nodes = (*_remote_workspace_manager)[num_connection]->getNbNodes( );        
  }
  else {
    nb_nodes = (*_remote_workspace_manager)[num_connection]->getNbNodes( node_kind );    
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return nb_nodes;
}

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

string Node::getRemoteWorkspaceID( unsigned long num_connection )
{
  COLCOWS_IN_DEBUG();

  string remote_id;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  if ( _remote_workspace_manager->find(num_connection) ==  _remote_workspace_manager->end() ) {
    COLCOWS_DEBUG( dblWarning,"No connection with num " << num_connection );
  }
  else{
    remote_id = (*_remote_workspace_manager)[num_connection]->getId();
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
 
  COLCOWS_OUT_DEBUG();  
  return remote_id;    
}

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

string Node::getRemoteWorkspaceKind( unsigned long num_connection )
{
  COLCOWS_IN_DEBUG();
  
  string remote_kind;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  if ( _remote_workspace_manager->find(num_connection) ==  _remote_workspace_manager->end() ) {
    COLCOWS_DEBUG( dblWarning,"No connection with num " << num_connection );
  }
  else{
    remote_kind = (*_remote_workspace_manager)[num_connection]->getKind();
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return remote_kind;    
}

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

unsigned long Node::getNumConnection( std::string ws_id , std::string ws_kind ) 
{
  COLCOWS_IN_DEBUG();

  unsigned long num_connection = NOT_CONNECTED;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  RemoteWorkspaceManager::const_iterator it, it_begin, it_end;
  it_begin = _remote_workspace_manager->begin();
  it_end = _remote_workspace_manager->end();

  for (it = it_begin; it != it_end; ++ it) {
    if ( ( it->second->getId() == ws_id ) && 
         ( it->second->getKind() == ws_kind ) ) {
      num_connection = it->second->getNumConnection();
      break;
    }
  }
  
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return num_connection;  
}

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

void Node::getNumConnectionVec(std::vector<unsigned long> & num_connection_vec ,
                               std::string ws_id , 
                               std::string ws_kind ) 
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  num_connection_vec.clear();

  RemoteWorkspaceManager::const_iterator it, it_begin, it_end;
  it_begin = _remote_workspace_manager->begin();
  it_end = _remote_workspace_manager->end();

  for (it = it_begin; it != it_end; ++ it) {
    if ( ( it->second->getId() == ws_id ) && 
         ( it->second->getKind() == ws_kind ) ) {
      num_connection_vec.push_back( it->second->getNumConnection() );
      break;
    }
  }
  
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return;  
}

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

void Node::activate()
  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  _node_servant->activate();
  setActivated(true);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  COLCOWS_OUT_DEBUG();
  return;
}

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

void Node::deactivate()
  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  setActivated(false);
  _node_servant->deactivate();

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return;
}

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

void Node::onActivation( const IdlWorkspaceDesc& ws_desc ) 
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
    
  COLCOWS_DEBUG(dblAccessory, "Activation of node " << _num_node << "(" << _node_kind << ")");
  
  pthread_mutex_lock(&_event_mut);

  _local_workspace->convertFromIdl( ws_desc );

  _event_handler_manager->onActivation( );
  
  _fully_activated = true;
  
  pthread_cond_broadcast(&_event_cond);
  pthread_mutex_unlock(&_event_mut);
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  COLCOWS_OUT_DEBUG();
  return;
}


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

void Node::onDeactivation( const IdlWorkspaceDesc& ws_desc )  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

    pthread_mutex_lock(&_event_mut);

    _local_workspace->convertFromIdl( ws_desc );

    _event_handler_manager->onDeactivation( );
    
    _fully_activated = false;

    pthread_cond_broadcast(&_event_cond);
    pthread_mutex_unlock(&_event_mut);
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  COLCOWS_OUT_DEBUG();
  return;
}

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

void Node::onConnection( unsigned long num_connection, const IdlWorkspaceDesc& idl_ws_desc, bool initiator )  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

    WorkspaceDesc * ws_desc = new WorkspaceDesc(idl_ws_desc);
    ws_desc->setNumConnection( num_connection );

    pthread_mutex_lock(&_event_mut);
    _remote_workspace_manager->addRemoteWorkspace( ws_desc );

    _event_handler_manager->onConnection( num_connection, initiator );

    pthread_cond_broadcast(&_event_cond);
    pthread_mutex_unlock(&_event_mut);
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__
  
  COLCOWS_OUT_DEBUG();
  return;
}

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

void Node::onDisconnection( unsigned long num_connection )  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

    pthread_mutex_lock(&_event_mut);
    _remote_workspace_manager->removeRemoteWorkspace( num_connection );

    _event_handler_manager->onDisconnection( num_connection );
    
    pthread_cond_broadcast(&_event_cond);
    pthread_mutex_unlock(&_event_mut);
    
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return;
}


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

bool Node::waitActivation( bool use_timeout )  
{
  COLCOWS_IN_DEBUG();
  
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  pthread_mutex_lock(&_event_mut);

  int keep_trying = WAITING_RETRY;

  while( !_fully_activated && keep_trying) {
    COLCOWS_DEBUG( dblAccessory, "Waiting for activation of node " << _num_node << "(" << _node_kind << ")" );

    if (use_timeout)
      {
        struct timeval now;
        struct timespec timeout;
        gettimeofday(&now,NULL);
        timeout.tv_sec = now.tv_sec + WAITING_TIMEOUT;
        timeout.tv_nsec = now.tv_usec * 1000;
        if(pthread_cond_timedwait(&_event_cond, &_event_mut, &timeout) == ETIMEDOUT) {
          --keep_trying;
          COLCOWS_DEBUG( dblAccessory, "activation timeout, nb retry = " << keep_trying );
        }
      }
    else 
      {
        pthread_cond_wait(&_event_cond, &_event_mut );
        keep_trying = 1;
      }
      
  }
  
  pthread_mutex_unlock(&_event_mut);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return _fully_activated;
}

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

bool Node::waitDeactivation( bool use_timeout )  
{
  COLCOWS_IN_DEBUG();
 
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  pthread_mutex_lock(&_event_mut);

  int keep_trying = WAITING_RETRY;
  while( _fully_activated && keep_trying) {
    COLCOWS_DEBUG( dblAccessory, "Waiting for deactivation." );
    
    if (use_timeout)
      {
        struct timeval now;
        struct timespec timeout;
        gettimeofday(&now,NULL);
        timeout.tv_sec = now.tv_sec + WAITING_TIMEOUT;
        timeout.tv_nsec = now.tv_usec * 1000;
        if(pthread_cond_timedwait(&_event_cond, &_event_mut, &timeout) == ETIMEDOUT) {
          --keep_trying;
          COLCOWS_DEBUG( dblAccessory, "deactivation timeout, nb retry = " << keep_trying );
        }
      }
    else 
      {
        pthread_cond_wait(&_event_cond, &_event_mut );
        keep_trying = 1;
      }
    
  }
  
  pthread_mutex_unlock(&_event_mut);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return !_fully_activated;
}

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

unsigned long Node::waitConnection( std::string ws_id, std::string ws_kind, bool use_timeout ) 
{
  COLCOWS_IN_DEBUG();

  unsigned long  is_connected;  

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  pthread_mutex_lock(&_event_mut);

  is_connected = isConnected(ws_id, ws_kind);
  
  int keep_trying = WAITING_RETRY;
  while(( is_connected == NOT_CONNECTED) && keep_trying) {
    COLCOWS_DEBUG( dblAccessory, "Waiting for connection." );
    
    if (use_timeout)
      {
        struct timeval now;
        struct timespec timeout;
        gettimeofday(&now,NULL);
        timeout.tv_sec = now.tv_sec + WAITING_TIMEOUT;
        timeout.tv_nsec = now.tv_usec * 1000;
        if(pthread_cond_timedwait(&_event_cond, &_event_mut, &timeout) == ETIMEDOUT) {
          --keep_trying;
          COLCOWS_DEBUG( dblAccessory, "connection timeout, nb retry = " << keep_trying );
        }
      }
    else 
      {
        pthread_cond_wait(&_event_cond, &_event_mut );
        keep_trying = 1;
      }
    
    is_connected = isConnected(ws_id, ws_kind);
  }
  
  pthread_mutex_unlock(&_event_mut);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return is_connected;
}

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

unsigned long Node::waitAllDisconnection( bool use_timeout ) 
{
  COLCOWS_IN_DEBUG();

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  pthread_mutex_lock(&_event_mut);

  int keep_trying = WAITING_RETRY;
  while( (!_remote_workspace_manager->empty()) && keep_trying) {
    COLCOWS_DEBUG( dblAccessory, "Waiting for all disconnection." );
    
    if (use_timeout)
      {
        struct timeval now;
        struct timespec timeout;
        gettimeofday(&now,NULL);
        timeout.tv_sec = now.tv_sec + WAITING_TIMEOUT;
        timeout.tv_nsec = now.tv_usec * 1000;
        if(pthread_cond_timedwait(&_event_cond, &_event_mut, &timeout) == ETIMEDOUT) {
          --keep_trying;
          COLCOWS_DEBUG( dblAccessory, "all disconnection timeout, nb retry = " << keep_trying );
        }
      }
    else 
      {
        pthread_cond_wait(&_event_cond, &_event_mut );
        keep_trying = 1;
      }
    
  }
  
  pthread_mutex_unlock(&_event_mut);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return _remote_workspace_manager->empty();
}

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

unsigned long Node::waitDisconnection( std::string ws_id, std::string ws_kind, bool use_timeout )
{
  COLCOWS_IN_DEBUG();
  
  unsigned long  is_connected;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  pthread_mutex_lock(&_event_mut);

  is_connected = isConnected(ws_id, ws_kind);
    
  int keep_trying = WAITING_RETRY;
  while(( is_connected != NOT_CONNECTED ) && keep_trying) {
    COLCOWS_DEBUG( dblAccessory, "Waiting for connection." );      
    
    if (use_timeout)
      {
        struct timeval now;
        struct timespec timeout;
        gettimeofday(&now,NULL);
        timeout.tv_sec = now.tv_sec + WAITING_TIMEOUT;
        timeout.tv_nsec = now.tv_usec * 1000;
        if(pthread_cond_timedwait(&_event_cond, &_event_mut, &timeout) == ETIMEDOUT) {
          --keep_trying;
          COLCOWS_DEBUG( dblAccessory, "disconnection timeout, nb retry = " << keep_trying );
        }
      }
    else 
      {
        pthread_cond_wait(&_event_cond, &_event_mut );
        keep_trying = 1;
      }
      
    is_connected = isConnected(ws_id, ws_kind);
  }
  
  pthread_mutex_unlock(&_event_mut);

__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();
  return !is_connected;
}

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

bool Node::isConnected(std::string ws_id, std::string ws_kind) const
{
  COLCOWS_IN_DEBUG();

  bool is_connected = false;

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  RemoteWorkspaceManager::const_iterator it, it_begin, it_end;
  it_begin = _remote_workspace_manager->begin();
  it_end = _remote_workspace_manager->end();

  for (it = it_begin; it != it_end; ++ it) {
    if ( ( it->second->getId() == ws_id ) && 
         ( it->second->getKind() == ws_kind ) ) {
      is_connected = true;
      break;
    }
  }
  
__END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__

  COLCOWS_OUT_DEBUG();  
  return is_connected;  
}

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

void Node::setEventHandlerManager(EventHandlerManager * event_handler_manager) 
{
  COLCOWS_IN_DEBUG();  

  event_handler_manager->_colcows_node = this;
  _event_handler_manager = event_handler_manager;   

  COLCOWS_OUT_DEBUG();  
  return;  
}

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

unsigned int Node::addEventHandler( EventHandler * event_handler ) 
{
  COLCOWS_ASSERT((_event_handler_manager != NULL), "Event handler manager is null");
  return _event_handler_manager->addEventHandler( event_handler );
}

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

void Node::removeEventHandler( unsigned int key ) 
{ 
  _event_handler_manager->removeEventHandler( key ); 
}

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

void Node::removeEventHandler( EventHandler * event_handler ) 
{ 
  _event_handler_manager->removeEventHandler( event_handler->getKey() ); 
}

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

void Node::printself(ostream & stream, int indent) const 
{
  NodeDesc::printself(stream, indent);  
  _local_workspace->printself(stream, indent+1);
}

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

ostream& operator <<(std::ostream& stream, const Node & _this)
{
  stream << "Node {" << std::endl; 
  _this.printself(stream);
  stream << "}" << std::endl;
  return stream;
}

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

__COLCOWS_END__

// EOF

---