SnapshotCM is a powerful, easy to use Software Configuration Management (SCM) System built on new concepts that greatly simplify common tasks for small and large development teams. Its visual snapshot technology makes branching and tagging operations trivial. SnapshotCM's client/server, TCP/IP based architecture is designed for heterogeneous, local- and wide-area networked environments. SnapshotCM is easy to use, requires little administration, integrates with leading development environments, and most importantly, allows you to focus your energies on your product rather than ours!
- New Concepts
- Branching, Labeling and Parallel Development
- Powerful Workspace
- Efficient Networking
- Simple Administration
- IDE Support
- Reporting and Auditing
SnapshotCM simplifies software configuration management for small and large development teams through a breakthrough concept: that of reversing the traditional filerevision relationship. Rather than having thousands of files, each with many revisions to choose from (most combinations of which would be invalid), SnapshotCM allows you to define the project versions you care about. SnapshotCM does the rest. You no longer need to tag revisions for releases, or remember whether you've moved tags appropriately. SnapshotCM handles it.
SnapshotCM keeps track of which revisions of which files (and even which files) belong to a given project version, manages changes to all file attributes (including renames and deletes), and allows graphical viewing of your project versions and their relationships. Project versions can be compared and changes copied from one version to another with a few clicks of the mouse. In SnapshotCM, a project version is called a snapshot, and forms the basis for simplifying what used to be time-consuming, confusing and error-prone branching, labeling and parallel development tasks.
SnapshotCM's unique strength is the elegantly simple support for branching, labeling and parallel development provided by our patented Snapshot Technology. In SnapshotCM, a snapshot is a complete state of a project, including, for each file or directory, its name, parent directory, text/binary type, keyword expansion setting, unix mode, its existence and its content. No change to any item in any snapshot affects any other snapshot.
Labeling is accomplished by creating a snapshot copy in an instantaneous, atomic operation. The new copy can then be frozen to prevent inadvertent modification. Branch or parallel development is initiated by creating a copy of any existing snapshot and leaving it open for modification.
Branch changes of any attribute can be quickly identified and easily copied between snapshots. Changes to any attribute in a snapshot can also be copied into a workspace.
Snapshots and snapshot relationships are shown and manipulated graphically, making these operations simple to perform and easy to understand. Snapshot operations are also accessible from the command-line.
SnapshotCM client workspaces track local changes to files, and support copying changes of all types, including renames, creates and deletes, from a snapshot into the workspace. Once the workspace is defined, explicit references to the server, the snapshot, to revisions, or paths are unnecessary. Even from the command-line, developers simply perform CM operations on local paths, and SnapshotCM workspaces take care of the details.
SnapshotCM consists of server and client components. The SnapshotCM server provides controlled access to the central file archive on the server's machine. Users access the SnapshotCM server through client programs running on their local workstations anywhere on the network.
Each developer typically has his or her own workspaces holding files of interest. The SnapshotCM clients monitor changes to workspace and server files and are used to commit changes to the SnapshotCM server, as well as update a workspace with server changes.
The SnapshotCM server has three components: a request handler, a data manager and a file manager. The request handler receives requests from the clients and makes calls to the data and file managers as appropriate. The data manager manages all information, except file content, in a fast and efficient transaction oriented database. The file manager stores files on a disk local to the server. Most file revisions are stored in an RCS format. Very large files are stored directly without using RCS.
SnapshotCM server and clients communicate using a TCP/IP-based protocol designed for efficient network performance. SnapshotCM does not use shared or proprietary file systems and works well in local- and wide-area networks. Once files are retrieved to a workspace, all accesses are local to the user's machine. Normal editing and compiling operations do not use the network.
All clients have direct access to the server, even if operating from home over a low speed dialup connection. All clients interoperate with all servers, regardless of OS or platform, providing excellent heterogeneous environment support.
SnapshotCM does not rely on special kernel support or special file systems. Written in C++, SnapshotCM is readily ported to most platforms. Initial releases support Windows, Linux, Solaris and HP-UX, with more planned. Please do ask if you have need for a platform not mentioned.
SnapshotCM largely manages itself. Routine administration consists of performing backups, which can be done without stopping the SnapshotCM server.
SnapshotCM supports Microsoft's Source Code Control (SCC) API, providing integration with the Developer Studio suite of products (Visual C++, Visual Basic, et al) and many other tools. The SnapshotCM SCC module communicates directly with the SnapshotCM server to provide top performance and tight integration.
SnapshotCM provides file and directory change histories, including history entries for each attribute change. Snapshot difference reports show attribute values which have changed between snapshots. All change operations are logged for auditing, allowing a quick and flexible review of work performed.