Document Sample
Middleware Powered By Docstoc
					                 Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

          WebFrame: a Multi-Phase Reconfigurable Middleware Platform

                           Fan Guochuang,Chen An, Zhang Wenbo,Huang Tao
                                Technology Center of Software Engineering
                            Institute of Software, Chinese Academy of Sciences
                                         Beijing, 100080, P. R. China

                       Abstract                              systems are creating new web computing environments
                                                             that are characterized by a high degree of dynamism.
   Web application servers (WASs) are middleware             As the new generation middleware platforms, WASs
platforms for deployment and execution of component-         should address an increasingly diverse range of
based web applications. To cater for an increasingly         changing QoS requirements [7~9]. These changes may
diverse range of QoS demands, WAS must be capable            occur from the design-time, deployment-time to run
of adaptation during execution to modify itself and to       time. We distinguish two types of changes:
respond to changing conditions in its external               programmed changes are foreseen and anticipated by
environment. To accommodate such changes, WAS                the system designer, while evolutionary changes are
should provide both deployment-time configurability          unanticipated and become necessary over the execution
and run-time reconfigurability. Unfortunately, most of       lifetime of the system. However, it is impossible to
the mainstream web application servers adopt a               construct a ready-made platform for cater for all those
monolithic architecture and “black box” philosophy to        changing QoS needs.
their design, and fail to properly address such                  To achieve the accommodation of those changing
requirements. In our point of view, adaptation and           QoS requirements, WAS must be adaptable and
reconfigurability of WASs should be available at any         flexible enough during execution to modify itself and
time of the whole lifecycle. In this paper, a middleware     to respond to changing conditions. WASs should be
architecture (WebFrame) that supports multi-phase            capable of both deployment-time configurability and
adaptation      using      computational       reflection,   run-time reconfigurability [8] so that their service
microkernel, and component techniques is proposed            implementation can be reconfigured dynamically at run
for web application servers. The architecture is             time to adapt to changes in the environment and
structured into five layers. Both deployment-time            provide support for fine-grain resource management.
configuration and run-time reconfiguration at multiple       Unfortunately, the current generation of mainstream
layers is supported in this architecture. The key insight    WASs such as BEA Weblogic and IBM Websphere,
to this work is the MService Reconfiguration design          which typically adopt a monolithic architecture and
pattern, which provides dynamic adaptation at run            “black-box” philosophy to their design[11,12], fails to
time by swapping in/out the optional middleware              fully support for (re)configurability and open
components. The comparative evaluation of the                engineering[13]. In Iona’s Orbix2000, there have been
performance impact of reflection and multi-phase             some efforts to introduce reconfigurability but not
reconfigurability on systems are given.                      completely. Despite the usefulness of some reflective
                                                             features, the degree of support for customization and
1. Introduction                                              dynamic adaptation is only partial, and the extent to
                                                             which elements of the design can be opened and
   Web application servers (WASs), which are                 exposed to the programmer is severely limited[13]. In
considered to be one of the most exciting enterprise         our point of view, a reconfigurable architecture
technologies today [1], have become very popular in          covering all aspects of the design and the different
the last few years [2, 3]. They provide middleware           phases of a WAS life cycle is needed, and the
platforms that offer basic services to support for the       architecture supports dynamic customization and
component-based web applications [4~6]. Recent               reconfigurability at multiple layers.
advances in distributed, mobile, and ubiquitous

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                           1
                Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

    The paper proposes an approach to the design of a          To provide the capability of customization,
reconfigurable and open WAS (referred to as                 flexibility and reconfigurability, the Microkernel
WebFrame) based on the concept of reflection,               architectural pattern [15] is applied. As illustrated in
supplemented by the marriage of microkernel                 Figure 1, the basic services are separated from the
technology and component technology. The approach           common services by the microkernel. The common
followed for the design of WebFrame is driven by two        services are reserved in the kernel while the basic
principles: clear separation of concerns and What You       services that can be reconfigured or customized by the
Need Is What You Get. The first principle requires a        application programmer are moved out from the
clear and easy to understand decomposition of the web       kernel. The microkernel also serves as a socket for
application server into modules. The second principle,      plugging in these services and coordinating their
WYNIWYG, requires that only the required                    collaboration.
functionality is present. Whenever more functionality
is required, it can be easily added either statically or
dynamically. When some functionality is no longer
required therefore, it can be removed.
    In this paper, a middleware architecture
(WebFrame) that supports multi-phase adaptation
using computational reflection, microkernel, and
component techniques is proposed for web application
servers. The architecture supports both deployment-
time configuration and run-time reconfiguration.
Dynamic reconfiguration allows modifying the
architecture of WASs and Web applications at run-time
and therefore it is possible to choose at any time only
the functionality that is required. The key insight to       Figure 1. The structure of reflective microkernel
this work is the MService Reconfiguration pattern,
which provides dynamic adaptation at run time by               All services are managed by the MService Server.
swapping in/out the optional middleware components.         Every service binds itself a Meta-interface, which is
    The rest of this paper is structured as follows.        implemented by a class called MService (Meta Service)
Firstly, the reflective microkernel structure for WASs      ,which is the most basic unit of services. It not only
is described in section 2. In section 3, five-layer         provides Meta information and the interfaces that
structure of WASs and a multi-phase reconfigurable          control the life cycle of a service itself, but also offers
architecture are presented. The service reconfigurable      additional interfaces that tailor non-functional QoS
framework is described in Section 4. Section 5              demands. MService provides reflective access to the
illustrates    the     implementation     of     runtime    representation of a particular service in terms of its set
reconfiguration of services and components. Section 6       of methods and associated attributes. Information
presents preliminary performance results. Section 7         about the internal structure of a service can be obtained
discusses the related work. Section 8 concludes the         from the interfaces of MService. System and
paper lastly.                                               application code may use MService to inspect the
                                                            internal configuration and behavior of a service and, if
2. The    Structure               of       Reflective       needed, reconfigure it to adapt to changes in the
                                                            environment and, therefore changing its own behavior.
   Microkernel                                              The microkernel consists of these following common
    A web application server provides two categories of              Server Configurator, which is started first,
the services: i) Basic services for component-based                  reads the basic configuration information from
transactional web applications. For example,                         the system configuration description file
transaction service, component container, messaging                  (.XML) and loads all component loaders.
service, naming service, and hot deploy service are                  Loader Repository contains many Service
basic services. ii) Common services that provide the                 Loaders, which can load physical resources
most essential services for those basic services. One                such as component binary file and physical
common solution, which has been widely used in                       devices. A service loader can inspect the
“black box” design, is to hard-code them in the system               component type of a service and adapt to
at compile time.                                                     change the right manner to load that service.

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                              2
                 Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

        MService Repository maintains all services           Reconfigurator service has been started successfully,
        that are registered successfully in the              one can reconfigure WASs to adapt to the changing
        MService Server. Each service’s current state        requirements at any time from the design-time to the
        is maintained in the Service Repository, as          run-time. Basic services or upper components can be
        well.                                                added, removed, and replaced at run-time. WASs can
        Service Dependency Manager provides the              be reconfigured at multiple phases of their lifecycle
        management of the dependency relationship            from the design-time, deployment-time to run-time.
        between services.                                    The dynamic reconfiguration entities can be common
        MService Communication Manager deals with            services, basic services and application components.
        communication protocols, message arrivals,
        dispatching, and marshalling/unmarshalling           3.1. Kernel Layer
        etc. Clients communicate with services using
        adapters provided by the microkernel.                   The most essential services are reserved in the
        MService Server is the server of all MServices.      microkernel. MService Server is started after the
        Client can interact with MServices though the        Server Configurator dynamically loads the basic
        invoke method of MService Server.                    configuration   information      from   the    system
   Since the microkernel is able to observe and              configuration description file at system startup time.
manipulate itself through these services, we refer to the    All the services in the reconfiguration layer are
concept of reflective microkernel.                           configured and started by the microkernel after kernel
                                                             services are started. To meet the particular
3. A      Multi-phase Reconfigurable                         requirements of applications, the Reconfiguration
   Architecture for Web Application                          Layer can be statically customized and configured in
                                                             system configuration file.
    Separation of concerns is an essential issue in          3.2. Reconfiguration layer
reflective systems. The usual approach is to regard web
applications as the base-level and basic services and           All the basic services outside of kernel are
common services as their meta-level. An alternative          configured and Loaded by the Reconfiguration Layer
approach is to consider the meta-level as orthogonal         services, instead of by WASs directly as “Black Box”
plane to the middleware and application layers. In this      WASs. As presented in Figure 2, there are three
approach, both applications and middleware have their        services    at     Reconfiguration     Layer:     Service
functionality defined at the base-level, whereas the         Configurator, Service Controller, and Reconfigurator.
entities at meta-level provide the facilities to reify,         Service Configurator first reads that configuration
inspect and control such functionality. Although             information from a service descriptor file and gets the
viewing reflective middleware in this way enables a          component binary file and resource for a service, and
cleaner and unified model for reflection programming,        then instantiates the service.
it is not enough to support reconfiguration and                 Service Controller is used to control the life cycle of
customization at multiple layers during the whole            a service by invoking the MService meta-interface
lifecycle of WASs. Therefore, a multi-layer reflective       using reflection. Services can be executed in several
architecture for WASs is required.                           execution models: single threaded model, multi-
    To achieve this, a reflective tower of meta-level        threaded model, and multi-process model. Every
should be created. As shown in Figure 2, the                 service exposes a uniform set of life cycle management
architecture is usually structured into five layers:         operations such as initialize, start, suspend, resume,
Kernel Layer, Reconfiguration Layer, Meta Service            stop and destroy.
Layer, Basic Service Layer, and Application Layer.              Reconfigurator is used to dynamically reconfigure
The bottom layer is the microkernel, and the topmost         basic services at run-time, while introducing little (or
layer is the applications. Each layer is concerned with      ideally no) impact on the system’s execution. In this
the representation and manipulation of the layer above       way, the system does not have to be taken off-line to
it (which is its relative base-level). Each layer means      accommodate changes. Operations on basic services
different reconfiguration level. In this architecture, one   can be replacement, addition, and removal. The
can statically configure the Reconfigurator and Service      reconfiguration process is triggered when some
Controller via specifying the URL location of their          internal states have been changed or reconfiguration
binary package and class name in the system                  script is executed. In addition, Reconfigurator
configuration file at deployment-time. After                 preserves system consistency to make sure that the

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                              3
                Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

WASs under reconfiguration must be left in a “correct”         The Basic Service Layer provides a series of basic
state after reconfiguration (a more detailed discussion     services including Container, Transaction, Naming,

                               Figure 2. The multi-phase reconfigurable architecture

will be presented in another paper).                        Messaging, Security, and Hot Deploying Service etc.
                                                            To meet the requirements of “What You Need is What
3.3. Meta Service Layer                                     You Get”, our solution is a dynamically customized
                                                            WAS that allows changing its whole functionality or
   Each service of the Basic Service Layer has a Meta       selecting different service implementations provided
Service, which can be considered as meta-objects of a       by the third party. The possible configurations range
basic service. Every service may have different             from minimal functionality versions with minimal
implementation strategies. A service instance can be        memory and resource requirements to fully functional
replaced by another instance that implements the same       versions. All those services are configured and loaded
functionality, but with a different strategy. For           by the Reconfiguration Layer as described above.
example, in a large-scale dynamic environment, the
transaction services should also be reflective to           3.5. Application Layer
dynamically provide the necessary support for various
transaction models in accordance to user requirements,         Users can develop and deploy applications or
changing environments, and so on[17]. Load balancing        server-side components in the Application Layer.
service should be adaptive to the change of server’s        These components typically contain the business logic
load and select different request scheduling strategies     that should be quickly adapted to the changes that the
[10, 16].                                                   market brings. To meet the new requirements for the
   In addition, Meta Service provides the lifecycle         changing market, the Basic Service Layer provides the
interface and Meta interfaces which allow structure         deploy service to deploy, undeploy, and redeploy
reflection and behavior reflection.                         different types of applications and components at run-
3.4. Basic Service Layer                                       Component is a most essential unit of web
                                                            applications. The reconfiguration of those applications

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                          4
                Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

is accomplished through the dynamic reconfiguration             invoked by Service Configurator and Service
of component. Each component has a container, which             Controller to dynamically (re)configure the
acts as a meta-object. Component reconfiguration is             services at run-time.
described as an example in section 5.3.                         IMServiceMetaInterface inherits from the
                                                                IMServiceLifeCycle and provides access to the
                                                                operations and attributes declared to be reflective
                                                                by the services. Moreover, the interface defines a
                                                                series of standard methods to support the
                                                                capability of reflection. All meta-level access to a
                                                                service must be done via operations defined in the
                                                                interface. The invoke method lets application or
                                                                system code call any of the operations exposed by
                                                                the service.
                                                                ConcreteService implements the IMServiceMeta-
                                                                Interface that provides meta-level functionality
                                                                and      other     service-specified      base-level
                                                                functionality. Each concrete service inherits such
                                                                a meta-interface whose name is formed by adding
                                                                the MetaInterface suffix to the Service’s name.
                                                                For example, the service named “Container”
     Figure 3. The structure of MService Pattern                should implement the interface namely
4. Service Reconfiguration Framework                            ServiceRepository maintains all services that are
                                                                registered successfully in the MService Server.
   Service Reconfiguration Framework consists of                This allows administrative entities to centrally
both reconfiguration management components and                  manage and control the behavior of the
concrete basic services. The former includes                    configured services.
Reconfigurator,       Service    Configurator,  Service       Figure 4 depicts the collaboration diagram between
Controller, Service Repository, and Service                the components of Service Reconfiguration
Dependency Manager. The later implements the               Framework.       MServices      have     four    phases:
concrete services that perform application-specific        configuration stage, running stage, reconfiguration
processing and define a uniform interface that can be      stage, and termination stage.
used to (re)configure or alter the functionality of the
concrete service. To optimize, control, and reconfigure    5. Implementation
the behavior of a service at run-time, decoupling the
implementation of a service from its configuration         5.1. Deployment-time Configuration
makes it possible to fine-tune certain implementation
or configuration parameters of services. Moreover, to         The section explains the steps to configure
meet advanced QoS requirements, some concrete              Reconfiguration Layer in WebFrame at deployment-
services may provide meta-services to inspect the          time.
internal information and reconfigure the behavior of                Implement the reconfiguration interface:
them. For instance, Container is a typical Meta-object              IServiceReconfigurator, IServiceConfigurator,
that can be reconfigurable.                                         and IServiceController.
   We extend the Service Configurator pattern in                    Define the MService Reconfiguration Layer
[14].The structure of the extended Service                          boot-strap configuration file as depicted in
Configurator pattern, called MService Reconfiguration               table 1.
Pattern, is illustrated in Figure 3:                          After Microkernel is started, the configuration
   The key participants in the MService pattern            information of Reconfiguration Layer is loaded.
including:                                                 Microkernel invokes the start method on each instance
      IMServiceLifeCycle specifies the interface           of the service in Reconfiguration Layer. After these
      containing hook methods (such as init, start,        services are started successfully, Meta Services can be
      pause, resume, stop, and destroy) which are          started either at deployment-time or at run-time.

                                     0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                             5
                 Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

                                                             protocols and methods of the container for interacting
                                                             with each other and with platform services. In the
                                                             multi-phrase reconfigurable architecture, containers are
                                                             considered to be meta-objects of EJB components.
                                                                Table 1. Reconfiguration layer configuration file

                                                                 <Reconfigurator Name="RecongfiguratorService">
                                                                          CODE = "reconfiguration.Reconfigurator"
                                                                          ARCHIVE="reconfigurator. jar"
                                                                 <Configurator Name="CongfiguratorService">
                                                                          CODE = "reconfiguration.Configurator"
                                                                          ARCHIVE="configurator. jar"
                                                                 <Controller Name="ControllerService">
                                                                          CODE = "reconfiguration.Controller"
      Figure 4. Interaction diagram for MService

5.2. Run-time Reconfiguration of Services
                                                                       Table 2. Reconfiguration script file
    Run-time reconfiguration allows modifying system
architecture     to    accommodate       the      changing       <ReconfigurationScript>
requirements of applications. Dynamic reconfiguration              <Operations>
operations on services can be replacement, addition,                    <add target="MailService"/>
and removal. Those steps are examined briefly below:                    <remove target=" TransactionManager"/>
          Define a new Interface that inherits
          IMServiceMetaInterface.                                            target="AdaptiveLoadBalancingService"
          Implement the new interface in a Meta Service                   />
          class.                                                   </Operations>
          Write the reconfiguration script in a file.            </ReconfigurationScript>
          Deploy the reconfiguration script.
    The reconfiguration criteria can be specified in
various ways: on the command line, through a user
interface, or in a reconfiguration script file. As              WebFrame       provides     a     customizable    and
illustrated in table 2, the example script presents how      reconfigurable container, which supports run-time
to use reconfiguration operations of add, remove, and        reconfiguration on a per method invocation basis.
replace.                                                     Here, run-time reconfiguration refers to mechanisms
    In the script file, MailService is added, and            that allow the implementation of the container to be
TransactionManager is removed. LoadBalancing-                dynamically adapted to cater for changing
Service is replaced by AdaptiveLoadBalancingService.         environmental conditions.
                                                                The structure of a customizable and reconfigurable
5.3. Run-time reconfiguration of components                  container is illustrated in Figure 5. The Interceptor
                                                             Pattern is applied in the structure. The basic idea is to
   WebFrame is a web application server that supports        enable the container to intercept all method invocations
J2EE specifications. Containers provide run-time             made on the server components within it and make the
environments for EJB components. EJB components              request go through all the responding metaobjects
never interact directly with other J2EE application          before being delegated to the target component.
components, so does Java client. They use the                However, Metaobjects does not implement the

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                             6
                Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

function directly themselves, and they are responsible     reflection and multi-phase reconfigurability on the web
for selecting the implementation strategies to deal with   application server by comparing the performance
an invocation.                                             between WebFrame and BEA Weblogic 7.0, the latter
   As shown in the Figure 5, the InvocationDispatcher      is one of the mainstream web application servers and
intercepts invocations from client and implements a        compatible with J2EE1.3 specifications.
general framework for providing different types of            We are primarily interested in the performance
Invokers for containers that can be accessed using         measure: Response Time per Invocation. It is the mean
different protocols such as JRMP, RMI-IIOP, and            total elapsed time from the instant the client starts its
SOAP. InvocationDispatcher inspects the type of the        request cycle to the time the final reply is received
accessing protocol and matches with the policy to          from the server used in the cycle. The parameter is a
reconfigure the InvokerMetaObject to the selected          measure of the latency for the system.

                     Figure 5. The structure of customizable and reconfigurable container

Invoker. After an invoker is selected, all method             For testing purpose, some small applications
invocations are dispatched to it directly. However,        consisting of Java clients and Enterprise Java Beans of
instead of implementing the function directly inside the   different categories have been built. Users deploy some
selected invoker, it is divided into a number of smaller   EJBs into the target application server, and then
tasks that are implemented in InterceptorMetaObjects.      invocate the methods of those EJBs. BEA Weblogic
As shown in Figure5, ConcurrentMetaObject and              uses the default settings, and WebFrame uses an
TransactionMetaObejct          are      examples      of   optimized implementation of persistence strategy
InterceptorMetaObjects. The invoker is responsible for     adaptively via PersisteneceMetaObject.
coordinating the InterceptorMetaObjects to fulfill the        The hardware consists of a dedicated application
whole function that the user specifies. To provide         server with 1 Intel CPU 1.70 GHz and 780 MB of
flexibility and adaptability, users can plug metaobjects   RAM and one client with 1 Intel CPU 1.70 GHz and
in the form of MService before or/and after method         512 MB of RAM, interconnected in a 100Mbit LAN.
execution on the target component. Each task can be        The database is Cloudscape provide by SUN.
implemented in a number of ways in different
metaobjects, thus users can customize container to suit    6.2. Experimental Results
the application by using the most appropriate
Metaobjects.                                                   Our hope and expectation is that Webframe should
   ContextObject allows InterceptorMetaObjects to          perform as well as existing web application servers
access and control aspects of the container’s internal     without multi-phase reconfigurable characteristics. As
state and behavior in response to certain events.          illustrated in Figure 6, the response time per invocation
                                                           of WebFrame is 1.6 milliseconds longer than that of
6. Preliminary Performance Evaluation                      BEA Weblogic partly due to the use of reflection, and
                                                           the number of invocations of per second is less than
6.1. Scope of Evaluation                                   that of Bea Weblogic with the same reason. However,
                                                           the Bean overhead of reflection is very lower
   A number of preliminary tests have been carried out     compared with the cost of business methods of a
in order to measure the performance impact of              session bean in real applications, so the design of the

                                      0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                            7
                                    Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

container has little effect on the performance of session
beans although the cost of reflection affects

    Response Time


                                                                                  Figure 8. Comparison results for BMP Bean

 Figure 6. Comparison results for Session Bean                                 7. Related work
   Figure 7 and Figure 8 report the results using entity                          This discussion is organized accordingly to the
beans with CMP (Container-Managed Persistence) and                             related fields that our work touches:
BMP (Bean-Managed Persistence).The number of                                           Web Application Servers
invocations per second for CMP of WebFrame is                                     Most of the mainstream WASs (such as Iona
between 6 and 9 times more than that of Weblogic. In                           Orbix2000, BEA Weblogic, and IBM Websphere)
                                                                               typically adopt a monolithic architecture and “black-
                                                                               box” philosophy to their design. Despite the usefulness
                                                                               of some reflective features, the degree of support for
              Response Time

                                                                               customization and dynamic adaptation is only partial,
                               25                                              and the extent to which elements of the design can be
                               15                                              opened and exposed to the programmer is severely
                                0                                              limited. While WebFrame provides a reconfigurable
                                                                               architecture covering all aspects of the design and the
                                                                               different phases of a WAS life cycle .In this
                                                                               architecture, both deployment-time configuration and
                                                                               run-time reconfiguration is supported at multiple
       Figure 7. Comparison Results for CMP Bean                                  JBoss, an open-source J2EE application server,
                                                                               employs the microkernel architectural pattern to their
 the case of entity beans with BMP, the number of                              design. Java Management Extensions (JMX) is used as
invocations per second is about 1.5 times more than                            a reflective microkernel at the very basis of the whole
that of Weblogic. It is the optimized implementation of                        server in JBOSS. However, JMX should be used as a
persistence strategy that improves the performance of                          means to instrument selected parts of the application
entity beans, and the reason is that the improvement is                        server and make them manageable through JMX-
far more than the cost of the extensible use of                                compliant clients. It is too big and complicated to be a
reflection and multi-phase architecture. The                                   microkernel. While WebFrame’s microkernel is based
performance may be further improved after                                      on MService model. It is more lightweight than that of
reconfiguring the WebFrame to adapt to other more                              JBoss. One of MService’s benefits is that it can reduce
optimized persistence strategies although there are                            the footprint size of middleware platform for use,
overheads to achieve the capability of openness and                            especially in resource-constrained embedded system.
flexibility.                                                                   In WebFrame, users can choose JMX module if
    In summary, the cost of the reflection and multi-                          needed.      In     addition,    WebFrame       provides
phase reconfigurable architecture may affect                                   Reconfigurator to deal with unanticipated changes, and
performance of web application servers, but the                                services can be added, removed, and replaced using
significant performance improvement achieved by                                reconfiguration script at run-time while preserving
reconfiguring system effectively to adapt to changes                           system’s consistency.
through the multi-phase reconfigurable architecture is                                 Reflective      middleware     and     Dynamic
far more than the cost of the reconfiguration activity                                 Reconfiguration

                                                        0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                             8
                Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

    A reflective architecture for configurable              pattern promotes a decoupling between components
middleware platforms is presented in [8]. The approach      and components connection, aiming at supporting ad-
relies on reflective techniques for reconfiguring the       hoc dynamic reconfiguration and the migration of
ORB to the desired behavior. Reconfiguration is done        component with state transferring. Virtual Component
by configuring the meta-level of the reflective             pattern is applied throughout ZEN to decompose and
architecture, while the ORB implementation is residing      factor most of the unused or rarely used component out
at the base-level. However, reconfiguration is limited      of memory. This pattern provides an application-
to application wide concerns and cannot be addressed        transparent way of loading and unloading components
on a per remote method invocation basis.                    that implementing middleware software functionality.
    Universal Interoperable Core (UIC, formerly             MService Reconfiguration design pattern can be
LegORB) is a reflective middleware infrastructure that      viewed as a compound pattern that combines elements
is customizable to ubiquitous computing scenarios. It       of the Service Configurator and Component
can be configured at run-time so that it loads just         Configurator patterns. What is different from other
enough components to provide the middleware                 configuration design patterns is that MService
services required by its applications. .It also supports    Reconfiguration design pattern support reflection
“What You Need Is What You Get”. Run-time                   mechanism. It decomposes meta-level functionality of
configuration is achieved by defining pre-existing          services from base-level functionality. It means that the
hooks for changing strategies related to concurrency,       services in MService design pattern are open and
security, monitoring, and the like. This implies that       reflective.
only anticipated non-functional requirements can be
meet whereas our approach is able of coping with            8. Conclusions and future work
changing non-functional aspects as well. Due to multi-
phrase dynamic reconfiguration design, WebFrame can            In this paper, a middleware architecture
add or remove unanticipated functionalities at multi-       (WebFrame) that supports multi-phase adaptation
layers from deployment-time to run-time.                    using computational reflection, microkernel, and
    DynamicTAO is a reflective CORBA ORB, built as          component techniques is proposed for web application
an extension of TAO. Some reflective features are           servers. The architecture is usually structured into five
added to make the system more flexible, dynamic, and        layers: Kernel Layer, Reconfiguration Layer, Meta
customized. Conversely, WebFrame focuses on a novel         Service Layer, Basic Service Layer, and Application
middleware architecture where reconfiguration from          Layer, Both deployment-time configuration and run-
the kernel layer to application layer is supported          time reconfiguration at multiple layers is supported in
inherently from the scratch.                                this architecture.
    ZEN is a highly configurable real-time COBRA               Our approach overcomes the limitations of
ORB implemented using Java. ZEN’s ORB                       monolithic architecture and “black box” philosophy by
architecture is based on the concept of layered             offering a reflective microkernel, and the basic services
pluggability where various components of the                are separated from the common services. All basic
middleware may be plugged or unplugged on an as-            services can be run-time reconfigured in application-
needed basis. WebFrame has some similarity in the           specific manner with the support of Service
micro-ORB design. ZEN has five generations of ORB           Reconfiguration Framework. The reconfiguration
design. The current research work focuses on dynamic        process can be executed in script manner.
micro-ORB which does not use reflection to provide             To validate the multi-phase reconfigurable
feedback to allow run-time reconfiguration to               architecture, we develop a J2EE WAS prototype. It is
customize ZEN. While WebFrame provides reflection           called WebFrame.Comparing the performance between
capability at multiple layers of the reflection tower,      WebFrame and BEA Weblogic 7.0, preliminary
thus, internal states can be inspected, and WebFrame        experimental results show that the significant
can be adaptive to adjust structure and behavior of         performance improvement achieved by run-time
itself at run-time.                                         reconfiguration may be far more than the cost of the
         Design Patterns for configuration                  reconfiguration activity itself.
    Design patterns for configuration issues include           Here are some of our future research work on
Service Configurator, Component Configurator, and           WebFrame: (1) To minimize the cost of the use of
Virtual Component pattern. Service Configurator             multi-phase reconfigurable architecture; (2) To carry
pattern decouples the implementation of services from       out the further development of other reconfigurable
their configuration. It provides the ability to configure   services (such as transaction service, caching service
a service without modifying, recompiling, or statically     etc) to achieve great improvements of performance. (3)
relinking existing code. Component Configurator

                                       0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                            9
                 Proceedings of the 37th Hawaii International Conference on System Sciences - 2004

To apply the multi-phase adaptation architecture to            [13] Gordon S. Blair, Geoff Coulson, “The Case For
other distributed systems.                                          Reflective Middleware:Buidling Middleware that is
                                                                    Flexible,Reconfigurable And Yet Simple To Use”,
Acknowledgments                                                     2002.
                                                               [14] Prashant Jain and Douglas C. Schmidt,”Dynamically
                                                                    Configuring Communication Services with the Service
    The research described in this paper is funded by               Configurator Pattern”. C++ Report,9(5),June 1997.
the     National    863      Program      of    China     
(No.2001AA113010,          2001AA414020,          and               ml.
2001AA414310), and by the 973 Program of China                 [15] Buschmann, F., R. Meunier, H. Rohnert, P.
(No 2002CB312005).                                                  Sommerlad, and M. Stal. „Pattern-Oriented Software
                                                                    Architecture: A System Of Patterns”. West Sussex,
References                                                          England: John Wiley & Sons Ltd., 1996.
                                                               [16] Othman, C. O’Ryan, and D. C. Schmidt, “Strategies for
[1]  Ron Copeland. “Web Application Servers”,                       CORBA Middleware-Based Load Balancing,” IEEE,                Distributed Systems Online, Volume 2, Number 3
     1999.                                                          ,March 2001.
[2] Mike Ricciuti, ”Application Server Eludes Definition”,     [17] Weihai Yu and Randi Karlsen,”Reflective Transaction,1998.              Service”,Proc., IFIP/ACM Middlware’2000,2000.
[3] C.Mohan. “Tutorial: Application Servers and           
     Associated Technologies”, Proceedings of the 2002
     ACM SIGMOD international conference on
     Management of data. New York, NY, USA:ACM
     Press,2002, 636-636.
[4] C.Mohan. “Application Servers:Born-Again TP
     Monitors For The Web”,Proceedings of the 2001 ACM
     SIGMOD international conference on Management of
     data. New York :ACM Press,2001, 622-622.
[5] Fan GC, Zh H, Huang T, Feng YL. “A Survey of Web
     Application Servers”. Journal of Software (Chinese),
[6] Scott Dietzen. “Web Application Server Architecture”,
     Ninth International Workshop on High Performance
     Transaction Systems (HPTS), 2001.
[7] John Bates, “The State of The Art In Distributed and
     Dependable Computing”, A CaberNet Sponsord report,
[8] Blair, G.S., Coulson, G., Robin, and P., Papathomas,
     M., "An Architecture for Next Generation
     Middleware", Proc. IFIP International Conference on
     Distributed Systems Platforms and Open Distributed
     Processing (Middleware'98), Springer, 1998, pp. 191-
[9] Geoff Coulson and Gordon S. etc., "The design of a
     configurable      and     reconfigurable     middleware
     platform",Distributed Computing, vol 15(2):109-
[10] O. Othman, C. O'Ryan, and D. C. Schmidt, "An
     Efficient Adaptive Load Balancing Service for
     CORBA," IEEE Distributed Systems Online, vol. 2,
[11] Gordon Blair Geoff Coulson, Fabio Costa ,and Hector
     A.Duran. “On The Design Of Reflective Middlewaare
     Platforms”.Workshop on Reflective middleware,
     Proc.,IFIP/ACM Middlware’ 2000.
[12] Marc Fleury and Juha lindfors,”Enabling Component
     Architecture with JMX”,the O’Reilly Network,2001.

                                         0-7695-2056-1/04 $17.00 (C) 2004 IEEE                                                10

Shared By: