geronimo-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "gianny DAMOUR" <>
Subject Distributed filesystem
Date Wed, 18 Feb 2004 14:04:53 GMT

Following your feedback on my first attempt to implement a WebDAV service, I 
have started the implementation of a "distributed" filesystem.

The goal is to provide a remote access to a shared repository of components. 
This feature could be used to distribute modules (JSR88) to targets and more 
generally to read, update or delete files stored on the network.

Moreover, I also tried to set-up a networking infrastructure, which could be 
leveraged to implement a RemoteCluster (by now, only a LocalCluster is 

This prototype has reached a stage, where I would like to have your feedback 
on the general idea as I plan to perform a first round of refactoring (by 
now, there are 54 classes) prior to submit this proposal.

So, here is the general idea:

The "current" networking infrastructure is based on a standard client-server 
design using TCP as the communication protocol. The "final" infrastructure 
will be based on the same design with many servers. Clients and servers are 
in charge of performing network related tasks (handshake, heart-beat, 
routing et cetera) and delegate the processing of byte blocks to connected 
components. These components can be whatever you want, for instance a 
filesystem manager or a (cluster) Tier.

The overall idea is depicted hereafter:

Connector -- MTO -- ServantNode -- MTO -- ServerNode -- OTM -- Connector

- ServantNode is a client (i.e. Socket side);
- ServerNode is a server (i.e. ServerSocket side);
- Connector is a component in charge of processing byte blocks (this is not 
a RPC invocation) sent by remote Connectors.

For instance one could have this in the case of the prototype I am working 

GFileManagerClient -- MTO -- ServantNode -- MTO -- ServerNode -- OTM -- 
GFileManagerProxy -- LocalGFileManager

where GFileManagerClient is a Connector, which allows a remote access to 
GFileManagerProxy, also a Connector, which delegates the actual file 
management to LocalGFileManager. This latter is a local filesystem.

This is for the networking part.

For the filesystem part, I have designed the solution as a "Data Store" for 
files. It is also possible to add properties to these files (required for 
WebDAV). The storage is performed via a DAO (I have quickly implemented a 
DAO for a local filesystem).

Clients interact with the filesystem via a standard "Data Store" API:

void start();
void persistNew(GFile);
void persistUpdate(GFile);
void persistDelete(GFile);
void end();

and GFile mirrors most of the File API.

This is for the filesystem part.

Any concerns?

Thanks for your inputs,

MSN Messenger : dialoguez en direct et 
gratuitement avec vos amis !

View raw message