Upload
debra-mckenzie
View
236
Download
0
Embed Size (px)
Citation preview
INTEROP-1.1
CSE298
CSE300
CSE333
Interoperability Strategies for Enterprise Computing
Prof. Steven A. Demurjian
Computer Science & Engineering DepartmentThe University of Connecticut
191 Auditorium Road, Box U-155Storrs, CT 06269-3155
[email protected]://www.engr.uconn.edu/
~steve(860) 486 - 4818
INTEROP-1.2
CSE298
CSE300
CSE333
Interoperability StrategiesInteroperability Strategies
Architectural Alternatives and FrameworksArchitectural Alternatives and Frameworks Taxonomy of Architectural Variants Integration via Java, CORBA, etc.
Case Study: The ADAM EnvironmentCase Study: The ADAM Environment Upgrading a C++ Legacy Application to be
Java-Compatible The TwinPeaks Software Package Pros and Cons of Effort
Issues for InteroperabilityIssues for Interoperability Concluding Remarks and DiscussionConcluding Remarks and Discussion
INTEROP-1.3
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
Reviewing Architectural VariantsReviewing Architectural Variants Java Client to Legacy Appl. via RDBS ORB Integration of Java Client and Legacy
Application Java Client with Wrapper to Legacy Appl. One COTS and One Legacy Appl. to Java
Clients Quick Review of Select Material from Summer Quick Review of Select Material from Summer
1997 White Paper:1997 White Paper: “The Java Programming Language: Impact upon
the Army Technical Architecture (ATA) and Joint Technical Architecture (JTC)” Demurjian/Shin
INTEROP-1.4
CSE298
CSE300
CSE333
Java Client to Legacy App via RDBSJava Client to Legacy App via RDBS
Java ClientJava Client
LegacyLegacyApplicationApplication
Relational Relational DatabaseDatabase
System(RDS)System(RDS)
Transformed Transformed Legacy DataLegacy Data
Updated DataUpdated Data
Extract and Extract and Generate DataGenerate Data
Transform andTransform andStore DataStore Data
INTEROP-1.5
CSE298
CSE300
CSE333
ORB Integration of Java ClientORB Integration of Java Clientand Legacy Applicationand Legacy Application
Java ClientJava ClientLegacyLegacy
ApplicationApplication
JavaJavaWrapperWrapper
Object Request Broker (ORB)Object Request Broker (ORB)
CORBA is the Medium of Info. Exchange
Requires Java/CORBA Capabilities
INTEROP-1.6
CSE298
CSE300
CSE333
Java Client with Wrapper Java Client with Wrapper to Legacy Applicationto Legacy Application
LegacyLegacyApplicationApplication
NetworkNetwork
Java ClientJava Client
Java Application CodeJava Application Code
WRAPPERWRAPPER
Mapping ClassesMapping Classes
JAVA LAYERJAVA LAYER
NATIVE LAYERNATIVE LAYER
Native Functions (C++)Native Functions (C++)RPC Client Stubs (C)RPC Client Stubs (C)
Interactions Between Java ClientInteractions Between Java Clientand Legacy Appl. via C and RPCand Legacy Appl. via C and RPC
C is the Medium of Info. ExchangeC is the Medium of Info. Exchange
Java Client with C++/C WrapperJava Client with C++/C Wrapper
INTEROP-1.7
CSE298
CSE300
CSE333
One COTS and One Legacy One COTS and One Legacy Application to Java ClientsApplication to Java Clients
NetworkNetwork
Java Application CodeJava Application Code
JAVA NETWORK WRAPPERJAVA NETWORK WRAPPER
Mapping ClassesMapping Classes
NATIVE LAYERNATIVE LAYER
JAVA LAYERJAVA LAYER
Native Functions that Native Functions that Map to COTS ApplMap to COTS Appl
Java ClientJava Client Java ClientJava Client
Java Application CodeJava Application Code
JAVA NETWORK WRAPPERJAVA NETWORK WRAPPER
Mapping ClassesMapping Classes
NATIVE LAYERNATIVE LAYER
JAVA LAYERJAVA LAYER
Native Functions that Native Functions that Map to Legacy ApplMap to Legacy Appl
COTS ApplicationCOTS Application Legacy ApplicationLegacy Application
Java is Medium of Info. Exchange - C/C++ Appls with Java Wrappers
INTEROP-1.8
CSE298
CSE300
CSE333
ADAM: User PerspectiveADAM: User Perspective
ServerAbstraction for Design Persistence
C++Ada83, Ada95EiffelJava (on PC/NT)Ascii/Latex Doc.
Ontos OODBS
Multiple Versions: ADAM/Unix: IV3.1, X, Sparcstation ADAM/PC: Win95, Borland C++ ADAM/NT: Under Development
Code/Documentation Generation
ADAM GraphicalUser Interface
OODesign
INTEROP-1.9
CSE298
CSE300
CSE333
Case Study: The ADAM EnvironmentCase Study: The ADAM Environment
ADAM is a C++ Legacy Application with: ADAM is a C++ Legacy Application with: GUI Interviews/Unidraw Core C++ Internal Classes which are Compiler
Independent Designs Stored in Ontos OODBS
Redesign/Reformulate ADAM as:Redesign/Reformulate ADAM as: Java Client that Replaces C++ GUI Java Server Wraps Core C++ Internal Classes C/S Communications via Java Designs Stored in Jasmine (1998 Task)
Similar to Providing C/S Interactions for an C++ Similar to Providing C/S Interactions for an C++ Legacy/COTS ApplicationLegacy/COTS Application
INTEROP-1.10
CSE298
CSE300
CSE333
Characterizing ADAM Software ProfileCharacterizing ADAM Software Profile
C++ Class Library - Intended as a Single-CPU, C++ Class Library - Intended as a Single-CPU, Single-User, Interactive Design EnvironmentSingle-User, Interactive Design Environment
C++ Classes Structured as Multiple Interacting C++ Classes Structured as Multiple Interacting Hierarchies for Different Components:Hierarchies for Different Components: C++ Classes for GUI C++ Classes to Store Design as it is Created C++ Classes for Code Generation Capabilities C++/Ontos Classes for Persistence
Source Code Level Access to ADAM SoftwareSource Code Level Access to ADAM Software Goal: Minimize Code-Level Modifications as Goal: Minimize Code-Level Modifications as
ADAM Moves to Java Client/Server ParadigmADAM Moves to Java Client/Server Paradigm
INTEROP-1.11
CSE298
CSE300
CSE333
ADAM: Current Software ArchitectureADAM: Current Software Architecture
C++ Classes/Instancesto Store Design and
Code GenerationAlgorithms
DB ServerAbstraction for Design Persistence
C++Ontos C++Ada83, Ada95EiffelJava (on PC)
Ontos OODBS
ADAM/Unix: IV3.1, X, SparcstationADAM/PC: Win95, Borland C++
Design/GenerationCompiler Independent Software
ADAM GraphicalUser Interface
OODesign
INTEROP-1.12
CSE298
CSE300
CSE333
Client Requirements and FunctionalitiesClient Requirements and Functionalities
New ADAM Java Client Replicates Core C++ New ADAM Java Client Replicates Core C++ Classes to Allow Transitory Storage of Designs: Classes to Allow Transitory Storage of Designs: Existing Designs from Legacy Server Storable
at ADAM Java Client New/Existing Designs at Java Client Locally
Manipulated to Reduce Communication Traffic New/Existing Designs Sent to Legacy Server
for Persistent Storage Java Communications from Client to ServerJava Communications from Client to Server
Transmission of Modified Design to Server Receipt of Existing Design from Server Both Accomplished via Object Serialization
INTEROP-1.13
CSE298
CSE300
CSE333
Client Requirements and FunctionalitiesClient Requirements and Functionalities
ADAM C++Legacy Application
(Server)
Java/TwinPeaksWrapper
Existing Designs Sent/Loaded for Local Manipulation
Completed New Designs orRevised Existing Designs
Sent for Persistent Storage
New ADAM JavaUser Interface
(Client)
OODesign
Designs atClient toReduce
CommunicationOverhead
INTEROP-1.14
CSE298
CSE300
CSE333
ADAM: Target Software ArchitectureADAM: Target Software Architecture
Java Communications (Object Serialization/Sockets)
New ADAM JavaUser Interface
(Client)
OODesign
Java/TwinPeaksWrapper
ADAM C++Legacy Application
(Server)
Java: Communication and Interpretation
C++: Common Interfaceto Access Server Classes
Modified Design to Server
Existing Design from Server
INTEROP-1.15
CSE298
CSE300
CSE333
Wrapper Requirements and FunctionalitiesWrapper Requirements and Functionalities
Transmission/Receipt of Messages from ClientsTransmission/Receipt of Messages from Clients Existing Design from Server to ClientExisting Design from Server to Client
Locating C++ Instances in Legacy Server Creation of Java Instances from C++ Instances Object Serialization of Java Instances to Client
Store New/Existing Design from Client to ServerStore New/Existing Design from Client to Server Receipt of Java Instances via O-Serialization Creation of C++ Instances from Java Instances Storage of C++ Instances into Legacy Server
Interactions between Java and C++ via Java Native Interactions between Java and C++ via Java Native Interface (JNI) or TwinPeaksInterface (JNI) or TwinPeaks
INTEROP-1.16
CSE298
CSE300
CSE333
ADAM: Client/Wrapper ComponentsADAM: Client/Wrapper Components
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
Java
Des
ign
Cla
sses
/In
stan
ces Java D
esign C
lasses/Instan
ces
Java
Com
mu
nic
atio
nC
lass
es/I
nst
ance
sJava C
omm
un
icationC
lasses/Instan
ces
Java Client
GUIClasses
and Instances
Java Wrapper
TranslationJava to C++
LegacyCode
AdamC++
Server
May Not BeNeeded
Depends on Comm. Protocol
INTEROP-1.17
CSE298
CSE300
CSE333
ADAM: Java to C++ WrapperADAM: Java to C++ Wrapper
Com
mu
nic
atio
n
Java Design Classes
and Instances
Tra
nsl
atio
nJa
va t
o C
++
Lib
rary
Fol
der C
lass Fold
er
C+
+ C
omm
on In
terfaceADAM
C++ Legacy Classes
and Instances
TwinPeaks
Legacy Application Wrapper
INTEROP-1.18
CSE298
CSE300
CSE333
Communication Requirements and Communication Requirements and FunctionalitiesFunctionalities
Layers of Classes/Instances (Client vs. Server)Layers of Classes/Instances (Client vs. Server) Interface (GUI) Classes and Instances (C) Java Design Classes and Instances (C&S) Java Communication Classes and Instances
(C&S) Translation Java to C++ Classes and Instances
(S) Communications Communications
Sockets (Current) Object Serialization (Current) CORBA/ORBs vs. RMI (Future)
INTEROP-1.19
CSE298
CSE300
CSE333
ADAM: Socket CommunicationsADAM: Socket Communications
Potential Performance Issue: Multiple Layers of Translation
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
Java
Com
mu
nic
atio
nC
lass
es/I
nst
ance
sJava C
omm
un
icationC
lasses/Instan
ces
Java
Des
ign
Cla
sses
/In
stan
ces
Java Client
GUIClasses
and Instances
Java Design
Classes/In
stances
Java Wrapper
TranslationJava to C++
LegacyCode
AdamC++
Server
INTEROP-1.20
CSE298
CSE300
CSE333
TwinPeaks Requirements and TwinPeaks Requirements and FunctionalitiesFunctionalities
Evaluated Feasibility of JNI Evaluated Feasibility of JNI Directly Access Native Layer Eliminates Platform Independence Difficult to Understand and Use
Exploring TwinPeaks ProductExploring TwinPeaks Product Beta Product from Sun Automatically Generates Java Interface to C or
C++ Native Library Analyzes Native Library Header Files to
Produce a Java API that Closely Mirrors Original C/C++ API
Generates Platform Specific Native Code
INTEROP-1.21
CSE298
CSE300
CSE333
ADAM: TwinPeaks ArchitectureADAM: TwinPeaks Architecture
Java Application
C++ DLL
Java/C++Bridge
Lib. Folder
GE
NE
RA
TE
GE
NE
RA
TE
C++Application
C++ HeaderFiles (.h)
C++ Implemen.Files (.c)
INPUT
Java InterfaceClass Folder(.java/.class)
Tw
inP
eak
s
INTEROP-1.22
CSE298
CSE300
CSE333
Status of TwinPeaks EffortStatus of TwinPeaks Effort
Established TwinPeaks EnvironmentEstablished TwinPeaks Environment Downloaded Multiple Times due to Difficulty
in Setting up Software and Multiple Releases by SunSoft
Worked to Understand the Mechanism and Proper steps Needed to work with TwinPeaks
UConn Beta Testing Site of Product: UConn Beta Testing Site of Product: Initial Efforts in Sept and Oct 97 Provided
Feedback and Suggestions to SunSoft Many of Suggestions for Improvement
Reflected in the Second Release
INTEROP-1.23
CSE298
CSE300
CSE333
Status of TwinPeaks EffortStatus of TwinPeaks Effort
As of January 15, 1998As of January 15, 1998 Installed Newest TwinPeaks Release Developed Two Test Prototypes that Generates
the Java to C++ Mapping for Subset of the ADAM C++ Server Legacy Code
Written a Detailed Report Describing this Effort Written a Detailed Report Describing this Effort that will be Critical in Continuing this Workthat will be Critical in Continuing this Work
The Java/C++ Interface is Pivotal for Integrating The Java/C++ Interface is Pivotal for Integrating and Upgrading Legacy Software to Java and Upgrading Legacy Software to Java
INTEROP-1.24
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
PROsPROs To Our Knowledge, the Only Available Tool
that Supports Java to C/C++ at High Abstract. Automates Tedious/Error Prone Process an of
Generating Peer Java classes for C++ Code Offers Clever Techniques to Solve Mismatch
Between Java and C/C++ Pointers Multiple Inheritance Operator Overloading
Cost - Currently TwinPeaks is Free!
INTEROP-1.25
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
CONSCONS Supports Very Limited Platform
Solais and SunSoft C++ What about Windows 95, NT, and Linux Apps?
Based on Native Method Specification and not Up-to-Date JNI
Potential for Incompatibility and/or Abandonment in Future
Automatic, but Difficult to Use Very Limited Support/Documentation
Minimal Small User Community
INTEROP-1.26
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
CONsCONs Requires Familiarity with SunSoft C++ and Java
Native Method No Debugging Facilities Makes Understanding
and Correcting Errors Difficult Generics, Unions, and other C/C++ Features not
Supported No support for calling Java from C++
Conclusion: Conclusion: TwinPeaks is not a Stable Tool Falls Short of our Expectations Acceptance/Adoption for EC Applications is
Premature!!
INTEROP-1.27
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Ability to Pull-Off or Disable Legacy GUI
Needed to Support Wrapping Process May Not be Possible for Every Legacy/COTS
application Source-Code Availability or Robust
Programming Interface Alternative to Disable A Robust OO API Assist Wrapper Creation and
Java to C++ Interactions
INTEROP-1.28
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Development of a New Java GUI/Client
New GUI to Collect, Synthesize, Interpret Information from Multiple Legacy/COTS
New/Innovative Uses for Legacy/COTS Applications
Short-Term Persistence of Client Data Thin vs. Medium vs. Thick Clients For EC Applications, if Clients Leave Network,
Local Storage is Needed Must Also Consider Limited Bandwidth
INTEROP-1.29
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Message Passing Interface to Legacy Appl.
If Not Present, Embed in Communications Layer of both Client and Wrapper
For EC Applications, Extra Layers May be Required to Transform Legacy Data to OO/Java
Integration of Java and C++ Java Wrapper Requires Bi-Directional Exchange
of Information to/from C++ Automated Tools (TwinPeaks) vs. JNI For EC Applications - C, C++, Ada, Fortran, etc.
INTEROP-1.30
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
Integration of Java and C++Integration of Java and C++ Occurs within the Java Wrapper to C++ Server Requires Ability to Encompass and Build C++
Server as Shared Library Shared Library Interacts with TwinPeaks Bi-Directional Translation (Java to/from C++) May Require a New C++ Library for a
Uniform Interface to Server C++ Classes Maintains Multiple Layers of Same
Information in Different Formats Applicability to C Legacy ApplicationsApplicability to C Legacy Applications
Techniques Extensible to C Providing that Workable Native C++ Library Available
INTEROP-1.31
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
Utilization of our Efforts on ADAM as BlueprintUtilization of our Efforts on ADAM as Blueprint C++ Legacy Application (with/out GUI) Source Code Availability/Programming Interf. New Java Client Appls/Java Server Wrapper Message Passing Interface Redesign/Development of Java Client Classes
that Mirror/Imitate Legacy Server Classes Introduction of Multiple Layers of Translation Increased Overhead with Java or CORBA Applicability to Well-Designed C Appls
Conclusion: Significant Effort with Potential Conclusion: Significant Effort with Potential Long-Range Benefit of Common Java MediumLong-Range Benefit of Common Java Medium
INTEROP-1.32
CSE298
CSE300
CSE333
Architectural Alternatives & FrameworkArchitectural Alternatives & Framework
PROsPROs Likely Applicable to C and C++ Component-Based, Organized Approach Greatly Facilitates Exchange of Information Solves the N x M Translation Problem
CONsCONs Additional Overhead Due to Translations Instability/Immaturity of TwinPeaks Complexity and Effort of Task Performance Degradation Unacceptable
Conclusion: Do Java, CORBA, etc., Benefits Conclusion: Do Java, CORBA, etc., Benefits Outweigh the Risks and Shortfalls?Outweigh the Risks and Shortfalls?
INTEROP-1.33
CSE298
CSE300
CSE333
Concluding Remarks and DiscussionConcluding Remarks and Discussion
What are Keys Issues that Influence and Guide the What are Keys Issues that Influence and Guide the Integration Process for EC?Integration Process for EC? Software Reuse in a Distributed Computing
Environment Reuse Existing Legacy/COTS in Innovative Ways Not Cost Effective to Redesign/Reimplement EC Users will Demand Modern Interfaces on Up-
to-Date Platforms Wrappers for Cohesive/Seamless Interactions
Apply to Languages (C, C++, Ada, etc.) and Paradigms (OODBS, CORBA, RPC)
Address Communication, Translation, Security, Concurrency, Performance, Bandwidth, etc.
INTEROP-1.34
CSE298
CSE300
CSE333
Concluding Remarks and DiscussionConcluding Remarks and Discussion
What are Keys Issues that Influence and Guide the What are Keys Issues that Influence and Guide the Integration Process for EC?Integration Process for EC? Communications Alternatives Dictated by
Application Domain Tradeoffs of Low-Level (Sockets) vs. Mid-Level
(RCP, RMI) vs. High-Level (CORBA, DCOM, …) Will EC Utilize Combination?
Consistency of Information in Distributed Computing Environment When is Data Sent from Client to Legacy Server? Automatic (Regular) vs. User-Initiated? When Network Traffic is Low? EC Likely Spans Broad Spectrum