public Task Build(DeploymentContext context)
{
var tcs = new TaskCompletionSource <object>();
ILogger innerLogger = context.Logger.Log(Resources.Log_PreparingFiles);
try
{
using (context.Tracer.Step("Copying files to output directory"))
{
// Copy to the output path and use the previous manifest if there
DeploymentHelper.CopyWithManifest(_sourcePath, context.OutputPath, context.PreviousMainfest);
}
using (context.Tracer.Step("Building manifest"))
{
// Generate a manifest from those build artifacts
context.ManifestWriter.AddFiles(_sourcePath);
}
// Log the copied files from the manifest
innerLogger.LogFileList(context.ManifestWriter.GetPaths());
}
catch (Exception ex)
{
context.Tracer.TraceError(ex);
context.GlobalLogger.Log(ex);
innerLogger.Log(ex);
tcs.SetException(ex);
// Bail out early
return(tcs.Task);
}
try
{
// Download node packages
DownloadNodePackages(context);
AddIISNodeConfig(context);
tcs.SetResult(null);
}
catch (Exception ex)
{
context.Tracer.TraceError(ex);
// HACK: Log an empty error to the global logger (post receive hook console output).
// The reason we don't log the real exception is because the 'live output' when downloding
// npm packages has already been captured.
context.GlobalLogger.LogError();
tcs.SetException(ex);
}
return(tcs.Task);
}
private ISiteBuilder DetermineProject(string repositoryRoot, string targetPath)
{
if (!DeploymentHelper.IsDeployableProject(targetPath))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectNotDeployable,
targetPath));
}
else if (File.Exists(targetPath))
{
var solution = VsHelper.FindContainingSolution(repositoryRoot, targetPath);
string solutionPath = solution != null ? solution.Path : null;
return(new WapBuilder(_settings,
_propertyProvider,
repositoryRoot,
targetPath,
_environment.TempPath,
_environment.NuGetCachePath,
solutionPath));
}
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectDoesNotExist,
targetPath));
}
private ISiteBuilder ResolveProject(string repositoryRoot, string targetPath, bool tryWebSiteProject, SearchOption searchOption = SearchOption.AllDirectories, bool specificConfiguration = true)
{
if (DeploymentHelper.IsProject(targetPath))
{
return(DetermineProject(repositoryRoot, targetPath));
}
// Check for loose projects
var projects = DeploymentHelper.GetProjects(targetPath, searchOption);
if (projects.Count > 1)
{
// Can't determine which project to build
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_AmbiguousProjects,
String.Join(", ", projects)));
}
else if (projects.Count == 1)
{
return(DetermineProject(repositoryRoot, projects[0]));
}
if (tryWebSiteProject)
{
// Website projects need a solution to build so look for one in the repository path
// that has this website in it.
var solutions = VsHelper.FindContainingSolutions(repositoryRoot, targetPath);
// More than one solution is ambiguous
if (solutions.Count > 1)
{
ThrowAmbiguousSolutionsError(solutions);
}
else if (solutions.Count == 1)
{
// Unambiguously pick the root
return(new WebSiteBuilder(_propertyProvider,
repositoryRoot,
targetPath,
_environment.TempPath,
_environment.NuGetCachePath,
solutions[0].Path));
}
}
// This should only ever happen if the user specifies an invalid directory.
// The other case where the method is called we always resolve the path so it's a non issue there.
if (specificConfiguration && !Directory.Exists(targetPath))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_ProjectDoesNotExist,
targetPath));
}
// If there's none then use the basic builder (the site is xcopy deployable)
return(new BasicBuilder(targetPath, _environment.TempPath, _environment.ScriptPath, _environment.SiteRootPath));
}
protected override Task BuildProject(DeploymentContext context)
{
var tcs = new TaskCompletionSource <object>();
ILogger copyLogger = context.Logger.Log(Resources.Log_PreparingFiles);
try
{
using (context.Tracer.Step("Copying files to output directory"))
{
// Copy to the output path
DeploymentHelper.CopyWithManifest(_projectPath, context.OutputPath, context.PreviousMainfest);
}
using (context.Tracer.Step("Building manifest"))
{
// Generate the manifest from the project path
context.ManifestWriter.AddFiles(_projectPath);
}
// Log the copied files from the manifest
copyLogger.LogFileList(context.ManifestWriter.GetPaths());
tcs.SetResult(null);
}
catch (Exception ex)
{
context.Tracer.TraceError(ex);
context.GlobalLogger.Log(ex);
copyLogger.Log(ex);
tcs.SetException(ex);
}
return(tcs.Task);
}
public override Task Build(DeploymentContext context)
{
var tcs = new TaskCompletionSource <object>();
string buildTempPath = Path.Combine(_tempPath, Guid.NewGuid().ToString());
ILogger buildLogger = context.Logger.Log(Resources.Log_BuildingWebProject, Path.GetFileName(_projectPath));
try
{
using (context.Tracer.Step("Running msbuild on project file"))
{
string log = BuildProject(context.Tracer, buildTempPath);
// Log the details of the build
buildLogger.Log(log);
}
}
catch (Exception ex)
{
context.Tracer.TraceError(ex);
// HACK: Log an empty error to the global logger (post receive hook console output).
// The reason we don't log the real exception is because the 'live output' running
// msbuild has already been captured.
context.GlobalLogger.LogError();
buildLogger.Log(ex);
tcs.SetException(ex);
return(tcs.Task);
}
ILogger copyLogger = context.Logger.Log(Resources.Log_PreparingFiles);
try
{
using (context.Tracer.Step("Copying files to output directory"))
{
// Copy to the output path and use the previous manifest if there
DeploymentHelper.CopyWithManifest(buildTempPath, context.OutputPath, context.PreviousMainfest);
}
using (context.Tracer.Step("Building manifest"))
{
// Generate a manifest from those build artifacts
context.ManifestWriter.AddFiles(buildTempPath);
}
// Log the copied files from the manifest
copyLogger.LogFileList(context.ManifestWriter.GetPaths());
tcs.SetResult(null);
}
catch (Exception ex)
{
context.Tracer.TraceError(ex);
context.GlobalLogger.Log(ex);
copyLogger.Log(ex);
tcs.SetException(ex);
}
finally
{
// Clean up the build artifacts after copying them
CleanBuild(context.Tracer, buildTempPath);
}
return(tcs.Task);
}