Dynamic and Selective Combination of Extension in Component-based Applications

1
Dynamic and Selective Combination of Extension in
Component-based Applications

• Eddy Truyen, Bart Vanhaute, Wouter Joosen, Pierre
  Verbaeten, Bo N. Jørgensen

2
Outline

• Motivation Dynamic customization of distributed
  services
• Overview of wrapper-based model Lasagne
• Problem statement analysis of problems with
  wrappers
• Detailed overview of Lasagne
• Lessons learned
• Conclusion

3
Motivation

• Support for dynamic and client-specific
  customization of distributed services is needed
• An example web service on the Internet
• Multiple clients are accessing service instance
  simultaneously
• Different clients have different customization
  needs
• One client must be able to customize the web
  service for use in its own context,
• without affecting other clients (service behavior
  delivered to other clients must not be affected)

4
Motivation (ctd)

• Customization process context-sensitive and
  dynamic combination of extensions to a minimal
  core system
• Extensions can be functional (e.g. refined core
  service) and non-functional (e.g authentication,
  authorization)
• Revisiting example web service on the Internet
• Each client must be able to select a subset of
  extensions into the core service
• for use in its own context
• per client request, per client session
• without interfering with other clients

5
Short overview of Lasagne

• A programming, deployment and run-time model that
  supports dynamic combination of extensions per
  client request
• Inspired by wrapper-based design patterns
• Decorator and Role Object
• Advantages of wrappers
• already support combination of extensions to a
  component
• operate at instance-level gt customization of
  online services
• Deal with disadvantages of wrappers
• object identity problems

6
Wrapper-based design patterns

• Decorator Gamma et al
• Disjunctive chaining supports selective
  combination

7
Wrapper-based design patterns

• Role Object Baumer et al
• Component type widening
• Dynamically adds new service interface
• selection of roles by means of specification
  object

Component
getRole(specification)
8
Problem Statement
System-wide interaction refinement
9
Spaghetti Problem
10
Spaghetti Problem
11
Spaghetti Problem
12
Spaghetti Problem
13
Spaghetti Problem
14
Coordination Problem
15
Coordination Problem
16
Coordination Problem
17
Coordination Problem
18
Coordination Problem
19
Other problems solved

• Partial ordering constraints between wrappers
• Some wrapper composition logic should not be
  under control of the clients
• Use of design patterns must be anticipated by
  core application developer.
• Technical problems
• Problems with delegation and common self
• State consistency between multiple instances of
  the same wrapper definition

20
Turning Spaghetti into Lasagne

• Externalize wrapper composition logic from the
  code of core system and extensions
• Clients can customize the wrapper composition
  logic on a per collaboration basis

21
High-level overview of Lasagne

• Introductory terms
• Component-based, distributed core system
• Component type lt services, dependenciesgt
• Connection supported by COTS middleware
• Client request initiates collaboration between
  core components
• Lasagne customization process consists of three
  phases extension programming, deployment of
  extensions to a core system, and selective
  combination per collaboration

connection
dependency
service
22
High-level overview of Lasagne

• The extension programming model
• An extensions is implemented as layer of wrappers
• Wrappers are programmed in hybrid form between
  Decorator and Role Object
• Each wrapper definition is meant for decorating a
  specific minimal component type

ltDating, Negotiationgt
ltNegotiation, gt

23
High-level overview of Lasagne

• Deployment of extensions to core application
• Declarative specification of how to integrate
  wrappers to a specific core application
• specify fine-grained partial ordering constraints

24
High-level overview of Lasagne

• Selective combination per client request

25
Lasagne Concepts

• Component Identity
• Aggregates core instance and its wrappers into
  one identity
• Removes the spaghetti of wrapper references
• Extension Identifier
• qualified name that uniquely identifies an
  extension
• Is used to designate wrappers as belonging to a
  specific extension
• Composition Policy
• specifies the subset of extension identifiers
  for a specific collaboration between client and
  core system
• A composition policy propagates with the
  collaboration flow

26
Lasagne concepts

• Contextual properties
• e.g client-specific preferences, message flow
  history
• defined as ltname, valuegt pairs that propagate
  with the collaboration flow
• Interceptors
• define contextual properties of collaboration
• select or unselect extensions. Typical selection
  rule
• If ltconditiongt is satisfied within ltcontextgt then
  attach/discard ltextension identifiergt to
  composition policy
• Variation point
• Extension to runtime component model
• Generic message dispatch mechanism
• Dynamically constructs wrapper chain
• Interprets composition policy and ordering
  constraints

27
Component Identity
28
Extension Identifiers
ltgroupgt
ltauthorizgt
29
Interceptors and Composition Policy
ltauthorizgt

ltgroupgt
ltauthorizgt
ltauthorizgt

ltauthorizgt
Interceptor definitions
Attach client_localhost, client_identity as
contextual properties to collaboration.
If client_localhost on remote subnet then attach
ltauthorizgt to composition policy
30
Underlying runtime mechanisms
ltauthorizgt
ltgroupgt
ltauthorizgt
ltauthorizgt

ltauthorizgt

• Propagation of composition policy
• Propagation of contextual properties
• Variationpoint performs automatic adjustment
  of message flow

31
Lessons learned

• Lasagne is suitable for customization at the
  coarse-grained architectural level
• Extensions are reusable over multiple
  applications
• is supported in Java implementation of Lasagne
  (co-work with Renaud Pawlak)
• Wrappers are reusable over different types of
  components
• Deployment-time operation that dynamically
  connects extension operation to core operation.

32
Lessons Learned (ctd)

• Lasagne is too low-level and complex to use
• Need to build higher-level tool or language on
  top of Lasagne framework
• feedback from advanced separation of concerns
  community
• Aspect-oriented programming
• Aspectual Components
• GenVoca and Mixin layers
• Multidimensional separation of concerns

33
Conclusion

• Customization of distributed services
• non-invasive customization
• dynamic combination of system-wide extensions
• consistency and scalability
• context-sensitiveness
• simultaneous client-specific views
• message flow history
• Lasagne prototypes
• Programming Languages with an open implementation
• Correlate, Java
• Reflective middleware platforms
• Java RMI, Lasagne ORB

34
Other problems solved

• Partial ordering constraints between wrappers
• Multiple instances of the same wrapper definition
  due disjunctive wrapper chains
• difficult to keep the states of different wrapper
  instances consistent to each other
• No Delegation
• Self-call of core component is not redirected
  through wrappers
• Some wrapper composition logic should not be
  under control of the clients

35
Coordination Problem
36
Coordination Problem
37
Lasagne mechanisms

• Underlying run-time component model