Mobile Agents for World Wide Web Distributed Database Access

  Mobile Agents for World Wide Web.pdf (Size: 1.87 MB / Downloads: 0)
1 INTRODUCTION
THE widespread use of Java [1] in network-centric
computing, attributed mainly to its portability and
security control system, gives Java the lead in client/server
programming and mobile computing [2]. Moreover, the
already established Java database connectivity application
interface (JDBC API) [3], [4] and the constantly growing and
refining of JDBC [5] drivers have drawn the attention of
major database vendors. On the other hand, the World
Wide Web (simply Web) [10], [11], [12] is rapidly being
accepted as a universal access mechanism for network
information. The popularity of the Web suggests that Web
browsers may offer a compelling end-user interface for a
large class of applications, including database management
systems (DBMSs).
Thus, an important issue is to combine these two
technologies, namely Java and Web, for the retrieval of
information residing in database systems. The real challenge
is the formation of smart, lightweight, flexible,
independent, and portable Java DBMS client programs that
will support database connectivity over the Internet.
However, the currently proposed approaches [5] (i.e., the
applet/JDBC based ones) overload the client, in terms of the
size of downloaded code, and offer limited flexibility and
scalability. In this paper, we introduce a new approach for
the development of Java-based distributed client/server
applications over the Web. Our approach is based on using
mobile agents [6], between the client program and the
server machine, to provide database connectivity, processing
and communication, and consequently eliminate the
overheads of the existing approaches.
The proposed framework, called the ªDBMS-Aglet
Framework,º utilizes the technology of mobile agents and
demonstrates its effectiveness over a specific application
context (i.e., DBMS access). The framework is comprised of
a set of Java based agents that cooperate to efficiently
support Web database connectivity. The main agent, called
DBMS-aglet, acquires its database capabilities dynamically,
not at the client but at the server. The other agents of the
framework assist this dynamic acquisition. This idea
promotes a much more efficient way of utilizing the JDBC
API and the JDBC driver API and eliminates the overheads
of the various conventional approaches. Consequently, it
frees the remote client to perform other tasks.
The new form of Web-based database access supported
by ªDBMS-Aglet Frameworkº is shown to be more flexible,
scalable, and robust than the current JDBC-based database
connectivity. Furthermore, the framework supports lightweight,
portable, and autonomous clients as well as
operation on slow or expensive networks. The framework
is generic and portable and can be used not only within the
Web but stand-alone as well for direct Java database
connectivity. Although, in this paper, we present performance
results for accessing relational databases, it is worth
pointing out that our approach is not restricted to relational
databases but it can be used to access any type of database
or file system. This is an additional strong point of the
ªDBMS-Aglet Framework,º since it allows accessing different
types of resources in a seamless manner.
The implementation of the framework shows that its
performance is comparable to, and in some cases outperforms,
the performance of current approaches. In fact, in
802 IEEE TRANSACTIONS ON KNOWLEDGE AND DATA ENGINEERING, VOL. 12, NO. 5, SEPTEMBER/OCTOBER 2000
. S. Papastavrou and G. Samaras are with the Department of Computer
Science, University of Cyprus, CY-1678 Nicosia, Cyprus.
E-mail: cssamara[at]cs.ucy.ac.cy.
. E. Pitoura is with the Department of Computer Science, University of
Ioannina, Greece. E-mail: pitoura[at]cs.uoi.gr.
Manuscript received 10 Sept. 1999; revised 10 July 2000; accepted 10 July
2000.
For information on obtaining reprints of this article, please send e-mail to:
tkde[at]computer.org, and reference IEEECS Log Number 112702.
1041-4347/00/$10.00 ß 2000 IEEE
wireless and dial-up environments and for average size
transactions, a certain adaptation of the framework provides
a performance improvement of approximately a
factor of ten. For the fixed network, the gains are about
40 percent and 30 percent, respectively. These performance
results were gained while using the Aglets Workbench [7]
for the implementation of mobile agents. Since the Aglets
Workbench is more tuned towards functionality than
performance, we expect our framework to perform even
better. This assumption is substantiated by early experiments
conducted using Voyager [22] as our implementation
platform. We report these experimental results as well.
The remaining sections of this paper are organized as
follows: Section 2 presents the needed background material.
This includes a short introduction to Java, mobile agents,
and mobile aglets along with an evaluation of the current
applet-based approaches for web access to distributed
databases. In Section 3, we present the proposed DBMSaglet
framework, discuss its adaptations and effectiveness
within the various client/server computational models, and
present and compare its advantages to the current
approaches. A variation of the framework and its advantages
for accessing distributed multidatabase systems is
discussed in Section 4. In Section 5, we present a Java-based
hierarchy and generalization of the various frameworks and
discuss future work. A specialized-agents library for
database services is also presented. Performance evaluation
is presented in Section 6. Implementation issues and the
role of the implementation platform are discussed in
Section 7. Section 8 concludes the paper.
2 BACKGROUND MATERIAL
2.1 Supporting Technologies
2.1.1 Java and JDBC
Java is an object-oriented, interpreted, robust, secure,
architecture neutral, portable, and multithreaded language.
The uniqueness of Java lies on the fact that it combines both
compiled and interpreted code. The Java executable code
(called bytecode) runs on any hardware platform with a
Java interpreter or any Java-enabled Web browser. In
particular, the Java bytecode represents the instructions
for a virtual microprocessor called the Java Virtual Machine
(JVM). The Java Virtual Machine, also known as the ªJava
Interpreterº [2], is an abstract computer that runs Java
compiled programs. The JVM is ªabstractº in the sense that
it is software based and runs over various hardware
platforms. Another key characteristic of Java is the small
size of its compiled code. This feature enables Java
compiled classes to travel efficiently through the Web,
making it very attractive for network-centric programming.
A Java applet is a Java object-program that can run within
the context of a Java enabled web browser. A downloaded
Java applet can perform tasks only within the context of the
client's hosting web browser and it is not allowed to access
any local resources of the client for security considerations.
Another restriction is that Java applets are not allowed to
communicate with URLs other than the one they were
downloaded from.
The Java Database Connectivity (JDBC) is the Java
standard specification for accessing and manipulating
relational databases [4]. The JDBC consists of two layers:
The JDBC API that provides a Java interface to the relational
database, and the JDBC driver API that executes/implements
this interface. A client that employs the JDBC API
must first download to its environment a JDBC driver
before accessing a particular database. In this work, the
version of the JDBC drivers used was 1.1.
2.1.2 Mobile Agents
Mobile agents are processes dispatched from a source
computer to accomplish a specified task [14], [15]. After its
submission, the mobile agent proceeds autonomously and
independently of the sending client. When the agent
reaches a server, it is delivered to an agent execution
environment. Then, if the agent possesses necessary
authentication credentials, its executable parts are started.
To accomplish its task, the mobile agent can transport itself
to another server, spawn new agents, or interact with other
agents. Upon completion, the mobile agent delivers the
results to the sending client or to another server.
Aglet Technology [7] (also known as the Aglets Workbench)
is a framework for programming mobile network
agents in Java developed by the IBM Japan research group.
The IBM's mobile agent, called ªAgletº (agile applet), is a
lightweight Java object that can move autonomously from
one computer host to another for execution, carrying along
its program code and state as well as the data so far
obtained. One of the main differences between an aglet and
the simple mobile code of Java applets is the itinerary or
travel plan that is carried along with the aglet. By having a
travel plan, aglets are capable of roaming the Internet
collecting information from many places. The itinerary can
change dynamically.
An aglet can be dispatched to any remote host that
supports the Java Virtual Machine. This requires from the
remote host to preinstall Tahiti, a tiny aglet server program
implemented in Java and provided by the Aglet Framework.
A running Tahiti server listens to the host's ports for
incoming aglets, captures them, and provides them with an
aglet context (i.e., an agent execution environment) in which
they can run their code from the state that it was halted
before they were dispatched. Within its context, an aglet can
communicate with other aglets, collect local information
and, when convenient, halt its execution and be dispatched
to another host. An aglet can also be cloned or disposed.
To allow aglets to be fired from within applets, an
abstract applet class, called ªFijiApplet,º is provided as part
of a Java package, called ªFiji Kit.º The FijiApplet maintains
some kind of an aglet context (like the Tahiti aglet server).
From within this context, aglets can be created, dispatched,
and retracted back to the FijiApplet. For a Java-enabled web
browser to host and fire aglets to various destinations, two
additional components are provided by the Aglet Framework.
These are an aglet plug-in that allows the browser to
host aglets and an aglet router that must be installed at the
Web server to capture incoming aglets and forward them to
their destination.
PAPASTAVROU ET AL.: MOBILE AGENTS FOR WORLD WIDE WEB DISTRIBUTED DATABASE ACCESS 803
2.2 The Current Approach: Applets for Distributed Database Access
The challenge is to provide the Internet user with a Webbased
database connectivity with the lowest possible
overhead. To this end, various non-Java-based approaches
(e.g., CGI) have been proposed [16], [17]. The concept,
however, of running applets within Java enabled browsers
that utilize the JDBC application interface is increasingly
gaining popularity with major database vendors. There are
four ways a Java applet can gain access to a remote
relational database (Fig. 1), making use of one of the four
existing types of JDBC driver implementations.
The first approach makes use of the JDBC-ODBC bridge
driver (JDBC driver type 1). The JDBC-ODBC bridge
translates the JDBC API calls into ODBC1 calls and sends
them to an ODBC driver already installed on the server.
This approach requires the client applet to download, along
with its code, some ODBC binary code. Moreover, in many
cases, client database code must be preinstalled on the client
machine. Thus, this approach poses many extra layers of
overhead. Nevertheless, it is useful in accessing databases
that do not directly support JDBC [5].
The second approach makes use of a JDBC driver written
half in Java and half in native2 code. The client applet,
through this JDBC driver (type 2 driver), speaks directly to
the protocol of the remote SQL database. While this
approach is very efficient in terms of performance, it
requires the preinstallation of native code at the client.
The third approach is considered to be the most flexible:
It uses a JDBC driver written entirely in Java meaning that
the entire driver can be downloaded to the client applet.
The client applet, through this JDBC driver (type 3 driver),
speaks an intermediate language that is translated by a
middle-tier gateway at the server into a DBMS-specific
protocol and eventually passed to the SQL server. The more
vendor protocols the gateway speaks, the more databases
the applet can be attached to simultaneously. Despite the
extra layer of the gateway, this approach has drawn the
attention of many database vendors, including Borland
with DataGateway [18], IBM with DB2 client support for
Java [19], and Symantec with dbANYWHERE [20].
Finally, the fourth approach makes use of a JDBC driver
(type 4 driver), also written entirely in Java. The driver can
be fully downloaded to the client applet and speaks a
DBMS-vendor protocol directly to the remote SQL server.
The approach can efficiently serve the Internet user over the
Web, but for attaching to various SQL servers, several JDBC
drivers need to be loaded. Borland and Sybase have already
released type 4 JDBC drivers.
All four existing approaches require, to some extent,
downloading and initiating the JDBC driver on the client
machine, which is generally a very resource-consuming
procedure. Our primary concern is to simplify and relieve
the remote client so that it does not need to handle a
complex set of JDBC interface classes, but just the input of
requests and the expected formatting of the output.
3 DBMS-AGLETS: MOBILE AGENTS FOR DISTRIBUTED DATABASE ACCESS
In a nutshell, our idea is to use mobile agents between the
client and the server machine. Instead of having a DBMSapplet
at the client machine that downloads from the
remote SQL server, initiates a JDBC driver, and handles a
complex set of JDBC interfaces, our proposed DBMS-applet
creates and fires a mobile agent (or agents if necessary) that
travels directly to the remote SQL server. At the SQL server,
the mobile agent initiates a local JDBC driver, connects to
the database and performs any queries specified by the
sending client. When the mobile agent completes its task at
the SQL server, it dispatches itself back to the client
machine directly into the DBMS-applet from where it was
initially created and fired. Since our mobile agents posses
database capabilities, they are called DBMS-aglets.
3.1 The DBMS-Aglet Framework
To realize our approach, a number of processes are defined
to complement the existing agent execution environment
(i.e., the aglets). In particular, applets need to be enhanced
to provide database specific interfaces and be capable to
804 IEEE TRANSACTIONS ON KNOWLEDGE AND DATA ENGINEERING, VOL. 12, NO. 5, SEPTEMBER/OCTOBER 2000
1. Open Database Connectivity: An API that defines the routines for
accessing MS-windows databases.
2. Native code: Database-vendor specific code.
Fig. 1. Standard JDBC approaches.
host agents with database capabilities. In addition, the
existing aglets need to be extended to be database capable.
Finally, supporting aglets need to be provided to assist such
database-capable aglets in their negotiations with the SQL
server.
Specifically, to support the DBMS aglet framework, the
following components are needed:
. A DBMS-applet: The DBMS-applet is responsible for
forming a graphical client database interface that the
user can utilize to input database requests. Our
suggested DBMS client applet is an extension of the
abstract FijiApplet class.
. A DBMS-aglet: The DBMS-aglet is created within the
context of the DBMS-applet and is responsible for
carrying the user's request directly to the remote
database, executing it, and returning the results back
to the DBMS-applet context. Our suggested DBMSaglet
is a Java-based extension of the Aglet class.
. A DBMS-assistant stationary aglet: The DBMS-assistant
stationary aglet resides at the site of the SQL
server. Its responsibility is to inform any incoming
DBMS-aglets carrying database requests about the
available JDBC drivers and data sources and to assist
them in carrying out their requests. Our suggested
DBMS-assistant stationary aglet is an extension of
the Aglet class.
The DBMS-applet, the DBMS-aglet, and the DBMSassistant
aglet compose the suggested ªDBMS-Aglet Framework
º that provides DBMS-capable mobile agents for
distributed database access. The DBMS-Aglet Framework
builds on and extends a mobile agent framework, in our
case, the Aglets Workbench [7], that provides the facilities
for hosting and routing mobile agents. In turn, the mobile
agent framework can exploit a standard networking
infrastructure, such as tools and services for Web-based
access. Table 1 summarizes the complete Web-based DBMSaglet
infrastructure that consists of 1) the DBMS-aglets
framework, 2) the aglets framework, and 3) the standard
networking infrastructure.