NodeManager_Impl::~NodeManager_Impl() { DANCE_TRACE ("NodeManager_Impl::~NodeManager_Impl()"); for (TManagers::iterator iter = this->managers_.begin(); iter != this->managers_.end(); ++iter) { try { PortableServer::ObjectId_var id = this->poa_->servant_to_id ( (*iter).int_id_); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::~NodeManager_impl - Deactivating NodeApplicationManager %C\n"), (*iter).ext_id_.c_str ())); this->poa_->deactivate_object (id.in()); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::~NodeManager_impl - deleting NodeApplicationManager\n"))); delete (*iter).int_id_; DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_DEBUG, DLINFO ACE_TEXT("NodeManager_impl::~NodeManager_impl - NodeApplicationManager deleted\n"))); } catch (...) { DANCE_ERROR (DANCE_LOG_NONFATAL_ERROR, (LM_WARNING, DLINFO ACE_TEXT("NodeManager_impl::~NodeManager_impl - Caught exception while removing ") ACE_TEXT("NodeApplicationManager %C\n"), (*iter).ext_id_.c_str ())); } } PLUGIN_MANAGER::close (); }
void NodeManager_Impl::destroyManager (::Deployment::NodeApplicationManager_ptr appManager) { DANCE_TRACE ("NodeManager_Impl::destroyManager"); for (TManagers::iterator iter = this->managers_.begin(); iter != this->managers_.end(); ++iter) { if (appManager->_is_equivalent (this->poa_->servant_to_reference ( (*iter).int_id_))) { PortableServer::ObjectId_var id = this->poa_->reference_to_id (appManager); this->poa_->deactivate_object (id.in()); DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::destroyManager - deleting NodeApplicationManager\n"))); delete (*iter).int_id_; DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::destroyManager - NodeApplicationManager deleted\n"))); this->managers_.unbind ( (*iter).ext_id_); DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::destroyManager - finished\n"))); return; } } DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("NodeManager_impl::destroyManager - ") ACE_TEXT("correponding NodeApplicationManager cannot be found\n"))); throw ::Deployment::InvalidReference(); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { DANCE_DISABLE_TRACE (); int retval = 0; try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); DAnCE::Logger_Service * dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger"); if (dlf) { dlf->init (argc, argv); } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager - initializing module instance\n"))); DAnCE_NodeManager_Module nm; CORBA::Object_var obj = nm.init (orb.in (), argc, argv); if (!CORBA::is_nil (obj.in ())) { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager - running ORB\n"))); orb->run (); } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager - destroying ORB\n"))); orb->destroy (); } catch (const CORBA::Exception& ex) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_EMERGENCY, "NodeManager - Error, CORBA Exception: %C\n", ex._info ().c_str ())); retval = -1; } catch (...) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, "NodeManager - Error: Unknown exception.\n")); retval = -1; } return retval; }
void DAnCE_NodeManager_Module::create_poas (void) { DANCE_TRACE("DAnCE_NodeManager_Module::create_poas"); // Get reference to Root POA. DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::create_poas - ") ACE_TEXT ("Resolving root POA\n"))); CORBA::Object_var obj = this->orb_->resolve_initial_references ("RootPOA"); this->root_poa_ = PortableServer::POA::_narrow (obj.in ()); DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::create_poas - ") ACE_TEXT ("Obtaining the POAManager\n"))); PortableServer::POAManager_var mgr = this->root_poa_->the_POAManager (); TAO::Utils::PolicyList_Destroyer policies (2); policies.length (2); try { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::create_poas - ") ACE_TEXT ("DAnCE_NodeManager_Module::create_poas - ") ACE_TEXT ("Creating the \"Managers\" POA.\n"))); policies[0] = this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID); policies[1] = this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT); this->nm_poa_ = this->root_poa_->create_POA ("Managers", mgr.in(), policies); } catch (const PortableServer::POA::AdapterAlreadyExists &) { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_INFO, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::create_poas - ") ACE_TEXT ("Using existing \"Managers\" POA\n"))); this->nm_poa_ = this->root_poa_->find_POA ("Managers", 0); } }
CORBA::Object_ptr Plan_Launcher_Base_Impl< Manager, AppManager, Application> ::prepare_plan (const ::Deployment::DeploymentPlan &plan) { DANCE_TRACE ("Plan_Launcher_Base_Impl::prepare_plan"); #ifdef GEN_OSTREAM_OPS if (DAnCE_debug_level >= DANCE_LOG_DETAILED_TRACE) { std::ostringstream plan_stream; plan_stream << plan << std::endl; DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO "Convert_Plan - Input plan: %C\n", plan_stream.str ().c_str ())); } #endif /* GEN_OSTREAM_OPS */ typename AppManager::_var_type app_manager; try { ::Deployment::ApplicationManager_var l_manager = this->manager_->preparePlan (plan, 0); app_manager = app_manager = AppManager::_narrow (l_manager.in ()); } catch (::Deployment::PlanError &ex) { ACE_CString error ("Caught PlanError exception while invoking preparePlan: "); error += ex.name.in (); error += ", "; error += ex.reason.in (); DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - %C\n"), error.c_str ())); throw Deployment_Failure (error); } catch (::Deployment::StartError &ex) { ACE_CString error ("Caught StartError exception while invoking preparePlan: "); error += ex.name.in (); error += ", " ; error += ex.reason.in (); DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - %C\n"), error.c_str ())); throw Deployment_Failure (error); } catch (::CORBA::Exception &ex) { ACE_CString error; error += "Caught CORBA exception while invoking preparePlan: "; error += ex._info (); DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - %C\n"), error.c_str ())); throw Deployment_Failure (error); } catch(...) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - ") ACE_TEXT("An exception was thrown during EM->preparePlan.\n"))); throw Deployment_Failure ("An unexpected C++ exception was caught while invoking preparePlan"); } DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher_Base_Impl::launch_plan - ") ACE_TEXT ("after to call preparePlan\n"))); if (CORBA::is_nil (app_manager.in ())) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - ") ACE_TEXT("preparePlan call failed: ") ACE_TEXT("nil ApplicationManager reference\n"))); return 0; } else { DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::prepare_plan - ") ACE_TEXT("ApplicationMAnager was received from preparePlan.\n"))); } return app_manager._retn (); }
int ACE_TMAIN (int argc, ACE_TCHAR **argv) { DANCE_DISABLE_TRACE (); auto_ptr<DAnCE::Logger_Service> logger; int retval (0); try { DAnCE::Logger_Service * dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger"); if (dlf) { dlf->init (argc, argv); } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("Module_main.h - initializing ORB\n"))); CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); Options options; int const error = options.parse_args (argc, argv); if (error == -1) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("Failed to parse command line arguments.\n"))); } else if (error == 1) { //help was issued -> quit return 0; } if (options.rm_ior_ == 0) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("No RepositoryManager IOR provided\n"))); return -1; } // Resolve the RepositoryManager reference CORBA::Object_var obj = orb->string_to_object (options.rm_ior_); Deployment::RepositoryManager_var rm = Deployment::RepositoryManager::_narrow (obj); if (CORBA::is_nil (obj)) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("Provided IOR was invalid or could not be narrowed: %s\n"), options.rm_ior_)); return -1; } DAnCE::RepositoryManager::Admin admin (rm.in ()); ACE_Unbounded_Set_Iterator<Options::Installation> inst_it = options.install_.begin (); Options::Installation *inst (0); while (inst_it.next (inst) == 1) { if (!admin.install_package (inst->path_.c_str (), inst->name_.c_str (), inst->replace_)) retval = -1; inst_it.advance (); } ACE_Unbounded_Set_Iterator<Options::Creation> creat_it (options.create_); Options::Creation *creat (0); while (creat_it.next (creat) == 1) { if (!admin.create_package (creat->path_.c_str (), creat->name_.c_str (), creat->base_location_.c_str (), creat->replace_)) retval = -1; creat_it.advance (); } ACE_Unbounded_Set_Iterator<ACE_TString> uninst_it (options.uninstall_); ACE_TString *uninst = 0; while (uninst_it.next (uninst) == 1) { if (!admin.uninstall_package (uninst->c_str ())) retval = -1; uninst_it.advance (); } if (options.list_) { ::CORBA::StringSeq * packages = admin.list_packages (); if (packages == 0) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("No packages returned from list_packages\n"))); retval = -1; } DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_EMERGENCY, ACE_TEXT ("Listing %u packages installed on server:\n"))); for (CORBA::ULong i = 0; i < packages->length (); ++i) { DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, "\t%s\n", (*packages)[i].in ())); } delete packages; } if (options.shutdown_) { DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT, (LM_EMERGENCY, ACE_TEXT ("Shutting down the Repository Manager\n"))); if (!admin.shutdown ()) retval = -1; } orb->destroy (); } catch (const CORBA::Exception &ex) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("Caught unexpected CORBA Exception: %s\n"), ex._info ().c_str ())); return -1; } catch (...) { DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("repository_manager_admin_exec::main - ") ACE_TEXT ("Caught unexpected C++ exception.\n"))); return -1; } return retval; }
bool parse_args(int argc, ACE_TCHAR *argv[], Options &options) { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL options : \""))); for (int i = 0; i < argc; ++i) { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, "\t%s\n", argv[i])); } ACE_Get_Opt get_opt(argc, argv, ACE_TEXT ("k:n:c:x:u:m:a:lsfqo::h")); get_opt.long_option(ACE_TEXT("em-ior"), 'k', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("nm-ior"), 'n', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("lm-ior"), ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("xml-plan"), 'x', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("cdr-plan"), 'c', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("plan-uuid"), 'u', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("am-ior"), 'm', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("app-ior"), 'a', ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("launch-plan"), 'l', ACE_Get_Opt::NO_ARG); get_opt.long_option(ACE_TEXT("stop-plan"), 's', ACE_Get_Opt::NO_ARG); get_opt.long_option(ACE_TEXT("force"), 'f', ACE_Get_Opt::NO_ARG); get_opt.long_option(ACE_TEXT("quiet"), 'q', ACE_Get_Opt::NO_ARG); get_opt.long_option(ACE_TEXT("output"), 'o', ACE_Get_Opt::ARG_OPTIONAL); get_opt.long_option(ACE_TEXT("help"), 'h', ACE_Get_Opt::NO_ARG); get_opt.long_option(ACE_TEXT("manager-timeout"), ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("domain-timeout"), ACE_Get_Opt::ARG_REQUIRED); get_opt.long_option(ACE_TEXT("domain-file"), ACE_Get_Opt::ARG_REQUIRED); int c; ACE_CString s; while ( (c = get_opt ()) != EOF) { switch (c) { case 'k': if (get_opt.opt_arg () == 0) { options.em_ior_ = ACE_TEXT ("corbaname:rir:/NameService#ExecutionManager"); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Defaulting to NameService lookup") ACE_TEXT ("of ExecutionManager\n"))); } else { options.em_ior_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using ExecutionManager IOR: %s\n"), options.em_ior_)); } break; case 'n': options.em_ior_ = 0; options.nm_ior_ = get_opt.opt_arg (); options.output_ = true; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using NodeManager IOR: %s\n"), options.nm_ior_)); break; case 'x': options.xml_plan_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using XML plan: %s\n"), options.xml_plan_)); break; case 'c': options.cdr_plan_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using CDR plan: %s\n"), options.cdr_plan_)); break; case 'u': options.uuid_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using UUID: %s\n"), options.uuid_)); break; case 'm': options.am_ior_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Using ApplicationManager IOR %s\n"), options.am_ior_)); break; case 'a': options.app_ior_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Application IOR: %s\n"), options.app_ior_)); break; case 'l': options.mode_ = Options::LAUNCH; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Launching nominated plan\n"))); break; case 's': options.mode_ = Options::TEARDOWN; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Tearing down nominated plan\n"))); break; case 'f': options.force_ = true; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Not stopping teardown on errors\n"))); break; case 'o': options.output_ = true; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("IOR files will be output to ") ACE_TEXT ("the current working directory\n"))); if (get_opt.opt_arg () != 0) { options.output_prefix_ = get_opt.opt_arg (); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Storing user-provided output ") ACE_TEXT ("postfix <%s>\n"), options.output_prefix_)); } break; case 'q': options.quiet_ = true; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Plan_Launcher will hide all ouput") ACE_TEXT ("messages.\n"))); break; case 'h': usage (argv[0]); return false; case 0: if (ACE_OS::strcmp (get_opt.long_option (), ACE_TEXT ("lm-ior")) == 0) { options.em_ior_ = 0; DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Got LM IOR file: %C"), get_opt.opt_arg ())); options.lm_ior_ = get_opt.opt_arg (); break; } if (ACE_OS::strcmp (get_opt.long_option (), ACE_TEXT ("domain-file")) == 0) { DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Got domain file: %C\n"), get_opt.opt_arg ())); options.domain_file_ = get_opt.opt_arg (); break; } if ((ACE_OS::strcmp (get_opt.long_option (), ACE_TEXT ("manager-timeout")) == 0)) { DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Got Manager Timeout value: %C\n"), get_opt.opt_arg ())); options.em_timeout_ = ACE_OS::atoi (get_opt.opt_arg ()); break; } if ((ACE_OS::strcmp (get_opt.long_option (), ACE_TEXT ("domain-timeout")) == 0)) { DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Got Manager Timeout value: %C\n"), get_opt.opt_arg ())); options.domain_timeout_ = ACE_OS::atoi (get_opt.opt_arg ()); break; } default: usage (argv[0]); return false; } } /// Sanity checking on the options. // In all cases, we need to have a EM/NM IOR specified, but only one. if ((!options.em_ior_ && !options.nm_ior_ && !options.lm_ior_) || (options.em_ior_ && options.nm_ior_ && options.lm_ior_)) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("Plan_launcher::parse_args - ") ACE_TEXT ("Error: Must specify either EM IOR, NM IOR, LM IOR\n"))); return false; } // Launching plans requires a plan (duh), and only one plan if ((options.mode_ == Options::LAUNCH) && ((!options.xml_plan_ && !options.cdr_plan_) || (options.xml_plan_ && options.cdr_plan_))) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Error: Launching plans requires ") ACE_TEXT ("exactly one type of plan (CDR/XML) be ") ACE_TEXT ("specified.\n"))); return false; } // tearing down plans requires a bit more complex set of options: if ((options.mode_ == Options::TEARDOWN) // Either way (EM/NM), we ca use a combination of a AM and a APP. && !( (options.am_ior_ && options.app_ior_) || // If we are tearing down from EM, we have more options, namely: // A plan of some kind (options.em_ior_ && ( ((!options.xml_plan_ && !options.cdr_plan_) || (options.xml_plan_ && options.cdr_plan_)) || // A UUID (!options.uuid_) ) ) ) ) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("Plan_Launcher::parse_args - ") ACE_TEXT ("Invalid set of plan identification ") ACE_TEXT ("as required for teardown\n"))); return false; } return true; }
::Deployment::NodeApplicationManager_ptr NodeManager_Impl::preparePlan (const ::Deployment::DeploymentPlan & plan, ::Deployment::ResourceCommitmentManager_ptr /*resourceCommitment*/) { DANCE_TRACE ( "NodeManager_Impl::preparePlan"); DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_DEBUG, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - ") ACE_TEXT("started for node %C and plan %C\n"), this->name_.c_str(), plan.UUID.in())); #ifdef GEN_OSTREAM_OPS if (DAnCE_debug_level >= DANCE_LOG_DETAILED_TRACE) { std::ostringstream plan_stream; plan_stream << plan << std::endl; DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO "NodeManager_impl::preparePlan - %C", plan_stream.str ().c_str ())); } #endif /* GEN_OSTREAM_OPS */ // resourceCommitment will be used on next development stage if (0 == this->managers_.find (plan.UUID.in())) { // What should we do here if we already have application for this plan? // Probably it is mistake because we should previously call destroyApplication // before performe relaunching of application DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - ") ACE_TEXT("ApplicationManager for UUID %C already exists\n"), plan.UUID.in ())); throw ::Deployment::PlanError(plan.UUID.in (), "Plan with same UUID already exists"); } DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - creating NodeApplicationManager...\n"))); NodeApplicationManager_Impl* manager = 0; ACE_NEW_THROW_EX (manager, NodeApplicationManager_Impl (this->orb_.in(), this->poa_.in(), this->installer_. in (), this->name_, this->properties_), CORBA::NO_MEMORY()); Safe_NodeApplicationManager_Impl safe_manager (manager); DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - ") ACE_TEXT ("invoking preparePlan on NodeApplicationManager...\n"))); manager->preparePlan (plan); DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - activating NodeApplicationManager...\n"))); PortableServer::ObjectId_var id = this->poa_->activate_object (manager); CORBA::Object_var nam = this->poa_->id_to_reference (id.in()); // There is an idea to check if plan.UUID really exists this->managers_.bind (plan.UUID.in(), safe_manager._retn ()); // narrow should return a nil reference if it fails. DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_INFO, DLINFO ACE_TEXT("NodeManager_impl::preparePlan - ") ACE_TEXT ("NodeApplicationManager for plan %C completed\n"), plan.UUID.in ())); return Deployment::NodeApplicationManager::_narrow (nam.in ()); }
CORBA::Object_ptr DAnCE_TargetManager_Module::init (CORBA::ORB_ptr orb, int argc, ACE_TCHAR *argv[]) { DANCE_TRACE ("DAnCE_TargetManager_Module::init"); try { if (CORBA::is_nil(orb)) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Attempted to create Target Manager with a nil orb.\n"))); return CORBA::Object::_nil(); } else { this->orb_ = CORBA::ORB::_duplicate (orb); } if (ACE_OS::strcmp(orb->id(), this->orb_->id()) != 0) { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Resetting TM's orb.\n"))); this->orb_ = CORBA::ORB::_duplicate (orb); this->domain_nc_ = CosNaming::NamingContext::_nil(); } if (!this->parse_args (argc, argv)) { return CORBA::Object::_nil (); } this->create_poas (); if (this->options_.domain_nc_) { try { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Resolving DomainNC.\n"))); CORBA::Object_var domain_obj = this->orb_->string_to_object (this->options_.domain_nc_); if (!CORBA::is_nil (domain_obj.in ())) { this->domain_nc_ = CosNaming::NamingContext::_narrow (domain_obj.in()); if (CORBA::is_nil (this->domain_nc_.in ())) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR,DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Narrow to NamingContext return nil for DomainNC.\n"))); return CORBA::Object::_nil (); } } } catch (CORBA::Exception&) { DANCE_DEBUG (DANCE_LOG_ERROR, (LM_WARNING, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("DomainNC context not found!\n"))); } } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Initializing the IOR Table\n"))); // Initialize IOR table CORBA::Object_var table_object = orb->resolve_initial_references ("IORTable"); IORTable::Table_var adapter = IORTable::Table::_narrow (table_object.in ()); if (CORBA::is_nil (adapter.in ())) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Unable to RIR the IORTable.\n"))); return CORBA::Object::_nil (); } //Creating repository manager servant DAnCE::TargetManagerDaemon_i * rm = new DAnCE::TargetManagerDaemon_i (orb); PortableServer::ServantBase_var safe_svt (rm); ACE_CString repository_manager_oid; if (this->options_.name_ == 0) { repository_manager_oid = "TargetManager"; } else { repository_manager_oid = ACE_TEXT_ALWAYS_CHAR (this->options_.name_); repository_manager_oid += ".TargetManager"; } // Registering servant in poa PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId (repository_manager_oid.c_str()); this->rm_poa_->activate_object_with_id (oid, rm); // Getting repository manager ior CORBA::Object_var nm_obj = this->rm_poa_->id_to_reference (oid.in ()); CORBA::String_var ior = orb->object_to_string (nm_obj.in ()); // Binding ior to IOR Table adapter->bind (repository_manager_oid.c_str (), ior.in ()); // Binding repository manager to DomainNC if (!CORBA::is_nil (this->domain_nc_.in ())) { ACE_CString ns_name; if (this->options_.name_ == 0) { ns_name = "TargetManager"; } else { ns_name = ACE_TEXT_ALWAYS_CHAR (this->options_.name_); } DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Registering NM in NC as \"%C\".\n"), ns_name.c_str ())); CosNaming::Name name (1); name.length (1); name[0].id = CORBA::string_dup (ns_name.c_str ()); name[0].kind = CORBA::string_dup ("TargetManager"); this->domain_nc_->rebind (name, nm_obj.in ()); } // Writing ior to file if (0 != this->options_.ior_file_) { DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Writing RM IOR %C to file %C.\n"), this->options_.ior_file_, ior.in ())); if (!DAnCE::Target_Manager::write_IOR (this->options_.ior_file_, ior.in ())) DANCE_ERROR (DANCE_LOG_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("Error: Unable to write IOR to file %C\n"), this->options_.ior_file_)); } // Activate POA manager PortableServer::POAManager_var mgr = this->root_poa_->the_POAManager (); mgr->activate (); // Finishing Deployment part DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT, (LM_NOTICE, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("DAnCE_TargetManager is running...\n"))); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("DAnCE_TargetManager_Module::init - ") ACE_TEXT ("TargetManager IOR: %s\n"), ior.in ())); return nm_obj._retn (); } catch (const CORBA::Exception& ex) { DANCE_ERROR (DANCE_LOG_TERMINAL_ERROR, (LM_EMERGENCY, ACE_TEXT ("Caught CORBA Exception: %C\n"), ex._info ().c_str ())); return CORBA::Object::_nil (); } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { DANCE_DISABLE_TRACE (); int retval = 0; try { DAnCE::Logger_Service * dlf = ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger"); if (dlf) { dlf->init (argc, argv); } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - initializing ORB\n"))); CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - initializing module instance\n"))); TAO::Utils::ORB_Destroyer safe_orb (orb); CORBA::Object_var poa_obj = orb->resolve_initial_references ("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow (poa_obj.in ()); PortableServer::POAManager_var mgr = poa->the_POAManager (); PortableServer::POA_var persistent_poa; TAO::Utils::PolicyList_Destroyer policies (2); policies.length (2); try { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - ") ACE_TEXT("before creating the \"Managers\" POA.\n"))); policies[0] = poa->create_id_assignment_policy (PortableServer::USER_ID); policies[1] = poa->create_lifespan_policy (PortableServer::PERSISTENT); persistent_poa = poa->create_POA ("Managers", mgr.in(), policies); } catch (const PortableServer::POA::AdapterAlreadyExists &) { persistent_poa = poa->find_POA ("Managers", 0); } DAnCE::Plan_Launcher_Daemon_i *pl_daemon (0); ACE_NEW_RETURN (pl_daemon, DAnCE::Plan_Launcher_Daemon_i (orb.in ()), 0); PortableServer::ServantBase_var safe_servant (pl_daemon); PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("Plan_Launcher_Daemon"); persistent_poa->activate_object_with_id (oid, pl_daemon); CORBA::Object_var pl_obj = persistent_poa->id_to_reference (oid.in ()); CORBA::String_var pl_ior = orb->object_to_string (pl_obj.in ()); DAnCE::Utility::write_IOR (ACE_TEXT ("PL_Daemon.ior"), pl_ior.in ()); orb->run (); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - destroying ORB\n"))); orb->destroy (); } catch (const CORBA::Exception& ex) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_EMERGENCY, DLINFO "PL_Daemon - Error - CORBA Exception :%C\n", ex._info ().c_str ())); retval = -1; } catch (...) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, "PL_Daemon - Error: Unknown exception.\n")); retval = -1; } return retval; }
CORBA::Object_ptr DAnCE_NodeManager_Module::init (CORBA::ORB_ptr orb, int argc, ACE_TCHAR *argv[]) { try { if (CORBA::is_nil(orb)) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Attempted to create Node Manager with a nil orb.\n"))); return CORBA::Object::_nil(); } if (CORBA::is_nil(this->orb_.in())) { DANCE_TRACE_LOG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("NM's orb is nil.\n"))); this->orb_ = CORBA::ORB::_duplicate (orb); } else if (ACE_OS::strcmp(orb->id(), this->orb_->id()) != 0) { DANCE_DEBUG (DANCE_LOG_DETAILED_TRACE, (LM_TRACE, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Resetting NM's orb.\n"))); this->orb_ = CORBA::ORB::_duplicate (orb); this->domain_nc_ = CosNaming::NamingContext::_nil(); } if (!this->parse_args (argc, argv)) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Unable to parse the commandline arguments.\n"))); return CORBA::Object::_nil (); } this->register_value_factories (); this->create_poas (); if (this->options_.domain_nc_) { try { DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Resolving DomainNC.\n"))); CORBA::Object_var domain_obj = this->orb_->string_to_object (this->options_.domain_nc_); if (!CORBA::is_nil (domain_obj.in ())) { this->domain_nc_ = CosNaming::NamingContext::_narrow (domain_obj.in()); if (CORBA::is_nil (this->domain_nc_.in ())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Narrow to NamingContext return nil for DomainNC.\n"))); return CORBA::Object::_nil (); } } } catch (const CORBA::Exception&) { DANCE_ERROR (DANCE_LOG_WARNING, (LM_WARNING, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("DomainNC context not found!\n"))); } } DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("DAnCE_NodeManager_Module::init - ") ACE_TEXT("Resolving plan NS naming context.\n"))); CosNaming::NamingContext_var rebind_nc; if (this->options_.rebind_plan_ns_) { if (!this->options_.create_plan_ns_) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Rebind_plan_ns option is enabled but Create_plan_ns is not.\n"))); return CORBA::Object::_nil(); } CORBA::Object_var tmp_obj; if (0 != this->options_.rebind_plan_ns_ior_) { tmp_obj = orb->string_to_object (this->options_.rebind_plan_ns_ior_); rebind_nc = CosNaming::NamingContext::_narrow (tmp_obj); } else { if (CORBA::is_nil (this->domain_nc_.in ())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("The rebind plan is enabled but neither NC ") ACE_TEXT ("nor DomainNC are not supplied. No rebinding will be done.\n") ACE_TEXT ("Use the \"-rebind-plan-ns NC ior\" ") ACE_TEXT ("or \"-ORBInitRef DomainNC\" option.\n"))); return CORBA::Object::_nil (); } rebind_nc = CosNaming::NamingContext::_duplicate (this->domain_nc_.in ()); } } // Initialize IOR table CORBA::Object_var table_object = orb->resolve_initial_references ("IORTable"); IORTable::Table_var adapter = IORTable::Table::_narrow (table_object.in ()); if (CORBA::is_nil (adapter.in ())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Unable to RIR the IORTable.\n"))); return CORBA::Object::_nil (); } // Creating in process nameservice CosNaming::NamingContext_var plan_nc; if (this->options_.create_plan_ns_) { DANCE_DEBUG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Resolving plan-specific naming context.\n"))); CORBA::Object_var naming_obj; if (0 != this->options_.create_plan_ns_ior_) { naming_obj = orb->string_to_object (this->options_.create_plan_ns_ior_); plan_nc = CosNaming::NamingContext::_narrow (naming_obj.in()); if (CORBA::is_nil (plan_nc.in())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Failed trying to narrow naming context ") ACE_TEXT ("for dance creating plan NC.\n") ACE_TEXT ("Use the \"--create-plan-ns NC ior\" ") ACE_TEXT ("or \"--process-ns\" option.\n"))); return CORBA::Object::_nil (); } } else if (this->options_.process_ns_) { naming_obj = orb->resolve_initial_references ("NameService"); if (0 != this->options_.process_ns_file_) { CORBA::String_var ior = orb->object_to_string (naming_obj.in ()); DAnCE::Node_Manager::write_IOR (this->options_.process_ns_file_, ior.in ()); } plan_nc = CosNaming::NamingContext::_narrow (naming_obj.in ()); if (CORBA::is_nil (plan_nc.in ())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Fails trying to narrow naming context ") ACE_TEXT ("for dance creating plan NC.\n") ACE_TEXT ("Use the \"--create-plan-ns NC ior\" ") ACE_TEXT ("or \"--process-ns\" option.\n"))); return CORBA::Object::_nil (); } } else if (CORBA::is_nil (this->domain_nc_.in ())) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("The create plan is enabled but neither NC ior ") ACE_TEXT ("nor --process-ns or DomainNC option are not supplied.\n") ACE_TEXT ("Use the \"--create-plan-ns NC ior\", \"--process-ns\" ") ACE_TEXT ("or \"-ORBInitRef DomainNC\" option.\n"))); return CORBA::Object::_nil (); } else { plan_nc = CosNaming::NamingContext::_duplicate (this->domain_nc_.in ()); } } // Parsing Node name and node manager ior file name ACE_TString node_name = this->options_.node_managers_[0].c_str (); ACE_TString node_file; size_t npos = node_name.find ('='); if (ACE_CString::npos != npos) { node_file = node_name.substring (npos + 1, node_name.length() - npos + 1); node_name = node_name.substring (0, npos); } // load service modules for artifact installation service load_artifact_installation_modules (argc, argv); // Creating in process artifact installation service DAnCE::ArtifactInstallation_Impl* installer = 0; ACE_NEW_RETURN (installer, DAnCE::ArtifactInstallation_Impl (), CORBA::Object::_nil ()); PortableServer::Servant_var<DAnCE::ArtifactInstallation_Impl> safe_installer (installer); ACE_CString installer_oid_str = ACE_TEXT_ALWAYS_CHAR ((node_name + ACE_TEXT (".ArtifactInstaller")).c_str ()); // Registering servant in poa PortableServer::ObjectId_var installer_oid = PortableServer::string_to_ObjectId (installer_oid_str.c_str()); this->nm_poa_->activate_object_with_id (installer_oid, safe_installer._retn ()); CORBA::Object_var installer_object = this->nm_poa_->id_to_reference (installer_oid.in ()); this->installer_ = DAnCE::ArtifactInstallation::_narrow (installer_object.in ()); // Getting node manager ior CORBA::String_var installer_ior = orb->object_to_string (installer_object.in ()); // Binding ior to IOR Table adapter->bind (installer_oid_str.c_str (), installer_ior.in ()); // Make sure that we have only one Node Manager if (this->options_.node_managers_.size () != 1) { DANCE_ERROR (DANCE_LOG_EMERGENCY, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("For now only one node manager creation is supported.\n"))); return CORBA::Object::_nil (); } DANCE_DEBUG (DANCE_LOG_MINOR_EVENT, (LM_DEBUG, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("DAnCE_NodeManager::run_main - creating NodeManager for node %C\n"), this->options_.node_managers_[0].c_str())); //Creating node manager servant DAnCE::NodeManager_Impl * nm = 0; if (this->nm_map_.find (node_name, nm) == -1) { DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Allocating new NodeManager servant instance for NodeManager\n"))); int size = 64; DAnCE::Utility::PROPERTY_MAP properties (size); this->create_nm_properties (properties); ACE_NEW_RETURN (nm, DAnCE::NodeManager_Impl (orb, this->root_poa_.in (), this->installer_.in (), ACE_TEXT_ALWAYS_CHAR (node_name.c_str()), this->options_.node_config_, properties), CORBA::Object::_nil ()); DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("New NodeManager servant instance for NodeManager allocated.\n"))); this->nm_map_.bind (node_name, nm); } ACE_CString node_manager_oid = ACE_TEXT_ALWAYS_CHAR ((node_name + ACE_TEXT (".NodeManager")).c_str ()); // Registering servant in poa PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId (node_manager_oid.c_str()); this->nm_poa_->activate_object_with_id (oid, nm); // Getting node manager ior CORBA::Object_var nm_obj = this->nm_poa_->id_to_reference (oid.in ()); CORBA::String_var ior = orb->object_to_string (nm_obj.in ()); // Binding ior to IOR Table adapter->bind (node_manager_oid.c_str (), ior.in ()); // Binding node manager to DomainNC if (!CORBA::is_nil (this->domain_nc_.in ())) { DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Registering NM in NC as \"%C.NodeManager\".\n"), node_name.c_str ())); CosNaming::Name name (1); name.length (1); name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (node_name.c_str ())); name[0].kind = CORBA::string_dup ("NodeManager"); this->domain_nc_->rebind (name, nm_obj.in ()); } // Writing ior to file if (0 != node_file.length ()) { DANCE_DEBUG (DANCE_LOG_EVENT_TRACE, (LM_TRACE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Writing node IOR %C to file %C.\n"), node_file.c_str (), ior.in ())); if (!DAnCE::Node_Manager::write_IOR (node_file.c_str (), ior.in ())) DANCE_ERROR (DANCE_LOG_NONFATAL_ERROR, (LM_ERROR, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("Error: Unable to write IOR to file %C\n"), node_file.c_str ())); } // Activate POA manager PortableServer::POAManager_var mgr = this->root_poa_->the_POAManager (); mgr->activate (); // Finishing Deployment part DANCE_DEBUG (DANCE_LOG_MAJOR_EVENT, (LM_NOTICE, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("DAnCE_NodeManager is running...\n"))); DANCE_DEBUG (DANCE_LOG_MAJOR_DEBUG_INFO, (LM_DEBUG, DLINFO ACE_TEXT ("DAnCE_NodeManager_Module::init - ") ACE_TEXT ("NodeManager IOR: %C\n"), ior.in ())); return nm_obj._retn (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("DAnCE_NodeManager::main\t\n"); return CORBA::Object::_nil (); } }