Computer Networks and ISDN Systems 28 (1996) 1269-1281
COMPUTER NETWORKS and ISDN SYSTEMS
CorbaWeb: A generic object navigator
Philippe Merle *, Christophe Gransart l, Jean-Marc Geib 2 Laboratoire d'lnformatique Fondamentale de Lille - URA CNRS 369, Universit[, de Lille 1, Bat M3, 59655 Villeneuve d'Ascq Cedex,
France
Abstract
The World Wide Web and Distributed Object-Oriented Systems (e.g. CORBA) provide future infrastructures for distributed client/server computing. This paper presents our work to provide the integration of CORBA objects into the Web: first, to describe Web services using object-oriented technologies and second to access any Information System developed with CORBA from the Web. We present a new Shared Information Space model with the following issues: Object Orientation Design, Distributed and Heterogeneous Environment, Users" Point of View, Object Invocation and Navigation.
Navigation over SIS is supported by CorbaWeb, a Generic Object Navigator, composed of metascripts allowing the access, the representation and the invocation of any CORBA object from the Web. These operations are achieved by scripts written in CorbaScript, an interpreted scripting language which can dynamically invoke any CORBA objects.
The WWW is the "killer system" of the 1990s to access distributed information and services on Inter- net thanks to its user-friendly uniform interface. But WWW users ask for many extensions: integrating new kinds of Web resources, extending Web browsers, changing stateless Web protocol. These problems can be overcome with a uniform model of resource interfaces, and transportable front-ends, that could be generically integrated in WWW.
In the last five years, most computing technolo- gies have been influenced by the object-oriented approach: design methods, databases, components
libraries, programming languages and distributed ob- ject-oriented systems. As [4] pointed out, WWW may be seen as an Object-Oriented Operating Sys- tem. It furnishes the canonical functionalities of an OOOS:
a uniform naming with the Uniform Resource Locators (URL),
• persistent objects implemented via http daemons and their host file systems, an invocation meta-protocol through HyperText Transfert Protocol (HTTP) [3] and a set of basic operations (GET, POST, etc.), and extensibility via the Common Gateway Interface protocol [ 11 ].
These authors point out some lessons about WWW that can increase the OOOS impacts: • a single uniform user interface to access all
1270 P. Merle et a L / Computer Networks and ISDN Systems 28 (1996) 1269-1281
simple scripting languages to incorporate new applications. We will see that CorbaScript permits one to access any service implemented by CORBA ob- jects.
A uniform paradigm to encapsulate and structure Web components can be achieved thanks to the Object Management Group's Common Object Re- quest Broker Architecture (CORBA) [15]. Its object- oriented approach brings modularity, flexibility and abstraction to the diversity of needed features en- countered into WWW. Moreover a parallel can be made between a set of objects and an hypertext-lin- ked set of resources. Hypertext navigational model can be used to navigate through CORBA objects, and so, WWW can be used as a uniform "any-ob- ject" presentation and invocation GUI.
In this paper, we present a new model which defines shared information spaces. This model is supported by the CorbaWeb environment [12]: A generic gateway between http servers and CORBA objects. This enables to navigate over and invoke CORBA objects as easily as users navigate over WWW documents. With CorbaWeb, a WWW client can navigate through CORBA object links using dynamically generated URLs for each object. These URLs refer to CorbaWeb scripts: a first one executes any operation on any object, a second one automati- cally generates HTML Forms from IDL interfaces and a third one generates an HTML representation [2] of the object state. Currently, these scripts are CGI programs written in CorbaScript. CorbaScript is an interpreted scripting language to apply any opera- tion on any CORBA object. Objects are dynamically invoked through the Dynamic Invocation Interface (DII): Invocations are checked thanks to the object IDL signatures retrieved from the CORBA Interface Repository.
2. Our Shared Information Space model
As the Web, a Shared Information Space (SIS) is a large set of information highly distributed and accessed by a high number of various cooperative users. A SIS is brought by distributed servers and accessed by standard client programs. Contrary to the Web, a SIS is structured by objects which can be
of various types. A user can navigate through a SIS by following links between objects. It can invoke any operation on these objects. The navigation is done thanks to a single uniform user interface (i.e. a browser) whatever information types. The navigator adapts itself to the user's profile and to the object types. A SIS manages object access control policies to protect information confidentiality and to prevent anybody from accessing and modifying any informa- tion. The four major issues of this model are:
(1) Object Orientation. Object-oriented design al- lows the construction of applications using classes. Well-known benefits of object-oriented design [21] are encapsulation, extensibility, modularity, etc. These benefits can be preserved in distributed het- erogeneous information systems [10]. In our informa- tion model, we have the possibility to mix classical data and multimedia data: data objects (e.g. database), service objects (e.g. computational object) and multi- media objects (e.g. sound, image, video objects).
(2) Distributed and Heterogeneous Environment. Clients and servers applications are running on dif- ferent architectures and operating systems. Commu- nication between several programs can be achieved using the same protocol (e.g. HTTP between Web clients and Web servers; IIOP [16] between CORBA applications). Using these protocols permits one to have distributed and heterogeneous information sys- tems.
(3) Navigation and Invocation. We submit that a single uniform user interface can simplify informa- tion exploitation e.g. data browsing and service invo- cations. Users apply operations and show results always the same way whatever the kind of informa- tion they manipulate and the computing environment they use. In general, one finds N user interfaces for N applications. In our model, we use 1 interface for all applications. The navigation through this space is done using the hypertext metaphor. For example in an application designed with object methodology, a user who navigates in it can follow the references between objects to browse information contained in objects.
(4) Users' Point of View. In our Shared Informa- tion Space Model, information is displayed accord- ing to the user's profile. For example in a medical application, when a physician browses a patient med- ical folder, he /she sees every information about the
P. Merle et a l . / Computer Networks and ISDN Systems 28 (1996) 1269-1281 1271
patient but when a hospital receptionist browses the same folder, he/she sees only a part of it (patient name, address). This example illustrates that the same information is not seen the same way accord- ing to people who access it.
As the information space is shared between sev- eral users, an object access control policy must be installed to protect information confidentiality and to prevent anybody from accessing and modifying any information.
To implement SIS environments, we want to reuse current technologies:
The Interface Definition Language (IDL) to spec- ify SIS object interfaces. The Common Object Request Broker Architecture (CORBA) to support SIS object servers. Web browsers as a single uniform user interface to navigate through SIS objects. The Uniform Resource Locators to access objects and to apply operations on them. The HyperText Markup Language to present the object state and Graphical User Interfaces on objects. CGI in Web seroers as a gateway between the Web and SIS objects. From a technological point of view, our work
concerns the integration between the Web and CORBA:
The description of Web services using object-ori- ented technologies. Services are implemented in the most appropriate language (see CORBA sec- tion). They are accessible through a standard Web
browser or through a specific CORBA client ap- plication.
• From the Web, the access to any Information System developed with CORBA even if this IS was not designed for WWW.
This integration model aims at providing the most important features of both environments: object-ori- ented programming from CORBA and hypermedia navigation from the WWW.
3. Our CorbaWeb environment
3.1. C.O.R.B.A.: A Common Object-Oriented Archi- tecture
Recognizing the urgent requirement for a standard in object-oriented application interoperability, the in- dustry has formed the Object Management Group (OMG) consortium to create a unified distributed architecture to promote object technologies. In 1991, it proposed the Object Management Architecture guide (OMA) [14]. The OMA gives an overview of a federated distributed object system. The first OMG specification was the Common Object Request Bro- ker Architecture (CORBA) [15]. CORBA specifies an object-oriented messaging facility for a dis- tributed object environment: the Object Request Bro- ker (ORB) allowing any object to invoke the ser- vices of any other object. Thus, CORBA provides interoperability between applications on different machines in heterogeneous distributed environments
I l t l l l i i i l i l latedac~ia~dc~Ifox ~IlORB irapleaxte~tations ~k Up-C~lli~tez, fao~ i~,~'~'~,~ One m1:~-4ace s~bs and skdexon for each obj ec~ WP~ i ORB-de!p=d~intedaoe ::::::::::::::::5::: On~int~fac~ for eaohObjectAdaptor biora/al eallintadace
kTT l l 111 l'l'l'l IIl l'l'i'l'111 ..... Implea~t~on {
~ " Requ~t ~v0catlcct
~ - ~ . ORB-d~?ead~tli~
Fig. 1. The Common Object Request Broker Architecture.
1272 P. Merle et a l . / Computer Networks" and lSDN Systems 28 (1996) 1269-1281
and seamlessly interconnects multiple object sys- tems. CORBA is specified independently of any programming language, since object interfaces are described in the Interface Description Language (IDL). A CORBA environment (cf. Fig. 1) is decom- posed into three main parts:
A client/server object-oriented invocation sys- tem: The communication between objects is sup- ported by a standard stubs mechanism generated by the compilation of IDL descriptions. This sep- aration hides distribution and permits heterogene- ity between the service consumer (client) and the service producer (server). An adaptive object support policy: CORBA pro- vides object adaptors to accommodate a diverse range of object features such as lifetime and granularity policies.
• A reflexive environment: CORBA provides at runtime objects to retrieve IDL information (In- terface Repository). It facilitates dynamic type checking and allows the construction of requests through the Dynamic Invocation Interface.
boolean is_prime_number (in Positive number);
sequence<Positive> prime_numbers (in Positive number); sequence<Positive> decompose_into _prime_factors (in Positive number);
};
This object type can be implemented with any lan- guage supported by CORBA. A language mapping defines how this language interfaces with CORBA. Currently, the mappings for C, C+ + , SmallTalk and Ada95 are specified by the OMG. Nevertheless, an effective computer implementation could be done on a supercomputer because prime algorithms consume many CPU resources. In the following sections, a computer instance is considered as a distributed resource.
3.3. The CorbaWeb Architecture
3.2. The Interface Description Language
The IDL language allows the definition of types, structures, exceptions and interfaces. An object inter- face is a set of attributes and operations applying to its instances. Each operation is specified by a return type, an operation name, a set of parameters and a list of related exceptions. Each parameter is specified by a call mode (in, out and inout), a type and a name. A type can be any basic IDL type (e.g. integer, double, boolean, char, string, object refer- ence) or constructed types (e.g. structures, se- quences, arrays, unions or object interfaces). Opera- tions can return exceptions to signal problems.
The following example illustrates an IDL descrip- tion. It defines the object interface computer. This interface contains three operations: is_prime_num- ber which computes if a number is prime, prime_numbers which computes prime numbers less than a number and decompose_into_prime_factors which decomposes a number into its prime factors.
interface computer { typedef unsigned long Positive;
To experiment the integration between the Web and CORBA objects, we have implemented the envi- ronment CorbaWeb. This environment acts as a generic gateway between http servers and CORBA systems: A Web server extension through the CGI protocol. Users invoke and navigate over CORBA objects as easily as they navigate over the World Wide Web. Any Web browser (Mosaic, NetScape, Hot Java) manages the user interactivity and sends users' actions to the Web server. CorbaWeb receives users' actions and executes operations on CORBA objects. These operations are invoked by scripts written in the language CorbaScript.
The CorbaWeb environment is supported by the following components (cf. Fig. 2): • With the standard WWW technology, any WWW
browser acts as a graphical user interface to browse and to invoke CORBA objects repre- sented both by HTML anchors to access objects and by HTML Forms to invoke operations on them.
• The CorbaWeb environment interprets the user's requirements by invoking objects. It is composed of many CGI scripts. They are written in the language CorbaScript. They invoke objects and
P. Merle et a l . / Computer Networks and ISDN Systems 28 (1996) 1269-1281 1273
wwwM°saic ]
Client
I HTTP protocol
Sewer
CORBA protocol
CorbaWeb Repository
Netscape WWW Client
Internet
iii =============================================
i::~::i:.i!i!it?!i!i!?;i i!i!i!} il :::::::::::::::::::::::::::
1 l,
Interface Repository I Ob Ser
Fig. 2. The CorbaWeb Architecture.
generate HTML documents to show request re- sults. The language CorbaScript is a new language per- mitting one to write scripts which invoke dynami- cally objects. This language contains construc- tions to manage variables, to control execution flows, to catch exceptions and to invoke objects. The CorbaWeb interpreter is an interpreter of the language CorbaScript. It translates CGI parame- ters into CorbaScript variables. The CORBA environment supports the heteroge- neous distributed object-oriented system and the dynamic invocation mechanism (DH). The Interface Repository contains a graph of objects representing IDL descriptions. These ob- jects are dynamically invoked to check invoca- tions of scripts. The CorbaWeb Repository maintains CorbaWeb environment information. For instance, it stores representation and access control information. This information is structured by CORBA ob- jects. It is handled by special scripts, also named meta scripts. Thus, CorbaWeb dynamically furnishes a trans-
parent access to all CORBA objects through a WWW server. In the next section, we present the main
characteristics of the language CorbaScript which is the basis of the CorbaWeb environment.
4. CorbaScript: A new CGI language
CorbaScript is a new interpreted scripting lan- guage developed from scratch. We have chosen to develop it to include the dynamic invocation opera- tion on CORBA objects in the CorbaScript nucleus. Integrating this mechanism in an existing language would be more complicated and the syntactic sim- plicity would not be obtained.
The first way of using the CorbaWeb environment allows the writing of CGI programs which invoke objects. These programs are written with the lan- guage CorbaScript. After describing the main fea- tures of the CorbaScript language, we show how to integrate in the Web a previous object computer via a CorbaScript program.
4.1. The CorbaScript language
A CorbaScript program is a sequence of the fol- lowing kinds of instructions: • The e c h o instruction outputs any value. It recur-
1274 P. Merle et al. / Computer Networks and ISDN Systems 28 (1996) 1269-1281
sively explores structures, unions, arrays and se- quences to display their field values. For instance, a structure is displayed by an HTML list. Each field is an item of this list. An object reference is displayed by an HTML anchor referring to a CGI script which displays the object (cf. Section 5.3).
• The assignment instruction ( : = ) sets a value to a variable. Variables are defined at their first use. A variable can be set with any IDL value.
• The conditional test instruction is constructed as follows: t es tcons t ruc t ion ' " = i f cond i t ion t h e n i n s t ruc t ions l [ e l s e ins t ruc t ions2 ] e n d
• Ins t ruc t ions1 are executed if condi t ion is true. Else ins t ruc t ions2 are executed.
• The condititional loop construction: loop_con- struction : : - - w h i l e condi t ion d o ins t ruc t ions
e n d • Ins t ruc t ions are executed while cond i t ion is true. • The exception management construction handles
raised CORBA exceptions: b lockcons t ruc t ion :: = t r y ins truct ions1
[ c a t c h excep t ion ins t ruc t ions2 ] *
[ c a t c h a n y ins t ruc t ions3 ]
e n d • This construction executes i n s t r u c t i o n s l . I f an
excep t ion is raised by one operation of ins truc-
t i o n s l then ins t ruc t ions2 are executed. Several exception types can be caught, each is managed by a separate c a t c h clause. If an unexpected exception is raised then ins t ruc t ions3 are exe- cuted. If an exception is raised from a catch block (e.g. i n s t ruc t ions2 , in s t ruc t ions3 ) then it is propa- gated in the previous block.
• The invocation mechanism (. operator) permits operation calling, attribute getting or attribute set- ting on any CORBA object,
Objects are dynamically invoked through the Dy- namic Invocation Interface. The language Cor- baScript and its interpreter hide the complexity of the use of the DII. The interpreter translates scripts into dynamic invocations. Invocations are checked thanks to the IDL signatures re t r i eved ' f rom the Interface Repository. The parameters are dynami- cally checked, and infered if necessary. The inter- preter dynamically constructs a request according to parameters. Then this request is sent to the ORB which executes the request on the right object and returns the result.
A script is a set of instructions handling values and variables. A CorbaScript value could be:
NCSA Mosaic: Document View
File ~tiona Navigate A_nnotate Help
° ° ° u ° . - , , , . " ...................................................................................... L _ I I Wel co~e to the Pr i me Service
Doe u me nt U R L: I o,0", oo j
Welcome to the Prime Service
[0ecompose] L 9 9 ~ ......... ] i n t o its p r i m e factors .
Fig. 3. The prime service page and its HTML forms.
P. Merle et al. / Computer Networks and ISDN Systems 28 (1996) 1269-1281 1275
any basic value like integer, float, character or string, a set of CorbaScript values like (10 , ' a ' , "hello" ), the result of an operation invocation on an object, any CORBA typed value composed of an IDL type and a set of values, any expression with standard operators (+, o r , < =, etc.), a variable (e.g. $ c o m p u t e r ) , and a CORBA object reference.
A CorbaScript object reference of a CORBA object is composed of four parts: an IDL object interface, an object name, an application name and a host name; e.g. computer (my_computer : com- puterSvr :blanche) refers to an object of type
computer with the name my_computer; this object is managed by the computerSvr application which runs on the host blanche.
We have a complete mapping of IDL in Cor- baScript so we can handle simple or composed IDL values (integer, character, string, sequence, union, etc.). The shell performs type inference on the pa- rameters; for example (10 , " h e l l o " , T r u e ) given as a parameter to a method call is translated into the appropriate IDL structure. The user does not give the IDL types neither for the items in the structure nor for the structure type; all this work is done by the interpreter.
4.2. The computer example
The previous object computer can be a Web service. But it is not directly accessible from the standard WWW. The CGI protocol provides a solu- tion to access it: designing a CGI script which acts as a gateway between a Web server and a computer instance. So this CGI is referred by the /cgi-bin/ prime__service URL. This CGI program generates the graphical interface to use an object computer (other solutions are possible). Fig. 3 shows an HTML document generated by this CGI script. It contains HTML Forms to call the various operations of this object. The action associated to each form is a URL to the CGI script with a distinct query string (e.g. ?is_prime, ?prime_numbers, and ?decompose).
The following program illustrates the way to write a CGI script to access a CORBA object computer.
#! /usrl/bin/cwsh
echo "Content-Type: text/html\n\
n<HTML>\n"
$computer:= computer(my_computer:com-
puterSvr:blanche)
if SQUERY_STRING = "" then
# generates HTML Forms (cf. Fig. 3)
# each text field of HTML forms is
named 'number'
end
if $QUERY_STRING = "is_prime" then ...
invokes computer and displays re-
sult.., end
if $QUERY STRING = "prime_numbers"
then
$result:~
$computer.prime_numbers($number)
echo "The prime numbers less than the
number ", $number, " are\n<P>\n"
echo $result
end
if $QUERY_STRING = "decompose" then ...
invokes computer and displays re-
sult.., end
echo "</HTML>\n"
The CorbaScript interpreter is named cwsh. It trans- lates CGI parameters into CorbaScript variables (e.g. $QUERY_STRING, $number). The variable $com- puter refers to a computer instance. This script generates an HTML document according to the value of the CGI variable QUERYSTRING, if it contains:
a null value then the script generates HTML Forms (cf. Fig. 3) to use the service, i s p r i m e value then it i n v o k e s the isprimenumber operation of the $computer ob- ject,
• prime numbers value then it invokes the primenumbers operation of the $computer ob- ject, or decompose value then it invokes the decompose__into_prime__factors operation of this object.
After each invocation, the script displays the invoca- tion result.
CorbaScript simplifies the implementation of CGI scripts which interface objects with the Web. But
1276 P. Merle et a l . / Computer Networks and ISDN Systems 28 (1996) 1269-1281
this first approach looks like the standard CGI pro- gramming, the main difference being that Cor- baScript is a dynamic interpreted scripting language specially designed for CORBA and OMG-IDL. Thus, the Web integration of several million objects and several hundred object interfaces requires to program a plethora of CGI scripts. In the next section, we introduce the concept of meta scr ip ts to solve this engineering problem.
5. CorbaWeb: A set of meta scripts
A me ta scr ip t allows the definition of generic actions on CORBA objects. These scripts take pa- rameters like object references or scripts. They apply meta operations on these parameters such as an object browsing or a script execution.
5.1. E x e c me ta scr ip t
This meta script takes a script as parameter, and then executes it. It allows user to invoke operations on any object from a Web browser. If the parameter is not set then the script generates an HTML Form and the user types its parameter script.
# ! /usrl/bin/cwsh echo "Content- Type : text/html\n\
n<HTML>\n"
if $QUERY STRING <> "" then
echo "<TITLE>", $QUERY_STRING,
"< / T I TLE>\n<BODY>\n"
try
execute ( $QUERY_STRING ) catchany
echo "Exception raised: ", SEXCEP-
TION
'1~1 NCSA Mosaic: Document View
File Opt ions Navigate Anno ta t e H__elp
Document Title: I~eb2Corba View t ~
Document UR/: [ http : l lb l anche : 800O lc~ i -b i nl~eb2morba/ i nter t
computer Weblnterface
computer operations
Iio_ 'mo_nom oq .umb : L
In,i~_numbers I number:120,,
tdooomposo_.nto_p, m _fo o.ol .umber: l
computer attributes
1
J
I M
Fig. 4. Meta script execution examples.
P. Merle et al. / Computer Networks and ISDN Systems 28 (1996) 1269-1281 1277
end
echo "</BODY>\n</HTML>\n"
else
# generates HTML Form for user's in-
put
end
This script presents the new instruction e x e c u t e and a special variable $EXCEPTION. The new in- struction takes one string as a parameter and exe- cutes it as a CorbaWeb script. This executed script can raise exceptions and the meta script must catch them and signal it to the Web user. The special variable $EXCEPTION stores the last exception. CorbaWeb unmarshalls an exception into an H T M L list as it unmarshalls complex IDL types. This generic unmarshalling is based on the possibility to explore a CORBA TypeCode which represents an IDL type at runtime.
This script aims at providing a distant invocation mechanism for mobile code. The next meta script reuses this meta script in order to provide a generic object browser which allows the invocation of any defined operation on any object type.
5.2. Interface meta script
This script takes an object reference as parameter and generates an H T M L document containing one HTML Form for each operation of the object IDL interface. The action of each form refers to the Exec meta script. From the object reference, the script retrieves its interface object. This object is managed by the Interface Repository. The script accesses the IR object and retrieves all operations and attributes of this interface. It generates a form for each opera- tion or attribute. When an operation takes parame- ters, it generates H T M L input text fields. For an enum parameter, it generates a popup menu (<SELECT>.. < / SELECT> in HTML).
For instance, the computer object can be browsed via HTML Forms (cf. Fig. 4(a)) automatically gener- ated by the Interface Meta Script. Then it can be invoked via the Exec Meta Script (cf. Fig. 4(b)).
5.3. View meta script
The previous meta scripts define basic meta oper- ations: invocation and browsing allowing users to access and invoke any object. But in a shared infor- mation space, objects must be displayed according to users' profiles as we have presented in our model. We define a profile as a kind of user such as a physician's profile or a receptionist 's profile. For each couple of one object type and one profile, we associate a view script. These scripts are composed of CorbaScript instructions which generate an HTML document representing the object state. They are stored into the CorbaWeb Repository.
Thus, the view meta script takes two parameters: an object reference and a profile. It retrieves from the CorbaWeb Repository the appropriate view script according to the object type and the profile. Then it executes the retrieved script. This script calls at- tributes and operations on the object, and generates an H T M L document presenting the object state. The
1278 P. Merle et a l . / Computer Networks and ISDN Systems 28 (1996) 1269-128l
• Patient DYLAN MICKAEL
• Date de l'ekmmen 16~m 1.095
• Mlt+d+lil#+ IR~I
• Dea:riptif IKM REIN
• Oozmzlmtaire~ D0~er R~'um~ d'lma~¢~i~
• Motifs di.hue U Bilan d~tmtmettd'ur~m~s~olide~ pble
Fig. 5. H T M L pages o f a F rench hospi ta l i n fo rma t ion sys t em.
script can also generate HTML forms to invoke object methods.
For instance, Fig. 5 shows complex HTML docu- ments generated by v i e w scripts . These snapshots illustrate an hospital information system mixing mul- timedia information and structured object informa- tion. In this example, the user is a physician and its profile is mapped by the HTTP authentication mech- anism. Note that the navigation across structured information is achieved by anchors. These anchors are URLs dynamically generated referring to the view meta script.
Then the CorbaWeb Repository and the View Meta Script are powerful tools to handle meta infor- mation (scripts) to display any CORBA object ac- cording to users' profiles.
5.4. M e t a scr ip t s u m m a r y
The concept of meta scripts allows the seamless integration of any CORBA object into WWW. These scripts are designed for general purposes and they handle meta operations on objects. As described below, meta scripts can be used in many ways: • Distant invocations are supported by the meta
script E x e c . • HTML Forms representing IDL object interfaces
are automatically generated by the meta script In ter face .
P. Merle et a l . / Computer Nem'orks and ISDN Systems 28 (1996) 1269-1281 1279
The meta script View allows the generation of HTML or MIME documents representing the state of any object. And in the near future, VRML documents could be generated by a VRML meta script to navigate in 3D objects.
The CorbaWeb environment can be incrementally extended thanks to meta scripts. Moreover meta scripts permit the integration of legacy CORBA ob- jects (i.e. not designed for WWW) without any object modification.
6. Related work
There are some other projects which investigate object-oriented design and the Web: • The integration done by AnsaWeb appears at two
levels. First, HTTP is substituted by IIOP proto- col [19]. Second, the IDL language is used to specify external Web services (CGI) [5]. Authors automatically generate stubs and forms for CGI programs from IDL specifications.
• Work on Web * [20] defines a model to access CORBA objects by a standard Web browser. The gateway is realized by writing layout pages i.e. HTML documents containing scripts to apply op- erations on CORBA objects. Scripts are written with an extension of the Tcl language (TclDII [9]) which allows the dynamic invocation of opera- tions on objects. But in TclDII, the user has to precisely define the IDL type of each parameter so this tool is hard to use for a non IDL-CORBA expert.
• WebObjects [13] allows the structuration of Web CGI applications thanks to objects. CGI aspects and HTML generation are encapsulated in We- bObjects instances. A Web application is com- posed of: • HTML templates structuring page layout and
referencing WebObjects, Declaration files maintaining WebObjects states and associating scripts to HTML Form actions, and Script files defining actions executed accord- ing to user requests.
• An interface between WebObjects and CORBA is under work.
• The Apache + Python + ILU approach allows the access to ILU objects [7] via standard browsers. A framework based on Python [18] is used inside the Apache server [1] to design new services. This integration increases service execution perfor- mances avoiding CGI process forking. WWW server is defined by an ISL interface. This permits to specific ILU client applications to access ILU objects managed by this server. With the ILU requester [6], they plan to develop a support to dynamically discover objects like the CorbaWeb meta script View. The previous approaches tend to design Web
applications using object-oriented technologies. Ap- plications are specifically designed to manage and encapsulate particular kinds of resources. But users can not directly access these resources or objects. Then the only solution to integrate a legacy object is to develop a Web application.
In W3Objects [8], all Web resources are seen as objects described by an interface. Then Web servers are represented by W3Object instances. This ap- proach aims at providing an extensible web architec- ture.
Our approach focusses on the access to any CORBA object through generic mechanisms without specific developments for such objects. With Cor- baWeb, users can display resources and invoke oper- ations defined on them. In that way, our work pro- vides the access to objects from Web instead of the design of Web applications using objects.
Let us note that specific Web applications can be developed with CORBA objects and accessed by the CorbaWeb environment.
7. Conclusion
The CorbaWeb environment has been imple- mented on a SUN Sparc station with Orbix 1.3 [17] for Solaris 2.4. The CorbaWeb prototype implemen- tation consists of 8,000 lines of C+ + code including the syntax analyzer, the interpreter engine and the CORBA specific code. All HTML figures in this paper are execution snapshots of the current proto- type. We plan to adopt another server API like Apache API instead of CGI to improve performances but the CorbaWeb architecture will not be modified.
1280 P. Merle et a l . / Computer Networks and ISDN Systems 28 (1996) 1269-1281
The integration between WWW and Object-Ori- ented Design is a great deal to manage the explosion of Web services. We propose a generic gateway to integrate any object on the Web server side. This integration is supported by the environment Cor- baWeb: A new scripting language CorbaScript and a set of meta scripts. Each meta script implements a meta operation on CORBA objects. At present, we defines three meta scripts: the Exec one executes any operation on objects, the Interface one generates automatically Graphical User Interfaces from IDL interfaces and the View one generates an HTML representation from the object state (via scripts stored in the CorbaWeb Repository). This set of meta scripts can be easily extended.
We are testing this environment on a hospital information system: It is modelized by objects and the users' interface is implemented by WWW browsers and CorbaWeb. This experimentation will aim at defining new required meta scripts and proposing an object access control policy for the CorhaWeb environment.
Our shared information space model combines the benefits of both environments: WWW as an hyper- media browsing environment and CORBA as a struc- turing object-oriented system. We argue that WWW and CORBA will merge to provide the next infras- tructure for distributed client/server computing. Thus we submit that Web resources could be implemented by distributed CORBA objects.CorbaWeb allows WWW clients to access, display, navigate over and invoke any CORBA object, therefore it provides a set of functionalities to support a generic object navigator.
References
[1] The Apache Home Page. http://www.apache.org [2] T. Bemers-Lee and D.W. Cormolly, Hypertext Markup Lan-
guage - 2.0, Interact Network Working Group RFC 1866, MIT/W3C (1995). ftp://ds.internic.net/rfc/rfc 1866.txt
[3] T. Beruers-Lee, R. Fielding, and H. Frystyk, HyperText Transfert Protocol - HTI"P / I.O, Internet Network Working Group draft, Work in progress (expires August 19, 1996), MIT/LCS, UC Irvine, February 19 (1996). ftp://ds. internic.net/interuet-drafts/draft-ietf-http-v 10-spec-05.txt
[4] A.P. Black and J. Walpole, Objects to the rescue! or httpd:
the next generation operating system, in: Proc. A C M - SIGOPS 94, 6th SIGOPS European Workshop, Wadem, Ger- many. (1994). ftp://sigops.informatik.uni-kl.de/sigops/ papers/S.Postscript.Black
[5] N. Edwards, Object Wrapping (for WWW) - The Key to Integrated Services?, The AnsaWeb Project, Document Iden- tifier APM.1464, Architecture Projects Management Ltd, Cambridge (1995). ht tp : / /www.ansa .co .uk /ANSA/ ISF/ 1464/1464prt I .html
[6] P. Everitt, The ILU Requester: Objects Services in HTI'P Servers, W3C Informational Draft 07-Mar-96. ht tp: / / www.w3.org/pub/WWW/TR/WD-ilu-requestor
[8] D. Ingham, M. Little, S. Caughey and S. Shrivastava, W3Ob- jects: Bringing object-oriented technology to the Web, in: Proc. 4h lnternat. Conf. on the World-Wide Web, Boston (1995). http: / /www.w3 .org /pub /Con ferences /WWW4/ Papers2/141 /
[9] G. Alamsi, A. Suvaiala, C. Goina, C. Cascaval and V. "Juggy" Jagannathan, TclDii: A TCL Interface to the Orbix Dynamic Invocation Interface, Tech. Rept. (1994). ht tp: / / www.cerc.wvu.edu/dice/iss/TclDii/TclDiiDoc.ps
[10] J.R. Nieol, C.T. Wilkes and F.A. Manola, Object orientation in heterogeneous distributed computing system, IEEE Com- puter 26 (1993).
[11] R. McCool, The Common Gateway Interface. ht tp: / / hoohoo.ncsa.uiuc.edu/cgi/overview.html
[12] P. Merle, C. Gransart and J.M. Geib, CorbaScript and Cor- baWeb: A generic object-oriented dynamic environment upon CORBA, in: Proc. TOOLS Europe'96, Palais des Congr~s, Paris, Prentice-Hall, Engelwood Cliffs, NJ (1996). ht tp: / / www.lifl.fr/~ merle/papers/TOOLS96.ps.gz
[13] The WehObjects Home Page. http://www.next.com/ WebObjects/
[17] The Orbix Home Page at IONA Technologies. http://www.iona.ie
[18] The Python Language Home Page. http://www.python.org [19] O. Rees, N. Edwards, M. Madsen, M. Beasley and A.
McClenaghan, A Web of distributed objects, in: Proc. 4th Intern. Conf. on the World-Wide Web, Boston (1995). http: / /www.w3.org/pub/Conferences /WWW4/Papers / 85/
[20] Web* Home Page. http://webstar.cerc.wvu.edu [21] P. Wegner, Concepts and paradigms of object-oriented pro-
gramming, ACM OOPS Messenger 1(1) (1990).
P. Merle et al. / Computer Networks and ISDN Systems 28 (1996) 1269-1281
Philippe Merle graduated from the Computer Science Department of the University of Lille (LIFL) in 1992. Since 1993 he has been a postgraduate student in the LIFL, the subject of his Ph.D. being a Generic Object-Oriented Dy- namic Environment (GOODE) for coop- erative applications using CORBA. He gave some courses about distributed client/server programming and CORBA at graduate and postgraduate levels. He is a member of the OSACA project, a
part of the R&D program on Advanced Communication called "Ganymede" and supported by "Region Nord/Pas-de-Calais".
Chr is tophe Gransa r t obtained his Ph.D. in Computing Science from the University of Lille (LIFL) in 1995. His previous work was on BOX 3: " A model and a language for concurrent and dis- tributed object-oriented programming". Now he is a lecturer at the University of Lille. His main areas of research are Distributed Object-Oriented Program- ming with CORBA, Cooperative Work and ATM. He is a member of the OS- ACA project.
1281
Jean-Marc Geib is a professor in Com- puter Science at the University of Lille. At present he is the Director of the Compute r Science Laboratory of the University of Lille 4, and the scientific administrator of the Objects and Actors Research Group. His main topic con- ceres object approach for distributed systems and parallel applications.
3 h t tp: / /www. l i f l . f r /GOAL/pvcbox/abs trac ts /cgthese fr . html
