예제 #1
0
        public void ParseStatus()
        {
            var statusText = @"M  a
A  a.txt2
D  b
AM g.txt
MM a.txt
M  b.txt
?? x.txt
A  New File With Spaces.txt

";
            var status     = GitExeRepository.ParseStatus(statusText.AsReader()).ToList();

            Assert.Equal(8, status.Count);

            Assert.Equal("a", status[0].Path);
            Assert.Equal(ChangeType.Modified, status[0].Status);

            Assert.Equal("a.txt2", status[1].Path);
            Assert.Equal(ChangeType.Added, status[1].Status);

            Assert.Equal("b", status[2].Path);
            Assert.Equal(ChangeType.Deleted, status[2].Status);

            Assert.Equal("g.txt", status[3].Path);
            Assert.Equal(ChangeType.Added, status[3].Status);

            Assert.Equal("a.txt", status[4].Path);
            Assert.Equal(ChangeType.Modified, status[4].Status);

            Assert.Equal("b.txt", status[5].Path);
            Assert.Equal(ChangeType.Modified, status[5].Status);

            Assert.Equal("x.txt", status[6].Path);
            Assert.Equal(ChangeType.Untracked, status[6].Status);

            Assert.Equal("New File With Spaces.txt", status[7].Path);
            Assert.Equal(ChangeType.Added, status[7].Status);
        }
예제 #2
0
        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 <*****@*****.**>
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);
        }
예제 #3
0
        public void GitExecuteWithRetryTest(string message, int expect)
        {
            // Mock
            var settings = new Mock <IDeploymentSettingsManager>();
            var trace    = new Mock <ITraceFactory>();

            var       repository = new GitExeRepository(Mock.Of <IEnvironment>(), settings.Object, trace.Object);
            Exception exception  = null;
            var       actual     = 0;

            // Setup
            trace.Setup(t => t.GetTracer())
            .Returns(() => NullTracer.Instance);

            // Test
            try
            {
                repository.ExecuteGenericGitCommandWithRetryAndCatchingWellKnownGitErrors(() =>
                {
                    ++actual;
                    if (message == null)
                    {
                        return(true);
                    }

                    throw new Exception(message);
                });
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // Assert
            Assert.Equal(expect, actual);
            Assert.Equal(message, (exception == null) ? null : exception.Message);
        }
예제 #4
0
        private static int Main(string[] args)
        {
            // Turn flag on in app.config to wait for debugger on launch
            if (ConfigurationManager.AppSettings["WaitForDebuggerOnStart"] == "true")
            {
                while (!Debugger.IsAttached)
                {
                    System.Threading.Thread.Sleep(100);
                }
            }

            if (System.Environment.GetEnvironmentVariable(SettingsKeys.DisableDeploymentOnPush) == "1")
            {
                return(0);
            }

            if (args.Length < 2)
            {
                System.Console.WriteLine("Usage: kudu.exe appRoot wapTargets [deployer]");
                return(1);
            }

            // The post receive hook launches the exe from sh and intereprets newline differently.
            // This fixes very wacky issues with how the output shows up in the console on push
            System.Console.Error.NewLine = "\n";
            System.Console.Out.NewLine   = "\n";

            System.Environment.SetEnvironmentVariable("GIT_DIR", null, System.EnvironmentVariableTarget.Process);

            // Skip SSL Certificate Validate
            OperationClient.SkipSslValidationIfNeeded();

            string appRoot    = args[0];
            string wapTargets = args[1];
            string deployer   = args.Length == 2 ? null : args[2];

            IEnvironment env      = GetEnvironment(appRoot);
            ISettings    settings = new XmlSettings.Settings(GetSettingsPath(env));
            IDeploymentSettingsManager settingsManager = new DeploymentSettingsManager(settings);

            // Adjust repo path
            env.RepositoryPath = Path.Combine(env.SiteRootPath, settingsManager.GetRepositoryPath());

            // Setup the trace
            TraceLevel    level        = settingsManager.GetTraceLevel();
            ITracer       tracer       = GetTracer(env, level);
            ITraceFactory traceFactory = new TracerFactory(() => tracer);

            // Calculate the lock path
            string lockPath           = Path.Combine(env.SiteRootPath, Constants.LockPath);
            string deploymentLockPath = Path.Combine(lockPath, Constants.DeploymentLockFile);
            string statusLockPath     = Path.Combine(lockPath, Constants.StatusLockFile);
            string hooksLockPath      = Path.Combine(lockPath, Constants.HooksLockFile);

            IOperationLock deploymentLock = new LockFile(deploymentLockPath, traceFactory);
            IOperationLock statusLock     = new LockFile(statusLockPath, traceFactory);
            IOperationLock hooksLock      = new LockFile(hooksLockPath, traceFactory);

            IBuildPropertyProvider buildPropertyProvider = new BuildPropertyProvider();
            ISiteBuilderFactory    builderFactory        = new SiteBuilderFactory(buildPropertyProvider, env);

            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);

            IWebHooksManager         hooksManager            = new WebHooksManager(tracer, env, hooksLock);
            IDeploymentStatusManager deploymentStatusManager = new DeploymentStatusManager(env, analytics, statusLock);
            IAutoSwapHandler         autoSwapHander          = new AutoSwapHandler(deploymentStatusManager, env, settingsManager, traceFactory);
            var functionManager = new FunctionManager(env, traceFactory);
            var logger          = new ConsoleLogger();
            IDeploymentManager deploymentManager = new DeploymentManager(builderFactory,
                                                                         env,
                                                                         traceFactory,
                                                                         analytics,
                                                                         settingsManager,
                                                                         deploymentStatusManager,
                                                                         deploymentLock,
                                                                         GetLogger(env, level, logger),
                                                                         hooksManager,
                                                                         autoSwapHander,
                                                                         functionManager);

            var step = tracer.Step(XmlTracer.ExecutingExternalProcessTrace, new Dictionary <string, string>
            {
                { "type", "process" },
                { "path", "kudu.exe" },
                { "arguments", appRoot + " " + wapTargets }
            });

            using (step)
            {
                try
                {
                    deploymentManager.DeployAsync(gitRepository, changeSet: null, deployer: deployer, clean: false)
                    .Wait();
                }
                catch (Exception e)
                {
                    tracer.TraceError(e);

                    System.Console.Error.WriteLine(e.GetBaseException().Message);
                    System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                    return(1);
                }
            }

            if (logger.HasErrors)
            {
                System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                return(1);
            }

            return(0);
        }
예제 #5
0
        private static int PerformDeploy(
            string appRoot,
            string wapTargets,
            string deployer,
            string lockPath,
            IEnvironment env,
            IDeploymentSettingsManager settingsManager,
            TraceLevel level,
            ITracer tracer,
            ITraceFactory traceFactory,
            IOperationLock deploymentLock)
        {
            System.Environment.SetEnvironmentVariable("GIT_DIR", null, System.EnvironmentVariableTarget.Process);

            // Skip SSL Certificate Validate
            if (System.Environment.GetEnvironmentVariable(SettingsKeys.SkipSslValidation) == "1")
            {
                ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
            }

            // Adjust repo path
            env.RepositoryPath = Path.Combine(env.SiteRootPath, settingsManager.GetRepositoryPath());

            string statusLockPath = Path.Combine(lockPath, Constants.StatusLockFile);
            string hooksLockPath  = Path.Combine(lockPath, Constants.HooksLockFile);

            IOperationLock statusLock = new LockFile(statusLockPath, traceFactory);
            IOperationLock hooksLock  = new LockFile(hooksLockPath, traceFactory);

            IBuildPropertyProvider buildPropertyProvider = new BuildPropertyProvider();
            ISiteBuilderFactory    builderFactory        = new SiteBuilderFactory(buildPropertyProvider, env);
            var logger = new ConsoleLogger();

            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);

            IWebHooksManager         hooksManager            = new WebHooksManager(tracer, env, hooksLock);
            IDeploymentStatusManager deploymentStatusManager = new DeploymentStatusManager(env, analytics, statusLock);
            IDeploymentManager       deploymentManager       = new DeploymentManager(builderFactory,
                                                                                     env,
                                                                                     traceFactory,
                                                                                     analytics,
                                                                                     settingsManager,
                                                                                     deploymentStatusManager,
                                                                                     deploymentLock,
                                                                                     GetLogger(env, level, logger),
                                                                                     hooksManager);

            var step = tracer.Step(XmlTracer.ExecutingExternalProcessTrace, new Dictionary <string, string>
            {
                { "type", "process" },
                { "path", "kudu.exe" },
                { "arguments", appRoot + " " + wapTargets }
            });

            using (step)
            {
                try
                {
                    // although the api is called DeployAsync, most expensive works are done synchronously.
                    // need to launch separate task to go async explicitly (consistent with FetchDeploymentManager)
                    var deploymentTask = Task.Run(async() => await deploymentManager.DeployAsync(gitRepository, changeSet: null, deployer: deployer, clean: false));

#pragma warning disable 4014
                    // Track pending task
                    PostDeploymentHelper.TrackPendingOperation(deploymentTask, TimeSpan.Zero);
#pragma warning restore 4014

                    deploymentTask.Wait();

                    if (PostDeploymentHelper.IsAutoSwapEnabled())
                    {
                        string                branch     = settingsManager.GetBranch();
                        ChangeSet             changeSet  = gitRepository.GetChangeSet(branch);
                        IDeploymentStatusFile statusFile = deploymentStatusManager.Open(changeSet.Id);
                        if (statusFile != null && statusFile.Status == DeployStatus.Success)
                        {
                            PostDeploymentHelper.PerformAutoSwap(env.RequestId, new PostDeploymentTraceListener(tracer, deploymentManager.GetLogger(changeSet.Id))).Wait();
                        }
                    }
                }
                catch (Exception e)
                {
                    tracer.TraceError(e);

                    System.Console.Error.WriteLine(e.GetBaseException().Message);
                    System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                    return(1);
                }
            }

            if (logger.HasErrors)
            {
                System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                return(1);
            }

            return(0);
        }
예제 #6
0
 public void DecodeGitExeOutputToUtf8(string original, string expected)
 {
     Assert.Equal(GitExeRepository.DecodeGitLsOutput(original), expected);
 }
예제 #7
0
        private static int PerformDeploy(
            string appRoot,
            string wapTargets,
            string deployer,
            string lockPath,
            IEnvironment env,
            IDeploymentSettingsManager settingsManager,
            TraceLevel level,
            ITracer tracer,
            ITraceFactory traceFactory,
            IOperationLock deploymentLock)
        {
            System.Environment.SetEnvironmentVariable("GIT_DIR", null, System.EnvironmentVariableTarget.Process);

            // Skip SSL Certificate Validate
            OperationClient.SkipSslValidationIfNeeded();

            // Adjust repo path
            env.RepositoryPath = Path.Combine(env.SiteRootPath, settingsManager.GetRepositoryPath());

            string statusLockPath = Path.Combine(lockPath, Constants.StatusLockFile);
            string hooksLockPath  = Path.Combine(lockPath, Constants.HooksLockFile);

            IOperationLock statusLock = new LockFile(statusLockPath, traceFactory);
            IOperationLock hooksLock  = new LockFile(hooksLockPath, traceFactory);

            IBuildPropertyProvider buildPropertyProvider = new BuildPropertyProvider();
            ISiteBuilderFactory    builderFactory        = new SiteBuilderFactory(buildPropertyProvider, env);
            var logger = new ConsoleLogger();

            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);

            IWebHooksManager         hooksManager            = new WebHooksManager(tracer, env, hooksLock);
            IDeploymentStatusManager deploymentStatusManager = new DeploymentStatusManager(env, analytics, statusLock);
            IAutoSwapHandler         autoSwapHander          = new AutoSwapHandler(env, settingsManager, traceFactory);
            var functionManager = new FunctionManager(env, traceFactory);
            IDeploymentManager deploymentManager = new DeploymentManager(builderFactory,
                                                                         env,
                                                                         traceFactory,
                                                                         analytics,
                                                                         settingsManager,
                                                                         deploymentStatusManager,
                                                                         deploymentLock,
                                                                         GetLogger(env, level, logger),
                                                                         hooksManager,
                                                                         functionManager);

            var step = tracer.Step(XmlTracer.ExecutingExternalProcessTrace, new Dictionary <string, string>
            {
                { "type", "process" },
                { "path", "kudu.exe" },
                { "arguments", appRoot + " " + wapTargets }
            });

            using (step)
            {
                try
                {
                    deploymentManager.DeployAsync(gitRepository, changeSet: null, deployer: deployer, clean: false)
                    .Wait();

                    string                branch     = settingsManager.GetBranch();
                    ChangeSet             changeSet  = gitRepository.GetChangeSet(branch);
                    IDeploymentStatusFile statusFile = deploymentStatusManager.Open(changeSet.Id);
                    if (statusFile != null && statusFile.Status == DeployStatus.Success)
                    {
                        autoSwapHander.HandleAutoSwap(changeSet.Id, deploymentManager.GetLogger(changeSet.Id), tracer).Wait();
                    }
                }
                catch (Exception e)
                {
                    tracer.TraceError(e);

                    System.Console.Error.WriteLine(e.GetBaseException().Message);
                    System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                    return(1);
                }
            }

            if (logger.HasErrors)
            {
                System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                return(1);
            }

            return(0);
        }
예제 #8
0
 public void ConvertStatusUnknownStatusThrows()
 {
     Assert.Throws <InvalidOperationException>(() => GitExeRepository.ConvertStatus("AG"));
 }
예제 #9
0
 public void IsDiffHeaderReturnsTrueForValidDiffHeaders()
 {
     Assert.True(GitExeRepository.IsDiffHeader("diff --git"));
 }
예제 #10
0
        static int Main(string[] args)
        {
            // Turn flag on in app.config to wait for debugger on launch
            if (ConfigurationManager.AppSettings["WaitForDebuggerOnStart"] == "true")
            {
                while (!Debugger.IsAttached)
                {
                    System.Threading.Thread.Sleep(100);
                }
            }

            if (args.Length < 2)
            {
                System.Console.WriteLine("Usage: kudu.exe appRoot wapTargets [deployer]");
                return(1);
            }

            // The post receive hook launches the exe from sh and intereprets newline differently.
            // This fixes very wacky issues with how the output shows up in the conosle on push
            System.Console.Error.NewLine = "\n";
            System.Console.Out.NewLine   = "\n";

            System.Environment.SetEnvironmentVariable("GIT_DIR", null, System.EnvironmentVariableTarget.Process);

            string appRoot    = args[0];
            string wapTargets = args[1];
            string deployer   = args.Length == 2 ? null : args[2];

            IEnvironment env      = GetEnvironment(appRoot);
            ISettings    settings = new XmlSettings.Settings(GetSettingsPath(env));
            IDeploymentSettingsManager settingsManager = new DeploymentSettingsManager(settings);

            // Adjust repo path
            env.RepositoryPath = Path.Combine(env.SiteRootPath, settingsManager.GetRepositoryPath());

            // Setup the trace
            IFileSystem   fileSystem   = new FileSystem();
            TraceLevel    level        = settingsManager.GetTraceLevel();
            ITracer       tracer       = GetTracer(env, level, fileSystem);
            ITraceFactory traceFactory = new TracerFactory(() => tracer);

            // Calculate the lock path
            string         lockPath           = Path.Combine(env.SiteRootPath, Constants.LockPath);
            string         deploymentLockPath = Path.Combine(lockPath, Constants.DeploymentLockFile);
            string         statusLockPath     = Path.Combine(lockPath, Constants.StatusLockFile);
            IOperationLock deploymentLock     = new LockFile(deploymentLockPath, traceFactory, fileSystem);
            IOperationLock statusLock         = new LockFile(statusLockPath, traceFactory, fileSystem);

            IBuildPropertyProvider buildPropertyProvider = new BuildPropertyProvider();
            ISiteBuilderFactory    builderFactory        = new SiteBuilderFactoryDispatcher(buildPropertyProvider, env);

            IRepository gitRepository = new GitExeRepository(env, settingsManager, traceFactory);

            var logger = new ConsoleLogger();
            IDeploymentManager deploymentManager = new DeploymentManager(builderFactory,
                                                                         env,
                                                                         fileSystem,
                                                                         traceFactory,
                                                                         settingsManager,
                                                                         new DeploymentStatusManager(env, fileSystem, statusLock),
                                                                         deploymentLock,
                                                                         GetLogger(env, level, logger));

            var step = tracer.Step("Executing external process", new Dictionary <string, string>
            {
                { "type", "process" },
                { "path", "kudu.exe" },
                { "arguments", appRoot + " " + wapTargets }
            });

            using (step)
            {
                try
                {
                    deploymentManager.Deploy(gitRepository, changeSet: null, deployer: deployer, clean: false);
                }
                catch (Exception e)
                {
                    System.Console.Error.WriteLine(e.Message);
                    System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                    return(1);
                }
            }

            if (logger.HasErrors)
            {
                System.Console.Error.WriteLine(Resources.Log_DeploymentError);
                return(1);
            }

            return(0);
        }
예제 #11
0
 public TestRepository(string repositoryName)
 {
     _physicalPath = Git.GetRepositoryPath(repositoryName);
     _repository   = new GitExeRepository(_physicalPath);
 }