path: root/TAO/CIAO/ciao/Deployment.idl

// $Id$
#ifndef DEPLOYMENT_IDL
#define DEPLOYMENT_IDL

#include "Deployment_Data.idl"
#include "Packaging_Data.idl"
#include "Target_Data.idl"
#include "ServerResources.idl"

module Deployment {

  exception InvalidProperty {
    string name;
    string reason;
  };

  exception NameExists {
  };

  exception PackageError {
    string source;
    string reason;
  };

  exception NoSuchName {
  };

  exception LastConfiguration {
  };

  exception InvalidReference {
  };

  // Below exception types are CIAO specific
  exception PlanNotExist {
  };

  // CIAO specific struct type used for shared component management
  // mapping the name of component to its plan_uuid
  struct ComponentPlan
  {
    string name;
    string plan_uuid;
  };

  typedef sequence < ComponentPlan > ComponentPlans;

  interface ApplicationManager {
    Application startLaunch (in Properties configProperty,
                             out Connections providedReference,
                             in boolean start)
      raises (ResourceNotAvailable, StartError, InvalidProperty);
    void destroyApplication (in Application app)
      raises (StopError);
  };

  typedef sequence < Application > Applications;

  /// CIAO 's DomainApplicationManager interface differs spec-defined interface
  /// in the same that it also integrates the spec-defined interface for
  /// DomainApplication into itself
  interface DomainApplicationManager
  {
    DeploymentPlan getPlan ();

    /// CIAO specific version of startLaunch implementation, this one
    /// differs with spec-defined operation in the sense that it doesn't
    /// return DomainApplication object reference.
    void startLaunch (in Properties configProperty, in boolean start)
      raises (ResourceNotAvailable, StartError, InvalidProperty);

    void finishLaunch (in boolean start,
                       in boolean is_ReDAC)
      raises (StartError, InvalidConnection);

    void start ()
      raises (StartError);

    /// CIAO specific extention
    /// Fetch NodeApplication based on the given node name
    NodeApplication get_node_app (in string node_name)
      raises (NoSuchName);

    /// CIAO speicifc extension, it differs with the spec defined one
    /// for no input parameter.
    void destroyApplication ()
      raises (StopError);

    /// CIAO specific extension to destroy NodeApplicationManager
    void destroyManager ()
      raises (StopError);

    /// CIAO specific extension
    /// Perform the actual redeployment and reconfiguration on the dommain level.
    void perform_redeployment (in DeploymentPlan new_plan)
      raises (PlanError,
              InstallationFailure,
              UnknownImplId,
              ImplEntryPointNotFound,
              InvalidConnection,
              InvalidProperty,
              ::Components::RemoveFailure);
  };

  typedef sequence < DomainApplicationManager > DomainApplicationManagers;

  interface ExecutionManager {
    DomainApplicationManager preparePlan (in DeploymentPlan plan,
                                          in boolean commitResources)
      raises (ResourceNotAvailable, PlanError, StartError);

    DomainApplicationManagers getManagers ();

    DomainApplicationManager getManager (in string plan_uuid)
      raises (PlanNotExist);

    void destroyManager (in DomainApplicationManager manager)
      raises (StopError);

    /// CIAO specific extention
    /// Destroy ApplicatioManagers by plan_uuid, the unique semantics of this
    /// operation lies in the fact that if some components are
    /// still up and running, then the ApplicationManagers won't be destroyed.
    void destroyManagerByPlan (in string plan_uuid)
      raises (StopError);

    /// CIAO specific extention
    /// "Get" operation, return the DeploymentPlan
    DeploymentPlan getPlan (in string plan_uuid);

    /// CIAO specific operation to handle dynamic system redeployment
    /// and reconfiguration
    /// This operation could handle dynamic redeployment, and this
    /// is the operation exposed to clients directly. Other
    /// "perform_redeployment" operation defined on DAM and NA
    /// are implementaion details within DAnCE.
    void perform_redeployment (in DeploymentPlan new_plan)
      raises (PlanError,
              InstallationFailure,
              UnknownImplId,
              ImplEntryPointNotFound,
              InvalidConnection,
              InvalidProperty,
              ::Components::RemoveFailure);
  };

  interface Logger {
  };

  interface NodeApplicationManager :
    ApplicationManager
  {
    /// CIAO specific operation to handle dynamic system redeployment
    /// and reconfiguration
    /// This operation could handle dynamic redeployment for
    /// a node-level deployment plan within a node
    Application perform_redeployment (in Properties configProperty,
                                      out Connections providedReference,
                                      in boolean start)
      raises (PlanError,
              InstallationFailure,
              UnknownImplId,
              ImplEntryPointNotFound,
              InvalidConnection,
              InvalidProperty,
              ::Components::RemoveFailure);

    /// CIAO specific operation to reset deployment plan
    void reset_plan (in DeploymentPlan plan);

    /// CIAO speicfic operation to set the information of
    /// "shared components" (through NodeManager)
    void set_shared_components (in ComponentPlans components);
  };

  interface NodeManager {
    void joinDomain (in Domain ciao_domain,
                     in TargetManager manager,
                     in Logger log);

    void leaveDomain ();

    NodeApplicationManager preparePlan (in DeploymentPlan plan)
      raises (StartError, PlanError);

    void destroyManager (in NodeApplicationManager appManager)
      raises (StopError, InvalidReference);

    /// CIAO specific extension
    /// Destroy the NAM and all the associated NAs with this child_plan
    /// We can guarantee that the input DeploymentPlan is valid, since it
    /// is fetched from the cached DeploymentPlan of DAM, which has been
    /// validated before.
    void destroyPlan (in DeploymentPlan plan)
      raises (StopError);

    /// CIAO specific extension
    /// Get all the shared components installed in this node
    ComponentPlans get_shared_components ();
  };

  interface RepositoryManager {
    void installPackage (in string installationName, in string location)
      raises (NameExists, PackageError);
    void createPackage (in string installationName,
                        in PackageConfiguration package,
                        in string baseLocation,
                        in boolean replace)
      raises (NameExists, PackageError);
    PackageConfiguration findPackageByName (in string name)
      raises (NoSuchName);
    PackageConfiguration findPackageByUUID (in string UUID)
      raises (NoSuchName);
    ::CORBA::StringSeq findNamesByType (in string type);
    ::CORBA::StringSeq getAllNames ();
    ::CORBA::StringSeq getAllTypes ();
    void deletePackage (in string installationName)
      raises (NoSuchName);
  };


//***************************************new_RepositoryManager ONWARDS*****************************************

typedef sequence<octet> Artifact;
  typedef sequence<octet> Package;

  exception NoPlan {
  };

  enum Platform {
    Win32,
    Unix,
    Linux,
    Solaris,
    Vxworks,
    UNDEF
  };

  struct Implementation
  {
    Platform the_platform;
    string name;
    Artifact the_implementation;
  };

  typedef sequence<Implementation> Implementations;

  interface new_RepositoryManager
  {
    void installPackage (in string installationName,
                         in Package the_package,
                         in boolean replace)
      raises (NameExists, PackageError);

    DeploymentPlan  retrievePlan (in string packageName)
      raises (NoPlan);

    Package findPackageByName (in string name)
      raises (NoSuchName);

    Implementation findImplementationByName (in string implementation_name,
                                             in string package_name)
      raises (NoSuchName);

    Package findPackageByUUID (in string UUID)
      raises (NoSuchName);

    Implementation findImplementationByUUID (in string UUID)
      raises (NoSuchName);

    //::CORBA::StringSeq findNamesByType (in string type);
    //::CORBA::StringSeq getAllTypes ();

    ::CORBA::StringSeq getAllPackageNames ();

    void deletePackage (in string installationName)
      raises (NoSuchName);
  };
};

#endif /* DEPLOYMENT_IDL */