<!-- CORBA Component Model (CCM) Specification                    -->
<!-- Version 4.0                                                  -->
<!-- Object Management Group, Inc.                                -->
<!-- Document Number formal/2006-04-01                            -->
<!-- Chapter 15:  IDL for CCM		                          -->

<!-- Copyright 2002, Laboratoire d’Informatique Fond de Lille     -->
<!-- Copyright 2006, Object Management Group, Inc.                -->

<!-- The companies listed above have granted to the Object        -->
<!-- Management Group, Inc. (OMG) a nonexlcusive, royalty-free,   -->
<!-- paid up, worldwide license to copy and distribute this       -->
<!-- document and to modify this document and distribute copies   -->
<!-- of the modified version. Each of the copyright holders       -->
<!-- listed above has agreed that no person shall be deemed to    -->
<!-- have infringed the copyright in the included material of     -->
<!-- any such copyright holder by reason of having used the       -->
<!-- specification set forth herein or having conformed any       -->
<!-- computer software to the specification.                      -->

<!-- The following IDL is considered "summary" IDL, not           -->
<!-- compilable. This IDL was defined by the UML Profile for      -->
<!-- CORBA specification on the Deployment PSM for CCM, which is  -->
<!-- derived from PIM in the Deployment and Configuration         -->
<!-- specification.                                               -->


#include <orb.idl>

module Deployment {

  enum SatisfierPropertyKind {
    Quantity,
    Capacity,
    Minimum,
    Maximum,
    _Attribute,
    Selection
  };

  struct SatisfierProperty {
    string name;
    SatisfierPropertyKind kind;
    boolean dynamic;
    any value;
  };

  typedef sequence < SatisfierProperty > SatisfierProperties;

  struct SharedResource {
    string name;
    ::CORBA::StringSeq resourceType;
    ::CORBA::ULongSeq nodeRef;
    SatisfierProperties property;
  };

  typedef sequence < SharedResource > SharedResources;

  struct Resource {
    string name;
    ::CORBA::StringSeq resourceType;
    SatisfierProperties property;
  };

  typedef sequence < Resource > Resources;

  struct Node {
    string name;
    string label;
    ::CORBA::ULongSeq sharedResourceRef;
    ::CORBA::ULongSeq connectionRef;
    Resources resource;
  };

  typedef sequence < Node > Nodes;

  struct Interconnect {
    string name;
    string label;
    ::CORBA::ULongSeq connectionRef;
    ::CORBA::ULongSeq connectRef;
    Resources resource;
  };

  typedef sequence < Interconnect > Interconnects;

  struct Bridge {
    string name;
    string label;
    ::CORBA::ULongSeq connectRef;
    Resources resource;
  };

  typedef sequence < Bridge > Bridges;

  struct Property {
    string name;
    any value;
  };

  typedef sequence < Property > Properties;

  struct Domain {
    string UUID;
    string label;
    SharedResources sharedResource;
    Nodes node;
    Interconnects interconnect;
    Bridges bridge;
    Properties infoProperty;
  };

  struct ResourceAllocation {
    string elementName;
    string resourceName;
    Properties property;
  };

  typedef sequence < ResourceAllocation > ResourceAllocations;

  exception ResourceCommitmentFailure {
    string reason;
    long index;
    string propertyName;
    ::CORBA::AnySeq propertyValue;
  };

  interface ResourceCommitmentManager {
    void commitResources (in ResourceAllocations resources)
      raises (ResourceCommitmentFailure);
    void releaseResources (in ResourceAllocations resources)
      raises (ResourceCommitmentFailure);
  };

  enum DomainUpdateKind {
    Add,
    Delete,
    UpdateAll,
    UpdateDynamic
  };

  interface TargetManager {
    Domain getAllResources ();
    Domain getAvailableResources ();
    ResourceCommitmentManager commitResources (in ResourceAllocations resources)
      raises (ResourceCommitmentFailure);
    void destroyResourceCommitment (in ResourceCommitmentManager manager);
    void updateDomain (in ::CORBA::StringSeq elements, in Domain domainSubset, 
                       in DomainUpdateKind updateKind);
  };

  typedef sequence < Object > Endpoints;

  struct Connection {
    string name;
    Endpoints endpoint;
  };

  typedef sequence < Connection > Connections;

  exception StartError {
    string name;
    string reason;
  };

  exception InvalidConnection {
    string name;
    string reason;
  };

  interface Application {
    void finishLaunch (in Connections providedReference, in boolean start)
      raises (StartError, InvalidConnection);
    void start ()
      raises (StartError);
  };

  exception ResourceNotAvailable {
    string name;
    string resourceType;
    string propertyName;
    string elementName;
    string resourceName;
  };

  exception InvalidProperty {
    string name;
    string reason;
  };

  exception InvalidNodeExecParameter {
    string name;
    string reason;
  };

  exception InvalidComponentExecParameter {
    string name;
    string reason;
  };

  exception StopError {
    string name;
    string reason;
  };

  interface ApplicationManager {
    Application startLaunch (in Properties configProperty, out Connections providedReference)
      raises (ResourceNotAvailable, StartError, InvalidProperty, InvalidNodeExecParameter, InvalidComponentExecParameter);
    void destroyApplication (in Application app)
      raises (StopError);
  };

  typedef sequence < Application > Applications;

  enum CCMComponentPortKind {
    Facet,
    SimplexReceptacle,
    MultiplexReceptacle,
    EventEmitter,
    EventPublisher,
    EventConsumer
  };

  struct ComponentPortDescription {
    string name;
    string specificType;
    ::CORBA::StringSeq supportedType;
    boolean provider;
    boolean exclusiveProvider;
    boolean exclusiveUser;
    boolean optional;
    CCMComponentPortKind kind;
  };

  typedef sequence < ComponentPortDescription > ComponentPortDescriptions;

  struct ComponentPropertyDescription {
    string name;
    CORBA::TypeCode type;
  };

  typedef sequence < ComponentPropertyDescription > ComponentPropertyDescriptions;

  struct ComponentInterfaceDescription {
    string label;
    string UUID;
    string specificType;
    ::CORBA::StringSeq supportedType;
    ::CORBA::StringSeq idlFile;
    Properties configProperty;
    ComponentPortDescriptions port;
    ComponentPropertyDescriptions property;
    Properties infoProperty;
  };

  struct Requirement {
    string name;
    string resourceType;
    Properties property;
  };

  typedef sequence < Requirement > Requirements;

  struct MonolithicDeploymentDescription {
    string name;
    ::CORBA::StringSeq source;
    ::CORBA::ULongSeq artifactRef;
    Properties execParameter;
    Requirements deployRequirement;
  };

  typedef sequence < MonolithicDeploymentDescription > MonolithicDeploymentDescriptions;

  enum ResourceUsageKind {
    None,
    InstanceUsesResource,
    ResourceUsesInstance,
    PortUsesResource,
    ResourceUsesPort
  };

  struct InstanceResourceDeploymentDescription {
    ResourceUsageKind resourceUsage;
    string requirementName;
    string resourceName;
    Properties property;
  };

  typedef sequence < InstanceResourceDeploymentDescription > InstanceResourceDeploymentDescriptions;

  struct InstanceDeploymentDescription {
    string name;
    string node;
    ::CORBA::StringSeq source;
    unsigned long implementationRef;
    Properties configProperty;
    InstanceResourceDeploymentDescriptions deployedResource;
    InstanceResourceDeploymentDescriptions deployedSharedResource;
  };

  typedef sequence < InstanceDeploymentDescription > InstanceDeploymentDescriptions;

  struct ComponentExternalPortEndpoint {
    string portName;
  };

  typedef sequence < ComponentExternalPortEndpoint > ComponentExternalPortEndpoints;

  struct PlanSubcomponentPortEndpoint {
    string portName;
    boolean provider;
    CCMComponentPortKind kind;
    unsigned long instanceRef;
  };

  typedef sequence < PlanSubcomponentPortEndpoint > PlanSubcomponentPortEndpoints;

  struct ExternalReferenceEndpoint {
    string location;
    boolean provider;
    string portName;
    ::CORBA::StringSeq supportedType;
  };

  typedef sequence < ExternalReferenceEndpoint > ExternalReferenceEndpoints;

  struct ConnectionResourceDeploymentDescription {
    string targetName;
    string requirementName;
    string resourceName;
    Properties property;
  };

  typedef sequence < ConnectionResourceDeploymentDescription > ConnectionResourceDeploymentDescriptions;

  struct PlanConnectionDescription {
    string name;
    ::CORBA::StringSeq source;
    Requirements deployRequirement;
    ComponentExternalPortEndpoints externalEndpoint;
    PlanSubcomponentPortEndpoints internalEndpoint;
    ExternalReferenceEndpoints externalReference;
    ConnectionResourceDeploymentDescriptions deployedResource;
  };

  typedef sequence < PlanConnectionDescription > PlanConnectionDescriptions;

  struct PlanSubcomponentPropertyReference {
    string propertyName;
    unsigned long instanceRef;
  };

  typedef sequence < PlanSubcomponentPropertyReference > PlanSubcomponentPropertyReferences;

  struct PlanPropertyMapping {
    string name;
    ::CORBA::StringSeq source;
    string externalName;
    PlanSubcomponentPropertyReferences delegatesTo;
  };

  typedef sequence < PlanPropertyMapping > PlanPropertyMappings;

  struct ImplementationDependency {
    string requiredType;
  };

  typedef sequence < ImplementationDependency > ImplementationDependencies;

  struct ResourceDeploymentDescription {
    string requirementName;
    string resourceName;
    Properties property;
  };

  typedef sequence < ResourceDeploymentDescription > ResourceDeploymentDescriptions;

  struct ArtifactDeploymentDescription {
    string name;
    ::CORBA::StringSeq location;
    string node;
    ::CORBA::StringSeq source;
    Properties execParameter;
    Requirements deployRequirement;
    ResourceDeploymentDescriptions deployedResource;
  };

  typedef sequence < ArtifactDeploymentDescription > ArtifactDeploymentDescriptions;

  enum PlanLocalityKind {
    SameProcess,
    DifferentProcess,
    NoConstraint
  };

  struct PlanLocality {
    PlanLocalityKind constraint;
    ::CORBA::ULongSeq constrainedInstanceRef;
  };

  typedef sequence < PlanLocality > PlanLocalities;

  struct DeploymentPlan {
    string label;
    string UUID;
    ComponentInterfaceDescription realizes;
    MonolithicDeploymentDescriptions implementation;
    InstanceDeploymentDescriptions instance;
    PlanConnectionDescriptions connection;
    PlanPropertyMappings externalProperty;
    ImplementationDependencies dependsOn;
    ArtifactDeploymentDescriptions artifact;
    Properties infoProperty;
    PlanLocalities localityConstraint;
  };

  interface DomainApplicationManager :
      ApplicationManager
  {
    Applications getApplications ();
    DeploymentPlan getPlan ();
  };

  exception PlanError {
    string name;
    string reason;
  };

  typedef sequence < DomainApplicationManager > DomainApplicationManagers;

  interface ExecutionManager {
    DomainApplicationManager preparePlan (in DeploymentPlan plan, in ResourceCommitmentManager resourceCommitment)
      raises (ResourceNotAvailable, PlanError, StartError);
    DomainApplicationManagers getManagers ();
    void destroyManager (in DomainApplicationManager manager)
      raises (StopError);
  };

  interface Logger {
  };

  interface NodeApplicationManager :
      ApplicationManager
  {
  };

  interface NodeManager {
    void joinDomain (in Domain theDomain, in TargetManager manager, in Logger log, in long updateInterval);
    void leaveDomain ();
    NodeApplicationManager preparePlan (in DeploymentPlan plan, in ResourceCommitmentManager resourceCommitment)
      raises (StartError, PlanError);
    void destroyManager (in NodeApplicationManager appManager)
      raises (StopError);
    Resources getDynamicResources ();
  };

  interface NodeApplication :
      Application
  {
  };

  interface DomainApplication :
      Application
  {
  };

  exception NameExists {
  };

  exception PackageError {
    string source;
    string reason;
  };

  exception NoSuchName {
  };

  exception LastConfiguration {
  };

  exception InvalidReference {
  };

  struct ComponentPackageDescription;

  typedef sequence < ComponentPackageDescription > ComponentPackageDescriptions;

  struct PackageConfiguration;

  typedef sequence < PackageConfiguration > PackageConfigurations;

  struct ComponentPackageReference {
    string requiredUUID;
    string requiredName;
    ComponentInterfaceDescription requiredType;
  };

  typedef sequence < ComponentPackageReference > ComponentPackageReferences;

  struct ComponentPackageImport {
    ::CORBA::StringSeq location;
  };

  typedef sequence < ComponentPackageImport > ComponentPackageImports;

  struct SubcomponentInstantiationDescription {
    string name;
    ComponentPackageDescriptions basePackage;
    PackageConfigurations specializedConfig;
    Requirements selectRequirement;
    Properties configProperty;
    ComponentPackageReferences referencedPackage;
    ComponentPackageImports importedPackage;
  };

  typedef sequence < SubcomponentInstantiationDescription > SubcomponentInstantiationDescriptions;

  struct SubcomponentPortEndpoint {
    string portName;
    unsigned long instanceRef;
  };

  typedef sequence < SubcomponentPortEndpoint > SubcomponentPortEndpoints;

  struct AssemblyConnectionDescription {
    string name;
    Requirements deployRequirement;
    ComponentExternalPortEndpoints externalEndpoint;
    SubcomponentPortEndpoints internalEndpoint;
    ExternalReferenceEndpoints externalReference;
  };

  typedef sequence < AssemblyConnectionDescription > AssemblyConnectionDescriptions;

  struct SubcomponentPropertyReference {
    string propertyName;
    unsigned long instanceRef;
  };

  typedef sequence < SubcomponentPropertyReference > SubcomponentPropertyReferences;

  struct AssemblyPropertyMapping {
    string name;
    string externalName;
    SubcomponentPropertyReferences delegatesTo;
  };

  typedef sequence < AssemblyPropertyMapping > AssemblyPropertyMappings;

  enum LocalityKind {
    SameNodeAnyProcess,
    SameNodeSameProcess,
    SameNodeDifferentProcess,
    DifferentNode,
    DifferentProcess,
    NoConstraint
  };

  struct Locality {
    LocalityKind constraint;
    ::CORBA::ULongSeq constrainedInstanceRef;
  };

  typedef sequence < Locality > Localities;

  struct ComponentAssemblyDescription {
    SubcomponentInstantiationDescriptions instance;
    AssemblyConnectionDescriptions connection;
    AssemblyPropertyMappings externalProperty;
    Localities localityConstraint;
  };

  typedef sequence < ComponentAssemblyDescription > ComponentAssemblyDescriptions;

  struct NamedImplementationArtifact;

  typedef sequence < NamedImplementationArtifact > NamedImplementationArtifacts;

  struct ImplementationArtifactDescription {
    string label;
    string UUID;
    ::CORBA::StringSeq location;
    Properties execParameter;
    Requirements deployRequirement;
    NamedImplementationArtifacts dependsOn;
    Properties infoProperty;
  };

  struct NamedImplementationArtifact {
    string name;
    ImplementationArtifactDescription referencedArtifact;
  };

  typedef sequence < ResourceUsageKind > ResourceUsageKinds;

  struct ImplementationRequirement {
    ResourceUsageKinds resourceUsage;
    string resourcePort;
    string componentPort;
    string name;
    string resourceType;
    Properties property;
  };

  typedef sequence < ImplementationRequirement > ImplementationRequirements;

  struct MonolithicImplementationDescription {
    Properties nodeExecParameter;
    NamedImplementationArtifacts primaryArtifact;
    ImplementationRequirements deployRequirement;
    Properties componentExecParameter;
  };

  typedef sequence < MonolithicImplementationDescription > MonolithicImplementationDescriptions;

  struct Capability {
    string name;
    ::CORBA::StringSeq resourceType;
    SatisfierProperties property;
  };

  typedef sequence < Capability > Capabilities;

  struct ComponentImplementationDescription {
    string label;
    string UUID;
    ComponentInterfaceDescription implements;
    ComponentAssemblyDescriptions assemblyImpl;
    MonolithicImplementationDescriptions monolithicImpl;
    Properties configProperty;
    Capabilities capability;
    ImplementationDependencies dependsOn;
    Properties infoProperty;
  };

  struct PackagedComponentImplementation {
    string name;
    ComponentImplementationDescription referencedImplementation;
  };

  typedef sequence < PackagedComponentImplementation > PackagedComponentImplementations;

  struct ComponentPackageDescription {
    string label;
    string UUID;
    ComponentInterfaceDescription realizes;
    Properties configProperty;
    PackagedComponentImplementations implementation;
    Properties infoProperty;
  };

  struct PackageConfiguration {
    string label;
    string UUID;
    ComponentPackageDescriptions basePackage;
    PackageConfigurations specializedConfig;
    Requirements selectRequirement;
    Properties configProperty;
    ComponentPackageReferences referencedPackage;
    ComponentPackageImports importedPackage;
  };

  interface RepositoryManager {
    void installPackage (in string installationName, in string location, in boolean replace)
      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);
  };

  struct ComponentUsageDescription {
    ComponentPackageDescriptions basePackage;
    PackageConfigurations specializedConfig;
    Requirements selectRequirement;
    Properties configProperty;
    ComponentPackageReferences referencedPackage;
    ComponentPackageImports importedPackage;
  };

  struct RequirementSatisfier {
    string name;
    ::CORBA::StringSeq resourceType;
    SatisfierProperties property;
  };
};