Getting Started with Oracle Tuxedo CORBA Applications

     Previous  Next    Open TOC in new window  Open Index in new window  View as PDF - New Window  Get Adobe Reader - New Window
Content starts here

The Oracle Tuxedo CORBA Programming Environment

This topic includes the following sections:

Note: The Oracle Tuxedo CORBA Java client and Oracle Tuxedo CORBA Java client ORB were deprecated in Tuxedo 8.1 and are no longer supported. All Oracle Tuxedo CORBA Java client and Oracle Tuxedo CORBA Java client ORB text references, associated code samples, should only be used to help implement/run third party Java ORB libraries, and for programmer reference only.
Note: Technical support for third party CORBA Java ORBs should be provided by their respective vendors. Oracle Tuxedo does not provide any technical support or documentation for third party CORBA Java ORBs.

 


Overview of the Oracle Tuxedo CORBA Programming Features

Oracle Tuxedo offers a robust CORBA programming environment that simplifies the development and management of distributed objects. The following topics describe the features of the programming environment:

IDL Compilers

The Oracle Tuxedo CORBA programming environment supplies Interface Definition Language (IDL) compilers to facilitate the development of CORBA objects:

For a description of how to use the IDL compiler, see Developing Oracle Tuxedo CORBA Applications. For a description of the idl command, see the Oracle Tuxedo Command Reference in the Oracle Tuxedo online documentation.

Development Commands

Table 2-1 lists the commands that the Oracle Tuxedo CORBA programming environment provides for developing CORBA applications and managing the Interface Repository.

Table 2-1 Oracle Tuxedo CORBA Development Commands
Development
Command
Description
buildobjclient
Constructs a C++ client application.
buildobjserver
Constructs a C++ server application.
genicf
Generates an Implementation Configuration File (ICF). The ICF file defines activation and transaction policies for C++ server applications.
id12ir
Creates the Interface Repository and loads interface definitions into it.
ir2idl
Shows the content of the Interface Repository.
irdel
Deletes the specified object from the Interface Repository.

For a description of how to use the development commands to develop client and server applications, see Developing Oracle Tuxedo CORBA Applications.

For a description of the development commands, see the Oracle Tuxedo Command Reference in the Oracle Tuxedo online documentation.

Administration Tools

The Oracle Tuxedo CORBA programming environment provides a complete set of tools for administering your CORBA applications. You can manage Oracle Tuxedo CORBA applications through commands, through a graphical user interface, or by including administration utilities in a script.

You can use the commands listed in Table 2-2 to perform administration tasks for your CORBA application.

Table 2-2 Administration Commands
Administration
Command
Description
tmadmin
Displays information about current configuration parameters.
tmboot
Activates the Oracle Tuxedo CORBA application referenced in the specified configuration file. Depending on the options used, the entire application or parts of the application are started.
tmconfig
Dynamically updates and retrieves information about the configuration of a Oracle Tuxedo CORBA application.
tmloadcf
Parses the configuration file and loads the binary version of the configuration file.
tmshutdown
Shuts down a set of specified server applications, or removes interfaces from a configuration file.
tmunloadcf
Unloads the configuration file.

The Administration Console is a Java-based applet that you can download into your Internet browser and use to manage your Oracle Tuxedo CORBA applications remotely. The Administration Console allows you to perform administration tasks, such as monitoring system events, managing system resources, creating and configuring administration objects, and viewing system statistics. Figure 2-1 shows the main window of the Administration Console.

Figure 2-1 Administration Console Main Window

Administration Console Main Window

In addition, a set of utilities called the AdminAPI is provided for directly accessing and manipulating system settings in the Management Information Bases (MIBs) for the Oracle Tuxedo product. The advantage of the AdminAPI is that it can be used to automate administrative tasks, such as monitoring log files and dynamically reconfiguring an application, thus eliminating the need for manual intervention.

For information about the Administration commands, see File Formats, Data Descriptions, MIBs, and System Processes Reference in the Oracle Tuxedo online documentation.

For a description of the Administration Console and how it works, see the online help that is integrated into the Administration Console graphical user interface (GUI).

For information about the AdminAPI, see Setting Up a Oracle Tuxedo Application in the Oracle Tuxedo online documentation.

 


Oracle Tuxedo CORBA Object Services

The Oracle Tuxedo product includes a set of environmental objects that provide object services to CORBA client applications in a Oracle Tuxedo domain. You access the environmental objects through a bootstrapping process that accesses the services in a particular Oracle Tuxedo domain.

Oracle Tuxedo CORBA provides the following services:

Oracle Tuxedo CORBA provides environmental objects for the following programming environments:

Oracle Tuxedo CORBA also supports the use of the OMG CORBA Interoperable Naming Service (INS) by third-party clients, to obtain initial object references.

 


Oracle Tuxedo CORBA Architectural Components

This section provides an introduction to the following architectural components of the Oracle Tuxedo CORBA programming environment:

Figure 2-2 illustrates the components in a Oracle Tuxedo CORBA application.

Figure 2-2 Components in a Oracle Tuxedo CORBA Application

Components in a Oracle Tuxedo CORBA Application

Bootstrapping the Oracle Tuxedo Domain

A domain is a way of grouping objects and services together as a management entity. A Oracle Tuxedo domain has at least one IIOP Listener/Handler and is identified by a name. One client application can connect to multiple Oracle Tuxedo domains using different Bootstrap objects.

Bootstrapping the Oracle Tuxedo domain establishes communication between a client application and the domain. There are two mechanisms available for bootstrapping, the Oracle mechanism and the CORBA Interoperable Naming Service (INS) bootstrapping mechanism specified by the OMG. Use the Oracle mechanism if you are using Oracle CORBA client software. Use the CORBA INS mechanism if you are using a client ORB from another vendor. For more information about bootstrapping the Oracle Tuxedo domain, see the CORBA Programming Reference in the Oracle Tuxedo online documentation.

One of the first things that client applications do after startup is create a Bootstrap object by supplying the host and port of the IIOP Listener/Handler using one of the following URL address formats:

For more information about the Bootstrap URL address formats, see Using Security in CORBA Applications in the Oracle Tuxedo online documentation.

The client application then uses the Bootstrap object or the INS bootstrapping mechanism to obtain references to the objects in a Oracle Tuxedo domain. Once the Bootstrap object is instantiated, the resolve_initial_references() method is invoked by the client application, passing in a string id, to obtain a reference to the objects in the Oracle Tuxedo domain that provide CORBA services.

Figure 2-3 illustrates how the Bootstrap object or INS mechanism operates in a Oracle Tuxedo domain.

Figure 2-3 How the Bootstrap Object or INS Operates

How the Bootstrap Object or INS Operates

IIOP Listener/Handler

The IIOP Listener/Handler is a process that receives the CORBA client request, which is sent using IIOP, and delivers that request to the appropriate CORBA server application. The IIOP Listener/Handler serves as a communication concentrator, providing a critical scalability feature. The IIOP Listener/Handler removes from the CORBA server application the burden of maintaining client connections. For information about configuring the IIOP Listener/Handler, see Setting Up a Oracle Tuxedo Application and the description of the ISL command in the Oracle Tuxedo Command Reference in the Oracle Tuxedo online documentation.

ORB

The ORB serves as an intermediary for requests that CORBA client applications send to CORBA server applications, so that these applications do not need to contain information about each other. The ORB is responsible for all the mechanisms required to find the implementation that can satisfy the request, to prepare an object's implementation to receive the request, and to communicate the data that makes up the request. The Oracle Tuxedo CORBA product includes a C++ client/server ORB.

Figure 2-4 shows the relationship between an ORB, a CORBA client application, and a CORBA server application.

Figure 2-4 The ORB in a CORBA Client/Server Environment

The ORB in a CORBA Client/Server Environment

When the client application uses IIOP to send a request to the Oracle Tuxedo domain, the ORB performs the following functions:

TP Framework

The TP Framework provides a programming model that achieves high levels of performance while shielding the application programmer from the complexities of the CORBA interfaces. The TP Framework supports the rapid construction of CORBA applications, which makes it easier for application programmers to adhere to design patterns associated with successful TP applications.

The TP Framework interacts with the Portable Object Adapter (POA) and the CORBA application, thus eliminating the need for direct POA calls in an application. In addition, the TP Framework integrates transactions and state management into the Oracle Tuxedo CORBA application.

The application programmer uses an application programming interface (API) that automates many of the functions required in a standard CORBA application. The application programmer is responsible only for writing the business logic of the CORBA application and overriding default actions provided by the TP Framework.

The TP Framework API provides routines that perform the following functions required by a CORBA application:

The TP Framework ensures that the execution of a client request takes place in a coordinated, predictable manner. The TP Framework calls the objects and services available in the Oracle Tuxedo application at the appropriate time, in the correct sequence. In addition, the TP Framework maximizes the reuse of system resources by objects. Figure 2-5 illustrates the TP Framework.

Figure 2-5 The TP Framework

The TP Framework

The TP Framework is not a single object, but is rather a collection of objects that work together to manage the CORBA objects that contain and implement the data and business logic in your CORBA application.

One of the TP Framework objects is the Server object. The Server object is a user-written programming entity that implements operations that perform tasks such as initializing and releasing the server application. For server applications the TP Framework instantiates the CORBA objects needed to satisfy a client request.

If a client request arrives requiring an object that is not currently active and in memory in the server application, the TP Framework coordinates all the operations that are required to instantiate the object. This includes coordinating with the ORB and the POA to get the client request to the appropriate object implementation code.

 


How Oracle Tuxedo CORBA Client and Server Applications Interact

The interaction between Oracle Tuxedo CORBA client and server applications includes the following steps:

  1. The CORBA server application is initialized.
  2. The CORBA client application is initialized.
  3. The CORBA client application authenticates itself to the Oracle Tuxedo domain.
  4. The CORBA client application obtains a reference to the CORBA object needed to execute its business logic.
  5. The CORBA client application invokes an operation on the CORBA object.

The following topics describe what happens during each step.

Step 1: The CORBA Server Application Is Initialized

The system administrator enters the tmboot command on a machine in the Oracle Tuxedo domain to start the Oracle Tuxedo CORBA server application. The TP Framework invokes the initialize() operation in the Server object to initialize the server application.

The TP Framework

During the initialization process, the Server object does the following:

  1. Uses the Bootstrap object or INS to obtain a reference to the FactoryFinder object.
  2. Typically registers any factories with the FactoryFinder object.
  3. Optionally gets an object reference to the ORB.
  4. Performs any process-wide initialization.

Step 2: The CORBA Client Application Is Initialized

During initialization, the CORBA client application obtains initial references to the objects available in the Oracle Tuxedo domain.

The TP Framework

The Bootstrap object returns references to the FactoryFinder, SecurityCurrent, TransactionCurrent, NameService, and InterfaceRepository objects in the Oracle Tuxedo domain.

Step 3: The CORBA Client Application Authenticates Itself to the Oracle Tuxedo Domain

If the Oracle Tuxedo domain has a security model in effect, the CORBA client application needs to authenticate itself to the Oracle Tuxedo domain before it can invoke any operations in the CORBA server application. To authenticate itself to the Oracle Tuxedo domain using authentication, the CORBA client application completes these steps:

  1. Uses the Bootstrap object to obtain a reference to the SecurityCurrent object.
  2. Invokes the logon() operation of the PrincipalAuthenticator object, which is retrieved from the SecurityCurrent object.
Note: For information about using certificate based authentication, see Using Security in CORBA Applications in the Oracle Tuxedo online documentation.

Step 4: The CORBA Client Application Obtains a Reference to the CORBA Object Needed to Execute Its Business Logic

The CORBA client application needs to perform the following steps:

  1. Obtain a reference to the factory for the object it needs.
  2. For example, the client application needs a reference to the SimpleFactory object. The client application obtains this factory reference from the FactoryFinder object, shown in the following figure.

  3. Invoke the SimpleFactory object to get a reference to the Simple object.
  4. If the SimpleFactory object is not active, the TP Framework instantiates the SimpleFactory object by invoking the Server::create_servant method on the Server object, shown in the following figure.


    The TP Framework

  5. The TP Framework invokes the activate_object() and find_simple() operations on the SimpleFactory object to get a reference to the Simple object, shown in the following figure.

  6. The TP Framework

The SimpleFactory object then returns the object reference to the Simple object to the client application.

Note: Because the TP Framework activates objects by default, the Simpapp sample application does not explicitly use the activate_object() operation for the SimpleFactory object.

Step 5: The CORBA Client Application Invokes an Operation on the CORBA Object

Using the reference to the CORBA object that the factory has returned to the client application, the client application invokes an operation on the object. For example, now that the client application has an object reference to the Simple object, the client application can invoke the to_upper() operation on it. The instance of the Simple object required for the client request is created as shown in the following figure.

The TP Framework


  Back to Top       Previous  Next