How to model Parlay/CORBA based interface in J2EE environmen

[gerkokoppelman]

We using a Parlay based CORBA interface that we want to access on a J2EE platform. The interface recognizes a remote "service layer" and a local "application layer". The remote "service layer" contains several classes (each having a different CORBA interface description). Each of these classes has an associated callback class in the "application layer". This means that both "service layer" and "application" are CORBA servers and clients.

The behavior of the interface is typically session oriented. An action inside the "service layer" will initiate a new session. A session will typically contain one instance of a certain class, multiple instances of another class (and perhaps multiple instances of a third class). Each of these instances will have its unique corresponding callback instance in the "application layer". Actions on the "service layer" are mostly asynchronous; e.g. serviceInstance.actionReq() is called by the application on the "service layer" and the callbackInstance.actionRes() or callbackInstance.actionErr() are called by the service on the "application layer".

An example of such a session is a telephony call. A "telephonyCall" instance is located in the "service layer" and has multiple "telephonyCallLeg" instances (multiple in case of a telephony conference). In the "application layer" a "telephonyCallCB" callback instance and multiple "telephonyCallLegCB" callback instances are present (associated with their corresponding instances in the service layer). Different callback instances are needed to distinguish events happening in the telephone conference from one another (e.g. one caller hangs up, another presses a digit on its phone).

Aside from the handling of the sessions, the "application layer" will also need to perform some "management related" tasks, e.g. periodically checking if the "service layer" is still available, (for a particular application) registering for certain incoming sessions (e.g. telephone calls directed to particular numbers), or starting a new outgoing session (e.g. initiating an outgoing telephone call).

The CORBA IDL is used to generate stub files for both "application layer" and "service layer". There is no interface repository available.


Now, given a J2SE environment, the "application layer" can be perfectly modeled, either by using the generated stub files, implementing the (CORBA) callback objects and accessing the remote objects. Different "applications" each can have their own ORB, providing a nice separation of functionality.

For J2EE it is unclear for us how to proceed. It is essential that (for a given session) an application is aware of the different callback interfaces, as it needs to react on the events (invocations) on the different interfaces. It must be possible for different "applications" to register for different sessions (e.g. one application handles telephone calls for number X, another application for number Y). We have considered using JCA to "wrap" the CORBA based interface, but we are unsure how we can / need to approach this.

Any help, info or suggestion is appreciated.

[weston.price]

The first place I would suggest looking is the JCA spec itself. In the 1.5 spec (latest) you will want to play particular attention to MessagingInflow as this would seem to correspond to your callback interface in your app tier. Further, connection management (section 6) is also important.

Beyond that, writing adapters can be a bit painstaking. For this I would look at the JBoss source tree. We have adapters for support JDBC, JMS (outbound and inbound), Mail (inbound). While not exactly on point, this should give you a broad understanding of what an adapter is, the problems they solve, and how they integrate into the J2EE environment.

Finally, while JBoss doesn't provide any direct CORBA JCA adapters, there are third party companies that do. Perhaps you could get this 'off the shelf'. Hope this helps.