View source for Version Control on the CS Systems

Version Control on the CS Systems

All of the [[:Category:Computers_Available_on_the_CS_Network|CS computers]] have at least the following version control software installed:

* [http://bazaar.canonical.com/ Bazaar]
* [http://www.nongnu.org/cvs/ CVS]
* [http://darcs.net Darcs]
* [http://git-scm.com/ Git]
* [http://mercurial.selenic.com/ Mercurial]
* [http://subversion.apache.org/ Subversion]

If you're unfamiliar with version control, you are encouraged to read about each program to decide what's best for you.  Bazaar and Mercurial tend to be fairly newcomer-friendly.  git is currently very popular among many open source software projects.


== Using a VCS Yourself ==

If you want to manage your own files, you can use any of the version control programs directly on our systems; you don't need to use a server of any kind.

Bazaar, Darcs, Git, and Mercurial are all [https://en.wikipedia.org/wiki/Distributed_version_control_system distributed version control] systems and are designed to work without requiring a central repository.  Working with them is as simple as changing to the directory where your files are (or will go) and initializing a new repository there.  That looks something like this:

 $ cd ~/my-project
 $ bzr init    ''# For Bazaar''
 $ darcs init  ''# For Darcs''
 $ git init    ''# For Git''
 $ hg init     ''# For Mercurial''

After that, you can work with your files and commit them to the repository as you like.

CVS and Subversion are centralized version control systems and, as such, need to have a separate repository, even if only one person will be working on it.  You will need to designate a subdirectory of your home directory as your Subversion or CVS repository in addition to the directory where you will be working with your files.

For Subversion, that looks something like this:

 $ svnadmin create ~/my-repository
 $ svn mkdir --parents -m 'Create my project.' file://${HOME}/my-repository/my-project/trunk
 $ svn checkout file://${HOME}/my-repository/my-project/trunk ~/my-project
 $ cd ~/my-project

For CVS, it looks like this:

 $ cvs -d ~/my-repository init
 $ cd ~/my-project
 $ cvs -d ~/my-repository import -m 'Create my project.' my-project $USER start
 $ cd ~
 $ mv ~/my-project ~/my-project-original  ''# or rm -r ~/my-project''
 $ cvs -d ~/my-repository checkout my-project

Note that the use of CVS is not really recommended unless you have a specific need for it.  Subversion is generally an easier system to work with, and many people find that the distributed version control systems are better for them than either Subversion or CVS.


== Using a VCS Remotely ==

You can keep a checkout of your files on other computers (like your personal desktop or laptop) and still commit changes to the repository you set up on the CS systems.  Although remote access will work through any of the lab systems, we suggest that you use ''gradx'' on the Grad/Research network and ''ugradx'' on the Undergrad network.

Assuming you're on the Grad/Research network, for a project in <tt>~/my-project</tt> with an account name of ''your-account'', here are the repository URLs you would use with each DVCS:

;Bazaar
:<tt>bzr+ssh://''your-account''@gradx.cs.jhu.edu/~/my-project</tt>
;Darcs
:<tt>''your-account''@gradx.cs.jhu.edu:my-project</tt>
;Git
:<tt>ssh://''your-account''@gradx.cs.jhu.edu/~/my-project</tt>
;Mercurial
:<tt>ssh://''your-account''@gradx.cs.jhu.edu/~/my-project</tt>

For '''Subversion''', you would use <tt>svn+ssh://''your-account''@gradx.cs.jhu.edu/users/''your-account''/my-project</tt>.  Note that home directories on the Undergrad network are in <tt>/home</tt>, not <tt>/users</tt>.

For '''CVS''', you would use <tt>:extssh:''your-account''@gradx.cs.jhu.edu:/users/''your-account''/my-project</tt>, with the same caveats about home directories as mentioned for Subversion.


== Using a VCS with Other People ==

The CS department does not currently provide a centralized repository service for use by faculty and students, although that might change in the future.  Fortunately, it's not too hard to use your home directory and your [[:Category:Webpages_and_Webservices|website]] to facilitate collaboration with others, especially if you're using a distributed version control system.

The essence of this approach is that you have a repository that's shared with others through your website.  They pull from your repository and make changes locally on their systems.  When those changes are ready to be integrated into your repository, either you pull from other people's web-shared repositories or they send you changesets that your version control system can integrate.

For each of the examples below, we will assume that the project name is "my-project", that you will be editing its files in the <tt>~/my-project</tt> directory, and that the URL for others to access it will be <tt><nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project</tt>.

(Note that on the Undergrad network, you would connect to ugradx instead of gradx; your home directory would be <tt>/home/''your-account''</tt>, not <tt>/users/''your-account''</tt>; and the URL would be <tt><nowiki>https://</nowiki>www.ugrad.cs.jhu.edu/~''your-account''/my-project</tt>, not <tt><nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project</tt>.)

=== Bazaar ===

From your project directory, use <code>bzr push</code> to make a public repository in your webspace:

 $ mkdir ~/public_html/my-project
 $ cd ~/my-project
 $ bzr push --no-tree ~/public_html/my-project

The public branch will just be the repository; it will not have files that you can edit in it.  When you make changes to your private repository (in <tt>~/my-project</tt>), you will have to preiodically re-run <code>bzr push</code> to make those changes visible to others.

Other people can get their own checkouts from your public branch:

 $ bzr branch <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project
 $ cd my-project

When you want to pull in other people's changes, you can either pull from their public repositories:

 $ cd ~/my-project
 $ bzr merge <nowiki>https://</nowiki>other.server.edu/path/to/their/repo

Or they can send you a merge directive, which you then merge.

They would run:

 $ bzr send -o /path/to/directive.patch <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project

Then they would send you the merge directive and you would run:

 $ cd ~/my-project
 $ bzr merge /path/to/directive.patch

=== Darcs ===

With Darcs, the recommended way to publish your repository is simply to make a symbolic link to it from your webspace:

 $ ln -s ~/my-project ~/public_html/my-project

People can then get a copy of your repository with:

 $ darcs get <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project

When you want to pull in other people's changes, you can either pull from their public repositories:

 $ darcs pull <nowiki>https://</nowiki>other.server.edu/path/to/their/repo

Or they can send you a merge directive, which you then merge.

They would run:

 $ darcs send <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project

After you receive the changeset, you would merge it with:

 $ cd ~/my-project
 $ darcs apply /path/to/changeset

=== Git ===

Git uses <code>git clone</code> to create the public repository initially:

 $ git clone --bare ~/my-project ~/public_html/my-project.git
 $ cd ~/my-project
 $ git remote add public ~/public_html/my-project.git

As you make changes to your repository, you will need to periodically push those changes to the public repository so others can see them:

 $ cd ~/my-project
 $ git push public

Others can get a copy of your repository with:

 $ git clone <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project.git

When you want to pull in other people's changes, you can either pull from their public repositories:

 $ cd ~/my-project
 $ git pull <nowiki>https://</nowiki>other.server.edu/path/to/their/repo.git

Or they can send you patches from git.

They would run:

 $ git format-patch origin

After you receive the patch files, you run:

 $ cd ~/my-project
 $ git am /path/to/changes.patch

=== Mercurial ===

Mercurial uses <code>hg clone</code> to create a new repository:

 $ hg clone -U ~/my-project ~/public_html/my-project

As you make changes to your repository, you will need to periodically push those changes to the public repository so others can see them:

 $ cd ~/my-project
 $ hg push ~/public_html/my-project

Others can get a copy of your repository with:

 $ hg clone <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project

When you want to pull in other people's changes, you can either pull from their public repositories:

 $ cd ~/my-project
 $ hg pull <nowiki>https://</nowiki>other.server.edu/path/to/their/repo

Or they can send you patches.

They would run:

 $ hg outgoing -p <nowiki>https://</nowiki>www.cs.jhu.edu/~''your-account''/my-project >/path/to/changes.patch

After you receive the patch files, you run:

 $ cd ~/my-project
 $ hg import /path/to/changes.patch

=== Subversion ===

Subversion is not currently supported for collaboration on the CS systems because it needs more than just plain HTTP for sharing its repositories.  If you need to use Subversion to collaborate with other people, please email support@cs.jhu.edu for assistance.

=== CVS ===

CVS does not support using HTTP as a transport, so it's not currently supported for collaboration, though personal projects will work just fine.  If you need to use CVS to collaborate with other people, please email support@cs.jhu.edu for assistance.

== Non-CS Hosting ==

There are various websites on which you can host repositories under various conditions.  The ones listed here are for your information; we don't endorse or recommend any particular service.

[https://github.com GitHub] has [https://github.com/edu educational accounts] aimed at students working on class projects and at teachers providing repositories for their students.  These accounts support a limited number of private repositories, so your data is not explicitly shared with the world.  (It is, however, hosted on servers not under the direct control of Johns Hopkins.)