With the explosion of broadband Internet connections in the late 80s, new types of applications, called distributed applications, came to light. These applications typically seek to provide a user with remote services that appear to that user as if they were local. For instance, when a user browses the Internet, web pages are downloaded from different servers and are displayed on the screen of the client's computer as if they were directly available on the computer itself. Typically one distinguishes two kinds of actors in such applications: clients, searching for information, and servers, providing the information. Furthermore, there are generally two models of interaction according to which these actors exchange information. In the first model, the client requests specific information and waits until the server replies to it. In the second model, the client registers its interests in some information with a set of servers and is notified when new information is available. Both models have their advantages and disadvantages but the second has obvious asynchrony benefits in a large-scale system in which it is very difficult to know the time taken to answer a request. The second model is usually encapsulated within the celebrated publish/subscribe abstraction. According to this abstraction, clients are either subscribers which express interest in specific information, or publishers which create and send pieces of information usually transmitted in the form of events (e.g., as HTML pages or plain data). The subscriber does not need to know a publisher or to be on-line with it to receive its published events. These properties are sometimes refer to as space and time decoupling respectively. Newsgroups are the most well known example of publish/subscribe system. While indeed appealing, the publish/subscribe abstraction is not easy to implement effectively. There are at least two challenging issues: (1) the representation of the events and (2) their dissemination on a large-scale or in a mobile environment. Events are usually transferred as XML messages or byte arrays. The system must therefore transform events into pieces of software implemented in its underlying language (e.g., Java, C#) before handling them. In addition, the reliable dissemination on a large-scale or in a mobile environment is not trivial, especially as in practice it is necessary to minimize the number of duplicates and parasite events (i.e., events of no interest) to save bandwidth and processing power. We focus in this thesis on devising and implementing algorithms which address the above two issues in publish/subscribe systems implemented in object-oriented languages (e.g., Java, C#) and such that the events that are transferred between the different actors correspond to serialized objects. These systems are also called type-based publish/subscribe systems. We first present techniques to detect events of interest and throw away parasite events. We show that these techniques are of major use for reliably disseminating events either on a large-scale or in a mobile environment without flooding the network. Finally, we illustrate type interoperable rules that let instances of two different types, but still representing the same entity, to be used indistinguishably. Together with the algorithms, we exhibit implementation prototypes and performance measures conducted over them.
Read more
3