httpd-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Anil K. Vijendran" <>
Subject Re: [Proposal] "Relayed" Apache API Project
Date Mon, 31 Jan 2000 22:01:29 GMT
On Mon, 31 Jan 2000, Shachor Gal wrote:

> I guess that the question here is what are we looking for, CORBA is good
> when you need to implement a flexible general purpose object interface.
> IMHO this is not such case, I think (and correct me if I am wrong) that 
> what we are looking for is a fast request forwarding with callback
> capabiliies...
> - We are not going to pass object references...
> - Most of the data is going to be plain strings/integers representing a
> well known value
> - Callbacks should happen at the same thread that initiated the request,
> in CORBA on the other hand due to (good) generalization limits callbacks
> are done in another thread...
> We can find more reasons if we will look for them.
> So, it seems that using an AJP2.1 based protocol is going to be a much
> simpler and adequate approach.

CORBA is basically an API description system (IDL) and a protocol (IIOP).
This allows you to make arbitrary function calls. 

Data you pass can be plain predefined IDL types (integers, strings etc) in
which case it doesn't hurt very much to use IIOP in its simple basic form. 
There are atleast two objects -- one on the Apache side and one on the
Tomcat side and these objrefs can either be exchanged as initial
references or using a naming service that comes with any ORB. 

I'm not worried about the overkill factor of using CORBA for fast request
forwarding with callback capabilities; what worries me is the
singlethreaded restriction. There is support for singlethreaded invocation
using an event poll and dispatch mechanism. Unfortunately not many people
implement it :-) 

>From the ORBit sources: 

1082 /* Section 4.9.1 */
1083 CORBA_boolean CORBA_ORB_work_pending(CORBA_ORB orb, CORBA_Environment
1084 {
1085         g_assert(!"Not yet implemented");
1086         return(CORBA_FALSE);
1087 }
1089 /* Section 4.9.2 */
1090 void CORBA_ORB_perform_work(CORBA_ORB orb, CORBA_Environment *ev)
1091 {
1092         g_assert(!"Not yet implemented");
1093         return;
1094 }

The advantage I see in using something like CORBA is that there is a
easy and well defined way to define interfaces and make RPCs. That ensures
a good evolutionary path as the need for richer communication between
Apache and Tomcat increases. With new-httpd, there is the multi-threading
flexibility as well.

Again, are there any users of mod_corba here that can shed more light? 

Peace, Anil +<:-)

View raw message