Menu
▾
▴
#7 Hierarchical servers
What is the difference between a CORBA ORB and a
SharedSpace instance?
From the perspective of object lookup, an ORB is the
reunion of a shob server and a shared space. It has
code for finding objects inside other ORBs, and code to
share objects inside it with other ORBs.
I don't see the need to make shob more like CORBA.
Instead, I think we could have hierarchical servers,
capable of talking to other servers and finding objects
in a WAN just like they would in a LAN.
There are two opposite views for this: one that thinks
of a WAN as nothing more that a big network, where all
the hosts can connect to each other. An ideal server
would work a little bit like the DNS system: it may not
know about the global name you seek, but it can direct
you to another server who has the answer. Still we have
to worry about the distributed locks, so we can't just
cache results in the server. The client's lookup system
would have to keep track of which server has which
lock, but to implement this is not inherently difficult.
The second point of view sees a WAN as a collection of
LANs, possibly corporate networks with firewalls and
local IPs (such as 192.168.x.x). In this network, a
hierarchical approach for servers would begin with
mixed server-clients (like an ORB!) who could get a
copy for you, lock on it, and commit your changes when
you're done. Yes, a proxy program like Squid!! All the
objects shared within the local network would be shared
on our local server, and thus have locks there. Other
objects would be indirectly accessed, and would have
their locks in their own local server. A third server
would connect the first two just like a local space (I
mean, two clients for him, with shared "globalName" lists.
So far we don't have any restriction to global names.
But they were thought, from the start, to be
hierarchical. Imagine that your server would have a
name like "IME". An object shared there with the name
"duke" would have a global name "IME.duke" and could be
shared with the cyberspace like this. No
"name-to-number" translations, nothing. A 3-layer
globalName could be "Sampa.IME.duke" - the fact is
that, if every server has a name, a server who can
share his name table with "IME" has a unique chunk for
his local objects. Since "Sampa" was already unique,
"Sampa.IME.duke" is unique!
A host that only has access to the server "Sampa.eba"
could get "Sampa.IME.duke" with no problems through the
"Sampa" server. But he would already find his target
object asking for "IME.duke", since both "IME" and
"eba" servers are in the same level.
We would no longer allow dots to share names. A small
price to pay.