1. ©Kabira Technologies Inc, 2001 May 7-9, 2001 Westward Look Resort Tucson, Arizona SMUG 2001 Execution in UML

2. ©Kabira Technologies Inc, 2001 Michael M. Lee V.P of Application Engineering

3. ©Kabira Technologies Inc, 2001 Michael M. Lee V.P of Application Engineering Automated Bridging to Third Party Packages

4. ©Kabira Technologies Inc, 2001 Recursive Design 101 Requirements Implementations

5. ©Kabira Technologies Inc, 2001 Domains of Different Technologies Material Handling Process Alarm Handling Generic Equipment Handling Operator Interface Corba-Based Equipment Drivers Java-Based Plant Maintenance You need to use a 3rd party software package (a.k.a. COTS, legacy software, realized domain) as a service? You need to expose your system as a service to another system? But What Happens When Straightforward approach with homogeneous, OOA domains

6. ©Kabira Technologies Inc, 2001 Bridging to 3rd Party Packages Generic Equipment Handling Corba-Based Equipment Drivers The ability of the client domain to drive requirements on the service domain is limited. –totally limited if service is fixed –partially limited if it isn’t fixed The implementation mechanisms can be dictated by the service. –Corba, Java –execution paradigms (transactions, multi versus single threaded, synch/asynch)

7. ©Kabira Technologies Inc, 2001 The Question for Code Generation executable process standard compiler technology conventional compiler and linker object-oriented models Model Compiler Model Code System Software Architecture Run Time Implementation Platform Translation Rules Design Patterns Frameworks Translation Rules Design Patterns Frameworks Run Time Libraries Model Translator Source Compiler and linker source code Software Architecture Design Software Architecture Design Application Logic Application Logic ? 3rd Party Packages

8. ©Kabira Technologies Inc, 2001 Interfaces to 3rd Party Packages Language based API’s –Java –C++ –C–C Specification based API’s –Corba –DCOM Interfaces to 3rd party packages are typically defined in one of two basic ways:

9. ©Kabira Technologies Inc, 2001 One Approach Code Generation Interface Definition Model Based Wrapper Native Client Interface to Service Corba-Based Equipment Drivers Generic Equipment Handling Model Based Wrapper Native Client Interface to Service model based interface OOA model

10. ©Kabira Technologies Inc, 2001 Implications Corba-Based Equipment Drivers Generic Equipment Handling Model Based Wrapper Native Client Interface to Service The client deals directly with the level of abstraction presented by the 3rd party package. Good: nothing “between” package and client Bad: may be a conceptual gap between client and service Let’s look at some examples...

11. ©Kabira Technologies Inc, 2001 Corba Client Adapter (a.k.a. Bridge) Code Generation IDL Model Based Wrapper ORB Interface Logic Development Deployment Client “sees” CORBA service as if it were modeled in OOA

12. ©Kabira Technologies Inc, 2001 The Development Process Design Center IDL CCA Component Application model ObjectSwitch Node CCA Engine Client Application Engine Built from application model + CCA component Design Center “wrapping” CCA Component unpack/deploy Step 1. Create CCA Component by “wrapping” IDL Step 2. Use Component + your model to build engine Engine Component CORBA Server CORBA Server

13. ©Kabira Technologies Inc, 2001 Basic Operation Obtain stringified IOR ( strIOR ) Declare and create object of wrapped type, proxy object declare componentName::MyModule::MyInterface mi; create mi values (m_stringifiedIOR:strIOR); If the IDL contained user exceptions, the client can catch them in try…catch blocks. CCA Engine CORBA Server ORB ObjectSwitch Shared Memory

14. ©Kabira Technologies Inc, 2001 Java Client Adapter (a.k.a. Bridge) Development Code Generation Java client routines Model Based Wrapper Java Client Routines Java VM Deployment Client Engine JCA Engine Java application ObjectSwitch The client “sees” the Java service as if it were modeled in OOA.

15. ©Kabira Technologies Inc, 2001 Nothing New Here ©Kabira Technologies Inc, 2001 Basic Operation ObtainstringifiedIOR ( strIOR ) Declare and create object of wrapped type, proxy object declarecomponentName::MyModule::MyInterfacemi; create mi values (m_stringifiedIOR:strIOR); If the IDL contained user exceptions, the client can catch them in try…catch blocks. CCA Engine CORBA Server ORB ObjectSwitch Shared Memory proxy object mi proxy object mi The approach to Java is basically the same as Corba.

16. ©Kabira Technologies Inc, 2001 Another Exchange Standard: XML eXtended Markup Language Specifies structure and contents for a “document” ( DTD/Schema ) Does not specify communication protocol as Corba and Java do. Service Actication HTTP Service XML Service COVAD

17. ©Kabira Technologies Inc, 2001 XSA Adapter (a.k.a. Bridge) The client “sees” the XML document as if it were modeled in OOA. Deployment XSA Engine Protocol Engine ObjectSwitch Client Engine Development Code Generation XML Schema Model Based Wrapper 3rd Party DOM Service import/export documents of defined schema

18. ©Kabira Technologies Inc, 2001 XSA Service Component Each XML Schema you wrap results in a distinct XSA Service component The XSA Service component contains a hierarchy of entities and interfaces that facilitate conversion of data between XML and object attributes The key object in the generated object hierarchy is the “root” object Design Center XML Schema XSA Service component root entity -XMLString exportToXML() setXMLString()

19. ©Kabira Technologies Inc, 2001 The Development Process Design Center XML Schema XSA Service Component Client model ObjectSwitch Node XSA Service Engine XSA client Engine Built from Client model + XSA Service component Design Center “wrapping” XSA Service component unpack/deploy Step 1. Create XSA Component from XML schema Step 2. Use Component + your model to build engine XSA client component

20. ©Kabira Technologies Inc, 2001 Sending an XML Document XSA Engine Protocol Engine ObjectSwitch Client Engine The client engine creates the objects it needs for an XML document from the entities defined in the XSA Service Engine and assigns values as desired. The Client then calls the exportToXML() operation in the root object of the document. An XML string of the document is returned which is then sent out using the protocol engine.

21. ©Kabira Technologies Inc, 2001 Receiving an XML Document XSA Engine Protocol Engine ObjectSwitch Client Engine The client engine acquires an XML document (a string) using the protocol engine. A document root object is created. The setXMLString() operation of the root object of the document is invoked with the XML document as an input. The objects necessary to contain the information in the XML document are created and initialized.

22. ©Kabira Technologies Inc, 2001 One Approach Code Generation Interface Definition Model Based Wrapper Native Client Interface to Service Corba-Based Equipment Drivers Generic Equipment Handling Model Based Wrapper Native Client Interface to Service model based interface OOA model Wrapped non OOA functionality in OOA. Used code/model generation technology. Exposed an OOA interface to existing service functionality. Built up the domain chart as the technology (RD) dictates. Summary: Bridging to 3rd Party Software

23. ©Kabira Technologies Inc, 2001 Supplementary Slides

24. ©Kabira Technologies Inc, 2001 Extinsible CodeGen Architecture Plug In Service Model Repository Import/Export Model Auditor System Builder Model Compiler AL Interpreter Adapter-1 Adapter-N... DC Server DC GUI Client DC CMD Client Core Plug Ins Adapter Plug Ins Persistence Corba SNMP others... Basis for Extensible DC Services Register/List/Search Project Mgmt Property Mgmt Commands/Results Corba ORB Built with ObjectSwitch!