A Generic Deployment Framework for Grid Computing and Distributed Applications

Deployment of distributed applications on large systems, and especially on grid infrastructures, becomes a more and more complex task. Grid users spend a lot of time to prepare, install and configure middleware and application binaries on nodes, and eventually start their applications. The problem is that the deployment process is composed of many heterogeneous tasks that have to be orchestrated in a specific correct order. As a consequence, the automatization of the deployment process is currently very difficult to reach. To address this problem, we propose in this paper a generic deployment framework allowing to automatize the execution of heterogeneous tasks composing the whole deployment process. Our approach is based on a reification as software components of all required deployment mechanisms or existing tools. Grid users only have to describe the configuration to deploy in a simple natural language instead of programming or scripting how the deployment process is executed. As a toy example, this framework is used to deploy CORBA component-based applications and OpenCCM middleware on one thousand nodes of the French Grid5000 infrastructure.Comment: The original publication is available at http://www.springerlink.co

Rapid Prototyping of Domain-Specific Architecture Languages

International audienceSoftware architecture has become a sensitive discipline, which consists in concretizing the user requirements into a set of artifacts that can be used to model and reason about the software to be developed. However, the architect often relies on its own knowledge to map domain-specific requirements onto generic software abstractions. Most of the time, this leads to the definition of repetitive tasks and architecture fragments, which can be particularly error prone. We therefore believe that architects need a more flexible approach to cope with the definition of domain-specific architectures by leveraging general purpose architecture description languages. This paper introduces the FraSCAla framework as an architectural framework that can be used to rapidly prototype and experiment domain-specific ADLs in order to catalyze the definition and to improve the reliability of software architectures. We demonstrate the merits of this approach on two case studies that illustrate component-based architectures exhibiting various categories of architectural patterns

Vers un environnement multi personnalités pour la configuration et le déploiement d'applications à base de composants logiciels

La multiplication des langages de description d'architectures, des modèles et des plates-formes de composants pose un sérieux dilemme aux architectes d'applications à base de composants logiciels. D'un côté, ils doivent choisir un langage pour exprimer des configurations concrètes qui seront déployées automatiquement sur des plates-formes d'exécution. D'un autre côté, ils désirent capitaliser leurs architectures logicielles indépendamment des langages de description et des plates-formes d'exécution. Pour résoudre ce problème, nous proposons un environnement multi personnalités pour la configuration et le déploiement d'applications à base de composants logiciels. Celui-ci est constitué d'un noyau central capturant un modèle canonique de configuration et de déploiement et d'un ensemble de personnalités adaptées aux langages et aux plates-formes. Cet article décrit l'architecture de cet environnement et discute des personnalités pour les modèles de composants CORBA et Fractal. –––––The multiplication of architecture description languages, component models and platforms implies a serious dilemma for component based software architects. On the one hand, they have to choose a language to describe concrete configurations which will be automatically deployed on execution platforms. On the other hand, they wish to capitalize their software architectures independently of any description languages or platforms. To solve this problem, we propose a multi personalities environment for the configuration and the deployment of component based applications. This environment is composed of a core capturing a canonical model of configuration and deployment, and a set of personalities tailored to languages and platforms. This paper details the architecture of such an environment and describes the personalities for the CORBA and Fractal component models

Towards Model-Driven Validation of Autonomic Software Systems in Open Distributed Environments

New distributed systems are running onto fluctuating environments (e.g. ambient or grid computing). These fluctuations must be taken into account when deploying these systems. Autonomic computing aims at realizing programs that implement self-adaptation behaviour. Unfortunately in practice, these programs are not often statically validated, and their execution can lead to emergent undesirable behaviour. In this paper, we argue that static validation is mandatory for large autonomic distributed systems. We identify two kinds of validation that are relevant and crucial when deploying such systems. These validations affect the deployment procedures of software composing a system, as well as the autonomic policies of this system. Using our Dacar model-based framework for deploying autonomic software distributed architectures, we show how we tackle the problem of static validation of autonomic distributed system

Applying OMG D&C Specification and ECA Rules for Autonomous Distributed Component-based Systems

Manual administration of complex distributed applications is almost impossible to achieve. On one side, work in autonomic computing focuses on systems that are able to maintain themselves, driven by high-level policies. Such a selfadministration relies on the concept of a control loop. On the other side, modeling is currently used to ease design of complex distributed systems. Nevertheless, at runtime, models remain useless, because they are decoupled from the running system which is subject to dynamic changes. The autonomic computing control loop involves an abstract representation of the system used to analyze the situation and to adapt the application properly. Our proposition, named Distributed Autonomous Component-based ARchitectures (Dacar), introduces models in the control loop. Using adequate models into the control loop, it is possible to design both the distributed systems and their evolution policies, and to execute them. The metamodel suggested in our work mixes both OMG Deployment and Configuration specification and the Event-Condition-Action (ECA) metamodels. This paper treats the different concerns that are present in the control loop and focuses on the concepts of the metamodel that are needed to express entities of the control loop. It also gives an overview of the current Dacar prototype and illustrated it on an ubiquitous application example

Leveraging Component-Based Software Engineering with Fraclet

International audienceComponent-based software engineering has achieved wide acceptance in the domain of software engineering by improving productivity, reusability and composition. This success has also encouraged the emergence of a plethora of component models. Nevertheless, even if the abstract models of most of lightweight component models are quite similar, their programming models can still differ a lot. This drawback limits the reuse and composition of components implemented using different programming models. The contribution of this article is to introduce Fraclet as a programming model com- mon to several lightweight component models. This programming model is presented as an annotation framework, which allows the developer to annotate the program code with the elements of the abstract component model. Then, using a generative approach, the annotated program code is completed according to the programming model of the component model to be supported by the component runtime environment. This article shows that this annotation framework provides a significant simplification of the program code by removing all dependencies on the component model interfaces. These benefits are illustrated with the Fractal and OpenCOM component models

Molecular Mechanisms Underlying Hepatocellular Carcinoma

Hepatocarcinogenesis is a complex process that remains still partly understood. That might be explained by the multiplicity of etiologic factors, the genetic/epigenetic heterogeneity of tumors bulks and the ignorance of the liver cell types that give rise to tumorigenic cells that have stem cell-like properties. The DNA stress induced by hepatocyte turnover, inflammation and maybe early oncogenic pathway activation and sometimes viral factors, leads to DNA damage response which activates the key tumor suppressive checkpoints p53/p21Cip1 and p16INK4a/pRb responsible of cell cycle arrest and cellular senescence as reflected by the cirrhosis stage. Still obscure mechanisms, but maybe involving the Wnt signaling and Twist proteins, would allow pre-senescent hepatocytes to bypass senescence, acquire immortality by telomerase reactivation and get the last genetic/epigenetic hits necessary for cancerous transformation. Among some of the oncogenic pathways that might play key driving roles in hepatocarcinogenesis, c-myc and the Wnt/β-catenin signaling seem of particular interest. Finally, antiproliferative and apoptosis deficiencies involving TGF-β, Akt/PTEN, IGF2 pathways for instance are prerequisite for cancerous transformation. Of evidence, not only the transformed liver cell per se but the facilitating microenvironment is of fundamental importance for tumor bulk growth and metastasis