CARDAMOM - An Enterprise Middleware for Building Mission and Safety Critical Applications
CARDAMOM is a middleware framework that provides features to configure,
deploy and execute near real-time, distributed and fault-tolerant applications.
CARDAMOM is multi-domain, as it is intended to be used by different Industrial
Domains for Command and Control Systems such as civil Air Traffic Control Systems,
or Defence Command and Control Systems. CARDAMOM is CORBA-based. CORBA enables
interoperability across hardware platforms and programming languages and thus is
suitable to integrate smoothly legacy systems.
CARDAMOM favours the integration of CORBA services and functionality implementations
that are available on the market (COTS and Open Source Software). Nevertheless, OMG
specifications cover several users needs but not all of them. In addition, available
implementations of some CORBA services do not provide the required Quality of Service
(QoS). The purpose of CARDAMOM is to provide an added-value execution platform including
services whose functionality and implementation fit with users requirements in the
mission and safety critical area.
CARDAMOM is initially developed by the CDO (Common Development Organisation), a
dedicated structure currently grouping together SELEX Sistemi Integrati and THALES and
ready to welcome new parties.
Services and tools provided by this version of CARDAMOM are listed hereafter:
- CORBA Component Model (CCM). One of the major advantages brought by this
model is to make a clear separation between the functional properties
(business logic) and the non-functional properties (technical services).
Therefore this model allows application developers to focus on business
code without worrying about the underlying execution platform. CARDAMOM
provides an OMG CCM compliant implementation of the "Session Component
category" and "Session Container API Type".
- CORBA Fault Tolerance. As systems supported by CARDAMOM are mission-critical
and thus require a high level of availability, mechanisms allowing to develop
fault-tolerant applications as well as a fault-tolerant middleware platform
(with no single point of failure) are included. CARDAMOM provides an implementation
of the Warm-Passive replication style, and the appropriate fault-tolerance
mechanisms allowing managing transparently failure detection, request retry and
redirection. In terms of consistency, an application may use the provided CARDAMOM
capabilities such as the State Transfer Framework that offers an automatic and
transparent update of replicas with strong replica consistency.
- System Management. This service supports the system technical supervision allowing
to handle and monitor the elements (nodes, processes, components, ...) making up
a system. It covers:
- The initial definition of the system configuration as well as its modification
during system operation
- The control of system elements (initialisation, start, stop, ...), including
capabilities to control the initialisation order and the termination order of
- The system monitoring including the detection of faulty system elements and
the monitoring of node resources CPU load, memory occupation, ...)
- The system reconfiguration allowing either manually or automatically to cope
with faults and thus to ensure the continuity of system operation despite
- The notification to subscribers (application software, administration tools, ...)
of status and configuration changes of managed elements, including filtering
capabilities in order to reduce the amount of information exchanged. It also
includes forwarding of application commands alarms.
- Life Cycle service which provides a framework for creating and deleting CORBA objects
and managing servants life cycle through pre-defined strategies, corresponding to the
selection of POA (Portable Object Adapter) policies. This service is accessible through
an interface providing location and access transparency. One major advantage of this
framework is to ease the use of the POA while allowing the selection of POA advanced
- Naming and Repository service which provides a scalable object repository to store and
retrieve object references and attributes. This service provides CORBA Naming and
Property Services compatible interfaces and an access independent from programming
languages. It also includes a wrapping of the CORBA Naming Service API in order to ease
the use of this service.
- Event service. This service supports asynchronous communication in compliance with
the COS Event Service. It provides add-on software that encapsulates ORB implementation
specific features such as event channel creation and that eases connection to typed and
untyped event channels in the Push model. It also includes an administration tool to
manage event channel configuration and their federation.
- Traces and Performance service allowing the run-time analysis of middleware platform as
well as application software, by providing traces that can be enabled / disabled at
runtime. It includes several selection criteria that can be set at runtime so as to
provide only information in which users are interested.
- Load Balancing service. Load balancing is dividing the amount of work that a computer
or server has to do between two or more computers/server so that more work gets done in
the same amount of time and, in general, all users get served faster; this mechanism
enhance server scalability. CARDAMOM provides a Load Balancing service which has been
designed so to allow a rather inexpensive per-request load balancing scheme. This means
that load balancing decisions are taken each time a client performs a request toward a
pool of servers. This service also provide a load balancing policy framework that can be
easily extended by the user with its own custom policies, so to exploit its domain
knowledge or specific request pattern.
- Time Service. All distributed real-time systems, in order to properly work, need to have
access to an accurate time service; moreover, many complex systems have to efficiently
maintain and share several different times, some of which virtual, i.e., their speed and
time origin can be controlled. To satisfy these application needs, CARDAMOM provides an
implementation of the OMG Enhanced View of Time standard. This specification provides
facilities for both UTC and controlled clocks as well as timers. In order to guarantee
adequate level of performances, scalability and availability, the clock service is
implemented so to be totally distributed and federated. Regardless of the clock that is
being read, our implementation guarantees that reads are always local, i.e., within the
- XML service provides a programming interface to parse XML documents, to execute XPath
queries, to manipulate a DOM tree and to serialise it. User applications can access to
the programming interface features via direct IDL interfaces definitions.
- Code Generation Tool is a convenient way to produce source code in native programming
language and speeds up the process of building a CARDAMOM-based software. The appropriate
code for initialising the required CARDAMOM services is automatically produced allowing
programmers to concentrate on his applications behaviour.
- Production Tool Chain that uses the CARDAMOM Code Generation tool and, from
OpenCCM, a compiler for OMG IDL 3.0, a CORBA 3.0 Interface Repository and its
- A Packaging/Assembling Tool Chain. All CORBA Components XML descriptors supported,
i.e.: Component Assembly Descriptor (CAD), CORBA Software Descriptor (CSD),
CORBA Component Descriptor (CCD) and Component Property File (CPF). Both Component
(*.zip) and Assembly (*.aar) archives supported.
- A Distributed Deployment Tool that provides commands to install or to remove
component packages; to create, to install, to remove or to destroy an assembly
package; and to build an assembly allowing to create all homes and components
and to establish connections.
Multi-environment: CARDAMOM is first developed on a reference platform (PC - Linux RedHat, TAO, JacORB) but is designed to run over other several target hardware platforms including Unix and Windows as well as to rely on several ORBs. It supports applications developed in C++ and Java.