Newcastle University e-prints
Date deposited:
9
th
March 2011
Version of file:
Author final
Peer Review Status:
Peer reviewed
Citation for item:
Ingham DB, Caughey SJ, Little MC. Supporting Highly Manageable Web Services. In: 6th International
World Wide Web Conference. April 7-11, 1997, Santa Clara, California, USA: Elsevier Science
Publishers
Further information on publisher website:
http://www.elsevier.com
Publisher’s copyright statement:
This is the author’s version of a work that was accepted for publication in
Computer Networks and ISDN
Systems
. Changes resulting from the publishing process, such as peer review, editing, corrections,
structural formatting, and other quality control mechanisms may not be reflected in this document.
Changes may have been made to this work since it was submitted for publication. A definitive version
was subsequently published in
Computer Networks and ISDN Systems
, volume 29, issue 8-13,
September 1997. DOI:
10.1016/S0169-7552(97)00044-5
Always use the definitive version when citing.
Use Policy:
The full-text may be used and/or reproduced and given to third parties in any format or medium,
without prior permission or charge, for personal research or study, educational, or not for profit
purposes provided that:
• A full bibliographic reference is made to the original source
• A link is made to the metadata record in Newcastle E-prints
• The full text is not changed in any way.
The full-text must not be sold in any format or medium without the formal permission of the
copyright holders.
Robinson Library, Univ
ersity of Newcastle upon Tyne,
Newcastle upon Tyne.
NE1 7RU. Tel. 0191 222 6000
1
Supporting Highly Manageable Web Services
D. B. Ingham, S. J. Caughey and M. C. Little
Department of Computing Science, University of Newcastle upon Tyne,
Newcastle upon Tyne, NE1 7RU, United Kingdom
{dave.ingham, s.j.caughey, m.c.little}@ncl.ac.uk
Abstract
This paper focuses on the management aspects of Web service provision. We argue that support for
manageability has to be considered at the design stage if services are to be capable of delivering
high levels of quality of service for their users. Examples of the problems caused by lack of
manageability include maintenance operations that necessitate service downtime, or difficulties in
ensuring consistency of information. We categorise management issues into those concerning a site
as a whole and those pertaining to individual services. Our approach to site management supports
the arbitrary distribution of services to machines, allowing the optimum cost/performance
configuration to be selected. Services can be easily migrated between machines, resulting in sites that
scale, both in terms of the number of services and the number of users. Service management issues
may be generalised as supporting evolution, for example, supporting changes to the functionality, the
presentation logic, and the overall look and feel of a service. Our approach, based on the separation
of functionality and presentation, allows such changes to be performed on-line and ensures that
updates are reflected consistency across the various pages of a service, or across services. This
approach also facilitates the development of services that utilise dynamic content for service
customisations, such as tailoring a service to match the profile of users. Furthermore, all
management operations are available through Web-based interfaces, making them accessible to a
broad range of users, not only specialist system administrators.
Keywords:
web; management; object-oriented; dynamic content; Dublin core; metadata
1. Introduction
The Web continues to evolve from the initial role as a provider of read-only access to static documentation-
based information, and is becoming a platform for supporting complex services. This evolution is being
partially driven by commercial organisations that are beginning to use the Web for critical applications, such
as customer support systems and electronic commerce, and not simply as a low-cost advertising medium.
These advanced services typically share a number of common functional requirements, such as support for
session-based interactions, generation of dynamic content and controlled update of persistent system state. To
facilitate their implementation a number of Web application toolkits have been produced, including our own
W3Objects [
Ingham95], which provide system support for these common features.
We believe, however, that providing support for the construction of Web services only addresses part of the
problem. Of equal, if not more, importance is the manageability of such services. Manageability encompasses
many issues, some relate to individual services while others are concerned with the collection of services that
together constitute a site. Scalability is an important aspect of site management so as to allow a site to grow to
support increased numbers of users and services. Service management is concerned with supporting change
while preserving consistency, both in terms of information and its presentation. If services are to be able to
deliver the high levels of quality of service demanded by users (customers), then manageability features have to
be designed in. This is particularly important for commercial services, where the consequences of providing
inconsistent information or suffering downtime for maintenance are often financial.
Another aspect of the changing Web is the increased use of dynamic content. Its use is becoming widespread,
not only for creating responses to a client-driven applications, but throughout services, in a system-driven
manner to support various customisation requirements. Examples include tailoring advertising to match the
profile of the user, or customising a merchant's catalogue based upon current stock levels. Such systems require
logic-based mechanisms to drive the customisations. The specification and maintenance of these logic
components is another service management issue.
This paper describes an architecture to support manageable sites based on the use of distributed object
technology. Our approach supports scalability by allowing arbitrary distribution of services to machines
2
allowing sites to be configured for optimum performance. Furthermore, configurations can be modified at run-
time without disruption.
To support manageability and customisation of services, we introduce a novel structuring technique, based on
the separation of presentation and functional aspects. This technique supports on-line service maintenance,
allowing changes to presentation and logic components to be performed. A particular feature is the ability to
ensure the consistency of changes to replicated components, such as an author's contact details, within a
service or across services.
A particular goal of this work is accessibility: traditionally service management was so complex a task that it
was reserved for only specialist system administrators. By allowing all management operations to be performed
via Web-based interfaces we aim to break down this technology barrier, making site and service management
accessible to non-specialists.
The remainder of the paper begins with an overview of the W3Objects system that has been used as a testbed
for our ideas. This is followed by a review of site management issues and how they are addressed by our
architecture. The next section focuses on service management, describing the model, an implementation
overview and several illustrations. An extended example is presented that demonstrates how the techniques can
be used to support the incorporation and management of resource metadata. Finally, we present our concluding
remarks and ideas for further work.
2. W3Objects Overview
Several research groups [
Rees95, Merle96] and commercial organisations [ActiveX, WebObjects] have seen
the benefits to be gained from the application of object-oriented techniques to various aspects of Web service
provision. Our system, W3Objects, uses distributed object technology, to assist in the construction of advanced
Web-based services [
Ingham95, Ingham96
]. In our model, Web resources are represented as objects, which are
encapsulated resources possessing internal state and a well defined behavior, rather than the traditional file-
based entities. The model supports abstraction since clients interact with W3Objects only through well-defined
published interfaces. The objects themselves are responsible for managing their own state transitions and
properties, in response to method invocations.
W3Objects may support a number of distinct interfaces, obtained via interface inheritance. Common interfaces
may be shared thereby enabling polymorphic access, for example, all W3Objects conform to an HTTP
interface, providing methods including httpGet() and httpPost(). The specific implementation of the
methods may differ between the different classes of object. For example, a simple W3Object for holding HTML
state may simply return this state in response to a httpGet() request.
Arbitrary classes of application object can be implemented using this framework, adding class specific
operations. Desirable properties, such as persistence and concurrency control are obtained via the use of
behavioural inheritance.
W3Objects are organised and named within contexts, which may be nested. W3Object server processes
(W3OServers) are simply active contexts. Objects are accessed using RPC and addressed by specifying the
communication end-point of their containing server and the name of the object within that server. Inter-object
communication is used thoughout W3Objects to support functionality such as referential integrity [
Ingham96]
and caching [Caughey97].
2.1 Web Access to W3Objects
Web access to W3Objects is provided though a gateway, implemented as a plug-in module for an extensible
Web server, such as Apache [
Apache]. The gateway is fully compatible with the CGI interface allowing
standard HTML forms to be used to create user interfaces to services. The Web server is configured to pass
requests for part of the URL space (for example, URLs beginning /w3o/) to the gateway module. The
remainder of the URL identifies the name of the required service and any parameters to be passed to it. The
module then binds to the requested named object within the nameserver (a standard context) and invokes the
appropriate method on it, e.g., httpGet() or httpPost(). Additional data associated with the request,
including URL-encoded data from the client and environment data generated by the server is grouped together
as a request object that is passed as a parameter to the HTTP interface operations. The request is passed on
through the nameserver object to the destination object which performs the necessary computation and returns
3
the results to the client, via the server. The diagram in Figure 1 illustrates the architecture through an example
W3Objects site.
‘extensible’
Web server
W3Objects
gateway
module
nameserver
HTTP
Web
browser
W3Objects
(services)
W3OServers
host boundary
naming
contexts
RPC
Figure 1: Architecture of a W3Objects site
3. Site Management
With the number of Web users increasing rapidly, site managers can expect the future to bring increased load
on their services. Similarly, it is likely that new services will be added to a site over time. Furthermore,
application-based services tend to be more computationally intensive than those that simply load and transmit
data files. Together these factors raise the issue of scalability; in order to continue to provide the desired levels
of quality of service, it is likely, that services will have to be partitioned across machines, with occasional
reconfiguration of the partitioning as load patterns vary or new services are added.
Using traditional server technology, applications are implemented as a number of disparate components,
including programs, HTML files, access control configuration, etc. Also, services typically share common
components, such as images or access control information, thereby creating dependencies between services and
between services and the server. In such conditions, migrating services can be a complex, error-prone
operation. For example, hypertext links, contained either in HTML files or embedded in programs, may
require updating, or changes to server configurations files may be required.
Due to the international nature of the Web, there is no appropriate time to bring down a service to perform
maintenance operations, therefore, a service provider would ideally like to perform such tasks on-line, without
the need for service downtime or major disruption.
The W3Objects architecture possesses a number of manageability features that help to address many of the
above issues, namely:
• Scalability through transparent distribution:
The architecture supports arbitrary allocation of
services to processes and processes to machines, in a manner which is completely transparent to users.
This provides administrators with great freedom in selecting the optimum cost/performance
configuration for their site.
• Transparent service migration:
Services may be migrated between processes and machines as
desired. Since services are encapsulated entities (discussed in more detail later), migrating a service is
achieved simply by invoking a migrate operation on the service object. This is accessible via a
programming-language API or via a Web-based management interface. The referential integrity
support inherent in the W3Objects system will ensure that all intra- and inter-object references (for
example, hypertext links) will remain valid after the migration and will be optimised over time to
provide the most direct paths [
Ingham96].
• Introduction and removal of services:
Services are made available to Web clients by registering
them in the nameserver. Installing a new application is simply a matter of starting the service and
registering it. Similarly services can be removed by deregistering them. These operation can be
4
performed while the system in on-line without disruption to users (naturally, service removal should
be performed with care.) Again, these operations are available either through a programming-
language API or a Web interface.
• Support for stateful services: Since W3Objects persist across requests, session-based state can be
held internally, either held in memory, or optionally on secondary storage. To aid the construction of
such services, application builders are able to use state persistence support provided by the W3Objects
class library.
3.1 Comparison with Alternative Techniques
In addition to the manageability features mentioned, the W3Objects architecture has several advantages over
both the traditional CGI-based mechanisms and the API-based schemes available with many of today's servers.
The mechanism of creating new processes to serve individual requests that is used in conventional CGI is
highly inefficient and results in unnecessary load on the server machine, thereby reducing the observable
performance of the server. It also makes supporting session-based services difficult, necessitating the use of
bespoke disc-based mechanisms to store session state, typically incurring additional performance penalties.
W3Objects services persist between requests and are accessed using RPC, resulting in high performance, and
the inherent ability to support session-based services.
The API mechanisms supported by many modern Web servers allow arbitrary applications to be loaded directly
into the Web server, thereby removing the need for CGI and its associated poor performance. Using this
approach, a separate module is typically installed for each application. The installation of user-code within the
Web server increases the probability of introducing bugs. A programming error in any of the installed modules
can result in the whole server crashing thereby rendering all applications unavailable. The single gateway
module used by W3Objects is a relatively simple piece of code that can be thoroughly tested. The effects of
programming faults within a W3Object application are contained to the process supporting that particular
application; other services will be unaffected.
Supporting session-based interaction using an API-based approach is complicated by the fact that most servers
use a multi-process architecture, making it possible for several instances of an application to be executing in
parallel. Since individual requests may be directed to any of the available server processes, external persistence
mechanisms are required to synchronise session-state between application instances.
4. Service Management
A Web service may be thought of as consisting of both functional and presentation components. For example,
the functional requirements of a search engine can be summarised as the ability to query a database based upon
some search criteria. The presentation requirements include providing usage instructions, accepting search
terms and returning results to the user. From a client's perspective, a service is simply seen as a collection of
pages. The server creates these pages either by returning some static data (e.g., usage instructions) or by
populating templates with data from programs to create dynamic content. In general, dynamic content may
either be used as the response to a client-driven request (e.g., the results of a search request) or in a system-
driven manner to support various presentation customisations, such as tailoring advertising to match user
profiles. The presentational aspects of a service can therefore by sub-divided into static and dynamic
components. Frequently services are implemented without a clear distinction between functionality and
presentation. For example, templates may be embedded within programs or the computation concerned with
the primary role of the service may be tied together with the computation concerned with presentation
customisation.
Service management is primarily concerned with supporting changes to services as they evolve over time.
Experience has shown that updates are often made to the look and feel, the logic that drives customised
presentations, and the functionality. We argue that combining functional and presentation aspects of a service
together complicates the task of performing change. Consider, as an example, the effects of modifying the
contact details of a service administrator. It is likely that this information is replicated on every page of the
service. Ensuring that all instances are consistency updated is a time-consuming and potentially error-prone
activity. Furthermore, instances may exist in both static and dynamic components. Although a trivial change, it
is likely that updating a presentation template within an application would require the skills of a programmer.
There is also the danger of accidentally interfering with the functional aspects of the service. This is more of an
issue when updates are required to the presentation logic of a service.
