IBM Rational ClearCase

From Wikipedia, the free encyclopedia

Rational ClearCase is a software tool for revision control (e.g. configuration management, SCM) of source code and other software development assets. It is developed by the Rational Software division of IBM. ClearCase forms the base of version control for many large and medium sized businesses and can handle projects with hundreds or thousands of developers, but the price is quite steep for smaller companies.

Rational supports two types of SCM configurations, UCM, and base ClearCase. UCM provides an out-of-the-box SCM configuration while base ClearCase supplies all the basic tools to make it very configurable and flexible. Both can be configured to support a wide variety of SCM needs.

ClearCase can run on a number of platforms including Linux, HP-UX, Solaris and Windows. It can handle large binary files, large numbers of files, and large repository sizes. It handles branching, labeling, and versioning of directories.

1 History
- 1.1 DSEE
2 Views
3 Configuration specifications
4 Unique features
5 Weaknesses
6 See also
7 Notes
8 References
9 External links

[edit] History

ClearCase was developed by Atria Software and first released in 1992^[1] on Unix and later on Windows. Some of the Atria developers had worked on an earlier system: DSEE (Domain Software Engineering Environment) from Apollo Computer. After Hewlett-Packard bought Apollo Computer in 1989, they left to form Atria.^[2]^[3]^[4] Atria later merged with Pure Software to form PureAtria.^[5] That firm merged with Rational Software, which was purchased by IBM ^[6] . IBM continues to develop and market ClearCase. It is a popular product used by software production companies.

[edit] DSEE

DSEE introduced many concepts now used in ClearCase. The Apollo Domain file system allowed special handler programs to intervene during file access, and DSEE made use of this to invisibly substitute a versioned copy when a particular file was opened. With the versioning specification resident in the user environment, all accesses to versioned files were redirected, including such mundane accesses as printing, viewing in a generic text editor etc.

DSEE relied heavily on a file which described all the software modules and their dependencies. This file had to be generated manually, which was a major impediment to its use in large systems. However once generated it allowed DSEE to calculate the optimum way to perform a build, re-using all modules that had previously been processed and whose version specifications matched the specifications for the current build.

DSEE also introduced the "version spec" which was then called a "thread". This was a list of possible versions that could be in the user environment, or in a build. The major innovation was using build signatures and software release signatures in the thread. The items in a thread might thus be:

Any copies reserved for editing (i.e. checked out)
Latest version (usually for developers only)
A branched version of a file (a version on an alternate line of development).
A labeled version (for developers working on a particular revision level)
The version used in build XYZ.
The version used in software release x.y.z.

Threads were processed from top to bottom for each file. A developer thread might have "reserved" at the top, followed by a labeled version. For a quick fix to an existing release, the thread would be "reserved", then the release signature.

In the absence of the invisible file redirection of the Apollo Domain file system, Rational ClearCase uses the virtual file system provided by the MVFS feature described below. The "thread" concept corresponds to the dynamic view. Support for derived objects in a view is similar to DSEE's concept.

[edit] Views

Objects under version control in ClearCase are stored with their histories in repositories called VOBs (Versioned Object Base). ClearCase's novelty^{[citation needed]} was in its versioned file system (called MVFS: MultiVersion File System), which can be used to mount VOBs as a virtual file system through a dynamic view, selecting a consistent set of versions and allowing for the production of derived objects. The dynamic view allows this to map to a Software Configuration. This was a departure from the repository/sandbox model, allowing for the early management of artifacts (before they are being checked in, and not limited to these first order configuration items).

Alternatively, ClearCase supports snapshot views which are just copies of a directory tree spanning one or several VOBs. Snapshot views do not use a virtual file system to provide access to VOB data. Instead, a snapshot view stores a copy of the VOB data locally on the user's computer. Snapshot views can be used while disconnected from the network and later resynchronized to the VOB when a connection is reestablished. This mode of operation is similar to how the widely-used CVS (Concurrent Versions System) software works.

From the perspective of software on the client computer, a view appears as just another file system. If a file is created in a view by normal OS means (copying or saving from an editor for instance), then ClearCase will create this file as a "view-private" file. It will not be visible in any other view. This allows build systems to operate in the same directory structure as the source code, and ensures that each developer can build completely independently of each other (though if the view is a dynamic one then the normal overhead associated with accessing files over an NFS link applies). A view-private file (or directory for that matter) can be converted into a versioned element at any time, making it visible to other developers.

Each developer typically has one or several views at his/her disposal. It is sometimes practical to share views between developers, but sharing branches is usually used instead. Having a branch hierarchy is often useful, so an entire development project shares a common development branch, while a smaller team shares a sub-branch, and each developer has his or her private branch. Whenever some change is deemed stable enough for a larger group, it can be merged to the parent branch.

[edit] Configuration specifications

Under base ClearCase, each view is controlled by its associated configuration specification, commonly referred to as a config spec. This is a collection of rules (stored internally in a text file, but compiled to a more efficient form before use) that specifies what elements (files or directories) should be visible in a view, and which versions of these elements. When deciding which version, if any, of an element should be visible, ClearCase traverses the configuration specification line-by-line from top to bottom, stopping when a match is found. Earlier rules always take priority over later ones.

A typical configuration specification could look like this:

# Show all elements that are checked out to this view, regardless any other rules.
element * CHECKEDOUT

# If an element has a version on the 'module2_dev_branch', then the latest 
# version of this branch shall be the visible version in this view.
element * .../module2_dev_branch/LATEST

# For all files named 'somefile', regardless of location, always show the latest version 
# on the main branch.
element .../somefile /main/LATEST

# Use a specific version of a specific file. Note: This rule must appear before 
# the next rule to have any effect!
element /vobs/project1/module1/a_header.h /main/proj_dev_branch/my_dev_branch1/14

# For other files in the 'project1/module1' directory, show versions 
# labeled  'PROJ1_MOD2_LABEL_1'. Furthermore, don't allow any checkouts in this path.
element /vobs/project1/module1/... PROJ1_MOD2_LABEL_1 -nocheckout

# Show the 'ANOTHER_LABEL' version of all elements under the 'project1/module2' path.
# If an element is checked out, then branch that element from the currently 
# visible version, and add it to the 'module2_dev_branch' branch.
element /vobs/project1/module2/... ANOTHER_LABEL -mkbranch module2_dev_branch

A configuration specification can also reference other configuration specifications using the 'include' statement.

[edit] Unique features

VOB (VERSIONED OBJECT BASE): A repository that stores versions of file elements, directory elements, derived objects, and metadata associated with these objects. With MultiSite, a VOB can have multiple replicas, at different sites.
Configuration Record: When a dynamic view and the omake make utility supplied with ClearCase is used for the software build, ClearCase records all files (and their versions) read during the build time. This process is called build-auditing. The dependency information is stored in a hidden configuration record which can be shown for each derived object. The configuration record can be used to set up another view showing all files that have been read before during the build time. Alternatively, you can use the configuration record to apply a label to the files (and versions) that were read during the build.
Build Avoidance: Use of MVFS (MultiVersion File System) allows derived objects built in one dynamic view to be automatically "copied over" to another dynamic view requiring "exactly the same" derived object. Two derived objects are deemed to be "exactly same" if they have the same configuration record (ClearCase terminology, also called bill of materials). Shared derived objects will be physically present on the VOB server, and not in the views that reference them. The process of "copying over" is called winking in in ClearCase terminology. This feature requires that the clearmake or omake tools are used instead of other build systems.
Unix/Windows Interoperability: VOBs hosted on *nix (Solaris, Linux, AIX, HP-UX, IRIX primarily) servers can be accessed from views hosted on Windows clients. VOBs hosted on Windows servers can only be accessed by Unix clients with snapshot views.
Integration With Other Products: Other products (originally) from Rational Software, notably ClearQuest and Rational Rose, integrate with ClearCase. ClearCase also integrates with TextPad, Microsoft Visual Studio, Code::Blocks, NetBeans and the Eclipse IDE through a plugin. There are also Emacs^[7] and Vim^[8] plugins available.

[edit] Weaknesses

The neutrality of this section is disputed.
Please see the discussion on the talk page.(February 2008)
Please do not remove this message until the dispute is resolved.

Transactions not atomic: Changes to files or directories are independent from others, unlike some other systems where multiple changes can be committed atomically at the same time, using the concept known as Atomic commit. Atomicity is desirable because it allows multiple changes that address a particular problem to be committed as a single unit, and, provided the developer has been careful, results in a buildable code base for every version.^[9]
Aging: ClearCase itself, and tools related to it like ClearQuest, have stagnated and accumulated significant quantities of legacy code.^{[citation needed]} This makes them slower and more difficult to use than other systems.^{[citation needed]} ClearCase was designed to support existing build systems rather than require the developer to use only ClearCase tools such as clearmake. These included Makefiles, shell scripts, etc.^[10]^[11]
Speed: ClearCase dynamic views are slower than local filesystems, even with good network infrastructure. A benchmark shows that many basic tasks take about twice as long to run using a ClearCase dynamic view than on competing SCM tools^[12], although repeated subsequent builds may run dramatically faster due to build avoidance if ClearCase's make substitute can be used. Because MVFS requires server access every time a file is accessed, the performance of the file system depends on server capacity.^[13]
Speed - Windows clients: ClearCase disk access performance for Windows clients are extremely low.^[14] This depends on unlucky combination of a very verbose protocol combined with Samba and CIFS.^[14] Replacing the windows clients standard CIFS implementation with NFS might increase the bandwidth approx. 2.5 times, leaving it still slow but more acceptable.^[14]
Sensitivity to network problems: Because MVFS is essentially an online file system, any problems with the server or network render the dynamic views unusable. It is not possible to work on dynamic views offline.^{[citation needed]}. If the view data for dynamic views is stored on a client host (as may be done for performance reasons or to reduce the need for servers), ClearCase does not automatically handle host IP address changes.^[15]