309 research outputs found

    SMT-based Verification of LTL Specifications with Integer Constraints and its Application to Runtime Checking of Service Substitutability

    Full text link
    An important problem that arises during the execution of service-based applications concerns the ability to determine whether a running service can be substituted with one with a different interface, for example if the former is no longer available. Standard Bounded Model Checking techniques can be used to perform this check, but they must be able to provide answers very quickly, lest the check hampers the operativeness of the application, instead of aiding it. The problem becomes even more complex when conversational services are considered, i.e., services that expose operations that have Input/Output data dependencies among them. In this paper we introduce a formal verification technique for an extension of Linear Temporal Logic that allows users to include in formulae constraints on integer variables. This technique applied to the substitutability problem for conversational services is shown to be considerably faster and with smaller memory footprint than existing ones

    Tau Be or not Tau Be? - A Perspective on Service Compatibility and Substitutability

    Get PDF
    One of the main open research issues in Service Oriented Computing is to propose automated techniques to analyse service interfaces. A first problem, called compatibility, aims at determining whether a set of services (two in this paper) can be composed together and interact with each other as expected. Another related problem is to check the substitutability of one service with another. These problems are especially difficult when behavioural descriptions (i.e., message calls and their ordering) are taken into account in service interfaces. Interfaces should capture as faithfully as possible the service behaviour to make their automated analysis possible while not exhibiting implementation details. In this position paper, we choose Labelled Transition Systems to specify the behavioural part of service interfaces. In particular, we show that internal behaviours (tau transitions) are necessary in these transition systems in order to detect subtle errors that may occur when composing a set of services together. We also show that tau transitions should be handled differently in the compatibility and substitutability problem: the former problem requires to check if the compatibility is preserved every time a tau transition is traversed in one interface, whereas the latter requires a precise analysis of tau branchings in order to make the substitution preserve the properties (e.g., a compatibility notion) which were ensured before replacement.Comment: In Proceedings WCSI 2010, arXiv:1010.233

    Service substitution : a behavioral approach based on Petri Nets

    Get PDF
    Service-Oriented Computing is an emerging computing paradigm that supports the modular design of (software) systems. Complex systems are designed by composing less complex systems, called services. Such a (complex) system is a distributed application often involving several cooperating enterprises. As a system usually changes over time, individual services will be substituted by other services. Substituting one service by another one should not affect the correctness of the overall system. Assuring correctness becomes particularly challenging, as the services rely on each other, and each of the involved enterprises only oversees a part of the overall system. In addition, services communicate asynchronously which makes the analysis even more difficult. For this reason, formal methods to support service substitution are indispensable. In this thesis, we study service substitution at the level of service models. Thereby we restrict ourselves to service behavior. As a formalism to model service behavior, we use Petri nets. The first contribution of this thesis is the definition of several substitutability criteria that are suitable in the context of Service-Oriented Computing. Substituting a service S by a service S0 should preserve some behavioral properties of the overall system. For each set of behavioral properties and a given service S, there exists a set of behaviorally compatible services for S. A substitutability criterion defines which of these behaviorally compatible services of S have to be preserved by S0. We relate our substitutability criteria to preorders and equivalences known from process theory. The second contribution of this thesis is to present, for each substitutability criterion, a procedure to decide whether a service S0 can substitute a service S. The decision requires the comparison of the in general infinite sets of behaviorally compatible services for the services S and S0. Hence, we extend existing work on an abstract representation of all behaviorally compatible services for a given service. For each notion of behavioral compatibility, we present an algorithmic solution to represent all behaviorally compatible services. Based on these representations, we can decide substitutability of a service S by a service S0. The third contribution of this thesis is a method to support the design of a service S0 that can substitute a service S according to a substitutability criterion. Our approach is to derive a service S0 from the service S by stepwise transformation. To this end, we present several transformation rules. Finally, we formalize and we extend the equivalence notion for services specified in the language WS-BPEL. That way, we demonstrate the applicability of our work

    Operating guidelines for services

    Get PDF
    In the paradigm of service-oriented computing, companies organize their core competencies as services and may request other functionalities from services of other companies. Services provide high flexibility, platform independent loose coupling, and distributed execution. They may thus help to reduce the complexity of dynamically binding and integrating heterogenous processes within and across organizations. The vision of service-oriented architectures is to provide a framework for publishing new services, for on demand searching for and discovery of existing services, and for dynamically binding services to achieve common business goals. That way, each individual organization gains more flexibility to dynamically react on new challenges. As services may be created or modified, or collaborations may be restructured at any point in time, a new challenge arises in this setting—the challenge for deciding the compatibility of the composed services before their actual binding. Recent literature distinguishes four different aspects of service compatibility: syntactical, behavioral, semantical, and non-functional compatibility. In this thesis, we focus on behavioral compatibility and abstract from the other aspects. Potential behavioral incompatibilities between services include deadlocks (two services wait for a message of each other), livelocks (two services keep exchanging messages without progressing), and pending messages that have been sent but cannot be received anymore. For stateful services that interact via asynchronous message passing, deciding behavioral compatibility is far from trivial. Local changes to one service may introduce errors in some or even all other services of an interaction. The verification of behavioral compatibility suffers from state explosion problems and is restricted by privacy issues. That is, the parties of an interaction are essentially autonomous and may be competitors in other business fields. Consequently, they do not want to reveal the internals of their processes to the other participants in order to hide trade secrets. To systematically approach this challenge, we introduce a formal framework based on Petri nets and automata for service modeling and formalize behavioral compatibility as deadlock freedom of the composition of the services. The main contribution of this thesis is to introduce the concept of the operating guideline of a service. Operating guidelines provide a formal characterization of the set of all behaviorally compatible services R for a given service S. Usually, this set is infinite. However, the operating guideline OGS of a service S serves as a finite representation of this infinite set. Furthermore, the operating guideline of S reveals only internals that are inevitably necessary to decide behavioral compatibility with S. We provide a construction method of operating guidelines for finite-state services with bounded communication. Operating guidelines can be used in many applications in the context of serviceoriented computing. The most fundamental application is to support the discovery of behaviorally compatible services. To this end, we develop a matching procedure that efficiently decides whether a given service R is characterized by the operating guideline OGS of a service S. If R matches, then both services R and S are behaviorally compatible and can be bound together to interact with each other. If R does not match with OGS, then the services are behaviorally incompatible and may run into severe behavioral errors and not reach their common business goal. Operating guidelines can furthermore be applied in the novel research areas of service substitutability and the generation of adapter services, for instance. To this end, we develop methods to compare the sets of services characterized by the operating guidelines OGS and OGS0 . If OGS0 characterizes more services than OGS, then the service S can be substituted by the service S0 without loosing any behaviorally compatible interaction partner R. Furthermore, we show how to synthesize a service R from the operating guideline OGS such that R is behaviorally compatible to S by construction. All results presented in this thesis are implemented in our service analysis tool Fiona. Fiona may compute operating guidelines for services modeled as Petri nets. It may match a service with an operating guideline, compare operating guidelines for equivalence or an inclusion relation, and synthesize service adapters for behaviorally incompatible services. Together with the tool BPEL2oWFN— which translates web services specified in BPEL into Petri net models of the services—we can immediately apply our results to services that stem from practic

    Counter-constrained finite state machines: modelling component protocols with resource-dependencies

    Get PDF
    This report deals with the specification of software component protocols (i.e., the set of service call sequences). The contribution of this report is twofold: (a) We discuss specific requirements of real-world protocols, especially in the presence of components wich make use of limited resources. (b) We define counter-constrained finite state machines (CC-FSMs), a novel extension of finite state machines, specifically created to model protocols having dependencies between services due to their access to shared resources. We provide a theoretical framework for reasoning and analysing CC-FSMs. Opposed to finite state machines and other approaches, CC-FSMs combine two valuable properties: (a) CC-FSMs are powerful enough to model realistic component protocols with resource allocation, usage, and de-allocation dependencies between methods (as occurring in common abstract datatypes such as stacks or queues) and (b) CC-FSMs have a decidabile equivalence- and inclusion problem as proved in this report by providing algorithms for efficient checking equivalence and inclusion. These algorithms directly lead to efficient checks for component interoperability and substitutability. Keywords: software component protocols, finite state machine extension, decidable inclusion check, interoperability, substitutability

    Residential equilibrium in a multifractal metropolitan area

    Get PDF
    A residential location model derived from urban economics is combined with the geometry of a multifractal Sierpinski carpet to represent and model a metropolitan area. This area is made up of a system of built-up patches hierarchically organised around a city centre, and green areas arranged in an inverse hierarchical order (large open-spaces in the periphery). An analytical solution is obtained by using a specific geographic coding system for computing distances. The values of the parameters used in the model are based on the French medium sized metropolitan areas; a realistic benchmark is proposed and comparative-statics simulations are performed. The results show that the French peri-urbanisation process (which took place from 1970 onward) can be explained by an increase in income and a reduction in transport costs. Nevertheless, changes in household preferences, in particular an increased taste for open spaces, can also contribute to urban sprawl by making the gradient of land rents less steep and by making peripheral household locations more desirableperi-urban, residential localisation, fractal geometry, amenities

    Modeling Software Components Using Behavior Protocols

    Get PDF
    This thesis proposes a novel approach for a description of a software component's behavior. The behavior is specified by using behavior protocols - a notation similar to regular expressions, which is easy to read and comprehend

    Checking compatibility and substitutability of software components

    Get PDF
    In component-based systems, two components are compatible if all possible sequences of services requested by one component can be provided by the other component. It has been recently shown that for verification of compatibility, the behavior of interacting components, at their interfaces, can be modeled by labeled Petri nets with labels representing the requested and provided services. Such component models are then composed and the composition operation is designed in such a way that component incompatibilities are manifested as deadlocks in the composed model. Compatibility verification is thus performed through deadlock analysis of the composed models. Component compatibility is also used for the verification of component substitutability; if the new component is compatible with all components that interact with the old component, it can safely replace the old one

    Assembly of components based on interface automata and {UML} component model

    No full text
    International audienceWe propose an approach which combines component UML model and interface automata in order to assemble components and to verify their interoperability. We specify component based system architecture with component UML model, and component interfaces with interface automata. Interface automata is a common Input Output (I/O) automata-based formalism intended to specify the signature and the protocol level of component interfaces. We improve interface automata approach by component UML model, in order to consider system architecture, in component composition and interoperability verification methods. Therefore, we handle in interface automata, the connection between components, and the hierarchical connections between composite components and their subcomponents
    • …
    corecore