Introduction

 

This topic includes the following sections:

• Interoperability Among the CORBA, J2EE, and Tuxedo Programming Models

  This topic describes the interoperability and coexistence capabilities in the WebLogic Enterprise (WLE) T-Engine among the CORBA, J2EE, and Tuxedo programming models.

• Overview of the T-Engine Interoperability Sample Applications

  This topic describes the T-Engine interoperability sample applications provided with the WebLogic Enterprise software. The sample applications provide client and server programmers with information about the basic concepts of combining Enterprise JavaBeans (EJBs) and CORBA objects in the same WebLogic Enterprise application.

  Note: These examples specifically refer to interoperability within the T-Engine environment.

  Note: In WebLogic Enterprise 5.1, interoperability between the J-Engine and T-Engine is available in only one direction-from the J-Engine to the T-Engine. The product does not support calling the J-Engine from the T-Engine.

 

---

Interoperability Among the CORBA, J2EE, and Tuxedo Programming Models

The key interoperability features are presented in the following categories:

• T-Engine Server Interoperability

• T-Engine Client and Server Interoperability

• J-Engine and T-Engine Interoperability

• Third-party ORB Interoperability

• T-Engine Interdomain Interoperability

• WebLogic Enterprise and Tuxedo Domains Interoperability

First, a summary description of BEA clients, servers, the T-Engine, and the J-Engine follows.

BEA Clients and Servers

Note the following definitions:

• BEA client

  A BEA client can be any of the following entities, which exist outside the BEA domain and must use a listener/handler as a gateway to the domain:

  • Jolt® client application (via the Jolt listener/handler)

  • Tuxedo /WS client application (via the Tuxedo /WS listener/handler)

  • WebLogic Enterprise CORBA client application (via the IIOP listener/handler)

  • ActiveX client application (via the IIOP listener/handler)

  • T-Enging RMI client application (via the IIOP listener/handler)

    Note that BEA clients invoking other BEA clients is not supported.

• BEA server

  A BEA server can fall into one of two general categories:

  • Tuxedo engine, or T-Engine, servers. T-Engine servers include Tuxedo services, CORBA objects, and EJBs that run on the Tuxedo-based WebLogic Enterprise infrastructure. These servers run within the administrative unit of a WebLogic Enterprise domain, and are configured via a UBBCONFIG file.

  • Java engine, or J-Engine servers. J-Engine servers include EJBs, Servlets, and Java Server Pages (JSPs) that run on the WebLogic Server-based infrastructure.

T-Engine Server Interoperability

This section describes the interoperability among the following T-Engine server components:

• Tuxedo service

• CORBA C++ object

• CORBA Java object

• Enterprise JavaBean

Figure 1-1 shows the direct interoperability support among the various T-Engine server applications. The numbered callouts in the figure are explained in the text that follows the figure. In this figure, the solid black arrows show the direct invocation paths that are supported. The dotted arrows show indirect invocation paths that are supported; for example, a Tuxedo service can invoke a CORBA Java object using either a CORBA C++ proxy object, or a C++ client stub file compiled from the OMG IDL for that Java object.

Figure 1-1 T-Engine Server Interoperability

Note the following details about the preceding figure:

1. CORBA Java object or T-Engine Enterprise JavaBean invoking a Tuxedo service

   WebLogic Enterprise provides the Java Enterprise Tuxedo (JET) API that you can use to have either a CORBA Java object or a T-Engine EJB invoke a Tuxedo service running in the WebLogic Enterprise domain. An example of a CORBA Java object invoking a Tuxedo service using JET is described in CORBA/Java-to-Tuxedo Simpapp Sample Application, and an example of an EJB application invoking a Tuxedo service using JET is described in EJB-to-Tuxedo Simpapp Sample Application. (Note that RMI server applications can also run in the WebLogic Enterprise T-Engine domain, and they can also use JET to invoke Tuxedo services in that domain.)

   For considerations about using the JET software, see Java Enterprise Tuxedo (JET) Software.

2. Tuxedo service invoking a CORBA C++ object and vice versa

   A C++ object can include ATMI calls to Tuxedo services. See the Wrapper University sample application, available from the Guide to the University Sample Applications, for an example application that shows this feature.

   A Tuxedo service can invoke a CORBA C++ object using the compiled C++ client stub file for that object. (One way to do this is to implement the Tuxedo service as a C-callable C++ function that invokes the client stub file for the C++ object. If you use this approach, note that you need to link in the C++ ORB libraries when you build the Tuxedo service.)

3. CORBA C++ object invoking a CORBA Java object and vice versa

   CORBA C++ and CORBA Java objects that run in the same WebLogic Enterprise domain can invoke each other directly. For information about invoking across WebLogic Enterprise domains, see the section T-Engine Interdomain Interoperability.

4. CORBA Java object invoking a T-Engine EJB and vice versa

   In the WebLogic Enterprise environment, a CORBA Java object can invoke methods on a T-Engine EJB directly. See CORBA/C++-to-T-Engine EJB Simpapp Sample Application, for an example application that includes a CORBA Java object that invokes an EJB.

5. Tuxedo service invoking a CORBA Java object

   A Tuxedo service can invoke a CORBA Java object by compiling the Java object's OMG IDL file with the idl command, which produces a C++ client stub file that the Tuxedo service can invoke, using an approach similar to the one described in point 2.

6. T-Engine EJB invoking a CORBA C++ object and vice versa

   T-Engine EJB-to-CORBA/Java Simpapp Sample Application, shows an example of an EJB invoking a CORBA Java object. You can extend this example to include a CORBA C++ object by designing the Java object in that application to serve as an intermediary, or wrapper, object that delegates invocations from the EJB to the C++ object, and vice versa. An alternative means for having an EJB invoke a C++ object is to compile the OMG IDL file for the C++ object using the m3idltojava command, which produces a Java client stub file that the EJB can invoke directly.

Java Enterprise Tuxedo (JET) Software

The WebLogic Enterprise software includes the JET API, which allows T-Engine Java entities -- namely, EJBs and CORBA Java objects -- to make ATMI calls on Tuxedo services that exist in either the same WebLogic Enterprise domain or in a separate WebLogic Enterprise domain. JET is a server-side adaptation of BEA Jolt. JET shares some of its software components with Jolt, including the Repository Editor and the bulk loader. To take full advantage of all the capabilities of JET, you need to install the Jolt software, which is included with the WebLogic Enterprise software.

For more information about JET, see Using Java Enterprise Tuxedo (JET). For more information about installing Jolt, see the Jolt Installation Guide, which is included in the WebLogic Enterprise package.

Note: JET cannot be used by Java clients to invoke Tuxedo services; this capability is provided by BEA Jolt, which is summarized in Transactions and Security Within the T-Engine Environment.

Transactions and Security

Transaction and security context propagation among BEA server applications running in a WebLogic Enterprise domain is fully supported.

T-Engine Client and Server Interoperability

Figure 1-2 shows the interoperability support among BEA clients invoking BEA servers.

Figure 1-2 T-Engine Client and Server Interoperability

Note the following details in the preceding figure:

1. Jolt client application invoking a Tuxedo service

   A Jolt client can invoke a Tuxedo service running in the WebLogic Enterprise domain via a Jolt listener/handler. For more information about Jolt, see the BEA Jolt online documentation.

2. Tuxedo /WS client application invoking a Tuxedo service

   A Tuxedo /WS client application can invoke a Tuxedo service running in the WebLogic Enterprise domain via the Workstation listener/handler.

3. BEA CORBA C++ client application invoking a CORBA object

   A BEA CORBA C++ client application can invoke both CORBA C++ and Java objects running in a WebLogic Enterprise domain via the IIOP listener/handler. For more information, see Creating CORBA Client Applications.

4. BEA CORBA Java client application invoking a CORBA server-side object

   A BEA CORBA Java client application can invoke both CORBA C++ and Java objects running in a WebLogic Enterprise domain via the IIOP listener/handler. For more information, see Creating CORBA Client Applications.

5. BEA ActiveX client application invoking a CORBA server-side object

   A BEA ActiveX client application can invoke both CORBA C++ and Java objects running in a WebLogic Enterprise domain via the IIOP listener/handler. For more information, see Creating CORBA Client Applications.

6. T-Engine RMI client application invoking an T-Engine Enterprise JavaBean

   An RMI client application can invoke an Enterprise JavaBean running in the WebLogic Enterprise domain via the IIOP listener/handler using the WebLogic RMI-on-IIOP protocol. For more information, see Using RMI in a WebLogic Enterprise Environment. (Note that an RMI client can also invoke an RMI server running in a WebLogic Enterprise domain.)

The following additional invocation paths are also supported in the WebLogic Enterprise T-Engine environment via proxy objects or servers:

• BEA CORBA C++ client application invoking a Tuxedo service

  You can create a C++ client with a set of operations that map one-to-one with calls to Tuxedo services using an intermediary C++ server-side object. See the Wrapper University sample application for an example application that shows this feature, available in the Guide to the University Sample Applications.

• WebLogic Enterprise T-Engine RMI client application invoking a CORBA C++ object

  A WebLogic Enterprise T-Engine RMI client application can invoke a CORBA C++ object by using a T-Engine EJB and a CORBA Java object in the server process as intermediaries. For an example, you can extend the sample application described in T-Engine EJB-to-CORBA/Java Simpapp Sample Application, as follows:

  • The T-Engine RMI client application invokes the EJB to initiate the request.

  • The CORBA Java object, which is invoked by the EJB, delegates the invocation to the C++ object.

• WebLogic Enterprise T-Engine RMI client application invoking a CORBA Java object

  A WebLogic Enterprise T-Engine RMI client application can invoke a CORBA Java object by using a T-Engine EJB as an intermediary. For an example, you can extend the sample application described in T-Engine EJB-to-CORBA/Java Simpapp Sample Application, to have the RMI client application initiate the request instead of the EJB.

• Tuxedo/WS client application invoking a CORBA C++ object

  Interoperability is provided via a Tuxedo service wrapper. You create a Tuxedo service wrapper as a CORBA C++ object that runs in the WebLogic Enterprise domain and that makes invocations on the legacy CORBA C++ object.

• Tuxedo/WS client application invoking a CORBA Java object

  Interoperability is provided via a Tuxedo service wrapper.

• Tuxedo/WS client application invoking a T-Engine EJB

  Interoperability is provided via a Tuxedo service wrapper on a CORBA Java object in the server process, which then delegates the invocation to the EJB.

Transactions and Security Within the T-Engine Environment

Transaction and security context propagation between T-Engine client and server applications is fully supported, with the following restrictions:

• T-Engine client applications can demarcate a transaction -- that is, they can explicitly begin, suspend, resume, and commit a transaction -- but they cannot participate in a transaction.

  For example, a client can begin a transaction and make multiple invocations on services and objects within the domain, and those services and objects can in turn make invocations on yet other services and objects. However, the client application cannot, within the scope of that transaction, perform operations locally and have them included in that transaction. That is, if the client application starts a transaction, invokes an object within the domain, then writes data to a database local to the client, the local database operation cannot not be included in the transaction.

• When a T-Engine client application authenticates itself to the domain, and invokes various services and objects in the domain -- which in turn may invoke other services and objects in the domain -- the client's security context is passed along with each operation. However, if in the course of satisfying a client request, a service in one domain makes an invocation on a service in a second domain, the client's security context cannot be passed to the second domain. The service in the second domain does not have knowledge of the original client.

A Note About BEA Jolt

BEA Jolt provides a means for allowing Java clients to make ATMI calls on Tuxedo services that exists in a Tuxedo or WebLogic Enterprise domain. Jolt also provides a means for allowing J-Engine servers to invoke T-Engine Tuxedo services . This latter capability is performed via Jolt connection pools, which is shown in J-Engine and T-Engine Interoperability. BEA provides Jolt with the WebLogic Enterprise software.

For more information, see the following documents:

• For more information about Jolt, see the BEA Jolt version 1.2 online documentation.

• For more information about setting up Jolt connection pools to connect J-Engine servers to T-Engine Tuxedo services, see Using WebLogic Enterprise Connectivity.

T-Engine RMI Clients and the WebLogic RMI-on-IIOP Protocol

RMI clients of EJBs running in a T-Engine domain must use the WebLogic RMI-on-IIOP protocol. This is a proprietary protocol and is different from the RMI-over-IIOP protocol, which is used by clients of the BEA WebLogic Server^TM system.

For more information about the WebLogic RMI-on-IIOP protocol, see Using RMI in a WebLogic Enterprise Environment.

J-Engine and T-Engine Interoperability

The WebLogic Enterprise domain can comprise both T-Engine and J-Engine components. As of WebLogic Enterprise 5.1, this connectivity is available in only one direction-from the J-Engine to the T-Engine.

Figure 1-3 shows how IIOP and Jolt connection pools allow components hosted by the J-Engine can invoke objects and services hosted by a T-Engine running in the same WebLogic Enterprise domain.

Figure 1-3 J-Engine and T-Engine Interoperability

Note the following about these connection pools:

• IIOP connection pools allow J-Engine applications to invoke T-Engine EJBs and CORBA objects in a WebLogic Enterprise domain. For information about setting up and using IIOP connection pools, see Using WebLogic Connectivity.

• Jolt connection pools allow J-Engine applications to invoke Tuxedo services in a WebLogic Enterprise domain. For information about setting up and using Jolt connection pools, see Configuring Jolt for WebLogic.

For details about the versions of J-Engine and T-Engine server components that can interoperate, see the Release Notes.

Third-party ORB Interoperability

CORBA applications based on third-party ORBs can interoperate with CORBA, Tuxedo, and J2EE server applications running in a WebLogic Enterprise T-Engine domain provided that there is a correct match-up between IIOP protocols. Figure 1-4 provides a high-level view of third-party ORB interoperability with WebLogic Enterprise.

Figure 1-4 Third-party ORB Interoperability

Note the following regarding third-party ORB interoperability with WebLogic Enterprise:

• The WebLogic Enterprise C++ ORB supports the IIOP 1.2 protocol, and the WebLogic Enterprise T-Engine Java ORB supports the IIOP 1.0 protocol. Both ORBs interoperate with client products from other vendors that support the IIOP 1.2, or earlier, protocol.

• The WebLogic Enterprise T-Engine provides transactional and security support for the following third-party client products. However, BEA does not provide environmental objects for these clients, so these products cannot directly access transactional and security capabilities inside the WebLogic Enterprise domain. These client products can connect to a WebLogic Enterprise server application using a stringified object reference.

  • ActiveX

  • Netscape Communicator

  • Visibroker C++ version 3.3 (not clients using the Visibroker Java ORB)

  • Orbix 2.3c02 (with patch 26 or greater)

• CORBA applications that use a third-party ORB cannot initiate or coordinate a transaction propagated to the WebLogic Enterprise T-Engine. These applications can invoke transactional objects running in the WebLogic Enterprise T-Engine, and the WebLogic Enterprise transaction coordinator can manage those transactions; however, all the transactional management is fully delegated to the WebLogic Enterprise T-Engine.

• If the CORBA application using the third-party ORB supports the Secure Sockets Layer (SSL), that application can use SSL mutual authentication as an alternative mechanism for authentication to the T-Engine.

• The T-Engine can call out to applications using third-party ORBs, using whatever callback mechanism is supported by the third-party ORB.

• WebLogic Enterprise client ORBs can interoperate with third-party ORBs (including SSL support).

• The WebLogic Enterprise J-Engine supports RMI over IIOP; therefore, J-Engine server applications can interoperate with third-party ORBs and other J2EE application servers that support the RMI over IIOP protocol. For information about restrictions or limitations on this interoperability, see the Release Notes.

T-Engine Interdomain Interoperability

A server application running in one WebLogic Enterprise domain can interoperate with a server application running in another WebLogic Enterprise domain via the domain gateway (and not IIOP), as shown in Figure 1-5.

Figure 1-5 T-Engine Interdomain Interoperability

Domain gateways provide the following interoperability features:

• Domains can be heterogeneous with respect to the WebLogic Enterprise version. That is, a given WebLogic Enterprise can run both version 4.x and version 5.x WebLogic Enterprise applications; and those applications can invoke operations on either WebLogic Enterprise version 4.x or version 5.x applications running in a separate domain.

• Domain gateways fully support transaction propagation across domains. For example, a transactional object in one WebLogic Enterprise domain can include an object running in another domain in that transaction.

• Security context propagation is fully supported across domains for CORBA and EJB applications. (Interdomain security context propagation that span Tuxedo services running in WebLogic Enterprise domains is not supported.) However, note the following restriction:

  When a client application authenticates itself to the domain, and invokes various services and objects in the domain -- which in turn may invoke other services and objects in the domain -- the client's security context is passed along with each operation. However, if in the course of satisfying a client request, a service in one domain makes an invocation on a service in a second domain, the client's security context cannot be passed to the second domain. The service in the second domain does not have knowledge of the original client.

• You can secure all domain gateway communications with Link-Level Encryption (LLE).

• You can advertise factory objects and EJB home interfaces across domains.

For more information about interdomain WebLogic Enterprise interoperability, see Administration in the WebLogic Enterprise online documentation.

WebLogic Enterprise and Tuxedo Domains Interoperability

WebLogic Enterprise and Tuxedo domains can interoperate via domain gateways, as shown in Figure 1-6.

Figure 1-6 WebLogic Enterprise and Tuxedo Domains Interoperability

Note the following about WebLogic Enterprise and Tuxedo interdomain interoperability:

• Transactions and security contexts can be fully propagated between WebLogic Enterprise and Tuxedo domains.

• Domain mixing is still not supported; that is, you cannot combine a WebLogic Enterprise domain and a Tuxedo domain into a single domain.

For more information about WebLogic Enterprise and Tuxedo domains interoperability, see Administration in the WebLogic Enterprise online documentation.

 

---

Overview of the T-Engine Interoperability Sample Applications

The WebLogic Enterprise software includes the sample applications as described in Table 1-1.

Table 1-1 The Interoperability Sample Applications

Application	Description
T-Engine EJB-to-CORBA/Java Simpapp	Shows an EJB server acting as a client invoking a request and receiving a response from a CORBA/Java object.
CORBA/C++-to-T-Engine EJB Simpapp	Shows CORBA/C++ client invoking a request and receiving a response from an EJB server.
CORBA/Java-to-Tuxedo	Shows a CORBA/Java object that invokes a Tuxedo service using the Java Enterprise Tuxedo (JET) API.
T-Engine EJB-to-Tuxedo	Shows an Enterprise JavaBean application that invokes a Tuxedo service using the Java Enterprise Tuxedo (JET) API.

Use the interoperability sample applications in conjunction with the following documents:

• Getting Started

• Guide to the University Sample Applications

• Guide to the Java Sample Applications