36 research outputs found
A Formal Semantics for the SmartFrog Configuration Language
System configuration languages are now widely used to drive the deployment and evolution of large computing infrastructures. Most such languages are highly informal, making it difficult to reason about configurations, and introducing an important source of failure. We claim that a more rigorous approach to the development and specification of these languages will help to avoid these difficulties and bring a number of additional benefits. In order to test this claim, we present a formal semantics for the core of the SmartFrog configuration language. We demonstrate how this can be used to prove important properties such as termination of the compilation process. To show that this also contributes to the practical development of clear and correct compilers, we present three independent implementations, and verify their equivalence with each other, and with the semantics. Supported by an extended example from a real configuration scenario, we demonstrate how the process of developing the semantics has improved understanding of the language, highlighted problem areas, and suggested alternative interpretations. This leads us to advocate this approach for the future development of practical configuration languages
Automated planning for cloud service configurations
The declarative approach has been widely accepted as an appropriate way to manage configurations of large scale systems – the administrators describe the specification
of the “desired” configuration state of the system, and the tool computes and executes
the necessary actions to bring the system from its current state into this desired state. However, none of state-of-the-art declarative configuration tools make any guarantees
about the order of the changes across the system involved in implementing configuration changes.
This thesis presents a technique that addresses this issue – it uses the SFP language to allow administrators to specify the desired configuration state and the global
constraints of the system, compiles the specified reconfiguration task into a classical
planning problem, and then uses an automated planning technique to automatically
generate the workflow. The execution of the workflow can bring the system into the desired state, while preserving the global constraints during configuration changes.
This thesis also presents an alternative approach to deploy the configurations – the
workflow is used to automatically choreograph a set of reactive agents which are capable to autonomously reconfigure a computing system into a specified desired state.
The agent interactions are guaranteed to be deadlock/livelock free, can preserve pre-specified global constraints during their execution, and automatically maintain the desired state once it has been achieved (self-healing).
We present the formal semantics of SFP language, the technique that compiles SFP
reconfiguration tasks to classical planning problems, and the algorithms for automatic
generation and execution of the reactive agent models. In addition, we also present
the formal semantics of core subset of SmartFrog language which is the foundation
of SFP. Moreover, we present a domain-independent technique to compile a planning problem with extended goals into a classical planning problem.
As a proof of concept, the techniques have been implemented in a prototype configuration tool called Nuri, which has been used to configure typical use-cases in cloud
environment. The experiment results demonstrate that the Nuri is capable of planning and deploying the configurations in a reasonable time, with guaranteed constraints on
the system throughout reconfiguration process
Two ways to Grid: the contribution of Open Grid Services Architecture (OGSA) mechanisms to service-centric and resource-centric lifecycles
Service Oriented Architectures (SOAs) support service lifecycle tasks, including Development, Deployment, Discovery and Use. We observe that there are two disparate ways to use Grid SOAs such as the Open Grid Services Architecture (OGSA) as exemplified in the Globus Toolkit (GT3/4). One is a traditional enterprise SOA use where end-user services are developed, deployed and resourced behind firewalls, for use by external consumers: a service-centric (or ‘first-order’) approach. The other supports end-user development, deployment, and resourcing of applications across organizations via the use of execution and resource management services: A Resource-centric (or ‘second-order’) approach. We analyze and compare the two approaches using a combination of empirical experiments and an architectural evaluation methodology (scenario, mechanism, and quality attributes) to reveal common and distinct strengths and weaknesses. The impact of potential improvements (which are likely to be manifested by GT4) is estimated, and opportunities for alternative architectures and technologies explored. We conclude by investigating if the two approaches can be converged or combined, and if they are compatible on shared resources
Rehearsal: A Configuration Verification Tool for Puppet
Large-scale data centers and cloud computing have turned system configuration
into a challenging problem. Several widely-publicized outages have been blamed
not on software bugs, but on configuration bugs. To cope, thousands of
organizations use system configuration languages to manage their computing
infrastructure. Of these, Puppet is the most widely used with thousands of
paying customers and many more open-source users. The heart of Puppet is a
domain-specific language that describes the state of a system. Puppet already
performs some basic static checks, but they only prevent a narrow range of
errors. Furthermore, testing is ineffective because many errors are only
triggered under specific machine states that are difficult to predict and
reproduce. With several examples, we show that a key problem with Puppet is
that configurations can be non-deterministic.
This paper presents Rehearsal, a verification tool for Puppet configurations.
Rehearsal implements a sound, complete, and scalable determinacy analysis for
Puppet. To develop it, we (1) present a formal semantics for Puppet, (2) use
several analyses to shrink our models to a tractable size, and (3) frame
determinism-checking as decidable formulas for an SMT solver. Rehearsal then
leverages the determinacy analysis to check other important properties, such as
idempotency. Finally, we apply Rehearsal to several real-world Puppet
configurations.Comment: In proceedings of ACM SIGPLAN Conference on Programming Language
Design and Implementation (PLDI) 201
µPuppet: A Declarative Subset of the Puppet Configuration Language
Puppet is a popular declarative framework for specifying and managing complex
system configurations. The Puppet framework includes a domain-specific language
with several advanced features inspired by object-oriented programming,
including user-defined resource types, 'classes' with a form of inheritance,
and dependency management. Like most real-world languages, the language has
evolved in an ad hoc fashion, resulting in a design with numerous features,
some of which are complex, hard to understand, and difficult to use correctly.
We present an operational semantics for Puppet, a representative subset
of the Puppet language that covers the distinctive features of Puppet, while
excluding features that are either deprecated or work-in-progress. Formalising
the semantics sheds light on difficult parts of the language, identifies
opportunities for future improvements, and provides a foundation for future
analysis or debugging techniques, such as static typechecking or provenance
tracking. Our semantics leads straightforwardly to a reference implementation
in Haskell. We also discuss some of Puppet's idiosyncrasies, particularly its
handling of classes and scope, and present an initial corpus of test cases
supported by our formal semantics.Comment: Full version of ECOOP 2017 conference pape
On the Integration of Automatic Deployment into the ABS Modeling Language
In modern software systems, deployment is an integral and critical part of application development (see, e.g., the DevOps approach to software development). Nevertheless, deployment is usually overlooked at the modeling level, thus losing the possibility to perform deployment conscious decisions during the early stages of development. In this paper, we address the problem of promoting deployment as an integral part of modeling, by focusing on the Abstract Behavioral Specification (ABS) language used for the specification of models of systems composed of concurrent objects consuming resources provided by deployment components. We extend ABS with class annotations expressing the resource requirements of the objects of that class. Then we define a tool that, starting from a high-level declaration of the desired system, computes a model instance of such system that optimally distributes objects over available deployment components
Constraint-based specifications for system configuration
Declarative, object-oriented configuration management systems are widely used, and
there is a desire to extend such systems with automated analysis and decision-making.
This thesis introduces a new formulation for configuration management problems based
on the tools and techniques of constraint programming, which enables automated
decision-making.
We present ConfSolve, an object-oriented declarative configuration language, in
which logical constraints on a system can be specified. Verification, impact analysis,
and the generation of valid configurations can then be performed. This is achieved via
translation to the MiniZinc constraint programming language, which is in turn solved
via the Gecode constraint solver. We formally define the syntax, type system, and
semantics of ConfSolve, in order to provide it with a rigorous foundation. Additionally
we show that our implementation outperforms previous work, which utilised an SMT
solver, while adding new features such as optimisation.
We next develop an extension of the ConfSolve language, which facilitates not
only one-off configuration tasks, but also subsequent re-configurations in which the
previous state of the system is taken into account. In a practical setting one does not
wish for a re-configuration to deviate too far from the existing state, unless the benefits
are substantial. Re-configuration is of crucial importance if automated configuration
systems are to gain industry adoption. We present a novel approach to incorporating
state-change into ConfSolve while remaining declarative and providing acceptable
performance
Domain specific language for deployment of parallel applications on parallel computing platforms
To increase the computing performance the current trend is towards applying parallel computing in which parallel tasks are executed on multiple nodes. The deployment of tasks on the computing platform usually impacts the overall performance and as such needs to be modelled carefully. In the architecture design community the deployment viewpoint is an important viewpoint to support this mapping process. In general the derived deployment views are visual notations that are not amenable for run-time processing, and do not scale well for deployment of large scale parallel applications. In this paper we propose a domain specific language (DSL) for modeling the deployment of parallel applications and for providing automated support for the deployment process. The DSL is based on a metamodel that is derived after a domain analysis on parallel computing. We illustrate the application of the DSL for a traffic simulation system and provide a set of important scenarios for using the DSL. © 2014 ACM