Formal Service-Oriented Development of Fault Tolerant Communicating Systems (original) (raw)
Related papers
Formal Service-Oriented Development of Fault Tolerant Systems
Telecommunication systems should have a high degree of availability, i.e., high probability of correct and timely provision of requested services. To achieve this, correctness of software for such systems and system fault tolerance should be ensured. Application of formal methods helps us to gain confidence in building correct software. However, to be used in practice, formal methods should be well integrated into existing development process. In this paper we propose a formal model-driven approach to development of communicating systems. Essentially our approach formalizes and extends Lyra -a top-down service-oriented method for development of communicating systems. Lyra is based on transformation and decomposition of models expressed in UML2. We formalize Lyra in the B Method by proposing a set of formal specification and refinement patterns reflecting the essential models and transformations of the Lyra service specification, decomposition and distribution phases. Moreover, we extend Lyra to integrate reasoning about fault tolerance in the entire development flow.
Formal Model-Driven Development of Communicating Systems
2005
Telecommunicating systems should have a high degree of availability, i.e., high probability of correct and timely provision of requested services. To achieve this, correctness of software for such systems should be ensured. Application of formal methods helps us to gain confidence in building correct software. However, to be used in practice, the formal methods should be well integrated into existing development process. In this paper we propose a formal model-driven approach to development of communicating systems. Essentially our approach formalizes Lyra – a top-down service-oriented method for development of communicating systems. Lyra is based on transformation and decomposition of models expressed in UML2. We formalize Lyra in the B Method by proposing a set of formal specification and refinement patterns reflecting the essential models and transformations of Lyra. The proposed approach is illustrated by a case study.
Model-driven development has gained increasing acceptance in the engineering community. Via abstraction and gradual model transformation, it offers an efficient way to cope with complexity of modern software-intensive systems, typical examples of which are distributed telecommunicating systems and communication protocols. However, variety of models representing the system structure and behaviour from different viewpoints and at different levels of abstraction raise the question of model consistency and their adherence to the predefined architectural rules. In this paper we formalize a development flow of distributed telecommunicating systems and communication protocols as an architectural profile in UML. We specify and formally verify this profile. The profile allows us to check adherence of models to the predefined architectural rules. Furthermore, by formalizing and verifying intra-and interconsistency rules, we ensure that the models do not contradict to each other. We use the B Method as our formal framework. The presented work establishes a basis for automating model-driven development of telecommunicating systems and communication protocols.
Modelling Fault Tolerance and Parallelism in Communicating Systems
Telecommunication systems should have a high degree of availability, i.e., high probability of correct provision of requested services. To achieve this, correctness of software for such systems and system fault tolerance should be ensured. In this paper we show how to formalise and extend Lyra -a top-down service-oriented method for development of communicating systems. In particular, we focus on integration of fault tolerance mechanisms into the entire Lyra development flow.
Towards Service-Based Systems Engineering: Formalizing and µ-Checking Service Specifications
Using graphical description techniques for the modeling of distributed reactive systems is especially useful in the early phases like requirements engineering. There, often a trial-and-error approach is applied to develop a first system specification. Thus, even there a precise meaning of those description techniques is necessary to check for consistency and completeness of a service-oriented description of the requirements. We introduce a formal semantics for the scenario-based graphical language Chisel. We show how this formalization can be directly applied to model checking service specifications without the need for an explicit operational system model thus supporting the development of complete and consistent service descriptions.
Service based Software Specification
2003
Nowadays the term of a "service" is frequently used in the discipline of modelling distributed system. However, it seems that the meaning of a service varies, depending on the domain it is used in. In this article we describe what various perceptions of the term "service" have in common and derive a formally founded definition of services that helps to
Structured Formalization of Service-Oriented Specifications
2009 16th Annual IEEE International Conference and Workshop on the Engineering of Computer Based Systems, 2009
We present and formalize concepts for the structured specification of system behavior based on services. Services are patterns of interaction between reactive components, thus supporting especially the development of distributed systems. We introduce a core set of concepts for the specification of basic services as well as for the combination of those to complex functionality. The result is an expressive mechanism for structured behavioral specifications. While basically independent from specific notations, we demonstrate the application of those concepts using (High-level) Message Sequence Charts and Mode Diagrams for the specification of services and their combination. We illustrate the approach using a simple telephone system as a running example.
A Model-Driven Approach to Service Orchestration
2008 IEEE International Conference on Services Computing, 2008
Software systems based on Service-Oriented Architectures (SOAs) promise high flexibility, improved maintainability, and simple re-use of functionality. A variety of languages and standards have emerged for working with SOA artifacts; however, service computing still lacks an effective and intuitive model-driven approach starting from models written in an established modeling language like UML and, in the end, generating comprehensive executable code. In this paper, we present a conservative extension to the UML2 for modeling service orchestrations at a high level of abstraction, and a fully automatic approach for transforming these orchestrations down to the wellknown Web Service standard BPEL.
Towards service-based systems engineering: Formalizing and µ-checking service descriptions
Using graphical description techniques for the modeling of distributed reactive systems is especially useful in the early phases like requirements engineering. There, often a trial-and-error approach is applied to develop a first system specification. Thus, even there a precise meaning of those description techniques is necessary to check for consistency and completeness of a service-oriented description of the requirements. We introduce a formal semantics for the scenario-based graphical language Chisel. We show how this formalization can be directly applied to model checking service specifications without the need for an explicit operational system model thus supporting the development of complete and consistent service descriptions.
The object-oriented paradigm is widely applied in designing and implementing communication systems. The Unified Modeling Language (UML) is a standard language used to model the design of object-oriented systems. A protocol state machine is a UML adopted diagram that is widely used in designing communication protocols. It has two key attractive advantages over traditional finite-state-machines: modeling concurrency and modeling nested hierarchical states. In a distributed communication system, each entity of the system has its own protocol that defines when and how the entity exchanges messages with other communicating entities in the system. The order of the exchanged messages must conform to the overall service specifications of the system. In object-oriented systems, both the service and the protocol specifications are modeled in UML protocol state machines. Protocol specification synthesis methods have to be applied to automatically derive the protocol specification from the service specification. Otherwise, a time-consuming process of design, analysis, and error detection and correction has to be applied iteratively until the design of the protocol becomes error-free and consistent with the service specification. Several synthesis methods are proposed in the literature for models other than UML protocol state machines, and therefore, because of the unique features of the protocol state machines, these methods are inapplicable to services modeled in UML protocol state machines. In this paper, we propose a synthesis method that automatically synthesizes the protocol specification of distributed protocol entities from the service specification, given that both types of specifications are modeled in UML protocol state machines. Our method is based on the latest UML version (UML2.3), and it is proven to synthesize protocol specifications that are syntactically and semantically correct. As an example application, the synthesis method is used to derive the protocol specification of the H.323 standard used in Internet calls.