YANCEES: Yet ANother Configurable Extensible Event Service
|
|
YANCEES: Yet ANother Configurable Extensible Event Service |
|
| Concepts: | Principles | | Design |
| System: | Implementation | | Documentation | |
In this project, we study the use of configurable and extensible component frameworks to provide versatility to event notification services (a.k.a. publish/subscribe infrastructures). Our goal is to support the development of application-specific publish/subscribe infrastructures in the support of different collaborative applications and to study the trade-offs involved in the construction and use of such infrastructures. Current industrial and research infrastructures strive to support application domain variability and evolution by adopting different strategies: Build new publish/subscribe infrastructures from scratch to support novel requirement sets; provide minimal generalized publish/subscribe cores such as Siena, Elvin or Scribe; provide one-size-fits-all variable infrastructures as CORBA-NS or READY and, more recently, adopt flexible (configurable and extensible) compositional approaches as the case with DREAM, FACET, GREEN and YANCEES.
YANCEES is a versatile component framework that allows the construction of application-specific publish/subscribe infrastructures by supporting the customization and extension of its feature set. Examples of such extensions include advanced event subscriptions with event correlation, alternate notification policies (push and pull), infrastructure protocols for mobile applications integration, and ad-hoc P2P protocols; end-user protocols such as event source location and browsing, event persistence services, fast routing cores, and many others. YANCEES configurability and extensibility is achieved by the use of extensible languages and plug-ins installed along main publish/subscribe design dimensions (event, publication, subscription, routing, notification and protocol models).
YANCEES has been used to support different applications such as Impromptu, vavoom, and some experiments with contextual collaboration. More recently, we are comparing YANCEES compositional approach with other versatility approaches in an empirical study of middleware versatility trade-offs.
Generality. One way to minimize the impact of dependencies, their configuration management costs, and incompatibility problems is the use of generalization. Central features such as the event format, which changes can virtually impact all other variability dimensions, need to be generalized. As such, In YANCEES, the default event model is represented by a tuple-based (attribute/value) abstraction, and the default subscription model is content-based. Generalization broadens reuse, requiring fewer adaptations of existing plug-ins (for the few cases where these models do not apply). As a rule, we use stabilty (the ratio between incoming and the total dependencis of a design dimension) as the criteria for selecting the dimension to generalize.
The application of these principles come with extra configuration management and customization overheads. In order to address these issues, the following strategies are adopted:
Automation of user interaction and infrastructure built process (static variability management). Even though the different concerns of publish/subscribe systems can be separated into different variability dimensions. It is usually the case that these concerns are not completely orthogonal. In other words, changes in one dimension may affect other dimensions. For example, content-based subscription is directly dependent on the event representation; advanced event processing as sequence detection, is dependent on the guarantees the routing protocols and the subscription algorithm does not change the order of the events; repeated events removal is highly dependent on timing. Hence, dependencies between components in each variability dimensions need to be documented and enforced.
Hence, without automation, the process of configuring and
building a versatile
infrastructure can become tedious and error-prone.
In YANCEES, configuration managers and dynamic parsers are used to
integrate and
automatically load user-required features, supporting the management
of feature dependencies, preventing inconsistent configurations and
allowing the runtime construction of user-tailored subscriptions.
Hence, differently from other systems such as
Siena or CORBA-NS where the user needs to navigate through a hierarchy
of
objects in order to assemble subscriptions, YANCEES strives to simplify
the
user interaction with the infrastructure through the use of
subscription and notification languages
that express the queries in the event model.
Dynamism (dynamic variability management). Publish/subscribe infrastructures are inherently interactive. Subscriptions are user-defined logical expressions defined based on the capabilities of the service. In order to support interactivity, the runtime loading and assembling of features is used as a binding mechanism of the features. This strategy not only copes with configurability and customization, by also supports simultaneous feature sets in the same infrastructure, for example: content-based and fast topic-based subscriptions. It also supports a more rational allocation of resources: features are loaded on demand, copying with more restricted environments such as PDAs.
Yancees
incorporates these principles and strategies in a component framework illustrated as
follows: the core components are extended and configured with plug-ins,
filters and adapters (different components for each variation
dimension). Subscription and notification models are defined according
to extensible languages, that guide the process of runtime composition
of subscription and notification plug-ins. Existing publish/subscribe
infrastructures such as Siena or Elvin can be reused as routing
components (or overlays). These components are integrated
according to a configuration file (architecture description) that checks
for coherent composition of plug-ins. The resulting infrastructure is
loaded, supporting the combined features.
Internally, YANCEES is a framework that combines:
1. Dynamic parsers that allocate plug-ins according to user-provided subscriptions subscription and notification commands.
2. Input and output publication filters as a way to intercept event publication and implement global policies and filters.
3. Special static plug-ins that implement services, for example: mDNS and persistence
4. Configuration managers, dynamic parsers and builders that orchestrate the integration of different components at load time and runtime.
5. Adapters that can support existing publish/subscribe infrastructures, for ex: Siena, Elvin and custom-made cores
6. A component framework that provides interfaces and composition rules on the different variation points.
The
YANCEES prototype was
implemented and tested with Java (J2SDK1.4.2 and WSDP1.2 - which
provides XMLSchema validation support for the DOM parser). Currently,
the framework supports
the core mechanisms presented in the previous sections: input and
output filters, subscription, notification and protocol plug-ins, and
shared services, which can be configured at boot time with the use of
configuration description files. The system was ported to work using
Siena and
Elvin. It also supports our own fast topic-based dispatcher. The
communication between client stubs and the
server
is implemented using Java RMI protocol.
The
following plug-ins are
implemented: event sequence
detection, pull and push notification policies, polling protocol, a
simple
persistence service (in memory), a fast multiplexer dispatcher
(topic-based), and many other features.
The
service is multi threaded and
supports many simultaneous subscriptions and publications as
non-blocking operations. Input and output buffers were implemented to
improve overall throughput and performance.
More current source code is available
in the CVS
repository.
Examples,
installation
instructions, user
manual and configurations are under construction at the YANCEES
manual page (under construction).
This
software is distributed
according to the following LICENSE.TXT.
This software was tested with J2SDK1.4.2
and
Java API for XML processing available at SUN
WSDP1.2 (web services pack) or higher.
For your
convenience, we provide some examples of YANCEES bundled in different
configurations. Those bundles include only a Yancees-SNAPSHOT.jar file
with the publisher and subscriber source codes. windows and
Unix shell
scripts are provided as well as the configuration file used to
customize YANCEES.
Minimal YANCEES:
(August 2006 snapshot)
Configured with a fast switch core, the subscription language has only
one command, <require>,
which filters messages with the specified attribute name.
Siena YANCEES:
(August 2006 snapshot)
Configured with Siena as the routing core, it provides Siena
configuration language with an extra sequence detector plug-in. This is
the version used in our example above.
June 8th 2004 - The third stable public release of the YANCEES prototype is available. Previous releases can be downloaded here. The Java implementation of the prototype can be downloaded as follows:
This version supports:
Roberto
Silveira Silva Filho
Irvine, CA. March 18th, 2004.
| 2007 - Silva Filho, R. S. and D. F. Redmiles. Managing Feature Interaction by Documenting and Enforcing Dependencies in Software Product Lines. in proceedings of the 9th International Conference on Feature Interactions in Software and Communication Systems. pp.39-54, Grenoble, France, September 3-5, 2007. |
| 2005 - Silva Filho
R. S., |
| 2005 - Silva Filho R. S., Redmiles D. F. A Survey of Versatility for Publish/Subscribe Infrastructures. Technical Report UCI-ISR-05-8. University of California, Irvine, May 2005. |
| 2004 - Silva Filho R. S., Redmiles D. F. Preserving Versatility in Event-based Middleware. Technical Report UCI-ISR-04-7. University of California, Irvine, October 2004. |
| 2004 - Silva Filho R. S., De Souza C. R. B., Redmiles D. F. Design and Experiments with YANCEES, a Versatile Publish-Subscribe Service. Technical Report UCI-ISR-04-1. University of California, Irvine, April 2004. |
| 2003 - Silva Filho R. S., De Souza C. R. B., Redmiles D. F. The Design of a Configurable, Extensible and Dynamic Notification Service. in Proc. Second International Workshop on Distributed Event-Based Systems (DEBS'03), In conjunction with The ACM SIGMOD/PODS Conference, San Diego, CA, USA, June 8th, 2003. |
Additional materials |
| Slides from the ICFI 2007 conference are available here. |
| |
| Slides from the SEM 2005 workshop are available here. |
| Slides from the DEBS 2003 workshop are available here. |
| |
| YANCEES Flyer
presented in the
ISR Internal Workshop, June 2005 is available here. |
| |
| YANCEES Poster presented in the ISR Internal Workshop, June 2004 is available here. |
This research has been sponsored by NSF (grants 0133749, 0205724, 0326105, 0527729,0524033), an IBM Eclipse technology exchange grant, and the Intel Corporation.
