Derik Whittaker : GitHub

Moving a TFS Git Repository to Github

Derik Whittaker — Tue, 09 Apr 2013 11:16:00 GMT

We gave using the git support in TFS the old college try but the friction and issues were just too much so we decided to move our repository over to github. I am not going to go over our issues w/ TFS git here, but I am thinking of creating a separate post for it.

Because we already had our repository w/ change history setup all we really wanted to do was ‘change remote origin’ for our repository and here are the steps WE took to accomplish this.

Our Steps (it is assume you already have a github account setup)

Go to github.com and create your repository.
Create a copy of your existing tfs/git source and move it to a new directly. I do this simply to ensure I don’t screw anything up and have to do a new pull (i am lazy and xcopy is faster).
1. from c:\TFSRepo –> c:\GithubRepo
Open a git command prompt and CD into the destination directory from step 1
From the command prompt run ‘git remote –v’ this command is a sanity check to double check the current origin of your repository
From the command prompt run ‘git remote rm origin’ this command will remove/clear the origin settings for your reporsitory
From the command prompt run ‘git remote add origin https://github.com/[AccountUserNameHere]/[RepoNameHere].git’ this command will set the origin information to your new repository path in github. Pay attention to the url’s casing as github is case sensitive and you may experience issues if the casing is off.
1. PS. You can get the url above from the github repository page
From the command prompt run ‘git push origin master’ this command will push your current files up to github and publish them. Please note that this will ONLY push the master branch. If you want to push other branches you will need to do a ‘git push origin [branchnamehere]’ for each branch.
Refresh the github.com project page and rejoice in the fact that you are out of TFS and your pain should be greatly reduced :)

These are the steps that worked for us, of course they may be different or better ways, but again these worked for us.

Till next time,

How we handled our branches during our TFS to Git migration

Derik Whittaker — Sat, 10 Nov 2012 18:02:03 GMT

In my prior post I documented the steps and processes that OUR team took to move from hosting our source in a TFS solution to Git/Github (remember, these are SIMPLY our steps). However, one thing I did not mention is how we moved our feature branches from TFS to Github.

Given the fact that TFS and GIT treat branches treated 100% differently at the lowest level, we knew we would NOT be able to clone/convert our features branches in any reasonable manor and push those into Git. However, these branches were still active and did need to get them out of TFS and into Git.

So how did we migrate/push our feature branches from TFS to Git? Simply xCopy :)

What we did was the following

Did a pull from our TFS root into each of the feature branches and resolved any merge issues.
Created the feature branch in Git via the Windows Github client
Switched context on our git repository to be that of the new branch
xCopied our TFS branch files from TFS into the folder of our Git repository
Let the Windows Github client pick up the changes (I had to restart the Windows client in order for changes to get noticed, but that may not be required for everyone)
Committed the changes locally
Synced the changes to Github
Deleted my old branch
Had a beer.

As you can see from above, there were a few steps involved, and there may have been a better way. However, this just worked for us.

Till next time,

Moving from TFS to Github – Steps we took to do the migration

Derik Whittaker — Wed, 07 Nov 2012 12:10:12 GMT

In a previous post I talked about how to use git tfs to extract your source out of a TFS repository, format it for git and finally push that source to Github. This post is a follow up to that prior post and will go a bit further in explaining the exact steps, i took, to do a full end to end migration from TFS to Github (git).

Plan of attack:

Get and install Git TFS (instructions are on this are in my prior post)
Get and install the TFS Powertools
Need to remove all existing TFS bindings from your .csproj and .sln files

The way I found to do this, with a bit of help from my coworker is check out each and every .csproj/.sln file in my source tree.

Open a Visual Studio Command prompt and CD into the folder where your TFS source is stored
Run the command -- tf edit /r *.csproj *.sln this command will check out each and every csproj/sln file in your file structure. This MUST be done in the root of your TFS source files.
Download and run this VS Unbind Source tool I found on codeplex to remove all binding information from the files .
** NOTE **
I noticed after running this that there may be a bug. In all my .sln files the ‘EndGlobalSection’ was removed which caused build failures. I had to manually add them back and then it worked
** NOTE **
Run the command – tfpt uu /r . this command will revert any files which were not actually edited in order to avoid committing unchanged files.
Commit the changes to the .csproj and .sln file back to TFS

Need to export your source from TFS and format it for git. For this you need to use the git tfs tool for this.

CD into the folder where you want to store the new git formatted source and run
git tfs clone http://serveraddresshere:8080/tfs/DefaultCollection $/root/foldername here (of course i removed my company specific settings)

Note, this could take a LONG time depending on how much source you have and how many historical commits. If you don’t care about history do a quick-clone rather than a clone

Push your source to Github.
- This can be done via the command line as:
  git push http://github.com/[GitHubAccountNameHere]/[RepositoryNameHere] master
- This can also be done via the Windows client for Github by simply dropping your root folder into the UI and pushing the changes. The choice is yours.
Sit back and relax, you are now using Github rather than TFS for your source storage….

As you can see completely moving from TFS to Github (or git for that matter) is actually pretty easy and can be done with little effort.

Till next time,

How to migrate your TFS Repository to GitHub

Derik Whittaker — Sun, 09 Sep 2012 11:17:43 GMT

So it has begun. We have been using TFS at work for 2+ years and the time has come to move off of TFS and over to GitHub (we have a few reasons, most of which I am going to avoid for this post as they do not add any real value). Normally when you are going from one system to another you have to run some sort of conversion, this is kinda true here, but not 100%. In this case we are going to be doing a conversion and a publication, both of which are simple.

The basic idea of what we are going to be doing is:

Clone from TFS –> Push to GitHub –> have a beer :)

Really, moving from TFS to GitHub (or git in general) is really easy, but does involve a few steps

Install Chocolately
Install GitTFS (chocolately package) – this is a tool which allows you to use git syntax w/ your TFS repository
Open up a Visual Studio Command prompt
CD into the directory you whish to clone into
Clone your TFS repo locally via Git TFS
There are 2 different ways to do this, you can do a full clone which includes all your commit history or you can do a quick-clone which does not

Clone (this could take a really long time, like hours so be warned)
git tfs clone http://[YourTFSServerHere]:8080/tfs/DefaultCollection $/[NameOfFolderHere]

Quick Clone
git tfs quick-clone http://[YourTFSServerHere]:8080/tfs/DefaultCollection $/[NameOfFolderHere]
Create your repository on GitHub (I found this was just the simplest way)
Go back to your command prompt (ensure you are in the directory that has your files)
Do a git push via
git push http://github.com/[GitHubAccountNameHere]/[RepositoryNameHere] master

Make sure you put master as you need to tell it what branch to do the push to.
Go verify your code is in GitHub
Your done

As you can see getting all your files out of TFS and into GitHub is pretty simple, but does involve a few steps (and possibly a few hours depending on how much commit history you have in TFS).

Hope this helps,

Till next time,