CONICET | Buscador de Institutos y Recursos Humanos

In the new paradigm of Service-Oriented Computing (SOC), the structure of software systems is intrinsically dynamic. In this paradigm, software artefacts run over globally available computational network infrastructures and they rely on external services they may need to procure and bind to at runtime, in order to collectively fulfil certain business goals. Therefore, development is no longer a process in which subsystems are developed and integrated by skilled engineers but a runtime composition of services discovered and bound by a dedicated middleware.In [1] we provided a trace semantics for the service component algebra presented in [2] ? Asynchronous Relational Networks (ARNs) ? that accounted for the fact that, because of runtime discovery and binding, ARNs are reconfigured on demand as the execution reaches the point in which a component is required to continue executing.Our work resorts to the formalisation of services introduced in [3], in terms of hypergraphs whose nodes correspond to structured sets of messages that can be exchanged between the network components attached to that point, and whose hyperedges capture those elements of networks that account for computation and/or communication, i.e. processes and communication channels.The logic ruling the behaviour of components and communication channels, as given in [3,1], is formalised in terms of Muller automata [4], therefore the execution of both, components and communication channels, are prescribed to be infinite, as a consequence of the acceptance condition of this family of automata. That particular choice for the ARNs semantics forces the reconfiguration of a SOC software artefact to be necessarily incremental, thus bound services execute indefinitely accompanying the execution of the activity that triggered the recon- figuration.In this work we explore non-incremental reconfigurations as the result of unbinding services. This situation may be the outcome of: a) the execution of a services whose goal is met in a finite number of steps, and b) the failure of a service to meet its goal.Regarding the first situation, actual services are generally atomic and stateless; and, going further in the conceptual bases of the paradigm, each binding resulting from a discovery triggered by the execution of an activity does not need to be served by the same service as it may not be available at that particular time, or it may not be the best suited for the task. In general, the existing formalisations of services prescribe that services are reactive software artefacts, thus, once a service was bound, it remains bound and there was no notion of termination. To overcome this limitation we propose to model the computational aspects of terminating services as finite state automata such that they coexist in a coherent way with the non-terminating services whose computation is modelled by Muller automata. We call this class of networks Hybrid ARNs.The second situation emerges from the fact that the execution of communi- cating software systems, running over a falible communication infrastructure is likely to experience errors derived from the temporal unavailability of a given service bound to the executing software. SOC in the real world need to cope with this kind of errors as an absolute minimum fault tolerance criterion. Our proposal is to adapt the formal framework allowing the traces of a Hybrid ARN to include spontaneous ?structure-decreasing? transitions from one state to another.These transitions are simple from the point of view of the transformation suffered by the network but, at the same time, they give rise to the question of to which state of the system it should transition to after the detection of the failure. We explore several answers to this question determining a family of rollback policies, depending on how aggressive the rollback is, and how computationally complex is to calculate better solutions.