Generic Architecture of Complex Event Processing Systems

In recent years, there has been a growing need for the use of active systems, systems that are required to respond automatically to events. Examples include applications such as Business Activity Monitoring (BAM) and Business Process Management (BPM). Complex event processing is emerging as a discipline in its own right, with roots in existing research disciplines such as Databases and Software Engineering. This chapter aims at introducing a generic architecture of complex event processing systems that promotes modularity and flexibility. We start with a brief introduction of the primitive elements of complex event processing systems, namely events and rules. We discuss a grid approach to complex event processing systems. We detail the layers of the proposed architecture, as well as the architecture main components within the context of the major data flow in an event management system, namely: event collection, event purification, event storage, event inferencing, and event situation management. We discuss each of these elements in detail. Our tool of choice is the CA Agile Architecture (C3A) reference description approach (Hadar & Silberman, 2008). Throughout the chapter, we illustrate our discussion with two case studies. The first is that of service availability management, providing safeguards to critical business processes. The second involves disaster management, managing early warning systems.

Event-Driven Mobile Computing with Objects

We motivate why event-driven approaches are suitable to address the challenges of mobile and ubiquitous computing. In particular, we describe the beneficial properties of event-based communication in so-called mobile ad hoc networks. However, because contemporary programming languages feature no built-in support for event-driven programming, programmers are often forced to integrate event-driven concepts with a different programming paradigm. In particular, we study the difficulties in combining events with the object-oriented paradigm. We argue that these difficulties form the basis of what we call the object-event impedance mismatch. We highlight the various issues at the software engineering level and propose to resolve this mismatch by introducing a novel object-oriented programming language that supports event-driven abstractions from the ground up.

mTrigger

Location-based triggers are the fundamental capability for supporting location-based advertisements, location-based entertainment applications, personal reminders, as well as presence-based information sharing applications. In this chapter, we describe the design and the implementation of mTrigger, an event-based framework for scalable processing of location-based mobile triggers (location triggers for short). A location trigger is a standing spatial trigger specified with the spatial region over which the trigger is set, the actions to be taken when the trigger conditions are met, and the list of recipients to whom the notification will be sent upon the firing of the location trigger. The mTrigger framework consists of three alternative architectures for supporting location triggers: (1) the client-server architecture, which allows mobile clients to register and install location triggers of interest on the mTrigger server system; the server being responsible for processing location triggers, performing associated actions and sending out notifications upon firing of triggers; (2) the client-centric architecture, which enables mobile users to manage and process location triggers on their own mobile clients; and (3) the decentralized peer-to-peer architecture, which allows mobile users to collaborate with one another in terms of location trigger processing. The server-centric architecture is particularly suitable for supporting public and shared location triggers, enabling effective sharing of location trigger processing among multiple users. The client-centric architecture is more suitable for users possessing mobile clients with high computational capacity and more sensitive to the location privacy of their location triggers. The decentralized peer-to-peer architecture provides on-demand and opportunistic collaboration in terms of location trigger evaluation. Clearly, the performance optimizations for server-centric architecture should focus on efficient and scalable processing of location triggers by reducing the bandwidth consumption and the amount of redundant computation at the server; whereas, the performance optimizations for client-centric architecture and decentralized architecture should also take into account energy efficiency of mobile clients in addition to computational efficiency. In addition, processing of location triggers with moving target of interest requires the knowledge of position information of the moving target and may not be suitable for the client-centric architecture. This chapter will describe the design principles and the performance optimization techniques of the mTrigger framework, including a suite of energy-efficient spatial trigger grouping techniques for optimizing both wake-up times and check times of location trigger evaluations.

Panel

This chapter is a panel discussion in writing. The field of event-based systems finds researchers from a number of different backgrounds: distributed systems, streaming data, databases, middleware, and sensor networks. One of the consequences is that everyone comes to the field with a slightly different mindset and different expectations and goals. In this chapter, we try to capture some of the voices that are influential in our field. Seven panellists from academia and industry were invited to answer and discuss questions about event-based systems. The questions were distributed via email, to which each participant replied their initial set of answers. In a second round every panelist was given the opportunity to expand their statement and discuss the contributions of the other panellists. The questions asked can be grouped into two types. Questions in the first group refer to each participant’s understanding of the basic concepts of event-based systems (EBS), the pros and cons of EBS, typical assumptions of the field and how they understood EBS to fit into the overall landscape of software architectures. The second group of questions pointed to the future of EBS, possible killer applications and the challenges that EBS researchers in academia and industry need to address in the medium and long term. The next section gives each panellist’s initial statements as well as their comments to other participants’ contributions. Each participant’s section starts with a short introduction of the panellist and their work. In the final section, we compare and reflect on the statements and discussions that are presented by the seven panellists.

Mobile Push for Converged Mobile Services

In this chapter, we outline an event-based infrastructure that combines the Session Initiation Protocol (SIP) and Web technologies in order to realize secure converged mobile services. Our main service scenario has been supporting proactive information delivery to airline customers. This application built on top of the infrastructure is designed to help customers in several airport activities, such as check-in and boarding, and to enable highly crowded airports to offer consumer services. We focus on the two key technologies, namely SIP and Web technologies, and outline a distributed system architecture that was developed for the airline scenario. The scenario involves supporting the identification and tracking of users across different networks, enabling proactive information delivery (push) to the devices, and supporting rich multimedia interactions with users. The push system architecture is based on a lightweight access network consists of access points and edge proxies. The edge proxies connect the mobile users to the information backbone in a secure way using TLS or DTLS connections.

Event Processing in Web Service Runtime Environments

Service-oriented Architectures (SOA) and Web services have received a lot of attention from both industry and academia. Services as the core entities of every SOA are changing regularly based on various reasons. This poses a clear problem in distributed environments since service providers and consumers are generally loosely coupled. Using the publish/subscribe style of communication service consumers can be notified when such changes occur. In this chapter, we present an approach that leverages event processing mechanisms for Web service runtime environments based on a rich event model and different event visibilities. Our approach covers the full service lifecycle, including runtime information concerning service discovery and service invocation, as well as Quality of Service attributes. Furthermore, besides subscribing to events of interest, users can also search in historical event data. We show how this event notification support was integrated into our service runtime environment VRESCo and give some usage examples in an application context.

The PADRES Publish/Subscribe System

This chapter introduces PADRES, the publish/subscribe model with the capability to correlate events, uniformly access data produced in the past and future, balance the traffic load among brokers, and handle network failures. The new model can filter, aggregate, correlate and project any combination of historic and future data. A flexible architecture is proposed consisting of distributed and replicated data repositories that can be provisioned in ways to tradeoff availability, storage overhead, query overhead, query delay, load distribution, parallelism, redundancy and locality. This chapter gives a detailed overview of the PADRES content-based publish/subscribe system. Several applications are presented in detail that can benefit from the content-based nature of the publish/subscribe paradigm and take advantage of its scalability and robustness features. A list of example applications are discussed that can benefit from the content-based nature of publish/subscribe paradigm and take advantage of its scalability and robustness features.

StreamMine

StreamMine is a novel distributed event processing system that we are currently developing. It is architected for running on large clusters and uses content-based publish/subscribe middleware for the communication between event processing components. Event processing components need to enforce application-specific ordering constraints, e.g., all events need to be processed in order of some given time stamp. To harness the power of modern multi-core computers, we support the speculative execution of events. Ordering conflicts are detected dynamically and rolled backed using a Software Transactional Memory.

Time/Space Aware Event Correlation

Ubiquitous computing, with a dramatic increase in the event monitoring capabilities of wireless devices and sensors, requires more complex temporal and spatial resolution in event correlation. In this chapter, we describe two aspects of event correlation to support such environments: event modelling including spatio-temporal information, and composite event semantics with interval-based semantics for efficient indexing, filtering, and matching. It includes a comparative study of existing event correlation work. The described durative event model, combined with interval-semantics, provides a new vision for data processing in ubiquitous computing. This makes it possible to extend the functionality of simple publish/subscribe filters to stateful subscriptions, parametrisation, and computation of aggregates, while maintaining high scalability.

Temporal Perspectives in Event Processing

One of the major characteristics of event processing is its strong relationship to the notion of time, yet some of the temporal aspects of event processing still issue challenges to the implementations of event processing tools. This paper provides an overview of the notion of “event processing network” as the underlying model behind event processing; maps the temporal aspects, and discuss each of them. The temporal aspects that are discussed are: temporal dimensions of events, time granularities, temporal context, temporal patterns, event order, and retrospective and proactive operations.