TAO/CIAO/ciao/Deployment_Data.idl


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

// $Id$

#ifndef DEPLOYMENT_DATA_IDL
#define DEPLOYMENT_DATA_IDL
#include "Deployment_Base.idl"

module Deployment {

  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 resourceType;
    string name;
    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;
  };

  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;

  struct DeploymentPlan {
    string label;
    string UUID;
    ComponentInterfaceDescription realizes;
    MonolithicDeploymentDescriptions implementation;
    InstanceDeploymentDescriptions instance;
    PlanConnectionDescriptions connection;
            PlanPropertyMappings externalProperty;
    ImplementationDependencies dependsOn;
    ArtifactDeploymentDescriptions artifact;
    Properties infoProperty;
  };

  enum DomainUpdateKind {
    Add,
    Delete,
    UpdateAll,
    UpdateAvailable
  };

  struct ComponentPackageReference {
    string requiredUUID;
    string requiredName;
    string requiredType;
  };

  typedef sequence < ComponentPackageReference > ComponentPackageReferences;

  typedef sequence < ResourceUsageKind > ResourceUsageKinds;

  struct ImplementationRequirement {
    ResourceUsageKinds resourceUsage;
    string resourcePort;
    string componentPort;
    string resourceType;
    string name;
    Properties property;
  };

  typedef sequence < ImplementationRequirement > ImplementationRequirements;

  struct Capability {
    string name;
    ::CORBA::StringSeq resourceType;
    SatisfierProperties property;
  };

  typedef sequence < Capability > Capabilities;

  struct RequirementSatisfier {
    string name;
    ::CORBA::StringSeq resourceType;
    SatisfierProperties property;
  };
};

#endif /* DEPLOYMENT_DATA_IDL */