Engineering CORBA-based Distributed Systems
Ramón Juanes+, Fernando Bellas*, Nieves Rodríguez* and Ángel Viña*
+Departamento de Electrónica y Sistemas, Universidad Alfonso X El Sabio, Madrid, CP/ 28691, Spain.
*Departamento de Electrónica e Sistemas, Universidade da Coruña, A Coruña, CP/ 15071, Spain. Abstract1 Development of distributed applications is a difficult
The origin of CABLE is the FUN (Functional UNit)
task. Object Requests Brokers (ORBs) facilitate the
methodology, that allows to break down the functionality
development of large and complex distributed
of a system into a set of agents and FUNs, a special class of
applications. However, the programmer still has to deal
agents that delegate part of their functionality into a
with a complex framework, which increases the learning
number of cooperating agents under the FUN’s
curve. In this paper, we present a middleware that tries to
coordination. We consider an agent as an autonomous
facilitate the transition from the design to the
entity that provides the agent community with services. implementation. The middleware is made up of a C++
CABLE, is built on top of Orbix 2.2 MT ), a
framework and an Agent Definition Language (ADL). Theframework is implemented on top of a CORBA ORB and
programmer with high-level abstractions, such as, agentprovides the programmer with high-level abstractions,
and FUN, and therefore giving direct support to the FUN
such as “agent” and “FUN” (a special class of agent that
analysis. CABLE is made up of a C++ framework
delegate part of its functionality into a number of
(implementing the core functionality) and an Agent
cooperating agents). ADL is a template-like language,
Definition Language (ADL). The purpose of ADL is to
which hides the underlying C++ framework from the
hide the complexity of the underlying framework from the
programmer (including the CORBA ORB). The paper
programmer, who only needs to learn ADL, a small subset
makes special emphasis in describing such a language.
of the CABLE framework and CORBA IDL (it is notnecessary for the programmer to learn the API of the
1. Introduction
CORBA ORB). ADL provides the programmer with a verysimple language for specifying the key components of an
Object Requests Brokers (ORBs), such as those
agent (for example, the services it provides), in a similar
way to a template, in which he/she will embed C++ (for
are making easier the development of large and complex
example, for the implementation of the services the agent
distributed applications. All of these frameworks allow the
programmer to invoke methods of remote objects as if they
Therefore, we have adopted a language based
were local. CORBA is standardized by the OMG, the
approach, instead of a framework based approach.
largest software consortium in the world, and provides the
Proponents of frameworks argue that frameworks are more
most interoperable solution. However, the programmer
open to developers, provide greater flexibility, and obviate
still has to deal with a complex framework, which increases
the need to learn yet another language. However the type of
the learning curve. This is specially true for users with no
language based approach adopted by CABLE does offer
previous experience in developing distributed applications.
some advantages over the framework based approach,
In this paper we describe a CORBA-based middleware,
namely, (1) ease of use (there is no need to learn a complex
CABLE, that tries to facilitate the transition from the
framework), which is specially true for inexperiencedusers, and (2) a closer mapping from agent design toimplementation (provides high-level abstractions such as
1. This work is supported by the EUCLID RTP 6.1 programme under
contract MAL1a/0262 and partially by CICYT TIC-96-0982.
Both the methodology and the middleware are being
used in the EUCLID RTP 6.1 European research project,
3. An example of use of the FUN analysis
undertaken by the GRACE (Grouping for Research intoAdvanced C3I for Europe) consortiu provides a
In order to clarify the concepts presented above, this
detailed description of the project. The demonstrator
section outlines the FUN analysis of a distributed multi-
being developed is made up of a number of graphical
agent browser for land military units (FORCE). The
facilities that help military users in the decision taking
objective of this browser is to allow a number of military
process. All the facilities, and the demonstrator as a
users to explore and analyse the ORBAT (Order Of
whole, have been analysed with the FUN approach, and
Battle), a tree of military units (divisions, brigades, and
so on), representing a future scene of the battlefield (with
The rest of the paper is organized as follows. Section
2 explains the FUN analysis, and section 3 presents anexample of its use. Section 4 describes CABLE, making
Objective
To allow a military user to explore and analyse
special emphasis in ADL. Section 5 compares our work
with other alternatives. Section 6 finishes with
browsers at the same time (the browser that ac-quires the resource ORBAT is the owner and can
modify the ORBAT until it releases it). 2. FUN analysis Strategy
All browsers will make use of the same agent handling the ORBAT.
The FUN analysis proposes an analogy between a
Services S1. To allow the military user to explore the OR- BAT, modify its structure and compare forces.
system and a human organization. Following the FUNanalysis, a system is broken down into a set of agents and
S2. To refresh windows when an owner modifies the ORBAT, if necessary (i.e., if a browser was
FUNs, which provide other agents/FUNs with services.
showing information that has just been modi-
Under this methodology, an agent is an autonomous
entity that provides the agent community with services. S3. To allow other agents to access the ORBAT
A FUN is a special class of agent that delegates part of
(to retrieve unit information, the sons of a unit, to
its functionality into a number of cooperating agents,
acquire/release the resource ORBAT, etc.). Resources R1. ORBAT.
A FUN is specified by giving the following
information: (1) its objectives, (2) the strategy for
Figure 1. FORCE FUN.
meeting its objectives, (3) the services it provides to itsclients (who could be an end-user or another FUN/
FORCE allows a user to explore the ORBAT in the
agent), (4) the resources it provides and can make use of
same way a file browser allows to explore a file system,
(a resource is basically a synchronization mechanism),
evaluate which is the effect of moving a unit to another
and (5) the roles that cooperate to provide its services. A
place in the tree and compare forces. Several users can be
FUN, in the same way as a human organization, specifies
running browsers at the same time, but only one of them,
the roles its members have to fulfil. This way, a FUN
the owner, can move a unit to another father, which
delegates part of its work into its members.
causes changes to the information stored in some units.
A role describes the part to be played by an agent
The rest of browsers have to update their windows if a
(that may itself be a FUN) within a FUN in terms of: (1)
change made by the owner affects the information they
the role title, (2) the cardinality (the required number of
members taking on this role), (3) its joining benefits, and
From the above description, it seems clear that there
(4) its joining criteria. Joining criteria are specified in
are two separate responsibilities in FORCE: the handling
terms of services and resources. An agent must satisfy
of the ORBAT and the graphical environment (which
the joining criteria in order to take on a role in a FUN,
allows the user to analyse the ORBAT in a convenient
which will make use of these services and resources in
way). Therefore it is quite natural to think of the browser
order to carry out its own services. Joining criteria allow
as a FUN that specifies a role for accessing the ORBAT,
plug and play of agents, as the FUN need not specify the
implemented by another agent. Figure 1 depicts FORCE
name of the agent fulfilling the role, but just what needs
FUN (the browser). Services S1 and S2 are provided to
from it. Joining benefits are specified in terms of
services, resources and service responsibilities (FUN’s
In order to carry out S1 service, this FUN draws on
services delegated to the agents playing this role), that an
the OperateOnOrderOfBattle service provided by the
agent gains as a consequence of joining the FUN in this
agent playing the role of ORBAT handler (figure 2). All
role. Joining benefits allow software reuse, i.e., agents
the instances of this FUN make use of such an agent. If
that offer most of what is needed to fulfil a given role,
the owner modifies the ORBAT, it notifies all FORCE
can be selected if the FUN supplies them with the
FUNs, in order for them to consider whether or not they
Finally, S3 service is delegated into the agent
playing the role of ORBAT handler. S3 service
These files, together with the C++ files provided by the
corresponds to OperateOnOrderOfBattle, and is used by
programmer, when linked, provide the agent’s
other agents. As we said in section 2, joining benefits do
implementation. The ADL compiler also allows to
not have a direct mapping into our software; it is only a
generate code in order to allow a CORBA agent
way to specify that a FUN, in this case FORCE,
communicate with a CABLE agent. As CABLE is built
delegates a service into an agent playing the
corresponding role, which actually provides the service.
Among the main components of an agent definition
file, we can mention:• Working memory. Global data to all activities (see
Cardinality
Exactly one, and shared by all the FORCE FUNs.
below) in the agent. • Initialise section. Actions to be carried out when the
Services: OperateOnOrderOfBattle (provides entries to retrieve unit information, the sons of
agent comes into existence (for example, for initialising
criteria
a unit, to acquire/release the resource ORBAT,
data members of the agent’s working memory).
and to change the father of a unit).
• Finalise section. Actions to be carried out upon the
Resources: ORBAT ([R1]).
destruction of the agent (for example, for deleting
dynamically allocated data members of the agent’s
benefits
working memory). Figure 2 shows an excerpt of afinalise section. Figure 2. Role 1 for FORCE FUN. finalise {
Hence, the functionality of FORCE has been broken
insert C++ {
down into two agents: the browser and the ORBAT
MyWorkingMemory. fOperateOnOrderOfBattle->Finish();
handler, each with its own responsibility. Breaking down
delete MyWorkingMemory.fOperateOnOrderOfBattle;
the software this way makes it easier to design and
implement than a monolithic version of FORCE.
Furthermore, part of its functionality, the management of
Figure 3. An excerpt of a finalise section.
the ORBAT (the agent taking on this role), can be reusedby other agents (those needing access to the ORBAT).
• Activities. A CABLE agent is composed of multiple
threads of control, called activities, which look like Adatasks. An activity is made up of a set of entries, a run
section and a private working memory. Entries are like
developed by the GRACE consortium, which gives
methods in normal objects, which other activities can
support to the FUN approach, and tries to facilitate the
call on. Whenever an activity is created, the underlying
development of CORBA-based multi-agent systems,
thread executes the run section, and controls the order the
making possible a closer mapping of the design to the
entries can be called on, by means of accept-select
implementation. It provides a C++ framework for
statements, in a similar way to Ada, i.e, a calling activity
developing this kind of systems, and an Agent Definition
is blocked until the called activity accepts a call to that
Language (ADL) for facilitating its use, that enables the
entry. The private working memory is a placeholder for
programmer to specify the main components of an agent.
variables that can be referred from the entries and the run
The current implementation runs on top of a CORBA 2.0
section. In the run section, it is possible to specify post-
rendezvous code after an accept statement for an entry.
platform is a network of SPARC and Intel computers,
When the execution of the entry completes, the calling
running Solaris 2.5.1 and Windows NT 4.0, respectively.
activity resumes its execution, and the called activityexecutes the post-rendezvous code. This maximizes the
4.1. The Agent Definition Language
parallelism. Figure 4 shows an excerpt of theimplementation of an activity (service).
ADL provides a syntax for specifying three types of
There are two types of activities: internal and
files, namely, service specification file (it specifies a
external ones. The external activities are also called
service in a similar way to a CORBA interface), typeservices, and its entries can be called from another agent. specification file (it specifies, in CORBA IDL, a type
In order for a client agent can access a remote service, it
used in an entry corresponding to a service), and agent
needs to construct a proxy for it, which enables access to
definition file (one per agent). In an agent definition file,
the remote entries. Services are identified by hierarchical
the programmer specifies the key components of the
names, and CABLE allows to build a proxy for a service
agent, and provides an implementation for them
from its name, which allows plug and play of agents.
(currently in C++), embedded into the ADL.
Whenever a proxy for a service is created, a thread is
The ADL compiler parses ADL files into C++ files.
created in the server agent for executing such a service.
Multiple instances of a given service can be running in
An agent definition file can define a FUN instead of
a simple agent. Figure 5 shows an example of thedefinition of FORCE FUN (section 3), which specifies
activity OperateOnOrderOfBattle implementsservice
three roles (two of them have not been specified in
section 3, for brevity). Each role requires one agent
memory { insertC++ {
(cardinality 1) providing the corresponding service.
Such agents can be used by other FUNs/agents (sharing
). CABLE searches on run-time available agents for
fulfilling these roles, launching them in the event they
<< Other entries. >> entry GiveUnitComposition (in DontUnitCode aCode, in EontUnitSide aSide, out DontUnitList aUnitList) { insertC++ { FUN Force { role OrbatHandler withcardinality 1 withsharingall { joiningcriteria { service OperateOnOrderOfBattle; insertC++ { role SetOfUnitsHandler withcardinality 1 withsharingall { accept(Start); joiningcriteria { service HandleSetOfUnits; accept(GiveUnitInformation); role UnitCommandLevelHandler withcardinality 1 accept(GiveUnitComposition); withsharingall { when (!fItIsTheOwner) joiningcriteria { accept(TryToAcquireTheOrderOfBattle) { service HandleUnitCommandLevel;
<< Other components (services, internal activities,
} while (!endOfInteraction); } // insert C++
Figure 5. An excerpt of a FUN definition. Figure 4. An excerpt of an activity (service). 4.2. The Manufacturer Agent
There is an agent, called the Manufacturer, running
Unlike services, which are created in a reactive
on a machine of the distributed system, whose role is to
fashion, internal activities are created autonomously by
locate or to launch a providing agent (if it was not
the agent. They can be used for carrying out internal
running) whenever an agent constructs a proxy for a
computations, monitoring, etc. There is a special type of
service. When an agent is no longer required (no other
internal activity, the core activity, which gets executed
agent is using its services), the Manufacturer kills it.
automatically after the initialise section.
Finally, it is worth noting that applications are launched
• Notification handling. An activity can subscribe to the
and killed from the control panel, which is a browser for
events generated by another agent. The subscribing
application configuration files. Such files specify the
activity need not know the name of the publishing agent
first agent to be launched for a given application. The
(having a proxy for one of its services suffices), which
rest of agents are launched in subsequent proxy
decouples publishing agents from subscribing agents.
The subscribing activity can specify the data which isinterested in for a particular event. ADL provides a
5. Related work
syntax for subscribing activities to specify a notificationhandler (the piece of code to be executed when a
also discusses the convenience of providing the
notification is received), and notification criteria (a piece
programmer with a language, CORRELATE, that
of code for the publishing agent can access the data
supports high-level abstractions in order for the
which remote activities are interested in, and send the
programmer need not learn a complex framework.
CORRELATE provides high-level abstractions for low-
• Agent inheritance. An agent can be defined by
level concurrent distributed programming (the authors
deriving it from another one. Derived agents inherit the
are building a I/O framework). The only point in
base agent’s activities, its core activity, service proxies,
common (obviously the domain of application is
notification criteria and working memory. The derived
different) with the approach presented here is the use of
agent can extend the functionality of the base agent and
a language for hiding the underlying framework from the
override the implementation of the inherited activities.
programmer. ADL is a template-like language instead of
a complete language like CORRELATE. Among the
[2] Microsoft Coporation, Distributed Component Object
benefits of using a template-like language based
Model Protocol - DCOM/1.0, January 1998.
approach, in which the programmer will embed C++, is
[3] Sun Microsystems, Inc, JavaTM Remote Method Invocation
that there is no need to learn yet another language, but
Specification, Revision 1.4, February 1997.
only some new constructs, and the possibility to use the
[4] Iona Technologies, Orbix 2.2 MT - Programming Guide,
huge amount of commercial software written in C++ (as
[5] OMG, The Common Object Request Broker: Architectureand Specification, Revision 2.0, July 1996.
Visibroker (a CORBA ORB for Java). It hides CORBA
[6] K. Broadent, P. Martin, CEPA 6. Advanced Information
IDL, and its mapping to Java, from the programmer, by
Processing and Communications - incorporating EUCLID
allowing him/her to define CORBA interfaces as Java
interfaces, and provides pass-by-value semantics for
objects. However, most of them will be passed (by the
[7] F. Matthijs, W. Joosen, B. Robben, B. Vanhaute, P.
underlying implementation) by using the Java object
Verbaeten, Multi-level patterns, in Proceedings of the
serialization mechanismhich is not CORBA-
ECOOP’97 Conference on Language Support for Design
Patterns and Frameworks, Jyväskylä, Finland, June 1997.
Voyager) is a mobile agent system in Java, and
[8] Visigenic, Visibroker for Java 3.2 - Programmer’s Guide,
it is integrated with CORBA. With respect to CORBA, it
provides a similar functionality to Caffeine, but it goes a
[9] Sun Microsystems, Inc, JavaTM Object Serialization
step further, because it allows remote-enable third-party
Specification, Revision 1.4.1, October 1997.
classes, but it suffers the same problem as Caffeine with
[10]ObjectSpace, Voyager 2.0 - Core Technology User Guide,
http://www.objectspace.com/voyager, 1997.
CABLE has not addressed the problem of making
[11]S. Nowacki, An alternative IDL C++ mapping, in
more transparent the mapping of CORBA IDL to the
Proceedings of the ECOOP’97 Conference on CORBA:
target language, C++ in this case. However, it provides
Implementation, Use and Evaluation, Jyväskylä, Finland,
the programmer with high-level abstractions, making
possible a closer mapping from the design to theimplementation, and hiding the underlying CORBAORB from the programmer. The transparency in the IDLto C++ mapping could be improved by using thealternative mapping proposed inn the C++Standard Library), on top of the standard mapping. 6. Concluding remarks
EUCLID RTP 6.1 has been running for 4+ years.
The functionality of the GRACE demonstrator wasbroken down into a number of C3I facilities, likeFORCE. In parallel with the development of CABLE,these facilities were implemented. At the beginning of1997, the first operative release of CABLE wasavailable, and all the facilities were agentised withCABLE, which enabled them to communicate oneanother. This agentisation was easy and quick, becauseCABLE provides a closer mapping from the design tothe implementation. The Agent Definition Languageallowed to express the key components of agents, and toembed the existing C++ code (developed before CABLEwas available). As CABLE services are executed indifferent threads of control, some C++ upper-levelclasses needed to be made thread-safe, however this didnot show to be an important problem. 7. References
[1] OMG, The Common Object Request Broker: Architectureand Specification, Revision 2.2, February 1998.
Bewegen und Heilen: Sport bei Angst und Depression Begleitmanuskript zum Vortrag von Dr. Dr. med. Herbert Mück, Facharzt für Psychosomati-sche Medizin & Psychotherapie – Sportmedizin/Ernährungsmedizin (Köln), am 06.11.2010auf dem 5. internationalen Hamburger Sport-Kongress Einleitung und Ausblick Jeder Mensch durchläuft mitunter allein schon im Verlauf eines einzigen Tages kürz
Bijsluiter: informatie voor de gebruik(st)er Folavit 4, 4 mg TABLETTEN Lees goed de hele bijsluiter, want deze bevat belangrijke informatie Dit geneesmiddel kunt u zonder voorschrift krijgen. Maar gebruik het wel zorgvuldig, dan bereikt - Bewaar deze bijsluiter. Misschien heeft u hem later weer nodig - Heeft u nog vragen? Neem dan contact op met uw arts of apotheker. - Wordt uw klac