User Guide to Product-Line Dependencies
This chapter discusses how to apply product-line
dependencies (or simply dependencies) to your project.
SnapshotCM dependencies provide linkage between related
projects that you want to group into a single unit for building, releasing,
branching, merging, etc. For example, if snapshot A uses snapshots B & C
for building, development, etc., recording that dependency causes B & C
(the dependent snapshots) to be automatically included in actions applied to A
(the primary snapshot). Figure 1 illustrates this.
|Figure 1: Snapshot Dependency
Snapshot A depends on, or uses B & C. Equivalently,
we say that snapshots B & C are used by A. A is the primary
snapshot and B & C are the dependent snapshots.
We will get into the details later, but for now, the
important point is that dependencies define a group of snapshots to operate
Figures 2a and 2b show a project with and without
dependencies. When dependencies are present, SnapshotCM adds a link
overlay onto the standard icons, and a Dependencies folder. The link
overlay provides a quick indicator of the presence of dependencies. Note that
the link overlay and Dependencies folder are displayed when a snapshot
is either a primary or dependent member of a dependency relationship,
and it may be both at once.
|Figure 2a: Project without dependencies.
||Figure 2b: Project with dependencies.
||Figure 2c: Showing project dependencies.
SnapshotCM provides three methods to display
- A tooltip on the link overlay in the release graph (shown
in figure 2c).
- A tooltip on the dependencies folder (not shown).
- Expanding the dependencies folder (shown in figure
Dependencies are directional, displayed as either
Uses or Used by. Within the dependencies folder, Uses
dependencies display with a right-pointing icon, as shown under dependencies in
figure 2c. An up and to the left pointing icon indicates a Used by
relationship. In addition, frozen dependencies are indicated using the standard
SnapshotCM provides three ways to create dependency
The simplest is to select the intended primary snapshot,
then invoke the Snapshot->Add Snapshot Dependency... menu and select
the dependent, or used by snapshot. Any snapshot can be used by
any other snapshot, even snapshots on a different server.
Dependencies are also created whenever you copy or branch a
primary snapshot which already has uses dependencies. This will be
Finally, you can use existing workspace mounts to create a
corresponding set of dependencies. This is useful when first starting to use
dependencies. Before you can do this, however, you must identify the
primary snapshot from those the workspace mounts. Remember, the primary
snapshot is the one that uses the other snapshots.
You identify a workspace's primary snapshot by
double-clicking a mount on the Attributes page of workspace properties. An
indicator on the left, as shown in figure 3, indicates the primary mount whose
snapshot will depend on all other mounted snapshots. You must press OK to save
|Figure 3: Double-click to select the primary
snapshot mount, then press OK.
Once the primary mount/snapshot is identified, open the
Project Browser, select the workspace you wish to create dependencies from, and
then select the Snapshot->Synchronize Dependencies menu (or
equivalent context menu). A dialog will confirm the actions to be taken.
Perform direct creating, editing and deleting of
dependencies using the context menu on the Dependency folder and its children.
The synchronization options, discussed next, also provide automated dependency
editing for specific scenarios.
Synchronizing a Workspace with Dependency Changes
We previously looked at how to create initial dependencies
from a workspace. The same action can synchronize dependencies from a changed
workspace definition. In addition, the Sync Mounts action in Workspace
Properties will add/remove mounts to synchronize the workspace definition with
an updated set of dependencies. These actions are only enabled when the
dependencies and mounts are not already synchronized.
Using Dependencies to Understand Project Relationships
Since dependencies are intended to group related projects,
they encapsulate which projects (and which versions or snapshots of those
projects) are used by each version of your project. Similarly, looking from the
dependent project/snapshot perspective, you can see which snapshots of your
project are being used, and by whom. Both perspectives facilitate user
understanding of a project. In addition, when dependencies are recorded within
SnapshotCM, SnapshotCM can act upon a primary and its dependent snapshots in a
single user action. Following are the key ways dependencies are used in our
Using Dependencies to Navigate Between Projects
Dependencies provide a short-cut for navigating between
related projects. Double-clicking on a snapshot in the Dependencies
folder will switch the Project Browser to display and select it. Because both
uses and used by dependencies are shown, this also is useful to
switch back to the primary project/snapshot. The Open Project action is
also available on the dependency snapshot's context menu.
Using Dependencies to Create a Product Workspace
Dependencies are used to automatically populate the
workspace mounts for a new workspace. This greatly simplifies workspace
creation and helps ensure that workspaces are created correctly and
consistently. A workspace mounting a snapshot and its dozen dependencies can be
created in just a few clicks. Simply create a workspace for the primary
snapshot and all dependent snapshots are automatically mounted.
Using Dependencies to Create New Release Snapshots for a
When creating a new release snapshot from a primary
snapshot, the new snapshot will have dependencies on everything the original
snapshot has dependencies on, or on new copies of those original dependencies
(you choose for each dependency). Figure 4 shows the dialog for this. Note that
the primary snapshot will be copied into a snapshot named 3.0 and will
use the new /Monsoon/3.0 (copied from /Monsoon/Current) and the existing
|Figure 4: New Release Snapshot dialog showing
the dependencies which will be created.
You can select which dependencies to use unchanged in the
new snapshot, and which to also copy. In addition, you can customize how to
insert the new snapshots into the release graph of their respective projects
and whether to freeze the new snapshots.
Using Dependencies to Create Development Snapshots for a
When creating a new development snapshot from a primary
snapshot, the new snapshot will have dependencies on everything the original
snapshot has dependencies on, or on new copies of those original dependencies.
This behavior is consistent with creating new release snapshots, except that
these new snapshots are created as children of the originals.
Using Dependencies to Copy/Promote/Update Changes for a
The Compare Browser loads differences for the snapshots
being compared, as well as their pair-able dependent snapshots. Pairing works
- Identical dependencies are recognized and removed as no
differences can exist.
- Dependencies from the same project are paired.
- Dependencies from different projects are never
- Unpaired snapshots are ignored.
All differences for the paired snapshots are loaded at once.
In order to distinguish otherwise identical paths within different projects,
items in the Compare Browser are displayed with their full workspace path,
which also makes it easy to see which change belongs to which snapshot
Using Dependencies to Freeze, Unfreeze or Delete a Snapshot
When freezing, unfreezing or deleting a primary snapshot,
you are given the option to also act upon the dependencies. Figure 5 shows the
dialog that appears.
|Figure 5: Dialog for freezing a snapshot and
its dependencies. Snapshot /Monsoon/2.0 is already frozen so cannot be
Check the snapshots to which to apply the action. Sometimes
you cannot select a dependency for action, in which case a note of explanation
Summary: Dependencies provide product-level actions in a
reuse-oriented, product-line environment.
SnapshotCM dependencies provide a powerful means to operate
across multiple projects quickly, efficiently, and accurately. The product
abstraction means users can focus more on their intent and less on the details
of implementation. And because dependencies facilitate project reuse,
especially in a product-line development and production environment, your whole
team benefits. Install the SnapshotCM Product-Line release today and experience
for yourself the benefits of SnapshotCM's product-line support.