• It lets us keep SVN as our central repository
• Some team members prefer not to use a DVCS for whatever reason so it lets them carry on using SVN without interruption.
• It allows me to work and commit changes (but not push!), search history and switch between branches completely disconnected. I can continue to work during network outages or while traveling when I don’t have connectivity.
• You get full, fast history search.
• Switching between branches is easy and fast.
• Any automated processes which use SVN (i.e. automated builds and deployments) can continue to operate while everyone moves to DVCS.
• It’s much easier to perform merges than regular SVN (via export/import patch queues – which I detail later)

Why not use git-svn?

I personally prefer Mercurial with hgsubversion since, in my mind, the tooling in Windows is currently much more mature and I already have a hgsubversion workflow which is simple, robust and effective.

That being said, many people are happy with using git-svn and if you’re evaluating options, it may be worth giving it a go too!

General Overview

My local Mercurial repo contains the full history of the project with a full graph of branches – I use it to search full history, switch between branches, export/import patches, commit and push. I keep everything in a single C:\Source\my-project folder. no need for \trunk or \branches. There are many ways which you can use Mercurial with a SVN repository, each has it’s own caveats and edge-cases. This article is intended to record a way which I have found to be robust and hassle free.

I use TortoiseHg which you can get from http://tortoisehg.bitbucket.org/

TortoiseHg includes the command line client, so you don’t need to install it separately.

This guide assumes knowledge of Mercurial and SVN concepts and workflows and is intended to be a kind of a summary of things to keep in mind when using Mercurial to work with a SVN repository.

To interact with the SVN repository, I only need to use TortoiseHG’s hg workbench http://tortoisehg.bitbucket.org/manual/2.3/workbench.html . Generally I’ll keep the window open at all times on my second monitor, minimizing it when not needed.

More reading: http://tortoisehg.bitbucket.org/manual/2.3/workbench.html

Getting hgsubversion

You can get it from https://bitbucket.org/durin42/hgsubversion/overview/

This guide assumes that you will clone it to: C:\Apps\Mercurial\hgsubversion

I’m using hgsubversion at revision #821 (f28e0f54a6ef) so if in doubt and latest doesn’t seem to be working for you, try updating to this specific version.

More reading: http://mercurial.selenic.com/wiki/HgSubversion

Configuration

My mercurial.ini file in C:\Users\Matt looks like:

[extensions]
hgsubversion = C:\Apps\Mercurial\hgsubversion\hgsubversion
mq =
rebase =
hgext.bookmarks =
hgext.graphlog =
mercurial_keyring=
[ui]
username = mattbutton
[tortoisehg]
ui.language = en
[diff]
git = True

my hgrc file in C:\Source\my-project\.hg looks like:

[paths]
default = svn+https://path-to-my-project-repository
[tortoisehg]
postpull = update
autoresolve = False
closeci = True
[ui]
username = mattbutton

my .hgignore in C:\Source\my-project for ASP.NET MVC development in Visual Studio on Windows looks like:

syntax: glob
obj
[Bb]in
_Resharper.*
*.csproj.user
*.resharper.user
*.resharper
*.suo
*.cache
*~
*.swp
*.db
build
GlobalAssemblyInfo.cs
*.sqlite
#ignore thumbnails created by windows
Thumbs.db
#Ignore files build by Visual Studio
*.obj
*.exe
*.pdb
*.user
*.aps
*.pch
*.vspscc
*_i.c
*_p.c
*.ncb
*.suo
*.tlb
*.tlh
*.bak
*.cache
*.ilk
*.log
*.dbmdl
[Bb]in
[Dd]ebug*/
*.lib
*.sbr
obj/
bin/[Rr]elease*/
_ReSharper*/
[Tt]est[Rr]esult*
*.ReSharper

Cloning the Repository

It’s best to clone the entire repository – not just trunk. This way you can take advantage of switching between branches and full history search.

If you’re cloning a large repository with thousands of changesets, you can expect the initial clone to take a few hours.

I recommend that you zip up the repository after the initial clone and keep it as a backup in case something happens to the working repository. This way, you can extract it somewhere and pull without having to go through the time consuming initial clone of the SVN repository.

Import/Export Patch

It’s important that git patches are enabled. Add the following to your mercurial.ini

[diff]
git = True

Without this setting, if you add a new file, commit, then create a patch based on the commit, you’ll discover that the new file is not included in the patch. Enabling git diffs will avoid this problem altogether.

More reading: http://mercurial.selenic.com/wiki/GitExtendedDiffFormat

Branching and Merging

Do not ever use Mercurial for merging when dealing with a SVN repository. SVN only accepts a linear history, thus HG SVN cannot push merge changesets to a SVN repository and you’ll only end up with errors if you attempt this. There are two ways that you can get the same result without a merge.

If you’re working off of the trunk and you want to push your new changes, use the rebase function and deal with any merge conflicts. This will take all of your changesets which you haven’t yet pushed, and append them to the SVN head. You’ll then be able to push a linear history.

** TODO: add note about rebase onto SVN head

The general command line workflow for this is:

hg pull
hg rebase --svn
hg push

If you want to merge changes from one branch to trunk or vice-versa, the export/import patch functionality.

More reading: http://blog.kalleberg.org/post/2337246985/merging-a-mercurial-repository-back-into-subversion

Removing Unversioned Files

When switching between branches, you may end up with files which don’t belong in the revision which you’ve switched to. This may cause problems in your build process. To remove any unversioned files, you can use the ‘purge’ extension:

hg purge --all

When Things Go Wrong and You Can’t Push

Sometimes you’ll have issues pushing to the SVN repository. Perhaps an error like ”

If your changeset can’t be pushed and you’re getting an odd error which isn’t the usual change conflict, a workflow to fix this is:

1. Pull the latest revisions
2. Export the changesets which aren’t pushing as a series of patches
3. Strip the changesets which aren’t pushing
4. Import the patches onto the head
5. Finalize the MQ
6. Push.

Strip will remove the changeset and all it’s descendants.

NB: Strip rewrites history so you should only use it on changesets which haven’t been pushed. You should never attempt to strip a changeset which has been pushed to SVN.

There are other methods such as hg collapse, however I see these as being quite risky and error prone since you’re making destructive. The export/import patch method has been reliable and problem-free for me.

More reading:
http://mercurial.selenic.com/wiki/Strip
http://mercurial.selenic.com/wiki/CollapseExtension

What’s happening here is that you’re connecting to a SQL 10.50 instance with a SQL 10.0 profiler and the profile templates for 10.50 aren’t present.

In the case of the profiler from SQL 2008 connecting to a SQL 2008 R2 instance, copy your 100 profile templates folder (default install is at C:\Program Files (x86)\Microsoft SQL Server\100\Tools\Profiler\Templates\Microsoft SQL Server\100) into a new folder in the same location with the name “1050″ i.e. C:\Program Files (x86)\Microsoft SQL Server\100\Tools\Profiler\Templates\Microsoft SQL Server\1050.

Then try to reconnect, and you’ll have access to the profile templates and everything will work fine.

More information about SQL versions can be found at: http://sqlserverbuilds.blogspot.com/

<script type="text/javascript">
    var gaJsHost = (("https:" == document.location.protocol) ? "https://" : "http://");
    document.write(unescape("%3Cscript src='" + gaJsHost + "ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js' type='text/javascript'%3E%3C/script%3E"));
    document.write(unescape("%3Cscript src='" + gaJsHost + "ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js' type='text/javascript'%3E%3C/script%3E"));
    document.write(unescape("%3Cscript src='" + gaJsHost + "ajax.googleapis.com/ajax/libs/swfobject/2.1/swfobject.js' type='text/javascript'%3E%3C/script%3E"));
</script>

This works just fine, however you can let the browser select the protocol depending on the request by the following snippet:

<script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
<script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js"></script>
<script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/swfobject/2.1/swfobject.js"></script>

This is obviously much cleaner, and you can see the full URL rather than javascript code to build up a string. The key here is the double slash within the src attribute. This kind of url works for any web resource and is particularly useful for loading resources from the Google CDN.

The code and value together are unique, and a composite key is created containing them both.

We load in reference data from an excel spreadsheet, and at some point, there was a code and value pair added to a reference data type which matched exactly with a code and value pair from another reference data type. Attempting to add the second code value pair resulted in a unique key violation.

I needed to add the discriminator column into the composite key. If you’re using auto mapping, you’ll need to add an auto mapping override. Below is an example of creating a composite key containing the code, discriminator and value columns.

 public class ReferenceDataAutoMappingOverride : IAutoMappingOverride<ReferenceData>
 {
 public void Override(AutoMapping<ReferenceData> mapping)
 {
 const string uniqueKeyName = "UK_ReferenceData_discriminator_Code_Value";
 mapping.DiscriminateSubClassesOnColumn<string>("discriminator").UniqueKey(uniqueKeyName);
 mapping.Map(refData => refData.Code).UniqueKey(uniqueKeyName);
 mapping.Map(refData => refData.Value).UniqueKey(uniqueKeyName);
 }
 }

This method is compatible with both IE 6+ and Firefox. It also avoids the IE button bug where button values are not passed on HTTP POST.

After discussing a few design options we decided to allow the user to add the desired search parameters via selecting them one by one from a drop down list. The user will commonly want up to three parameters at a time and may want to remove parameters after adding.

The relevant basic requirements of the search page were as follows:

• The form must work with JavaScript turned off
• 26 optional parameters.
• Display only the active parameters on screen.
• The user must be able to add/remove parameters to/from the screen.
• The user must be able to select individual items from the search results and download full XML certificate data for the selected records.
• The user must be able to export all search results to a CSV file for processing in Excel.

Buttons on forms allow us to go through a single action on the controller, we’ll call this PerformAction.

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult PerformAction(HomeModel model, ButtonActionModel buttonAction)
{
	model.Items.Where(x => x.Key == buttonAction.ActionValue);
	if (buttonAction.ActionName == ButtonActionNames.Remove.ToString())
	{
		RemoveItem(buttonAction.ActionValue, model);
	}
	TempModel = model;
	// Post-get-redirect pattern:
	// http://blog.jorritsalverda.nl/2010/03/10/maintainable-mvc-post-redirect-get-pattern/
	return RedirectToAction(ViewNames.Index, null);
}

PerformAction accepts two parameters; HomeModel contains all of the form data and ButtonActionModel contains the button parameter data.

public class ButtonActionModel
{
	public string ActionName { get; set; }
	public string ActionValue { get; set; }
}

The button model contains the name of the action (i.e. “Remove”) and the value of the action (i.e. “Parameter1″). The names and values are arbitrary and can be handled however you like in the PerformAction method.

In HTML, the buttons look like:

<input name="buttonaction:Remove:Parameter1" type="submit"
       value="Remove Parameter 1"></input>

We’ll need a custom model binder to create the ButtonAction model.

public class ButtonActionBinder : DefaultModelBinder
{
	public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
	{
		var request = controllerContext.HttpContext.Request;
		var formKeys = request.Form.AllKeys;
		ButtonActionModel result = null;
		var indexedbutton = formKeys.Where(x => x.StartsWith("buttonaction")).FirstOrDefault();
		if (indexedbutton != null)
		{
			result = new ButtonActionModel();
			var split = indexedbutton.Split(':');
			result.ActionName = split[1];
			if (split.Length > 2) result.ActionValue = split[2];
		}
		return result;
	}
}

The model binder above is fairly simple, searching the submitted form data for “buttonaction” which is the first part of the button name.

The binder then splits the button name based on the colons, using the second element as the ActionName and the third element as the ActionValue. Once this is done, the binding is complete and the bound model is returned.

Add the model binder to Application_Start in Global.asax.cs

ModelBinders.Binders.Add(typeof(ButtonActionModel),
                         new ButtonActionBinder());

Here’s an extended example demonstrating multiple parameterised form submit buttons without Javascript: MvcMultiSubmit

Sketchflow is missing a sketch style grid among other things, so we looked to Sketchables to provide.

Referencing Sketchables.Silverlight.dll wasn’t enough, the new controls weren’t appearing in the “Assets” panel. Initially I tried referencing the designer files, but that yielded no results. Reading the blog comments from hardcodet.net there was the following one-liner:

The libraries in the “design” folder are automatically picked up. They are used in Blend in order to provide the design time support.

The “Design” folder must sit below the folder which contains the referenced Sketchables.Silverlight.dll; Expression Blend 4 silently scans dlls in the design folder and loads them into the Assets panel.

For bitbucket, the commit username has to match your bitbucket username.

As commits in Mercurial are local, we have no way of controlling that you have set your username correctly. It is important for you to set this up in such a way that we can identify your user account on Bitbucket when you push your commits to us.

In tortoise-hg, the username setting is available through global settings->commit