diff options
Diffstat (limited to 'modules/CIAO/DAnCE/Starter/Starter.cpp')
| -rw-r--r-- | modules/CIAO/DAnCE/Starter/Starter.cpp | 924 |
1 files changed, 924 insertions, 0 deletions
diff --git a/modules/CIAO/DAnCE/Starter/Starter.cpp b/modules/CIAO/DAnCE/Starter/Starter.cpp new file mode 100644 index 00000000000..81ecf1af650 --- /dev/null +++ b/modules/CIAO/DAnCE/Starter/Starter.cpp @@ -0,0 +1,924 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Starter.cpp + * + * $Id$ + * + * @Brief Dynamically runs libraries + * + * @author Vinzenz Tornow <vt@prismtech.com> + */ +//============================================================================= + +#include "Starter.h" +#include "ace/Service_Config.h" +#include "ace/Thread_Manager.h" +#include "ace/DLL.h" +#include "ace/Get_Opt.h" +#include "tao/ORB.h" +#include "tao/Object.h" +#include "tao/PortableServer/PortableServer.h" +#include "tao/Object_Loader.h" +#include "tao/IORTable/IORTable.h" +#include "DAnCE/Logger/Log_Macros.h" + +using namespace DAnCE; + +#ifdef DANCE_BUILD_STARTER_EXE + +int ACE_TMAIN (int argc, ACE_TCHAR * argv[]) +{ + try + { + Starter starter (argc, argv); + starter.execute(); + return 0; + } + catch (ACE_CString & e) + { + DANCE_ERROR ( (LM_ERROR, "[%M] dance starter failed with an exception : \"%s\"\n", e.c_str())); + } + catch (CORBA::Exception & e) + { + DANCE_ERROR ( (LM_ERROR, "[%M] dance starter failed with an CORBA exception : \"%s\"\n", e._info().c_str())); + } + catch (...) + { + DANCE_ERROR ( (LM_ERROR, "[%M] dance starter failed with an unknown exception.\n")); + } + return -1; +} + +#endif /* DANCE_BUILD_STARTER_EXE */ + +namespace DAnCE +{ + +Starter::Starter(int argc, ACE_TCHAR * argv[]) : + orb_(CORBA::ORB_init (argc, argv, "")), + optLogLevel_(5), //default + argc_(argc), + argv_(argv), + optNS_(false), + optEM_(false), + optPLB_(false), + optPL_(false) +{ + DANCE_TRACE ("DAnCE::Starter::Starter ()"); + + Logger_Service + * dlf = ACE_Dynamic_Service<Logger_Service>::instance ("DAnCE_Logger_Backend_Factory"); + + if (!dlf) + dlf = new Logger_Service; + + this->logger_.reset (dlf); + this->logger_->init (argc, argv); + + DANCE_DEBUG ((LM_TRACE, DLINFO + ACE_TEXT("Starter::Starter - Creating starter...\n"))); + + this->parseArgs(argc, argv); + + this->configure_logging_backend (); + + DANCE_DEBUG ((LM_TRACE, DLINFO + ACE_TEXT("Starter::Starter - Starter was created successfully.\n"))); +} + +Starter::~Starter() +{ + DANCE_TRACE ("Starter::~Starter"); +/* TAO_Object_Loader + * loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("ExecutionManager_Loader"); + if (0 != loader) + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starter::~Starter - removing EM ...\n")); + loader = 0; + ACE_Service_Config::remove ("ExecutionManager_Loader"); + } + loader + = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("NodeManager_Loader"); + if (0 != loader) + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starter::~Starter - removing NM ...\n")); + loader = 0; + ACE_Service_Config::remove ("NodeManager_Loader"); + } + + this->orb_._retn()->destroy(); */ +} + +void Starter::parseArgs(int argc, ACE_TCHAR * argv[]) +{ + DANCE_DEBUG ( (LM_TRACE, "[%M] Parsing starter's arguments...\n")); + + ACE_Get_Opt opts(argc, argv, "p::n:e::c::r::il:hg:x:d:qk:w:t:a:", 1, 0, + ACE_Get_Opt::RETURN_IN_ORDER); + opts.long_option(ACE_TEXT("process-ns"), 'p', ACE_Get_Opt::ARG_OPTIONAL); + opts.long_option(ACE_TEXT("process-ns-options"), ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("node-mgr"), 'n', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("exec-mgr"), 'e', ACE_Get_Opt::ARG_OPTIONAL); + opts.long_option(ACE_TEXT("create-plan-ns"), 'c', ACE_Get_Opt::ARG_OPTIONAL); + opts.long_option(ACE_TEXT("rebind-plan-ns"), 'r', ACE_Get_Opt::ARG_OPTIONAL); + opts.long_option(ACE_TEXT("port-indirection"), 'i', ACE_Get_Opt::NO_ARG); + opts.long_option(ACE_TEXT("log-level"), 'l', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("help"), 'h', ACE_Get_Opt::NO_ARG); + opts.long_option(ACE_TEXT("gen-object-key"), 'g', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("read-plan"), 'x', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("read-cdr-plan"), 'd', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("stop-plan"), 'q', ACE_Get_Opt::NO_ARG); + opts.long_option(ACE_TEXT("em-ior"), 'k', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("write-cdr-plan"), 'w', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("plan-uuid"), 't', ACE_Get_Opt::ARG_REQUIRED); + opts.long_option(ACE_TEXT("dam-ior"), 'a', ACE_Get_Opt::ARG_REQUIRED); + + int j; + char c; + ACE_TString s; + while ( (c = opts ()) != -1) + { + DANCE_DEBUG((LM_TRACE, "[%M] Option : \"%s\" with argument \"%s\"\n", opts.last_option(), opts.opt_arg())); + switch (c) + { + case '?': + DANCE_ERROR ( (LM_ERROR, "[%M] Wrong option \"%s\" or this option is requred attribute!\n", opts.last_option())); + this->usage(); + throw ACE_CString("Error parsing starter arguments"); + break; + case 'p': + this->optNS_ = true; + DANCE_DEBUG ( (LM_TRACE, "[%M] Naming will be started.\n")); + this->optNSFile_ = opts.opt_arg(); + break; + case 'n': + s = opts.opt_arg(); + if (0 < s.length()) + { + ACE_CString nodename; + Node node; + size_t const pos = s.find(ACE_TEXT ("=")); + if (ACE_CString::npos != pos) + { + nodename = s.substring(0, pos); + node.ior_ = s.substring(pos + 1); + /* + node.obj = this->orb_->string_to_object(objstr.c_str()); + if (CORBA::is_nil (node.obj)) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed create object for node \"%s\"\n", nodename.c_str())); + throw ACE_CString ("Invalid IOR in --node-mgr option"); + } + */ + } + else + { + nodename = s; + DANCE_DEBUG ( (LM_TRACE, "[%M] Node \"%s\" will be started.\n", nodename.c_str())); + if (opts.optind < opts.argc_&& '-' != (s = opts.argv_[opts.optind])[0]) + { + ++opts.optind; + node.iorfile_ = s; + DANCE_DEBUG ( (LM_TRACE, "[%M] and its IOR will be written to file \"%C\".\n", node.iorfile_.c_str())); + } + + } + if (0 == this->nodes_.find(nodename)) + { + DANCE_ERROR((LM_ERROR, "[%M] Duplication of NM name \"%s\"\n", nodename.c_str())); + this->usage(); + throw ACE_CString("Duplication of NM name"); + } + this->nodes_.bind(nodename, node); + } + else + { + DANCE_ERROR ( (LM_ERROR, "[%M] --node-mgr option without arguments.\n")); + this->usage(); + throw ACE_CString ("--node-mgr option without arguments."); + } + break; + case 'e': + if (this->optEM_) + { + DANCE_DEBUG((LM_WARNING, "[%M] ExecutionManager option is encountered more than once. Second and following ignored.\n")); + break; + } + this->optEM_ = true; + DANCE_DEBUG ( (LM_TRACE, "[%M] ExecutionManager will be started.\n")); + this->optEMFile_ = opts.opt_arg(); + break; + case 'l': + j = ACE_OS::atoi (opts.opt_arg()); + if (j != 0) + { + this->optLogLevel_ = j; + } + else + { + DANCE_ERROR ( (LM_WARNING, "--log-level without argument. Using default.\n")); + } + break; + case 'h': + this->usage(); + break; + case 'x': + this->optPL_ = true; + DANCE_DEBUG ( (LM_TRACE, "[%M] PlanLauncher will be started.\n")); + break; + case 'd': + case 'q': + this->optPLB_ = true; + DANCE_DEBUG ( (LM_TRACE, "[%M] PlanLauncherBase will be started.\n")); + break; + case 'g': + DANCE_DEBUG ( (LM_TRACE, "[%M] Object key will be generated.\n")); + this->optGenObjKey_ = opts.opt_arg(); + if (0 == this->optGenObjKey_.length()) + { + DANCE_ERROR ( (LM_ERROR, "[%M] --gen-object-key without argument. Doing nothing.\n")); + } + break; + case 0: // long options that do not have short + s = opts.last_option(); + if (s == "process-ns-options") + { + this->optNSOptions_ = opts.opt_arg(); + if (0 == this->optNSOptions_.length()) + { + DANCE_ERROR ( (LM_ERROR, "[%M] --process-ns-options without argument\n")); + } + } + else + { + if (!isPossibleOption(s.c_str())) + { + DANCE_ERROR((LM_ERROR, "[%M] Invalid option : %s\n", s.c_str())); + } + } + break; + default: + if (!isPossibleOption(opts.last_option())) + { + DANCE_ERROR((LM_ERROR, "[%M] Invalid option : %s\n", opts.last_option())); + this->usage(); + } + break; + }//switch + }//while + + DANCE_DEBUG ( (LM_TRACE, "[%M] Parsing starter's arguments completed.\n")); +} + +void Starter::execute() +{ + DANCE_DEBUG ( (LM_TRACE, "[%M] Executing starter...\n")); + bool orb_run = false; + + // Generate object key + if (0 < this->optGenObjKey_.length()) + { + this->generateObjectKey(this->optGenObjKey_.c_str()); + } + + // Naming + if (this->optNS_) + { + this->initNaming(); + orb_run = true; + } + + // NodeManagers + for (ACE_Map_Manager<ACE_CString, Node, ACE_Null_Mutex>::iterator + it = this->nodes_.begin(); it != this->nodes_.end(); ++it) + { + if (!CORBA::is_nil ((*it).int_id_.obj) || 0 < (*it).int_id_.ior_.length()) + continue; + orb_run = true; + (*it).int_id_.obj = this->initNodeManager((*it).ext_id_.c_str()); + if (0 != (*it).int_id_.iorfile_.length()) + { + this->write_IOR((*it).int_id_.iorfile_.c_str(), this->orb_->object_to_string((*it).int_id_.obj)); + } + } + + // ExecutionManager + CORBA::Object_var em; + if (this->optEM_) + { + em = this->initExecutionManager(); + if ( !CORBA::is_nil(em) && 0 < this->optEMFile_.length()) + { + this->write_IOR(this->optEMFile_.c_str(), + this->orb_->object_to_string(em.in())); + } + orb_run = true; + } + + if (this->optPLB_ || this->optPL_) + { + this->runPlanLauncher(); + } + + if (orb_run) + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Running starter's ORB...\n")); + this->orb_->run(); + } + else + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Skipping starter's ORB->run.\n")); + } + DANCE_DEBUG ( (LM_TRACE, "[%M] Executing starter has completed.\n")); +} + +void Starter::usage() +{ + DANCE_ERROR ( (LM_EMERGENCY, "Usage : dance <options>\n" + "Options :\n" + "\t-l|--log-level <log level> - sets log level (default 5). 1 - most detailed.\n" + "\t-g|--gen-object-key \"<NODE_NAME> <PLAN_ID> <COMPONENT_ID> [<PORT_NAME>]\" - generates a corbaloc URL\n" + "\t-h|--help - shows this help\n" + "\t-p|--process-ns [IOR_FILE_NAME] - Instantiate a local name service within the DAnCE process. Export the root context to IOR_FILE if any.\n" + "\t--process-ns-options <options> - Specifies quoted string of options to be passed to name service. Depends on --process-ns option.\n" + "\t-e|--exec-mgr [IOR_FILE_NAME] - This process will have an execution manager and it's IOR will optionally be exported to IOR_FILE_NAME.\n" + "\t-n|--node-mgr name [IOR_FILE_NAME] - Create a named NodeManager in process and optionally export its IOR to IOR_FILE_NAME\n" + "\t-n|--node-mgr name=<IOR> - Place the NodeManager instance whose reference is IOR under the control of the ExecutionManager in this process (requires --exec-mgr).\n" + "In addition to the options above, the Service Configurator options are processed too.\n")); +} + +void Starter::generateObjectKey(const char * keyargs) +{ + ACE_CString args = keyargs; + ssize_t pos_start = 0; + ACE_CString node; + ACE_CString plan; + ACE_CString component; + ACE_CString port; + + // node + if (pos_start < (ssize_t) args.length()) + { + size_t pos_end = args.find(' ', pos_start); + if (ACE_CString::npos == pos_end) + { + node = args.substring(pos_start); + pos_start = args.length(); + } + else + { + node = args.substring(pos_start, pos_end - pos_start); + pos_start = pos_end + 1; + } + } + + // plan + if (pos_start < (ssize_t) args.length()) + { + size_t pos_end = args.find(' ', pos_start); + if (ACE_CString::npos == pos_end) + { + plan = args.substring(pos_start); + pos_start = args.length(); + } + else + { + plan = args.substring(pos_start, pos_end - pos_start); + pos_start = pos_end + 1; + } + } + + // component + if (pos_start < (ssize_t) args.length()) + { + size_t pos_end = args.find(' ', pos_start); + if (ACE_CString::npos == pos_end) + { + component = args.substring(pos_start); + pos_start = args.length(); + } + else + { + component = args.substring(pos_start, pos_end - pos_start); + pos_start = pos_end + 1; + } + } + + // port + if (pos_start < (ssize_t) args.length()) + { + size_t pos_end = args.find(' ', pos_start); + if (ACE_CString::npos == pos_end) + { + port = args.substring(pos_start); + pos_start = args.length(); + } + else + { + port = args.substring(pos_start, pos_end - pos_start); + pos_start = pos_end + 1; + } + } + + // check + if (0 == node.length() || 0 == plan.length() || 0 == component.length()) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Invalid object attributes received : \"s\"\n", args.c_str())); + this->usage(); + return; + } + + this->generateObjectKey(node.c_str(), plan.c_str(), component.c_str(), 0 + == port.length() ? 0 : port.c_str()); +} + +void Starter::generateObjectKey(const char * node, const char * plan, + const char * component, const char * port) +{ + DANCE_DEBUG ( (LM_TRACE, "[%M] Starter::generateObjectKey starting...\n")); + CORBA::Boolean prev_format = this->orb_->_use_omg_ior_format(); + this->orb_->_use_omg_ior_format(false); + // warning : parent POA supposed to be RootPOA + CORBA::Object_var obj = this->orb_->resolve_initial_references("RootPOA"); + PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in()); + + CORBA::PolicyList policies(4); + policies.length(4); + policies[0]= root_poa->create_id_assignment_policy(PortableServer::USER_ID); + policies[1] + = root_poa->create_request_processing_policy(PortableServer::USE_SERVANT_MANAGER); + policies[2] + = root_poa->create_servant_retention_policy(PortableServer::NON_RETAIN); + policies[3] = root_poa->create_lifespan_policy(PortableServer::PERSISTENT); + PortableServer::POAManager_var mgr = root_poa->the_POAManager(); + PortableServer::POA_var + myPOA = root_poa->create_POA(node, mgr.in(), policies); + for (size_t i = 0; i < policies.length(); ++i) + { + policies[i]->destroy(); + } + + const char delim = '/'; + + ACE_CString s = plan; + s += delim; + s += component; + if (0 != port) + { + s += delim; + s += port; + } + + PortableServer::ObjectId_var + oid = PortableServer::string_to_ObjectId (s.c_str()); + CORBA::Object_var o = myPOA->create_reference_with_id(oid.in(), + "IDL:omg.org/CORBA/Object:1.0"); + s = this->orb_->object_to_string(o); + size_t pos = s.find(delim); + if (ACE_CString::npos != pos) + { + s = s.substr(pos + 1); + } + else + { + DANCE_ERROR ( (LM_WARNING, "Failed to cut off the host specific part of URL.\n")); + } + DANCE_DEBUG ( (LM_TRACE, "[%M] Starter::generateObjectKey printing result : %s\n", s.c_str())); + ACE_OS::printf ("%s\n", s.c_str()); + + this->orb_->_use_omg_ior_format(prev_format); + DANCE_DEBUG ( (LM_TRACE, "[%M] Starter::generateObjectKey completed.\n")); +} + +void Starter::write_IOR(const ACE_TCHAR * ior_file_name, const char* ior) +{ + FILE* ior_output_file_ = ACE_OS::fopen (ior_file_name, "w"); + + if (ior_output_file_) + { + ACE_OS::fprintf (ior_output_file_, "%s", ior); + ACE_OS::fclose (ior_output_file_); + DANCE_DEBUG ( (LM_DEBUG, "[%M] ior was written into file \"%s\"\n", ior_file_name)); + } + else + { + DANCE_ERROR ( (LM_ERROR, "[%M] Unable to open IOR output file %s : %m\n", + ior_file_name)); + } +} + +void Starter::initNaming() +{ + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting naming...\n")); + TAO_Object_Loader + * loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("Naming_Loader"); + if (0 == loader) + { + ACE_CString directive = + "dynamic Naming_Loader Service_Object * TAO_CosNaming_Serv:_make_TAO_Naming_Loader() \""; + directive += this->optNSOptions_ + "\""; + ACE_Service_Config::process_directive(directive.c_str()); + } + + DANCE_DEBUG ( (LM_TRACE, "[%M] Putting ior to file if necessary...\n")); + if (0 < this->optNSFile_.length()) + { + CORBA::Object_var obj = this->orb_->resolve_initial_references("NameService"); + if (CORBA::is_nil(obj)) + { + DANCE_ERROR((LM_ERROR, "[%M] Failed to rir \"NameService\" after creation to write it to file.\n")); + } + else + { + this->write_IOR(this->optNSFile_.c_str(), this->orb_->object_to_string(obj)); + } + } + +/* CORBA::Object_var table_object = this->orb_->resolve_initial_references ("IORTable"); + IORTable::Table_var table = IORTable::Table::_narrow (table_object.in ()); + if (CORBA::is_nil (table.in())) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to register Naming in IORTable.Nil IORTable\n")); + return; + } + try + { + table->bind ("NameService", this->orb_->object_to_string (this->process_naming_)); + } + catch (...) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to register Naming in IORTable with \"NameService\". Exception is caught.\n")); + }*/ + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting naming completed.\n")); + } + +CORBA::Object_ptr +Starter::initNodeManager (const char * node) + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting NodeManager \"%s\"...\n", node)); + TAO_Object_Loader * loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("NodeManager_Loader"); + if (0 == loader) + { + ACE_Service_Config::process_directive (ACE_DYNAMIC_SERVICE_DIRECTIVE ("NodeManager_Loader", + "DAnCE_NodeManager", + "_make_DAnCE_NodeManager_Module", + "")); + loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("NodeManager_Loader"); + } + if (0 == loader) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to load node manager \"%s\".\n", node)); + throw ACE_CString ("Failed to load NodeManager."); + } + int c = 0; + ACE_TCHAR ** v = 0; + this->argCopyForNode (node, c, v); + CORBA::Object_var res = loader->create_object (this->orb_, c, v); + this->releaseArgs (c, v); + if (CORBA::is_nil(res.in())) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to create node manager \"%s\".\n", node)); + throw ACE_CString ("Failed to create NodeManager."); + } + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting NodeManager \"%s\" completed.\n", node)); + return res._retn(); + } + +CORBA::Object_ptr +Starter::initExecutionManager() + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting ExecutionManager...\n")); + ACE_Service_Config::process_directive ( + ACE_DYNAMIC_SERVICE_DIRECTIVE ("ExecutionManager_Loader" + , "DAnCE_ExecutionManager" + , "_make_DAnCE_ExecutionManager_Module" + , "")); + TAO_Object_Loader * loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("ExecutionManager_Loader"); + if (0 == loader) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to load execution manager .\n")); + throw ACE_CString ("Failed to load ExecutionManager."); + } + int c = 0; + ACE_TCHAR ** v = 0; + this->argCopyForEM (c, v); + CORBA::Object_var em = loader->create_object (this->orb_, c, v); + this->releaseArgs (c, v); + if (CORBA::is_nil(em.in())) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to create execution manager.\n")); + throw ACE_CString ("Failed to create ExecutionManager."); + } + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting ExecutionManager completed.\n")); + return em._retn(); + } + +void +Starter::runPlanLauncher() + { + if (this->optPL_) + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting PlanLauncher...\n")); + ACE_Service_Config::process_directive ( + ACE_DYNAMIC_SERVICE_DIRECTIVE ("PlanLauncher_Loader" + , "DAnCE_Plan_Launcher" + , "_make_DAnCE_Plan_Launcher_Module" + , "")); + } + else + { + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting PlanLauncherBase...\n")); + ACE_Service_Config::process_directive ( + ACE_DYNAMIC_SERVICE_DIRECTIVE ("PlanLauncher_Loader" + , "DAnCE_Plan_Launcher_Base" + , "_make_DAnCE_Plan_Launcher_Base_Module" + , "")); + } + TAO_Object_Loader * loader = ACE_Dynamic_Service<TAO_Object_Loader>::instance ("PlanLauncher_Loader"); + if (0 == loader) + { + DANCE_ERROR ( (LM_ERROR, "[%M] Failed to load plan launcher.\n")); + throw ACE_CString ("Failed to load PlanLauncher."); + } + int c = 0; + ACE_TCHAR ** v = 0; + this->argCopyForPL (c, v); + loader->create_object (this->orb_, c, v); + this->releaseArgs (c, v); + DANCE_DEBUG ( (LM_TRACE, "[%M] Starting PlanLauncher(Base) completed.\n")); + } + +void +Starter::argCopyForNaming (int & c, char **& v) + { + int total_sz = 2; + for (size_t pos = this->optNSOptions_.find (' '); + ACE_CString::npos != pos; + pos = this->optNSOptions_.find (' ', pos + 1)) + { + ++total_sz; + } + v = new char*[total_sz]; + c = 0; + //take the 0-th argument anyway + v[c++] = CORBA::string_dup (this->argv_[0]); + + for (int i = 1; i < total_sz; ++i) v[i] = 0; + + ssize_t p0 = 0; + + for (ssize_t p1 = this->optNSOptions_.find (' '); + (size_t) p0 < this->optNSOptions_.length(); + p1 = this->optNSOptions_.find (' ', p0)) + { + if (p1 == p0) + { + p0 = p1 + 1; + continue; + } + v[c++] = CORBA::string_dup (this->optNSOptions_.substring (p0, p1 - p0).c_str()); + p0 = p1 + 1; + } + } + +void +Starter::argCopyForNode (const char * node, int & c, char **& v) + { + const char * validOptions[] = + { //"--node-mgr", "-n" + "--process-ns", "-p" + , "--create-plan-ns", "-c" + , "--rebind-plan-ns", "-r" + , "--port-indirection", "-i" + , 0 + }; + + int total_sz = this->argc_ + 1; + v = new char*[total_sz]; + for (int i = 0; i < total_sz; ++i) v[i] = 0; + + c = 0; + v[c++] = CORBA::string_dup ("-n"); + v[c++] = CORBA::string_dup (node); + Node n; + if (0 == this->nodes_.find(node, n) && 0 < n.iorfile_.length()) + { + v[c++] = CORBA::string_dup (n.iorfile_.c_str()); + } + + bool take = false; + for (int i = 0; i < this->argc_; ++i) + { + if ('-' == this->argv_[i][0]) + { + take = false; + for (int j = 0; 0 != validOptions[j]; ++j) + { + if (this->argv_[i] == ACE_OS::strstr (this->argv_[i], validOptions[j])) + { + if (i + 1 < this->argc_ + && (0 == ACE_OS::strcmp (this->argv_[i], ACE_TEXT("--node-mgr")) || 0 == ACE_OS::strcmp (this->argv_[i], ACE_TEXT("-n")))) + { + ACE_CString s = this->argv_[i+1]; + if (ACE_CString::npos != s.find ('=')) + { + break; + } + else if (s == node) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + take = true; + break; + } + } + else + { + v[c++] = CORBA::string_dup (this->argv_[i]); + take = true; + break; + } + } + } + } + else if (take) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + } + } + v[c] = 0; + } + +void +Starter::argCopyForEM (int & c, char **& v) + { + const char * validOptions[] = + { + //"--node-mgr", "-n" + "--exec-mgr", "-e" + , "--process-ns", "-p" + , "--create-plan-ns", "-c" + , "--rebind-plan-ns", "-r" + , "--port-indirection", "-i" + , 0 + }; + + int total_sz = this->argc_ + 2 * this->nodes_.total_size() + 1; + v = new char*[total_sz]; + for (int i = 0; i < total_sz; ++i) v[i] = 0; + + bool take = false; + c = 0; + for (int i = 0; i < this->argc_; ++i) + { + if ('-' == this->argv_[i][0]) + { + take = false; + for (int j = 0; 0 != validOptions[j]; ++j) + { + if (this->argv_[i] == ACE_OS::strstr (this->argv_[i], validOptions[j])) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + take = true; + break; + } + } + } + else if (take) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + } + } + + for (ACE_Map_Manager<ACE_CString, Node, ACE_Null_Mutex>::iterator it = this->nodes_.begin(); + it != this->nodes_.end(); + ++it) + { + //v[c++] = CORBA::string_dup("--node-mgr"); + v[c++] = CORBA::string_dup ("-n"); + ACE_CString s = (*it).ext_id_; + s += "="; + if ( 0 < (*it).int_id_.ior_.length() ) + { + s += (*it).int_id_.ior_; + } + else if (!CORBA::is_nil((*it).int_id_.obj.in())) + { + s += this->orb_->object_to_string ( (*it).int_id_.obj.in()); + } + else + { + DANCE_ERROR((LM_ERROR, "[%M] No IOR for node \"%s\"\n", (*it).ext_id_.c_str())); + continue; + } + v[c++] = CORBA::string_dup (s.c_str()); + } + + v[c] = 0; + } + +void +Starter::argCopyForPL (int & c, char **& v) + { + const char * validOptions[] = + { "--em-ior", "-k" + , "--read-plan", "-x" + , "--read-cdr-plan", "-d" + , "--write-cdr-plan", "-w" + , "--plan-uuid", "-t" + , "--dam-ior", "-a" + , "--stop-plan", "-q" + , 0 + }; + + int total_sz = this->argc_ + 1; + v = new char*[total_sz]; + for (int i = 0; i < total_sz; ++i) v[i] = 0; + + bool take = false; + c = 0; + for (int i = 0; i < this->argc_; ++i) + { + if ('-' == this->argv_[i][0]) + { + take = false; + for (int j = 0; 0 != validOptions[j]; ++j) + { + if (this->argv_[i] == ACE_OS::strstr (this->argv_[i], validOptions[j])) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + take = true; + break; + } + } + } + else if (take) + { + v[c++] = CORBA::string_dup (this->argv_[i]); + } + } + v[c] = 0; + } + +void +Starter::releaseArgs (int c, char ** v) + { + for (int i = 0; i < c && 0 != v[i]; ++i) + { + CORBA::string_free (v[i]); + v[i] = 0; + } + delete [] v; + } + +bool +Starter::isPossibleOption(const char* opt) +{ + const char * validOptions[] = + { "node-mgr", "n" + , "exec-mgr", "e" + , "process-ns", "p" + , "create-plan-ns", "c" + , "rebind-plan-ns", "r" + , "port-indirection", "i" + , "gen-object-key", "g" + , "log-level", "l" + , "em-ior", "k" + , "read-plan", "x" + , "read-cdr-plan", "d" + , "write-cdr-plan", "w" + , "plan-uuid", "t" + , "dam-ior", "a" + , "stop-plan", "q" + , 0 + }; + + ACE_CString option = opt; + for (int i = 0; 0 != validOptions[i]; ++i) + { + if ( option == validOptions[i]) return true; + } + return false; +} + +void +Starter::configure_logging_backend (void) +{ + Logger_Service + *clf = ACE_Dynamic_Service<Logger_Service>::instance ("DAnCE_Logger_Backend_Factory"); + if (clf) + { + DANCE_DEBUG ((LM_TRACE, DLINFO "Starter::configure_logging_backend - " + "Replacing logger backend\n")); + ACE_Log_Msg_Backend * backend = clf->get_logger_backend(this->orb_); + backend->open(0); + ACE_Log_Msg::msg_backend (backend); + ACE_Log_Msg * ace = ACE_Log_Msg::instance(); + ace->clr_flags(ace->flags()); + ace->set_flags(ACE_Log_Msg::CUSTOM); + } +} + +} // DAnCE + |