15 research outputs found
Preliminary Results Towards Contract Monitorability
This paper discusses preliminary investigations on the monitorability of
contracts for web service descriptions. There are settings where servers do not
guarantee statically whether they satisfy some specified contract, which forces
the client (i.e., the entity interacting with the server) to perform dynamic
checks. This scenario may be viewed as an instance of Runtime Verification,
where a pertinent question is whether contracts can be monitored for adequately
at runtime, otherwise stated as the monitorability of contracts. We consider a
simple language of finitary contracts describing both clients and servers, and
develop a formal framework that describes server contract monitoring. We define
monitor properties that potentially contribute towards a comprehensive notion
of contract monitorability and show that our simple contract language satisfies
these properties.Comment: In Proceedings PrePost 2016, arXiv:1605.0809
Monitoring for Silent Actions
Silent actions are an essential mechanism for system modelling and specification. They are used to abstractly report the occurrence of computation steps without divulging their precise details, thereby enabling the description of important aspects such as the branching structure of a system. Yet, their use rarely features in specification logics used in runtime verification. We study monitorability aspects of a branching-time logic that employs silent actions, identifying which formulas are monitorable for a number of instrumentation setups. We also consider defective instrumentation setups that imprecisely report silent events, and establish monitorability results for tolerating these imperfections
A theory of monitors
We develop a behavioural theory for monitors — software entities that passively analyse the runtime behaviour of systems so as to infer properties about them. First, we extend the monitor language and instrumentation relation of [17] to handle piCalculus process monitoring. We then identify contextual behavioural preorders that allow us to re-late monitors according to criteria defined over monitored executions of piCalculus processes. Subsequently, we develop alternative monitor pre-orders that are more tractable, and prove full-abstraction for the latter alternative preorders with respect to the contextual preorders.peer-reviewe
A Foundation for Runtime Monitoring
Runtime Verification is a lightweight technique that complements other
verification methods in an effort to ensure software correctness.
The technique poses novel questions to software engineers: it is not easy to
identify which specifications are amenable to runtime monitoring, nor is it
clear which monitors effect the required runtime analysis correctly.
This exposition targets a foundational understanding of these questions.
Particularly, it considers an expressive specification logic (a syntactic
variant of the mmucalc) that is agnostic of the verification method used,
together with an elemental framework providing an operational semantics for the
runtime analysis performed by monitors.
The correspondence between the property satisfactions in the logic on the one
hand, and the verdicts reached by the monitors performing the analysis on the
other, is a central theme of the study.
Such a correspondence underpins the concept of monitorability, used to identify
the subsets of the logic that can be adequately monitored for by RV.
Another theme of the study is that of understanding what should be expected of a
monitor in order for the verification process to be correct.
We show how the monitor framework considered can constitute a basis whereby
various notions of monitor correctness may be defined and investigated
A foundation for runtime monitoring
Runtime Verification is a lightweight technique that complements other verification methods in an effort to ensure software correctness. The technique poses novel questions to software engineers: it is not easy to identify which specifications are amenable to runtime monitor-ing, nor is it clear which monitors effect the required runtime analysis correctly. This exposition targets a foundational understanding of these questions. Particularly, it considers an expressive specification logic (a syntactic variant of the modal ÎĽ-calculus) that is agnostic of the verification method used, together with an elemental framework providing an operational semantics for the runtime analysis performed by monitors. The correspondence between the property satisfactions in the logic on the one hand, and the verdicts reached by the monitors performing the analysis on the other, is a central theme of the study. Such a correspondence underpins the concept of monitorability, used to identify the subsets of the logic that can be adequately monitored for by RV. Another theme of the study is that of understanding what should be expected of a monitor in order for the verification process to be correct. We show how the monitor framework considered can constitute a basis whereby various notions of monitor correctness may be defined and investigated.peer-reviewe
The Best a Monitor Can Do
Existing notions of monitorability for branching-time properties are fairly restrictive. This, in turn, impacts the ability to incorporate prior knowledge about the system under scrutiny - which corresponds to a branching-time property - into the runtime analysis. We propose a definition of optimal monitors that verify the best monitorable under- or over-approximation of a specification, regardless of its monitorability status. Optimal monitors can be obtained for arbitrary branching-time properties by synthesising a sound and complete monitor for their strongest monitorable consequence. We show that the strongest monitorable consequence of specifications expressed in Hennessy-Milner logic with recursion is itself expressible in this logic, and present a procedure to find it. Our procedure enables prior knowledge to be optimally incorporated into runtime monitors
If At First You Don't Succeed: Extended Monitorability through Multiple Executions
This paper investigates the observational capabilities of monitors that can
observe a system over multiple runs. We study how the augmented monitoring
setup affect the class of properties that can be verified at runtime, focussing
on branching-time properties expressed in the modal mu-calculus. Our results
show that the setup can be used to systematically extend previously established
monitorability limits. We also prove bounds that capture the correspondence
between the syntactic structure of a branching-time property and the number of
system runs required to conduct the verification
On the Monitorability of Session Types, in Theory and Practice
Software components are expected to communicate according to predetermined protocols and APIs. Numerous methods have been proposed to check the correctness of communicating systems against such protocols/APIs. Session types are one such method, used both for static type-checking as well as for run-time monitoring. This work takes a fresh look at the run-time verification of communicating systems using session types, in theory and in practice. On the theoretical side, we develop a formal model of session-monitored processes. We then use this model to formulate and prove new results on the monitorability of session types, defined in terms of soundness (i.e., whether monitors only flag ill-typed processes) and completeness (i.e., whether all ill-typed processes can be flagged by a monitor). On the practical side, we show that our monitoring theory is indeed realisable: we instantiate our formal model as a Scala toolkit (called STMonitor) for the automatic generation of session monitors. These executable monitors can be used as proxies to instrument communication across black-box processes written in any programming language. Finally, we evaluate the viability of our approach through a series of benchmarks
Preliminary results towards contract monitorability
This paper discusses preliminary investigations on the monitorability of contracts for web service descriptions. There are settings where servers do not guarantee statically whether they satisfy some specified contract, which forces the client (i.e., the entity interacting with the server) to perform dynamic checks. This scenario may be viewed as an instance of Runtime Verification, where a pertinent question is whether contracts can be monitored for adequately at runtime, otherwise stated as the monitorability of contracts. We consider a simple language of finitary contracts describing both clients and servers, and develop a formal framework that describes server contract monitoring. We define monitor properties that potentially contribute towards a comprehensive notion of contract monitorability and show that our simple contract language satisfies these properties.peer-reviewe
Reliability and fault-tolerance by choreographic design
Distributed programs are hard to get right because they are required to be open, scalable, long-running,
and tolerant to faults. In particular, the recent approaches to distributed software based on (micro-)services where different services are developed independently by disparate teams exacerbate the
problem. In fact, services are meant to be composed together and run in open context where unpredictable behaviours can emerge. This makes it necessary to adopt suitable strategies for monitoring
the execution and incorporate recovery and adaptation mechanisms so to make distributed programs
more flexible and robust. The typical approach that is currently adopted is to embed such mechanisms
in the program logic, which makes it hard to extract, compare and debug. We propose an approach
that employs formal abstractions for specifying failure recovery and adaptation strategies. Although
implementation agnostic, these abstractions would be amenable to algorithmic synthesis of code,
monitoring and tests. We consider message-passing programs (a la Erlang, Go, or MPI) that are
gaining momentum both in academia and industry. Our research agenda consists of (1) the definition
of formal behavioural models encompassing failures, (2) the specification of the relevant properties of
adaptation and recovery strategy, (3) the automatic generation of monitoring, recovery, and adaptation
logic in target languages of interest.peer-reviewe