We demonstrate a new customizable toolchain for validating Kubernetes manifests. The toolchain supports multiple types of validation, including validations against JSON schema, Kubernetes built-in rules, best practices, and custom business rules expressed in Common Expression Language (CEL). It also enables the detection of inconsistencies within a defined set of rules. The main goal is to highlight the value of each validation type and demonstrate how their combination improves the robustness of Kubernetes manifests, ensuring reliable deployments.

Distributed systems can be subject to various kinds of partial failures, therefore building fault-tolerance or failure mitigation mechanisms for distributed systems remains an important domain of research. In this paper, we present a calculus to formally model distributed systems subject to crash failures with recovery. The recovery model considered in the paper is weak, in the sense that it makes no assumption on the exact state in which a failed node resumes its execution, only its identity has to be distinguishable from past incarnations of itself. Our calculus is inspired in part by the Erlang programming language and in part by the distributed $π$-calculus with nodes and link failures (D$π$F) introduced by Francalanza and Hennessy. In order to reason about distributed systems with failures and recovery we develop a behavioral theory for our calculus, in the form of a contextual equivalence, and of a fully abstract coinductive characterization of this equivalence by means of a labelled transition system semantics and its associated weak bisimilarity. This result is valuable for it provides a compositional proof technique for proving or disproving contextual equivalence between systems.

In the context of Network Functions Virtualization (NFV), telecommunication systems are more and more deployed on the cloud, using orchestration engines such as OpenStack Heat. Heat takes as input templates that describe the components of the target system and automatically performs the deployment. This prevents consumers of cloud services from handling the challenges of manual deployment. However, deploying such systems remains challenging. Indeed, the templates given to Heat may contain errors that can lead to a failed or a partial deployment, thus compromising the systems reliability. To handle this challenge, we propose a formal approach and a tool for the verification of templates consistency prior to launching their deployment. A case study is presented to validate the approach.

SUMMARY ThetextitService Component Architecture (SCA) is a technology‐independent standard for developing distributed Service‐oriented Architectures (SOA). The SCA standard promotes the use of components and architecture descriptors, and mostly covers the lifecycle steps of implementation and deployment. Unfortunately, SCA does not address the governance of SCA applications and provides no support for the maintenance of deployed components. This article covers this issue and introduces the F RA SCA TI platform, a run‐time support for SCA with dynamic reconfiguration capabilities and run‐time management features. This article presents the internal component‐based architecture of the F RA SCA TI platform, and highlights its key features. The component‐based design of the F RA SCA TI platform introduces many degrees of flexibility and configurability in the platform itself and it can host the SOA applications. This article reports on micro‐benchmarks highlighting that run‐time manageability in the F RA SCA TI platform does not decrease its performance when compared with the de facto reference SCA implementation: Apache T USCANY . Finally, a smart home scenario illustrates the extension capabilities and the various reconfigurations of the F RA SCA TI platform. Copyright © 2011 John Wiley & Sons, Ltd.

Building complex component-based software architectures can lead to subtle assemblage errors. In this paper, we introduce a type-system-based approach to avoid message handling errors when assembling component-based communication systems. Such errors are not captured by classical type systems of host programming languages such as Java or ML. Our approach relies on the definition of a small process calculus that captures the operational essence of our target component-based framework for communication systems, and on the definition of a novel type system that combines row types with process types.

Programming in an open environment remains challenging because it requires combining modularity, security, concurrency, distribution, and dynamicity. In this paper, we propose an approach to open distributed programming that exploits the notion of locality, which has been used in the past decade as a basis for several distributed process calculi such as Mobile Ambients, Dπ, and Seal. We use the locality concept as a form of component that serves as a unit of modularity, of isolation, and of passivation. Specifically, we introduce in this paper Oz/K, a kernel programming language, that adds to the Oz computation model a notion of locality borrowed from the Kell calculus. We present an operational semantics for the language and several examples to illustrate how Oz/K supports open distributed programming.

Many architecture description languages (ADLs) have been proposed to model, analyze, configure, and deploy complex software systems. To face this diversity, extensible ADLs (or ADL interchange formats) have been proposed. These ADLs provide linguistic support for integrating various architectural aspects within the same description. Nevertheless, they do not support extensibility at the tool level, i.e. they do not provide an extensible toolset for processing ADL descriptions. In this paper, we present an extensible toolset for easing the development of architecture-based software systems. This toolset is not bound to a specific ADL, but rather uses a grammar description mechanism to accept various input languages, e.g. ADLs, interface definition languages (IDLs), domain specific languages (DSLs). Moreover, it can easily be extended to implement many different features, such as behavioral analysis, code generation, deployment, etc. Its extensibility is obtained by designing its core functionalities using fine-grained components that implement flexible design patterns. Experiments are presented to illustrate both the functionalities implemented by the toolset and the way it can be extended.

Abstract This paper presents FRACTAL, a hierarchical and reflective component model with sharing. Components in this model can be endowed with arbitrary reflective capabilities, from plain black‐box objects to components that allow a fine‐grained manipulation of their internal structure. The paper describes JULIA, a Java implementation of the model, a small but efficient runtime framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components. The paper presents a qualitative and quantitative evaluation of this implementation, showing that component‐based programming in FRACTAL can be made very efficient. Copyright © 2006 John Wiley & Sons, Ltd.

This paper presents a component-based architecture for autonomous repair management in distributed systems, and a prototype implementation of this architecture, called JADE, which provides repair management for J2EE application server clusters. The JADE architecture features three major elements, which we believe to be of wide relevance for the construction of autonomic distributed systems: (1) a dynamically configurable, component-based structure that exploits the reflective features of the FRACTAL component model; (2) an explicit and configurable feedback control loop structure, that manifests the relationship between the managed system and repair management functions; (3) an original replication structure for the management subsystem itself which makes it fault-tolerant and self-healing.

This paper presents a new distributed process calculus, called the M-calculus, that can be understood as a higher-order version of the Distributed Join calculus with programmable localities. The calculus retains the implementable character of the Distributed Join calculus while overcoming several important limitations: insufficient control over communication and mobility, absence of dynamic binding, and limited locality semantics. The calculus is equipped with a polymorphic type system that guarantees the unicity of locality names, even in presence of higher-order communications -- a crucial property for the determinacy of message routing in the calculus.

The ReTINA project (ACTS AC048) is an industrial collaboration to explore the use of CORBA for the support of real-time multimedia services, from the point of view of network control and from the point of view of middleware services. This paper covers CORBA for network control, and CORBA extensions towards a DPE framework for flexible binding and real-time support.

One of the major requirements of distributed multimedia applications is the need to maintain often complex, real-time synchronization constraints. More specifically, it is necessary to be able to manage arbitrary intra- and inter-media synchronization across activities in the distributed environment. Furthermore, it is important that such developments are integrated into emerging object-oriented standards for distributed computing. This paper presents an object-oriented programming model and associated implementation to meet these requirements. The main concepts behind the proposed approach are, firstly, the use of reactive objects for real-time control and synchronization and, secondly, quality of service controlled bindings for predictable communication between objects. The flexibility of the approach is demonstrated by three contrasting examples of real-time synchronization. The implementation extends the real-time capabilities of the Chorus micro-kernel by introducing the concepts of rtports, rthandlers and quality of service controlled connections. The paper demonstrates how reactive objects and bindings are realized on this infrastructure.

There is currently considerable interest in developing multimedia applications in open distributed systems. However, it is now becoming clear that existing architectures for open distributed systems do not support the particular requirements of continuous media types such as digital audio and video. This is particularly the case in the important areas of quality of service support and real-time synchronization. This paper presents results from the Sumo project which aims at supporting continuous media types within the framework defined by the draft Open Distributed Processing standard. The paper advocates the use of synchronous languages within this framework for specifying and implementing real-time synchronization and QoS monitoring. A computational model and the realization of an infrastructure supporting this view are presented.

The programming of real-time systems with synchronous languages requires an infrastructure support, which we call a "synchronous execution machine". The role of a synchronous execution machine is to manage the interfacing of synchronous programs with their asynchronous environment, while respecting their synchronous semantics. Using the ESTEREL language as an example, we give a formal description of a generic execution machine and we discuss some aspects of its implementation on the Chorus distributed operating system micro-kernel.>

This paper addresses the programming of synchronization in multimedia applications. It briefly introduces multimedia objects and describes a synchronous language model, which yields a rigorous framework for both expressing multimedia object behaviour and supporting the implementation of the related synchronization. A complete programming example is presented and analyzed. Implementation issues are then considered and a simple synchronous execution machine running on top of the Chorus distributed operating system is described.

This paper investigates important quality of service (QOS) parameters which have to be taken into account for the construction of systems handling video representation media. The different existing video compression standards and their coding schemes are analyzed and some elements of choice between the standards according to users' and system QOS requirements are provided.