path: root/Planner_Manager/Component/Planner_Manager_exec.cpp

// $Id$
//
// ****              Code generated by the                 ****
// ****  Component Integrated ACE ORB (CIAO) CIDL Compiler ****
// CIAO has been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// CIDL Compiler has been developed by:
//       Institute for Software Integrated Systems
//       Vanderbilt University
//       Nashville, TN
//       USA
//       http://www.isis.vanderbilt.edu/
//
// Information about CIAO is available at:
//    http://www.dre.vanderbilt.edu/CIAO

#include "Planner_Manager_exec.h"
#include "ciao/CIAO_common.h"
#include "common/RACE_Log_Msg.h"

#define cpu_resource_prop_name  "LoadAverage"

namespace CIAO
{
  namespace RACE
  {
    namespace CIDL_Planner_Manager_Impl
    {
      //==================================================================
      // Facet Executor Implementation Class:   Planner_Manager_I_exec_i
      //==================================================================

      Planner_Manager_I_exec_i::Planner_Manager_I_exec_i (Planner_Manager_exec_i &comp)
        : comp_ (comp)
      {
      }

      Planner_Manager_I_exec_i::~Planner_Manager_I_exec_i (void)
      {
      }


      // emit log messages for all components being deployed... 
      void
      LogComponentDeploy( const ::CIAO::RACE::Plan_Actions& plan_seq )
      {

	for ( CORBA::ULong k=0; k<plan_seq.length(); k++ )
	{
          const ::Deployment::DeploymentPlan& plan = plan_seq[k].plan;

          for ( CORBA::ULong i=0; i < plan.instance.length(); ++i )
          {
             // Get the monolithic implementation that corresponds to
             // this instance....
             CORBA::ULong pos = plan.instance[i].implementationRef;
             const ::Deployment::MonolithicDeploymentDescription &mono =
                 plan.implementation[pos];

             for ( CORBA::ULong j=0; j < mono.execParameter.length(); ++j )
             {
               if (ACE_OS::strcmp (mono.execParameter[j].name.in (),
                                   cpu_resource_prop_name) == 0)
                 {
                    CORBA::Long value;
                    mono.execParameter[j].value >>= value;

                    RACE_DEPLOYMENT_STATUS(
                         plan_seq[k].command,  Log::EventMark::COMPONENT_DEPLOY,
                         plan.UUID.in(), 0,
                         Log::Status::SUCCESS,
                         plan.instance[i].name.in(),
                         value,
                         plan.instance[i].node.in()  
			 );

                    break;
		 }
	     }
	  }
	}
	return;
      }

      // Operations from ::CIAO::RACE::Planner_Manager_I

      void
      Planner_Manager_I_exec_i::execute_planners
      (const ::CIAO::RACE::Plan_Actions & plan_seq,
       const ::CIAO::RACE::PlannerFlow & flow
       ACE_ENV_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((CORBA::SystemException))
      {
        RACE_DEPLOYMENT_STATUS(
	      plan_seq[0].command,  Log::EventMark::BEGIN_PLAN,
              plan_seq[0].plan.UUID.in (), 0,
              Log::Status::SUCCESS,
              Log::find_importance( plan_seq[0].package ),
              "Success"  );

        bool planner_found = false;
        try
          {
            ACE_DEBUG ((LM_DEBUG, "Entering execute planners...\n"));

            ACE_DEBUG ((LM_DEBUG, "Copying plan_actions...\n"));
            ::CIAO::RACE::Plan_Actions result (plan_seq);

            //            ::Deployment::DeploymentPlan result (plan);

            ACE_DEBUG ((LM_DEBUG, "Getting planner connections.\n"));
            ::CIAO::RACE::Planner_Manager::plannersConnections_var planners
                = this->comp_.context_->get_connections_planners ();

            ACE_DEBUG ((LM_DEBUG, "%i planners found \n",
                        planners->length ()));

            // @@todo:  I should cache this list in a hash map to speed lookups....
            for (CORBA::ULong i = 0;
                 i < flow.length ();
                 ++i)
              {
                ACE_DEBUG ((LM_DEBUG, "Searching for planner %s\n",
                            flow[i].planner.in ()));

                for (CORBA::ULong j = 0;
                     j < planners->length ();
                     ++j)
                  {
                    ACE_DEBUG ((LM_DEBUG, "Examining %s\n",
                                planners[j].objref->name ()));

                    if (ACE_OS::strcmp (flow[i].planner.in (),
                                        planners[j].objref->name ()) == 0)
                      {
                        ACE_DEBUG ((LM_DEBUG, "RACE::Allocation::Planner_Manager - Found match for %s, running planner\n",
                                    flow[i].planner.in ()));
                        planner_found = true;

                        bool ret_val = true;
                        ACE_CString error;
                        try
                          {
                            ret_val = planners[j].objref->process_plan (result);

                            // error string , to be used in case plan fails ...
                            error = "PlannerFailure: Allocation Failed...Resource Exhaustion.";
                          }
                        catch (PlannerFailure &ex)
                          {
                            ret_val = false;
                            error = ex.name.in();
                            error += ": ";
                            error += ex.reason.in ();
                          }
                        catch (...)
                          {
                            ret_val = false;
                            error = "Unknown exception";
                          }
                        if (!ret_val) // must have been an error ...
                          {
                            ACE_DEBUG ((LM_DEBUG,
                                        "Planner %s has reported failure, bailing out....\n%s\n\n",
                                        flow[i].planner.in (), error.c_str() ));

                            RACE_DEPLOYMENT_STATUS(
	                          plan_seq[0].command,  Log::EventMark::END_PLAN,
                                  plan_seq[0].plan.UUID.in (), 0,
                                  Log::Status::FAILURE,
                                  Log::find_importance( plan_seq[0].package ),
                                  error.c_str ());
                            return;
                          }
                      }
                  }
                if (!planner_found) // must have been an error ...
                  {
                    ACE_DEBUG ((LM_DEBUG,
                                "Requested planner %s was not foind, bailing out....\n\n",
                                flow[i].planner.in ()));
                    return;

                  }
              }

            /// Call the output adapters only if the plan_action sequence
            /// returned by the planner contains one of more plan_actions.
	    	    
            ACE_DEBUG ((LM_DEBUG, "Planner_Manager: current deployment has %i actions\n",
                        result.length ()));

            LogComponentDeploy( result ); 

            RACE_DEPLOYMENT_STATUS(
	          plan_seq[0].command,  Log::EventMark::END_PLAN,
                  plan_seq[0].plan.UUID.in (), 0,
                  Log::Status::SUCCESS,
                  Log::find_importance (plan_seq[0].package),
                  ""  );
            
            if (result.length () > 0)
              {
                
                ::CIAO::RACE::Planner_Manager::outputsConnections_var conns
                  = this->comp_.context_->get_connections_outputs ();

                for (CORBA::ULong i = 0; i < conns->length (); ++i)
                  {
                    conns[i].objref->output_plan (result);
                  }
              }
            return;
          }
        catch (CORBA::Exception &ex)
          {
            ex._tao_print_exception ("");
          }
        catch (...)
          {
            ACE_ERROR ((LM_ERROR, "Unknown exception caught\n"));
          }


      }

      void
      Planner_Manager_I_exec_i::process_domain_change (
        ::CIAO::Domain_Changed_Event * ev
        ACE_ENV_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((::CORBA::SystemException))
      {
        ACE_DEBUG ((LM_DEBUG, "PlannerMgr::DomainChange - Entering.\n"));

        Plan_Actions_var plan_actions = new Plan_Actions;

        ::CIAO::RACE::Planner_Manager::plannersConnections_var planners;

        RACE_DEPLOYMENT_STATUS(
	      Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_BEGIN,
              "UNK-Multiple-Possible", 0,
              Log::Status::SUCCESS,
              -1, "Auto Plan for Domain Change"  
	      );

        try
          {
            planners = this->comp_.context_->get_connections_planners ();
          }
        catch (CORBA::Exception & ex)
          {
            ACE_DEBUG ((LM_DEBUG,
                        "PlannerMgr::DomainChange - CORBA Error in get_connections_planners\n"));

            RACE_DEPLOYMENT_STATUS(
                  Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                  "UNK-Multiple-Possible", 0,
                  Log::Status::FAILURE,
                  -1, "Domain Change Failed with CORBA Exception on call to get_connections_planners"  
	          );

             return;
          }

        CIAO::RACE::Planner_I::Domain_Changes changes;

        changes.length (ev->changes ().node.length ());

        for (CORBA::ULong i = 0;i < ev->changes ().node.length ();i++)
          {
            changes[i].hostname =
              CORBA::string_dup ( ev->changes ().node[i].name.in ());

	    if (ev->change_kind () == ::Deployment::Delete)
              changes[i].change = CIAO::RACE::Planner_I::NODE_FAILED;
            else if  (ev->change_kind () == ::Deployment::Add)
              changes[i].change = CIAO::RACE::Planner_I::NODE_JOINED;
	    else
	    {
              changes[i].change = CIAO::RACE::Planner_I::NODE_FAILED;
              ACE_DEBUG ((LM_DEBUG,
                 "PlannerMgr::DomainChange - Erro: Invalid change kind on Domain Change.\n"));
	    }
          }

        for ( CORBA::ULong i=0; i<planners->length() ;i++ )
          {
            //make a call to the planners to change domain
            bool ret_val = 0;
            Plan_Actions_var temp_plan_actions;

            try
              {
                ACE_DEBUG ((LM_DEBUG, "PlannerMgr::DomainChange - Making a call on the Planner = [%s]\n",
                            planners[i].objref->name ()));

                ret_val = planners[i].objref->
                             process_domain_change (changes,
                                                      temp_plan_actions.out ());

                // Add the plan actions ...
                CORBA::ULong prev_size = plan_actions->length ();

                if (temp_plan_actions)
                  {

                    plan_actions->length (prev_size + temp_plan_actions->length ());

                    // here append the plans ..
                    for (CORBA::ULong i = 0;
                         i < temp_plan_actions->length ();
                         i++)
                      {
                        plan_actions[prev_size + i] =
                          temp_plan_actions[i];
                      }
                  }
              }
            catch (CORBA::Exception &ex)
              {
                ex._tao_print_exception ("");

                 RACE_DEPLOYMENT_STATUS(
                       Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                       "UNK-Multiple-Possible", 0,
                       Log::Status::FAILURE,
                       -1, "Domain Change Failed with CORBA Exception on call to Planner"  
	               );

                 return;
              }
            catch (...)
              {
                ACE_ERROR ((LM_ERROR,
                            "Planner_Manager::Unknown exception caught\n"));

                 RACE_DEPLOYMENT_STATUS(
                       Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                       "UNK-Multiple-Possible", 0,
                       Log::Status::FAILURE,
                       -1, "Domain Change Failed with Unknown Exception on call to Planner"  
	               );

                 return;
              }

            if (!ret_val) // must have been an error ...
              {
                 ACE_DEBUG ((LM_DEBUG,
                            "PlannerMgr::DomainChange - Planner has reported failure \n"));
                 /*
                 RACE_DEPLOYMENT_STATUS(
                       Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                       "UNK-Multiple-Possible", 0,
                       Log::Status::FAILURE,
                       -1, "Domain Change Failed with Planner Error"  
	               );

                 return;
                 */
              }

          }

        ACE_DEBUG ((LM_DEBUG, "Planner_Manager::DomainChange: \
                    [%d] plans to be redeployed\n",
                    plan_actions->length ()));

        if (plan_actions->length () > 0)
          {
            ::CIAO::RACE::Planner_Manager::outputsConnections_var conns
              = this->comp_.context_->get_connections_outputs ();

                for (CORBA::ULong i = 0; i < conns->length (); ++i)
                  {
                    try
                      {
                        conns[i].objref->output_plan (plan_actions);
                      }
                    catch (CORBA::Exception &ex)
                      {
                        ex._tao_print_exception ("");

                        RACE_DEPLOYMENT_STATUS(
                	      Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                              "UNK-Multiple-Possible", 0,
                              Log::Status::FAILURE,
                              -1, "Domain Change Failed with CORBA Exception on call to Output Adapter"  
	                      );
			return;
                      }
                    catch (...)
                      {
                        ACE_ERROR ((LM_ERROR, "PlannerMgr::DomainChange - Unknown exception caught\n"));

                        RACE_DEPLOYMENT_STATUS(
	                      Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
                              "UNK-Multiple-Possible", 0,
                              Log::Status::FAILURE,
                              -1, "Domain Change Failed with Unknown Exception on call to Output Adapter"  
	                      );
			return;
                      }
                  }
            LogComponentDeploy( plan_actions ); 
          }
        else
	{
          ACE_DEBUG ((LM_DEBUG,
                      "Planner_manager::DomainChange - No plans were affected\n"));
	}

        RACE_DEPLOYMENT_STATUS(
	      Log::EventType::AUTO_PLAN,  Log::SubType::PLANNING_END,
              "UNK-Multiple-Possible", 0,
              Log::Status::SUCCESS,
              -1, "Successful Auto Plan for Domain Change"  
	      );

	return;
      }


      void
      Planner_Manager_exec_i::push_domain_changed (
        ::CIAO::Domain_Changed_Event * ev
        ACE_ENV_ARG_DECL_NOT_USED)
      ACE_THROW_SPEC (( ::CORBA::SystemException))
      {
        ACE_DEBUG ((LM_DEBUG,
                    "Planner_Manager_exec_i::push_domain_change - Enter.\n"));

        if (exec_ptr_)
          this->exec_ptr_->process_domain_change (ev);
        else
          ACE_DEBUG ((LM_DEBUG, "Planner_Manager_exec_i::push_domain_change - Executor still not active\n"));

      }

      //==================================================================
      // Component Executor Implementation Class:   Planner_Manager_exec_i
      //==================================================================

      Planner_Manager_exec_i::Planner_Manager_exec_i (void)
        :exec_ptr_ (0)
      {
      }

      Planner_Manager_exec_i::~Planner_Manager_exec_i (void)
      {
      }

      // Supported or inherited operations.

      // Attribute operations.

      ::CIAO::RACE::RACE_Classifications *
      Planner_Manager_exec_i::classes (
                                       ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((CORBA::SystemException))
      {
        // Your code here.
        RACE_Classifications_var retval (new RACE_Classifications (0));
        retval->length (0);
        return retval._retn ();
      }

      // Port operations.

      ::CIAO::RACE::CCM_Planner_Manager_I_ptr
      Planner_Manager_exec_i::get_planner_manager_i (
                                                     ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((CORBA::SystemException))
      {
        exec_ptr_ = new Planner_Manager_I_exec_i (*this);
        return exec_ptr_;
      }

      // Operations from Components::SessionComponent

      void
      Planner_Manager_exec_i::set_session_context (
                                                   ::Components::SessionContext_ptr ctx
                                                   ACE_ENV_ARG_DECL)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        this->context_ =
          Planner_Manager_Context::_narrow (
                                            ctx
                                            ACE_ENV_ARG_PARAMETER);
        ACE_CHECK;

        if (this->context_ == 0)
          {
            ACE_THROW (CORBA::INTERNAL ());
          }
      }

      void
      Planner_Manager_exec_i::ciao_preactivate (
                                                ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        // Your code here.
      }

      void
      Planner_Manager_exec_i::ciao_postactivate (
                                                 ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        // Your code here.
      }

      void
      Planner_Manager_exec_i::ccm_activate (
                                            ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        // Your code here.
      }

      void
      Planner_Manager_exec_i::ccm_passivate (
                                             ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        // Your code here.
      }

      void
      Planner_Manager_exec_i::ccm_remove (
                                          ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        // Your code here.
      }

      //==================================================================
      // Home Executor Implementation Class:   Planner_Manager_Home_exec_i
      //==================================================================

      Planner_Manager_Home_exec_i::Planner_Manager_Home_exec_i (void)
      {
      }

      Planner_Manager_Home_exec_i::~Planner_Manager_Home_exec_i (void)
      {
      }

      // Supported or inherited operations.

      // Home operations.

      // Factory and finder operations.

      // Attribute operations.

      // Implicit operations.

      ::Components::EnterpriseComponent_ptr
      Planner_Manager_Home_exec_i::create (
                                           ACE_ENV_SINGLE_ARG_DECL)
        ACE_THROW_SPEC ((
                         ::CORBA::SystemException,
                         ::Components::CCMException))
      {
        ::Components::EnterpriseComponent_ptr retval =
          ::Components::EnterpriseComponent::_nil ();

        ACE_NEW_THROW_EX (
                          retval,
                          Planner_Manager_exec_i,
                          CORBA::NO_MEMORY ());
        ACE_CHECK_RETURN (::Components::EnterpriseComponent::_nil ());

        return retval;
      }

      extern "C" PLANNER_MANAGER_EXEC_Export ::Components::HomeExecutorBase_ptr
      create_CIAO_RACE_Planner_Manager_Home_Impl (void)
      {
        ::Components::HomeExecutorBase_ptr retval =
          ::Components::HomeExecutorBase::_nil ();

        ACE_NEW_RETURN (
                        retval,
                        Planner_Manager_Home_exec_i,
                        ::Components::HomeExecutorBase::_nil ());

        return retval;
      }
    }
  }
}