“Infrastructures
for the Design and Deployment of Customizable Web Portals in Wireless and
Thin-client Platforms”
K. Kontogiannis
Dept. of Electrical and Computer Engineering
As the popularity of the Internet continues to grow at
an exponential rate, easy and affordable access to on-line services is quickly
becoming an integrated part of everyday life. The project aims on developing
tools that will assist users to access, process, fuse, and browse, on-line data
content and services that are available by various Internet sites using thin
clients.
This
research focused on the use of the Web as an open infrastructure where related services
and tasks can be defined, composed, and enacted in a fully customizable way. As
services can be scattered virtually everywhere on the Web, we need to define a
Software Engineering architecture that allows for the separation of business
application logic from the client-side presentation logic. The three-tier
architecture is instrumental for the deployment of the distributed objects on a
Web-enabled environment.
For this project we proposed an open, multi-tier
architecture, where a service can publish itself, and easily be integrated with
other legacy components and services. The proposed architecture is composed of
three layers.
The first layer consists of a wide range of Web
clients, including Web browsers for handheld and embedded systems, or Java/Pure
and CORBA based applications running on fully loaded desktops. The second layer
relates to services provided by the Web server and application server. The Web
server captures the requests from Web clients and directs the requests to the
Application server. This can be achieved by the utilization of modules such as
Service Management, Service Localization, Service Composition, and Service
Invocation modules. The Service Management module can maintain a database of
the descriptions of the available services. It enables the deployed services to
dynamically register their information in a repository. The Service
Localization module is responsible for selecting the required services among
many available ones, according to the criteria set by the client process. The
Service Composition and Invocation module can provide a framework and a
scripting language for dynamically enacting and composing remote services. This
module serves as an integrator that allows back-end services and legacy systems
to be composed seamlessly. Finally, the third layer of the architecture deals
with the distributed services that can be invoked. These distributed services
could be CORBA wrapped back-end legacy systems and components, as well as Web
sites and data content that is accessible by thin clients. The research
challenges for this area include the design of techniques to specify, register,
localize, and invoke remote and heterogeneous services in a transparent way to
the client in Web enabled environments.
Furthermore, we proposed the design of a system
architecture where a meta integration language
specified in XML, determines the manner by which existing software applications
interact. Specifically, this meta-language allows for Event-Condition-Action
(ECA) rules, to encode the transaction logic by which services are invoked and
remote processes interact. As new services are added to the application server,
or as business processes change, all that is required are changes to the rules
that encode the specific transaction logic. Moreover, these changes require
relatively little effort to implement and consequently customize the behavior
of the system with respect to specific user requirements. In this context,
several issues must be addressed that relate not only to communication between
processes but also, to interactions that occur between formerly independent
software applications. In order to ensure interoperability with existing
standards, open communication with other systems is a strong requirement. The proposed service integration architecture
has three major components. The first component is the Web server that
intercepts events (e.g. upon invocation of a service or upon notification of
the termination of a service) and forwards them to the second major component,
that is the rule engine. The rule engine enacts Event-Condition-Action (ECA)
scripts by checking whether a service can be invoked (i.e. the conditions in an
ECA rule are satisfied), locating the service, and finally requesting the
service by utilizing Enterprise Java Beans (EJBs).
The third major architectural component is the service repository, which
operates in a similar way as a DNS module and relates names of services,
interface descriptions, IP numbers, ports, and URLs. We plan to use the WebSphere
server developed by IBM to implement the proposed architecture. In addition to
capturing incoming events, the Web server also provides an infrastructure that
simplifies the invocation of remote services by deploying EJBs.
These can dynamically load classes containing or wrapping the desired remote
services. Research challenges for this area include the design and
implementation of a scripting language that allows for Web services to be
composed and enacted in a transparent way to the client. Other tasks involve
the design of a Web enabled service invocation architecture that is scalable,
reliable, and robust.
For
these tasks we built Software Engineering tools and workbenches on top of XML
standards for Web service registration and invocation. Such standards include
WSDL, UDDI, and SOAP.