Configuration Management System Research Articles

How Evolutionary Visual Software Analytics Supports Knowledge Discovery

Evolutionary visual software analytics is a specialization of visual analytics. It is aimed at supporting software maintenance processes by aiding the understanding and comprehension of software evolution with the active participation of users. Therefore, it deals with the analysis of software projects that have been under development and maintenance for several years and which are usually formed by thousands of software artifacts, which are also associated to logs from communications, defect-tracking and software configuration management systems. Accordingly, evolutionary visual software analytics aims to assist software developers and software project managers by means of an integral approach that takes into account knowledge extraction techniques as well as visual representations that make use of interaction techniques and linked views. Consequently, this paper discusses the implementation of an architecture based on the evolutionary visual software analytics process and how it supports knowledge discovery during software maintenance tasks.

Scientific Cluster Deployment and Recovery – Using puppet to simplify cluster management

Deployment, maintenance and recovery of a scientific cluster, which has complex, specialized services, can be a time consuming task requiring the assistance of Linux system administrators, network engineers as well as domain experts. Universities and small institutions that have a part-time FTE with limited time for and knowledge of the administration of such clusters can be strained by such maintenance tasks.This current work is the result of an effort to maintain a data analysis cluster (DAC) with minimal effort by a local system administrator. The realized benefit is the scientist, who is the local system administrator, is able to focus on the data analysis instead of the intricacies of managing a cluster. Our work provides a cluster deployment and recovery process (CDRP) based on the puppet configuration engine allowing a part-time FTE to easily deploy and recover entire clusters with minimal effort.Puppet is a configuration management system (CMS) used widely in computing centers for the automatic management of resources. Domain experts use Puppet's declarative language to define reusable modules for service configuration and deployment.Our CDRP has three actors: domain experts, a cluster designer and a cluster manager. The domain experts first write the puppet modules for the cluster services. A cluster designer would then define a cluster. This includes the creation of cluster roles, mapping the services to those roles and determining the relationships between the services. Finally, a cluster manager would acquire the resources (machines, networking), enter the cluster input parameters (hostnames, IP addresses) and automatically generate deployment scripts used by puppet to configure it to act as a designated role. In the event of a machine failure, the originally generated deployment scripts along with puppet can be used to easily reconfigure a new machine.The cluster definition produced in our CDRP is an integral part of automating cluster deployment in a cloud environment. Our future cloud efforts will further build on this work.

Centralized Fabric Management Using Puppet, Git, and GLPI

Managing the infrastructure of a large and complex data center can be extremely difficult without taking advantage of recent technological advances in administrative automation. Puppet is a seasoned open-source tool that is designed for enterprise class centralized configuration management. At the RHIC and ATLAS Computing Facility (RACF) at Brookhaven National Laboratory, we use Puppet along with Git, GLPI, and some custom scripts as part of our centralized configuration management system. In this paper, we discuss how we use these tools for centralized configuration management of our servers and services, change management requiring authorized approval of production changes, a complete version controlled history of all changes made, separation of production, testing and development systems using puppet environments, semi-automated server inventory using GLPI, and configuration change monitoring and reporting using the Puppet dashboard. We will also discuss scalability and performance results from using these tools on a 2,000+ node cluster and 400+ infrastructure servers with an administrative staff of approximately 25 full-time employees (FTEs).

Why Isn’t Model Analysis Integrated with Versioning?

This position paper discusses the idea of integrating model analysis with configuration management systems to enforce certain quality properties of models under version control. 1. THE IDEA OF CHECKING DELTAS Large parts of software engineering is nowadays covered by modeling. Modeling is widely used for specification of software, sometimes models are interpreted at system runtime, and for some domains it is even possible to completely generate software from models. Models provide the opportunity to enhance software quality. Before the software is derived from the models, they can be checked for certain properties such as security requirements. Furthermore on model level one can easily analyze the compliance to legal or technical regulations, e.g. when auditing a business process. If the models evolve, the quality properties have to be checked over and over again for each new revision of a model. Especially in case of exhaustive analyses such as business process auditing the re-verification becomes very expensive. Hence, it would be wise to narrow down the model analysis to the portion of the model that has actually changed (i.e. the delta). Besides reducing the costs of verification, the results might become more clear since the scope of analysis is more precise and found violations are probably more comprehensive for the user. Furthermore, the reduction to delta analysis allows us to integrate the model analysis into configuration management systems (CMS) that are used for versioning the models. In that case, each new revision of a model can immediately be verified and violating states could be rejected by the versioning system.

Answering software evolution questions: An empirical evaluation

ContextDevelopers often need to find answers to questions regarding the evolution of a system when working on its code base. While their information needs require data analysis pertaining to different repository types, the source code repository has a pivotal role for program comprehension tasks. However, the coarse-grained nature of the data stored by commit-based software configuration management systems often makes it challenging for a developer to search for an answer. ObjectiveWe present Replay, an Eclipse plug-in that allows developers to explore the change history of a system by capturing the changes at a finer granularity level than commits, and by replaying the past changes chronologically inside the integrated development environment, with the source code at hand. MethodWe conducted a controlled experiment to empirically assess whether Replay outperforms a baseline (SVN client in Eclipse) on helping developers to answer common questions related to software evolution. ResultsThe experiment shows that Replay leads to a decrease in completion time with respect to a set of software evolution comprehension tasks. ConclusionWe conclude that there are benefits in using Replay over the state of the practice tools for answering questions that require fine-grained change information and those related to recent changes.

Convergence of the Records Management and Enterprise Content Management in the Digital Environment

This study addresses the effects of the transformation experienced following the introduction of enterprise content management system configuration in the digital environment. The scope of this study comprises the integration of the opportunities provided by digital environment with the information management systems having different contents, including the information systems for administrative, financial and customer relations, the applications of enterprise communication, e-mail, records and archive management developed particularly from 1990s onwards, and the development of approaches to enterprise content management (ECM). In this study, descriptive method is used and the data were obtained through literature review. This study demonstrates that the relationship between records management and ECM applications is linear, and that there is a tendency for integrated systems oriented towards content management in the digital environment, which eventually lead to the convergence of independent enterprise information systems.

회전익기 다품종부품 개발을 위한 형상관리 체계

Medium size rotorcraft consist of approximately 5,000 key components. The components must satisfy the target weight and performance requirement through optimization. Therefore a rotorcraft component has approximately 100 times higher unit cost for mass production than the equivalent of an automobile's, along with huge development cost. Configuration management consists of four main parts : configuration identification, configuration control, configuration audit, and data management. In development programme, configuration management is one of the methods to save development cost, and setting a well-structured configuration management system according to the Military Standard is an important factor in success of the programme. The paper proposes a configuration management system suitable for development of various multi-use components development and presents that the configuration management was performed successfully during dual-use component development programme using the established system.

Integrating the SysML and the SystemC-UML profiles in a model-driven embedded system design flow

Modern embedded systems development, due to systems complexity and multifaceted nature, requires flexible high-level design techniques and notations. In this context, model-driven approaches are gaining popularity, both in industry as well as in academy, since they offer a high degree of abstraction and provide a common framework for the design, simulation and configuration management of complex heterogeneous systems. Moreover, a great variety of languages have been emerging as customization (or profiles) of the Unified Modeling Language (UML) for the embedded system and System-on-Chip (SoC) domains. No single modeling language or profile is adequate to cover aspects and requirements of the whole system development flow. Indeed, each of these languages owns characteristics and offers modeling primitives suitable for designing at a specific abstraction level. Therefore, possible strategies for integrating such UML profiles must be determined, in order to establish a common modeling framework able to support all steps of a system design development. This paper presents the integration of two modeling languages, the SysML and the SystemC UML profiles. The integration is based on a mapping from the SysML to the SystemC UML profile for the structural aspects, while for the behavioral aspects two main models of computation, SysML control-flow graphs and SystemC Process state machines, are proposed as complementary behavioral formalisms to be adopted in a model-driven SoC design flow at platform-independent and platform-specific description level, respectively. The integration we propose, has enabled us also to refine an already defined model-driven hardware-software co-design flow, where a gap remained moving from a platform-independent design level to a platform-specific level. The refined co-design flow starts from a SysML description at a high level of design abstraction, and proceeds through a chain of refined SystemC UML models, to lower levels of design abstraction, where the more complex last-level SystemC coding is left to automation.

MOD2-SCM: A model-driven product line for software configuration management systems

ContextSoftware Configuration Management (SCM) is the discipline of controlling the evolution of large and complex software systems. Over the years many different SCM systems sharing similar concepts have been implemented from scratch. Since these concepts usually are hard-wired into the respective program code, reuse is hardly possible. ObjectiveOur objective is to create a model-driven product line for SCM systems. By explicitly describing the different concepts using models, reuse can be performed on the modeling level. Since models are executable, the need for manual programming is eliminated. Furthermore, by providing a library of loosely coupled modules, we intend to support flexible composition of SCM systems. MethodWe developed a method and a tool set for model-driven software product line engineering which we applied to the SCM domain. For domain analysis, we applied the FORM method, resulting in a layered feature model for SCM systems. Furthermore, we developed an executable object-oriented domain model which was annotated with features from the feature model. A specific SCM system is configured by selecting features from the feature model and elements of the domain model realizing these features. ResultsDue to the orthogonality of both feature model and domain model, a very large number of SCM systems may be configured. We tested our approach by creating instances of the product line which mimic wide-spread systems such as CVS, GIT, Mercurial, and Subversion. ConclusionThe experiences gained from this project demonstrate the feasibility of our approach to model-driven software product line engineering. Furthermore, our work advances the state of the art in the domain of SCM systems since it support the modular composition of SCM systems at the model rather than the code level.

Don't Install Software by Hand

An IT system's setup and configuration affects developers mainly due to the proliferation and complexity of Internet-facing systems. Fortunately, we can control and conquer this complexity by adopting IT-system configuration management tools. By stipulating that all modifications to a system's configuration can only be performed through its configuration management system and by treating the system's rules as code, an organization ensures that the IT systems it delivers to its clients are not inscrutable monoliths that just happen to work but documented modular engines that work by design.

Security configuration management in intrusion detection and prevention systems

This paper aims to study the impact of security enforcement levels on the performance and usability of an enterprise information system. We develop a new analytical model to investigate the relationship between the Intrusion Detection and Prevention System performance and the rules mode selection. In particular, we analyze the IDPS rule-checking process along with its consequent action on the resulting security of the network and on the average service time per event. Simulation was conducted to validate our performance analysis study. The results demonstrate that it is desirable to strike a balance between system security and network performance.

Configuration Management Using Dependency Analysis of Software Change Visibility

Software configuration management is a field of managing sets of large scale software outputs to be the basis of the software products. Configuration management has significantly improved for the past few years, yet new system is still required. Instead of using previous methods or researching about configuration management, professional management of developing project is needed. Therefore, techniques such as storage model for configuration management, management program for change procedure and management of program interface is needed. In this paper, we provide storage for configuration management and implement decision-making system to manage divided program and interface. Thus, we propose a new access method by the configuration management dependency. This paper provides configuration management for developing software to verify and classify using decision-making system for the change and combination of independent components with high dependency.

A standard-based data model for configuration management and maintenance support

The goal of this paper is to define a data model for configuration management and maintenance, taking into account the whole life cycle of assets. First step was to review the systems related to configuration management checking the utilization of standards and norms which are connected in a practical way, and looking for the relationship of the different possible data models used for configuration management systems. A definition of data model is presented organized in 9 layers of information and it is applied in an use case where is checked the problems of the data model with the purpose of improve it.

소프트웨어 형상관리 시스템과 개인 작업공간 통합 기반 산출물 의존 관계 추적성 개선 기법

The ability to trace change history and dependency relations of software artifacts which are continuously changed has been recognized as an important factor that support quality management activities such as verification, validation, and testing in software system development process. General software configuration management systems provide tracing information for artifacts only within the configuration management system, and it does not go further to changes that occur within personal workspace. This paper provides a solution that helps tracing down not only changes of configuration items but also change history of artifacts existent in personal workspace through the integration of configuration management system and personal workspace. Furthermore, in cases of artifacts which are included in a configuration item, this paper provides a solution that support tracing dependency relations between the artifacts by identifying their version links. For the integration of configuration management system and personal workspace, a revision of configuration item is connected to the artifact`s version of the workspace by the tagging mechanism, and traceability for change history and dependency relations of artifacts can be managed more effectively through integrated change process.

Model-driven software engineering: concepts and tools for modeling-in-the-large with package diagrams

Model-driven software engineering intends to reduce development effort by generating executable code from high-level models. However, models for non-trivial problems are still very large and require sophisticated support for modeling-in-the-large--a challenge which has not yet gained sufficient attention in model-driven software engineering. In response to this need, we have developed a set of tools for modeling-in-the-large based on UML package diagrams. The tool set comprises a stand-alone tool, which serves as a graphical editor for package diagrams, an integration tool, which controls the consistency of the model with its architecture defined in the package diagram, and a metrics tool, which is used to measure the coupling of model packages. Our tools for modeling-in-the-large complement the functionality of an environment for model-driven software engineering which so far has focused on supporting modeling-in-the-small. The overall environment has been applied successfully in a project which is dedicated to model-driven engineering of a product line for software configuration management systems.

Safety, Configuration and Battery Management System of Tata Indica Vista EV

not Available.

Online Capacity Identification of Multitier Websites Using Hardware Performance Counters

Understanding server capacity is crucial to system capacity planning, configuration, and QoS-aware resource management. Conventional stress testing approaches measure server capacity offline in terms of application-level performance metrics like response time and throughput. They are limited in measurement accuracy and timeliness. In a multitier website, resource bottleneck often shifts between tiers as client access pattern changes. This makes the problem of online capacity measurement even more challenge. This paper presents an online measurement approach based on low-level hardware performance metrics such as instructions execution rate and cache access behavior. Such metrics together define a system internal running state. The measurement approach uses machine learning techniques to infer application-level performance at each tier from a set of selected hardware performance counters. A coordinated predictor is induced over individual tier-wide models to make global system performance prediction and identify the bottleneck when the system becomes overloaded. Experiments were conducted on a two-tier Tomcat/MySQL-configured website using TPC-W benchmarks. Experimental results demonstrated that this approach was able to achieve an overload prediction accuracy of higher than 90 percent for a priori known input traffic mix and over 85 percent accuracy even for traffic causing frequent bottleneck shifting. It costs less than 0.5 percent runtime overhead for data collection and no more than 50 ms for each online decision making.

System engineering approach in the EU Test Blanket Systems Design Integration

The complexity of the Test Blanket Systems demands diverse and comprehensive integration activities. Test Blanket Modules – Consortia of Associates (TBM-CA) applies the system engineering methods in all stages of the Test Blanket System (TBS) design integration. Completed so far integration engineering tasks cover among others status and initial set of TBS operating parameters; list of codes, standards and regulations related to TBS; planning of the TBS interfaces and baseline documentation. Most of the attention is devoted to the establishment the Helium-Cooled Lithium Lead (HCLL) and Helium-Cooled Pebble Bed Lead (HCPB) TBS configuration baseline, TBS break down into sub-systems, identification, definition and management of the internal and external interfaces, development of the TBS plant break down structure (PBS), establishment and management of the required TBS baseline documentation infrastructure. Break down of the TBS into sub-systems that is crucial for the further design and interfaces’ management has been selected considering several options and using specific evaluation criteria. Process of the TBS interfaces management covers the planning, definition and description, verification and review, non-conformances and deviations, and modification and improvement processes. Process of interfaces review is developed, identifying the actors, input, activities and output of the review. Finally the relations and interactions of system engineering processes with TBM configuration management and TBM-CA Quality Management System are discussed.

NixOS: A purely functional Linux distribution

AbstractExisting package and system configuration management tools suffer from animperative model, where system administration actions such as package upgrades or changes to system configuration files are stateful: they destructively update the state of the system. This leads to many problems, such as the inability to roll back changes easily, to deploy multiple versions of a package side-by-side, to reproduce a configuration deterministically on another machine, or to reliably upgrade a system. In this paper we show that we can overcome these problems by moving to apurely functional system configuration model. This means that all static parts of a system (such as software packages, configuration files and system startup scripts) are built by pure functions and are immutable, stored in a way analogous to a heap in a purely functional language. We have implemented this model inNixOS, a non-trivial Linux distribution that uses theNix package managerto build the entire system configuration from a modular, purely functional specification.

Extending self-healing in grid environment by pulse monitoring

The increasing complexity of Grid services and systems demands larger human effort for system configuration and performance management. The physical management of these systems is not only tedious but also error-prone. Inherently, effective monitorin