[Pipet Devel] summary for web

Brad Chapman chapmanb at arches.uga.edu
Fri Mar 31 07:02:02 EST 2000

>> 5. Communication with remote vsh programs as both a client and a
>> server
>> using corba (through an idl that still has to be defined). This 
>> a
>> specific implementation of vsh to serve out a specialized node or 
>> of
>> nodes to be utilized by other vsh implementations at remote 
>> The processing layer will handle the specifics of this 
>> but the middle will define a protocol to authenticate remote vsh
>> implementations and provide access only to available nodes.
> When the DL is authenticated by the BL, shoudn't 5) also be located 
> the
> BL?

Yes, I think so. I'm not at all clear on how the specifics of the node 
sharing are going to work eventually, although this is a very 
important part of vsh.
    I'll try and describe my ideas on this by an example. Lets say I'm 
running a vsh implementation at home, and I want to connect with a 
high speed machine of Jeff's running vsh at a remote location. My 
rough idea was that things would work as follows:

1. From within the user interface, I would request to see the 
available nodes at Jeff's computer, and enter a password for 

2. My definition layer would get access to Jeff's machine via some 
repository of IORs and machines, and connect with his corba server.

3. My dl would authenticate with his dl, and then would send a request 
of all nodes that I have permissions to use.

4. My definition layer would recieve this list and make these nodes 
known to the user interface. I would then use one of them in a 
work-flow diagram.

5. I would send this work-flow diagram with the remote node (as XML) 
to the brokering layer in a processing request.

(okay, this is where things get pretty hazy).

6. The brokering/processing layer would set up its path of processing 
(by whatever method) and start processing.

7. When it needed the info from that node, it would need to connect 
with Jeff's computer remotely (this connection would occur somewhere 
inside the brokering/processing layers), send the node the info it 
needs, let it process it, and then get the results back.

8. Then the results can be fetched from the brokering layer on my 
computer in the same way as for the execution of a local node.

Okay, that my cloudy idea of how things would work. Is this what you 
all were thinking? Is this at all feasible?


More information about the Pipet-Devel mailing list