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 ();
}
}
