CS590L Distributed Component Architecture References: Objects, components, and framenworks with UML,

1
CS590L Distributed Component ArchitectureRefere
nces - Objects, components, and framenworks
with UML, Ch 6-9 - A Component Based Services
Architecture for Building Distributed
Applications, R. Bramley, K. Chiu, S.
Diwan, et al.

• Yugi Lee
• STB 555
• [phone]
• leeyu_at_umkc.edu
• www.sice.umkc.edu/leeyu

2
(No Transcript)
3
Framework

• A Framework is a template model (of business,
  specs, design,...) defined in a Package
• the parameters of that template,
• any assumptions made in that model about the
  intended substitutions for those parameters, can
  be made explicit.
• the predefined rules of composition for combining
  the properties (imported and existing ones)
• Frameworks are useful for many sorts of patterns
  at all levels of modeling types, actions,
  collaborations, refinements, scenarios,
• A framework is used via Framework Application

4
Motivation for Frameworks and Patterns

• Developing software is hard
• Developing reusable software is even harder
• Proven solutions include patterns and frameworks

5
Overview of Patterns and Frameworks

• Patterns support reuse of software architecture
  and design
• Patterns capture the static and dynamic
  structures and collaborations of successful
  solutions to problems that arise when building
  applications in a particular domain
• Frameworks support reuse of detailed design and
  code
• A framework is an integrated set of components
  that collaborate to provide a reusable
  architecture for a family of related
  applications.
• Together, design patterns and frameworks help to
  improve software quality and reduce development
  time
• e.g., reuse, extensibility, modularity,
  performance

6
Frameworks

• 1. Frameworks are semi-complete applications
• Complete applications are developed from patterns
  and framework components
• 2. Frameworks provide domain-specific
  functionality
• business applications, telecommunication
  applications, window systems, databases,
  distributed applications, OS kernels
• 3. Frameworks exhibit inversion of control at
  time
• the framework determines which objects and
  methods to invoke in response to events

7
Case Study Common Component Architecture (CCA)

• Major Focuses
• Components (software objects that implement a set
  of required behaviors)
• Frameworks (A runtime environment, A set of
  services used by components)
• Draws ideas from CCM, SciRun (Univ of Utah), etc.
• Designed for
• efficient coupling of SPMD (Single Progrogram and
  Multiple Data) components running on very large
  cluster-based parallel computers.
• Coupling of components that execute on widely
  distributed (Grid) resources. I.e. A
  visualization app with a remote simulation and a
  data analysis component.
• A Component Based Services Architecture for
  Building Distributed Applications, R. Bramley, K.
  Chiu, S. Diwan, et al.

8
Main CCA Ideas

• Components Autonomous interchangeable parts
• Applications are developed by connecting
  components
• Ports define the public interfaces that a
  component uses or provides.
• Builders the tools used to select and link
  components together. eg JBuilder
• Framework defines a mechanism to link uses
  ports of one component to the provides ports
  of another.

Component A
Component B
Uses Port is a call site for an interface to
an external component
Provides Port - an interface to a service
provided by that component.
9
CCA Framework Services

• The framework must provide a set of standard
  services
• Directory Service
• To locate components based on port type and other
  attributes
• Registry Service
• To locate executing instances of components
• Creation Service
• To create an executing instance of a component
• Connection Service
• To connect the ports of two running component
  instances
• Event Service
• A framework for publish/subscribe messaging
  between services and components.

10
Services and the Grid

• A computational Grid is a networked set of
  computational and data resources that are tied
  together by a ubiquitous collection of services
• Traditional Grid services
• Authentication/Security
• File/data management
• Authorization/ User services
• Job Management (incl. co-scheduling, QOS)
• Information Services
• about resources, people, applications

11
Common Component Architecture Toolkit

• A CCA-compliant framework for distributed
  Grid-based applications.
• To enable the design of Grid Application Services
  as software components.
• Is an experiment to test CCA.
• CCA architecture is rich enough that the
  framework and services can be built as components
• In particular application builders can be
  components.
• Federation of Components design allows
  framework to be layered on top of Globus, Jini,
  e-speak or Legion
• There may be a better way to specify information
  (metadata) about components than a traditional IDL

12
CCAT Services Architecture

• Designed to operate over Grid middleware systems
• Chose Globus as the basic framework (could have
  used Legion too.)
• Abstracts out the core services for component
  architecture and layer on top of existing grid
  services
• CCAT has five CCA framework service components
• Directory
• Registry
• Creation
• Connection
• Events

13
CCAT experimental results

• To test the idea of going beyond traditional
  IDLs
• Uses XML as the interface definition language and
  to describe component metadata
• To test the generality of the CCA design
• A services architecture has been built following
  CCA specifications - all services are components.
• To see if components can be reused in the design
  of application builders
• Four different application builder components
  have been constructed

14
Corba-IDL

• Traditional distributed computing is based on the
  specification of public interfaces with simple
  type language called Interface Definition
  Language
• standard in Corba, DCOM and Java/Jini.
• Corba component model goes far beyond standard
  interface type specs.
• it requred OMG to define an extensive extension
  to the standard corba IDL.
• The result is a very specialized, non-extensible
  new specification language.

15
The Experiment Use XML as an IDL

• Simple canonical syntax
• Possible to describe IDLs in XML
• Transformation
• Easy to transform using programs (or XSLT)
• Also possible to describe meta-data associated
  with a component
• where is the component from
• who wrote it and author comments
• interface and port inheritance info
• Shortcoming
• XML as a Type system is very weak

16
IDS Information Directory Service

• Stores Component descriptions in XML
• Used to search databases and remote repositories
• Context a storage specific implementation of the
  IDS interface
• Two contexts provided WebDAV and
  local-file-system

Contexts
WebDAV repository
Request component info
Information Directory Service Component
RDBS
File system
Return XML specs.
LDAP
17
Specification Fragment Defining an Interface in
XML
ltport-typegt lttype-namegtSparseLinearSystem_idllt/ty
pe-namegt ltmethod-listgt ltmethodgt
ltmethod-namegtsendSparseLinearSystemlt/method-namegt
ltmethod-param-listgt ltparam-infogt
ltparam-namegtslslt/param-namegt
ltparam-dirgtinlt/param-dirgt ltparam-typegtSparseL
inearSystemlt/param typegt lt/param-infogt
lt/method-param-listgt ltreturn-valuegtintlt/return-
valuegt lt/methodgt lt/method-listgt lt/port-typegt
18
Registry Service

• Stores instance information (runtime
  configurations)
• Used by components to advertise their existence
  and search other instances
• Allows collaboration between CCAT sessions

Find a running instance of component X
Executing Component Registry Service Component
Returns remote reference to component instance
19
Creation Service

• Used to create a running instance of another
  component
• Encapsulates authentication issues

Globus managed resource Y
Launch an instance of component X on resource Y
Creation Service Component
X
Returns remote reference to new component
instance
20
Connection Service

• A component that can be used to connect a uses
  port of one component to the provides port of
  another.
• Makes it possible to build nested components.

X
Port Connection Service Component
A
Connect port A of component X to port B of
component Y
B
Y
21
Event Service

• Channel for publish-subscribe event model
• Components use it to subscribe to event streams
  like creation and connection events
• Application users can use it for asynchronous
  information transfer

C
Subscribe to listen for events of type X
Event Channel Service Component
x
Notification of publication of events of type X
A
x
B
22
CCAT Process
23
Building builders as components

• Builder A tool used to select and link
  components together
• Component Architecture systems need to provide a
  tool to work with components
• Build these builders as components so that the
  component model extends throughout

24
CCAT Builders

• Swing based GUI
• JPython scripting interface
• Matlab
• Web

25
(No Transcript)
26
JPython Example
import ccat stringDump ccat.createComponent(S
tringDump) printer ccat.createComponent(Printe
r) ccat.setCreationMechanism(stringDump,
gram) ccat.setCreationMechanism(printer,
gram) ccat.createInstance(printer) ccat.createI
nstance(stringDump) ccat.connectPorts(stringDump,
outputString, printer, inputString)
27
A Web Builder The builder is both a cca
component and a java servlet.
28
Conclusions

• XML does not have a strong-enough type system
• Replace XML with schemas
• Deploy a multiprotocol system for communication
• Globus Nexus good for big data, but not for small
  messaging
• Propagate events in a runtime system that is
  orthogonal to the one in which computation is
  being done
• Building framework services as components was a
  good idea