Host API, was: Support for callbacks

[Jeremy Boynes <jb...@apache.org>]

On Jul 10, 2006, at 7:53 AM, Jim Marino wrote:
>
> On Jul 10, 2006, at 7:40 AM, Jeremy Boynes wrote:
>
>> On Jul 10, 2006, at 7:19 AM, Jim Marino wrote:
>>> 2. We need to get the host API supporting callbacks. The  
>>> reference would use the host API to register itself as a listener  
>>> with a binding as opposed to talking directly with the binding.  
>>> This will allow us to decouple the callback infrastructure from  
>>> particular bindings. Jeremy may have some thoughts on this.
>>>
>>
>> I would have though that the reference would register with the  
>> binding rather than the host. After all the reference is bound on  
>> the outbound side so is coupled to the binding at that point;  
>> wouldn't the inbound side just be the reverse?
> Wouldn't the reference (composite reference) use the host api to  
> register with the binding transport? I may not have worded things  
> clear enough. This way we separate the protocol binding and  
> callback mechanisms from the particular transport (e.g. Jetty)?

In my mind, the host API is a low-level API that allows Tuscany  
services to connect to physical things in the host environment;  
examples for physical things would be sockets or things layered on  
top of sockets (such as servlets, mail-lets, JMS message listeners),  
threads, timers, etc. The host API would be bridged to a managed  
environment such as a J2EE server or could be implemented by other  
low-level Tuscany services such as a Jetty transport or ActiveMQ  
message broker to provide a standalone environment. Think of it as a  
host abstraction layer.

Things that represent Tuscany or SCA services would sit at a level  
above that. So, for example, a HTTP transport would sit at this level  
and would use the host API to register for inbound HTTP requests or  
to make outbound HTTP requests; a SOAP protocol handler would sit on  
top of the HTTP transport, a WebService binding would sit on top of a  
SOAP protocol handler, and so forth. This is a system connection level.

The associated between a reference and a binding is a Tuscany concept  
rather than a physical one so in my mind that would be a connection  
at the system level rather than at the host level.

We still get the decoupling from the physical side (e.g. from Jetty  
vs. Tomcat) but it's through the stack that the binding is using  
rather than at the host level. This also means that the reference  
would be abstracted from the details of the binding (e.g. which SOAP  
stack, which databinding, which transport).

--
Jeremy


---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-dev-help@ws.apache.org