From 7e29fa2122cbe12aa45d641439067e94c3c2a10d Mon Sep 17 00:00:00 2001
From: Ahmed ElSayed <ahmels@microsoft.com>
Date: Wed, 14 Jan 2015 18:33:50 -0800
Subject: [PATCH] support both libgit2sharp and gitexe at the same time and
 update test cases

---
 .editorconfig                                 |  15 -
 Kudu.Console/Program.cs                       |  10 +-
 .../Settings/DeploymentSettingsExtension.cs   |   5 +
 Kudu.Contracts/Settings/SettingsKeys.cs       |   1 +
 Kudu.Contracts/SourceControl/IRepository.cs   |   2 +-
 .../SourceControl/IRepositoryFactory.cs       |   1 +
 Kudu.Core.Test/GitRepositoryTest.cs           |  43 +-
 Kudu.Core.Test/NullRepositoryFacts.cs         |   2 +-
 Kudu.Core/Kudu.Core.csproj                    |  12 +-
 .../SourceControl/Git/GitExeRepository.cs     | 169 ++++---
 Kudu.Core/SourceControl/Git/IGitRepository.cs |  13 +
 .../Git/LibGit2SharpRepository.cs             | 418 ++++++++++++++++++
 Kudu.Core/SourceControl/Hg/HgRepository.cs    |  11 +-
 Kudu.Core/SourceControl/NullRepository.cs     |   8 +-
 Kudu.Core/SourceControl/RepositoryFactory.cs  |  33 +-
 Kudu.Core/packages.config                     |   2 +-
 .../DeploymentManagerTests.cs                 |  77 ++--
 Kudu.FunctionalTests/GitRepositoryFacts.cs    | 103 +++--
 .../Infrastructure/KuduAssert.cs              |  25 ++
 .../Vfs/VfsControllerBaseTest.cs              |  10 +-
 .../App_Start/NinjectServices.cs              |   5 -
 Kudu.Services/FetchHelpers/DropboxHelper.cs   |   2 +-
 Kudu.Services/GitServer/InfoRefsController.cs |   2 +-
 .../SourceControl/LiveScmController.cs        |   5 +-
 .../SourceControl/LiveScmEditorController.cs  |   7 +-
 Kudu.TestHarness/TestRepository.cs            |   5 +-
 build.cmd                                     |  19 +-
 27 files changed, 797 insertions(+), 208 deletions(-)
 delete mode 100644 .editorconfig
 create mode 100644 Kudu.Core/SourceControl/Git/IGitRepository.cs
 create mode 100644 Kudu.Core/SourceControl/Git/LibGit2SharpRepository.cs

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 096ff2565..000000000
--- a/.editorconfig
+++ /dev/null
@@ -1,15 +0,0 @@
-; Check http://editorconfig.org/ for more informations
-; Top-most EditorConfig file
-root = true
-
-; 4-column space indentation
-[*]
-indent_style = space
-indent_size = 4
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-; Not change VS generated files
-[*.{sln,csroj}]
-trim_trailing_whitespace = false
-insert_final_newline = false
diff --git a/Kudu.Console/Program.cs b/Kudu.Console/Program.cs
index f5a3ed6d8..e2b3fbaa7 100644
--- a/Kudu.Console/Program.cs
+++ b/Kudu.Console/Program.cs
@@ -83,7 +83,15 @@ private static int Main(string[] args)
             IBuildPropertyProvider buildPropertyProvider = new BuildPropertyProvider();
             ISiteBuilderFactory builderFactory = new SiteBuilderFactory(buildPropertyProvider, env);
 
-            IRepository gitRepository = new GitExeRepository(env, settingsManager, traceFactory);
+            IRepository gitRepository;
+            if (settingsManager.UseLibGit2SharpRepository())
+            {
+                gitRepository = new LibGit2SharpRepository(env, settingsManager, traceFactory);
+            }
+            else
+            {
+                gitRepository = new GitExeRepository(env, settingsManager, traceFactory);
+            }
 
             IServerConfiguration serverConfiguration = new ServerConfiguration();
             IAnalytics analytics = new Analytics(settingsManager, serverConfiguration, traceFactory);
diff --git a/Kudu.Contracts/Settings/DeploymentSettingsExtension.cs b/Kudu.Contracts/Settings/DeploymentSettingsExtension.cs
index fa2939b1e..947560902 100644
--- a/Kudu.Contracts/Settings/DeploymentSettingsExtension.cs
+++ b/Kudu.Contracts/Settings/DeploymentSettingsExtension.cs
@@ -190,5 +190,10 @@ public static string GetSiteExtensionRemoteUrl(this IDeploymentSettingsManager s
             string value = settings.GetValue(SettingsKeys.SiteExtensionsFeedUrl);
             return !String.IsNullOrEmpty(value) ? value : DefaultSiteExtensionFeedUrl;
         }
+
+        public static bool UseLibGit2SharpRepository(this IDeploymentSettingsManager settings)
+        {
+            return settings.GetValue(SettingsKeys.UseLibGit2SharpRepository) == "1";
+        }
     }
 }
\ No newline at end of file
diff --git a/Kudu.Contracts/Settings/SettingsKeys.cs b/Kudu.Contracts/Settings/SettingsKeys.cs
index 1423bf91b..c35e71894 100644
--- a/Kudu.Contracts/Settings/SettingsKeys.cs
+++ b/Kudu.Contracts/Settings/SettingsKeys.cs
@@ -23,6 +23,7 @@ public static class SettingsKeys
         public const string TargetPath = "SCM_TARGET_PATH";
         public const string RepositoryPath = "SCM_REPOSITORY_PATH";
         public const string NoRepository = "SCM_NO_REPOSITORY";
+        public const string UseLibGit2SharpRepository = "SCM_USE_LIBGIT2SHARP_REPOSITORY";
         // Free, Shared, Basic, Standard, Premium
         public const string WebSiteSku = "WEBSITE_SKU";
         public const string WebJobsRestartTime = "WEBJOBS_RESTART_TIME";
diff --git a/Kudu.Contracts/SourceControl/IRepository.cs b/Kudu.Contracts/SourceControl/IRepository.cs
index 5a0da0d91..cc1d8d49d 100644
--- a/Kudu.Contracts/SourceControl/IRepository.cs
+++ b/Kudu.Contracts/SourceControl/IRepository.cs
@@ -26,7 +26,7 @@ public interface IRepository : IFileFinder
         /// Commits new, modified and deleted files to the repository.
         /// </summary>
         /// <returns>True if one or more files were added to a changeset</returns>
-        bool Commit(string message, string authorName);
+        bool Commit(string message, string authorName, string emailAddress);
         void Update(string id);
         void Update();
         void Push();
diff --git a/Kudu.Contracts/SourceControl/IRepositoryFactory.cs b/Kudu.Contracts/SourceControl/IRepositoryFactory.cs
index 143b03b07..aa2fe77f2 100644
--- a/Kudu.Contracts/SourceControl/IRepositoryFactory.cs
+++ b/Kudu.Contracts/SourceControl/IRepositoryFactory.cs
@@ -7,5 +7,6 @@ public interface IRepositoryFactory
         IRepository EnsureRepository(RepositoryType repositoryType);
         IRepository GetRepository();
         IRepository GetCustomRepository();
+        IRepository GetGitRepository();
     }
 }
diff --git a/Kudu.Core.Test/GitRepositoryTest.cs b/Kudu.Core.Test/GitRepositoryTest.cs
index 00f1aa95b..07c75f489 100644
--- a/Kudu.Core.Test/GitRepositoryTest.cs
+++ b/Kudu.Core.Test/GitRepositoryTest.cs
@@ -16,6 +16,47 @@ namespace Kudu.Core.Test
 {
     public class GitRepositoryTest
     {
+        [Fact]
+        public void ParseCommitParsesCommit()
+        {
+            string commitText = @"commit 307d8fe354ff30609decef49f91195e2e9719398
+Author: David Fowler <davidfowl@gmail.com>
+Date:   Thu Jul 7 19:05:40 2011 -0700
+
+    Initial commit";
+
+            ChangeSet changeSet = GitExeRepository.ParseCommit(commitText.AsReader());
+
+            Assert.Equal("307d8fe354ff30609decef49f91195e2e9719398", changeSet.Id);
+            Assert.Equal("David Fowler", changeSet.AuthorName);
+            Assert.Equal("davidfowl@gmail.com", changeSet.AuthorEmail);
+            Assert.Equal("Initial commit", changeSet.Message);
+        }
+
+        [Fact]
+        public void ParseCommitWithMultipleCommitsParsesOneCommit()
+        {
+            string commitText = @"commit d35697645e2472f5e327c0ec4b9f3489e806c276
+Author: John Doe
+Date:   Thu Jul 7 19:23:07 2011 -0700
+
+    Second commit
+
+commit 307d8fe354ff30609decef49f91195e2e9719398
+Author: David Fowler <davidfowl@gmail.com>
+Date:   Thu Jul 7 19:05:40 2011 -0700
+
+    Initial commit
+";
+
+            ChangeSet changeSet = GitExeRepository.ParseCommit(commitText.AsReader());
+
+            Assert.Equal("d35697645e2472f5e327c0ec4b9f3489e806c276", changeSet.Id);
+            Assert.Equal("John Doe", changeSet.AuthorName);
+            Assert.Null(changeSet.AuthorEmail);
+            Assert.Equal(@"Second commit", changeSet.Message);
+        }
+
         [Theory]
         [InlineData(" a b c \\d e f", " a b c \\d e f")]
         [InlineData("\"\\303\\245benr\\303\\245.sln\"", "\"åbenrå.sln\"")]
@@ -49,7 +90,7 @@ public void GitExecuteWithRetryTest(string message, int expect)
             // Test
             try
             {
-                repository.GitFetchWithRetry(() =>
+                repository.ExecuteGenericGitCommandWithRetryAndCatchingWellKnownGitErrors(() =>
                 {
                     ++actual;
                     if (message == null)
diff --git a/Kudu.Core.Test/NullRepositoryFacts.cs b/Kudu.Core.Test/NullRepositoryFacts.cs
index 77a00e9cd..bf149266a 100644
--- a/Kudu.Core.Test/NullRepositoryFacts.cs
+++ b/Kudu.Core.Test/NullRepositoryFacts.cs
@@ -51,7 +51,7 @@ public void NullRepositoryCommitTests()
             var message = "this is testing";
             var author = "john doe";
             var email = "john.doe@live.com";
-            var success = repository.Commit(message, author + " <" + email + ">");
+            var success = repository.Commit(message, author, email);
 
             // Assert
             Assert.True(success);
diff --git a/Kudu.Core/Kudu.Core.csproj b/Kudu.Core/Kudu.Core.csproj
index 7d889fd05..e0390ea96 100644
--- a/Kudu.Core/Kudu.Core.csproj
+++ b/Kudu.Core/Kudu.Core.csproj
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\LibGit2Sharp.0.20.0.0\build\net40\LibGit2Sharp.props" Condition="Exists('..\packages\LibGit2Sharp.0.20.0.0\build\net40\LibGit2Sharp.props')" />
+  <Import Project="..\packages\LibGit2Sharp.0.20.2.0\build\net40\LibGit2Sharp.props" Condition="Exists('..\packages\LibGit2Sharp.0.20.2.0\build\net40\LibGit2Sharp.props')" />
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Kudu.sln))\Build\Kudu.targets" />
   <PropertyGroup>
     <ProjectGuid>{5320177C-725A-44BD-8FA6-F88D9725B46C}</ProjectGuid>
@@ -8,10 +8,12 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Kudu.Core</RootNamespace>
     <AssemblyName>Kudu.Core</AssemblyName>
+    <NuGetPackageImportStamp>4423e462</NuGetPackageImportStamp>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="LibGit2Sharp">
-      <HintPath>..\packages\LibGit2Sharp.0.20.0.0\lib\net40\LibGit2Sharp.dll</HintPath>
+    <Reference Include="LibGit2Sharp, Version=0.20.2.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\LibGit2Sharp.0.20.2.0\lib\net40\LibGit2Sharp.dll</HintPath>
     </Reference>
     <Reference Include="Mercurial.Net, Version=1.1.1.607, Culture=neutral, PublicKeyToken=9e2fabf3af85dba9, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -107,6 +109,8 @@
     <Compile Include="Settings\DiagnosticsSettingsManager.cs" />
     <Compile Include="SiteExtensions\SemanticVersion.cs" />
     <Compile Include="SiteExtensions\SiteExtensionManager.cs" />
+    <Compile Include="SourceControl\Git\IGitRepository.cs" />
+    <Compile Include="SourceControl\Git\LibGit2SharpRepository.cs" />
     <Compile Include="Tracing\KuduEventSource.cs" />
     <Compile Include="Tracing\KuduSiteExtensionLogEvent.cs" />
     <Compile Include="Tracing\NullTracer.cs" />
@@ -260,7 +264,7 @@
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
     <Error Condition="!Exists('..\packages\Microsoft.Diagnostics.Tracing.EventRegister.1.0.26\build\Microsoft.Diagnostics.Tracing.EventRegister.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Diagnostics.Tracing.EventRegister.1.0.26\build\Microsoft.Diagnostics.Tracing.EventRegister.targets'))" />
-    <Error Condition="!Exists('..\packages\LibGit2Sharp.0.20.0.0\build\net40\LibGit2Sharp.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\LibGit2Sharp.0.20.0.0\build\net40\LibGit2Sharp.props'))" />
+    <Error Condition="!Exists('..\packages\LibGit2Sharp.0.20.2.0\build\net40\LibGit2Sharp.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\LibGit2Sharp.0.20.2.0\build\net40\LibGit2Sharp.props'))" />
   </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Kudu.Core/SourceControl/Git/GitExeRepository.cs b/Kudu.Core/SourceControl/Git/GitExeRepository.cs
index b42094b86..7ddd5428c 100644
--- a/Kudu.Core/SourceControl/Git/GitExeRepository.cs
+++ b/Kudu.Core/SourceControl/Git/GitExeRepository.cs
@@ -8,14 +8,13 @@
 using Kudu.Contracts.Tracing;
 using Kudu.Core.Infrastructure;
 using Kudu.Core.Tracing;
-using LibGit2Sharp;
 
 namespace Kudu.Core.SourceControl.Git
 {
     /// <summary>
     /// Implementation of a git repository over git.exe
     /// </summary>
-    public class GitExeRepository : IRepository
+    public class GitExeRepository : IGitRepository
     {
         private const string RemoteAlias = "external";
 
@@ -47,7 +46,7 @@ public string CurrentId
         {
             get
             {
-                return ResolveHeadPeeledTargetId();
+                return Resolve("HEAD");
             }
         }
 
@@ -117,29 +116,27 @@ public void Initialize()
             var tracer = _tracerFactory.GetTracer();
             using (tracer.Step("GitExeRepository.Initialize"))
             {
-                string gitdir = LibGit2Sharp.Repository.Init(RepositoryPath);
+                Execute(tracer, "init");
 
-                using (var repo = new LibGit2Sharp.Repository(gitdir))
-                {
-                    repo.Config.Set("core.autocrlf", true);
+                Execute(tracer, "config core.autocrlf true");
 
-                    // This speeds up git operations like 'git checkout', especially on slow drives like in Azure
-                    repo.Config.Set("core.preloadindex", true);
+                // This speeds up git operations like 'git checkout', especially on slow drives like in Azure
+                Execute(tracer, "config core.preloadindex true");
 
-                    repo.Config.Set("user.name", _settings.GetGitUsername());
+                Execute(tracer, @"config user.name ""{0}""", _settings.GetGitUsername());
 
-                    repo.Config.Set("user.email", _settings.GetGitEmail());
+                Execute(tracer, @"config user.email ""{0}""", _settings.GetGitEmail());
 
-                    using (tracer.Step("Configure git server"))
-                    {
-                        // Allow getting pushes even though we're not bare
-                        repo.Config.Set("receive.denyCurrentBranch", "ignore");
-                    }
+                using (tracer.Step("Configure git server"))
+                {
+                    // Allow getting pushes even though we're not bare
+                    Execute(tracer, "config receive.denyCurrentBranch ignore");
+                }
 
-                    // to disallow browsing to this folder in case of in-place repo
-                    using (tracer.Step("Create deny users for .git folder"))
-                    {
-                        string content = "<?xml version=\"1.0\"" + @"?>
+                // to disallow browsing to this folder in case of in-place repo
+                using (tracer.Step("Create deny users for .git folder"))
+                {
+                    string content = "<?xml version=\"1.0\"" + @"?>
 <configuration>
   <system.web>
     <authorization>
@@ -148,25 +145,24 @@ public void Initialize()
   </system.web>
 <configuration>";
 
-                        File.WriteAllText(Path.Combine(_gitExe.WorkingDirectory, ".git", "web.config"), content);
-                    }
+                    File.WriteAllText(Path.Combine(_gitExe.WorkingDirectory, ".git", "web.config"), content);
+                }
 
-                    // Server env does not support interactive cred prompt; hence, we intercept any credential provision
-                    // for git fetch/clone with http/https scheme and return random invalid u/p forcing 'fatal: Authentication failed.'
-                    using (tracer.Step("Configure git-credential"))
-                    {
-                        FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(GitCredentialHookPath));
+                // Server env does not support interactive cred prompt; hence, we intercept any credential provision
+                // for git fetch/clone with http/https scheme and return random invalid u/p forcing 'fatal: Authentication failed.'
+                using (tracer.Step("Configure git-credential"))
+                {
+                    FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(GitCredentialHookPath));
 
-                        string content = @"#!/bin/sh
+                    string content = @"#!/bin/sh
 if [ " + "\"$1\" = \"get\"" + @" ]; then
       echo username=dummyUser
       echo password=dummyPassword
 fi" + "\n";
 
-                        File.WriteAllText(GitCredentialHookPath, content);
+                    File.WriteAllText(GitCredentialHookPath, content);
 
-                        repo.Config.Set("credential.helper", string.Format("!'{0}'", GitCredentialHookPath));
-                    }
+                    Execute(tracer, "config credential.helper \"!'{0}'\"", GitCredentialHookPath);
                 }
 
                 using (tracer.Step("Setup post receive hook"))
@@ -186,40 +182,37 @@ read i
             }
         }
 
-        private string ResolveHeadPeeledTargetId()
+        public string Resolve(string id)
         {
-            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
-            {
-                var headTip = repo.Head.Tip;
-
-                return headTip == null ? null : headTip.Sha;
-            }
+            return Execute("rev-parse {0}", id).Trim();
         }
 
         public ChangeSet GetChangeSet(string id)
         {
-            using (LibGit2Sharp.IRepository repo = new LibGit2Sharp.Repository(RepositoryPath))
+            string output = null;
+            try
             {
-                LibGit2Sharp.Commit commit = repo.Lookup<LibGit2Sharp.Commit>(id);
-
-                if (commit == null)
+                output = Execute("log -n 1 {0} --", id);
+            }
+            catch (CommandLineException ex)
+            {
+                if (!String.IsNullOrEmpty(ex.Message) && ex.Message.IndexOf("bad revision ", StringComparison.OrdinalIgnoreCase) != -1)
                 {
+                    // Indicates the changeset does not exist in the repo.
                     return null;
                 }
-
-                return new ChangeSet(commit.Sha, commit.Author.Name, commit.Author.Email, commit.Message, commit.Author.When);
+                throw;
             }
+            var commitReader = output.AsReader();
+            return ParseCommit(commitReader);
         }
 
         public void AddFile(string path)
         {
-            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
-            {
-                repo.Stage(path);
-            }
+            Execute("add {0}", path);
         }
 
-        public bool Commit(string message, string authorName = null)
+        public bool Commit(string message, string authorName = null, string emailAddress = null)
         {
             ITracer tracer = _tracerFactory.GetTracer();
 
@@ -229,13 +222,13 @@ public bool Commit(string message, string authorName = null)
             try
             {
                 string output;
-                if (authorName == null)
+                if (authorName == null || emailAddress == null)
                 {
                     output = Execute(tracer, "commit -m \"{0}\"", message);
                 }
                 else
                 {
-                    output = Execute(tracer, "commit -m \"{0}\" --author=\"{1}\"", message, authorName);
+                    output = Execute(tracer, "commit -m \"{0}\" --author=\"{1} <{2}>\"", message, authorName, emailAddress);
                 }
 
                 // No pending changes
@@ -286,7 +279,7 @@ public void FetchWithoutConflict(string remote, string branchName)
 
                 try
                 {
-                    GitFetchWithRetry(() => Execute(tracer, fetchCommand, RemoteAlias));
+                    ExecuteGenericGitCommandWithRetryAndCatchingWellKnownGitErrors(() => Execute(tracer, fetchCommand, RemoteAlias));
                 }
                 catch (CommandLineException exception)
                 {
@@ -315,11 +308,7 @@ public void FetchWithoutConflict(string remote, string branchName)
 
         public void Update(string id)
         {
-            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
-            {
-                repo.Checkout(id,
-                    new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force });
-            }
+            Execute("checkout {0} --force", id);
         }
 
         public void Update()
@@ -338,7 +327,7 @@ public void UpdateSubmodules()
                 // git submodule sync will update related git/config to reflect that change
                 Execute("submodule sync");
 
-                GitFetchWithRetry(() => Execute("submodule update --init --recursive"));
+                ExecuteGenericGitCommandWithRetryAndCatchingWellKnownGitErrors(() => Execute("submodule update --init --recursive"));
             }
         }
 
@@ -484,7 +473,7 @@ private string ParseGitDirectory()
 
         // Corrupted git where .git/HEAD exists but only contains \0.
         // we've since this issue on a few occasions but don't really understand what causes it
-        private bool TryFixCorruptedGit()
+        internal bool TryFixCorruptedGit()
         {
             var headFile = Path.Combine(_gitExe.WorkingDirectory, ".git", "HEAD");
             if (FileSystemHelpers.FileExists(headFile))
@@ -556,7 +545,7 @@ private void TryDeleteRemote(string remoteAlias, ITracer tracer)
             catch { }
         }
 
-        internal T GitFetchWithRetry<T>(Func<T> func)
+        internal T ExecuteGenericGitCommandWithRetryAndCatchingWellKnownGitErrors<T>(Func<T> func)
         {
             // 3 retries with 1s interval
             return OperationManager.Attempt(func, delayBeforeRetry: 1000, shouldRetry: ex =>
@@ -571,5 +560,65 @@ internal T GitFetchWithRetry<T>(Func<T> func)
                 return false;
             });
         }
+
+        internal static ChangeSet ParseCommit(IStringReader reader)
+        {
+            // commit hash
+            reader.ReadUntilWhitespace();
+            reader.SkipWhitespace();
+            string id = reader.ReadUntilWhitespace();
+
+            // Merges will have (from hash) so we're skipping that
+            reader.ReadLine();
+
+            string author = null;
+            string email = null;
+            string date = null;
+
+            while (!reader.Done)
+            {
+                string line = reader.ReadLine();
+
+                if (ParserHelpers.IsSingleNewLine(line))
+                {
+                    break;
+                }
+
+                var subReader = line.AsReader();
+                string key = subReader.ReadUntil(':');
+                // Skip :
+                subReader.Skip();
+                subReader.SkipWhitespace();
+                string value = subReader.ReadToEnd().Trim();
+
+                if (key.Equals("Author", StringComparison.OrdinalIgnoreCase))
+                {
+                    // Author <email>
+                    var authorReader = value.AsReader();
+                    author = authorReader.ReadUntil('<').Trim();
+                    authorReader.Skip();
+                    email = authorReader.ReadUntil('>');
+                }
+                else if (key.Equals("Date", StringComparison.OrdinalIgnoreCase))
+                {
+                    date = value;
+                }
+            }
+
+            var messageBuilder = new StringBuilder();
+            while (!reader.Done)
+            {
+                string line = reader.ReadLine();
+
+                if (ParserHelpers.IsSingleNewLine(line))
+                {
+                    break;
+                }
+                messageBuilder.Append(line);
+            }
+
+            string message = messageBuilder.ToString().Trim();
+            return new ChangeSet(id, author, email, message, DateTimeOffset.ParseExact(date, "ddd MMM d HH:mm:ss yyyy zzz", CultureInfo.InvariantCulture));
+        }
     }
 }
diff --git a/Kudu.Core/SourceControl/Git/IGitRepository.cs b/Kudu.Core/SourceControl/Git/IGitRepository.cs
new file mode 100644
index 000000000..0c440064d
--- /dev/null
+++ b/Kudu.Core/SourceControl/Git/IGitRepository.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Kudu.Core.SourceControl.Git
+{
+    public interface IGitRepository : IRepository
+    {
+        bool SkipPostReceiveHookCheck { get; set; }
+    }
+}
diff --git a/Kudu.Core/SourceControl/Git/LibGit2SharpRepository.cs b/Kudu.Core/SourceControl/Git/LibGit2SharpRepository.cs
new file mode 100644
index 000000000..d5b7d95b2
--- /dev/null
+++ b/Kudu.Core/SourceControl/Git/LibGit2SharpRepository.cs
@@ -0,0 +1,418 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Kudu.Contracts.Settings;
+using Kudu.Core.Tracing;
+using System.IO;
+using Kudu.Core.Infrastructure;
+using LibGit2Sharp;
+using Kudu.Contracts.Tracing;
+using System.Text.RegularExpressions;
+
+namespace Kudu.Core.SourceControl.Git
+{
+    public class LibGit2SharpRepository : IGitRepository
+    {
+        private const string _remoteAlias = "external";
+        private readonly ITraceFactory _tracerFactory;
+        private readonly IDeploymentSettingsManager _settings;
+        private readonly GitExeRepository _legacyGitExeRepository;
+
+        public LibGit2SharpRepository(IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory tracerFactory)
+        {
+            _tracerFactory = tracerFactory;
+            _settings = settings;
+            RepositoryPath = environment.RepositoryPath;
+            _legacyGitExeRepository = new GitExeRepository(environment, settings, tracerFactory);
+        }
+
+        public string CurrentId
+        {
+            get
+            {
+                using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+                {
+                    var headTip = repo.Head.Tip;
+
+                    return headTip == null ? null : headTip.Sha;
+                }
+            }
+        }
+
+        public string RepositoryPath { get; private set; }
+
+        public RepositoryType RepositoryType
+        {
+            get
+            {
+                return RepositoryType.Git;
+            }
+        }
+
+        public void Initialize()
+        {
+            var tracer = _tracerFactory.GetTracer();
+            using (tracer.Step("LibGit2SharpRepository Initialize"))
+            {
+                var dotGitPath = LibGit2Sharp.Repository.Init(RepositoryPath);
+                using (var repo = new LibGit2Sharp.Repository(dotGitPath))
+                {
+                    repo.Config.Set("core.autocrlf", true);
+
+                    // This speeds up git operations like 'git checkout', especially on slow drives like in Azure
+                    repo.Config.Set("core.preloadindex", true);
+
+                    repo.Config.Set("user.name", _settings.GetGitUsername());
+
+                    repo.Config.Set("user.email", _settings.GetGitEmail());
+
+                    using (tracer.Step("Configure git server"))
+                    {
+                        // Allow getting pushes even though we're not bare
+                        repo.Config.Set("receive.denyCurrentBranch", "ignore");
+                    }
+
+                    // to disallow browsing to this folder in case of in-place repo
+                    using (tracer.Step("Create deny users for .git folder"))
+                    {
+                        string content = "<?xml version=\"1.0\"" + @"?>
+<configuration>
+  <system.web>
+    <authorization>
+      <deny users=" + "\"*\"" + @"/>
+    </authorization>
+  </system.web>
+<configuration>";
+
+                        File.WriteAllText(Path.Combine(dotGitPath, "web.config"), content);
+                    }
+
+                    // Server env does not support interactive cred prompt; hence, we intercept any credential provision
+                    // for git fetch/clone with http/https scheme and return random invalid u/p forcing 'fatal: Authentication failed.'
+                    using (tracer.Step("Configure git-credential"))
+                    {
+                        FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(GitCredentialHookPath));
+
+                        string content = @"#!/bin/sh
+if [ " + "\"$1\" = \"get\"" + @" ]; then
+      echo username=dummyUser
+      echo password=dummyPassword
+fi" + "\n";
+
+                        File.WriteAllText(GitCredentialHookPath, content);
+
+                        repo.Config.Set("credential.helper", string.Format("!'{0}'", GitCredentialHookPath));
+                    }
+                }
+                using (tracer.Step("Setup post receive hook"))
+                {
+                    FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(PostReceiveHookPath));
+
+                    string content = @"#!/bin/sh
+read i
+echo $i > pushinfo
+" + KnownEnvironment.KUDUCOMMAND + "\n";
+
+                    File.WriteAllText(PostReceiveHookPath, content);
+                }
+
+                // NOTE: don't add any new init steps after creating the post receive hook,
+                // as it's also used to mark that Init was fully executed
+            }
+        }
+
+        private string GitCredentialHookPath
+        {
+            get
+            {
+                return Path.Combine(RepositoryPath, ".git", "hooks", "git-credential-invalid.sh");
+            }
+        }
+
+        public ChangeSet GetChangeSet(string id)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                LibGit2Sharp.Commit commit = repo.Lookup<LibGit2Sharp.Commit>(id);
+
+                if (commit == null)
+                {
+                    return null;
+                }
+
+                return new ChangeSet(commit.Sha, commit.Author.Name, commit.Author.Email, commit.Message, commit.Author.When);
+            }
+        }
+
+        public void AddFile(string path)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                repo.Stage(path);
+            }
+        }
+
+        public bool Commit(string message, string authorName, string emailAddress)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                var changes = repo.RetrieveStatus(new StatusOptions
+                {
+                    DetectRenamesInIndex = false,
+                    DetectRenamesInWorkDir = false
+                }).Select(c => c.FilePath);
+
+                if (!changes.Any())
+                {
+                    return false;
+                }
+
+                repo.Stage(changes);
+                if (string.IsNullOrWhiteSpace(authorName) ||
+                    string.IsNullOrWhiteSpace(emailAddress))
+                {
+                    repo.Commit(message);
+                }
+                else
+                {
+                    repo.Commit(message, new Signature(authorName, emailAddress, DateTimeOffset.UtcNow));
+                }
+                return true;
+            }
+        }
+
+        public void Update(string id)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                repo.Checkout(id, new CheckoutOptions { CheckoutModifiers = CheckoutModifiers.Force });
+            }
+        }
+
+        public void Update()
+        {
+            Update("master");
+        }
+
+        public void Push()
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                var masterBranch = repo.Branches["master"];
+                repo.Network.Push(masterBranch);
+            }
+        }
+
+        public void FetchWithoutConflict(string remoteUrl, string branchName)
+        {
+            try
+            {
+                using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+                {
+                    var trackedBranchName = string.Format("{0}/{1}", _remoteAlias, branchName);
+                    var refSpec = string.Format("+refs/heads/{0}:refs/remotes/{1}", branchName, trackedBranchName);
+
+                    // Configure the remote
+                    var remote = repo.Network.Remotes.Add(_remoteAlias, remoteUrl, refSpec);
+
+                    // This will only retrieve the "master"
+                    repo.Network.Fetch(remote);
+
+                    // Optionally set up the branch tracking configuration
+                    var trackedBranch = repo.Branches[trackedBranchName];
+                    if (trackedBranch == null)
+                    {
+                        throw new BranchNotFoundException(branchName, null);
+                    }
+                    var branch = repo.Branches[branchName] ?? repo.CreateBranch(branchName, trackedBranch.Tip);
+                    repo.Branches.Update(branch,
+                        b => b.TrackedBranch = trackedBranch.CanonicalName);
+
+                    //Update the raw ref to point the head of branchName to the latest fetched branch
+                    UpdateRawRef(string.Format("refs/heads/{0}", branchName), trackedBranchName);
+
+                    // Now checkout out our branch, which points to the right place
+                    Update(branchName);
+                }
+            }
+            catch (LibGit2SharpException exception)
+            {
+                if (exception.Message.Equals("Unsupported URL protocol"))
+                {
+                    // LibGit2Sharp doesn't support SSH yet. Use GitExeRepository
+                    _legacyGitExeRepository.FetchWithoutConflict(remoteUrl, branchName);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+            finally
+            {
+                using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+                {
+                    repo.Network.Remotes.Remove(_remoteAlias);
+                }
+            }
+        }
+
+        public void Clean()
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                repo.RemoveUntrackedFiles();
+            }
+        }
+
+        public void CreateOrResetBranch(string branchName, string startPoint)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                if (string.IsNullOrWhiteSpace(startPoint))
+                {
+                    var branch = repo.GetOrCreateBranch(branchName);
+                    repo.Checkout(branch);
+                }
+                else
+                {
+                    var commit = repo.Lookup<Commit>(startPoint);
+                    if (commit == null)
+                    {
+                        throw new LibGit2Sharp.NotFoundException(string.Format("Start point \"{0}\" for reset was not found.", startPoint));
+                    }
+                    var branch = repo.GetOrCreateBranch(branchName);
+                    repo.Checkout(branch);
+                    repo.Reset(ResetMode.Hard, commit);
+                }
+            }
+        }
+
+        public void UpdateRef(string toBeUpdatedToAlias)
+        {
+            UpdateRawRef(string.Format("refs/heads/{0}", "master"), string.Format("refs/heads/{0}", toBeUpdatedToAlias));
+        }
+
+        public void UpdateRawRef(string toBeUpdatedRef, string toBeUpdatedToRef)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                repo.Refs.UpdateTarget(toBeUpdatedRef, toBeUpdatedToRef);
+            }
+        }
+
+        public bool DoesBranchContainCommit(string branchName, string commitOrBranchName)
+        {
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                var branch = repo.Branches[branchName];
+                if (branch == null) return false;
+                return repo.Refs.ReachableFrom(
+                              new[] { repo.Refs[branch.CanonicalName] },
+                              new[] { repo.Lookup<Commit>(commitOrBranchName) }).Any();
+            }
+        }
+
+        public IEnumerable<string> ListFiles(string path, SearchOption searchOption, params string[] lookupList)
+        {
+            path = PathUtility.CleanPath(path);
+
+            if (!FileSystemHelpers.IsSubfolder(RepositoryPath, path))
+            {
+                throw new NotSupportedException("Only paths relative to the repository root path are supported, path provided: '{0}' is not a child folder of '{1}'".FormatCurrentCulture(path, RepositoryPath));
+            }
+
+            if (!Directory.Exists(path)) return Enumerable.Empty<string>();
+
+            var lookupPatterns = lookupList.Select(l => string.Format("^{0}$", Regex.Escape(l).Replace("\\*", ".*")));
+
+            using (var repo = new LibGit2Sharp.Repository(RepositoryPath))
+            {
+                var files = repo.Diff.Compare<TreeChanges>(null, DiffTargets.Index, lookupList, compareOptions: new CompareOptions() { IncludeUnmodified = true, Similarity = SimilarityOptions.None })
+                                      .Select(d => Path.Combine(repo.Info.WorkingDirectory, d.Path))
+                                      .Where(p => p.StartsWith(path, StringComparison.OrdinalIgnoreCase));
+
+                switch (searchOption)
+                {
+                    case SearchOption.TopDirectoryOnly:
+                        files = files.Where(line => !line.Substring(path.Length).TrimStart('\\').Contains('\\'));
+                        break;
+
+                    case SearchOption.AllDirectories:
+                        break;
+
+                    default:
+                        throw new NotSupportedException("Search option {0} is not supported".FormatCurrentCulture(searchOption));
+                }
+                // Make sure to materialize the list before finalizing repo
+                return files.ToList();
+            }
+        }
+
+        private string PostReceiveHookPath
+        {
+            get
+            {
+                return Path.Combine(RepositoryPath, ".git", "hooks", "post-receive");
+            }
+        }
+
+        public bool SkipPostReceiveHookCheck
+        {
+            get;
+            set;
+        }
+
+        public bool Exists
+        {
+            get
+            {
+                if (!SkipPostReceiveHookCheck && !File.Exists(PostReceiveHookPath))
+                {
+                    return false;
+                }
+
+                if (LibGit2Sharp.Repository.IsValid(RepositoryPath))
+                {
+                    // This should no-op if HEAD size > 0
+                    // Corrupted HEAD might happen if the process was terminated during a long running git operation.
+                    _legacyGitExeRepository.TryFixCorruptedGit();
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        public void UpdateSubmodules()
+        {
+            _legacyGitExeRepository.UpdateSubmodules();
+        }
+
+        public void ClearLock()
+        {
+            _legacyGitExeRepository.ClearLock();
+        }
+
+        public bool Rebase(string branchName)
+        {
+            return _legacyGitExeRepository.Rebase(branchName);
+        }
+
+        public void RebaseAbort()
+        {
+            _legacyGitExeRepository.RebaseAbort();
+        }
+    }
+
+    public static class RepositoryExtensions
+    {
+        public static Branch GetOrCreateBranch(this Repository repo, string branchName)
+        {
+            return repo.Branches[branchName] ?? repo.CreateBranch(branchName);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Kudu.Core/SourceControl/Hg/HgRepository.cs b/Kudu.Core/SourceControl/Hg/HgRepository.cs
index cf05c78a7..072efefe2 100644
--- a/Kudu.Core/SourceControl/Hg/HgRepository.cs
+++ b/Kudu.Core/SourceControl/Hg/HgRepository.cs
@@ -161,7 +161,7 @@ public void RevertFile(string path)
             Repository.Remove(path);
         }
 
-        public bool Commit(string message, string authorName = "")
+        public bool Commit(string message, string authorName = null, string emailAddress = null)
         {
             if (!Repository.Status().Any())
             {
@@ -170,9 +170,16 @@ public bool Commit(string message, string authorName = "")
 
             Repository.AddRemove();
 
+            var overrideAuthor = string.Empty;
+            if (!string.IsNullOrEmpty(authorName) &&
+                !string.IsNullOrEmpty(emailAddress))
+            {
+                overrideAuthor = string.Format("{0} <{1}>", authorName, emailAddress);
+            }
+
             var command = new CommitCommand
             {
-                OverrideAuthor = authorName ?? String.Empty,
+                OverrideAuthor = overrideAuthor,
                 Message = message
             };
 
diff --git a/Kudu.Core/SourceControl/NullRepository.cs b/Kudu.Core/SourceControl/NullRepository.cs
index 337ea7f64..0f92ff6b3 100644
--- a/Kudu.Core/SourceControl/NullRepository.cs
+++ b/Kudu.Core/SourceControl/NullRepository.cs
@@ -76,16 +76,14 @@ public void AddFile(string path)
             // no-op
         }
 
-        public bool Commit(string message, string authorName)
+        public bool Commit(string message, string authorName, string emailAddress)
         {
             var tracer = _traceFactory.GetTracer();
             using (tracer.Step("None repository commit"))
             {
-                string[] parts = String.IsNullOrEmpty(authorName) ? new string[0] : authorName.Split(new[] { '<', '>' }, StringSplitOptions.RemoveEmptyEntries);
-
                 var changeSet = new ChangeSet(Guid.NewGuid().ToString("N"),
-                                              parts.Length > 0 ? parts[0].Trim() : Resources.Deployment_UnknownValue,
-                                              parts.Length > 1 ? parts[1].Trim() : Resources.Deployment_UnknownValue,
+                                              !string.IsNullOrEmpty(authorName) ? authorName : Resources.Deployment_UnknownValue,
+                                              !string.IsNullOrEmpty(emailAddress) ? emailAddress : Resources.Deployment_UnknownValue,
                                               message ?? Resources.Deployment_UnknownValue,
                                               DateTimeOffset.UtcNow);
 
diff --git a/Kudu.Core/SourceControl/RepositoryFactory.cs b/Kudu.Core/SourceControl/RepositoryFactory.cs
index 269d89fee..02eb6b835 100644
--- a/Kudu.Core/SourceControl/RepositoryFactory.cs
+++ b/Kudu.Core/SourceControl/RepositoryFactory.cs
@@ -45,8 +45,8 @@ public virtual bool IsGitRepository
         {
             get
             {
-                var gitExeRepository = new GitExeRepository(_environment, _settings, _traceFactory);
-                return gitExeRepository.Exists;
+                var gitRepository = CreateGitRepositoryInstance();
+                return gitRepository.Exists;
             }
         }
 
@@ -59,9 +59,9 @@ public virtual bool IsCustomGitRepository
         {
             get
             {
-                var gitExeRepository = new GitExeRepository(_environment, _settings, _traceFactory);
-                gitExeRepository.SkipPostReceiveHookCheck = true;
-                return gitExeRepository.Exists;
+                var gitRepository = CreateGitRepositoryInstance();
+                gitRepository.SkipPostReceiveHookCheck = true;
+                return gitRepository.Exists;
             }
         }
 
@@ -86,7 +86,7 @@ public IRepository EnsureRepository(RepositoryType repositoryType)
             }
             else
             {
-                repository = new GitExeRepository(_environment, _settings, _traceFactory);
+                repository = CreateGitRepositoryInstance();
             }
 
             if (!repository.Exists)
@@ -107,7 +107,7 @@ public IRepository GetRepository()
             else if (IsGitRepository)
             {
                 tracer.Trace("Assuming git repository at {0}", _environment.RepositoryPath);
-                return new GitExeRepository(_environment, _settings, _traceFactory);
+                return CreateGitRepositoryInstance();
             }
             else if (IsHgRepository)
             {
@@ -123,13 +123,18 @@ public IRepository GetCustomRepository()
             if (IsCustomGitRepository)
             {
                 tracer.Trace("Assuming custom git repository at {0}", _environment.RepositoryPath);
-                var ret = new GitExeRepository(_environment, _settings, _traceFactory);
+                var ret = CreateGitRepositoryInstance();
                 ret.SkipPostReceiveHookCheck = true;
                 return ret;
             }
             return null;
         }
 
+        public IRepository GetGitRepository()
+        {
+            return CreateGitRepositoryInstance();
+        }
+
         private bool TryGetExistingRepositoryType(out RepositoryType repositoryType)
         {
             if (IsNullRepository)
@@ -151,5 +156,17 @@ private bool TryGetExistingRepositoryType(out RepositoryType repositoryType)
             repositoryType = default(RepositoryType);
             return false;
         }
+
+        private IGitRepository CreateGitRepositoryInstance()
+        {
+            if (_settings.UseLibGit2SharpRepository())
+            {
+                return new LibGit2SharpRepository(_environment, _settings, _traceFactory);
+            }
+            else
+            {
+                return new GitExeRepository(_environment, _settings, _traceFactory);
+            }
+        }
     }
 }
diff --git a/Kudu.Core/packages.config b/Kudu.Core/packages.config
index c82e1fbec..0143c6969 100644
--- a/Kudu.Core/packages.config
+++ b/Kudu.Core/packages.config
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="LibGit2Sharp" version="0.20.0.0" targetFramework="net45" />
+  <package id="LibGit2Sharp" version="0.20.2.0" targetFramework="net45" />
   <package id="Mercurial.Net" version="1.1.1.607" />
   <package id="Microsoft.Diagnostics.Tracing.EventRegister" version="1.0.26" targetFramework="net45" />
   <package id="Microsoft.Diagnostics.Tracing.EventSource" version="1.0.26" targetFramework="net45" />
diff --git a/Kudu.FunctionalTests/DeploymentManagerTests.cs b/Kudu.FunctionalTests/DeploymentManagerTests.cs
index 5e0150969..7f68fb34b 100644
--- a/Kudu.FunctionalTests/DeploymentManagerTests.cs
+++ b/Kudu.FunctionalTests/DeploymentManagerTests.cs
@@ -639,7 +639,8 @@ public async Task PullApiTestRepoCommitTextWithSpecialChar()
                 Assert.Equal(1, results.Count);
                 Assert.Equal(DeployStatus.Success, results[0].Status);
                 Assert.Equal("GitHub", results[0].Deployer);
-                Assert.Equal("invalid char is ", results[0].Message);
+                // [0] => git.exe, [1] => LibGit2Sharp
+                KuduAssert.EqualsAny(new [] {"invalid char is ", "invalid char is \n"}, results[0].Message);
 
                 KuduAssert.VerifyUrl(appManager.SiteUrl, "Hello World");
             });
@@ -815,7 +816,7 @@ public async Task PullApiTestRepoWithLongPath()
                     await PostPayloadHelperAsync(appManager, client => client.PostAsJsonAsync("deploy", payload));
                 });
 
-                Assert.Contains("unable to create file symfony", exception.Message);
+                KuduAssert.ContainsAny(new[] { "unable to create file symfony", "The data area passed to a system call is too small" }, exception.Message);
 
                 var results = (await appManager.DeploymentManager.GetResultsAsync()).ToList();
                 Assert.Equal(1, results.Count);
@@ -828,7 +829,7 @@ public async Task PullApiTestRepoWithLongPath()
 
                 var details = (await appManager.DeploymentManager.GetLogEntryDetailsAsync(results[0].Id, entries[0].Id)).ToList();
                 Assert.True(details.Count > 0, "must have at one log detail entry.");
-                Assert.Contains("unable to create file symfony", details[0].Message);
+                KuduAssert.ContainsAny(new[] { "unable to create file symfony", "The data area passed to a system call is too small" }, details[0].Message);
                 Assert.Equal(LogEntryType.Error, details[0].Type);
 
                 // Must not have entry with "An unknown error has occurred"
@@ -1037,52 +1038,52 @@ public async Task PullApiTestRepoInvalidUrl(string scm)
                     });
 
                     // Assert
-                    KuduAssert.Match(info.Expect, exception.Message, info.ToString());
+                    KuduAssert.MatchAny(info.Expect, exception.Message, info.ToString());
                 }
             });
         }
 
         private static IEnumerable<RepoInvalidInfo> GetRepoInvalidInfos()
         {
-            yield return new RepoInvalidInfo("InvalidUrl", "Repository url 'InvalidUrl' is invalid.", null);
-            yield return new RepoInvalidInfo("InvalidUrl", "Repository url 'InvalidUrl' is invalid.", null);
-            yield return new RepoInvalidInfo(".", "Repository url '.' is invalid.", null);
-            yield return new RepoInvalidInfo("http://google.com/", "fatal:.*http://.*google.com.* not found", null);
-            yield return new RepoInvalidInfo("http://google.com/", "abort: 'http://www.google.com/' does not appear to be an hg repository", "hg");
-            yield return new RepoInvalidInfo("InvalidScheme://abcdefghigkl.com/", "fatal: Unable to find remote helper for 'InvalidScheme'", null);
-            yield return new RepoInvalidInfo("InvalidScheme://abcdefghigkl.com/", "abort: repository InvalidScheme://abcdefghigkl.com/ not found", "hg");
-            yield return new RepoInvalidInfo("http://abcdefghigkl.com/", "Could.*n.*t resolve host.*abcdefghigkl.com", null);
-            yield return new RepoInvalidInfo("http://abcdefghigkl.com/", "abort: error: getaddrinfo failed.*hg.exe pull", "hg");
-            yield return new RepoInvalidInfo("https://abcdefghigkl.com/", "Could.*n.*t resolve host.*abcdefghigkl.com", null);
-            yield return new RepoInvalidInfo("https://abcdefghigkl.com/", "abort: error: getaddrinfo failed.*hg.exe pull", "hg");
-            yield return new RepoInvalidInfo("git@abcdefghigkl.com:Invalid/Invalid.git", "no address associated with name", null);
-            yield return new RepoInvalidInfo("ssh://hg@abcdefghigkl.com/Invalid/Invalid.git", "abort: no suitable response from remote hg.*hg.exe pull", "hg");
-            yield return new RepoInvalidInfo("git@github.com:Invalid/Invalid.git", "Permission denied [(]publickey[)]", null);
-            yield return new RepoInvalidInfo("git@bitbucket.org:Invalid/Invalid.git", "Permission denied [(]publickey[)]", null);
-            yield return new RepoInvalidInfo("git@github.com:KuduApps/Invalid.git", "Permission denied [(]publickey[)]", null);
-            yield return new RepoInvalidInfo("git@bitbucket.org:kudutest/Invalid.git", "Permission denied [(]publickey[)]", null);
-            yield return new RepoInvalidInfo("git@github.com:KuduApps/HelloKudu.git", "Permission denied [(]publickey[)]", null);
-            yield return new RepoInvalidInfo("git@bitbucket.org:kudutest/jeanprivate.git", "Permission denied [(]publickey[)]", null);
+            yield return new RepoInvalidInfo("InvalidUrl", new [] {"Repository url 'InvalidUrl' is invalid."}, null);
+            yield return new RepoInvalidInfo("InvalidUrl", new [] {"Repository url 'InvalidUrl' is invalid."}, null);
+            yield return new RepoInvalidInfo(".", new [] {"Repository url '.' is invalid."}, null);
+            yield return new RepoInvalidInfo("http://google.com/", new [] {"fatal:.*http://.*google.com.* not found", "\\[LibGit2SharpException: Too many redirects or authentication replays\\]"}, null);
+            yield return new RepoInvalidInfo("http://google.com/", new [] {"abort: 'http://www.google.com/' does not appear to be an hg repository"}, "hg");
+            yield return new RepoInvalidInfo("InvalidScheme://abcdefghigkl.com/", new [] {"fatal: Unable to find remote helper for 'InvalidScheme'"}, null);
+            yield return new RepoInvalidInfo("InvalidScheme://abcdefghigkl.com/", new [] {"abort: repository InvalidScheme://abcdefghigkl.com/ not found"}, "hg");
+            yield return new RepoInvalidInfo("http://abcdefghigkl.com/", new [] {"Could.*n.*t resolve host.*abcdefghigkl.com", "LibGit2SharpException: failed to send request: The server name or address could not be resolved"}, null);
+            yield return new RepoInvalidInfo("http://abcdefghigkl.com/", new [] {"abort: error: getaddrinfo failed.*hg.exe pull"}, "hg");
+            yield return new RepoInvalidInfo("https://abcdefghigkl.com/", new [] {"Could.*n.*t resolve host.*abcdefghigkl.com", "LibGit2SharpException: failed to send request: The server name or address could not be resolved"}, null);
+            yield return new RepoInvalidInfo("https://abcdefghigkl.com/", new [] {"abort: error: getaddrinfo failed.*hg.exe pull"}, "hg");
+            yield return new RepoInvalidInfo("git@abcdefghigkl.com:Invalid/Invalid.git", new [] {"no address associated with name"}, null);
+            yield return new RepoInvalidInfo("ssh://hg@abcdefghigkl.com/Invalid/Invalid.git", new [] {"abort: no suitable response from remote hg.*hg.exe pull"}, "hg");
+            yield return new RepoInvalidInfo("git@github.com:Invalid/Invalid.git", new [] {"Permission denied [(]publickey[)]"}, null);
+            yield return new RepoInvalidInfo("git@bitbucket.org:Invalid/Invalid.git", new [] {"Permission denied [(]publickey[)]"}, null);
+            yield return new RepoInvalidInfo("git@github.com:KuduApps/Invalid.git", new [] {"Permission denied [(]publickey[)]"}, null);
+            yield return new RepoInvalidInfo("git@bitbucket.org:kudutest/Invalid.git", new [] {"Permission denied [(]publickey[)]"}, null);
+            yield return new RepoInvalidInfo("git@github.com:KuduApps/HelloKudu.git", new [] {"Permission denied [(]publickey[)]"}, null);
+            yield return new RepoInvalidInfo("git@bitbucket.org:kudutest/jeanprivate.git", new [] {"Permission denied [(]publickey[)]"}, null);
             // due to unreliable error from github
             // yield return new RepoInvalidInfo("https://github.com/KuduApps/HelloKudu.git", "abort: HTTP Error 406: Not Acceptable.*hg.exe pull https://github.com/KuduApps/HelloKudu.git", "hg");
-            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/hellomercurial/", "fatal:.*https://bitbucket.org/kudutest/hellomercurial.* not found", null);
-            yield return new RepoInvalidInfo("https://github.com/Invalid/Invalid.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://github.com/KuduQAOrg/Invalid.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://github.com/KuduQAOrg/PrivateSubModule.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://KuduQAOrg@github.com/KuduQAOrg/PrivateSubModule.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://wrongusr@github.com/KuduQAOrg/PrivateSubModule.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://KuduQAOrg:wrongpwd@github.com/KuduQAOrg/PrivateSubModule.git", "fatal: Authentication failed.*git.exe fetch external", null);
-            yield return new RepoInvalidInfo("https://bitbucket.org/Invalid/Invalid.git", "fatal:.*https://bitbucket.org/Invalid/Invalid.git.* not found", null);
-            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/Invalid.git", "fatal:.*https://bitbucket.org/kudutest/Invalid.git.* not found", null);
-            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/jeanprivate.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://kudutest@bitbucket.org/kudutest/jeanprivate.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://wrongusr@bitbucket.org/kudutest/jeanprivate.git", "fatal: Authentication failed.*git.exe fetch", null);
-            yield return new RepoInvalidInfo("https://kudutest:wrongpwd@bitbucket.org/kudutest/jeanprivate.git", "fatal: Authentication failed.*git.exe fetch external", null);
+            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/hellomercurial/", new [] {"fatal:.*https://bitbucket.org/kudutest/hellomercurial.* not found", "\\[LibGit2SharpException: Request failed with status code: 404\\]"}, null);
+            yield return new RepoInvalidInfo("https://github.com/Invalid/Invalid.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://github.com/KuduQAOrg/Invalid.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://github.com/KuduQAOrg/PrivateSubModule.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://KuduQAOrg@github.com/KuduQAOrg/PrivateSubModule.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://wrongusr@github.com/KuduQAOrg/PrivateSubModule.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://KuduQAOrg:wrongpwd@github.com/KuduQAOrg/PrivateSubModule.git", new [] {"fatal: Authentication failed.*git.exe fetch external", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://bitbucket.org/Invalid/Invalid.git", new [] {"fatal:.*https://bitbucket.org/Invalid/Invalid.git.* not found", "\\[LibGit2SharpException: Request failed with status code: 404\\]"}, null);
+            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/Invalid.git", new [] {"fatal:.*https://bitbucket.org/kudutest/Invalid.git.* not found", "\\[LibGit2SharpException: Request failed with status code: 404\\]"}, null);
+            yield return new RepoInvalidInfo("https://bitbucket.org/kudutest/jeanprivate.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://kudutest@bitbucket.org/kudutest/jeanprivate.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://wrongusr@bitbucket.org/kudutest/jeanprivate.git", new [] {"fatal: Authentication failed.*git.exe fetch", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
+            yield return new RepoInvalidInfo("https://kudutest:wrongpwd@bitbucket.org/kudutest/jeanprivate.git", new [] {"fatal: Authentication failed.*git.exe fetch external", "\\[LibGit2SharpException: Request failed with status code: 401\\]"}, null);
         }
 
         public class RepoInvalidInfo
         {
-            public RepoInvalidInfo(string url, string expect, string scm)
+            public RepoInvalidInfo(string url, IEnumerable<string> expect, string scm)
             {
                 this.Url = url;
                 this.Expect = expect;
@@ -1097,7 +1098,7 @@ public RepoInvalidInfo(string url, string expect, string scm)
             }
 
             public string Url { get; set; }
-            public string Expect { get; set; }
+            public IEnumerable<string> Expect { get; set; }
             public string Scm { get; set; }
             public JObject Payload { get; set; }
             public override string ToString()
diff --git a/Kudu.FunctionalTests/GitRepositoryFacts.cs b/Kudu.FunctionalTests/GitRepositoryFacts.cs
index 0984d5fb0..797ab948e 100644
--- a/Kudu.FunctionalTests/GitRepositoryFacts.cs
+++ b/Kudu.FunctionalTests/GitRepositoryFacts.cs
@@ -15,13 +15,15 @@ namespace Kudu.FunctionalTests
     [TestHarnessClassCommand]
     public class GitRepositoryFacts
     {
-        [Fact]
-        public void GitGetChangeSetReturnsNullIfIdDoesNotExist()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitGetChangeSetReturnsNullIfIdDoesNotExist(Type gitRepoType)
         {
             // Arrange
             using (TestRepository testRepository = GetRepository())
             {
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 gitRepo.Initialize();
 
                 // Act
@@ -32,13 +34,15 @@ public void GitGetChangeSetReturnsNullIfIdDoesNotExist()
             }
         }
 
-        [Fact]
-        public void GitInitializeCreatesPostCommitHook()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitInitializeCreatesPostCommitHook(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
                 // Arrange
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 string postCommitHookPath = Path.Combine(testRepository.PhysicalPath, ".git", "hooks", "post-receive");
                 string expected = "#!/bin/sh\r\nread i\r\necho $i > pushinfo\r\n\"$KUDU_EXE\" \"$KUDU_APPPATH\" \"$KUDU_MSBUILD\" \"$KUDU_DEPLOYER\"\n";
 
@@ -50,13 +54,15 @@ public void GitInitializeCreatesPostCommitHook()
             }
         }
 
-        [Fact]
-        public void FetchWithoutConflictOnGitEmptyRepo()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void FetchWithoutConflictOnGitEmptyRepo(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
                 // Arrange
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
 
                 // Act
                 gitRepo.Initialize();
@@ -64,33 +70,39 @@ public void FetchWithoutConflictOnGitEmptyRepo()
             }
         }
 
-        [Fact]
-        public void GitRepoDoesntExistBeforeInitialize()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitRepoDoesntExistBeforeInitialize(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 Assert.False(gitRepo.Exists, "git repository shouldn't exist yet");
             }
         }
 
-        [Fact]
-        public void GitRepoExistsAfterInitialize()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitRepoExistsAfterInitialize(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository) Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 gitRepo.Initialize();
                 Assert.True(gitRepo.Exists, "git repository should exist");
             }
         }
 
-        [Fact]
-        public void GitRepoDoesntExistIfCorrupted()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitRepoDoesntExistIfCorrupted(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository) Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
 
                 gitRepo.Initialize();
                 Assert.True(gitRepo.Exists, "git repository should exist");
@@ -101,12 +113,14 @@ public void GitRepoDoesntExistIfCorrupted()
             }
         }
 
-        [Fact]
-        public void GitRepoExistIfCorruptedThenInitializedAgain()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitRepoExistIfCorruptedThenInitializedAgain(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
 
                 gitRepo.Initialize();
                 Assert.True(gitRepo.Exists, "git repository should exist");
@@ -120,20 +134,22 @@ public void GitRepoExistIfCorruptedThenInitializedAgain()
             }
         }
 
-        [Fact]
-        public void GitRepoDoesntExistIfGitRepoOnlyOnParentDirectory()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitRepoDoesntExistIfGitRepoOnlyOnParentDirectory(Type gitRepoType)
         {
             using (TestRepository testRepository = GetRepository())
             {
                 // Create a repository
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 gitRepo.Initialize();
 
                 // Checkout for existence in subdirectory
                 var testedPath = Path.Combine(testRepository.PhysicalPath, "subdirectory");
                 Directory.CreateDirectory(testedPath);
                 var environment = new TestEnvironment { RepositoryPath = testedPath };
-                gitRepo = new GitExeRepository(environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
                 Assert.False(gitRepo.Exists, "git repository shouldn't exist yet");
             }
         }
@@ -142,20 +158,23 @@ public void GitRepoDoesntExistIfGitRepoOnlyOnParentDirectory()
         [PropertyData("ParseCommitData")]
         public void GitRepoParsesCommitDetails(string id, ChangeSet expectedChangeset)
         {
-            using (var testRepository = Git.Clone("Mvc3Application_NoSolution"))
+            foreach (Type gitRepoType in new[] { typeof(LibGit2SharpRepository), typeof(GitExeRepository) })
             {
-                // Arrange
-                var gitRepo = new GitExeRepository(testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
-
-                // Act
-                var changeset = gitRepo.GetChangeSet(id);
-
-                // Assert
-                Assert.Equal(expectedChangeset.Id, changeset.Id);
-                Assert.Equal(expectedChangeset.AuthorName, changeset.AuthorName);
-                Assert.Equal(expectedChangeset.AuthorEmail, changeset.AuthorEmail);
-                Assert.Equal(expectedChangeset.Message, changeset.Message.Trim());
-                Assert.Equal(expectedChangeset.Timestamp, changeset.Timestamp);
+                using (var testRepository = Git.Clone("Mvc3Application_NoSolution"))
+                {
+                    // Arrange
+                    var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, testRepository.Environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+
+                    // Act
+                    var changeset = gitRepo.GetChangeSet(id);
+
+                    // Assert
+                    Assert.Equal(expectedChangeset.Id, changeset.Id);
+                    Assert.Equal(expectedChangeset.AuthorName, changeset.AuthorName);
+                    Assert.Equal(expectedChangeset.AuthorEmail, changeset.AuthorEmail);
+                    Assert.Equal(expectedChangeset.Message, changeset.Message.Trim());
+                    Assert.Equal(expectedChangeset.Timestamp, changeset.Timestamp);
+                }
             }
         }
 
@@ -168,8 +187,10 @@ public static IEnumerable<object[]> ParseCommitData
             }
         }
 
-        [Fact]
-        public void GitClearLockRemovesHeadAndIndexLocks()
+        [Theory]
+        [InlineData(typeof(LibGit2SharpRepository))]
+        [InlineData(typeof(GitExeRepository))]
+        public void GitClearLockRemovesHeadAndIndexLocks(Type gitRepoType)
         {
             using (var testRepo = GetRepository())
             {
@@ -183,7 +204,7 @@ public void GitClearLockRemovesHeadAndIndexLocks()
                 {
                     RepositoryPath = testRepo.PhysicalPath
                 };
-                var gitRepo = new GitExeRepository(env, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+                var gitRepo = (IGitRepository)Activator.CreateInstance(gitRepoType, env, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
 
 
                 // Assert - 1
diff --git a/Kudu.FunctionalTests/Infrastructure/KuduAssert.cs b/Kudu.FunctionalTests/Infrastructure/KuduAssert.cs
index 2f759ec71..ef53f13c5 100644
--- a/Kudu.FunctionalTests/Infrastructure/KuduAssert.cs
+++ b/Kudu.FunctionalTests/Infrastructure/KuduAssert.cs
@@ -159,5 +159,30 @@ public static void Match(string pattern, string actual, string message = null)
         {
             Assert.True(Regex.IsMatch(actual, pattern), String.Format("{0}\r\npattern: {1}\r\nactual: {2}\r\n", message, pattern, actual));
         }
+
+        public static void MatchAny(IEnumerable<string> patterns, string actual, string message = null)
+        {
+            GenericAnyAssert(patterns, (p) => Regex.IsMatch(actual, p), actual, message);
+        }
+
+        public static void EqualsAny(IEnumerable<string> options, string actual, string message = null)
+        {
+            GenericAnyAssert(options, (o) => string.Equals(actual, o), actual, message);
+        }
+
+        public static void ContainsAny(IEnumerable<string> options, string actual, string message = null)
+        {
+            GenericAnyAssert(options, (o) => actual.Contains(o), actual, message);
+        }
+
+        private static void GenericAnyAssert<T>(IEnumerable<T> options, Func<T, bool> assertFunc, T actual, string message = null)
+        {
+            Assert.True(options.Any(o => assertFunc(o)),
+                        string.Format("{0}\r\noptions: {1}\r\nactual: {2}\r\n",
+                                      message,
+                                      options.Select(o => o.ToString()).Aggregate((a, b) => string.Format("{0}, {1}", a, b)),
+                                      actual)
+                       );
+        }
     }
 }
diff --git a/Kudu.FunctionalTests/Vfs/VfsControllerBaseTest.cs b/Kudu.FunctionalTests/Vfs/VfsControllerBaseTest.cs
index db7afc559..466c819c5 100644
--- a/Kudu.FunctionalTests/Vfs/VfsControllerBaseTest.cs
+++ b/Kudu.FunctionalTests/Vfs/VfsControllerBaseTest.cs
@@ -21,14 +21,14 @@ public class VfsControllerBaseTest
         private static readonly char[] _segmentDelimiters = new char[] { _segmentDelimiter };
 
         private static readonly byte[] _fileContent0 = Encoding.UTF8.GetBytes("aaa\r\nbbb\r\nccc\r\n");
-        private static readonly byte[] _fileContent1 = Encoding.UTF8.GetBytes("AAA\r\nbbb\r\nccc\r\n");
-        private static readonly byte[] _fileContent2 = Encoding.UTF8.GetBytes("aaa\r\nbbb\r\nCCC\r\n");
-        private static readonly byte[] _fileContent3 = Encoding.UTF8.GetBytes("AAA\r\nbbb\r\nCCC\r\n");
-        private static readonly byte[] _fileContent4 = Encoding.UTF8.GetBytes("CCC\r\nbbb\r\nAAA\r\n");
+        private static readonly byte[] _fileContent1 = Encoding.UTF8.GetBytes("AAAA\r\nbbb\r\nccc\r\n");
+        private static readonly byte[] _fileContent2 = Encoding.UTF8.GetBytes("aaa\r\nbbb\r\nCCCCC\r\n");
+        private static readonly byte[] _fileContent3 = Encoding.UTF8.GetBytes("AAAA\r\nbbb\r\nCCCCC\r\n");
+        private static readonly byte[] _fileContent4 = Encoding.UTF8.GetBytes("CCCCC\r\nbbb\r\nAAAAA\r\n");
 
         private static readonly ContentRangeHeaderValue _fileContentRange = new ContentRangeHeaderValue(_fileContent0.Length);
 
-        private static readonly string _conflict = "<<<<<<< HEAD\r\nAAA\r\nbbb\r\nCCC\r\n=======\r\nCCC\r\nbbb\r\nAAA\r\n>>>>>>>";
+        private static readonly string _conflict = "<<<<<<< HEAD\r\nAAAA\r\nbbb\r\nCCCCC\r\n=======\r\nCCCCC\r\nbbb\r\nAAAAA\r\n>>>>>>>";
 
         private static readonly MediaTypeHeaderValue _fileMediaType = MediaTypeHeaderValue.Parse("text/plain");
         private static readonly MediaTypeHeaderValue _dirMediaType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
diff --git a/Kudu.Services.Web/App_Start/NinjectServices.cs b/Kudu.Services.Web/App_Start/NinjectServices.cs
index 89d6cdb48..50c31a2f8 100644
--- a/Kudu.Services.Web/App_Start/NinjectServices.cs
+++ b/Kudu.Services.Web/App_Start/NinjectServices.cs
@@ -247,11 +247,6 @@ private static void RegisterServices(IKernel kernel)
             kernel.Bind<ILogger>().ToMethod(context => GetLogger(environment, context.Kernel))
                                              .InRequestScope();
 
-            kernel.Bind<IRepository>().ToMethod(context => new GitExeRepository(context.Kernel.Get<IEnvironment>(),
-                                                                                context.Kernel.Get<IDeploymentSettingsManager>(),
-                                                                                context.Kernel.Get<ITraceFactory>()))
-                                                .InRequestScope();
-
             kernel.Bind<IDeploymentManager>().To<DeploymentManager>()
                                              .InRequestScope();
             kernel.Bind<IAutoSwapHandler>().To<AutoSwapHandler>()
diff --git a/Kudu.Services/FetchHelpers/DropboxHelper.cs b/Kudu.Services/FetchHelpers/DropboxHelper.cs
index a760a207e..0528c4b20 100644
--- a/Kudu.Services/FetchHelpers/DropboxHelper.cs
+++ b/Kudu.Services/FetchHelpers/DropboxHelper.cs
@@ -188,7 +188,7 @@ internal async Task<ChangeSet> Sync(DropboxInfo dropboxInfo, string branch, IRep
                 statusFile.UpdateProgress(String.Format(CultureInfo.CurrentCulture, Resources.Dropbox_Committing, _successCount));
 
                 // Commit anyway even partial change
-                if (repository.Commit(message, String.Format("{0} <{1}>", deployInfo.UserName, deployInfo.Email ?? deployInfo.UserName)))
+                if (repository.Commit(message, deployInfo.UserName, deployInfo.Email ?? deployInfo.UserName))
                 {
                     changeSet = repository.GetChangeSet("HEAD");
                 }
diff --git a/Kudu.Services/GitServer/InfoRefsController.cs b/Kudu.Services/GitServer/InfoRefsController.cs
index e67925c61..0f81024fb 100644
--- a/Kudu.Services/GitServer/InfoRefsController.cs
+++ b/Kudu.Services/GitServer/InfoRefsController.cs
@@ -191,7 +191,7 @@ public void InitialCommitIfNecessary()
                 // Once repo is init, persist the new repo path
                 settings.SetValue(SettingsKeys.RepositoryPath, Constants.WebRoot);
 
-                repository.Commit("Initial Commit", authorName: null);
+                repository.Commit("Initial Commit", authorName: null, emailAddress: null);
 
             }, GitExeServer.InitTimeout);
         }
diff --git a/Kudu.Services/SourceControl/LiveScmController.cs b/Kudu.Services/SourceControl/LiveScmController.cs
index 84f3ca97d..dcd09e6d9 100644
--- a/Kudu.Services/SourceControl/LiveScmController.cs
+++ b/Kudu.Services/SourceControl/LiveScmController.cs
@@ -11,6 +11,7 @@
 using Kudu.Core.SourceControl;
 using Kudu.Core.Tracing;
 using Kudu.Services.Infrastructure;
+using Kudu.Contracts.SourceControl;
 
 namespace Kudu.Services.SourceControl
 {
@@ -26,14 +27,14 @@ public class LiveScmController : ApiController
         public LiveScmController(ITracer tracer,
                                  IOperationLock deploymentLock,
                                  IEnvironment environment,
-                                 IRepository repository,
+                                 IRepositoryFactory repositoryFactory,
                                  IServerConfiguration serverConfiguration,
                                  IDeploymentStatusManager status)
         {
             _tracer = tracer;
             _deploymentLock = deploymentLock;
             _environment = environment;
-            _repository = repository;
+            _repository = repositoryFactory.GetGitRepository();
             _serverConfiguration = serverConfiguration;
             _status = status;
         }
diff --git a/Kudu.Services/SourceControl/LiveScmEditorController.cs b/Kudu.Services/SourceControl/LiveScmEditorController.cs
index 92b673c1f..29b52e64d 100644
--- a/Kudu.Services/SourceControl/LiveScmEditorController.cs
+++ b/Kudu.Services/SourceControl/LiveScmEditorController.cs
@@ -47,13 +47,12 @@ public class LiveScmEditorController : VfsControllerBase
                                        IDeploymentManager deploymentManager,
                                        IOperationLock operationLock,
                                        IEnvironment environment,
-                                       IRepository repository,
                                        IRepositoryFactory repositoryFactory)
             : base(tracer, environment, environment.RepositoryPath)
         {
             _deploymentManager = deploymentManager;
             _operationLock = operationLock;
-            _repository = repository ?? repositoryFactory.GetRepository();
+            _repository = repositoryFactory.GetGitRepository();
         }
 
         public override async Task<HttpResponseMessage> GetItem()
@@ -245,7 +244,7 @@ protected override async Task<HttpResponseMessage> CreateItemPutResponse(FileSys
                 bool updateBranchIsUpToDate = true;
 
                 // Commit to local branch
-                bool commitResult = _repository.Commit(parameters.Message, authorName: null);
+                bool commitResult = _repository.Commit(parameters.Message, authorName: null, emailAddress: null);
                 if (!commitResult)
                 {
                     HttpResponseMessage noChangeResponse = Request.CreateResponse(HttpStatusCode.NoContent);
@@ -358,7 +357,7 @@ protected override async Task<HttpResponseMessage> CreateFileDeleteResponse(File
             QueryParameters parameters = new QueryParameters(this.Request);
 
             // Commit to local branch
-            _repository.Commit(parameters.Message, authorName: null);
+            _repository.Commit(parameters.Message, authorName: null, emailAddress: null);
 
             bool rebasing = false;
             try
diff --git a/Kudu.TestHarness/TestRepository.cs b/Kudu.TestHarness/TestRepository.cs
index c50092df1..1efec8223 100644
--- a/Kudu.TestHarness/TestRepository.cs
+++ b/Kudu.TestHarness/TestRepository.cs
@@ -4,13 +4,14 @@
 using Kudu.Core.SourceControl.Git;
 using Kudu.Core.Test;
 using Kudu.Core.Tracing;
+using Kudu.Core.SourceControl;
 
 namespace Kudu.TestHarness
 {
     public class TestRepository : IDisposable
     {
         private readonly string _physicalPath;
-        private readonly GitExeRepository _repository;
+        private readonly IRepository _repository;
         private readonly IEnvironment _environment;
         private readonly bool _obliterateOnDispose;
 
@@ -24,7 +25,7 @@ public TestRepository(string repositoryName, bool obliterateOnDispose)
         {
             _physicalPath = Git.GetRepositoryPath(repositoryName);
             _environment = new TestEnvironment { RepositoryPath = _physicalPath };
-            _repository = new GitExeRepository(_environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
+            _repository = new LibGit2SharpRepository(_environment, new MockDeploymentSettingsManager(), NullTracerFactory.Instance);
             _obliterateOnDispose = obliterateOnDispose;
         }
 
diff --git a/build.cmd b/build.cmd
index 30e30292b..d49f445d2 100644
--- a/build.cmd
+++ b/build.cmd
@@ -1,18 +1,17 @@
 @echo Off
-
-SET BASEDIR=%~dp0
-
 set config=%1
 if "%config%" == "" (
     set config=Release
 )
 
-if exist "%ProgramFiles%\MSBuild\12.0\Bin\msbuild.exe" (
-  set MsBuildPath="%ProgramFiles%\MSBuild\12.0\Bin\msbuild.exe"
-) else if defined ProgramFiles(x86) if exist "%ProgramFiles(x86)%\MSBuild\12.0\Bin\msbuild.exe" (
-  set MsBuildPath="%ProgramFiles(x86)%\MSBuild\12.0\Bin\msbuild.exe"
-) else (
-  set MsBuildPath="%WINDIR%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe"
+:: use MSBuild from .net framework by default
+set MsBuildExe="%WINDIR%\Microsoft.NET\Framework\v4.0.30319\msbuild"
+
+:: if there is MSBuild from vs2013, use MSBuild from vs2013 instead
+if exist "%PROGRAMFILES%\MSBuild\12.0\Bin\MsBuild.exe" (
+    set MsBuildExe="%PROGRAMFILES%\MSBuild\12.0\Bin\MsBuild.exe"
+) else if exist "%PROGRAMFILES(X86)%\MSBuild\12.0\Bin\MsBuild.exe" (
+    set MsBuildExe="%PROGRAMFILES(X86)%\MSBuild\12.0\Bin\MsBuild.exe"
 )
 
-%MsBuildPath% "%BASEDIR%Build\Build.proj" /p:Configuration="%config%";ExcludeXmlAssemblyFiles=false /v:M /fl /flp:LogFile="%BASEDIR%msbuild.log";Verbosity=Normal /nr:false /m
+%MsBuildExe% Build\Build.proj /p:Configuration="%config%";ExcludeXmlAssemblyFiles=false /v:M /fl /flp:LogFile=msbuild.log;Verbosity=Normal /nr:false /m
\ No newline at end of file