ColCOWS_NodeServant.cc

//===========================================================================//
//    
//    Description: Implementation of ColCOWS Node interface 
//    Filename: colcows/ColCOWS_NodeServant.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_NodeServant.hh"
#include "ColCOWS_Node.hh"

using namespace std;

__COLCOWS_BEGIN__

//! max resolve retry (sec)
const unsigned int  RESOLVE_RETRY = 15;

//! max register retry (sec)
const unsigned int  REGISTER_RETRY = 15;


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


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

NodeServant::NodeServant()
{
  COLCOWS_IN_DEBUG();

  _my_node           = new IdlNodeDesc;
  _local_workspace   = new IdlWorkspaceDesc;
  _father_node       = new IdlNodeDesc;
  _children_nodes    = new IdlNodeDescSeq;
  _remote_workspaces   = new IdlWorkspaceDescSeq;

  pthread_mutex_init(&_children_mut, NULL);
  pthread_mutex_init(&_activation_mut, NULL);
  pthread_cond_init(&_activation_cond, NULL);

  _ready = false;
  _auto_activation = false;
  _current_num_connection = NOT_CONNECTED;

  COLCOWS_OUT_DEBUG();
  return;
}

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

NodeServant::~NodeServant()
{
  COLCOWS_IN_DEBUG();

  try {
    
    // deactivate (etherealize, wait for completion)
    if(! CORBA::is_nil( _colcows_pman ) ) {
      COLCOWS_DEBUG( dblTest, "Deactivate ColCOWS POA Manager");
      _colcows_pman->deactivate(true,true);
    }
    // unbind obj_ref with objname to the name service
    if(! CORBA::is_nil( _naming_ctxt ) ) {
      COLCOWS_DEBUG( dblTest, "Unbind ColCOWS from Naming Service");

      CosNaming::Name objectName;
      objectName.length(1);
      objectName[0].id   = CORBA::string_dup(_local_workspace->ws_id);   // string copied
      objectName[0].kind = CORBA::string_dup(_local_workspace->ws_kind);  // string copied
      
      try {
        _naming_ctxt->unbind(objectName);
      }
      catch(CosNaming::NamingContext::NotFound& ex) {
        // OK
      }
    }
  }
  catch( ... ) {
    cerr << "Service required is invalid [does not exist]." << endl;
  }

  pthread_mutex_destroy(&_children_mut);
  pthread_mutex_destroy(&_activation_mut);
  pthread_cond_destroy(&_activation_cond);

  COLCOWS_OUT_DEBUG();
  return;
}

//===========================================================================//
NodeServant * 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) 
{
  COLCOWS_IN_DEBUG();

  NodeServant * new_node_servant = new NodeServant;
  new_node_servant->lockChildrenMutex();
  new_node_servant->lockActivationMutex();

  try {
    CORBA::Object_var obj_ref;

    // verify if the reference on the ORB is not nil
    COLCOWS_ASSERT( ( !CORBA::is_nil( orbp ) ), "Got a nil ORB pointer.");

    new_node_servant->_orbp = orbp;

    // Obtain a reference of the root POA
    COLCOWS_DEBUG( dblTest, "Obtain a reference of the root POA");
    obj_ref = orbp->resolve_initial_references("RootPOA");
    new_node_servant->_root_poa = PortableServer::POA::_narrow(obj_ref);

    // Build ColCOWS POA unique name
    stringstream colcows_poa_name (stringstream::in | stringstream::out);
    colcows_poa_name << "ColCOWSPOA" << "_" << ws_id << "_" << ws_kind ;
 
    try {
      // Create the ColCOWS POA
      COLCOWS_DEBUG( dblTest, "Create the ColCOWS POA");

      CORBA::PolicyList policies;
      policies.length(1);
      policies[0] = new_node_servant->_root_poa->create_lifespan_policy( PortableServer::PERSISTENT );

      new_node_servant->_colcows_poa = new_node_servant->_root_poa->create_POA(  colcows_poa_name.str().c_str(), 
                                                                                 PortableServer::POAManager::_nil(),
                                                                                 policies );
    }
    catch ( ... ) {
      COLCOWS_DEBUG( dblTest, "Failed to create ColCOWS POA"  << ", let' s try to find it ...");
    }
    
    if( CORBA::is_nil( new_node_servant->_colcows_poa ) ) {
      // Obtain a reference of the ColCOWS POA
      COLCOWS_DEBUG( dblTest, "Find the reference of the ColCOWS POA");
     
      new_node_servant->_colcows_poa = new_node_servant->_root_poa->find_POA(colcows_poa_name.str().c_str(), false );     
    }

    COLCOWS_DEBUG( dblTest, "Activate new node servant in ColCOWS POA");
    new_node_servant->_colcows_poa->activate_object( new_node_servant );

    COLCOWS_DEBUG( dblTest, "Get ColCOWS POA Manager");
    new_node_servant->_colcows_pman = new_node_servant->_colcows_poa->the_POAManager( );

    COLCOWS_DEBUG( dblTest, "Activate ColCOWS POA Manager");
    new_node_servant->_colcows_pman->activate();

    // Obtain a reference of the name service:
    COLCOWS_DEBUG( dblTest, "Obtain a reference of the Naming Service");
    try {
      obj_ref = orbp->resolve_initial_references("NameService");
      new_node_servant->_naming_ctxt = CosNaming::NamingContext::_narrow(obj_ref);
    }
    catch ( ... ) {
      COLCOWS_ERROR( "Failed to resolve NameService");
    }
    COLCOWS_DEBUG( dblTest, "Naming Service resolved!");
    COLCOWS_ASSERT( !(CORBA::is_nil( new_node_servant->_naming_ctxt )), "Failed to narrow the root naming context.");

    new_node_servant->_my_node->node_kind       = CORBA::string_dup(node_kind);
    new_node_servant->_my_node->num_node        = num_node;
    new_node_servant->_my_node->max_descendant  = max_descendant;
    new_node_servant->_my_node->activated       = false;
    new_node_servant->_my_node->node_ref        = new_node_servant->_this();

    new_node_servant->_local_workspace->ws_id             = CORBA::string_dup(ws_id);
    new_node_servant->_local_workspace->ws_kind           = CORBA::string_dup(ws_kind);
    new_node_servant->_local_workspace->nb_nodes         = nb_nodes;
    new_node_servant->_local_workspace->activated        = false;
  

    if (num_node == 0) {

      try {   
        // bind obj_ref with objname to the name service
        CosNaming::Name objectName;
        objectName.length(1);
        objectName[0].id   = CORBA::string_dup(ws_id);   // string copied
        objectName[0].kind = CORBA::string_dup(ws_kind);  // string copied
    
        try {
          new_node_servant->_naming_ctxt->bind(objectName, new_node_servant->_this());
        }
        catch(CosNaming::NamingContext::AlreadyBound& ex) {
          COLCOWS_DEBUG( dblMajor, "Proxy must do a rebind on the Naming Service." );
          new_node_servant->_naming_ctxt->rebind(objectName, new_node_servant->_this());
        }

      }
      catch(...) {
        COLCOWS_ERROR( "Cannot bind root proxy in the naming service." );
      }

      COLCOWS_DEBUG( dblTest, "Object bind in the Naming Service!");

      new_node_servant->_local_workspace->enter_node_ref  = new_node_servant->_this();

      new_node_servant->_registred_to_father = true;
    }
    else {

      COLCOWS_DEBUG( dblTest, "Try to resolve object from the Naming Service");
      unsigned long retry = RESOLVE_RETRY;

      // Resolve the name to an object reference.
      CosNaming::Name name;
      name.length(1);
      name[0].id   = (const char*) CORBA::string_dup(ws_id);   // string copied 
      name[0].kind = (const char*) CORBA::string_dup(ws_kind);  // string copied 

      while ( true ) {
        try { 
          obj_ref = new_node_servant->_naming_ctxt->resolve(name);

          if (( CORBA::is_nil( obj_ref ) == false ) && ( obj_ref->_non_existent() == false )) break; // success
              
        }
        catch(CosNaming::NamingContext::NotFound& ex) {
          COLCOWS_DEBUG( dblWarning, "reference on  " << ws_id << ":" << ws_kind <<" not found in naming service" );
        }
        catch(CORBA::TRANSIENT& ex) {
          COLCOWS_DEBUG( dblWarning, "reference on  " << ws_id << ":" << ws_kind <<" raise TRANSIENT exception" );
        }
        
        if ( --retry > 0) {
          // keep trying ...
          COLCOWS_DEBUG( dblWarning, "Keep trying " << retry << " chances left ..." );
          sleep(1);
        }
        else {
          COLCOWS_ERROR( "Cannot resolve reference on  " << ws_id << ":" << ws_kind <<" (no more retry)" );
        }
      }

      COLCOWS_DEBUG( dblTest, "Object resolved from the Naming Service!");

      new_node_servant->_local_workspace->enter_node_ref  = ColCOWS::NodeInterface::_narrow(obj_ref);

      COLCOWS_ASSERT( !(CORBA::is_nil(new_node_servant->_local_workspace->enter_node_ref)), 
                      "Failed to narrow the enter node .");

      COLCOWS_ASSERT( (num_father < num_node), "Father num is greater than node num"); 
      new_node_servant->_father_node->num_node = num_father;      
      new_node_servant->_registred_to_father = false;

      // no retry to avoid troubles in sequential cases...
      new_node_servant->registerToFather( );
    }

  }
  catch ( ... ) { 
    COLCOWS_DEBUG( dblException, "Got a ColCOWS exception  in constructor" );
    delete new_node_servant;
    throw;
  }

  new_node_servant->unlockChildrenMutex();
  new_node_servant->unlockActivationMutex();

  COLCOWS_OUT_DEBUG();
  return new_node_servant;
}

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

bool NodeServant::registerToFather( unsigned long max_retry ) 
{  
  COLCOWS_IN_DEBUG();

  unsigned long num_father = _father_node->num_node;

  while (_registred_to_father == false) {
    COLCOWS_DEBUG( dblTest,"in while, ( max_retry =  " << max_retry << " )");

    try {

      // Must use an intermediate to avoid the blanking of _father_node ...
      IdlNodeDesc_var node_desc = new IdlNodeDesc;
      _local_workspace->enter_node_ref->getNode( num_father, node_desc.out());
      _father_node = node_desc;

      if (!(CORBA::is_nil(_father_node->node_ref)) && !(_father_node->node_ref->_non_existent())) 
        {
          
          _father_node->node_ref->setChildNode(_my_node.in()); 
          
          _registred_to_father = true;
        }

    }
    catch (CorbaException & e) { 
      if (e.kind == cstNotReadyException) {
        COLCOWS_DEBUG( dblException, "Got a NotReady exception when trying to register to father(set child wsnode).");
      }
      else {
        COLCOWS_DEBUG( dblException, "Got a ColCOWS exception  when trying to register to father(set child wsnode).");
        throw;
      }
    }
    catch(CORBA::TRANSIENT& ex) {
      COLCOWS_DEBUG( dblException, "Got a TRANSIENT exception  when trying to register to father(set child wsnode).");
    }
    catch(CORBA::COMM_FAILURE& ex) {
      COLCOWS_ERROR( "Got a COMM_FAILURE exception  when trying to register to father(set child wsnode).");
    }
    catch (const CORBA::SystemException & e) { 
      COLCOWS_ERROR( "Got a CORBA exception  when trying to register to father(set child wsnode).");
    }
    catch ( ... ) { 
      COLCOWS_ERROR( "Got an unknown exception  when trying to register to father(set child wsnode).");
    }

    if ((max_retry > 0) && (_registred_to_father == false)) {
      sleep(1);
      COLCOWS_DEBUG( dblWarning, "retrying registration.");
      max_retry --;
    }
    else
      break;
    
  }

  COLCOWS_OUT_DEBUG();
  return _registred_to_father;
}

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

void NodeServant::activate( ) 
{  
  COLCOWS_IN_DEBUG();

  COLCOWS_ASSERT( (!_my_node->activated), "Workspace Node is already activated." );

  pthread_mutex_lock(&_activation_mut); 
  pthread_mutex_lock(&_children_mut);

  COLCOWS_ASSERT( registerToFather( REGISTER_RETRY ), "Cannot register the Workspace to his father." );

  // check if the activated children cover all my descendants
  unsigned long nb_descendants_activated = 0;
  for (unsigned long i = 0; ((i < _children_nodes->length()) && (_children_nodes[i].activated)); i++) {
    nb_descendants_activated += _children_nodes[i].max_descendant - _children_nodes[i].num_node + 1;
  }

  pthread_mutex_unlock(&_children_mut);

  bool ready_for_activation = (nb_descendants_activated == _my_node->max_descendant - _my_node->num_node);

  COLCOWS_DEBUG(dblAccessory, "nb descendants activated " << nb_descendants_activated << " on " << ( _my_node->max_descendant - _my_node->num_node ) );
  COLCOWS_DEBUG(dblAccessory, "Is ready for activation ? " << ready_for_activation );

  // cannot be activated ...
  if (ready_for_activation == false) {
    
    COLCOWS_DEBUG(dblAccessory, "set auto_activation");
    _auto_activation = true;

  }
  else{ 

    _colcows_node->updateIdl(_my_node);

    COLCOWS_DEBUG(dblAccessory, "Node is activated");
    _my_node->activated = true;
  
    // reinitialize auto activation
    _auto_activation = false;

    // prepare the temporary image of this node with its children
    IdlNodeDesc_var wsnode = new IdlNodeDesc((const IdlNodeDesc) _my_node); // deep copy

    unsigned long current_child = wsnode->num_node + 1;
    unsigned long order_num_child = 0;
    wsnode->children_seq.length( _children_nodes->length() );

    while (current_child <= wsnode->max_descendant) {

      COLCOWS_ASSERT( (order_num_child < _children_nodes->length()), "Reaching the end of _children_nodes sequence.");

      unsigned long num_child;
      for (num_child = 0; 
           (   (num_child < _children_nodes->length()) 
               && (_children_nodes[num_child].num_node != current_child)) ; 
           num_child++) { }

      // if node not registred among the childs
      COLCOWS_ASSERT( (num_child != _children_nodes->length()), "There is a hole in the descendants.");

      IdlNodeDesc_var child_node = new IdlNodeDesc((const IdlNodeDesc) _children_nodes[num_child]); // deep copy

      wsnode->children_seq[order_num_child] = child_node;

      current_child =  _children_nodes[num_child].max_descendant + 1;
      order_num_child ++;

    } 

    // forward the activation to the father node if any
    if (_my_node->num_node != 0) {

      // Forwarding the activation to the father
      COLCOWS_DEBUG(dblAccessory, "Forwarding the activation to the father" );
      _father_node->node_ref->setChildNode(wsnode.in());

    }
    // The root propagate an image of the whole workspace to its children
    else {

      _local_workspace->activated = true;
      _local_workspace->enter_node = wsnode;

      unsigned long nb_children = _children_nodes->length();

      for (unsigned long j = 0; j < nb_children ; j++) 
        _children_nodes[j].node_ref->setWorkspace(_local_workspace.in());

      // signal activation on thre root... setWorkspace will do the same on the children
      _colcows_node->onActivation( _local_workspace );
    }
  }  

  pthread_mutex_unlock(&_activation_mut); 

  COLCOWS_OUT_DEBUG();
  return ;
}

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

void NodeServant::deactivate( ) 
{  
  COLCOWS_IN_DEBUG();

  pthread_mutex_lock(&_activation_mut); 

  // reinitialize auto activation
  _auto_activation = false;

  _my_node->activated = false;
  
  // forward the activation to the father node if any
  if (_my_node->num_node != 0) {
    COLCOWS_DEBUG( dblAccessory, "forward the activation to the father node if any.");    
  
    _father_node->node_ref->setChildNode(_my_node.in());
  }
  // The root propagate the deactivation of the WS to its children
  else {
    COLCOWS_DEBUG( dblAccessory, "The root propagate the deactivation of the WS to its children");    
    _local_workspace->activated = false;
    
    IdlNodeDesc_var wsnode = new IdlNodeDesc((const IdlNodeDesc) _my_node); // deep copy
    _local_workspace->enter_node = wsnode;

    // forward
    unsigned long nb_children = _children_nodes->length();
    for (unsigned long j = 0; j < nb_children; j++) {
      _children_nodes[j].node_ref->setWorkspace(_local_workspace);
    }

      // signal deactivation on thre root... setWorkspace will do the same on the children
    _colcows_node->onDeactivation( _local_workspace );
  }

  pthread_mutex_unlock(&_activation_mut); 

  COLCOWS_OUT_DEBUG();
  return ;
}

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

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

  COLCOWS_ASSERT( ( _my_node->num_node == 0 ), "Only the proxy can connect" );
  COLCOWS_ASSERT( ( getNumConnection(ws_id.c_str(), ws_kind.c_str()) == NOT_CONNECTED ), "Already connected" );
  COLCOWS_ASSERT( isReady(), "Workspace not ready for connection" );

  CosNaming::NamingContext_var naming_ctxt;
  if ( !nameservice_str.empty() ) 
    {
      // Obtain a reference of the name service:
      COLCOWS_DEBUG( dblTest, "Obtain a reference of the Naming Service");
      try {
        CORBA::Object_var obj_ref;
        obj_ref = _orbp->string_to_object( nameservice_str.c_str() );
        naming_ctxt = CosNaming::NamingContext::_narrow(obj_ref);
      }
      catch ( ... ) {
        THROW_CORBA_EXCEPTION( cstCorbaException, "Failed to resolve NameService");
      }
    }
  else 
    {
      naming_ctxt = _naming_ctxt;
    }

  // find the reference in the naming service
  CORBA::Object_var obj_ref;
  
  unsigned long retry = RESOLVE_RETRY;
  
  // Resolve the name to an object reference.
  CosNaming::Name name;
  name.length(1);
  name[0].id   = (const char*) CORBA::string_dup(ws_id.c_str());   // string copied 
  name[0].kind = (const char*) CORBA::string_dup(ws_kind.c_str());  // string copied 
  
  while ( true ) {
    try { 
        obj_ref = naming_ctxt->resolve(name);
        
        if (( CORBA::is_nil( obj_ref ) == false ) && ( obj_ref->_non_existent() == false )) break; // success
        
    }
    catch(CosNaming::NamingContext::NotFound& ex) {
      COLCOWS_DEBUG( dblWarning, "reference on  " << ws_id << ":" << ws_kind <<" not found in naming service" );
    }
    catch(CORBA::TRANSIENT& ex) {
      COLCOWS_DEBUG( dblWarning, "reference on  " << ws_id << ":" << ws_kind <<" raise TRANSIENT exception" );
    }
        
    if ( --retry > 0) {
      // keep trying ...
      COLCOWS_DEBUG( dblWarning, "Keep trying " << retry << " chances left ..." );
      sleep(1);
    }
    else {
      THROW_CORBA_EXCEPTION( cstCorbaException, 
                             "Cannot resolve reference on  " << ws_id << ":" << ws_kind <<" (no more retry)");
    }
  }

  NodeInterface_var remote_node_servant = ColCOWS::NodeInterface::_narrow(obj_ref);
  
  _current_num_connection++;
  
  remote_node_servant->getCommonNumConnection( (CORBA::ULong&)_current_num_connection ); 
  // remote_node_servant->getCommonNumConnection( _current_num_connection ); // pb with it64 !!!
  
  // exchange the descriptions
  
  IdlWorkspaceDesc_var remote_workspace ; //= new IdlWorkspaceDesc;
  remote_node_servant->getWorkspace(remote_workspace.out());
  
  bool initiator = false;
  remote_node_servant->setRemoteWorkspace( _current_num_connection, _local_workspace.in(), initiator );
  
  initiator = true;
  _local_workspace->enter_node_ref->setRemoteWorkspace( _current_num_connection, remote_workspace.in(), initiator );    
    
  COLCOWS_OUT_DEBUG();
  return getNumConnection(ws_id.c_str(), ws_kind.c_str());
}

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

//! disconnect a remote workspace
void NodeServant::disconnect( unsigned long num_connection ) 
{
  COLCOWS_IN_DEBUG();

  COLCOWS_ASSERT( isConnected(num_connection), "Not connected" );
  long num_ws = indexConnection(num_connection);
  COLCOWS_ASSERT( num_ws != -1 , "Incoherent index value" );

  _remote_workspaces[num_ws].enter_node_ref->releaseRemoteWorkspace( num_connection );
  _local_workspace->enter_node_ref->releaseRemoteWorkspace( num_connection );   
    
  COLCOWS_OUT_DEBUG();
  return ; 
}

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

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

  long num_ws; // not unsigned because of the test : num_ws < 0
  unsigned long nb_ws = _remote_workspaces->length();

  for (num_ws = nb_ws - 1 ; num_ws >= 0; num_ws--) // disconnect from the end of the sequence
    {
      unsigned long num_connection = _remote_workspaces[num_ws].num_connection;
      
      _remote_workspaces[num_ws].enter_node_ref->releaseRemoteWorkspace( num_connection );
        _local_workspace->enter_node_ref->releaseRemoteWorkspace( num_connection );
    }   
  
  
  COLCOWS_OUT_DEBUG();
  return ;
}

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

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

//! get a node description 
void NodeServant::getNode(CORBA::ULong num_node, IdlNodeDesc_out node) throw (CorbaException) 
  
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  // Invalid node number
  COLCOWS_ASSERT( (num_node >= 0), "Invalid node number");

  // It 's me !!!
  if (num_node == _my_node->num_node){
    node = new IdlNodeDesc((const IdlNodeDesc) _my_node); //deep copy
  }
  // It 's one of my descendants
  else if ((num_node > _my_node->num_node) && (num_node <= _my_node->max_descendant))  {
    unsigned long num_child;
    // looking for a node holding the same branch of the hierarchy
    for (num_child = 0;
         (   (num_child < _children_nodes->length())
             && (   (num_node < _children_nodes[num_child].num_node)
                    || (num_node > _children_nodes[num_child].max_descendant)  )  ); 
         num_child ++){}
 
    // if node not registred among the childs
    COLCOWS_ASSERT( (num_child != _children_nodes->length()), "Node " << num_node << " is not hold by any registred child.");

    // if it's one of my child and if I 've got an active description
    if ((num_node == _children_nodes[num_child].num_node) && _children_nodes[num_child].activated) {
      node = new IdlNodeDesc((const IdlNodeDesc) _children_nodes[num_child]); //deep copy      
    }
    // if I 've got a valid reference on the child holding this node
    else if ( !CORBA::is_nil(_children_nodes[num_child].node_ref)) {
      _children_nodes[num_child].node_ref->getNode(num_node, node);
    }
    else {
      THROW_CORBA_EXCEPTION( cstNotReadyException, "Node " << num_node << " is not hold by any registred child." );
    }

  }
  // It 's not one of my descendants, ask my father
  else if ((num_node < _my_node->num_node) || (num_node > _my_node->max_descendant))  {
    _father_node->node_ref->getNode(num_node, node);
  }    
  // It 's not one of my descendants
  else {
    COLCOWS_ERROR( "Unexpected case !!!" );
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}

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

//! set a node description 
void NodeServant::setChildNode(const IdlNodeDesc& node) throw (CorbaException) 
  
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  COLCOWS_DEBUG( dblAccessory,"Set child " << node.num_node << " on node " << _my_node->num_node);

  COLCOWS_ASSERT( ((node.max_descendant <= _my_node->max_descendant)&&(node.num_node > _my_node->num_node)),
                  "Node " << node.num_node << " is not one of my descendants" );

  pthread_mutex_lock(&_children_mut);

  unsigned long num_child;
  bool trigger_activation = false;
  bool trigger_deactivation = false;

  // looking for a node holding the same branch of the hierarchy
  for (num_child = 0;
       (   (num_child < _children_nodes->length())
           && (   (node.num_node != _children_nodes[num_child].num_node)
                  || (node.max_descendant != _children_nodes[num_child].max_descendant)  )  ); 
       num_child ++){}


  // if node not registred among the childs
  if(num_child == _children_nodes->length()) {

    // verif if can be inserted among the children 
    for (num_child = 0;
         (   (num_child < _children_nodes->length())
             && (   (node.max_descendant < _children_nodes[num_child].num_node)
                    || (node.num_node > _children_nodes[num_child].max_descendant)  )  ); 
         num_child ++){}

    // node can't be inserted
    COLCOWS_ASSERT( (num_child >= _children_nodes->length()),"Node " << num_child << " can't be inserted" );

    // create new entry child desc tab
    _children_nodes->length(num_child+1);
   
    if (node.activated) {
      COLCOWS_DEBUG( dblAccessory, "Child " << node.num_node << " has been added (activated)" );
      trigger_activation = true;
    }
    else {
      COLCOWS_DEBUG( dblAccessory, "Child " << node.num_node << " has been added (not activated)" );
    }
  }
  // if node is already registred among the childs
  else {
    if      ((! _children_nodes[num_child].activated) && (  node.activated)) {
      COLCOWS_DEBUG( dblAccessory, "Child " << node.num_node << " is now activated" );
      trigger_activation = true;
    }
    else if ((  _children_nodes[num_child].activated) && (! node.activated)) {
      COLCOWS_DEBUG( dblAccessory, "Child " << node.num_node << " is no more activated" );
      trigger_deactivation = true;
    }
    else if ((  _children_nodes[num_child].activated) && (  node.activated)) {
      COLCOWS_ERROR( "Child " << node.num_node << " already activated" );
    }
  }

  // set child node description
  IdlNodeDesc_var node_tmp = new IdlNodeDesc((const IdlNodeDesc) node); // deep copy
  _children_nodes[num_child] = node_tmp;
    
  pthread_mutex_unlock(&_children_mut);

    if ((trigger_activation) && (! _my_node->activated) && (_auto_activation == true))
      activate();
    else if ((trigger_deactivation) && (_my_node->activated))
      deactivate();

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;

}

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

CORBA::Boolean NodeServant::isActivated() throw (CorbaException) 
  
{
  COLCOWS_IN_DEBUG();

  COLCOWS_OUT_DEBUG();
  return _local_workspace->activated;
}

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

CORBA::Boolean NodeServant::isReady() throw (CorbaException) 
  
{
  COLCOWS_IN_DEBUG();

  COLCOWS_OUT_DEBUG();
  //! \todo return _ready insteed ...
  return _local_workspace->activated;
}

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

long NodeServant::indexConnection( CORBA::ULong num_connection )  
{
  COLCOWS_IN_DEBUG();

  long index = -1;  

  unsigned long num_ws;
  for (num_ws = 0; num_ws < _remote_workspaces->length(); num_ws++)
    {
      if ( num_connection = _remote_workspaces[num_ws].num_connection )
        {
          index = num_ws;
          break;
        }
    }   

  COLCOWS_OUT_DEBUG();
  return index;
}

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

CORBA::Boolean NodeServant::isConnected( CORBA::ULong num_connection ) throw (CorbaException) 
  
{
  COLCOWS_IN_DEBUG();

  COLCOWS_OUT_DEBUG();
  return (indexConnection(num_connection) != -1 );
}

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

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

  CORBA::ULong num_connection = NOT_CONNECTED;  

__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  unsigned long num_ws;
  for (num_ws = 0; num_ws < _remote_workspaces->length(); num_ws++)
    {
      if (   (strcmp(ws_id,_remote_workspaces[num_ws].ws_id) == 0) 
             && (strcmp(ws_kind,_remote_workspaces[num_ws].ws_kind) == 0))
        {
          num_connection = _remote_workspaces[num_ws].num_connection;
          break;
        }
    }   

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return num_connection;
}

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

void NodeServant::getCommonNumConnection( CORBA::ULong & num_connection ) throw (CorbaException) 
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  COLCOWS_ASSERT( ( _my_node->num_node == 0 ), "Only the proxy can assign a new number of connection" );

  if (_my_node->num_node == 0) {

    if ( num_connection <= _current_num_connection) {
      ++_current_num_connection; 
      num_connection = _current_num_connection;
      COLCOWS_DEBUG( dblAccessory, "num_connection = " << num_connection);
    }
    else {
      _current_num_connection = num_connection;
      COLCOWS_DEBUG( dblAccessory, "num_connection = " << num_connection);
    }
 
  }
  else {
    COLCOWS_DEBUG( dblWarning, "Should not call getNewNumConnection on a non-root node ..." );
    return;
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return;
}

//===========================================================================//
    
//! get the workspace description [public]
void NodeServant::getWorkspace(IdlWorkspaceDesc_out ws_desc) throw (CorbaException) 
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  COLCOWS_ASSERT((_local_workspace->activated ), "Node is not activated" );
 
  ws_desc = new IdlWorkspaceDesc((const IdlWorkspaceDesc)_local_workspace); //deep copy

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}

//===========================================================================//
    
//! set the workspace description [public]
void NodeServant::setWorkspace(const IdlWorkspaceDesc& ws_desc)
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  bool new_activation=false;
  bool new_deactivation=false;

  if ((! _local_workspace->activated) && (  ws_desc.activated))       { new_activation=true; }
  else if ((  _local_workspace->activated) && (! ws_desc.activated))  { new_deactivation=true; }
  else if ((! _local_workspace->activated) && (!  ws_desc.activated)) { }
  else // =>(( _local_workspace->activated) && ( ws_desc.activated))  
    { COLCOWS_ERROR( "Workspace already activated" ); }

  // register description
  _local_workspace = new IdlWorkspaceDesc((const IdlWorkspaceDesc) ws_desc); // deep copy


  // forward
  unsigned long nb_children = _children_nodes->length();
  for (unsigned long j = 0; j < nb_children; j++) {
    _children_nodes[j].node_ref->setWorkspace(ws_desc);
  }

  // execute appropriate treatment
  if ( new_activation == true )
    _colcows_node->onActivation( _local_workspace );
  else if ( new_deactivation == true )
    _colcows_node->onDeactivation( _local_workspace );

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}

//===========================================================================//
    
//! get the remote workspace description [public]
void NodeServant::getRemoteWorkspace(CORBA::ULong num_connection, IdlWorkspaceDesc_out ws_desc) throw (CorbaException)
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  bool is_local = false;

  unsigned long num_ws;
  for (num_ws = 0; num_ws < _remote_workspaces->length(); num_ws++)
    {
      if ( _remote_workspaces[num_ws].num_connection == num_connection )
        {
          ws_desc = new IdlWorkspaceDesc ((const IdlWorkspaceDesc)_remote_workspaces[num_ws]); // deep copy
          is_local = true;
          break;
        }
    }

  // if the description is here
  if (is_local == true) {
    // there is nothing more to do ...
  }
  else {
    COLCOWS_ERROR( "Remote Workspace is not connected." );
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}

//===========================================================================//
    
//! set the remote workspace description [public]
void NodeServant::setRemoteWorkspace( CORBA::ULong num_connection, 
                                      const IdlWorkspaceDesc& ws_desc,
                                      CORBA::Boolean connection_initiator)
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  unsigned long num_ws;
  for (num_ws = 0; num_ws < _remote_workspaces->length(); num_ws++)
    {
      if ( _remote_workspaces[num_ws].num_connection == num_connection )
        {
          break;
        }
    }

  COLCOWS_ASSERT( (num_ws == _remote_workspaces->length()), 
                  "The connection already exists." );

  _remote_workspaces->length(num_ws+1);

  IdlWorkspaceDesc_var new_ws_desc = new IdlWorkspaceDesc ((const IdlWorkspaceDesc) ws_desc); // deep copy
  new_ws_desc->num_connection = num_connection;
  _remote_workspaces[num_ws] = new_ws_desc;

  // send event "on Connection"
  _colcows_node->onConnection( num_connection, new_ws_desc, connection_initiator );

  unsigned long nb_children = _children_nodes->length();

  for (unsigned long j = 0; j < nb_children; j++) {
    _children_nodes[j].node_ref->setRemoteWorkspace(num_connection, new_ws_desc, connection_initiator);
  }

__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}
    
//===========================================================================//
    
//! set the remote workspace description [public]
void NodeServant::releaseRemoteWorkspace(CORBA::ULong num_connection )
{
  COLCOWS_IN_DEBUG();
__BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__

  unsigned long num_ws;
  unsigned long nb_ws =  _remote_workspaces->length();
  for (num_ws = 0; num_ws < nb_ws; num_ws++)
    {
      if ( _remote_workspaces[num_ws].num_connection == num_connection )
        {
          break;
        }
    }

  if (num_ws != nb_ws) {

    if (num_ws != nb_ws - 1) {
      // I don't think this operation need a deep copy ...
      _remote_workspaces[num_ws] = _remote_workspaces[nb_ws - 1];
    }

    _remote_workspaces->length(nb_ws-1);

    // send event "on disconnection"
    _colcows_node->onDisconnection( num_connection );

    unsigned long nb_children = _children_nodes->length();

    // forward to children 
    for (unsigned long j = 0; j < nb_children; j++) {
      _children_nodes[j].node_ref->releaseRemoteWorkspace(num_connection);
    }

  }
  else
    COLCOWS_ASSERT( dblWarning, "Cannot find connection ..." 
                    << "The connection " << num_connection << " may have been already disconnected." );


__END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__ 
  COLCOWS_OUT_DEBUG();
  return ;
}
    
//===========================================================================//

void NodeServant::printself(ostream & stream) const 
{
  stream << "IdlNodeDesc : "          << _my_node         << endl;
  stream << "IdlWorkspaceDesc : "     << _local_workspace   << endl;
  stream << "IdlWorkspaceDescSeq : "  << _remote_workspaces << endl;
}

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

ostream& operator <<(ostream& stream, const NodeServant & _this)
{
  stream << "Node {" << flush; 
  _this.printself(stream);
  stream << "}" << flush;
  return stream;
}

//! standard output stream operators
//===========================================================================//

std::ostream& operator <<(std::ostream& stream, const IdlWorkspaceDesc& wsdesc)
{
  stream << endl;
  stream << "( ws_id : "       << wsdesc.ws_id      << flush;
  stream << endl;
  stream << "( ws_kind : "     << wsdesc.ws_kind    << flush;
  stream << endl;
  stream << ", nb_nodes : "   << wsdesc.nb_nodes  << flush;
  stream << endl;
  stream << ", activated : "  << wsdesc.activated << flush;
  stream << endl;
  stream << ", enter_node_ref : " << "..."            << flush;
  stream << " )" << flush; 
  return stream;
}

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

std::ostream& operator <<(std::ostream& stream, const IdlWorkspaceDescSeq& wsdesc_seq)
{
  stream << "{" << flush;
  for (unsigned long i = 0; i < wsdesc_seq.length(); i++) {
    stream << endl;
    stream << " " << wsdesc_seq[i] << flush;   
  }
  stream << " }" << flush;
  return stream;
}

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

std::ostream& operator <<(std::ostream& stream, const IdlNodeDesc& wsnode)
{
  stream << endl << "(" << flush;
  stream << "  node_kind : "       << wsnode.node_kind      << flush;
  stream << endl;   
  stream << ", num_node : "  << wsnode.num_node << flush;
  stream << endl;
  stream << ", max_descendant : "  << wsnode.max_descendant << flush;
  stream << endl;
  stream << ", activated : "       << wsnode.activated      << flush;
  stream << endl;
  stream << ", node : "            << "..."                 << flush;
  stream << endl;
  stream << ", ref_seq : "         << wsnode.ref_seq        << flush;
  stream << " )" << flush; 
  return stream;
}

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

std::ostream& operator <<(std::ostream& stream, const IdlNodeDescSeq& wsnode_seq)
{
  stream << "{" << flush;
  for (unsigned long i = 0; i < wsnode_seq.length(); i++) {
    stream << endl;    
    stream << " " << wsnode_seq[i] << flush;   
  }
  stream << " }" << flush;
  return stream;
}

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

std::ostream& operator <<(std::ostream& stream, const IdlObjectDesc& ref)
{
  //  stream << "( num_node : " << ref.num_node << flush;
  stream << "( obj_id : "          << ref.obj_id          << flush;
  stream << ", obj_kind : "        << ref.obj_kind        << flush;
  stream << ", obj_ref : "         << "..."              << flush;
  stream << " )" << flush;   
  return stream;
}

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

std::ostream& operator <<(std::ostream& stream, const IdlObjectDescSeq& ref_seq)
{
   stream << "{" << flush;
  for (unsigned long i = 0; i < ref_seq.length(); i++)
    stream << " " << ref_seq[i] << flush;   
  stream << " }" << flush;
  return stream;
}

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

__COLCOWS_END__

// EOF

---