An Experimental, Pluggable Infrastructure for Modular Configuration Management Policy Composition Ronald van der Lingen and André van der Hoek Department of Informatics School of Information and Computer Science University of California, Irvine Irvine, CA 92697-3425 USA {vdlingen,andre}@ics.uci.edu Abstract Building a configuration management (CM) system is a difficult endeavor that regularly requires tens of thou-sands of lines of code to be written. To reduce this effort, several experimental infrastructures have been developed that provide reusable repositories upon which to build a CM system. In this paper, we push the idea of reusability even further. Whereas existing infrastructures only reuse a generic CM model (i.e., the data structures used to cap-ture the evolution of artifacts), we have developed a novel experimental infrastructure, called MCCM, that addition-ally allows reuse of CM policies (i.e., the rules by which a user evolves artifacts stored in a CM system). The key contribution underlying MCCM is that a CM policy is not a monolithic entity; instead, it can be composed from small modules that each address a unique dimension of concern. Using the pluggable architecture and base set of modules of MCCM, then, the core of a desired new CM system can be rapidly composed by choosing appropriate existing modules and implementing any remaining mod-ules only as needed. We demonstrate our approach by showing how the use of MCCM significantly reduces the effort involved in creating several representative CM sys-tems. 1. Introduction Despite the availability of many different CM systems that range in functionality from relatively simple version archives to advanced process-based environments, new CM systems continue to be developed on a regular basis. Some of these systems enter the marketplace, either com-mercially [11,15,22] or as free alternatives [6,8,26]. Oth-ers are developed primarily for in-house use [1,18]. Yet others are academic in nature and explore the boundaries of CM [4,5,8,9]. Unfortunately, designing and implementing a new CM system is difficult [7]. Anecdotal evidence indicates that it regularly takes a minimum of several years and tens of thousands of lines of code to create a fully-functional new CM system. Consider, for instance, the Subversion project [26]. Initiated in May 2000, Subversion now consists of over 100,000 lines of code and has iterated through more than 25 (alpha) releases. It still has a number of issues to be addressed and completion of the project is not expected soon. This is surprising given the modest goal of Subver-sion: to provide a better implementation of CVS that re-solves certain functional deficiencies [27]. Various factors contribute to needing this kind of effort when building a new CM system. Some factors are inher-ent to the CM system being built and cannot be avoided, for instance when a CM system is to contain novel func-tionality. That functionality has to be created from scratch (e.g., one goal of Subversion is to operate securely in dis-tributed settings; goals of other new CM systems include a unique graphical user interface; etc.). Other factors, how-ever, are fundamental to the field at large. In this paper, we focus on one of those fundamental factors: the lack of an effective platform with which CM policies can be com-pactly expressed and (at least partially) reused in the im-plementation of new CM systems. CM policies constitute the rules by which a user evolves the artifacts stored in a CM system. Most CM policies share similar concerns and their implementations are often similar in nature. In Sub-version, for instance, a non-trivial part of its code base reimplements significant parts of the CM policy of CVS. If such common code could be factored out and reused across multiple CM systems, significant savings in terms of time and effort could be achieved. In this paper, we describe MCCM, a new experimental infrastructure that we specifically designed to address this problem. Compared to existing infrastructures [29,32,34], which only support reuse of a generic CM model (i.e., the data structures used to capture the evolution of artifacts), MCCM pushes the idea of reusability further—from justreusing a generic CM model to additionally allowing re-use of critical parts of CM policies. MCCM is based on the key observation that a CM policy is not monolithic; rather, it can be composed from small, reusable modules that each address a unique dimension of concern. Using these modules, the core of a desired new CM system can be rapidly assembled by first choosing an appropriate set of existing modules, then implementing any additional modules as needed, and finally plugging the resulting set of modules into the generic, pluggable, and distributed architecture provided by MCCM. MCCM explicitly distinguishes constraint modules and action modules. Constraint modules plug into the MCCM server (repository) side to maintain, as prescribed by a desired CM policy, the consistency of the CM model. For example, constraint modules may be used to prevent branching or disallow replication of artifacts over multiple repositories. Action modules plug into the MCCM client (workspace) side to, also per the desired policy, enact the rules of that policy. For example, action modules may lock necessary artifacts, or determine whether particular actions should operate hierarchically (e.g., a commit of a collection leads to a commit of its constituent artifacts). To demonstrate the use of MCCM, we performed two experiments. In our first experiment, we built approxima-tions of RCS [25], CVS [3], and Subversion [26], as well as a prototype CM system based on change sets. Although none of these systems are as fully functional as their real-world counterparts, they illustrate reuse of modules across a variety of CM policies. Our second experiment com-pares an existing CM system, DVS [4], as it was originally implemented using NUCM [29] and now re-implemented using MCCM. This experiment shows the key benefit of our approach: a significant reduction in effort. The contributions of this work are two-fold. Theoreti-cally, we show that CM policies can be broken down into individual modules that each address a unique dimension of concern. Practically, we contribute the pluggable archi-tecture and base set of modules that constitute the MCCM infrastructure. Combined, these lay the basis for an effec-tive new approach to CM system