Journal reference: Computer Networks and ISDN Systems, Volume 28, issues 7–11, p. 1269.

CorbaWeb: A Generic Object Navigator

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.

Keywords

WWW, object orientation, CORBA, interoperability, scripting language, generic object navigator.

Introduction

In the last five years, most computing technologies have been influenced by the object-oriented approach: design methods, databases, components libraries, programming languages and distributed object-oriented systems. As [Black94] pointed out, WWW may be seen as an Object-Oriented Operating System. 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) [Berns96] and a set of basic operations (GET, POST, ...), and
• extensibility via the Common Gateway Interface protocol [McCool].

• a single uniform user interface to access all objects, (CorbaWeb aims at that), and
• simple scripting languages to incorporate new applications.
  We will see that CorbaScript permits one to access any service implemented by CORBA objects.

In this paper, we present a new model which defines shared information spaces. This model is supported by the CorbaWeb environment [Merle96]: 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 automatically generates HTML Forms from IDL interfaces and a third one generates an HTML representation [Berns95] of the object state. Currently, these scripts are CGI programs written in CorbaScript. CorbaScript is an interpreted scripting language to apply any operation 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.

Our Shared Information Space Model

Object Orientation

Object-oriented design allows the construction of applications using classes. Well-known benefits of object-oriented design [Wegner90] are encapsulation, extensibility, modularity ... These benefits can be preserved in distributed heterogeneous information systems [Manola93]. In our information model, we have the possibility to mix classical data and multimedia data: data objects (e.g. database), service objects (e.g. computational object) and multimedia objects (e.g. sound, image, video objects).

Distributed and Heterogeneous Environment

Clients and servers applications are running on different architectures and operating systems. Communication between several programs can be achieved using the same protocol (e.g. HTTP between Web clients and Web servers; IIOP [OMG94] between CORBA applications). Using these protocols permits one to have distributed and heterogeneous information systems.

Navigation and Invocation

We submit that a single uniform user interface can simplify information exploitation e.g. data browsing and service invocations. Users apply operations and show results always the same way whatever the kind of information 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.

Users' Point of View

In our Shared Information Space Model, information is displayed according to the user's profile. For example in a medical application, when a physician browses a patient medical folder, he/she sees every information about the 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 according to people who access it.
As the information space is shared between several users, an object access control policy must be installed to protect information confidentiality and to prevent anybody from accessing and modifying any information.

• The Interface Definition Language (IDL) to specify 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 servers as a gateway between the Web and SIS objects.

• The description of Web services using object-oriented technologies. Services are implemented in the most appropriate language (see CORBA section). They are accessible through a standard Web browser or through a specific CORBA client application.
• From the Web, the access to any Information System developed with CORBA even if this IS was not designed for WWW.

Our CorbaWeb Environment

C.O.R.B.A.: A Common Object-Oriented Architecture

• A client/server object-oriented invocation system: The communication between objects is supported by a standard stubs mechanism generated by the compilation of IDL descriptions. This separation hides distribution and permits heterogeneity between the service consumer (client) and the service producer (server).
• An adaptive object support policy: CORBA provides 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 (Interface Repository). It facilitates dynamic type checking and allows the construction of requests through the Dynamic Invocation Interface.

The Interface Description Language

The following example illustrates an IDL description. It defines the object interface computer. This interface contains three operations: is_prime_number 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;
  boolean is_prime_number (in Positive number);
  sequence<Positive> prime_numbers (in Positive number);
  sequence<Positive> decompose_into_prime_factors (in Positive number);
};

The CorbaWeb Architecture

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 represented 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 generate HTML documents to show request results.
• The language CorbaScript is a new language permitting one to write scripts which invoke dynamically objects. This language contains constructions 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 parameters into CorbaScript variables.
• The CORBA environment supports the heterogeneous distributed object-oriented system and the dynamic invocation mechanism (DII).
• The Interface Repository contains a graph of objects representing IDL descriptions. These objects are dynamically invoked to check invocations of scripts.
• The CorbaWeb Repository maintains CorbaWeb environment information. For instance, it stores representation and access control information. This information is structured by CORBA objects. It is handled by special scripts, also named meta scripts.

Thus, CorbaWeb dynamically furnishes a transparent 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.

CorbaScript: A New CGI Language

The first way of using the CorbaWeb environment allows the writing of CGI programs which invoke objects. These programs are written with the language CorbaScript. After describing the main features of the CorbaScript language, we show how to integrate in the Web a previous object computer via a CorbaScript program.

The CorbaScript Language

• The echo instruction outputs any value. It recursively explores structures, unions, arrays and sequences 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 View Meta Script).
• 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:
  test_construction ::= if condition then instructions1 [ else instructions2 ] end
  Instructions1 are executed if condition is true. Else instructions2 are executed.
• The condititional loop construction:
  loop_construction ::= while condition do instructions end
  Instructions are executed while condition is true.
• The exception management construction handles raised CORBA exceptions:
  block_construction ::= try instructions1
  
  [ catch exception instructions2 ]*
  [ catchany instructions3 ]
  end
  
  This construction executes instructions1. If an exception is raised by one operation of instructions1 then instructions2 are executed. Several exception types can be caught, each is managed by a separate catch clause. If an unexpected exception is raised then instructions3 are executed. If an exception is raised from a catch block (e.g. instructions2,instructions3) then it is propagated in the previous block.
• The invocation mechanism (. operator) permits operation calling, attribute getting or attribute setting on any CORBA object.

A script is a set of instructions handling values and variables. A CorbaScript value could be:

• 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 (+, or, <=, ...),
• a variable (e.g. $computer), and
• a CORBA object reference.

We have a complete mapping of IDL in CorbaScript so we can handle simple or composed IDL values (integer, character, string, sequence, union, ...). The shell performs type inference on the parameters; for example (10, "hello", True) 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.

The Computer Example

Fig.3. The Prime Service Page and its HTML Forms.

The following program illustrates the way to write a CGI script to access a CORBA object computer.

#! /usr1/bin/cwsh
echo "Content-Type: text/html\n\n<HTML>\n"
$computer := computer(my_computer:computerSvr:blanche)
if $QUERY_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 result ... 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 result ... end
echo "</HTML>\n"

1. a null value then the script generates HTML Forms (cf Fig.3) to use the service,
2. is_prime value then it invokes the is_prime_number operation of the $computer object,
3. prime_numbers value then it invokes the prime_numbers operation of the $computer object, or
4. decompose value then it invokes the decompose_into_prime_factors operation of this object.

CorbaScript simplifies the implementation of CGI scripts which interface objects with the Web. But this first approach looks like the standard CGI programming, the main difference being that CorbaScript 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 scripts to solve this engineering problem.

CorbaWeb: A Set of Meta Scripts

Exec Meta Script

#! /usr1/bin/cwsh
echo "Content-Type: text/html\n\n<HTML>\n"
if $QUERY_STRING <> "" then
  echo "<TITLE>" , $QUERY_STRING , "</TITLE>\n<BODY>\n"
  try
    execute ($QUERY_STRING)
  catchany
    echo "Exception raised: " , $EXCEPTION
  end
  echo "</BODY>\n</HTML>\n"
else
  # generates HTML Form for user's input
end

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.

Interface Meta Script

For instance, the computer object can be browsed via HTML Forms (cf Fig.4a) automatically generated by the Interface Meta Script. Then it can be invoked via the Exec Meta Script (cf Fig.4b).

Fig.4. Meta Script Execution Examples.

View Meta Script

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 attributes and operations on the object, and generates an HTML document presenting the object state. The script can also generate HTML forms to invoke object methods.

For instance, Fig.5 shows complex HTML documents generated by view scripts. These snapshots illustrate an hospital information system mixing multimedia information and structured object information. In this example, the user is a physician and its profile is mapped by the HTTP authentication mechanism.

Fig.5. HTML Pages of a French Hospital Information System.

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 information (scripts) to display any CORBA object according to users' profiles.

Meta Script Summary

• Distant invocations are supported by the meta script Exec.
• HTML Forms representing IDL object interfaces are automatically generated by the meta script Interface.
• 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.

Related Work

• The integration done by AnsaWeb appears at two levels. First, HTTP is substituted by IIOP protocol [Rees95]. Second, the IDL language is used to specify external Web services (CGI)[Edwards95]. Authors automatically generate stubs and forms for CGI programs from IDL specifications.
• Work on Web*[Web*] 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 operations on CORBA objects. Scripts are written with an extension of the Tcl language (TclDII [Jagannathan94]) which allows the dynamic invocation of operations 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[NeXT] allows the structuration of Web CGI applications thanks to objects. CGI aspects and HTML generation are encapsulated in WebObjects instances. A Web application is composed 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 according to user requests.
  An interface between WebObjects and CORBA is under work.
• The Apache+Python+ILU approach allows the access to ILU objects [ILU] via standard browsers. A framework based on Python [Python] is used inside the Apache server [Apache] to design new services. This integration increases service execution performances 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 [Everitt96], they plan to develop a support to dynamically discover objects like the CorbaWeb meta script View.

In W3Objects[Ingham95], all Web resources are seen as objects described by an interface. Then Web servers are represented by W3Object instances. This approach aims at providing an extensible web architecture.

Our approach focusses on the access to any CORBA object through generic mechanisms without specific developments for such objects. With CorbaWeb, users can display resources and invoke operations defined on them. In that way, our work provides the access to objects from Web instead of the design of Web applications using objects.
Let's note that specific Web applications can be developed with CORBA objects and accessed by the CorbaWeb environment.

Conclusion

The integration between WWW and Object-Oriented 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 CorbaWeb: 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 CorbaWeb environment.

Our shared information space model combines the benefits of both environments: WWW as an hypermedia browsing environment and CORBA as a structuring object-oriented system. We argue that WWW and CORBA will merge to provide the next infrastructure 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.

Bibliography

[Berns95] T. Berners-Lee and D.W. Connolly,
Hypertext Markup Language - 2.0,
Internet Network Working Group RFC 1866, MIT/W3C, November 1995.
<URL:ftp://ds.internic.net/rfc/rfc1866.txt>

[Berns96] T. Berners-Lee, R. Fielding, and H. Frystyk,
HyperText Transfert Protocol - HTTP/1.0,
Internet Network Working Group draft, Work in progress (expires August 19, 1996),
MIT/LCS, UC Irvine, February 19, 1996.
<URL:ftp://ds.internic.net/internet-drafts/draft-ietf-http-v10-spec-05.txt>

[Black94] A.P. Black and J. Walpole,
Objects to the rescue! or httpd: the next generation operating system,
ACM-SIGOPS 94, Sixth SIGOPS European Workshop,
Wadern Germany, September 1994.
<URL:ftp://sigops.informatik.uni-kl.de/sigops/papers/S.Postscript.Black>

[Edwards95] Nigel Edwards,
Object Wrapping (for WWW) -- The Key to Integrated Services?,
The AnsaWeb Project, Document Identifier APM.1464,
Architecture Projects Management Ltd, Cambridge, 1995.
<URL:http://www.ansa.co.uk/ANSA/ISF/1464/1464prt1.html>

[Everitt96] Paul Everitt,
The ILU Requester: Objects Services in HTTP Servers,
W3C Informational Draft 07-Mar-96,
<URL:http://www.w3.org/pub/WWW/TR/WD-ilu-requestor>

[ILU] Inter-Language Unification -- ILU
<URL:ftp://ftp.parc.xerox.com/pub/ilu/ilu.html>

[Ingham95] D. Ingham, M. Little, S. Caughey, S. Shrivastava,
W3Objects: Bringing Object-Oriented Technology to the Web,
Fourth International Conference on the World-Wide Web,
Boston, December 1995.
<URL:http://www.w3.org/pub/Conferences/WWW4/Papers2/141/>

[Jagannathan94] G. Alamsi, A. Suvaiala, C. Goina, C. Cascaval, V. "Juggy" Jagannathan,
TclDii: A TCL Interface to the Orbix Dynamic Invocation Interface,
TR, 1994.
<URL:http://www.cerc.wvu.edu/dice/iss/TclDii/TclDiiDoc.ps>

[Manola93] J.R. Nicol, C.T. Wilkes, F.A. Manola,
Object Orientation in Heterogeneous Distributed Computing System,
IEEE Computer 26, June 1993.

[McCool] R. McCool,
The Common Gateway Interface,
<URL:http://hoohoo.ncsa.uiuc.edu/cgi/overview.html>

[Merle96] P. Merle, C. Gransart and J.M. Geib,
CorbaScript and CorbaWeb: A Generic Object-Oriented Dynamic Environment upon CORBA,
In Proceeding of TOOLS Europe'96, Palais des Congrès, Paris,
Prentice-Hall, February 96.
<URL:http://www.lifl.fr/~merle/papers/TOOLS96.ps.gz>

[NeXT] The WebObjects Home Page,
<URL:http://www.next.com/WebObjects/>

[OMG92] Object Management Group,
Object Management Architecture Guide, Revision 2.0,
OMG Document Number 92.11.1, September 92.

[OMG93] Object Management Group,
The Common Object Request Broker: Architecture and Specification, Revision 1.2,
OMG Document Number 93.12.43, December 1993.
<URL:ftp://ftp.omg.org/pub/docs/1993/93-12-43.ps>

[OMG94] Object Management Group,
Universal Network Objects,
OMG Document Number 94.9.32, September 1994.
<URL:ftp://ftp.omg.org/pub/docs/1994/94-09-32.ps>

[ORBIX] The Orbix Home Page at IONA Technologies.
<URL:http://www.iona.ie>

[Python] The Python Language Home Page,
<URL:http://www.python.org>

[Rees95] O. Rees, N. Edwards, M. Madsen, M. Beasley, A. McClenaghan,
A Web of Distributed Objects,
Fourth International Conference on the World-Wide Web,
Boston, December 1995.
<URL:http://www.w3.org/pub/Conferences/WWW4/Papers/85/>

[Web*] Web* Home Page,
<URL:http://webstar.cerc.wvu.edu>

[Wegner90] P. Wegner,
Concepts and Paradigms of Object-Oriented Programming,
ACM OOPS Messenger, Vol 1 Number 1, Aug 1990.

About the authors

Christophe Gransart obtained his PhD in Computing Science from the University of Lille (LIFL) in 1995. His previous work was on BOX: A Model and a Language for Concurrent and Distributed Object-Oriented Programming. Now he is a lecturer at the University of Lille. His main areas of research are Distributed Object-Oriented Programming with CORBA, Cooperative Work and ATM. He is a member of the OSACA project.

Jean-Marc Geib is a professor in Computer Science at the University of Lille. At present he is the Director of the Computer Science Laboratory of the University of Lille, and the scientific administrator of the Objects and Actors Research Group. His main topic concerns object approach for distributed systems and parallel applications.