Rulecore

Rulecore is a research project investigating the use of different technologies to create software that support ACTIVE behavior.

The aim of the project is to transfer knowledge from the academic community into a commercial software product and services. The project contributes to some extent to academic research too.

The Rulecore project draws its IDeaS mainly from a number of academic research areas:

• Active Databases, Event-Condition-Action (ECA) rules specially.
• Simulation
• Network event correlation
• Complex Event Processing (CEP)
• The Semantic Web
• Multi sensor fusion

The aims of the project is to investigate how a loosely coupled component can be added to existing IT infrastructure in order to provide active capabilities.

Active capabilities are defined, in the scope of the project, as the ability to detect and react immediately to a complex situation consisting of multiple events. The complex situation is defined using ideas created by research within the active database community during 90's.

Although immediate reaction is a goal, the ruleCore implementation lacks any real-time features. Processing is performed on a best effort basis without any timing guarantees.

The Rulecore server uses slightly different programming interface model than traditional server software. Traditional programming interfaces (API) uses a request/replay paradigm for interacting with clients. The API is normally accessed using a programming language such as Java, Perl or C#. Clients interact with Rulecore purely using high level XML events. The Rulecore server is an event sink and an event generator. This model of interaction is not common and is a research topic for future software components. The claim is that high level access using events CREATES software components which are more easily re-used than software with traditional APIs. Although this approach comes With It own set of problems such lower performance and synchronization and correlation issues. Future research are conducted to assert the viability of this approach.

In order to provide a coherent and easy to understand architecture a event-driven architecture is used internally in Rulecore. The aim is to try to avoid shifting paradigms when passing the Rulecore external interface. As the Rulecore interface is event-driven an event-driven architecture is used internally. Thus external and internal events can be managed in the same way. Future research is done in resolving synchronization issues caused by the loosely coupled component architecture.

RuleCore uses active rules based on ideas from the active database research conducted in the 90s. The active database research invented the concept of active ECA (Event-Condition-Action) rules. The concept used in ruleCore is based on this research but modified and improved upon to be suitable in a message/event driven environment. It also improves in many areas on the initial research prototypes proposed in projects such as Snoop and ODE.

The Rulecore software is available freely for research and the GPL licensed source code is available on Sourceforge. The results of the project are described continuously in academic papers and reports. The Rulecore project has also contributed to EU funded research projects.