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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
|
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<!-- $Id$ -->
<html> <head>
<title>CIAO Release Information and TODOs</title>
</head>
<body>
<h1>CIAO Release Information and TODOs</h1>
<ul>
<li><a href="#status">Current Status</a>
<li><a href="#outlook">Project Outlook</a>
<li>Short-term <a href="todo.html">to-do list</a></p>
</ul>
<hr>
<h2>Current Status</h2><a name="status">
<ol>
<li><h3>Latest News</h3>
<ul>
<li>Thu Apr 16 2003 - The HUDisplay example now also works on
Linux platforms and allows you to remotely setup an
application. <p>
<li>Sat Apr 5 2003 - Added the support for connection
establishment and finished the multiple-component
<a href="../examples/handcrafted/Display/"> HUDisplay
example</a>. Check out the <a
href="../examples/handcrafted/Display/descriptors/NOTE.txt">
note </a> to see how to play with it. You need to
have <a href="http://www.trolltech.com/">Qt</a> library
available if you want to play with the GUI based
component. If you don't, no worries. You can still play
with the non-GUI configurations.<p>
<li>Thu Apr 3 2003 - Added the XML documents handlers for
componentassembly. They build the assembly specification
that the assembly mechanisms use to compose an
application. As with handlers for parsing softpkg
documents, these handlers do not have robust error
handling capability as they assume a validator in ACEXML
parser handles the validity of documents already (which
isn't the case for the time being.)<p>
<li>Fri Mar 21 2003 - Finished the component implementations
for the multi-component example. Next up, assembling
mechanism. <p>
<li>Thu Mar 6 2003 - The HelloWorld now uses the new command
Daemon control options to read in the component softpkg
descriptor, spawn a ComponentServer, and instantiate the
component. See the <code>
<a href="../examples/handcrafted/Hello/run_test.pl">
run_test.pl</a></code> for more details on how this can be
done. <p>
<li>Sun Feb 16 2003 - A new implementation for the per-host
daemon process is now availabe under <code>
$(CIAO_ROOT)/tools/Daemon/</code>. This application
includes both <code> ComponentInstallation</code> and
<code>ServerActivator</code> interfaces. It also comes
with a command line utility program to interact with the
daemon process. Please see its <a
href="../tools/Daemon/README">README</a> file for more
information.<p>
Implementation for <code>ComponentInstallation</code>
interface uses ACE_Configuration to maintain persistency
of component intallation data. <p>
<li>Fri Feb 14 2003 - We now have most of the assembly and
deployment framewok processes available. Next up,
implementing the XML
handlers that actually parses component assemblies and
assembles an application.<p>
<li>Sun Feb 9 2003 - Started implementing the Deployment and
Assembly framework a week ago. So far, the object
management mechanisms for AssemblyFactory and Assembly is
done, but I still need to fill in the meat where we build an
Assembly by parsing the Assembly descriptor. I'm going to
move on to finish the implementations for the rest of the
Deployment and Assembly interfaces in the next few days.<p>
<b>It looks like we will have to go straight to our
planned 0.2 release as our first publically available
CIAO. </b><p>
<li>Mon Jan 13 2003 - Finished the first round effort to
create a meta-code to describe how the CIDL compiler
should generated the container specific glue code. These
templates are available <a href="templates/">here</a>.
These templates can also be used to help handcrafting the
examples I'm working on.<p>
<li>Mon Jan 6 2003 - Both Jeff and Boris are working on the
CIDL compiler implementation.<p>
<li>Tue Dec 24 2002 - Started working a multi-component
handcrafted example in <a
href="../examples/handcrafted/Display/">examples/handcrafted/Display/</a><p>
<li>Sat Dec 21 2002 - Added *nix Makefiles, MPC specifications
and created MPC templates for CIAO clients, component
implementations, and server tools.<p>
<li>Wed Dec 18 2002 - A perl script fits beautifully with the
HelloWorld example.<p>
<li>Dec 17 2002 - A NameService based HomeFinder
implementation -- CIAO::HomeRegistrar -- is now
available. The simple component server in CIAO now use
the support the HomeFinder interface so we can install as
many components in the component server as possible.<p>
<li>Dec 15 2002 - Generic component server that can host
multiple components with a proprietary config file. More
information can be found <a
href="../tools/Simple_Component_Server/README"> here </a>
Next up, a trivial HomeFinder interface that can
simply forward requests to a Naming Service.<p>
<li>Dec 11 2002 - The server implementation in the HelloWorld
example is now a generic one-component server. It can be
modified easily to host any *one* component easily.<p>
<li>Dec 10 2002 - <a href="com-impl.html">This document</a>
captures how to "handcraft" a component and how this all
will be automated in the future.<p>
<li>Nov 22 2002 - Completed the first handcrafted example
<a href="../examples/handcrafted/Hello/README">HelloWorld</a>
component implementation. CIAO now also include a
minimally functioning session container implementation.<p>
</ul>
<li> <h3>Status of individual modules</h3>
<table valign="top" border="1" width="90%">
<th> Modules </th>
<th> Status </th>
<tr>
<td>CCM Core</td>
<td>We are currently working on a prototype that enables remote
component installation using the CCM
<code>ComponentInstallation</code> interface, a component
server implementation. Since we
still don't have a CIDL implementation, we will also write up
an example to show how the code should be generated in both
CCIDL compiler and provide example component
implementations.
There exists 3 libraries in CCM Core.
<ol>
<li><b>CIAO_Client</b>: contains the client side stubs for
CCMObject. All client programs that use CCMObject must
link to this library.
<li><b>CIAO_Container</b>: contains the interface
definitions and CIAO's container implementation. All
component implementations must link to this library.
<li><b>CIAO_Server</b>: contains the stubs to access
deployment framework. We'll need to use this to
implement the deployment mechanism.
</ol>
</td>
</tr>
<tr>
<td>TAO_IDL</td>
<td>TAO_IDL has been extended to handle and generate all the
component related keywords but <code>import</code>. We are
currently using the generated mapping, in combination to
manually simulation of CIDL generated code to implement CCM
component.
TAO_IDL Check out <a
href="http://cvs.doc.wustl.edu/ace-latest.cgi/ACE_wrappers/TAO/docs/releasenotes/index.html#idl"> TAO IDL compiler</a> for more details.
</td>
</tr>
<tr>
<td>CCIDL (CIAO Component Implementation IDL) Compiler</td>
<td>
We still have no solid schedule as to when an implemention of
CCIDL will be available at
this point and we do not have immediate plan to integrate
Persistence State Service into CCIDL. For starter, we will
probably only support a simple construct like the following:
<pre>
import ::some_idl_module;
module component_composite_name {
composition service component_home_executor {
implements component_home;
manages component_executor;
};
};
</pre>
We will also need to generate the operation implementation
inherit from following interfaces:
<ul>
<li><code>Navigation</code>
<li><code>Receptacle</code>
<li><code>Event</code>
<li><code>CCMObject</code>
<li>Component specific context
<li>Executor
</ul>
For the implementation of the three introspection interfaces,
one way to implement it is to simply(?) generate the code that
build the component meta-data when queried (such as,
<code>get_all_facets</code> method,) or to create a generic
implementation and use an XML file that describe the component
to fill in these meta-data.
</td>
</tr>
</table><p>
<li><b>TAO Modules required by CIAO:</b> We currently don't have a
target set up in TAO's make system to build CIAO required module
only, so you need to do this yourself. (BTW, we only support the
use of dynamic linked libraries, at least for now.) Here is a list
of necessary TAO modules in order of dependencies:
<ol>
<li>TAO Main library.
<li>PortableServer
<li>orbsvcs/orbsvcs/Security
<li>IFR_Client
</ol><p>
</ol>
<hr>
<a name="outlook">
<h2>Project Outlook</h2>
This to-do list is currently arranged in chronological order,
<i>i.e.</i>, we group features that are expected to be available in
certain release together. All interfaces and types are under
<CODE>Components</code> module namespace if not specified explicitly.
<ul>
<li><b>CIAO 0.1 alpha release</b> - (post TAO 1.3, Dec. 2002)
<UL>
<li>Default implementation of <code>
<ul>
<li>Navigations
<li>Receptacles
<li>Events
</ul>
</code>
interfaces and their supporting data types that
<code>CCMObject</code> interface requires. These
interfaces are defined in <code>
<a href="../ciao/CIAO_Base.pidl">CIAO_Base.pidl</a></code>
and <code><a
href="../ciao/CIAO_Event.pidl">CIAO_Event.pidl</a></code>.
<li>Default implementation of <code>
<ul>
<li>CCMObject
<li>CCMHome
<li>KeylessCCMHome
</ul>
</code> and their supporting data types as defined in part
of the <code><a href="../ciao/CIAO_Component.pidl">
CIAO_Component.pidl </a></code>.
<li>Partial support for basic container/callback interfaces: <code>
<ul>
<li>CCMContext, SessionContext
<li>EnterpriseComponent, SessionComponent
</ul>
</code>
<li>Extension to CORBA Core
<ul>
<li><code>CORBA::LocalObject</code> interface has been
added a long time ago.
<li><code>get_component()</code> method in
<code>CORBA::{Object|LocalObject}</code>
interfaces.
</ul>
<li><code>HomeExecutorBase</code> interface
<li>Support (hand crafted) monolithic executor implementation
<li>Extension to IDL compiler and Typecode factory. IDL
compiler shall recognize all CCM keyword extensions but not
necessarily generate code for these added keywords.
<li>Adaptive configuration of Notification Service/Event Channels
<li>Partial implementation of <code>Deployment</code> module.
<!-- support some descriptors -->
</UL>
AT this stage, we only implement "enough" CCM defined interface
capability to allow manual implementation of components and a
simple framework that offer some remote installation/composition
capability. This will help design how CCIDL generated code
should look like.
<p>
<LI><b>CIAO 0.2 beta release</b> - (TAO 1.3.X, Apr. 2003)
<ul>
<li>Support for various RT and QoS Policies
<li>Support for policy-based adaptation mechanism
<li><code>HomeFinder</code> interface
<li><code>HomeRegistration</code> interface
<li>Configuration interfaces <code>
<ul>
<li>Configurator
<li>StandardConfigurator
<li>HomeConfiguration
</ul>
</code>
<li>Other basic container programming interfaces <code>
<ul>
<li>EntityContext
<li>EntityComponent
</ul>
</code>
<li>Extension to Interface Repository.
<li>IDL should generate correct client/server side mapping for
component extension
<li>CCIDL implementation that generates skeleton implementation for
<ul>
<li><code>Navigations</code>, <code>Receptacles</code>,
and <code>Events</code> interfaces of a components
<li>component executor and home_executor templates for
monolithic component implementation
<li>What else???
</ul>
<li>Complete <code>Deployment</code> implementation, assuming
the revised deployment specification will be available
<!-- Support more descriptors -->
</ul>
<p>
<li><b>CIAO 1.0</b> - (TAO 1.4, Oct. 2003)
<ul>
<li>Interface <code>SessionSynchronization</code> and other
interfaces in <code>Transaction</code> module, assuming
time permitting and
<a href="http://xots.sourceforge.net/"> XOTS </a> will be
available in April 2003 timeframe
<li>PSS functionality?
<li><code>CCM2Context, Session2Context, Entity2Context</code>
and <code>
<li>Support for <code>ExecutorLocator</code> based component
implementation
<li><code>ProxyHomeRegistration</code> interface
<!-- support complete descriptors -->
</ul>
<p>
</ul>
<!--#include virtual="/~nanbor/signature.html" -->
<!-- <hr> -->
<!-- <address></address> -->
<!-- <\!-- hhmts start -\-> -->
<!-- Last modified: Wed Dec 18 23:20:37 Central Standard Time 2002 -->
<!-- <\!-- hhmts end -\-> -->
<!-- <address>Nanbor Wang <nanbor@cs.wustl.edu></address> -->
</body> </html>
<!-- LocalWords: TODOs CCM IDL CCIDL CIDL backend idl
-->
|
