path: root/CIAO/DAnCE/Plan_Launcher/Plan_Launcher_Base_Impl_T.cpp

// $Id$

#ifndef PLAN_LAUNCHER_BASE_IMPL_CPP
#define PLAN_LAUNCHER_BASE_IMPL_CPP

#include "Plan_Launcher_Base_Impl_T.h"

#include "ace/Env_Value_T.h"
#include "ace/OS_NS_stdio.h"
#include "ace/Get_Opt.h"

#include "Deployment/Deployment_ApplicationManagerC.h"
#include "DAnCE/Logger/Log_Macros.h"

#include "Deployment_Failure.h"

#ifdef GEN_OSTREAM_OPS
#include <iostream>
#include <sstream>
#endif /* GEN_OSTREAM_OPS */

namespace DAnCE
{
  template <typename Manager, typename AppManager, typename Application>
  Plan_Launcher_Base_Impl <Manager, AppManager, Application> ::
  Plan_Launcher_Base_Impl(CORBA::ORB_ptr orb, 
                          Manager_ptr manager)
    : orb_ (CORBA::ORB::_duplicate (orb)),
      manager_ (Manager::_duplicate (manager))
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::Plan_Launcher_Base_Impl");
    if (CORBA::is_nil (this->orb_.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO "Plan_Launcher_Base_Impl::Plan_Launcher_Base_Impl - "
                         "Plan Launcher requires a valid ORB\n"));
        throw Deployment_Failure ("Plan launcher requires a valid ORB\n");
      }

    if (CORBA::is_nil (this->manager_.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO "Plan_Launcher_Base_Impl::Plan_Launcher_Base_Impl - "
                         "Plan Launcher requires a valid Manager reference.\n"));
        throw Deployment_Failure ("Plan launcher requires a valid Manager reference\n");
      }
  }

  template <typename Manager, typename AppManager, typename Application>
  Plan_Launcher_Base_Impl < Manager, AppManager, Application> ::~Plan_Launcher_Base_Impl()
  {
  }

  template <typename Manager, typename AppManager, typename Application>
  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
    {
      std::ostringstream plan_stream;
      plan_stream << plan << std::endl;
      DANCE_DEBUG (9, (LM_TRACE, DLINFO "Convert_Plan - Input plan: %C\n",
                       plan_stream.str ().c_str ()));
    }
#endif /* GEN_OSTREAM_OPS */

    AppManager_var app_manager;
    try
      {
        app_manager = this->manager_->preparePlan (plan, 0);
      }
    catch(...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("An exception was thrown during EM->preparePlan.\n")));
        throw;
      }
  
    DANCE_DEBUG (6, (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 (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("preparePlan call failed: ")
                         ACE_TEXT("nil ApplicationManager reference\n")));
        return 0;
      }
    else
      {
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("ApplicationMAnager was received from preparePlan.\n")));
      }
  
    return app_manager._retn ();
  }

  template <typename Manager, typename AppManager, typename Application>
  CORBA::Object_ptr
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::start_launch (CORBA::Object_ptr app_mgr,
                  const ::Deployment::Properties &properties,
                  ::Deployment::Connections_out connections)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::start_launch");
  
    AppManager_var app_manager (AppManager::_narrow (app_mgr));

    if (CORBA::is_nil (app_manager.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("Plan_Launcher_Base_Impl::start_launch - ")
                         ACE_TEXT ("Nil ApplicationManager reference\n")));
        return 0;
      }

    Deployment::Application_var da;
    try
      {
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start_launch - ")
                         ACE_TEXT("before startLaunch...\n")));
        da = app_manager->startLaunch (properties, connections);
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start_launch - ")
                         ACE_TEXT("startLaunch completed...\n")));
      }
    catch(...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("An exception was thrown during DAM->startLaunch.\n")));
        throw;
      }
  
    if (CORBA::is_nil (da.in()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("CIAO_PlanLauncher:startLaunch call failed: ")
                         ACE_TEXT("nil DomainApplication reference\n")));
        return 0;
      }
    else
      {
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("DomainApplication was received from startLaunch\n")));
      }
  
    return da._retn ();
  }

  template <typename Manager, typename AppManager, typename Application>
  void
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::finish_launch (CORBA::Object_ptr app,
                   const ::Deployment::Connections &provided_connections,
                   bool start)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::finish_launch");
  
    Application_var application (Application::_narrow (app));

    if (CORBA::is_nil (application.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("Nil Application reference.\n")));
        throw Deployment_Failure ("Nil Application reference");
      }

    // Call finish Launch to complete the connections
    try
      {
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("before finishLaunch\n")));
        application->finishLaunch (provided_connections,
                                   start);
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("finishLaunch completed.\n")));
      }
    catch(...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT("An exception was thrown during DA->finishLaunch.\n")));
        throw;
      }
  }

  template <typename Manager, typename AppManager, typename Application>
  void
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::start (CORBA::Object_ptr app)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::start");
  
    Application_var application (Application::_narrow (app));

    if (CORBA::is_nil (application.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start - ")
                         ACE_TEXT("Nil Application reference.\n")));
        throw Deployment_Failure ("Nil Application reference");
      }

    try
      {
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start - ")
                         ACE_TEXT("before invoking start on application...\n")));
        application->start ();
        DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start - ")
                         ACE_TEXT("after invoking start on application...\n")));
      }
    catch(...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::start - ")
                         ACE_TEXT("An exception was thrown during DA->start.\n")));
        throw;
      }
  }

  template <typename Manager, typename AppManager, typename Application>
  const char *
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::launch_plan (const ::Deployment::DeploymentPlan &plan,
                 CORBA::Object_out am_out,
                 CORBA::Object_out app_out)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::launch_plan");
    
    //this->create_external_connections (plan, conns.inout());
  
    try
      {
        CORBA::Object_var app_mgr = this->prepare_plan (plan);
      
        ::Deployment::Connections_var conns;

        CORBA::Object_var app = this->start_launch (app_mgr.in (),
                                                    0,
                                                    conns.out ());
        
        this->create_external_connections (plan,
                                           conns.inout ());
        
        this->finish_launch (app.in (),
                             conns,
                             false);
      
        this->start (app.in ());

        DANCE_DEBUG (6, (LM_DEBUG, DLINFO
                         ACE_TEXT ("Plan_Launcher_Base_Impl::launch_plan - ")
                         ACE_TEXT ("Application Deployed successfully\n")));
        
        am_out = app_mgr._retn ();
        app_out = app._retn ();
      }
    catch (const Deployment::ResourceNotAvailable& ex)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: ResourceNotAvaiable exception caught: <%s>,\n"
                         "Type: <%s>\n"
                         "Property: <%s>\n"
                         "Element: <%s>\n"
                         "Resource: <%s>\n",
                         ex.name.in (),
                         ex.resourceType.in (),
                         ex.propertyName.in (),
                         ex.elementName.in (),
                         ex.resourceName.in ());
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    catch (const Deployment::StartError& ex)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: StartError exception caught: <%s>, <%s>\n",
                         ex.name.in (),
                         ex.reason.in ());
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    catch (const Deployment::InvalidProperty& ex)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: InvalidProperty exception caught: <%s>, <%s>\n",
                         ex.name.in (),
                         ex.reason.in ());
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    catch (const Deployment::InvalidConnection& ex)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: InvalidConnection exception caught: <%s>, <%s>\n",
                         ex.name.in (),
                         ex.reason.in ());
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    catch (const CORBA::Exception& ex)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - CORBA EXCEPTION: <%s>\n",
                         ex._info().fast_rep());
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    catch (...)
      {
        char buf[1024];
        ACE_OS::sprintf (buf, "Plan_Launcher_Base_Impl::launch_plan - EXCEPTION: non-CORBA exception\n");
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("%C"), buf));
        throw Deployment_Failure (buf);
      }
    
    return CORBA::string_dup (plan.UUID.in());
  }

  template <typename Manager, typename AppManager, typename Application>
  void
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::teardown_application (CORBA::Object_ptr am_obj,
                          CORBA::Object_ptr app_obj)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::teardown_application");
  
    AppManager_var am (AppManager::_narrow (am_obj));
  
    if (CORBA::is_nil (am.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::teardown_application - ")
                         ACE_TEXT("Nil ApplicationManager reference.\n")));
        throw Deployment_Failure ("Nil ApplicationManager reference");
      }
  
    Application_var app (Application::_narrow (app_obj));

    if (CORBA::is_nil (app.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::teardown_appliocation - ")
                         ACE_TEXT("Nil Application reference.\n")));
        throw Deployment_Failure ("Nil Application reference");
      }

    try
      {
        am->destroyApplication (app.in ());
      }
    catch (const ::Deployment::StopError &ex)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::teardown_appliocation - ")
                         ACE_TEXT ("Caught StopError exception\n")));
        throw Deployment_Failure ("StopError Exception\n");
      }
    catch (const CORBA::Exception &ex)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::teardown_appliocation - ")
                         ACE_TEXT ("Caught CORBA exception: %s\n"),
                         ex._info ().c_str ()));
        throw Deployment_Failure (ex._info ().c_str ());
      }
    catch (...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::teardown_appliocation - ")
                         ACE_TEXT ("Caught unknown C++ exception\n")));
        throw Deployment_Failure ("Unknown C++ exception\n");
      }
  }

  template <typename Manager, typename AppManager, typename Application>
  void
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::destroy_app_manager(CORBA::Object_ptr am_obj)
  {
    DANCE_TRACE ("Plan_Launcher_Base_Impl::destroy_app_manager");
  
    AppManager_var am (AppManager::_narrow (am_obj));

    if (CORBA::is_nil (am.in ()))
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT("Nil ApplicationManager reference.\n")));
        throw Deployment_Failure ("Nil ApplicationManager reference");
      }

    try
      {
        DANCE_ERROR (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT ("Destroying ApplicationManager\n")));
        this->manager_->destroyManager (am.in ());
        DANCE_ERROR (6, (LM_DEBUG, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT ("ApplicationManager destroyed.\n")));
      }
    catch (const ::Deployment::StopError &ex)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT ("Caught StopError exception\n")));
        throw Deployment_Failure ("StopError Exception\n");
      }
    catch (const CORBA::Exception &ex)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT ("Caught CORBA exception: %s\n"),
                         ex._info ().c_str ()));
        throw Deployment_Failure (ex._info ().c_str ());
      }
    catch (...)
      {
        DANCE_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT("Plan_Launcher_Base_Impl::destroy_app_manager - ")
                         ACE_TEXT ("Caught unknown C++ exception\n")));
        throw Deployment_Failure ("Unknown C++ exception\n");
      }
  }

  
  template <typename Manager, typename AppManager, typename Application>
  void
  Plan_Launcher_Base_Impl< Manager, AppManager, Application>
  ::create_external_connections(const ::Deployment::DeploymentPlan &plan,
                                Deployment::Connections &conn)
  {
    DANCE_DEBUG (6, (LM_DEBUG, DLINFO ACE_TEXT("create_external_connections - start\n")));
    
    for (CORBA::ULong i = 0; i < plan.connection.length(); i++)
      {
        if (plan.connection[i].externalReference.length() > 0
            && plan.connection[i].externalReference[0].provider)
          {
            DANCE_DEBUG (6, (LM_DEBUG,
                             "Plan_Launcher_i::create_external_connections - create connection %C from IOR %C\n",
                             plan.connection[i].name.in(),
                             plan.connection[i].externalReference[0].location.in()));
            
            try
              {
                CORBA::Object_ptr
                  obj = this->orb_->string_to_object(plan.connection[i].externalReference[0].location.in());
                if (!CORBA::is_nil (obj))
                  {
                    CORBA::ULong const indx = conn.length();
                    conn.length(indx + 1);
                    conn[indx].name= CORBA::string_dup (plan.connection[i].name.in());
                    conn[indx].endpoint.length(1L);
                    conn[indx].endpoint[0] = obj;
                  }
                else
                  {
                    DANCE_DEBUG (6, (LM_DEBUG, DLINFO
                                     ACE_TEXT("Plan_Launcher_i::create_external_connections - can't create object for IOR %C\n"),
                                     plan.connection[i].externalReference[0].location.in()));
                  }
              }
            catch (CORBA::Exception &ex)
              {
                DANCE_ERROR (1, (LM_ERROR, DLINFO 
                                 ACE_TEXT("Plan_Launcher_i::create_external_connections - ")
                                 ACE_TEXT("Caught CORBA Exception while resolving endpoint for connection %C\n"),
                                 plan.connection[i].name.in ()));
              }
            catch (...)
              {
                 DANCE_ERROR (1, (LM_ERROR, DLINFO 
                                  ACE_TEXT("Plan_Launcher_i::create_external_connections - ")
                                  ACE_TEXT("Caught C++ Exception while resolving endpoint for connection\n")));
              }
          }
      }
  }
    /*

    ACE_CString
    Plan_Launcher_Base_Impl::expand_env_vars (const ACE_TCHAR * s)
    {
    ACE_TString src(s);
    ACE_TString res;
    size_t pos_done = 0;
    while (pos_done < (size_t) src.length())
    {
    size_t pos_start = src.find ('$', pos_done);
    if (ACE_TString::npos == pos_start)
    {
    res += src.substring (pos_done);
    pos_done = src.length();
    }
    else // take the substring before '$' and append value
    {
    if (pos_start > pos_done)
    {
    res += src.substring (pos_done, pos_start - pos_done);
    pos_done = pos_start;
    }

    size_t pos_end = src.length();

    size_t p;

    p = src.find (ACE_TEXT(' '), pos_start + 1);
    if (ACE_TString::npos != p && pos_end > p) pos_end = p;

    p = src.find (ACE_TEXT('/'), pos_start + 1);
    if (ACE_TString::npos != p && pos_end > p) pos_end = p;

    p = src.find (ACE_TEXT('\\'), pos_start + 1);
    if (ACE_TString::npos != p && pos_end > p) pos_end = p;

    p = src.find (ACE_TEXT('$'), pos_start + 1);
    if (ACE_TString::npos != p && pos_end > p) pos_end = p;

    if (pos_end - pos_start > 1)
    {
    ACE_Env_Value<const ACE_TCHAR*> val (src.substring (pos_start + 1, pos_end - pos_start - 1).c_str(), 0);
    res += val;
    pos_done = pos_end;
    }
    else
    {
    DANCE_DEBUG (6, (LM_WARNING, DLINFO
    ACE_TEXT("Plan_Launcher_Base_Impl::expand_env_vars - ")
    ACE_TEXT("Envvar can not be parsed out at %i in \"<%s>\""),
    pos_start,
    src.c_str()));
    }
    }
    }
    return res;
    }

  */
}
#endif