In this paper we describe an approach that allows software components to adapt to their local execution environments at runtime, by undergoing dynamic reassembly from smaller constituents. This process occurs mostly transparently, without involvement of application-specific code. It is provided by an enhanced service management layer that builds components from environment-appropriate sets of unmutable and mutable sub-components.
We discuss our approach in the particular context of mobile agents, because these software elements migrate between local environments by definition, and hence present good applications for the kind of adaptation that we study. The illustrative example, which we highlight throughout the paper concerns a simple software management task dealing with the configuration of a set of distributed web clients.
We have chosen it as an efficient means to display characteristic features of our approach. We envision more practically driven use cases (beyond the scale of this paper) e.g. in the area of end-to-end network service configuration, where agents may roam to prepare remote equipment to conform to given central policies, whose interpretations and enforcement are environment-specific (e.g. some Cisco router functionality is only available via specific IOS commands, but not via the standard SNMP protocol; on other vendors' platforms the specific mix and feature set of available APIs may vary similarly). Diffserv [Bla98] for instance requires the coherent participation by multiple devices, with different functional behavior prescribed for e.g. edge and core devices, hence inserting yet another dimension of variation.
The use of mobile agents for system and network management tasks has been widely explored in the past [BPW98,FK01]. Last-generation efforts were boosted by the launch of Java, whose use of byte code makes it also suitable for execution on small consumer devices, e.g. under Java 2 Micro Edition [J2ME]. Java environments exist in a particular variety of concrete forms and can hide a large portion of the heterogenous nature of those devices.
Our particular agent-related aim is to reduce the footprint of mobile agents from the absolute sizes of their non-adaptive versions, and to device an adaptation mechanism with competitive relative runtime performance for meaningful workloads. For our prototype we have exclusively concentrated on a Java-based environment, and hence we regard transition of code only (weak mobility, i.e. no transition of state). Although we did not exploit this so far, adopting Java also presents us with the opportunity to relate to its intrinsic component models (JavaBeans and EJBs) [Tho98,MS00].
Mobile agents belong under the larger paradigm of code mobility. [FPV98] contains a concise overview of the existing technologies, design paradigms and applications involved. Code mobility can be defined as the capability to dynamically change bindings between code fragments and the location where they execute [CPV97]. Code mobility is concerned with the relative placement and migration of functionally related pieces of code and data in a distributed system. Mobile agents form a particular specialization of the paradigm, being concerned with autonomous behavior and the movement of code towards data sources. Because of the heterogeneous nature of real-world distributed systems, the need to cope with changing environments naturally arises for them.
Discrepancies between heterogenous environments can be commonly alleviated by introducing abstractions or virtualizations, such as those implicit in operating systems (file systems, etc.), virtual machines (Java core libraries) or runtime systems for mobile agents [LO98]. They form well established practice and work as long as there are common conceptual denominators, but they do also have a price tag both in terms of overhead [WC01] and in terms of loosing refinement (they expose only a shared subset of all functionality).
With dynamic adaptation we introduce another mechanism to refine the tradeoff involved. To highlight its merits we emphasize a scenario where fine-grained environment control (of the kind normally lost during abstractions) is needed, and where mobile agents need access to functionality not covered under an ``abstract'' umbrella (e.g. functional scope of Java core APIs). We simulate the scenario by requiring access to highly specific operating system resources (the Windows registry in one environment, and Unix configuration files in others, in the particular example), where access at times even requires going from Java through native language libraries.
The specific working example deals with a mobile agent that is responsible for the configuration of web browsers installed on workstations throughout a network. We assume that their configuration involves setting up Intranet homepages, disk caches, proxies, etc., and that it needs to be carried out by manipulating specific setup information on each host.
The mobile agent should be able to carry out its task for as large as possible an assortment of web browsers (Netscape Navigator, etc.) and operating systems (Linux, Microsoft Windows 2000, etc.) each. By looking at a popular example application that is supported on many different platforms we reach enough combinatoric variety to give our agents exploratory space for realistic adaptation.
For instance, the required mobile agent may not be implementable purely in Java. The configuration of the default web browser in Windows 2000 is based on entries in the registry database and not normally accessible through the (core) Java API. Apart from the operating system the configuration also depends on the kind of web browser.
In the rest of this paper we concentrate on this simple scenario for the purpose of illustration. It has the merit of using a mobile agent that needs access to environment-specific information, and can therefore highlight several properties of our approach.
We will show that our solution both recovers control (environment-specific aspects become visible and accessible again), and reduces the amount of code that is actually moved across the network, because subcomponents are only requested on demand. This has to be paid for by some new meta-information that must be maintained. We have developed ways to keep its amount and impact low on balance.
The overall intention of this work is to offer a methodology for creating mobile agents (or other software elements) which are able to adapt themselves to the environments where they are currently running. The variation is not achieved simply by entering an appropriate section of code as in a simple (and ``hard-wired'') if-then-else cascade, but by composing an environment-specific version of the agent that assembles only appropriate constituents.
The result leads to a slimmer version in most non-trivial instances, and to less movement of code across the network. The mechanism includes a concept for exploring the environment and the dynamic exchange of code parts as needed in order to work properly in the detected environment. The exchange of code parts is carried out without termination of the mobile agent, we therefore speak of dynamic adaptation.
We believe that this approach is particularily suitable and interesting to the IT management discipline, because there variations of equipment and environments are fundamental and always prevail, while fine-grained and therefore particular resource control is also needed at the same time.
In section II we place our approach alongside other uses of software adaptation, which we draw along a wide scale whose margins we describe as static and continous adaptation, respectively. After developing this local terminology, we present our mechanism in more detail in section III. This is followed by a short overview of a prototype implementation for configuration management of web browsers in section IV; more information on this can also be found in a related diploma thesis [Bra01]. Section V briefly investigates under which circumstances mobile agents can benefit from dynamic adaptation. Finally we present our conclusions.