Iscc98cr.fm

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). The framework is implemented on top of a CORBA ORB and programmer with high-level abstractions, such as, agent provides 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), type services, 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 implements service
three roles (two of them have not been specified in section 3, for brevity). Each role requires one agent memory {
insert C++ {
(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)
{
insert C++ {
FUN Force {
role OrbatHandler with cardinality 1
with sharing all {
joining criteria {
service OperateOnOrderOfBattle;
insert C++ {
role SetOfUnitsHandler with cardinality 1
with sharing all {
accept(Start);
joining criteria {
service HandleSetOfUnits;
accept(GiveUnitInformation);
role UnitCommandLevelHandler with cardinality 1
accept(GiveUnitComposition);
with sharing all {
when (!fItIsTheOwner)
joining criteria {
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: Architecture and 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: Architecture and Specification, Revision 2.2, February 1998.

Source: http://www.tic.udc.es/~fbellas/publications/iscc98cr.pdf