Distributed Electronic Mail
Bercovici Sivan (bercos@tx.technion.ac.il)
Instructor: Frishman Yaniv (frishman@tx.technion.ac.il)
Technion - Department of Electrical Engineering - Software Lab
March-October 2004
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
Currently
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:
 |
Lightweight dispatch units (servers) |
|
|
Dispatch unit GUI |
|
|
Mobile user mailbox |
|
|
Mailbox GUI |
|
|
Floating attachments |
|
|
Mailbox pool (Enables mailbox management on online computers) |
|
|
Spy (Enable system monitoring) |
|
|
Central system operation and debugging console |
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:
|
|
Dynamic Layout of Distributed Applications in FarGo (available) |
|
|
FarGo Programming Guide - A technical report by Ophir Holder and Hovav Gazit |
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
Demonstration
The demonstration available for download through this page
(on the right bar) includes both server side and client side components
demonstration. Download and unpack to a directory of your choice.
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
name>
The entries should correspond to the DEM servers that will or might be
brought up. This back-bone list file should be distributed to any
client that might want to use the system, as this file is used to solve
the first-connection (login) problem.
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
be created.
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:
|
|
Distributed system |
|
|
Mobile components |
|
|
Scalable |
|
|
Light communication |
|
|
Inherent server load balance |
|
|
Fault-tolerant servers |
|
|
Self-regenerating clients |
|
|
Lazy attachments |
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
development:
|
|
Privacy and overall system security |
|
|
Better load-balancing |
|
|
Bridges to classic mailing systems |
|
|
Examine a design and implementation of a pure decentralized e-mail system |
|
|
Hardware implementation (or hybrid
hardware/software solution) |
Use the following links to download the needed tools for the compilation and execution of the e-mail system:
http://www.java.com/en/developers/
http://www.dsg.technion.ac.il/fargo
http://www.jython.org/download.html/
http://ant.apache.org/
http://logging.apache.org/log4j
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.
Presentation
Projects presentation that
was submitted to the KASHER 2004 contest
Film
Explanatory film produced
using Fishman Yaniv's visualization tools - Drawing of clustered graphs
Poster
A short survey and explanation of key
elements in the project
Documentation
Project documentation,
including full design and implementation description
Abstract
Project abstract, as
proposed at the beginning of the project
Source
Latest DEM implementation
Demonstration
Server/client/administrator
side components demonstration