Oct 1, 2001 - Hybrid approaches use a combination of both top-down and bottom up ..... Once the services are generated and stored in a repos- itory, clients can ..... When an invalid verification ...... a tool called Arch Verifier is used to verify that the styles of components are consistent. ..... with vendors releasing web-.
Using
a Formal
Approach
Recovery
for
Reverse
to Support Final
Engineering
Software
Reuse
Report
Gerald C. Gannod, Ph.D. Principle Investigator
Period Covered:
10/01/2001
- 09/30/2002
Arizona State Unive_ity Office of Research & Creative Studies Box 871603 Tempe,
AZ85287-1603
Grant No. NAG-I-2241
and
Design
Introduction This
document
describes
accomplishments.
Included
Note that the budget budget
2
from
Third
2.1
Year
3 of the
formal
and
begin
While
project
the third
structural
area.
to
approaches
two,
but that
year
year
three.
a residual
that occurs
of software
provides
only a subset
risk of using
log files
as adequate
testing
in order
we
able
began
as log-file
integrating
to support
to use
year
looking
traces
for
software
2 residuals
at an approach
and structural
to for
diagrams
checking.
defined
to
be
in order for problem
a
obtain
reverse
behaviors
within
traces
of
using
process
of
analyzing
a description
engineering
from
the software observed
log files exist
for reverse
account
Engineering.
engineering
such
a wide a wide
been
of views
variety
software
of the software have
variety
at a
suggested
ranging
of techniques
from
covering
as a source are needed
of behavioral
behavior.
the use of compiler
a log file has the advantage
However,
of possible
community
is the use of
Several directives
different at the time
instrumentation.
engineering,
behavior.
development
software
including
and post-development
amount
from
project
analysis.
for creating
As a resource
is
engineering
generate
of development
papers
of approaches
cut, we were
information
to observable
activity
files
overall
into year three.
Reverse
Specifically,
Approaches
and dynamic
A common
was
interrelationships
the reverse
makeup
both static
after
investigation
reverse
budget
engineering
of abstraction.
that address
for
the
such as model
and their
Based
to involve
year
in this
reverse
high-level
adequate
was
approaches
components
continuance
into Log-File
the use of informal
Software
summarizes
are all published
was discontinued
minimal
approaches
investigations
with formal
and
Accomplishments
informal
combining
log
for this project
Investigations
Phase
accomplishments
as attachments
year two allowed
Initial
reuse.
3 rd year
behaviors
a disadvantage
to ensure coverage.
is that the
of the software.
of information
of being
for whatever
that a log file trace
log file
As a result, reason, provides
an accurate potentially
to mitigate
approaches a reasonable
the such or
Model checking approaches work by using exploration to determine whether certain temporal and safety conditions exist within the state space of some state-based model. Model checking, using tools such as Spin and SMV, has gained much attention recently due to many factors including the fact that it is relatively lightweight when compared to other formal approaches such as theorem proving. In this phase, we initiated investigations on approaches to reverse engineering that combine the use of model checking and log file analysis to reconstruct software architectures for the purpose of both understanding behavior and facilitating architecture level reuse. 2.2
Service-Based
During
Phase
software been
3 we
reuse
Web
at run-time
such
service
HTTP
providers
development services.
and
In this
integrate
model,
of data services
of a federation
based needed
mechanisms
or services
model,
a service
such
benefits
of using
over
is one
interact
and
the
one
built
as side
effects
a service-based
while
become
the
client
A
and
are viewed
as
be providers
or
which
facilitates
the creation
over time. include
publication.
the
service
software
modularity,
In the service-
definition
(modularity).
for developing
service-based
dynamically
the details
and
by
paradigm
technologies
hiding
internet
to be provided
that can evolve
is upon
and
this
and
non-factors
approach
another
resources
focus
data
use
components
within
of service-based
Since
achieving
boundaries.
that
internet.
in which
with
on available
(description)
(implementation-independence). concerns
information
clients
a primary
have
information
and organizational
implementation-independence, paradigm,
for
to
middleware
new "super-services")
characteristics
components
approaches
access
company
Applications
based
(e.g.,
can
of service-based
individual
whereby
allowing by
use
components.
broker-based
consumed
at runtime
description,
to access
XML,
behavior.
of services
development
employ
once
the
developed
by traditional
services
and
of the defining
availability,
are
and
paradigm,
consumers
Some
as
we
legacy
instance,
into
systems
adapted
constrained
for
investigations
Specifically,
technologies
Services,
our
for implementing
using
is no longer
protocols
continued
engineered.
Service-based behavior
also
as a means
reverse
integration
reuse.
of the
interface
of its implementation are
decoupled,
One
of the
is that
other potential
at any given
time,
a wide
client
(availability).
variety
of alternatives As a result,
at run-time
(published).
This
phase
of the work
the creation
of services
applications. services
The
and achieves
approach and
itself
use
technology
is
of the
used
using
with
needs
whereby
with
the
for
a client
approach
language
to describe
technology.
"glue"
for
code
both
generated.
facilitating
for client
middleware
is automatically
a broker
of a given
service-requesting
description
current
services
as
the
may be integrated
integration
model
meet
of an architecture-based
an architecture
integration
that
make
that
The services The
Jini
service
registration,
we developed
a translator
at runtime.
Tools
that
to XML
converts
Further formal
+
run-time
and integration
Source
4
utilizes
on a proxy
interconnection
3
subsequent
is based
applications
lookup,
the development
their
technique
be available
any or all of the services
involved and
may
generator.
As an add-on
an intermediate
tools
were
specification
planned
format that
generators
to previous
into
would
from
an XML-based
have
source
tools,
used
this
representation
called
representation
to
GXL.
implement
code.
Deviations Modified
scope
elimination
of the
construction, interfaces, ability
due to budget
which adaption
to create
third
year
would
cut. budget.
have
scope
was significantly
Specifically,
we were
provided
of components,
sophisticated
The
search
and
a seamless integration.
capabilities.
modified
unable
to complete
environment This
due to the
impacted
for discovery primarily
tool of our
s
Third
Year
Papers
Published
[1] "Automated Support for Service-Based Software Development and Integration", (with Sudhakiran V. Mudiam and Timothy E. Lindquist), submitted to the Journal of Systems and Software - Special Issue on Automated Component-Based Software Engineering, Oct. 2002. [2] "Using Log Files to Reconstruct State-Based Software Murthy), WCRE'02 Workshop on Software Architecture 2002. [3] *"A Novel Service-Based Paradigm for Dynamic Sudhakiran V. Mudiam and Timothy E. Lindquist), Intelligent Service Integration, July 2002 6
Project
Activities
6.1
Project Activities
The following period.
and
Architectures", Reconstruction,
(with Shilpa September
Component Integration", (with in the AAAI-02 Workshop on
Results
is a listing of all of the investigations that occurred during the funding
1. Service-Based
Software
a. Component b. System 2. Alternative
Reuse
Wrapping
Integration
Approaches
to Reverse
a. Graph-Based b. Log-File
Engineering
Approaches
(Component
Reuse)
Based Approach
(Architecture
Reuse)
3. Tool Development a. Reverse
Engineering
i.
Component
ii.
Reverse
Tools
Wrapping
Engineering
1. Dependency
Tools Tools
Graph Generator
2. Code parser and Visual Browser 3. C to XML Code Generator 6.2
Findings
The
primary
contribution
service-based such as performed
.NET
of this research
software development are
an indication
was the recognition
approaches. of the
towards
Recent introduction of technologies
emergence
under this grant directly addressed
of a move
of such work.
service-based
The
research
issues from the standpoint
of
legacy
system
providing
and
component
infrastructures
to support
eventual
6.3
Second
6.3.]
Tool
integration.
Specifically,
discovery
and specification
that support
reuse
and integration
of those
our
work
was
aimed
of components
components
at
in order
into new applications.
Year Results Development
During
the
second
reverse
engineering
•
Analysis
•
Construction
•
Clustering
year
of the
support
of ANSI
project,
construction
tool was completed
of
a preliminary
and supports
version
of the
the following
features:
code
a number
C programs
of graphical of graph
representations
based
of source
representations
code
of source
using
of
criteria The
tool
development
development
of
development
6.3.1.1 The
for
into two separate
the
user
C
program
interface
projects.
language.
as well
The
The
first involved
second
as the appropriate
the
involved
clustering
the
routines.
Parsing project
to support
source
code
generator
involved
modules.
was
grammar
display
C
This
the tools
input
C source
corresponding Hierarchy module). SourceFile
given
files.
Representation These >.stm,
files where
grammar
In
done
provide
to help
below.
Tree
< SourceFile
disk
a
for easier
will
for the source
code
the
names
>.c is the file being
similar
traversal,
system
parser
with
intermediate
in a manner analysis,
be used
be two
documentation
.ast parsed.
to and
can be built to parse
object
and the Statement
in API
of C
modified
by the
and
be
and the
it can
below
analysis
second
parser
can
parser
tool),
constructs
The
that
Metamata's
is built,
further to
using
addition,
tool.
system
and facilitate
building
the parser
generated
Syntax
saved
engineering Once
tools
tree
[1].
parsing
created
language
(described are
was
that grouped
Output
to the Abstract
based
engineering
associated
by the reverse
and files text
was
of a Java
system
(JavaCC's
language
of the C Source
using
parsing
developed
[3,4].
creation of reverse
The
JJTree
provided
representation
the
the construction
JavaCC,
JavaCC
the
a parser
of a graphical
parsing
used
was partitioned
files Class
for this and
Specfic
by one or more ports
Ports are the interaction
encapsulate
_
delivers
on the ports of the component,
Port specifications
Connectors
....
unit and has an interface that specifies
the interface
!
__
Requestt)lq
2: Object Adapter [Gamma
is defined as a configuration
of a computational
SpecificAdaptee Reques,(
via hierarchies
the user to describe
style. and con-
semantics
set of components of interfaces.
the architecture
There
of a system.
Jini
The primary the delivery connected desktop
enabling
feature of the work described
and management to the network.
devices,
printers,
of services.
Typically
In a typical
these devices
fax machines,
layer provides
distributed
system
services
is the existence
Jini network,
consist
and Personal
Figure 3 shows the layered architecture
in this paper
are provided
of a variety of products
Digital Assistants
of the Jini Interconnection for activities
services
ranging
by devices
for
that are
from cell phones,
(PDAs).
technology
such as discovery,
of the Jini technology
lookup,
where the Jini Technology remote
event management,
transaction
management,
into a Jini network, service.
When
mented
service
it becomes
a service
can discover
application volved
interactions
to provide
components
of its original
intention
join protocols
supported
a standard
that are acting
of being
service
of the network service.
through
Once
to interact
to implement
(often
imple-
other network
service.
When a client
but then is no longer to component
in-
integration,
and connecting
a client
to corre-
Jini technology
outside
the scope
with one another
service-based
proxy
registered,
In our approach
We are using
is plugged
by the Jini lookup
The
the lookup
for registering
as services.
I
or "service"
sets up the connection
method
Application[
a device
of the service.
and device.
able to allow devices
by this technology
service)
(e.g., service)
the client
When
by the lookup
to the clients
the lookup
between
(e.g.,
is stored
of the device
device,
leasing.
as a member
a proxy
the availability
we use the Jini technology software
and service
can later be transported
finds an appropriate
in subsequent
sponding
registered
is registered,
with an adapter)
members
registration,
software
by using
the discover
and
development.
Service
Jini Technology
Technology Java
Figure One of the advantages applications from
"on-the-fly"
the fact that services
network.
the client
or must
must have some
on Jini for a number More
importantly,
of the current providing
implement
and future
including of using
capabilities
a view into forthcoming
between
about
stems
is that it facilitates
from
the fact that it allows Jini over the emerging
of web service
support
Another
in order
and the device
advantage
to participate
upon
for the creation Web services
software
That
is,
our framework
technologies
of services. is that
supported
development
arises in a Jini
connection.
of federations
are already
of
to the services
We have implemented
infrastructure
of web service-based
construction
the fact that the interface
how to use the service.
capabilities
basis.
set of routines
the client
of the web services
of development
technique
can be used on an as-needed
of this approach
knowledge
an advantage
integration
a fairly general
be negotiated
of reasons
to wait for the completion
3
must
components
One of the disadvantages
must be well-defined
3: Jini Architecture
of using this Jini-based whereby
Technology Java Device
l
many
by Jini, thus
without
needing
technology.
Approach
This section services,
describes
specifying
the service-based client
applications,
development realizing
approach
integration,
including
and generating
the techniques glue code.
used for defining
3.1
Overview
The approach ology
that
although
described
we have developed the technology
that the technique require
in this paper follows follows
The approach
at the conceptual
itself focuses
via the use of adapter
to realize
on two concerns
and proxy
synthesis.
for software
suggested
domain
is Jini [Richards,
and that translation
amount
with respect
of change
to software
to for reuse, the approach Specifically,
development.
by Stal [Stal, 2002]
our approach
level and a modest
With respect
model
the model
to the web services
reuse and with reuse concerns.
services
closely
that we are using
is applicable
little change
a services-based
The method-
for web services,
1999].
It is our belief
into that technology
at the technology
reuse.
the methodology
level.
That is, it addresses
involves
the construction
involves
would
both for
of services
two steps for creating
as follows:
1. Specification
of the components
2. Generation These
In the context services.
of the services
services
using
are consequently
of this paper,
including
With respect
proxies
research
web services
via the construction
registered
we address
As part of our ongoing
of services
as services
the creation
adapters
and glue
code.
[Gannod
et al., 2000]
on a network.
of command-line
work we are investigating
and .NET
to with reuse concerns,
of appropriate
and made available
applications
as
approaches
for integrating
a wide-variety
the construction
of applications
using services
components.
the approach
involves
as follows: 1. Specification
of a client to make use of services
2. Generation
of the client
generation
of glue code)
3. Execution
Figure tructure accessed
of the client,
4 shows
described
other things,
the client
will need in order connections
services,
lookup
service.
construction
integration
the basic
Structurally
of proxies.
Within
application
specification
to be a complete
between
clients,
depicting
in this paper.
code for the client
manual
including
a diagram
via a layer
the source
(both
from the repository of client
the architecture
our approach, along
contains system.
the client
and employed
and connectors.
At run-time,
application
of the specified
architecture
services
uses a layered
a user (e.g.,
a description
services,
is generated
the services
are bound
created
within
the infras-
style with a layer
of services
is responsible
of the architecture services
code, including based
code and automated
at runtime
developer)
of the basic
source
specific
for applications
with the specification
All other
or network
for client.
that the client
code necessary on the specifications
to the client
for writing
component
Among
application to realize
the
describing using the Jini
Client
Figure 3.2
Service
In order
to generate
by utilizing defined
4: Basic
Architecture
Generation services
the interface
interface.
from
legacy
provided
The interface
components,
we take the approach
by the component.
is based entirely
For example,
of wrapping
command-line
on the knowledge
the components
applications
of how these applications
have a well are used rather
than how they work. 3.2.1
Specification
The
concept
Sneed,
and Synthesis
of using
1996, Cimitile
ping has many be created
benefits
an adapter
et al., 1998, Jacobsen in terms
and a reduction
In regards
for wrapping
in the amount components,
software
as an architectural
component
required
to define
3.2.2
based
the interface
(S1)
A sufficient
of existing
is created.
to the legacy
a reduction
[Gamma
strategy,
in the amount
et al., 1995,
component
wrap-
of new code that must
code that must be rewritten.
our approach
of an appropriate
specifications
amount
mize the amount
($2)
including
As a migration
one
uses These
software.
two steps. specifications
Second,
First,
a specification
provide
the appropriate
of the legacy
vital information adapter
source
that is code
is
Requirements
To aid in the development upon
1998].
is not a new
on the specification.
Specification
requirements
software
and Kramer,
of re-engineering
to wrapping
synthesized
legacy
of the interface
of information
of source
scheme
should
for the wrapping
to legacy
A specification
of the interface
of the adapted
from the target
implementation
language.
we defined
the following
software.
be captured
code that must be manually
activity,
in the interface
specification
in order
to mini-
constructed.
component
should
be as loosely
coupled
as possible
($3) Thespecification of theadapted component shouldbeusablewithina moregeneralarchitectural context. Therequirement $1addresses thefactthatweareinterested in gainingabenefitfromreusinglegacy software. Asaconsequence, wemustavoidmodifyingthesource codeofthelegacysoftware. At thesame time,wemustprovideaninterface thatis sufficient forusebyatargetapplication. Toprovidethatinterface, asufficientamount of information isneeded in ordertoautomatically construct theadapter. Asaninitialinvestigation intotheautomated synthesis of theadapters, weselected command-line applications asoursource ofreusable legacysoftware. Selection of thisclassoflegacyapplications addresses themodification concernof requirement S1sincesourcecodeis notavailable.Assuch,wearerequired to provideaninterface thatis basedsolelyon theknowledge of howtheapplication is usedratherthan howit works.In addition,theselection of thisclassof applications hastheconsequence of enforcingthe useof a particulararchitectural style,asdetermined by thenatureof thelegacyapplication.In thiscontext,wedefinedseveralproperties thatwouldbeneeded to appropriately specifythebehavior provided by a command-line application including:Signature,
Command,
Pre, Post, and Path.
We identified
properties
and outputs
generally
with command-line
by examining
the type of behaviors,
inputs,
associated
these
applications. The Command properties
property
identify
commands
and post-conditions given
types
names
application
Accordingly,
1 shows
component
specifications
indicate
executed,
respectively,
of a "service
later utilized
during
the adapter
component, property
defines
for command-line
degree
the Pre and Post preconditions
Path indicates
the types
of semantic
the path to the
and names
with command-line
applications,
while
code that will establish
respectively.
since we are dealing a certain
the application
of the expected
applications,
information
these names
the input
must
are typically
be used
limited
in
to file
options.
specification while
terms
Fortunately,
the properties
of the service,
within
and the Signature
to be strings.
and command-line
used to invoke
of the legacy
Here,
of the input.
Table
that are contained
of that application.
are expected
the name
the command
on the execution
command-line
input and output
identifies
used
consists
the ports
of two parts:
section
style-based in order
type"
describes
information to establish
(encoded
application
in the specification properties functions
and ports. provided
an environment property)
clients
and connectors.
The properties by the service.
as well as conditions
as an Interface
integration.
of services,
necessary
or commands
section
describes
style
In addition,
the service
that need
to be true or
to use the service.
is used to support
A service
a service
Finally,
a key in
lookup,
which
is
Group
Attribute
Description
Service Properties Service Port Properties
Component-Type Signature Return Cmd Pre Post Interface Path Port-Type Shared-GUI
Architectural style this component adheres to The port's signature The port's return type The command line program being wrapped Pre-processing command Post-processing command The generic interface implemented by this port Path to the wrapped command line program The port's type based on the Component-Type Boolean indicating shared (true) or exclusive (false) GUI
Part-of-client GUI-CodeFile
Does this specify the client application The filename for client's GUI code
Component-Type Shared-GUI Port-Type Interface
Architectural style this component adheres to Boolean indicating shared (true) or exclusive (false) GUI The port's type based on the Component-Type The generic interface that this port can bind with
Connector-Type Prop-Type
Architectural style this connector adheres to The connectors role based on the Connector-Type
Client Properties
Client Port Properties Connector Connector
Properties Role
Table 1: Properties The requirement
$2 (i.e.,
based on the desire to apply addition,
this requirement
artificially
embedded
that a certain would
the decoupling the synthesis
facilitates
of the source desirable context.
legacy
software
Technology
specification the added
is, it is advantageous for new systems.
benefit
target application In order wrappers,
of providing
S 1 by ensuring
information
and implementations. that new source
is ideal,
we found
In
code is not
in our strategy
due to the fact that our implementation
an interface
component
specification,
that can be integrated
is defined
as indicated within
to be able to use the specification
In using a content-rich
is
1999].
However,
of the adapted
language)
that facilitates
by requirement
the use
$3, it is also
a more general
architectural
as part of the software
architecture
where
interfaces
are defined
into an architectural
explicitly,
specification
of a
is gained.
to realize
the requirements
we used the ACME
we used
the properties
Signature,
Command,
specification
[Richards,
implementation
of target languages
was necessary
as part of a new application.
a target
this requirement
using our technique,
to be able to use the specification That
satisfying
dependence
has been wrapped
from
of requirement
While
of implementation
a component
to a variety
enforcement
make use of Jini Interconnection
When
approach
in the specification.
amount
of a specification
section
[Garlan
placed
of the ACME
[Garlan
desired
et al., 1997] Architecture
Pre, Post, and Path).
and interchange
upon
ADL to specify
ACME
et al., 1997].
interface
specifications
Description the interface
Language features
for legacy (ADL). described
is an ADL that has been used for high-level ACME contains
constructs
for embedding
software
Specifically, earlier
(e.g,
architectural specifications
writtenin a widevarietyof existingADLs,makingit extensible tobothexistingandfuturespecification languages. ACMEis supported by anarchitectural specification tool,ACMEStudio [AcmeStudio,2002], thatfacilitates graphical construction andmanipulation ofsoftware architectures. Figure5 showsa screen capture ofanACMEStudio session in whichacomponent hasbeenspecified asanaggregation of two wrapped applications expressed asports.In thefigure,thecomponent labeled RCSis theaggregate component andconsists of twoports,ChklnandChkOut. These as wrappers
for the Revision
portion
of the figure contains
values.
The amount
working
knowledge
parameters current
Control
System
(RCS)
a list of the properties
of knowledge
as well as other
application
in order
is used.
bits of information
ci
used to derive
that is required
of how a legacy
programs
and co,
respectively.
the wrapper
along
to write the wrapper
Often this includes
that can be retrieved
from
ports
are used
The bottom
right
with their corresponding
specification
knowledge manual
is limited
to a
of the command-line
pages (if they exist)
and
users.
=_1 Chkln System topleveL
d All Properties
q.I Global Type Deft - _ System toplevel - • RCS 6
Chkln
Ill
ChkOut
,t
I
I Inveriants
Name Cmd interface Path
zJ
l T),1oe string string string
] Heuristics I ,
[ Value ci ", filename
string string
Return
string
WriteFileD ata(file date. filename) Boolean resuff
Signature
string
Stringfilename,
ii
Figure benefits
if the specification aggregated behaviors
of an adapted
as a service
of applications out via ports
component.
through
can be aggregated of the aggregate
i
5: ACMEStudio
arise from the use of the ACME
into a single
String params,
...................... Editing b'_tem loplevel'
iin
Several
EXE
Post Pre
_eedy i
+ perams
VersionManagement C:\RKTOOLSkBIN\CI < No Value >
component
As a consequence,
into a single component.
i
as a port,
Second,
NUM
in
iiii
the legacy then
the aggregated
For example, component
several
such
component
as demonstrated
that offers
application
i
iiilll
I
services
wrappers.
First,
components
can be
can offer each
of the
in Section
4, the RCS suite
such as check-in
via the use of ACMEStudio,
9
'"
in Desi
Session
ADL to specify
is realized
a port interface.
i
Strincj filedata
Jt
and check-
the specification
of an
adapted component canbeintegrated intothespecification of targetapplications. Consequently, software architecture analysis techniques thatsupport theuseof ACMEcanbeappliedto targetapplications that utilizethewrapped legacysoftware.Finally,sincelibrarysupportforACMEconsists of a setof standard parsers andothermanipulation facilities,construction ofsupport toolsisconvenient (seeSection 3.5.1). 3.2.3
Synthesis
As stated
earlier,
this constraint,
the class of legacy
we make the assumption
a certain amount of knowledge to be reasonable tional history
due to the nature
First,
Java continues
legacy
into Java applications
straightforward components.
Finally,
nection
Technology
[Richards,
result,
software
applications. plementing
In our approach, ties associated
and environment
to enjoy
increases
as services
synthesis routines wrapper,
process,
the information
the support
code for facilitating an automated
shown
While plications broadening
to register
could
interaction
in Figure
to generate
6. In addition
we added
the Interface,
a service
with a standard
on a Jini network. to automate
a potential
fully executable
client
components.
components
is based
exactly
Command
template
this process
as Cmd in
These
implements
to synthesizing generates
and the wrapped
code for the wrapped
to the proper-
(shown
fields.
that
fields deIn the the setup
the appropriate
the appropriate
component.
application
on im-
Technology.
with the port, respectively.
In addition
As a
into distributed
and Return
after interaction
of wrapped
dynamically
corresponds
to the Signature,
of Java fa-
by the Jini Con-
by Jini Interconnection
wrappers
to integrate
or federation,
to software
for legacy
for a num-
nature
provided
and integrated
that is defined
are combined
between
also be applied
wrappers
platform
the object-oriented
that the services
for synthesizing
tool that we have constructed
tool that generates
user to modify
have an organiza-
and thus any opportunity
Second,
on a Jini network
that is needed
specifications
that are required
have
We find this assumption
as our target migration
we found
name of a port and the value returned ACME
Given
components
applications
of an aggregation,
devices
and join protocol
Figure 6), Pre, Post, and Path properties, fine the Jini service
legacy
consisting
importantly,
1999] for smart
discover
with the ports
where
applications.
the wrapped
component.
in popularity,
benefits.
of components
our approach
the standard
migration
language
and most
can be packaged Accordingly,
utilizing
of that wrapped
software
has obvious
construction
legacy
are command-line
usage profiles.
ber of reasons.
cilitates
the interface
of legacy
the Java programming
systems
that we are considering
that any client applications
regarding
with well-known
We chose
systems
At present,
source this is
and does not require
the
or write any new code.
the investigations for use within the context
that are described
a Jini-based
software
of this approach
here
are limited
integration
to other
legacy
10
to our efforts
environment, software
to adapt
command-line
ap-
we are pursuing
investigations
into
components
including
GUI-based
appli-
Component
RCS
:
Properties
{
{
Component-type
:
string
:
"Call
Return";
}; Port
ChkIn
=
{
Properties
{
Signature
:
Return
:
string =
"String
filename,String
"Boolean
:
string
=
"ci
Pre
:
string
=
"WriteFileData(filedata,
:
string
Interface Path
=
:
:
string
Port-type
:
filedata
";
filename
+
params"; filename)";
"";
string =
Shared-GUI: };
+
params,String
result";
Cmd
Post
};
=
string
:
"VersienManagement";
"C:\\RKTOOLS\\BIN\\CI.EXE
string
=
"callee";
string
=
"true";
";
};
Component
Lzpr
=
Properties
{
{
Component-type
:
string
:
"Call
Return";
:
string
=
"Call
Return";
}; Port
Print
:
{
Properties
);
};
{
};
Component
Javac
Properties
:
{
{
Component-type }; Port
Compile
=
Properties
};
};
{
{
};
Figure cations.
In addition,
approaches
due to the ability
for automatically
wrapping
6: ACME
Spec:
Services
of Java and consequently applications
Section Jini to run anywhere,
that exist within
heterogeneous
we are investigating operating
system
envi-
ronments. 3.3
Client
Generation
Once
the services
are generated
we need to specify Once
a client
is specified,
for specifying 3.3.1
the client
again
erties
of client
level,
two
Second,
application
in a repository,
taking
it can be verified and then describe
a client
into account
and generated. synthesis
application
the architectural
can be architect-ed. style of each
In this subsection
First
of the services.
we look at the requirements
of the client.
Specification
Refer
match
the client
and stored
to Table
application
issues
[Shaw most
1 which,
arise
modern
components
(among
and Garlan,
in addition
others)
1996]
applications
occurs
to the properties
and connectors. that
provide
When
are of interest.
when
the underlying a graphical
11
for service
user
dealing
First,
specifications, with integration
the problem
assumptions interface
the prop-
at the component
of architectural
made (GUI).
contains
style mis-
by components
As a result,
conflict.
integration
of
off-the-shelf components canleverage theseuserinterfaces in ordertotakeadvantage of previously technology.
To cope with these
issues
we impose
two requirements
on the specification
of client
built
applica-
tions. (CI)
The specification level interaction
(C2)
The specification
The requirement A component's interaction
client
C1 addresses plays
constraints.
the service.
is making
3.3.2
role
when
In this context, services
there
or exclusive
style so that the high-
GUI components.
provide
it interacts
a notion
with other
mismatches
of architectural
components
style.
by imposing
can be determined
by stating
style. may provide
may be GUI
to the service.
services
must
architectural
regarding
of architectural
and exclusive
the fact that a service
as well as other integrated
that provides
important
Using a basic style attribute,
C2 addresses
by other
the use of shared
the fact that a component
a very
that a component
Requirement
sharable
must facilitate
style
the assumption
control
of the components should capture the notion between clients and services can be verified.
a GUI that allows
components
A sharable
while an exclusive
provided
by services
GUI component
GUI component
a user to access that
and
are either
can be used by both the
can only be used by the service
the interface.
Synthesis
The second
stage
specification synthesis
of our approach
of a client. of client
and attachments, applications determine
such
depicts
the replacement
used to realize allows
and integration
specific
concerns
a template-based
promotes
loose
steps utilize
Figure
in with in "()"
between
services
to focus
tools.
approach
lacks
between
components.
specifications
to determine
are used
tags.
Given the nature
and clients upon
generality
that utilize client
issues
necessary
of service-based
components
In addition,
at the core
12
services),
dictates
That is,
template
generated
delegating
to synthesize
to
with either and
(e.g., code
we have found
while
client
is used
code.
for the client
of the code being
operation
and freedom
by services
to synthesize
the
connectors
between
that must be instantiated
those
a sample
to support
regarding
provided
approach
holders
7 shows
the relationships
GUI's
a template-based place
Figure
9 shows a piece of code (e.g., POC)
primarily
to automated
code.
First, the information
regarding
that has stubs containing
code, the very nature
coupling
8 are used
application.
parameters.
client
two features;
the GUI in a client
the developer
and integration
in Figure
of application
within
information
points
integration
contained
Second,
file has been created
or client
While
shown
services.
the synthesis
step utilizes
and client synthesis
service
nector
as those
and desired
Both the service
approach
information
code. This synthesis
how to realize
a standard
The
involves
that this connector
complex
con-
a level of interaction
that
of service-based
applications
is the
Component
Editor
Properties
:
{
{
Part-of-client GUI
:
CodeFile
:
Component-type
:
Shared-GUI:
string
:
string
=
string
string
:
"true";
"ClientGUICode.java"; =
"Call
Return";
"true";
}; Port
VMPort
=
{
Properties
{
Port
type
Interface };
:
string
=
"caller";
:
string
=
"VersionManagement"
;
};
Port
COMPILING_PORT Properties
= {
{
Port-type
:
string
=
"caller";
..};
:
string
=
"caller";
..};
}; Port
PRINTING
PORT
Properties };
{
=
{
Port
type
};
Figure notion
of common
and integration synthesis 3.4
interfaces
operations
and
Architectural
As mentioned facilitate
can be easily
Runtime
Style
earlier,
Client
parameterized,
Section
As a result,
further
code that
leading
towards
implements
connection
a template-based
software
Verification in our framework
a tool called
It does so by verifying
Our current
implementation
to components Call Return
of the same components
to allow for mappings
3.4.2
Client
Verifier
is used
an exact
match
For example, a Call Return
of other
types,
a Call Return
where
to verify
between
criteria
connector.
the style characteristics that
client
whereby
and service
components
component
Our future
the styles
of components.
To
of components
are
components
match.
can only be connected
can only be connected
investigations
include
to other
expanding
the
appropriate.
Generation
A client can be generated use of a client
the list of services and the user-defined of these
GUI facilities.
type.
through
Arch
capture
that all the attachments
imposes
verifier
developer
Spec:
and services.
Considerations
specifications
this verification
consistent.
makes
7: ACME clients
approach.
Integration
3.4.1
between
once the Arch Verifier
template
(indicated
similar
client
However,
to the one shown
by the (List
GUI components
validates
of
(indicated
the architecture. in Figure
Services) by the {GUI-
GUI components
by the can assume
the actual
of shared
names
13
tool called
9 and fills the appropriate
tag) that are to be integrated CodeFi
service
GUI components
classes
Generator
sections
with
with the client
1 e > tag) of the client.
that certain
and exclusive
a client.
A synthesis
Typically,
provide
the
common
need not be known
by
Connector
checking_out
Properties Role
{
=
{
caller
Connector-type
:
string
=
"Call
Return";
}
=
Properties
Prop
type
:
string
=
"output"
Prop
type
:
string
=
"input";
;
); Role
callee
=
Properties };
};
Connector
checking
Properties Role
{
in
=
{
caller
Connector =
type
:
string
=
"Call
Return";
}
{
Properties
{
Prop
type
:
string
=
"output";
:
string
=
"input";
};
}; Role
callee
=
{
Properties };
{
Prop-type
};
};
Connector
compiling
Properties Role
=
{
callee
{
connector
type
:
string
-
"Call
Return";
=
Properties
Prop-type
:
string
=
"input";
}
Prop-type
:
string
=
"output";
}; Role
caller
=
Properties };
;
};
Connector
printing
Properties Role
{
callee
=
{
Connector
type
:
string
-
"Call
Return";
};
=
Properties
Prop-type
: string
=
"input";
};
"output";
};
}; Role
caller
=
Properties };
{
Prod
type
:
string
=
Port
to
checking_in.caller;
to
checking_out.caller;
);
Attachments
{
Editor.VM Editor.VM_Port
Editor.COMPILING_PORT Javac.Compile Editor. Lzpr.
to to
PRINTING_PORT Print
Rcs.ChkOut Rcs.ChkIn
to
to
printing.caller;
printing.callee;
to to
compiling.caller;
compiling.callee;
checking_out.callee; checking_in.callee;
};
Figure 3.4.3 Since
many
nents.
In our framework,
interface
services
can be GUI-bound,
that allows
components
the adapters
the client
are potentially
dard GUI vocabulary which
8: ACME
Spec:
Connector
Section
to provide
a facility
GUI Integration
the GUI components nent is independent
for the various
to get a handle
used across
(for example
GUI components
it is necessary
by allowing and cannot
are used as is but may interact
multiple
across
services
between
in Figure
and exclusive
and are identified
or "ResultsWindow").
services.
reuse of widgets be shared
(as shown
on the shared
"CodeWindow"
can be shared
services
Such
shared
that provide services.
14
using
a common
of a GUI.
a name taken
Shared
from a stan-
The name is then used to identify facilitate
the same functionality.
components.
the GUI compo-
14) implement
components
components
The exclusive
with one or more of the shared
for integrating
the integration
An exclusive
GUI components For both shared
of
compo-
of the adapters and exclusive
public
class
MyClient
{ static
String[]
services
static
Hashtable
state
= =
new
;
Hashtable();
public
static
void
main
(String[]
args)
{ //discover
and
//discover //and
join
all
get
the
the
the
jini
network.
services
on the
the
network
adapter
for
service.
boolean
alreadyAdded(String
} private
static
key)
{ //check
if
//
key
with
a
shared has
component
been
added.
} private
static
boolean
inMyList(String
serviceName)
{ //
verify
//
list
if of
the
serviceName
is
in
the
services.
} } Figure components,
the interaction
interaction 3.5
with the client
with the services
9: Client
Template
POC
GUI and application
while the client
is seamless
need only interact
since the adapters
handle
direct
with the adapters.
Implementation
In this section
we discuss
the implementation
aspects
of the service
generation
and the client
generation
using tools that we have built. 3.5.1
Service
Generation
To support
our technique
tool called
ServiceTool.
specification the square
Figure
and produces corners
an internal
ArchParser h_terface
Generator
The Function service.
software
components
component
Generator
while
specification
component
component
uses these functions
15
to generate along
corners
in Figure
a set of ports.
or connector functions
6 and of the The
to the service.
that implement
with the ServiceTemplate
with
represent
uses the output
and produces
the interface
an ACME
the rectangles
to the one shown component
a Java support takes
with the rounded
Inspector
uses the same port information
which
In the diagram,
similar
to generate
we have created
of ServiceTool
the rectangles
of the wrapper
uses the set of ports
component
architecture
The Component
specification
software,
for a Jini network.
in an ACME
of the architecture.
the interface
Generator
The Service
reads
for legacy
the detailed
configured
component
model
to access
10 shows
wrappers
a wrapper
represent
files. The ArchParser builds
for constructing
the
to generate
thefinalJavasource codefortheservice. _
ACME
Arch
_
Parser
Component L
Inspector
I
Interface
Function
Generator
Generator
__4__ Service Generator
loter ] ace I Se 1ce Source
Source
Figure The ArchParser specifications. write
uses the ACMEParser
ACMELib
and manipulate
designed
to support
"native"
ADLs
the rapid
native ACME-based
source
work. Specifically, registering
a service
by the Function
with the lookup
service.
functions.
to the ServiceTemplate,
specification
and WriteFileData code to provide
( ) routines standard
read-from
1997] to parse
tools in Java that read,
The
ACMELib
(1) tools ]Allen
ACME
framework
that translate
and Garlan,
is
between
1997])
and (2)
tools.
Generator
component
file which necessary
functions
For instance,
and the names
contains
to integrate
that implement
of services.
all of the application the legacy the discover
also contains
in Figure
tags in the ServiceTem-
and service
code into a Jini netand join protocol
for
tags that are place-holders
11 the tag
is a
component. is also a reusable
in the generated
(shown
of applications
The ServiceTemplate
there
and consequently
Lib,
as an awk script that replaces
the routines contains
ADL.
1995] and Wright
of the ServiceTemplate
code and provides
generated
and analysis
[Acme
of architectural
in the ACME
and Vera,
for the final name of the adapter
In addition interface
a portion
specified
is implemented
the ServiceTemplate
for the automatically place-holder
generated
11 contains
independent
component
toolkit
the construction
of two classes
[Luckham design
Tool Architecture
the ACMELib
that facilitates
development
architectural
Generator
from
architectures
as Rapide
plate file with functions Figure
is a library
software
(such
The Service
10: Service
in Figure
and write-to
set of functions
wrappers.
For instance,
12), are available
file support,
16
respectively.
as functions
that can be utilized the ReadFi
leData
for use within
in an ()
the Java
public
class
implements
extends
UnicastRemoteObject
,
ServiceIDListener,
Serializable
{ public
()
throws
RemoteException
{ super
();
]
Figure
void //
WriteFileData(String the
generic
11: Excerpt
filedata,
String
of the
ServiceTemplate
filename
{
WriteFileData..
try{ File
f
=
new
File(filename);
System.out.println("IsFile() PrintWriter
out
=
: "
new
out.print(filedata) out.close()
+
f.isFile())
PrintWriter(
new
;
FileOutputStream(f),
true)
;
;
;
} catch
(Exception
e)
{ System.out.println
("Server:
Error
writing
file:
"
+
e);
}
String
ReadFileData(String
filename)
{
try{ BufferedReader String
in
=
new
BufferedReader(new
FileReader(filename));
s;
StringBuffer
while{
sb
(s
=
new
StringBuffer
:in.readLine())
!=
();
null
)
{ sb.append
Is);
sb.append
("\n");
} in.close(); //
returning
return
the
whole
file
as
a
string..
(sb.toString());
} catch
(Exception
e)
{ System.out.println
("Server:
return{"Server:
Error
Error
writing
writing
file:
"+
file:
"
+
e);
e);
} } Figure 3.5.2
To
Client
support
the
ClientGenTool. tecture represent
12:
Sample
Library
Routines
Generation
construction Figure
(specification) software
of
13 shows and
components
client the
produces while
applications,
we have
detailed
architecture
a Client
source.
the rectangles
created
of the In this
with
itories.
17
a support
ClientGenTool
figure,
the rounded
the
tool
written
which
takes
rectangles
comers
with
represent
the data
in Java
called
an Acme
archi-
square stores
comers or repos-
Acme
[ l I
Architecture
Acn_e
(
]
Parser
Internal
Arch
)_
1
Arch Verifier
Extract
(C[ientComp
Client
GUI
....
t
)
Figure
and 8 and builds from
reads
the ACMELib
Internal
Arch
properties.
in ACME
an internal
model
Once
[Acme
to verify
from the h2ternal
Client
to produce
4
Lib, 1997]
the Extract
List of Services Template
13: ClientGen
architecture
]
Tool Architecture
specifications
similar
(h_ternaIArch).
to parse
component
Arch model.
Template
)
ACME
the style of the architecture
it is verified,
)
-Client
Clle.tSou_c_
model of the architecture
toolkit
ListOfServices
Generator
)
(
The ArchParser
Q
to the ones
The ArchParser
specifications.
based
identifies
shown
The Arch
Component,
All these are used by the Generator
6, 7
uses the ACMEParser
on the Component-type the Client
in Figures
Verifier
uses the
and the Port-type Client
GU1, and the
component
along
with
the Client Source.
Examples
To demonstrate
the use of the integration
technique
a simple editing
application
network monitoring
The intent of the simple lation and printing servers
4.1
were generated Editing
Figure services
14 shows
application
a consolidated
were generated
in this paper, we have created two examples, example.
is to support text file editing
The intent of the simple
by creating
All the services
cations
editing
facilities.
on a network
servers.
and a simple
described
network
console
monitoring
using simple
using ServiceGenTool
with version example
administration
[Gannod et al., 2000]
control,
compi-
is to monitor
various
tools while
running
on the
the client appli-
using ClientGenTool.
Application the conceptual
architecture
via each of their respective
adapters.
of the editing
application.
The adapters provide
18
The client application
GUI components
interacts
that are integrated
with by
theclienttorendertheclientapplication. TheseGUIcomponents mayinteract withcomponents fromother services (e.g.,theymaybesharedor exclusive).If a GUIcomponent is exclusive, it mustbeintegrated directlyby theclientasrequired by theservice.If theGUIcomponent is shared, it maybeusedonlyif a similarcomponent doesnotalreadyexist.Forexample, theRCSservice adapter provides a shared editing panelcomponent named "CodeWindow". If theclientalready hasa"CodeWindow" component, theshared component fromtheRCSservice adapter isnotused. l Client_Application
I
liem_GUIO
Figure 4.1.1
Architecture:
Editing
Application
Specification
Figures shown
6-8 contain in Figure
property.
portions
These
spectively.
component
attachments
between
attachments
4.1.2
Client
The
ClientGenTool
generated,
depicts
that the editor
and
ports.
can actually
section
While
be made
printing,
COMPILING_port,
and Java
and PRINT-
shown
shown
in Figure
compilation
the Component-Type
in the specification
components
As
by the Component-Type
compiling,
must match
application.
seeks to bind with at run-time.
printing,
the specification
to generic
the editor
as indicated
V3{_port,
management,
The attachments
roles
component,
namely
for these connectors
and generate
(shown in this
components, property
in Figure examples
that identify
8 conre-
of the two
8) describes identifies
the
specific
a class of services.
Application
the client
time the client joins are bound
to the services
version
Connector-Type
it connects.
ports,
checking_in,
to the appropriate
The
used to describe
is a Call Return
has three
checking_out,
components
services,
component
ports correspond
The connectors the editor
of the specifications
7, the Editor
The Editor
ING_port.
nect
14: Conceptual
[
generates becomes
the focal
a Jini network
via an adapter
the editing
the client
specifications
similar
point for the integration
and looks for services
and the GUIs
application
using
are integrated
as a result
of executing
to integrate.
side code.
described
services.
with the GUI provided
the client
19
of the various
with which
along
to the ones
Once
above.
Specifically, found,
at run-
the services
by the client.
In this case,
Once
the client
Figure
15
has been
executed onaJininetworkthatdoesnothaveanyof thedesired services available.
Figure 4.1.3
Integration
As each
either
is executed
exclusive
integration
it joins
or shared.
they
once all the services
editing
text panes are exclusive the client
up and running daemon
along
must be running
order to enable Network
Monitoring
17 shows
the conceptual
editing
application,
the client
integrates
provide
the top CPU processes
about
how long a system
DumpService
provides
executes
on different
provides
a unified
component.
appears
provided
Figure
as shown
(and shared)
16 shows
by the Javac
lookup
service.
Since
of the lookup
of shared
the result
of the
16. In the diagram, The buttons
respectively.
directly
The middle
and
and Lzpr services. requires
Jini is build
service.
in Figure
by the client,
and the Javac service,
needed
application
of the network here
Finally
has been
machines
to render
UpTimeService
that the Jini network
must be
on top of Java RMI,
an RMI
a web server
with the load
on a network.
must be running
a user to monitor
Similar
in
the client
application.
using
monitoring the machines.
the uptime command.
client
adapters,
This application
The TopService
The UpTimeService
average
to the simple
via each of their respective
using the tcpdump
The network
2O
application.
and TcpDumpService.
using the top command.
up along
that then enables
monitoring
with services
that are integrated
TopService,
information
interacts
a dump of the traffic on network
client
that can be
they are used as is. In the case
with the set of services
architecture
services:
vides
GUI components
with it
the Jini network.
GUI components
the following
provides
and integrates
Example
Figure
each of which
to integrate
across
similar
by the RCS service
prior to execution
code delivery
adapter
the application
window
with an associated
of its existence
the Jini network.
GUI components
application
learns
components,
of another
have been integrated,
the top text pane are provided
Getting
4.2
in lieu
the client
The service
of exclusive
have joined
the top text pane is the original
bottom
adapter.
In the case
may be used
Once all the services
below
a Jini network,
with the corresponding
components,
by itself
and Execution
service
by interacting
15: Client
provides command. Each
integrates
pro-
information The Tcp-
of these services
these
services
and
Class HelloWorld( publlc stitt¢ votd rosin(String(] args)( System. out.prt ntl n('HolloWortd')
iClass HelloWrld{ ^ 1 error
l senatng..leb 'm@ml_!_4 c_nectl_ to 'l_._lks_ connected ti) '1_a1_'
" to lp(mlocalhest i
_, _
er_r ilO_lrliO I_I711 t_t9K_ rllOX SBtVII_ v_tk _ck dl _ sendlng s_r 'AIIlpo' ts _]pC_)_hoSI_ _ error asS: 'speel qvHe for _lpO' dHS not exist on server error ass: ' n_n-extst_nt prlnttr or yov need to run '¢he
ill i Figure 16: Client after Integration 4.2.1
Specification
To build this application,
we constructed specifications
similar to those found in Figures 6- 8. In this exam-
ple, a monitoring client is connected to the TopService, UpTimeService tors. The monitoring client is a CallReturn component,
and a TcpDumpService
as are the services TopService,
via connec-
UpTimeService
and
TcpDumpService. 4.2.2
Client Application
The Client Application
is connected
ilarly the client application TfME_Port
with TopService
is connected
and to the TcpDumpService
via a cjet_totz
to the UpTimeService via a c_et_tcpdunap
21
connector
to the T(3P_poz-t:.
via a getz_uptS_vae connector
connector
Sim-
to the UP-
to the TCPDUEP_Po_t.
The
Network
Admin
Client
op
Figure specification
exclusive
GUI components
4.2.3
Integration
The client
is used
by the
namely
when executed
becomes
it looks for the TopService,
available
on the network,
network 4.3
[ Tcpdump
Service
Architecture:
I
Uptime
Network
ClientGenTool
Service
Monitoring
to generate
]
Application
a client.
"TopResults",
"UpTimeResults"
the focal point
for the integration.
client
is notified
Each
of the services
provide
and "TcpDumpResults".
GUI components
would
When the client
TcpDumpService.
and is bound
to reach and interact
and exclusive
monitoring
UpTimeService,
the client
is used by the client
using the shared
Application
•
and Execution
network,
adapter
"
17: Conceptual
produced
GUI
that are provided
look once all the services
up on the Jini
As each of these services
with the adapter
with the service.
comes
provided
by the service.
The GUI components by the services.
are available
become The
are also integrated
Figure
and integrated
18 shows how the by the client.
Discussion
In the examples the creation service. and
described
of the appropriate
In the client
16 no effort
the network
adminstration
approach
automatically amount
generated.
of effort
vices) is limited With regards of supporting
specific
application
is greatly
to client
specification
seamless
integration
to realize
for the editor
amounts
to a frame
since
In comparison
required
focused.
which
application
less effort
to other component
was likewise
was necessary
GUI,
to generate
primarily
as demonstrated
amounts
upon
a GUI interface
final GUI and application
by Figures
integration
to just
to the 15
outside
a text pane and for
panel. the amount
and glue code
to development
was centered
to provide
However,
application
development,
the adapter
reduced
the services
as well as the code needed
the effort
to a "one-time" required
needed
specifications
(e.g., no extra code)
application
In comparison
the effort
applications,
of the client
based
above,
of code development for service
of applications
since each subsequent
and client
that utilize
application
in the service-
existing
(assuming
components
is
services,
the
existence
of ser-
and code development. and middleware based
technologies,
on availability
22
the approach
of services.
However,
used here has the advantage along
with other
service-
S:lSam
up 10:00,
1S users,
lud
mr_Jm
1,32,
O._IS, 0.4
_-
f ....
ill
I
mmmmm r-
__ eatem
up to!u,
!1 .,gersw_ lud.M_
_2_,
0.SS,
0.4
;
CPU states: 2,21V user, 3.R System, 0;0_ n!¢e, i ram: =1_)_ tv, _0aK used, 15_ rroeo o_ sh i _tp: I_K iv, UK used, I_W _rie ! I PTn II(;FR PItT liT _rTI r R4;_ _I4ARIr _TAT S_'Pil S_4FN TTN 8326 root IG 0 1158 11511 748 R 20.S 0.2 OsO J
........................
Ir00:t0:40,04.13S4 10$;I$,4S.O41SS8 I05:15:4$.08641S i05:19:49.16_t$ i05:19:49.195189 OS:19:49.lSSS05 101_19:49._30t4 r05:t0:40._44C_ 05:t9:49,210015 05:19:'t_!.3134)'$
Figure based
technologies
heavily
5
upon a priori
Related
Recently, services XML service
including knowledge
regarding
Monitoring
Application
has the disadvantage service
behavior
of assuming
loose
and data integration
coupling,
thus relying
concerns.
Work
toolkits
that allow
and Sharkey,
integration
the applications
but rather
An interesting
2001]
protocols
services
to transport
the information
over transport
code provided namely
with vendors
Webservices
are based
layers such as HTTP
paradigm
provide
attention
provides.
and where
and HTTPS.
It does
they reside.
need to be used with a larger
work
The Sematic
has gained
webservices.
what the webservices
area of research
gain a lot of momentum.
Jr., 2001]
and using
what these services
how these
We make use of the ability
[Oellermann,
for building
goes beyond
we also try to define
allows
18: Network
web services,
the use of WebServices
[Seely
s_00,10.12S,21i1._:_ IQ.O.O_,2,41Gt41 P 35000 r_ 10.0.0,Z,4!II_ _i_l_Jt._bh; P 1:4S( 10.0,0,J:,330_5 • _NIX_gpl.pllS_.usweSt:on41t.d0 20!l_111,125,251,1r;m ) 1_r9;9._2,41614: , ack 4 phn_o_l.ghn_.us_;rdit;dg_ln ) 10.0.0.2.3 10.0.0;2,_ ) _.jph_,.u_vest.n_t.do iI_mcpo=1,phflx.__doml_n > t0.0.0.2.3 t0.0.0.2.3:0_G _ _t,_n#.vm*est.net.do vfp _1'1._,_ I0.0,0,t2_ kvll 10.0.0. t phnxpo_1.pflflx.us_est.ne_.do_ln _ lO.O.o.z.3
releasing
on the SOAP
not talk about
of several
to
how to use in that
kinds of services.
by the Jini technology.
Semantic
Web [Semantic
Web, 2002]
Web is an extenstion
to the existing
web as it exists today,
to be given a well-defined
and
Our approach
We take a step further
context
web-
meaning,
23
allowing
computers
and people
has also started
to
in that it
to work together.
TheDAML[DAML,2002]isanagentmarkup language thatis a firststepintryingtospecifyinformation thatcanbeinterpreted bycomputers asopposed tohumans. Jacobsen andKramer[Jacobsen andKramer,1998]describe anapproach for synthesizing wrappers basedon thespecification of a modifiedCORBAIDL description.In theirapproach, theyaddress the problemofobjectsynchronization withinthecontextof theCORBAstandard anddefinea technique based ontheapplication of theadapter designpattern.In manyways,Jacobsen andKramer'sapproach is similar totheonedescribed inthispaper.Wearecurrently interested insoftware atahigherlevelofgranularity than theonesoftenprovided viaORB-based interfaces, thusourapproach hassomepotential forfull automation. However, asweincrease ourscope to includea moregeneral classofcomponent, wemustaddress similar concerns. Thakkar etal.describe theAriadneservice-specification language andprocess andtheTheseus serviceexecution platform[Thakkara etal.,2002].Ariadneadopts arelational-database viewofexistingresources andsupports theconstruction of wrappers treating theseresources asrelational databases. Resources specifiedin Ariadnecanbecombined intermsofdata-flowspecification andthesecompositions areexecuted at run-time by theirTheseus environment. Theylookatdataintegration asopposed tobehavioral integration. Sullivanetal. lookat systematic reuseof large-scale software components viastaticcomponent integration]Sullivanetal.,1997].Thatis, theyuseanOLE-based approach for component integration.To demonstrate theuseof theirscheme, theydeveloped a safetyanalysis toolthatintegrates application components suchasVisioandWord.Inourapproach weuseadynamic approach forcomponent integration and thus,canutilizeawidevarietyof components whoseinterfaces arediscovered atrun-time. CyberDesk [Deyetal.,1998]is acomponent-based framework writtenin Javathatsupports automatic integration ofdesktop andnetworkservices. Thisframework is flexibleandcanbeeasilycustomized and extended. Thecomponents in thisframework treatalldatauniformlyregardless of whetherthedatacame fromalocallyrunningservice or theWorldWideWeb.Thegoalofthisframework is toprovideubiquitous access to services. Thisapproach issimilartoourproposed approach in thattheyuseadynamicmapping facilitytosupport run-time discovery of interfaces. Finally,Grechanik etal.describe waystointegrate andreuse GUIdrivenapplications [Grechanik etal.,2002] bywrapping applications asobjects andaccessing themprogramatically viaanAPI.Theyachieve thisusing interceptors thatcapture GUI eventswhichcanbelaterreplayed.In comparison, ourapproach achieves GUIintegration byrequiringthatservices onaJininetworkprovidea GUIviaanadapter andproxy.The GUIintegration is realized byusingJini'sbuilt-infacilityfortransporting directhandles totheproxiesand integrating themdirectlyintoclientapplications atrun-time.
24
6
Conclusions
The web-based as SOAP
services
[Seely
application
and Future
and Sharkey,
sharing,
providing
reuse,
facilities
approach
paradigm
Technology. integration services
2001].
The benefits
and target applications,
utilizes
In addition,
we are investigating
application
in order
to create
to the ones described
web service
an environment service
approaches federated
groups
introspection.
integration,
browsing
of services.
in order to support
these
we described
an
to collaborate
component
is used to specify
design beyond
both
checking.
of applications
application
as by
compatibility
in the creation
such
benefits
to realize
ADL
service
such
of Jini Interconnection
code necessary
to facilitate services
extend
in the context
for performing
advantages
In this paper,
the ACME
that will assist
of technologies
has obvious Services
to generate
for allowing
in this paper
technologies
organizations.
synthesis
To facilitate
and will support
with the development
via the use of services
and is used a medium
developing
paradigm
of such
and component
integration
the approach
recently
between
integration
as well as GUI integration.
service-based
attention
and inter-operability
component
Specifically,
We are currently
similar
has gained
for on-the-fly
for addressing
Investigations
within
[Mudiam
the
et al., 2002].
the scope of a client
Furthermore,
we are developing
service-based
application
technologies
within
the .NET and
frameworks.
References [Acme
Lib, 1997]
Acme
Lib
(1997).
The
acme
tool
developer's
library
(acmelib).
http://www.cs.cmu.edu/,_acme/acme_downloads.html. [Acme
Studio,
2002]
Acme
Studio
(2002).
Acmestudio:
A graphical
design
environment
for acme.
http://www.cs.cmu.edu/_acme/AcmeStudio/AcmeStudio.html. [Allen and Garlan, ACM
Transactions
[Chikofsky
Allen,
1990]
A Taxonomy.
et al., 1998]
2002]
DAML
Engineering
Chikofsky,
Cimitile,
for wrapping.
A Formal
Basis
for Architectural
Connection.
and Methodology. J. H. (1990).
Reverse
Engineering
and Design
7( 1): 13-17.
A., DeCarlini,
(2002).
D. (1997).
E. J. and Cross,
IEEE Software,
gies: Data flow analysis IEEE, IEEE CS Press. [DAML,
R. and Garlan,
on Software
and Cross,
Recovery: [Cimitile
1997]
U., and DeLucia,
In Working
Daml-based
A. (1998).
Conference
web-services
Incremental
on Reverse
description
Engineering,
language.
migration
strate-
pages
59-68.
[Online]
Available
http://www.daml.org/services. [Dey et al., 1998] Self-Integrating [Fremantle
Dey, A. K., Abowd, Context-aware
et al., 2002]
munications
Fremantle,
of the ACM,
G.,,
Services.
and Wood,
A. (1998).
Knowledge-Based
E, Weerawarana,
CyberDesk:
Systems,
S., and Khalaf,
45(10):77-80.
25
A Framework
for Providing
11 (1):3-13.
R. (2002).
Enterprise
services.
Com-
[Gamma etal.,1995]Gamma, E.,Helm,R.,Johnson, R.,andVlissides, J.(1995).Design ments of Reusable [Gannod
Object-Oriented
et al., 2000]
Approach
on Reverse
et al., 1997]
Interchange [Grechanik driven
Garlan,
pages
D., Monroe,
In Proceedings
et al., 2002]
Grechanik,
Wesley
Adapters
for Legacy
128-137.
IEEE.
T. E. (2000). Software.
R. T., and Wile,
D. (1997).
of CASCON'97,
pages
M., Batory,
applications.
In Proc. of the h_tl Conf
and Kramer,
1998]
Ele-
An Architecture-Based
In Proc.
Acme:
of the 7th Working
An Architecture
Description
169-183.
D., and Perry,
D. E. (2002).
on Software
Patterns:
Longman.
S. V., and Lindquist,
and Integrating
Engineering,
Language.
Addison
G. C., Mudiam,
for Synthesizing
Conference [Garlan
Gannod,
Software.
Reuse
(LNCS
Integrating 2319),
and reusing
gui-
pages
1-16.
Springer-
pattern
based
approach
Verlag. [Jacobsen
to generating Engineering [Luckham
IEEE
[Medvidovic
a family
[Oellermann,
Jr., 2001]
[Richards, [Seely
1999]
and Sharkey,
Development [Semantic
Canada.
2001]
Seely,
Using XML.
Semantic
R. N. (1997).
American
Core Jini.
Architecture
Engineering,
Exploiting
Software
Definition
Lan-
Association 2001).
architectural
style to
144(5-6):237-248. T. E. (2002).
In Proc. of the AAAI-02
S. and Sharkey,
Prentice
An Event-Based
G. C., and Lindquist,
Jr., W. L. (October
W. K. (1999).
of the Automated
21 (9):717-734.
N. and Taylor,
integration.
Oellermann,
Web, 2002]
Engineering,
S. V., Gannod,
A design
In Proceedings
CS Press.
D. and Vera, J. (1995).
Component
Richards,
idl.
lEE Proc. in Software
Alberta,
B. J. (1998).
annotated
IEEE, IEEE
Medvidovic,
Mudiam,
Edmonton,
from
on Software
1997]
for Dynamic
Integration,
Luckham,
of applications,
et al., 2002]
Paradigm
H.-A. and Kramer,
adaptors
pages 63-72.
Transactions
and Taylor,
develop [Mudiam
Conference,
and Vera, 1995]
guage.
Jacobsen,
synchronization
A Novel
Workshop
for Artificial
Architect#zg
Service-Based
on Intelligent
Service
Intelligence.
Web Services.
a! Press.
Prentice-Hall.
K. (August
2001).
SOAP:
Cross
Platforn2
Web Services
Hail.
Web
(2002).
The
semantic
web.
[Online]
Available
http://www.w3.org/2001/sw/. [Shaw
and Garlan,
Emerging
1996]
Discipline.
[Sneed, 1996] Sneed, Working Conference
Shaw,
et al., 1997]
Web services:
Sullivan,
et al., 2002]
composing Integration,
Thakkara,
web services Edmonton,
beyond
K. J., Cockrell,
Programming of Engineering neering, pages 616-617. [Thakkara
D. (1996).
Software
Architectures:
Perspectives
on an
Hall.
H. M. (1996). Encapsulating legacy software for use in client/server on Reverse Engineering, pages 104-119. IEEE, IEEE CS Press.
[Stal, 2002] Stal, M. (2002). A CM, 45(10) :71-76. [Sullivan
M. and Garlan,
Prentice
Tools.
Alberta,
J., Zhang,
In Proceedings
S., Knoblock,
from on-line
component-based
Canada,
S., and Coppit,
of the bzternational
C. A., Ambite,
sources. pages
computing.
J.-L.,
1-7. American
26
Association
Communications
Package
Conference
on Software
Workshop
C. (2002).
Oriented Engi-
Dynamically
on Intelligent
for Artificial
In
of the
D. (1997).
and Shahabi,
In Proc. of the AAAI-02
systems.
Service
Intelligence.
