CIAO Release Information and TODOs

• Current Status
• Project Outlook
• Short-term to-do list

Current Status

1. Latest News

   • Sun Aug 24 2003 - The first phase of RT support extension is complete. The RT extension enables developers to specify RT policy on a per component installation basis (per home, and the component created form the home). The extension includes the following major features:
     • A real-time ComponentServer: A real-time ComponentServer is capable of hosting real-time Container for components in real-time applications. To use the real-time ComponentServer, simply tell CIAO_Daemon to use the RTComponentServer via the '-n' flag.
     • RT extension for assembly descriptors (defined in .cad files) to specify component installations to RT policy sets defined in CIAO's real-time descriptors (defined in CIAO's .rtd files.) DTD definitions for .rtd files can be found in this file. An example .cad file that uses the RT extension and an example .rtd file that provides RT policy definitions can be found at:

       
            $(CIAO_ROOT)/examples/OEP/Display/descriptors/HUDisplay-rtcad.cad
            $(CIAO_ROOT)/examples/OEP/Display/descriptors/test.rtd
                         

     More documentation and comprehensive examples/tests/benchmark results for CIAO's RT extension will be added shortly.

   • Thu Jul 31 2003 - Arvind and Diego are starting to work on benchmarking and comparing the performance of CIAO and TAO. These performance test programs are available in the repository

   • Thu Jul 24 2003 - Bala and George are starting to work on a container mediated event delivering support. This will allow developers to specify the event deliverying strategy and the degree of QoS. The fist task is to integrate TAO's event channel into the container framework.

   • Tue Jun 3 2003 - The first Alpha release of CIAO is now available with ACE/TAO beta kit.

   • Mon Jun 2 2003 - We now have a CIDL compiler. Check out its README file for more information. Examples are also moved to here to use the new CIDL compiler to generate servant glue code.

   • Thu Apr 16 2003 - The HUDisplay example now also works on Linux platforms and allows you to remotely setup an application.

   • Sat Apr 5 2003 - Added the support for connection establishment and finished the multiple-component HUDisplay example. Check out the note to see how to play with it. You need to have Qt 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.

   • 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.)

   • Fri Mar 21 2003 - Finished the component implementations for the multi-component example. Next up, assembling mechanism.

   • 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 run_test.pl for more details on how this can be done.

   • Sun Feb 16 2003 - A new implementation for the per-host daemon process is now availabe under $(CIAO_ROOT)/tools/Daemon/. This application includes both ComponentInstallation and ServerActivator interfaces. It also comes with a command line utility program to interact with the daemon process. Please see its README file for more information.

     Implementation for ComponentInstallation interface uses ACE_Configuration to maintain persistency of component intallation data.

   • 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.

   • 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.

     It looks like we will have to go straight to our planned 0.2 release as our first publically available CIAO.

   • 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 here. These templates can also be used to help handcrafting the examples I'm working on.

   • Mon Jan 6 2003 - Both Jeff and Boris are working on the CIDL compiler implementation.

   • Tue Dec 24 2002 - Started working a multi-component handcrafted example in examples/OEP/Display/

   • Sat Dec 21 2002 - Added *nix Makefiles, MPC specifications and created MPC templates for CIAO clients, component implementations, and server tools.

   • Wed Dec 18 2002 - A perl script fits beautifully with the HelloWorld example.

   • 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.

   • Dec 15 2002 - Generic component server that can host multiple components with a proprietary config file. More information can be found here Next up, a trivial HomeFinder interface that can simply forward requests to a Naming Service.

   • 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.

   • Dec 10 2002 - This document captures how to "handcraft" a component and how this all will be automated in the future.

   • Nov 22 2002 - Completed the first handcrafted example HelloWorld component implementation. CIAO now also include a minimally functioning session container implementation.

2. Status of individual modules

   Modules	Status
   CCM Core	We are currently working on a prototype that enables remote component installation using the CCM ComponentInstallation 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. CIAO_Client: contains the client side stubs for CCMObject. All client programs that use CCMObject must link to this library. CIAO_Container: contains the interface definitions and CIAO's container implementation. All component implementations must link to this library. CIAO_Server: contains the stubs to access deployment framework. We'll need to use this to implement the deployment mechanism.
   TAO_IDL	TAO_IDL has been extended to handle and generate all the component related keywords but import. We are currently using the generated mapping, in combination to manually simulation of CIDL generated code to implement CCM component. TAO_IDL Check out TAO IDL compiler for more details.
   CIDL (Component Implementation Defintion Language) Compiler	An implementation that supports a subset of CIDL appropriate for DRE systems has been implemented. We do not have immediate plans to integrate Persistence State Service into the CIAO CIDL compiler. At present we support only a simple construct like the following: module component_composite_name { composition service component_home_executor { implements component_home; manages component_executor; }; }; The compiler generates operation implementations inherited from following interfaces: Navigation Receptacle Event CCMObject Component specific context Executor

3. TAO Modules required by CIAO: 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:
   1. TAO Main library.
   2. PortableServer
   3. orbsvcs/orbsvcs/Security
   4. IFR_Client

• CIAO 0.1 alpha release - (post TAO 1.3, Dec. 2002)
  • Default implementation of
    • Navigations
    • Receptacles
    • Events
    interfaces and their supporting data types that CCMObject interface requires. These interfaces are defined in CCM_Base.idl and CCM_Event.idl.
  • Default implementation of
    • CCMObject
    • CCMHome
    • KeylessCCMHome
    and their supporting data types as defined in part of the CIAO_Component.idl .
  • Partial support for basic container/callback interfaces:
    • CCMContext, SessionContext
    • EnterpriseComponent, SessionComponent
  • Extension to CORBA Core
    • CORBA::LocalObject interface has been added a long time ago.
    • get_component() method in CORBA::{Object|LocalObject} interfaces.
  • HomeExecutorBase interface
  • Support (hand crafted) monolithic executor implementation
  • Extension to IDL compiler and Typecode factory. IDL compiler shall recognize all CCM keyword extensions but not necessarily generate code for these added keywords.
  • Adaptive configuration of Notification Service/Event Channels
  • Partial implementation of Deployment module.
  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.

• CIAO 0.2 beta release - (TAO 1.3.X, Apr. 2003)
  • Support for various RT and QoS Policies
  • Support for policy-based adaptation mechanism
  • HomeFinder interface
  • HomeRegistration interface
  • Configuration interfaces
    • Configurator
    • StandardConfigurator
    • HomeConfiguration
  • Other basic container programming interfaces
    • EntityContext
    • EntityComponent
  • Extension to Interface Repository.
  • IDL should generate correct client/server side mapping for component extension
  • CCIDL implementation that generates skeleton implementation for
    • Navigations, Receptacles, and Events interfaces of a components
    • component executor and home_executor templates for monolithic component implementation
    • What else???
  • Complete Deployment implementation, assuming the revised deployment specification will be available

• CIAO 0.4 - (TAO 1.4, Jan 2004)
  • Usable version of CIAO tested on Linux and Win32.
  • CIDLC supports most of the IDL2 and IDL3 keywords.
  • Simple examples of usage is available in $CIAO_ROOT/examples