Runtime enforcement techniques are introduced in the literature to cope with the failures that occur while software is being executed in its target environment. These techniques may also offer diagnosis and recovery actions to respectively identify the causes of the failures and to heal them. Since the development of runtime enforcement techniques can be complex, error-prone and costly, runtime enforcement frameworks are proposed to ease the development process. To this aim, these frameworks support various languages to specify the desired properties of software, to express the necessary diagnosis rules for detecting the causes of failures, and to define the recovery strategies. Based on the specifications, runtime enforcement frameworks generate code and integrate it with the software to be verified and/or healed. The code is usually generated in the same language that is used to implement the software, or in an intermediate language that abstracts the software. Unfortunately, the specification languages employ the elements of the programming languages of the generated code, and therefore, they fall short in representing the runtime enforcement concepts naturally. By the term concept we mean a fundamental abstraction or definition that exists in most runtime enforcement techniques. As a result, implementation of runtime enforcement concepts may suffer from scattering and tangling. This reduces the modularity and compose-ability of the specifications of runtime enforcement concepts. Moreover, adoption of the elements of the underlying languages in specifications causes the specifications to become too specific to the employed programming languages and platforms. This reduces the reusability and comprehensibility of the specifications, and increases their complexity. To facilitate a natural representation of runtime enforcement concepts, this thesis introduces a computation model termed as Event Composition Model, which respects the characteristic features of the runtime enforcement concepts. This computation model offers a set of novel linguistic abstractions, called events, event modules, reactors, reactor chains, event composition language and event constraint language. Events represent changes in the states of interest. Event modules are means to group events, have input- output interfaces, and implementations. Reactors are the implementations of event modules. Reactor chains are groups of related reactors that process events in a sequence. The event composition language facilitates selecting the events of interest; and the event constraint language facilitates defining constraints among reactors or event modules. An important issue is how to implement Event Composition Model effectively, by using current programming languages. For this purpose, the thesis evaluates the relevant programming languages with respect to their support for implementing Event Composition Model. The evaluation reveals that none of the existing languages can implement the model such that the desired quality attributes, such as modularity, abstractness and compose-ability are accomplished. Nevertheless, aspect-oriented languages offer promising features for this matter. The thesis introduces the EventReactor language, as the successor of the Compose* aspect-oriented language, that implements Event Composition Model. The language is open-ended for new sorts of events and reactor types. This helps to represent new sorts of concepts. It makes use of the Prolog language as its event composition language. Reactors and reactor chains are parameterizable, and are defined separately from event modules. This increases the reusability of event modules and their implementations. The systems of today are more and more implemented using multiple languages and this trend seems to continue also in the near future. The current runtime enforcement frameworks, unfortunately, fall short in supporting software implemented in different programming languages. In Event Composition Model, the event composition language facilitates selecting events from systems implemented in various languages. In the EventReactor language, the specifications are defined independently from any programming language, and the compiler of EventReactor facilitates generating code for Java, C and .Net languages. As a result, the specifications can be reused for software developed in different languages. It is now more and more usual that applications are designed to run on distributed system architectures. Unfortunately, most runtime enforcement frameworks cannot be utilized for distributed systems. There are a few runtime enforcement frameworks that can work with distributed architectures. These systems, however, adopt specifications that contain information about the underlying process structure. This increases the complexity and reduces the reusability of the specifications if the process structure of software changes. The EventReactor language addresses this problem with the support of distribution transparency. There are two basic ways in utilizing the EventReactor language: a) as an underlying language for the specification languages of runtime enforcement frameworks; b) as an implementation language of runtime enforcement techniques. This thesis explains Event Composition Model, its implementation the EventReactor language, and the compiler of this language with the use of illustrative examples. The thesis makes use of an example runtime enforcement technique called Recoverable Process to evaluate the suitability of the EventReactor language in representing the concepts of interest naturally.
|Award date||15 Sep 2011|
|Place of Publication||Enschede|
|Publication status||Published - 15 Sep 2011|
- Event Composition
- Runtime Enforcement