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);
}
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);
}
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);
}
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);
}
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);
}
public void DecodeGitExeOutputToUtf8(string original, string expected)
{
Assert.Equal(GitExeRepository.DecodeGitLsOutput(original), expected);
}
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);
}
public void ConvertStatusUnknownStatusThrows()
{
Assert.Throws <InvalidOperationException>(() => GitExeRepository.ConvertStatus("AG"));
}
public void IsDiffHeaderReturnsTrueForValidDiffHeaders()
{
Assert.True(GitExeRepository.IsDiffHeader("diff --git"));
}
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);
}
public TestRepository(string repositoryName)
{
_physicalPath = Git.GetRepositoryPath(repositoryName);
_repository = new GitExeRepository(_physicalPath);
}
