Abstract: Content-based routing realized through static networks of brokers usually exhibit nice performance when subscribers with similar interest are physically close to each other (e.g. in the same LAN, domain or in the same geographical area) and connected to a broker which is also nearby. If these subscribers are dispersed on the Internet, benefits of such routing strategy significantly decrease. In this paper we present a Topology Management System (TMS) which is a component of a content-based pub/sub system. The aim of a TMS is to mask dynamic changes of the brokers topology to the content-based routing. TMS relies on a self-organizing algorithm whose goal is to place close (in terms of TCP hops) brokers that manage subscribers with similar interests keeping acyclic the topology and without compromising network-level performance. TMS is also resilient to broker failures and allows joining of new brokers.
Abstract: In this paper we discuss our ongoing experience in integrating a Product Data Management application, ThinkTeam, and the Siena Publish/Subscribe Middleware. This integration should support ThinkTeam users in managing the lost-update problem. This problem arises when a client performs a check-out/modify/check-in cycle on a document that may be used as reference copy by other clients. In this context Siena should allow for disseminating alerts about the state of the document. The integration between ThinkTeam, and Siena poses new requirements on how to manage events and subscriptions. The paper discusses a set of integration problems and their possible solutions.
Abstract: Content-based publish/subscribe systems offer a convenient abstraction for data producer and consumers, as most of the complexity related to addressing and routing is encapsulated within the network infrastructure. A major challenge of content-based networks is their ability to efficiently cope with changes in consumer membership. In our XNET XML content network, we have addressed this issue by designing novel algorithms to speed up subscription management at the routers, while guaranteeing perfect routing at all times and maintaining compact routing tables thanks to extensive usage of aggregation. In this paper, we discuss the issue of subscription management in content-based networks, and we specifically describe and evaluate the algorithms that we have developed for our XML content network. Experimental evaluation confirms that these algorithms are key to XNET s ability to efficiently handle large and highly dynamic consumer populations.
Abstract: Content-based publish/subscrbe systems provide an useful alternative to traditional address-based communication due to their ability to decouple communication between participants. It has remained a challenge to design a scalable overlay supporting the complexity of content-based networks, while satisfying the desirable properties large distributed systems should have. This paper presents a new peer-to-peer overlay called HOMED for distributed publish/ subscribe systems. It can construct a flexible and efficient event dissemination tree by organizing participants based on their interest. The delivery depth of an eventas well as subscribing/unsubscribing overhead scales logarithmically with the number of participating nodes
Abstract: The event-based approach is well suited for integrating autonomous components or applications into complex systems by means of exchanging events. Event-based systems need an event dissemination mechanism (or notification service) to deliver relevant events to interested consumers. The publish/subscribe interaction paradigm has been gaining relevance for this purpose. One of the main characteristics of publish/subscribe systems is that they decouple producers and consumers so that they are are unknown to each other. Therefore, the consideration of data heterogeneity issues is fundamental. However, most pub/sub notification services do not support the interaction among heterogeneous event producers and consumers. In this paper we describe the concept-based approach as a high-level dissemination mechanism for distributed and heterogeneous event-based applications. It enhances the notification service by enabling it to pass semantic information across through component, institutional or cultural boundaries. It provides a high level abstraction for a meaningful exchange of data within the pub/sub interaction paradigm.
Abstract: A variety of Message-Oriented Middleware (MOM) platforms are available each with their own propriety functionality to solve specific messaging challenges. At present, it is not possible to mix and match these propriety features into a customized MOM solution. A number of patterns have been identified that allow a software systems implementation to be more flexible and extensible. This work investigates the use of one such pattern, the POSA Interceptor pattern, in the construction of a MOM framework that can be easily customised and extended in a structured way. This framework, Chameleon, is designed to support the use of interceptors (message handlers) with a MOM platform to facilitate dynamic changes to the behaviour of the deployed platform. The framework also allows for interceptors to be used on both the client-side and serverside, permitting advance functionality to be deployed to the client, and for cooperation between client-side and server-side interceptors.
Abstract: Various application domains exist where the advantages of the event-based paradigm make it a key technology. In general, this architectural style allows better control of the structural and behavioral complexity of applications: components can be developed independently and loosely integrated. The computational behavior of this paradigm, however, remains poorly understood. This position paper argues on the necessity of a new methodology for constructing event-based applications as well as a new logic that clari- fies the computational behavior of such applications. For this, the paper presents some factors that make the event-based style so troublesome and discusses the (non-) adequacy of existing formal techniques for the construction of event-based applications.
Abstract: Publish/subscribe is emerging as a very flexible communication paradigm that is applicable to environments demanding scalable and evolvable architectures. Although considered for workflow, electronic commerce, mobile systems, and others, security issues have long been neglected in publish/subscribe systems. Recent advances address this issue, but only on a low, technical level. In this paper, we analyze the trust relationships between producers, consumers, and the notification infrastructure. We devise groups of trust to model and implement security constraints both on the application and the system level. The concept of scopes helps to localize and implement security policies as an aspect of structured publish/subscribe systems.
Abstract: The problem domain of Collaborative Intrusion Detection Systems (CIDS) introduces distinctive data routing challenges, which we show are solvable through a sufficiently flexible publish-subscribe system. In general, CIDS aim to share intrusion detection data among organizations, usually to earlier and more accurately predict impending attacks, e.g., from Internet worms that tend to attack many sites at once. In particular, participants in the CIDS collect lists of suspect IP addresses, and want to be notified if others are suspicious of the same addresses. The matching must be done efficiently and anonymously, as most organizations are reluctant to share potentially revealing information about their networks, routing alerts regarding external probes only to other CIDS participants experiencing probes from the same source(s). We term this type of simultaneous publish/subscribe selecticast. We present a potential solution using the secure Bloom filter data structure propagated over the MEET publishsubscribe framework.
Abstract:
The paradigm shift from device-oriented to
serviceoriented management has also implications to the area of event
correlation. Today s event correlation mainly addresses the
correlation of events as reported from management tools. However, a
correlation of user trouble reports concerning services should also be
performed. This is necessary to improve the resolution time and to
reduce the effort for keeping the service agreements. We refer to such
a type of correlation as service-oriented event correlation.
For
introducing service-oriented event correlation for an IT service
provider, an appropriate modeling of the work- flow and of the
information is necessary. Therefore, we examine the process management
frameworks ITIL and eTOM for their contribution to the workflow
modeling in this area. The MNM Service Model, which is a generic model
for IT service management proposed by the MNM Team, is used to derive
an appropriate information modeling. The different kinds of
dependencies that we find in our general scenario are used to develop
a workflow for the serviceoriented event correlation.
Abstract: In this paper we are concerned with event-based situation analysis. Application areas include the understanding and awareness of complex unfolding scenarios such as homeland security threats and future battlespace engagements. The paper (i) discusses the differences between the environments/requirements for event-based management and situation management, (ii) presents an argument for an integration of an event correlation system and a situation awareness system, and (iii) proposes an integrated architecture that combines rule-based spatio-temporal event correlation and casebased reasoning for understanding and managing situations. In addition, the paper discusses the hard problem of the mutual influence between event management and situation awareness.
Abstract: Event-based middleware is emerging as the major paradigm for large-scale and widely distributed systems, especially sensor-rich environments. Here, many primitive events are low-level and effort has been directed towards defining more meaningful composite events, which are typically recognised by finite-state machines. We argue that finite-state-machines (FSMs) are insufficient for meeting the requirements of users in Sentient Computing environments; user intuition may be concerned with notions such as state and negation which FSMs cannot support with reasonable efficiency. We aim to support querying and subscribing transparently to distributed state, which necessitates an alternative model for Sentient Computing. We propose a state-based, temporal first order logic (TFOL) model whose implementation is based on a deductive knowledgebase. Furthermore, we propose a generalised notion of an event, an abstract event, which we define as a notification of transparent changes in distributed state. An extension to the publish/subscribe protocol is discussed, in which a higherorder service (Abstract Event Detection Service) publishes its interface; this service takes a TFOL abstract event definition as an argument and in return publishes an interface to a further service (an abstract event detector) which notifies transitions between the values true and false of the formula, thus providing a more natural and efficient interface to applications.
Abstract: Information dissemination in a wide area network has recently garnered much attention. Two differing models, publish/subscribe and rendezvous-based multicast atop overlay networks, have immerged as the two leading approaches for this goal. Event-based publish/subscribe supports content-based services with powerful filtering capabilities; peer-to-peer rendezvous-based services allow for efficient communication in a dynamic network infrastructure. We describe Reach, a system that integrates these two approaches to provide efficient and scalable content-based services in a dynamic network setting.
Abstract: The paper proposes a novel approach to mobility in publish/subscribe (pub/sub) systems that relies on notification persistency. The existing solutions apply proxy subscribers that take the role of disconnected subscribers, store notifi- cations published during disconnections, and deliver them to subscribers after reconnection to the pub/sub system. The system perceives a constant number of subscribers which is inefficient if it serves a large number of subscribers that are often disconnected. We argue that the system should not be burdened by proxy subscribers during subscriber disconnections, but rather store persistent notifications, and deliver valid notifications to subscribers when they reconnect to the system. We show that the proposed solution resolves the observed scalability weakness of the existing solutions.
Abstract: As event-based middleware is currently being applied for application component integration in a range of application areas, a variety of event services have been proposed to address different application requirements. The emergence of ubiquitous computing systems has given rise to application integration across multiple areas and as a result, has led to systems comprising several, independently operating event services. Even though event services are based on the same communication pattern, application component integration across heterogeneous services is typically prevented by the constraints imposed by their respective event models. This paper presents the design and implementation of the Federated Event Service (FES). The FES enables heterogeneous event services to cooperate and to operate as a single logical service. It therefore facilitates building event-based systems in which the application requirements cannot be met by a single event service.
Abstract: Publish Subscribe Systems route events to interested subscribers through a distributed network of routing tables. We present a self-stabilizing algorithm that maintains these routing tables in a consistent distributed state, and recovers from faults in the network. Neighboring message routers (or brokers) periodically exchange their routing table state, and take corrective actions if (and only when) necessary. We formally prove that the resulting algorithm brings the system back to a legal global state if it starts out in a faulty state. Further, we show how to reduce the size of the periodic message exchanges by exchanging sketches of the routing tables which are much smaller than the routing tables themselves. We present a message size/accuracy tradeoff of using these sketches, which are based on Bloom filters. We have simulated our algorithm, and present our results of studying the important special case of a transient edge failure in greater detail.
Abstract: We present the algorithms for achieving service guar-antees in the SMILE distributed relational publish-subscribe system in the presence of lost or reordered messages due to broker and/or link failures. SMILE extends the content-based publish-subscribe paradigm by allowing subscribers to request continually updated derived views, specified as relational algebraic (SQL-like) expressions over published event histories. The SMILE system performs compile-time analysis of subscriptions, and generates tailored code for com-puting incremental state updates, and for detecting and recovering from lost or permuted messages. We exploit: (1) the languages monotonic type system, and (2) a refined service guarantee of eventual correctness. We first present an abstract protocol capturing the common features of all fault detection and recovery pro-tocols implemented in the SMILE prototype. We then de-scribe the specialized protocols for particular relational operators. We discuss potential optimizations and per-formance tradeoffs.
Abstract: In this work we leverage the advantages of the Chord DHT to build a content-based publish-subscribe system that is scalable, self-organizing, and well-performing. However, DHTs provide very good support only for exactmatch, equality predicates and range predicates are expected to be very popular when specifying subscriptions in pub/sub systems We will thus also provide solutions supporting efficiently subscriptions with range predicates in Chord-based pub/sub systems.
Abstract: With the growing size and complexity of software systems, software verification and validation (V&V) is becoming increasingly important. Model checking and testing are two of the main V&V methods. In this paper, we present a framework that allows for testing and formal modeling and analysis to be combined. More precisely, we describe a framework for model checking and testing implicitinvocation software. The framework includes a new programming language the Implicit-Invocation Language (IIL), and a set of formal rule-based transformation tools that allow automatic generation of executable and formal verification artifacts. We evaluate the framework on several small examples. We hope that our approach will advance the state-of-the-art in V&V for event-based systems. Moreover, we plan on using it to explore the relationship between testing and model checking implicit invocation systems and gain insight into their combined benefits.