|
|
REDS (REconfigurable Dispatching System) is a framework of Java classes to build publish-subscribe applications for large, reconfigurable networks.
Distributed publish-subscribe applications are organized as a collection of components, which interact by publishing messages and by subscribing to the classes of messages they are interested in. Publish-subscribe applications are usually built around a publish-subscribe middleware, which provides a dispatcher, responsible for collecting subscriptions and forwarding messages from publishers to subscribers, and a library to access the services of the dispatcher and implement components.
REDS is more than a simple publish-subscribe middleware. It provides the client API to write publish-subscribe applications and defines a general framework of components, with clearly defined interfaces, to build a distributed dispatcher.
A REDS dispatcher is organized as a set of brokers linked in an overlay dispatching network, which collaborate to route messages from publishers to subscribers. REDS defines the structure of a broker in terms of a set of Java interfaces, and provides different implementations for each of them. REDS developers may use them to build their own dispatching network, with the desired characteristics, or they can implement new versions of the main components to fit their needs.
By choosing the right components to build brokers and connect them or by defining new components, developers using REDS may define:
Finally, REDS provides advanced mechanism to reconfigure the topology of the dispatching network at run-time either to react to changes in the underlying phisical network or to adapt it to the application's needs, e.g., to balance the traffic load, or to change the number of brokers and their connectivity.
Components of an application built using REDS access the services provided
by REDS through an object that implement the DispatchingService
interface. It provides methods to subscribe and
unsubscribe to classes of messages and to publish
messages. REDS provides several implementations of the
DispatchingService interface, which differ for the protocol used
to access the REDS dispatcher. Developers using REDS may define their own
format of messages and filters (used to define the classes of messages
application components want to subscribe to) by implementing the
Message and Filter interfaces,
respectively. Otherwise, they can use the classes already provided with
REDS.
The REDS
dispatcher is organized as a set of brokers linked together in an overlay
dispatching network. Each broker is structured in a set of components whose
interfaces constitutes the core of the REDS framework. Figure on the right
shows the internal structure of a REDS broker:
Core is the central element of a
REDS broker. It holds the two shared data structures (i.e., the
SubscriptionTable and the NeighborSet) and mediates
the communication among the other components, which do not have visibility of
each other. The Core is also in charge of dispatching
internal messages to the listeners registered for them (for more
details on this issue see the REDS documentation).Router implements the specific routing strategy
adopted. It includes a set of methods that get invoked by the transport layer,
through the \texttt{Core}, to notify it that a subscription, an
unsubscription, or a message have been received from one of the broker's
neighbors. It uses the SubscriptionTable to store the information
about subsribed neighbors that are useful for routing.ConnectionManager is the component in charge of
managing the dispatching network in presence of reconfigurations. In
particular, it is notified by the Transport (through the
Core) when a new peer or broker requested to connect or to
disconnect. It is also contacted when the Transport cannot reach
a neighbor that was previously connected.NeighborSet and the SubscriptionTable. The
former keeps track of the set of brokers and peers attached to the local
broker, while the latter stores the relevant information about the set of
filters each neighbor is subscribed to.Transport component and a set of
Neighbors, one for each broker or peer attached to the local
broker. Objects implementing the Neighbor interface act as
proxies toward the neighbors of the local broker.Current version of REDS provides several classes that implements the
interfaces defined above. By opportunely choosing them, programmers using REDS
may adapt the behavior of the system to their needs. Programmers are also free
to implement new versions of these components if none of them fits their
specific needs. As an example, one could define a new component implementing
the Router interface, which realizes a new routing strategy for
messages and subscriptions. If correctly implemented, such component can be
combined with existing ones to implement a fully functional, innovative
dispatching network with a minimal effort.
REDS is the result of a research effort led by Gianpaolo Cugola and Gian Pietro Picco, which has been carried out at Politecnico di Milano, Italy. While the two researchers designed REDS and guided its development, the implementation of the current REDS prototype has been possible thanks to the contribution of Fabrizio Buzzi, Sandro Calzoni, and Luca Mottola.
REDS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
REDS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
Moreover, REDS is being provided with no support and without any obligation on the part of Politecnico di Milano, its trustees, faculty, staff, students, or employees, (collectively "Politecnico di Milano" herein) to assist in its use, correction, modification, or enhancement.
Politecnico di Milano will have no liability with respect to infringement of copyrights, trade secrets, patents, or other intellectual property rights or values by others' use of REDS. In no event will Politecnico di Milano be liable for lost revenue, lost profits, or any general, special, indirect or consequential damages under any theory of liability whatsoever.
To use REDS you must a recent Java Development Kit installed. You can download last version of the JDK for the major platforms from the Sun's Java site. REDS should work with any recent version of the JDK. It has been developed and tested with JDK v1.4 both under Linux and Windows.
To compile reds yourself download the reds source package and read the README file included (you need ant).
For any question about REDS you can contact one of its authors: Gianpaolo Cugola and Gian Pietro Picco.