Moved some classes over from GitVersion to support dynamic repositories

Author: GeertvanHorrik

src/GitTools.Core/GitTools.Core.Shared/Exceptions/WarningException.cs

@@ -0,0 +1,19 @@
+namespace GitTools
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [Serializable]
+    public class WarningException : Exception
+    {
+        public WarningException(string message)
+            : base(message)
+        {
+        }
+
+        protected WarningException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}

src/GitTools.Core/GitTools.Core.Shared/Git/GitDirFinder.cs

@@ -0,0 +1,20 @@
+namespace GitTools.Git
+{
+    using System.IO;
+    using LibGit2Sharp;
+
+    public class GitDirFinder
+    {
+        public static string TreeWalkForDotGitDir(string currentDirectory)
+        {
+            var gitDirectory = Repository.Discover(currentDirectory);
+
+            if (gitDirectory != null)
+            {
+                return gitDirectory.TrimEnd(Path.DirectorySeparatorChar);
+            }
+
+            return null;
+        }
+    }
+}

src/GitTools.Core/GitTools.Core.Shared/Git/GitPreparer.cs

@@ -0,0 +1,182 @@
+namespace GitTools.Git
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using LibGit2Sharp;
+    using Logging;
+
+    public class GitPreparer
+    {
+        private static readonly ILog Log = LogProvider.GetCurrentClassLogger();
+
+        string targetUrl;
+        string dynamicRepositoryLocation;
+        AuthenticationInfo authentication;
+        bool noFetch;
+        string targetPath;
+
+        public GitPreparer(string targetUrl, string dynamicRepositoryLocation, AuthenticationInfo authentication, bool noFetch, string targetPath)
+        {
+            this.targetUrl = targetUrl;
+            this.dynamicRepositoryLocation = dynamicRepositoryLocation;
+            this.authentication = authentication ?? new AuthenticationInfo();
+            this.noFetch = noFetch;
+            this.targetPath = targetPath;
+        }
+
+        public bool IsDynamicGitRepository
+        {
+            get { return !string.IsNullOrWhiteSpace(DynamicGitRepositoryPath); }
+        }
+
+        public string DynamicGitRepositoryPath { get; private set; }
+
+        public void Initialise(bool normaliseGitDirectory, string currentBranch)
+        {
+            if (string.IsNullOrWhiteSpace(targetUrl))
+            {
+                if (normaliseGitDirectory)
+                {
+                    GitHelper.NormalizeGitDirectory(GetDotGitDirectory(), authentication, noFetch, currentBranch);
+                }
+                return;
+            }
+
+            var tempRepositoryPath = CalculateTemporaryRepositoryPath(targetUrl, dynamicRepositoryLocation);
+
+            DynamicGitRepositoryPath = CreateDynamicRepository(tempRepositoryPath, authentication, targetUrl, currentBranch, noFetch);
+        }
+
+        static string CalculateTemporaryRepositoryPath(string targetUrl, string dynamicRepositoryLocation)
+        {
+            var userTemp = dynamicRepositoryLocation ?? Path.GetTempPath();
+            var repositoryName = targetUrl.Split('/', '\\').Last().Replace(".git", string.Empty);
+            var possiblePath = Path.Combine(userTemp, repositoryName);
+
+            // Verify that the existing directory is ok for us to use
+            if (Directory.Exists(possiblePath))
+            {
+                if (!GitRepoHasMatchingRemote(possiblePath, targetUrl))
+                {
+                    var i = 1;
+                    var originalPath = possiblePath;
+                    bool possiblePathExists;
+                    do
+                    {
+                        possiblePath = string.Concat(originalPath, "_", i++.ToString());
+                        possiblePathExists = Directory.Exists(possiblePath);
+                    } while (possiblePathExists && !GitRepoHasMatchingRemote(possiblePath, targetUrl));
+                }
+            }
+
+            return possiblePath;
+        }
+
+        static bool GitRepoHasMatchingRemote(string possiblePath, string targetUrl)
+        {
+            try
+            {
+                using (var repository = new Repository(possiblePath))
+                {
+                    return repository.Network.Remotes.Any(r => r.Url == targetUrl);
+                }
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        public string GetDotGitDirectory()
+        {
+            if (IsDynamicGitRepository)
+            {
+                return DynamicGitRepositoryPath;
+            }
+
+            return GitDirFinder.TreeWalkForDotGitDir(targetPath);
+        }
+
+        public string GetProjectRootDirectory()
+        {
+            if (IsDynamicGitRepository)
+            {
+                return targetPath;
+            }
+
+            return Directory.GetParent(GitDirFinder.TreeWalkForDotGitDir(targetPath)).FullName;
+        }
+
+        static string CreateDynamicRepository(string targetPath, AuthenticationInfo authentication, string repositoryUrl, string targetBranch, bool noFetch)
+        {
+            if (string.IsNullOrWhiteSpace(targetBranch))
+            {
+                throw new Exception("Dynamic Git repositories must have a target branch (/b)");
+            }
+
+            Log.Info(string.Format("Creating dynamic repository at '{0}'", targetPath));
+
+            var gitDirectory = Path.Combine(targetPath, ".git");
+            if (Directory.Exists(targetPath))
+            {
+                Log.Info("Git repository already exists");
+                GitHelper.NormalizeGitDirectory(gitDirectory, authentication, noFetch, targetBranch);
+
+                return gitDirectory;
+            }
+
+            CloneRepository(repositoryUrl, gitDirectory, authentication);
+
+            // Normalize (download branches) before using the branch
+            GitHelper.NormalizeGitDirectory(gitDirectory, authentication, noFetch, targetBranch);
+
+            return gitDirectory;
+        }
+
+        private static void CloneRepository(string repositoryUrl, string gitDirectory, AuthenticationInfo authentication)
+        {
+            Credentials credentials = null;
+            if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password))
+            {
+                Log.Info(string.Format("Setting up credentials using name '{0}'", authentication.Username));
+
+                credentials = new UsernamePasswordCredentials
+                {
+                    Username = authentication.Username,
+                    Password = authentication.Password
+                };
+            }
+
+            Log.Info(string.Format("Retrieving git info from url '{0}'", repositoryUrl));
+
+            try
+            {
+                Repository.Clone(repositoryUrl, gitDirectory,
+                    new CloneOptions
+                    {
+                        Checkout = false,
+                        CredentialsProvider = (url, usernameFromUrl, types) => credentials
+                    });
+            }
+            catch (LibGit2SharpException ex)
+            {
+                var message = ex.Message;
+                if (message.Contains("401"))
+                {
+                    throw new Exception("Unauthorised: Incorrect username/password");
+                }
+                if (message.Contains("403"))
+                {
+                    throw new Exception("Forbidden: Possbily Incorrect username/password");
+                }
+                if (message.Contains("404"))
+                {
+                    throw new Exception("Not found: The repository was not found");
+                }
+                
+                throw new Exception("There was an unknown problem with the Git repository you provided");
+            }
+        }
+    }
+}