src/SALOMESDS/SALOMESDS_DataServerManager.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony GEAY (EDF R&D)
  20
  21 #include "SALOMESDS_DataServerManager.hxx"
  22 #include "SALOMESDS_Exception.hxx"
  23
  24 #include "SALOME_ContainerManager.hxx"
  25 #include "SALOME_NamingService.hxx"
  26
  27 #include <sstream>
  28 #include <algorithm>
  29
  30 using namespace SALOMESDS;
  31
  32 const char DataServerManager::NAME_IN_NS[]="/DataServerManager";
  33
  34 const char DataServerManager::DFT_SCOPE_NAME_IN_NS[]="Default";
  35
  36 DataServerManager::DataServerManager(int argc, char *argv[], CORBA::ORB_ptr orb, PortableServer::POA_ptr poa):_orb(CORBA::ORB::_duplicate(orb))
  37 {
  38   DataScopeServer *dftScope(new DataScopeServer(orb,DFT_SCOPE_NAME_IN_NS));//_remove_ref will be call by DataScopeServer::shutdownIfNotHostedByDSM
  39   PortableServer::POAManager_var pman(poa->the_POAManager());
  40   CORBA::PolicyList policies;
  41   policies.length(1);
  42   PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
  43   policies[0]=PortableServer::ThreadPolicy::_duplicate(threadPol);
  44   _poa=poa->create_POA("SingleThPOA4SDS",pman,policies);
  45   threadPol->destroy();
  46   //
  47   dftScope->initializePython(argc,argv);// agy : Very important ! invoke this method BEFORE activation !
  48   // activate this to be ready to be usable from NS.
  49   PortableServer::ObjectId_var id(_poa->activate_object(this));
  50   CORBA::Object_var obj(_poa->id_to_reference(id));
  51   SALOME::DataServerManager_var obj2(SALOME::DataServerManager::_narrow(obj));
  52   // publish Data server manager in NS
  53   SALOME_NamingService ns(orb);
  54   ns.Register(obj2,NAME_IN_NS);
  55   // the default DataScopeServer object is the only one hosted by the current process
  56   id=_poa->activate_object(dftScope);
  57   obj=_poa->id_to_reference(id);
  58   SALOME::DataScopeServer_var dftScopePtr(SALOME::DataScopeServer::_narrow(obj));
  59   dftScope->setPOAAndRegister(_poa,dftScopePtr);// agy : Very important ! invoke this method BEFORE activation ! Because this method initializes Python !
  60 }
  61
  62 SALOME::StringVec *DataServerManager::listScopes()
  63 {
  64   std::vector<std::string> scopes(listOfScopesCpp());
  65   SALOME::StringVec *ret(new SALOME::StringVec);
  66   std::size_t sz(scopes.size());
  67   ret->length(sz);
  68   for(std::size_t i=0;i<sz;i++)
  69     (*ret)[i]=CORBA::string_dup(scopes[i].c_str());
  70   return ret;
  71 }
  72
  73 SALOME::StringVec *DataServerManager::listAliveAndKickingScopes()
  74 {
  75   std::vector<std::string> scopes(listOfScopesCpp());
  76   std::size_t sz(scopes.size());
  77   std::vector<std::string> retCpp; retCpp.reserve(sz);
  78   for(std::size_t i=0;i<sz;i++)
  79     {
  80       if(isAliveAndKicking(scopes[i].c_str()))
  81         retCpp.push_back(scopes[i]);
  82     }
  83   //
  84   SALOME::StringVec *ret(new SALOME::StringVec);
  85   sz=retCpp.size();
  86   ret->length(sz);
  87   for(std::size_t i=0;i<sz;i++)
  88     (*ret)[i]=CORBA::string_dup(retCpp[i].c_str());
  89   return ret;
  90 }
  91
  92 SALOME::DataScopeServer_ptr DataServerManager::getDefaultScope()
  93 {
  94   return retriveDataScope(DFT_SCOPE_NAME_IN_NS);
  95 }
  96
  97 CORBA::Boolean DataServerManager::isAliveAndKicking(const char *scopeName)
  98 {
  99   SALOME::DataScopeServer_var scopePtr(getScopePtrGivenName(scopeName));
 100   CORBA::Boolean ret(true);
 101   try
 102     {
 103       scopePtr->ping();
 104     }
 105   catch(...)
 106     { ret=false; }
 107   return ret;
 108 }
 109
 110 SALOME::DataScopeServer_ptr DataServerManager::createDataScope(const char *scopeName)
 111 {
 112   std::string scopeNameCpp(scopeName);
 113   std::vector<std::string> scopes(listOfScopesCpp());
 114   if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)!=scopes.end())
 115     {
 116       std::ostringstream oss; oss << "DataServerManager::createDataScope : scope name \"" << scopeName << "\" already exists !";
 117       throw Exception(oss.str());
 118     }
 119   //
 120   SALOME_NamingService ns(_orb);
 121   std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
 122   std::ostringstream oss; oss << "SALOME_DataScopeServer" << " " << scopeName << " ";
 123   SALOME_ContainerManager::AddOmninamesParams(oss,&ns);
 124   std::string command(oss.str());
 125   SALOME_ContainerManager::MakeTheCommandToBeLaunchedASync(command);
 126   int status(SALOME_ContainerManager::SystemThreadSafe(command.c_str()));
 127   int count(SALOME_ContainerManager::GetTimeOutToLoaunchServer());
 128   SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_nil());
 129   while (CORBA::is_nil(ret) && count)
 130     {
 131       SALOME_ContainerManager::SleepInSecond(1);
 132       count--;
 133       CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
 134       ret=SALOME::DataScopeServer::_narrow(obj);
 135     }
 136   return SALOME::DataScopeServer::_duplicate(ret);
 137 }
 138
 139 SALOME::DataScopeServer_ptr DataServerManager::giveADataScopeCalled(const char *scopeName, CORBA::Boolean& isCreated)
 140 {
 141   std::string scopeNameCpp(scopeName);
 142   std::vector<std::string> scopes(listOfScopesCpp());
 143   if(std::find(scopes.begin(),scopes.end(),scopeNameCpp)==scopes.end())
 144     {
 145       isCreated=true;
 146       return createDataScope(scopeName);
 147     }
 148   else
 149     {
 150       if(isAliveAndKicking(scopeName))
 151         {
 152           isCreated=false;
 153           return retriveDataScope(scopeName);
 154         }
 155       else
 156         {
 157           SALOME_NamingService ns(_orb);
 158           std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(scopeNameCpp));
 159           ns.Destroy_Name(fullScopeName.c_str());
 160           isCreated=true;
 161           return createDataScope(scopeName);
 162         }
 163     }
 164 }
 165
 166 SALOME::DataScopeServer_ptr DataServerManager::retriveDataScope(const char *scopeName)
 167 {
 168   SALOME::DataScopeServer_var ret(getScopePtrGivenName(scopeName));
 169   return SALOME::DataScopeServer::_duplicate(ret);
 170 }
 171
 172 void DataServerManager::removeDataScope(const char *scopeName)
 173 {
 174   SALOME::DataScopeServer_var scs(getScopePtrGivenName(scopeName));
 175   scs->shutdownIfNotHostedByDSM();
 176 }
 177
 178 void DataServerManager::cleanScopesInNS()
 179 {
 180   SALOME_NamingService ns(_orb);
 181   std::vector<std::string> scopes(listOfScopesCpp());
 182   for(std::vector<std::string>::const_iterator it=scopes.begin();it!=scopes.end();it++)
 183     {
 184       if(!isAliveAndKicking((*it).c_str()))
 185         {
 186           std::string fullScopeName(SALOMESDS::DataServerManager::CreateAbsNameInNSFromScopeName(*it));
 187           ns.Destroy_Name(fullScopeName.c_str());
 188         }
 189     }
 190 }
 191
 192 void DataServerManager::shutdownScopes()
 193 {
 194   std::vector<std::string> scopeNames(listOfScopesCpp());
 195   for(std::vector<std::string>::const_iterator it=scopeNames.begin();it!=scopeNames.end();it++)
 196     getScopePtrGivenName(*it)->shutdownIfNotHostedByDSM();
 197 }
 198
 199 std::string DataServerManager::CreateAbsNameInNSFromScopeName(const std::string& scopeName)
 200 {
 201   std::ostringstream oss; oss << NAME_IN_NS << "/" << scopeName;
 202   return oss.str();
 203 }
 204
 205 std::vector<std::string> DataServerManager::listOfScopesCpp()
 206 {
 207   SALOME_NamingService ns(_orb);
 208   ns.Change_Directory(NAME_IN_NS);
 209   std::vector<std::string> ret(ns.list_directory());
 210   return ret;
 211 }
 212
 213 SALOME::DataScopeServer_var DataServerManager::getScopePtrGivenName(const std::string& scopeName)
 214 {
 215   std::vector<std::string> scopes(listOfScopesCpp());
 216   std::size_t sz(scopes.size());
 217   if(std::find(scopes.begin(),scopes.end(),scopeName)==scopes.end())
 218     {
 219       std::ostringstream oss; oss << "DataServerManager::getScopePtrGivenName : scope name \"" << scopeName << "\" does not exist !";
 220       throw Exception(oss.str());
 221     }
 222   SALOME_NamingService ns(_orb);
 223   std::string fullScopeName(CreateAbsNameInNSFromScopeName(scopeName));
 224   CORBA::Object_var obj(ns.Resolve(fullScopeName.c_str()));
 225   SALOME::DataScopeServer_var ret(SALOME::DataScopeServer::_narrow(obj));
 226   return ret;
 227 }