IBM Rational ClearCase 7.0: Master the Tools That Monitor, Analyze, and Manage Software Configurations

IBM Rational ClearCase 7.0: Master the Tools That Monitor, Analyze, and Manage Software Configurations
eBook: $32.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $87.98    Print cover: $54.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • Master ClearCase from the inside out: Go technical for consistent, well-structured, and robust software
  • Cut out chaos! Introduce order through reproduction with clearmake
  • Use and extend ClearCase in manageable collaborations
  • Design scalable and stable working practices with ClearCase MultiSite distribution

Book Details

Language : English
Paperback : 360 pages [ 235mm x 191mm ]
Release Date : April 2011
ISBN : 1849680124
ISBN 13 : 9781849680127
Author(s) : Marc Girod, Tatiana Shpichko
Topics and Technologies : All Books, Enterprise Products and Platforms, Enterprise, IBM

Table of Contents

Chapter 1: Using the command line
Chapter 2: Presentation of ClearCase
Chapter 3: Build Auditing and Avoidance
Chapter 4: Version Control
Chapter 5: MultiSite Concerns
Chapter 6: Primary Metadata
Chapter 7: Merging
Chapter 8: Tools Maintenance
Chapter 9: Secondary Metadata
Chapter 10: Administrative Concerns
Chapter 11: MultiSite Administration
Chapter 12: Challenges
Chapter 13: The Recent Years' Development
Conclusion: ClearCase Future
  • Teaser
    • But first the scenario
    • Time to review the exhibited functionality?
    • Chapter 1: Using the command line
      • Rationale (pun intended)
      • Against intuition
        • The continuity of reasoning
        • Illustrations
      • Text, shell, and terminal
      • Perl
        • Perl documentation
      • Windows command prompt and alternatives
      • GUI versus text mode
      • ClearCase documentation
      • Summary
      • Chapter 2: Presentation of ClearCase
        • SCM history
        • ClearCase originality
          • Virtual file system
          • Auditing, winkin
        • The main concepts
          • Vobs and views
          • Deeper into views
            • Versioning mechanism
            • Views properties
          • Registry, License, and even Shipping servers
          • Config specs
        • Summary
        • Chapter 3: Build Auditing and Avoidance
          • Configuration records
            • Flat or hierarchical: clearaudit vs. clearmake
            • Makefile syntaxes—compatibility modes
            • A first case with clearmake
            • Recording the makefiles
            • Using remote subsystems
            • Remote dependencies
            • Multiple evaluation of dependencies
          • Validation
            • Error reports and their analysis
            • State of derived objects and reference count
            • Removing derived objects
            • Dependencies on the environment and on tools
            • Reproducing the build
            • Litmus test
          • Tying some knots
            • Ties between vobs and views
            • Distributed or parallel builds
            • Staging
            • Application to other tasks than mere builds
          • Summary
          • Chapter 4: Version Control
            • Making elements
            • Checkout and checkin
              • Versioned directories
              • lost+found
              • Removing files
              • Looking at the view extended side of things
              • Version tree
              • Recovering files
              • Hard links
              • Evil twins
              • Eclipsed files
              • Writable copies
            • Differences and annotations
            • Misguided critiques
            • Summary
            • Chapter 5: MultiSite Concerns
              • Distribution model
                • Multitool, and MultiSite Licenses
              • Replicas and mastership
                • Avoid depending on mastership
                • Branches
                • Labels
                • Other types
              • Global types and admin vobs
              • Shortcomings of MultiSite
              • Summary
              • Chapter 6: Primary Metadata
                • Metadata in the version extended view
                • Types and instances
                • Labels or branches?
                • Parallel development
                  • Config specs
                  • Floating and fixed labels
                  • Baselines and incremental labels
                • Branches and branch types
                  • Delivery
                  • Archiving
                  • Rollback
                • Use of locking
                • Types as handles for information
                • Summary—wrapping up of recommended conventions
                • Chapter 7: Merging
                  • Patching and merging
                    • Patching text files
                  • Managing contributions
                  • Merging directories
                  • Rebase or home merge
                  • Complex branching patterns
                  • Rollback of in-place delivery
                  • Bulk merges
                  • Evil twins
                  • Summary—wrapping up
                  • Chapter 8: Tools Maintenance
                    • Why?
                      • Dependency control
                      • Safety with updates
                        • Explicitly declare tools as dependencies?
                        • ClearCase has better to offer!
                      • Referential transparency
                      • Flexibility
                      • Tool fixes
                      • Indirect dependencies
                      • MultiSite replication
                    • How?
                      • Example—perl installation under a ClearCase vob, with multi-platform support
                        • Importing CPAN modules
                        • Installing the Perl distribution
                        • Upgrading the distribution
                      • Installation
                      • Import
                        • Minor checks prior to importing
                        • Branching and labeling
                        • Issues during the import
                      • Operating system
                      • Shared libraries
                      • Licenses
                      • MultiSite and binary elements
                      • Labels, config specs, and multiple platforms
                      • Special cases: Java 1.4.2_05 on Linux
                      • Naming issues: acquisitions, splits, mergers
                    • Summary
                    • Chapter 9: Secondary Metadata
                      • Triggers
                        • NO_RMELEM
                        • CHECK_COMMENT
                        • REMOVE_EMPTY_BRANCH
                      • Comments
                      • Scrubbers
                      • Attributes
                      • Hyperlinks
                      • Type managers and element types
                        • The magic files
                        • User defined types
                          • Type without a new manager
                          • New type manager
                      • Native types
                        • Binary types
                        • Text type
                      • Summary
                      • Chapter 10: Administrative Concerns
                        • Top-down
                          • License and registry
                            • Synchronization between regions
                          • Monitoring client activity
                          • Location broker
                          • Remote monitoring infrastructure
                          • Scheduler
                          • Storage and backup
                          • Vob size
                          • Authentication
                          • Importing files to ClearCase
                            • Even UCM has to use Perl
                          • Relocating
                          • Importing with synctree
                            • ClearCase::Wrapper
                          • Copying a vob
                            • Moving vob storage
                            • Copying vob by replication
                            • Re-registering a replica
                          • Views cleanup
                          • ClearCase and Apache integration
                          • Installation tricks
                        • Bottom-up
                          • ALBD account problems
                          • Changing the type manager
                          • dbid and the Raima database
                          • Protecting vobs: protectvob, vob_sidwalk, fix_prot
                          • Cleaning lost+found
                        • Summary
                        • Chapter 11: MultiSite Administration
                          • Setting up the scenery
                            • Permissions preserving
                            • Connectivity
                          • Configuration
                            • Export
                            • Shipping/routing
                            • Import
                            • Receipt handler
                            • Shipping server
                              • Setting up the scheduler on a shipping server
                          • Monitoring
                            • Client side (remote host)
                            • Server side (local host)
                          • Troubleshooting
                            • Missing oplogs
                            • History of exports
                            • Consequences of replicas being out of sync
                            • Export failures
                            • Incompatibility between ClearCase releases
                            • MultiSite shipping problems—a tricky case
                          • Summary
                          • Chapter 12: Challenges
                            • Java
                              • Problems with the Java build process
                              • .JAVAC support in clearmake
                              • Ant and XML
                              • Audited Objects
                            • MultiSite
                              • Maven, and Buckminster
                              • Mercurial and git
                            • Perspectives in Software Engineering
                              • Eclipse and OSGI
                              • Virtual machines
                            • Conclusion
                              • Conclusion: ClearCase Future
                                • ClearCase is dead, long live ClearCase!
                                  • The legacy of ClearCase
                                  • Some errors to avoid, or the limits of ClearCase
                                • Appendix
                                  • Chapter 1
                                  • Chapter 2
                                  • Chapter 3
                                  • Chapter 4
                                  • Chapter 6
                                  • Chapter 7
                                  • Chapter 8
                                  • Chapter 9
                                  • Chapter 10
                                  • Chapter 11
                                  • Chapter 12
                                  • Chapter 13
                                  • Conclusion

                                  Marc Girod

                                  Marc grew up and graduated in France (MSci - Supélec 1983). He moved to Finland, where he lived over 20 years, then to Ireland. He worked first as a software developer, later as a ClearCase administrator and build engineer. He is currently working for LM Ericsson in Athlone, Ireland. He invested similar passion into several technologies over his career: Transputers and Occam2, C++, and since 1994, ClearCase. He is interested in contemporary philosophy (existentialism and postmodernity).

                                  Tatiana Shpichko

                                  Tatiana (Tanya) Shpichko was born in Moscow, Russia. She got an early interest for mathematics and programming, which developed into a lifelong passion in the secondary mathematical school number 179. She graduated from Moscow State Technical University of Electronics and Mathematics with a MSci degree in Computer Science. Tatiana started to do software development back in 1989, and has been programming in Pascal, C, C++ and Java. She first started to use ClearCase as a developer and then moved to work as a ClearCase administrator in 2005. Tatiana has lived and worked in Finland for the past 10 years. She is interested in literature, science and travel. Tanya and Marc share a passion for scuba diving and underwater photography.
                                  Sorry, we don't have any reviews for this title yet.

                                  Code Downloads

                                  Download the code and support files for this book.

                                  Submit Errata

                                  Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                                  - 2 submitted: last submission 03 Mar 2013

                                  Errata type: Technical | Page number: 120 | Errata date: 18 July 11

                                  "Versioned derived objects are thus simply not visible to lsdo and cannot (probably) be winked in:". A detailed discussion for this part is given here "We are happy that we added the word "probably", but even more to admit that this conclusion was incorrect. We did not appreciate the advantages of the change we detected. Derived object versions were indeed detached from the other derived objects, but this didn't impact their being winkable, and at first sight, it did solve the issues with reference counting under MultiSite. Effectively, it makes it possible to replicate derived objects in a semi-manual way. In practice however, successful winkin on a remote site requires that all the intermediate derived objects would be checked in. Let's illustrate this by completing our example, forgetting for now the -cr option, hence checking in the data as well as the config record. We checked in the foo derived object as version /main/mg/3 using the view v2 the config spec of which selected version /main/cr/1 of the t directory. This element is thus not accessible from view v1, which selects version /main/mg/1 of the same t directory. We now remove from there the original derived object, and run clearmake: $ clearmake Wink in derived object "foo" $ ls -l foo -rw-r--r-- 1 emagiro EEI-ATusers 4 Jul 7 13:14 foo $ ct ls foo foo@@/main/mg/3 $ ct lsdo foo cleartool: Error: Not a derived object: "foo" $ ct des -fmt "%m\n" foo derived object version $ ct dump foo | egrep '^(ref|Pre|config|Build)|cont=' source cont="/vstg/test.vbs/s/sdft/26/b/0-7bf68b49a89311e085b700156004455c-fq" clrtxt cont="/vstg/test.vbs/c/cdft/3c/1f/7bf68b49a89311e085b700156004455c" config rec=536984571 Predefined dependency hash=0 Build script hash=2790973829 ref count=1 We clearly see that while not being a derived object (hence not being connected for instance to the do-pool, and affected by scrubbing issues), this object has a reference count, a config record, and a build script. Let us stress the point that it need not (and should not) be accessed via the config spec, except for the sole purpose of updating it), yet may be shopped for and winked in by clearmake. With this insight, we have to take back, with an apology, the adjective naive we used to qualify all proponents of staging practices, and to admit that there may be a window of opportunity for it, keeping an eye on the tradeoffs of downloading large binaries. Testing the effect of replication brings however new surprises. We skipped one step by building a compound object, i.e. one depending on an intermediate derived object, and checking in only the final one (a case thus completely disconnected from the previous one): $ cat Makefile foo: bar @cat bar > foo bar: @echo bar > bar $ ct catcr -r foo ---------------------------- ---------------------------- Derived object: /vob/test/foo@@/main/mg/1 ... ---------------------------- MVFS objects: ---------------------------- /vob/test/bar@@--07-09T12:24.17098 /vob/test/foo@@/main/mg/1 ---------------------------- Build Script: ---------------------------- @cat bar > foo ---------------------------- ---------------------------- ---------------------------- Derived object: /vob/test/bar@@--07-09T12:24.17098 ... ---------------------------- MVFS objects: ---------------------------- /vob/test/bar@@--07-09T12:24.17098 ---------------------------- Build Script: ---------------------------- @echo bar > bar ---------------------------- $ We note first that in another view on the same site (but on a different architecture, checking this way that no dependency on local tools is creeping in), in which the foo derived object has been winked in before we made it an element, running clearmake once again gets rid of the shared derived object, and replaces it with the versioned one: $ ct lsdo foo bar --07-09T12:24 "foo@@--07-09T12:24.17099" --07-09T12:24 "bar@@--07-09T12:24.17098" $ clearmake `foo' is up to date. $ ct lsdo foo@@--07-09T12:24.17099 bar cleartool: Error: Not a derived object: "foo@@--07-09T12:24.17099" --07-09T12:24 "bar@@--07-09T12:24.17098" $ ct des foo@@--07-09T12:24.17099 cleartool: Error: Unable to access "foo@@--07-09T12:24.17099": Invalid argument. $ ct des -s foo foo@@/main/mg-001/1 Note the fact that we renamed the mg branch type to mg-001 between the two transcripts, in order to hide the versioned element from the views using config specs set up to use .../mg/LATEST rules. But then, on a remote site, and after waiting for the synchronization: $ clearmake $ ct lsdo foo --07-09T18:20 "foo@@--07-09T18:20.15821" $ ct des -fmt "%m\n" .@@/main/mg-001/1/foo/main/mg-001/1 derived object version No winkin took place, despite the fact that the derived object version was indeed correctly replicated! Removing the derived objects, and building with the verbose option shows a mention of the bar sub-object: $ rm foo bar $ clearmake -v No candidate in current view for "bar" ======== Rebuilding "bar" ======== Will store derived object "/vob/test/bar" ======================================================== Must rebuild "foo" - due to rebuild of subtarget "bar" ======== Rebuilding "foo" ======== Will store derived object "/vob/test/foo" ======================================================== $ ct catcr -r .@@/main/mg-001/1/foo/main/mg-001/1 ... ---------------------------- MVFS objects: ---------------------------- /vob/test/bar <2011-07-09T16:54:41+05:30> /vob/test/foo@@/main/mg-001/1 ---------------------------- Build Script: ---------------------------- @cat bar > foo ---------------------------- ---------------------------- ---------------------------- Target bar built by ... ---------------------------- MVFS objects: ---------------------------- /vob/test/bar <2011-07-09T16:54:41+05:30> ---------------------------- Build Script: ---------------------------- @echo bar > bar ---------------------------- Our next move will obviously be to make an element from bar, and to see whether this affects. It does. But only after one explicitly removes the derived objects: only running clearmake leaves them as "up-to-date": $ ct lsdo foo bar --07-09T19:33 "foo@@--07-09T19:33.14947" --07-09T19:33 "bar@@--07-09T19:33.14946" $ clearmake `foo' is up to date. $ ct lsdo foo bar --07-09T19:33 "foo@@--07-09T19:33.14947" --07-09T19:33 "bar@@--07-09T19:33.14946" $ rm foo bar $ clearmake Wink in derived object "bar" Wink in derived object "foo" $ ct lsdo foo bar $ ct des -s foo bar foo@@/main/mg-001/1 bar@@/main/mg-001/1 It seems to be a very tough requirement if all the intermediate derived objects need to be checked in! One may consider means to support this, using syntree, its -vreuse and -cr options, and the branchoff root strategy; let's admit that will depart from common standard procedures."


                                  Errata type: Technical | Page number: 190 | Errata date: 18 July 11

                                  "Special Cases: This was an arbitrary assumption, defeated by the fact that in the context of ClearCase, the path returned would point inside the cleartext pool. ". A detailed discussion for this is given here: "With this sentence, we accepted the experienced situation as a matter of fact. It did not come to our mind to compare the path returned under Linux to the one returned in a similar case under Solaris. Doing it it makes it clear that the former is incorrect. RedHat 5.3 (2.6 kernel), with ClearCase 7.0.1: $ /vob/tst/lsl -l /proc/self/exe lrwxrwxrwx 1 shpichko admcc 0 Jul 6 11:25 /proc/self/exe -> /filer/vstg/tst.vbs/c/cdft/41/38/113d8057a7a811e08e6b0022649817a8 Solaris: $ /vob/tst/lss -l /proc/self/path/a.out lrwxrwxrwx 1 shpichko admcc 0 Jul 6 11:19 /proc/self/path/a.out -> /vob/tst/lss In the above tests, we imported to the vob the Linux version of the standard UNIX tool ls as lsl, and the Solaris version as lss. We used both on hosts of the respective platforms, to show the path made available to the running process by the operating system, using the /proc file system (slightly different syntaxes in the two cases) and the readlink system call. We can see that the path returned under Solaris is correctly virtualized, hence is usable by the process to determine colocated tools, under the same view. This is not the case under Linux, which caused the problem we mentioned with Java 1.4.2. Whereas the problem was real, hence still justifies our picking it as an example of a "special case", the root cause was a bug which IBM classified as a vendor issue, and was eventually fixed in RHEL6 and SLES11 (released in November 2010), supported by ClearCase versions 7.1.1.x and above (we shall check this as soon as possible). "


                                  Sample chapters

                                  You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                                  Frequently bought together

                                  IBM Rational ClearCase 7.0: Master the Tools That Monitor, Analyze, and Manage Software Configurations +    Programming Microsoft Dynamics NAV 2009 =
                                  50% Off
                                  the second eBook
                                  Price for both: €41.05

                                  Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                                  What you will learn from this book

                                  • Master ClearCase command line essentials with Perl's text handling capabilities
                                  • Take full advantage of audited dependencies to support truly incremental development
                                  • Extend ClearCase with powerful Perl modules
                                  • Gain a wealth of troubleshooting tips and tricks for ClearCase, using the tool as a wholly distributed system
                                  • Get fully acquainted with a novel model of branching and publishing for optimizing distribution with ClearCase
                                  • Shed new light on testing from a Software Configuration Management perspective
                                  • Understand the value of focusing on derived objects, and also learn how to avoid generating duplicates
                                  • Get to grips with using ClearCase MultiSite to design processes that are stable over distribution

                                  In Detail

                                  Undeniably, IBM Rational ClearCase is one of the major Software Configuration Management (SCM) tools on the market, and an integral part of a development environment. It introduced significant novelties into SCM, making it an original and insightful tool, and it's precisely these features that are often underutilized by ClearCase users. This book will show readers how to use ClearCase to its full potential and take advantage of its build auditing and dependency analysis applied to derived objects, workspace management with dynamic views, and its support for distributed development with ClearCase MultiSite. Through mastering ClearCase tools, this book will demonstrate that ClearCase is for users, and not only for the administrators.

                                  The book capitalizes on the main competitive advantage of ClearCase: that, thanks to build avoidance, ClearCase can focus on and identify derived objects through build management. This practical guide will help you master the tools for monitoring, analyzing, and managing software configurations with ClearCase.

                                  The book spends as little time as possible setting the scene. It delves straight into the ClearCase essentials of Build Management, which serves as the basis for the whole book.

                                  By the end of the book you will have learned how to master and optimize the various tasks pertaining to both administration and day-to-day development, in both a single-site and a multi-site environment. The emphasis is on ensuring the collaborative management of software development. Special attention is paid to third-party tool management under ClearCase and many practical examples are given, with a particular focus on the command line and scripting as a means to maximize flexibility and management over one's work.

                                  This book is a practical guide that highlights and demonstrates those specific functions not traditionally expected from an SCM tool, and supported only by ClearCase.


                                  This is a practical book with plenty of code examples for mastering ClearCase tools to monitor, analyze, and manage software configurations.

                                  Who this book is for

                                  If you are a developer who wants to use ClearCase for software development then this book is for you. This book is not for experts, but it will certainly challenge your technical skills.

                                  While ClearCase concepts and tools are presented for those unfamiliar with the tool, an ability to use the command line as well as some fluency with shell scripting will certainly be an advantage.

                                  Code Download and Errata
                                  Packt Anytime, Anywhere
                                  Register Books
                                  Print Upgrades
                                  eBook Downloads
                                  Video Support
                                  Contact Us
                                  Awards Voting Nominations Previous Winners
                                  Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                                  Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software