Distributed Electronic Mail
Bercovici Sivan (firstname.lastname@example.org)
Instructor: Frishman Yaniv (email@example.com)
Technion - Department of Electrical Engineering - Software Lab
most modern e-mail systems are based on a centralized approach in which users communicate with a central server in order to retrieve their personal mail. This sort of approach inherently suffers from key problems such as scalability, fault-tolerance and various constrains on the systemís users. Using FarGo as the development environment, we have designed and implemented a distributed mailing system, providing answers to both performance and fault-tolerance issues. Using personal traveling mailboxes which reside on on-line clients, most communication will be done between mailboxes, thus removing much of the bottleneck that might be caused by the mail server. Fault-tolerance of mailboxes is based on traveling backup mailboxes that will scatter among the currently connected clients - redundancy used to increase the fault-tolerance. The server goal in this scheme will be to act as a reference gate for all the mailboxes. As these servers may experience crashes, a special reference resolving is done on backup servers to enable fault-tolerance at this point as well. The systemís components will try to detect local faults, regenerating its dead components on on-line clients. This adaptive approach, commonly known as a self-regenerating system (or self-healing systems) allows the convergence of the system into a fixed legal state in which the degree of fault-tolerance is preserved. The solution also focused on removing as much storage stress as possible for the mail system. This was achieved by the use of a single copy of an attachment regardless of the number of mail recipients.
Figure 1: DEM preliminary design overview
implemented components offer the full range
needed in-order to setup a working e-mail system. From the server end,
light-weight server (dispatch unit) keep track of the mobile
mailboxes, offering the clients up-to-date references for the requested
mailbox objects (according to a given address). A dispatch-unit GUI
will show events inside the system, including the joining and removal
of other dispatch units and system clients. From the client end, users
are able to create an account and perform mail operations such as mail
composition, deletion, reply, etc. These operations are performed
through the client's GUI.
The components in the following list are mobile, thus they can reside anywhere inside the network:
As these components are mobile, GUI and model elements can reside on different computers. This means that a user can view his/her mail through a local GUI, while the entire mailbox resides on a distant computer. This feature allows some degree of communication optimization, as users tend not to read their entire mailbox at each single session.
The project was implemented using Fargo (link available under the links section). Fargo is being developed here, at the Electrical Engineering faculty. Fargo is an example of a mobile-component-based distributed applications development environment. It is Java based, which yields easy development of a cross-platform application. Its unique capability to control relationships between moving objects allows a more precise and rich application design. Using Fargo does not imply major code changes. Rather, a small set of modifications is required to allow the application's components to be mobile.
To learn more, one can review the following papers:
The source files contain the implementation of all of the previously described components. A detailed design is available in both the supplied report and as part of the actual source. To compile the system, one should download the source from the provided link (on the right bar). Upon download, one should modify the "build.xml" file, so the directories inside the build file will be correct. Put special notice to the directory definition for the "tools.tar" file.
After modifying the "build.xml" file, one can proceed by building the system using the "ant compile" command.
Links for the needed tools are available in the following sections
To build a back-bone server
list, one should modify the "DispatchUnit.list" file. Add entries in
the following format: <IP address>:<port number>/<core
To run a server, use the
"runServer <server name>" script. This will start a server on the
local system , using the supplied parameter as the name of the server.
To use the system from the
client side, one should execute "runLogin". The user will be prompt for
a name. In case the user name is new to the system, a new account will
The demonstration also
includes the administrative/developer console. To start the console one
should use the "runTest" script.
following is a list of of key features and advantages that are available as either infrastructure or full-implementation in the latest version of the system:
In this section, we will give a short tour of the available system's GUI ranging from client-side components to server-side components:
Figure 2: Client side mailbox interface
Figure 3: Compose a new mail
Figure 4: Dispatch unit monitoring view
Figure 5: System monitoring and interaction
following is a list
of suggested future directions for research and
Use the following links to download the needed tools for the compilation and execution of the e-mail system:
The author is grateful to Dr. Ilana David for providing the needed consoling, research freedom and resources for the project development. The author is also grateful for the close guidance from both Dr. Tal Ayellet and Dr. Keidar Idit. One last thanks goes to Frishman Yaniv that offered his attention, guidance and skills that were needed throughout the project's life-cycle.