Modeling with Filter Objects in Distributed Systems

1
Modeling with Filter Objects in Distributed
Systems

• Rushikesh K. Joshi
• Department of Computer Science Engineering
• Indian Institute of Technology, Bombay
• Powai, Mumbai - 400 076
• India
• Presentation at EDO 2000, UC Davis, Nov. 2-3,
  2000.

2
Messages in the Conventional Object Model are
Direct

• Messages are directly delivered to receiver
  objects specified by source objects

m
3
Filter Objects can transparently trap Messages

• Clients are unaware of the existence of filter
  objects

f
4
Some Properties of Filter Objects

• First class nature
• Conventional properties
• Upward and downward filtering
• Message manipulations
• Pass and bounce actions
• Selective filtering
• Dynamically pluggable
• Group filtering

5
Currently Available Implementations of the Filter
Object Model

• Extension to C
• Filter Objects for MICO CORBA implementation
• Extensions to JAVA

6
The Guiding Principles

• Homogeneous integration into existing programming
  paradigms
• AND
• Ability to provide an orthogonal layer over
  existing design and code

7
Dynamically Evolution using Filter Objects

• Through Injection
• Employ Filter configurations
• (e.g. Replacer, Router, Repeater, Value
  Transformer, Message Transformer, Request Logger
  etc.)

8
The Approach

old solution
Old Code
Old clients
evolved solution
Old Code
Old clients
Injected Filter
9
The Approach
10
Properties of the Injection Approach

• Modifications to existing classes can be avoided
• Evolution is reversible By lifting the filter
  network
• Original object oriented design must be
  filter-aware

11
The Distributed Transparent Decorator Pattern
(DTDP)

• Decorator Pattern (DP) Dynamically attaches
  additional responsibilities to an existing object
• DP uses Inheritance and part-of
• DP Not transparent to clients
• Proposed DTDP uses Filter Relationship
• DTDP is transparent to clients

12
Conventional DP
AbstractComp

component
Component
Decorator
Based on part-of And inheritance relationships
Decorator2
Decorator1
13
DP Instance Diagram

Client objects are decorator aware Decorator
objects are also decorator aware (in the case of
multilevel decorators)
14
Problems with DP in Distributed Context

• Client obtains the handle to decorator object
• May not be a problem in single process systems
  but
• Undesirable in Distributed Systems
• Dynamic Pluggability of decorators
• client needs to update its handle.
• Changing intermediate decorator objects
• The decorator that aggregates it needs to be
  updated

15
An Interclass Filter Relationship
dic
search ()
main()
cached() search()
update() search()
16
A Filter Relationship between Instances
dic
transClient
dDictionary
17
DTDP Static ModelClass Diagram
comp
operation ()
clientFunc()
addedOperation() operation()
18
DTDP Static ModelAn Instance Diagram
eng
clQProcessor
seEngine
19
DTDP Dynamic Model Inter-object Interactions
se.getPage(..)
lf.logReq(..)
pass
return
lf
cl
logger
se
20
Observations on the DTDP

• Transparent to Clients
• Dynamically Pluggable without involving remote
  clients
• Filter Class injection allows new typs of filters
• Incremental evolution of a system by means of
  injection of filter objects

21
DTDP A Distributed Implementation

• Need-to-filter principle A server is declared as
  Filterable Server
• interface Filterable
• attach (in Object filter)
• detach ()
• interface Engine Filterable
• getPage ()

22
Implementation of IDL Filterable

• A standard implementation of Filterable is
  provided in class Filterable_impl
• class Filterable_impl public Filterable_skel
• // library implementations of attach and detach

23
Implementing the Filterable Component

• Inherit the standard implementation of IDL
  Filterable
• class Engine_impl public Filterable_impl,
  public Engine_skel
• // implementations of Engine IDL

24
Implementing the Decorator Object

• Implement the Filter base interface generated by
  an IDL precompiler
• interface Engine_Filter
• // up and down filter member declarations

25
Dynamic Pluggability of the Decorator

• A CORBA Object that acquires handles to a filter
  object and its corresponding filterable server
  object may carry out the plug and unplug
  operations
• main ( )
• .
• engine_obj--gtattach (logger_obj)
• engine_obj--gtdetach ( )

26
Conclusions

• A Method of Modeling Distributed Systems with
  Dynamically Pluggable First Class Filter Objects
  is proposed
• The Distributed Transparent Decorator Pattern was
  Introduced.
• An Implementation of the DTDP was presented

27
Future/Ongoing Work

• Methodologies
• Programming Models
• Implementations
• Applications

28
Related Work

• Proxy pattern of Gamma et al.
• Composition filters of Aksit et al.
• CORBA Filters e.g. ORBIX per-process and
  per-object filters
• Seiter and Lieberherrs Context Relations

29
Some Results on Filter Objects

• 1 Rushikesh K. Joshi, N. Vivekananda, D Janaki
  Ram, Software Practice and Experience, June 1997,
  pp. 677-699
• 2 Rushikesh K. Joshi, Filter Configurations for
  Structuring Distributed Object Systems, To appear
  in Journal of Object Oriented Programming.
• 3 Rushikesh K. Joshi, On-the-fly Evolution of
  Object Oriented Systems using Filter Objects,
  Technical Report, Feb. 1999, IIT Bombay. (result
  submitted for publication).
• 4 G. Sriram Reddy, Rushikesh K. Joshi, Filter
  Objects for Distributed Object Systems, To Appear
  in Journal of Object Oriented Programming
  (January 2001).
• 5 R. K. Joshi, Modeling with Filter Objects in
  Distributed Systems, EDO 2000, UC Davis, Nov 2-3,
  2000
• 6 Maureen Mascarenhas, R. K. Joshi, Design and
  Implementation of Filter Objects for JAVA,
  Technical Report, IIT Bombay October 2000.
  (result submitted for Publication).