Search

Complex Event Processing (CEP) is an event-based technology that allows us to process and correlate large data streams in order to promptly detect meaningful events or situations and respond to them appropriately. CEP implementations rely on the so-called Event Processing Languages (EPLs), which are used to implement the specific event types and event patterns to be detected for a particular application domain. To spare domain experts this implementation, the MEdit4CEP approach provides them with a graphical modeling editor for CEP domain, event pattern and action definition. From these graphical models, the editor automatically generates a corresponding Esper EPL code. Nevertheless, the generated code is syntactically but not semantically validated. To address this problem, MEdit4CEP is extended in this paper by Prioritized Colored Petri Net (PCPN) formalism, resulting in the MEdit4CEP-CPN approach. This approach provides both a novel PCPN domain-specific modeling language and a graphical editor. By using model transformations, event pattern models can be automatically transformed into PCPN models, and then into the corresponding PCPN code executable by CPN Tools. In addition, by using PCPNs we can compare the expected output with the actual output and can even conduct a quantitative analysis of the scenarios of interest. To illustrate our approach, we have conducted an air quality level detection case study and we show how this novel approach facilitates the modeling, simulation, analysis and semantic validation of complex event-based systems.

Cloud computing has emerged as a cutting-edge technology which is widely used by both private and public institutions, since it eliminates the capital expense of buying, maintaining, and setting up both hardware and software. Clients pay for the services they use, under the so-called Service Level Agreements (SLAs), which are the contracts that establish the terms and costs of the services. In this paper, we propose the CloudCost UML profile, which allows the modeling of cloud architectures and the users’ behavior when they interact with the cloud to request resources. We then investigate how to increase the profits of cloud infrastructures by using price schemes. For this purpose, we distinguish between two types of users in the SLAs: regular and high-priority users. Regular users do not require a continuous service, so they can wait to be attended to. In contrast, high-priority users require a constant and immediate service, so they pay a greater price for their services. In addition, a computer-aided design tool, called MSCC (Modeling SLAs Cost Cloud), has been implemented to support the CloudCost profile, which enables the creation of specific cloud scenarios, as well as their edition and validation. Finally, we present a complete case study to illustrate the applicability of the CloudCost profile, thus making it possible to draw conclusions about how to increase the profits of the cloud infrastructures studied by adjusting the different cloud parameters and the resource configuration., This work was supported by the Spanish Ministry of Science and Innovation (co-financed by European Union FEDER funds) project “FAME (Formal modeling and advanced testing methods. Applications to medicine and computing systems) and MASSIVE (Engineering adaptive software by and for the people in a highly connected world)”, references RTI2018-093608-B-C32 and RTI2018-095255-B-I00. There was also support from the Junta de Comunidades de Castilla-La Mancha project SBPLY/17/180501/000276/ 01 (cofunded with FEDER funds, EU), the Region of Madrid (grant number FORTE-CM, S2018/TCS-4314), and the Madrid Government (Comunidad de Madrid-Spain) under the Multiannual Agreement with the Complutense University as part of the Program to Stimulate Research for Young Doctors in the context of the V PRICIT (Regional Programme of Research and Technological Innovation) under grant PR65/19-22452

Nowadays, cloud computing technologies are commonly used both by the public and private institutions, so as to save money and computing efforts, by using a network of remote servers hosted on the Internet to manage their services. Thus, cloud clients must interact with cloud providers in order to make use of the services deployed in the cloud, and the cloud infrastructure must be designed taking into account both the physical devices and equipment required (racks, switches, and so on) and also the user demands, expressed in terms of the services they need. This paper focuses on this latter aspect, in which we analyze how cloud clients interact with a cloud provider, providing a Unified Modeling Language-based framework to model a cloud system, including the underlying infrastructure, the user resource requirements, and their interactions with the cloud provider.

In this paper, we present a unified modelling language (UML) framework to model timed Web services with distributed resources. We provide a graphical model of timed Web services that integrates the publish/subscribe paradigm in the context of distributed resources, with the goal that users have a formal framework to design this kind of systems. A formalization is then provided by using UML sequence diagrams with Combined Fragments (CFs) to represent the interactions between the roles involved and Web Services Resource Framework as a standard for the management of distributed resources. The formalization is based on a two-level process algebra. At the top level we have the CF description, and at the bottom the interactions inside them. An operational semantics is then defined for this model, and two case studies are presented to illustrate the applicability of this formalism.

In this paper we present a Timed Automata model for the Publish/Subscribe paradigm in the context of Web Service Compositions with distributed resources, on the basis of an algebraic language inspired by the WSRF standard constructions. This framework allows a set of participants in a Web Service composition to interact with one another and also to manage a collection of distributed resources. The model includes operations for clients to publish, discover and subscribe to resources, so as to be notified when the resource property values fulfill certain conditions (topic-based subscription). Simulation and model-checking techniques can therefore be applied to the obtained network of timed automata, in order to check whether certain properties of interest are satisfied. A specific case study is finally presented to illustrate the model and the verification of the relevant properties on the obtained timed automata model.

Complex event processing (CEP) is a computational intelligence technology capable of analyzing big data streams for event pattern recognition in real time. In particular, this technology is vastly useful for analyzing multicriteria conditions in a pattern, which will trigger alerts (complex events) upon their fulfillment. However, one of the main challenges to be faced by CEP is how to define the quantitative analysis to be performed in response to the produced complex events. In this paper, we propose the use of the MEdit4CEP-CPN model-driven tool as a solution for conducting such quantitative analysis of events of interest for an application domain, without requiring knowledge of any scientific programming language for implementing the pattern conditions. Precisely, MEdit4CEP-CPN facilitates domain experts to graphically model event patterns, transform them into a Prioritized Colored Petri Net (PCPN) model, modify its initial marking depending on the application scenario, and make the quantitative analysis through the simulation and monitor capabilities provided by CPN tools.

UML sequence diagrams are used to graphically describe the message interactions between the objects participating in a certain scenario. Combined fragments extend the basic functionality of UML sequence diagrams with control structures, such as sequences, alternatives, iterations, or parallels. In this paper, we present a UML profile to annotate sequence diagrams with combined fragments to model timed Web services with distributed resources under the publish/subscribe paradigm. This profile is exploited to automatically obtain a representation of the system based on Colored Petri nets using a novel model-to-model (M2M) transformation. This M2M transformation has been specified using QVT and has been integrated in a new add-on extending a state-of-the-art UML modeling tool. Generated Petri nets can be immediately used in well-known Petri net software, such as CPN Tools, to analyze the system behavior. Hence, our model-to-model transformation tool allows for simulating the system and finding design errors in early stages of system development, which enables us to fix them at these early phases and thus potentially saving development costs.

Complex event processing (CEP) is a technology that allows us to process and correlate large volumes of data by using event patterns, aiming at promptly detecting specific situations that could require special treatment. The event types and event patterns for a particular application domain are implemented by using an event processing language (EPL). Although some current model-driven tools allow end users to easily define these patterns, which are then transformed automatically into a particular EPL, the generated code is syntactically but not semantically validated. To deal with this problem, a prioritized colored Petri net (PCPN) model for CEP is proposed and conducted in this paper. This well-known graphical formalism together with CPNTools makes possible the modeling, simulation, analysis, and semantic validation of complex event-based systems. To illustrate this approach, a case study is presented, as well as a discussion on the benefits from using PCPN for modeling CEP-based systems.

Pollution due to road traffic in big cities is an important problem in our society, with consequences for human health. In this paper we deal with this problem, proposing an Intelligent Transportation System (ITS) model based on Complex Event Processes (CEP) technologies and Petri nets that takes into account the levels of environmental pollution according to the air quality levels accepted by the international recommendations. Thus, we are tackling a rather common problem in big cities nowadays, where traffic restrictions must be applied due the pollution. Petri nets are then used in this paper as a tool to make decisions about traffic regulations, so as to reduce pollution levels.

Web services managing distributed resources is a technology that allows the user to have an easier and cheaper mechanism to access and manage distributed resources. Then, the formal modeling of web services with distributed resources becomes very important in order to understand accurately their behavior. In this paper, we present a framework to model these systems by using a widely adopted standard (UML 2.0), enriched with the resource management capabilities, on the basis on WSRF.

A Web Service is a self-describing, self-contained modular application that can be published, located, and invoked over a network, such as the Internet. Web Service composition provides a way to obtain value-added services by combining different existing facilities, which are then able to support the integration of commercial applications. WS-CDL (Web Services Choreography Description Language) is a W3C candidate recommendation for the description of peer-to-peer collaborations by participants in a Web Services composition. This paper focuses on several important aspects of WS-CDL, namely, data variables, timed restrictions, as well as the priorization of collaborations. In WS-CDL there are no priorities, thus, one of our first goals is to provide a WS-CDL definition of prioritized collaborations. We also define a semantics of WS-CDL (with priorities) by means of prioritized-timed colored Petri nets.

We present an approach for the validation and verification of Web services choreographies, and more specifically, for those composite Web services systems with timing restrictions. We use a W3C proposal for the description of composite Web services, WS-CDL (Web Services Choreography Description Language), and we define an operational semantics for a relevant subset of it. We then define a translation of the considered subset of WS-CDL into a network of timed automata, proving that this translation is correct. Finally, we use the UPPAAL tool for the validation and verification of the described system, by using the generated timed automata.

In this paper we introduce a tool called the Web Service Translation tool (WST), which we are developing to implement a methodology for the design, validation and verification of Web Services with timed restrictions. This methodology works by making several translations, from phase to phase in the software development life cycle, where the system is represented at each phase by XML models. We use XSL Transformations (XSLT), which is a language for transforming XML documents. The purpose of these translations is to generate XML code automatically for a Web Service system and to obtain Web Services description models with Timed Automata for validating and verifying composite Web Services with time restrictions.

Web Services composition provides a way to obtain value-added services by combining several Web Services. WS-CDL (Web Services Choreography Description Language) is a W3C candidate recommendation for the description of peer-to-peer collaborations for the participants in a Web Services composition. However, the semantics of WS-CDL is provided in a textual way, and hence a complete rigorous semantics is lacking. In this paper we focus our attention on the WS-CDL elements related to concurrency, as well as on the collaborations that have timing restrictions associated. We then provide an operational semantics for a relevant subset of WS-CDL, paying special attention to timed collaborations. This operational semantics is based on barred terms, which allow us to capture the current state of the choreography throughout its execution.

A Web Service is a self-describing, self-contained modular application that can be published, located, and invoked over a network, e.g. the Internet. Web Services composition provides a way to obtain value-added services by combining several Web Services. The composition of Web Services is, therefore, suitable to support enterprise application integration. WS-CDL (Web Services Choreography Description Language) is a W3C candidate recommendation for the description of peer-to-peer collaborations for the participants in a Web Services composition. In this paper we focus our attention on the development of a methodology for the design and validation of composite Web Services using WS-CDL as the language for describing Web Services interactions and Petri nets as a formalism that allows us to simulate and validate the described systems. We specifically intend, then, to capture timed and prioritized collaborations in composite Web Services, so the model of Petri nets that we use is a prioritized version of Time Petri nets.

In this paper we consider a Timed Automata model for the Publish/Subscribe paradigm, where special attention is given to its temporal aspects. Despite this special interest, we present a generic model for publishing and managing WS-resourses in the context of Web services with distributed resources. The model includes operations for clients to discover and subscribe to resources, with the intention of being notified when the resource property values fulfill certain conditions. Furthermore, error handling is provided in case discovery fails or a resource life has expired. Model-checking is used to verify the model soundness, by means of the UPPAAL tool, and a specific case study is presented to illustrate how the model deals with the scalability problem.

TPALp is an algebraic language for the description of concurrent systems with capabilities to express timed and probabilistic behaviours, as well as urgent interactions. In this paper we present the main features of the language, its operational semantics, and a translation of TPALp terms into a particular class of timed-probabilistic Petri nets. The language includes a probabilistic choice operator, a timed prefix operator, and an urgent prefix operator, as well as some other operators that we may find in classical process algebras. An important feature of the language is that urgency is considered at any instant by executing as many urgent actions as possible, with the goal of complying in a great extent with the urgent actions indicated in the user specifications.

In this paper a Prioritized-Timed Colored Petri Net model for the Publish/Subscribe paradigm in the context of Web services distributed resources is considered. We present a generic CPN model for publishing and managing WS-resources, which includes operations for clients to subscribe to these resources, with the intention of being notified when the resource property values fulfill certain conditions. We use CPN Tools to check and validate the model, and a case study is presented to illustrate how this CPN model works.

Composite Web services technologies are widely used due to their ability to provide interoperability among services from different companies. Web services are usually stateless, which means that no state is stored from the clients viewpoint. However, some new applications and services require to capture the state of some resources after each computation. Thus, new standards to model Web services states have emerged e.g. Web Services Resource Framework (WSRF). In this paper, we present a formal model based on WS-BPEL and WSRF, and we provide a prioritised-timed coloured Petri net semantics for it. This semantics captures the main activities of WS-BPEL, but we also consider other important aspects, both from WS-BPEL and WSRF, such as fault handling, resource management, time-outs and a publish-subscribe system.

We present an algebraic language for the specification of probabilistic and nondeterministic processes, PNAL, which is a probabilistic extension of EPL that maintains nondeterminism.

C-O Diagrams have been introduced as a means to have a visual representation of normative texts and electronic contracts, where it is possible to represent the obligations, permissions and prohibitions of the different signatories, as well as what are the penalties in case of not fulfillment of their obligations and prohibitions. In such diagrams we are also able to represent absolute and relative timing constrains. In this paper we consider a formal semantics for C-O Diagrams based on a network of timed automata and we present several relations to check the consistency of a contract in terms of realizability, to analyze whether an implementation satisfies the requirements defined on its contract, and to compare several implementations using the executed permissions as criteria., In Proceedings FLACOS 2012, arXiv:1209.1699

Web service compositions are gaining increasingly attention for the development of complex web systems by combination of existing ones. In this paper, we present a formal framework that integrates a well-known business process language (BPEL) with a recent technology for describing distributed resources throughout the Internet (WSRF). We define an operational semantics for a language that integrates both approaches taking into account the main features of them, such as notifications, event handling, fault handling and timed constraints.

Choreography languages allow us to describe Web Services compositions from a global viewpoint in Service Oriented Architectures (SOA). However, none of the existing languages has achieved the status of de facto standard for that purpose until now. In this paper we compare three existing proposals to specify Web Services choreographies: WSCI, WS-CDL, and OWL-S. First, we describe the main characteristics of each one of these languages, and after that we compare the different structures of the three languages. Finally, we present some conclusions of our work.

In this work we explain how to perform the design and verification of a Web Services composition with time restrictions using the Web Services Translation tool, WST for short. We pay special attention to Web Services systems with timing restrictions. As illustration, we use a case study called “Form Generator Service”, a system that allows developers to manage a form repository by means of several Web Services. We show how to design this system and the verification of some properties on it, using a Timed Automata representation.

In previous work we have presented the generation of WS-CDL and WS-BPEL documents. In this paper we show the unification of both generations. The aim is to generate correct WS-BPEL skeleton documents from WS-CDL documents by using the Timed Automata as an intermediary model in order to check the correctness of the generated Web Services with Model Checking Techniques. The model checker used is UPPAAL, a well known tool in theoretical and industrial cases that performs the verification and validation of Timed Automata. Note that our interest is focused on Web services where the time constraints play a critical role.

RT-UML is a UML Profile for modeling Real Time Systems, which can be used in particular to describe Web Services Orchestration with time constraints. For that purpose, we can use a classical UML diagram, namely, the sequence diagram. Our goal in this paper is the design of Web Services with time restriction by using RT-UML. We introduce a translation of the main elements of RT-UML into Web Services Business Process Execution Language.

In this paper we present the testing of time goal requirements by using model checking as an engine for test generation. The goal model that we use to capture the time requirements is an extension of KAOS. This goal model specifies the properties that the system must satisfy and how they are tested by using the model checker engine, UPPAAL. As an illustration of this proposal we take a particular study case based on GSM cell technology

In this paper we present an automatic testing process to validate Avionic Systems. To do that, we have developed a tool that interprets scripts written in Automated Test Language and translate them to user codes written in C language. To carry out this work, the syntax of scripts has been defined by a context free grammar. This testing process is based on the execution of a pre-defined set of test cases. Currently, these test sets are obtained from Test Description Document and they are introduced in the system in C code manually. Therefore, automation of this process would reduce the time used for the testing, as a great quantity of tests are realized and a great quantity of errors are made when tests are made by hand.

In this paper we show how we can use the UML Profile for modeling Real Time Systems, which allows us to describe Web Services Choreographies with time constraints. More specifically, we see how by using the diagrams of this profile, we can capture the main elements of a Real-time Web Services Choreography Description Language specification (WS-CDL), which we can then translate into Web Services Choreographies.

In previous work we have presented the generation of WS-CDL and WS-BPEL documents. In this paper we show the unification of both generations. The aim is to generate correct WS-BPEL skeleton documents from WS-CDL documents by using the Timed Automata as an intermediary model in order to check the correctness of the generated Web Services with Model Checking Techniques. The model checker used is UPPAAL, a well known tool in theoretical and industrial cases that performs the verification and validation of Timed Automata. Note that our interest is focused on Web services where the time constraints play a critical role.

In this paper we consider a timed process algebra based on classical LOTOS operators in order to specify the behaviour of concurrent systems and, concretely, those systems for which time becomes an important factor to take into account, such as real-time systems. One of the main goals of this paper is to define a translation into a kind of dynamic state graph, which is currently supported by a tool (TPAL), which allows it to simulate the execution of a specification by means of these dynamic state graphs.

Software engineers work gladly with process algebras, as they are very similar to programming languages. However, graphical models are better in order to understand how a system behaves, and even these graphical models allow us to analyze some properties of the systems. Then, in this paper we present two formalisms for the specification of concurrent systems. On the one hand we present the timed-probabilistic process algebra TPPAL, which is a suitable model for description of systems in which time and probabilities are two important factors to be considered in the description, as it occurs in real-time systems and fault-tolerant systems. Then, the specification written in TPPAL can be automatically translated into a graphical model (the so-called probabilistic dynamic state graphs), which allows us to simulate and evaluate the system. Thus, in this paper we present this translation, which is currently supported by a tool (TPAL).

In this work we describe an approach to deal with systems having at the same time probabilistic and real-time behaviors. The main goal in the paper is to show the automatic translation from a real time model based on UPPAAL tool, which makes automatic verification of Real Time Systems, to the RAPTURE tool, which makes verification of probabilistic systems.Furthermore, this approach allows us to use the best techniques developed in both tools (abstraction, refinement, state space reduction, etc). Finally, this translation is applied to verify a case study, the SET internet protocol.

In this paper we show how we can use formal methods for describing and analyzing the behavior of Web Services, and more specifically those including time restrictions. Then, our starting point are Web Services descriptions written in WSCI – WSCDL (XML-based description languages). These descriptions are then translated into timed automata, and then, we use a well known tool that supports this formalism (UPPAAL) to simulate and analyze the system behavior. As illustration we take a particular case study, a travel reservation system.

We present an algebraic model for the description of concurrent systems with capabilities to express timed and probabilistic behaviours, as well as urgent interactions. This model is based on basic LOTOS, including a probabilistic choice operator, a timed prefix operator for the specification of time intervals where the involved actions are enabled, and a prefix operator for the specification of urgent interactions. An operational semantics for this model is also presented, which is based on the execution of bags. This semantics establishes that processes must always execute as many urgent actions as they can, thus complying in a great extent with the user specifications of urgent actions.

This work presents a new approach to the analysis and verification of the time requirements of Web Services compositions via goal-driven models and model checking techniques. The goal-driven model used is an extension of the goal model KAOS and the model checker engine is the UPPAAL tool. The goal model specifies the properties that the system must satisfy and how they should be verified by using the model checker engine. In order to illustrate this approach, we apply these techniques to a basic Internet purchase process.

It is well known that Petri nets are a very suitable model for the description and analysis of concurrent systems, and several timed extensions of PNs have been defined to specify the behaviour of systems including time restrictions. But some software designers still find it a little difficult to work directly with Petri nets, specially when dealing with large systems, and they prefer to work with a formalism closer to a programming language, such as algebraic specification languages. Our goal, then, in this paper is to present an automatic translation of specifications written in a (timed) algebraic language (TPAL) into a timed model of Petri nets (Timed-Arc Petri nets). In this task we try to exploit as far as possible the special characteristics of Timed-Arc Petri nets, more specifically the presence of dead tokens, which allows us to extend in some particular cases the classical translations.