private string ModificationFile(IIntegrationResult result)
{
if (!AppendTimeStamp)
{
return(Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename));
}
FileInfo fi = new FileInfo(Filename);
string dummy = Filename.Remove(Filename.Length - fi.Extension.Length, fi.Extension.Length);
string newFileName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0}_{1}{2}", dummy, result.StartTime.ToString("yyyyMMddHHmmssfff", CultureInfo.CurrentCulture),
fi.Extension);
return(Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), newFileName));
}
private string[] GetModificationFiles(IIntegrationResult result)
{
FileInfo fi = new FileInfo(Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename));
string filespec = fi.Name.Remove(fi.Name.Length - fi.Extension.Length) + "*" + fi.Extension;
return(Directory.GetFiles(fi.DirectoryName, filespec));
}
/// <summary>
/// Make sure this IIntegrationResult object has our environment variables set in it.
/// </summary>
/// <param name="environmentVariables">The collection of environment variables to be updated.</param>
/// <param name="result">IntegrationResult for the command whose variables we are updating.</param>
private void SetEnvironmentVariables(StringDictionary environmentVariables, IIntegrationResult result)
{
if (!string.IsNullOrEmpty(AccuRevHomeDir))
{
environmentVariables["ACCUREV_HOME"] = result.BaseFromArtifactsDirectory(AccuRevHomeDir);
}
if (!string.IsNullOrEmpty(AccuRevPrincipal))
{
environmentVariables["ACCUREV_PRINCIPAL"] = AccuRevPrincipal;
}
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Running NCover reporting");
// Make sure there is a root directory
rootPath = BaseDirectory;
if (string.IsNullOrEmpty(rootPath))
{
rootPath = result.WorkingDirectory;
}
// Take a before snapshot of all the files
var outputDirectory = new DirectoryInfo(RootPath(OutputDir, false));
var oldFiles = GenerateOriginalFileList(outputDirectory);
// Run the executable
var info = this.CreateProcessInfo(result);
var processResult = this.TryToRun(info, result);
result.AddTaskResult(new ProcessTaskResult(processResult, false));
if (processResult.TimedOut)
{
result.AddTaskResult(MakeTimeoutBuildResult(info));
}
// Check for any new files and copy them to the artefact folder
if (processResult.Succeeded)
{
outputDirectory.Refresh();
var newFiles = ListFileDifferences(oldFiles, outputDirectory);
if (newFiles.Length > 0)
{
// Copy all the new files over
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "NCover");
Log.Debug(string.Format(System.Globalization.CultureInfo.CurrentCulture, "Copying {0} files to {1}", newFiles.Length, publishDir));
var index = outputDirectory.FullName.Length + 1;
foreach (FileInfo newFile in newFiles)
{
var fileInfo = new FileInfo(Path.Combine(publishDir, newFile.FullName.Substring(index)));
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
newFile.CopyTo(fileInfo.FullName, true);
}
}
}
return(processResult.Succeeded);
}
public virtual void Run(IIntegrationResult result)
{
string outputFile = result.BaseFromArtifactsDirectory(OutputFile);
ProcessResult nunitResult = processExecutor.Execute(NewProcessInfo(outputFile, result));
result.AddTaskResult(new ProcessTaskResult(nunitResult));
if (File.Exists(outputFile))
{
result.AddTaskResult(new FileTaskResult(outputFile));
}
else
{
Log.Warning(string.Format("NUnit test output file {0} was not created", outputFile));
}
}
public virtual void Run(IIntegrationResult result)
{
string outputFile = result.BaseFromArtifactsDirectory(OutputFile);
ProcessResult nunitResult = processExecutor.Execute(NewProcessInfo(outputFile, result), result.ProjectName);
result.AddTaskResult(new ProcessTaskResult(nunitResult));
if (File.Exists(outputFile))
{
result.AddTaskResult(new FileTaskResult(outputFile));
}
else
{
Log.Warning(string.Format("NUnit test output file {0} was not created", outputFile));
}
}
/// <summary>
/// Add the package to the list of packages.
/// </summary>
/// <param name="result"></param>
/// <param name="listFile"></param>
/// <param name="fileName"></param>
/// <param name="numberOfFiles"></param>
/// <remarks>
/// This is to allow discoverability of packages. In future CruiseControl.Net will allow clients to download this
/// list to see which packages are available.
/// </remarks>
private void AddToPackageList(IIntegrationResult result, string listFile, string fileName, int numberOfFiles)
{
XmlDocument listXml = new XmlDocument();
// See if there is an existing list
listFile = result.BaseFromArtifactsDirectory(listFile);
if (File.Exists(listFile))
{
listXml.Load(listFile);
}
else
{
XmlElement rootElement = listXml.CreateElement("packages");
listXml.AppendChild(rootElement);
}
// See if the entry already exists
XmlElement packageElement = listXml.SelectSingleNode(
string.Format(CultureInfo.CurrentCulture, "/packages/package[@name='{0}']", PackageName)) as XmlElement;
if (packageElement == null)
{
packageElement = listXml.CreateElement("package");
listXml.DocumentElement.AppendChild(packageElement);
packageElement.SetAttribute("name", PackageName);
}
// Add the properties for the package
var packageFile = new FileInfo(fileName);
packageElement.SetAttribute("file", fileName);
packageElement.SetAttribute("label", result.Label);
packageElement.SetAttribute("time", DateTime.Now.ToString("s", CultureInfo.CurrentCulture));
packageElement.SetAttribute("files", numberOfFiles.ToString(CultureInfo.CurrentCulture));
packageElement.SetAttribute("size", packageFile.Length.ToString(CultureInfo.CurrentCulture));
// Save the updated list
var listDir = Path.GetDirectoryName(listFile);
if (!Directory.Exists(listDir))
{
Directory.CreateDirectory(listDir);
}
listXml.Save(listFile);
}
/// <summary>
/// Moves the file from its temporary (working) location to its final location.
/// </summary>
/// <param name="result"></param>
/// <param name="tempFile"></param>
/// <returns></returns>
/// <remarks>
/// This method will also generate the correct name of the file and ensure
/// the output directory exists.
/// </remarks>
private string MoveFile(IIntegrationResult result, string tempFile)
{
string actualFile = EnsureFileExtension(Path.Combine(result.Label, PackageName), ".zip");
actualFile = result.BaseFromArtifactsDirectory(actualFile);
if (File.Exists(actualFile))
{
DeleteFileWithRetry(actualFile);
}
string actualFolder = Path.GetDirectoryName(actualFile);
if (!Directory.Exists(actualFolder))
{
Directory.CreateDirectory(actualFolder);
}
File.Move(tempFile, actualFile);
if (!string.IsNullOrEmpty(OutputDirectory))
{
var basePath = OutputDirectory;
if (!Path.IsPathRooted(basePath))
{
basePath = Path.Combine(result.ArtifactDirectory, basePath);
}
// Create output directory if it doesn't exist
if (!Directory.Exists(basePath))
{
Log.Info(string.Format(
CultureInfo.CurrentCulture, "Creating output directory '{0}'", basePath));
Directory.CreateDirectory(basePath);
}
// Copy the file to the output directory (so it can be used by other tasks)
Log.Info(string.Format(
CultureInfo.CurrentCulture, "Copying file to '{0}'", basePath));
File.Copy(
actualFile,
EnsureFileExtension(Path.Combine(basePath, PackageName), ".zip"),
true);
}
return(actualFile);
}
/// <summary>
/// Executes the specified result.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
/// <remarks></remarks>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Executing NUnit");
string outputFile = result.BaseFromArtifactsDirectory(OutputFile);
ProcessResult nunitResult = executor.Execute(NewProcessInfo(outputFile, result));
DeleteNUnitAgentProcesses();
result.AddTaskResult(new ProcessTaskResult(nunitResult, true));
if (File.Exists(outputFile))
{
result.AddTaskResult(new FileTaskResult(outputFile));
}
else
{
Log.Warning(string.Format(System.Globalization.CultureInfo.CurrentCulture, "NUnit test output file {0} was not created", outputFile));
}
return(!nunitResult.Failed);
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
this.logger.Debug("Starting ANTS Performance Profiler task");
result.BuildProgressInformation
.SignalStartRunTask(!string.IsNullOrEmpty(this.Description) ? this.Description : "Executing ANTS Performance Profiler");
// Make sure there is a root directory
this.rootPath = this.BaseDirectory;
if (string.IsNullOrEmpty(this.rootPath))
{
this.rootPath = result.WorkingDirectory;
}
// Run the executable
var info = this.CreateProcessInfo(result);
var processResult = this.TryToRun(info, result);
result.AddTaskResult(new ProcessTaskResult(processResult, false));
if (processResult.TimedOut)
{
result.AddTaskResult(MakeTimeoutBuildResult(info));
}
// Publish the results
if (this.PublishFiles) // && !processResult.Failed) - TODO: only publish files if successful
{
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "AntsPerformance");
this.PublishFile(string.IsNullOrEmpty(this.OutputFile) ? defaultOutput : this.OutputFile, publishDir);
this.PublishFile(this.SummaryCsvFile, publishDir);
this.PublishFile(this.SummaryXmlFile, publishDir);
this.PublishFile(this.SummaryHtmlFile, publishDir);
this.PublishFile(this.CallTreeXmlFile, publishDir);
this.PublishFile(this.CallTreeHtmlFile, publishDir);
this.PublishFile(this.DataFile, publishDir);
}
return(processResult.Succeeded);
}
private string ModificationFile(IIntegrationResult result)
{
return(Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename));
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Executing NDepend");
// Make sure there is a root directory
rootPath = BaseDirectory;
if (string.IsNullOrEmpty(rootPath))
{
rootPath = result.WorkingDirectory;
}
// Take a before snapshot of all the files
var outputDirectory = RootPath(OutputDir, false);
var oldFiles = GenerateOriginalFileList(outputDirectory);
// Run the executable
var info = this.CreateProcessInfo(result);
var processResult = this.TryToRun(info, result);
result.AddTaskResult(new ProcessTaskResult(processResult, false));
if (processResult.TimedOut)
{
result.AddTaskResult(MakeTimeoutBuildResult(info));
}
if (Publish && processResult.Succeeded)
{
// Check for any new files
var newFiles = ListFileDifferences(oldFiles, outputDirectory);
if (newFiles.Length > 0)
{
logger.Debug("Copying {0} new file(s)", newFiles.Length);
// Copy all the new files over
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "NDepend");
var oldLen = outputDirectory.Length + 1;
var lastDir = string.Empty;
foreach (var newFile in newFiles)
{
// Ensure the directory exists
var newPath = Path.Combine(publishDir, newFile.Substring(oldLen));
var newDir = Path.GetDirectoryName(newPath);
if (lastDir != newDir)
{
lastDir = newDir;
if (!fileSystem.DirectoryExists(newDir))
{
fileSystem.CreateDirectory(newDir);
}
}
// Copy the file and marge it if XML
if (fileSystem.FileExists(newFile))
{
fileSystem.Copy(newFile, newPath);
if (Path.GetExtension(newFile) == ".xml")
{
result.AddTaskResult(fileSystem.GenerateTaskResultFromFile(newFile));
}
}
else
{
logger.Warning("Unable to find file: " + newFile);
}
}
}
}
return(processResult.Succeeded);
}
/// <summary>
/// Executes the specified result.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
/// <remarks></remarks>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Executing NUnit");
string outputFile = result.BaseFromArtifactsDirectory(OutputFile);
ProcessResult nunitResult = executor.Execute(NewProcessInfo(outputFile, result));
DeleteNUnitAgentProcesses();
result.AddTaskResult(new ProcessTaskResult(nunitResult, true));
if (File.Exists(outputFile))
{
result.AddTaskResult(new FileTaskResult(outputFile));
}
else
{
Log.Warning(string.Format(System.Globalization.CultureInfo.CurrentCulture,"NUnit test output file {0} was not created", outputFile));
}
return !nunitResult.Failed;
}
/// <summary>
/// Moves the file from its temporary (working) location to its final location.
/// </summary>
/// <param name="result"></param>
/// <param name="tempFile"></param>
/// <returns></returns>
/// <remarks>
/// This method will also generate the correct name of the file and ensure
/// the output directory exists.
/// </remarks>
private string MoveFile(IIntegrationResult result, string tempFile)
{
string actualFile = EnsureFileExtension(Path.Combine(result.Label, PackageName), ".zip");
actualFile = result.BaseFromArtifactsDirectory(actualFile);
if (File.Exists(actualFile))
{
DeleteFileWithRetry(actualFile);
}
string actualFolder = Path.GetDirectoryName(actualFile);
if (!Directory.Exists(actualFolder))
{
Directory.CreateDirectory(actualFolder);
}
File.Move(tempFile, actualFile);
if (!string.IsNullOrEmpty(OutputDirectory))
{
var basePath = OutputDirectory;
if (!Path.IsPathRooted(basePath))
{
basePath = Path.Combine(result.ArtifactDirectory, basePath);
}
// Create output directory if it doesn't exist
if (!Directory.Exists(basePath))
{
Log.Info(string.Format(
CultureInfo.CurrentCulture, "Creating output directory '{0}'", basePath));
Directory.CreateDirectory(basePath);
}
// Copy the file to the output directory (so it can be used by other tasks)
Log.Info(string.Format(
CultureInfo.CurrentCulture, "Copying file to '{0}'", basePath));
File.Copy(
actualFile,
EnsureFileExtension(Path.Combine(basePath, PackageName), ".zip"),
true);
}
return actualFile;
}
/// <summary>
/// Moves the file from its temporary (working) location to its final location.
/// </summary>
/// <param name="result"></param>
/// <param name="tempFile"></param>
/// <returns></returns>
/// <remarks>
/// This method will also generate the correct name of the file.
/// </remarks>
private string MoveFile(IIntegrationResult result, string tempFile)
{
string actualFile = Path.Combine(result.Label, name);
if (!actualFile.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase)) actualFile += ".zip";
actualFile = result.BaseFromArtifactsDirectory(actualFile);
if (File.Exists(actualFile)) DeleteFileWithRetry(actualFile);
string actualFolder = Path.GetDirectoryName(actualFile);
if (!Directory.Exists(actualFolder)) Directory.CreateDirectory(actualFolder);
File.Move(tempFile, actualFile);
if (!string.IsNullOrEmpty(OutputDirectory))
{
// Copy the file to the output directory (so it can be used by other tasks)
var basePath = OutputDirectory;
if (!Path.IsPathRooted(basePath)) basePath = Path.Combine(result.ArtifactDirectory, basePath);
Log.Info(string.Format("Copying file to '{0}'", basePath));
File.Copy(actualFile, Path.Combine(basePath, Name), true);
}
return actualFile;
}
/// <summary>
/// Make sure this IIntegrationResult object has our environment variables set in it.
/// </summary>
/// <param name="environmentVariables">The collection of environment variables to be updated.</param>
/// <param name="result">IntegrationResult for the command whose variables we are updating.</param>
private void SetEnvironmentVariables(StringDictionary environmentVariables, IIntegrationResult result)
{
if (!string.IsNullOrEmpty(AccuRevHomeDir))
environmentVariables["ACCUREV_HOME"] = result.BaseFromArtifactsDirectory(AccuRevHomeDir);
if (!string.IsNullOrEmpty(AccuRevPrincipal))
environmentVariables["ACCUREV_PRINCIPAL"] = AccuRevPrincipal;
}
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Publishing build results");
if (result.Succeeded || AlwaysPublish)
{
DirectoryInfo srcDir = new DirectoryInfo(result.BaseFromWorkingDirectory(SourceDir));
DirectoryInfo pubDir = new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir));
if (!pubDir.Exists)
{
pubDir.Create();
}
else
{
if (CleanPublishDirPriorToCopy)
{
DeleteFolder(pubDir.FullName);
pubDir.Create();
}
}
if (UseLabelSubDirectory)
pubDir = pubDir.CreateSubdirectory(result.Label);
RecurseSubDirectories(srcDir, pubDir);
switch (CleanUpMethod)
{
case CleanupPolicy.NoCleaning:
break;
case CleanupPolicy.DeleteBuildsOlderThanXDays:
DeleteSubDirsOlderThanXDays(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
case CleanupPolicy.KeepLastXBuilds:
KeepLastXSubDirs(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
default:
throw new System.Exception(string.Format("unmapped cleaning method choosen {0}", CleanUpMethod));
}
}
return true;
}
private string[] GetModificationFiles(IIntegrationResult result)
{
FileInfo fi = new FileInfo(Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename));
string filespec = fi.Name.Remove(fi.Name.Length - fi.Extension.Length) + "*" + fi.Extension;
return Directory.GetFiles(fi.DirectoryName,filespec);
}
private string ModificationFile(IIntegrationResult result)
{
return Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename);
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Executing NDepend");
// Make sure there is a root directory
rootPath = BaseDirectory;
if (string.IsNullOrEmpty(rootPath)) rootPath = result.WorkingDirectory;
// Take a before snapshot of all the files
var outputDirectory = RootPath(OutputDir, false);
var oldFiles = GenerateOriginalFileList(outputDirectory);
// Run the executable
var info = this.CreateProcessInfo(result);
var processResult = this.TryToRun(info, result);
result.AddTaskResult(new ProcessTaskResult(processResult, false));
if (processResult.TimedOut)
{
result.AddTaskResult(MakeTimeoutBuildResult(info));
}
if (Publish && processResult.Succeeded)
{
// Check for any new files
var newFiles = ListFileDifferences(oldFiles, outputDirectory);
if (newFiles.Length > 0)
{
logger.Debug("Copying {0} new file(s)", newFiles.Length);
// Copy all the new files over
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "NDepend");
var oldLen = outputDirectory.Length + 1;
var lastDir = string.Empty;
foreach (var newFile in newFiles)
{
// Ensure the directory exists
var newPath = Path.Combine(publishDir, newFile.Substring(oldLen));
var newDir = Path.GetDirectoryName(newPath);
if (lastDir != newDir)
{
lastDir = newDir;
if (!fileSystem.DirectoryExists(newDir))
{
fileSystem.CreateDirectory(newDir);
}
}
// Copy the file and marge it if XML
if (fileSystem.FileExists(newFile))
{
fileSystem.Copy(newFile, newPath);
if (Path.GetExtension(newFile) == ".xml")
{
result.AddTaskResult(fileSystem.GenerateTaskResultFromFile(newFile));
}
}
else
{
logger.Warning("Unable to find file: " + newFile);
}
}
}
}
return processResult.Succeeded;
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Executing NDepend");
// Make sure there is a root directory
rootPath = BaseDirectory;
if (string.IsNullOrEmpty(rootPath)) rootPath = result.WorkingDirectory;
// Take a before snapshot of all the files
var outputDirectory = RootPath(OutputDir, false);
var oldFiles = GenerateOriginalFileList(outputDirectory);
// Run the executable
var processResult = TryToRun(CreateProcessInfo(result), result);
result.AddTaskResult(new ProcessTaskResult(processResult, true));
if (Publish && !processResult.Failed)
{
// Check for any new files
var newFiles = ListFileDifferences(oldFiles, outputDirectory);
if (newFiles.Length > 0)
{
logger.Debug("Copying {0} new file(s)", newFiles.Length);
// Copy all the new files over
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "NDepend");
fileSystem.EnsureFolderExists(publishDir);
foreach (var newFile in newFiles)
{
fileSystem.Copy(newFile,
Path.Combine(publishDir,
Path.GetFileName(newFile)));
// Merge all XML files
if (Path.GetExtension(newFile) == ".xml")
{
result.AddTaskResult(fileSystem.GenerateTaskResultFromFile(newFile));
}
}
}
}
return !processResult.Failed;
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
this.logger.Debug("Starting ANTS Performance Profiler task");
result.BuildProgressInformation
.SignalStartRunTask(!string.IsNullOrEmpty(this.Description) ? this.Description : "Executing ANTS Performance Profiler");
// Make sure there is a root directory
this.rootPath = this.BaseDirectory;
if (string.IsNullOrEmpty(this.rootPath))
{
this.rootPath = result.WorkingDirectory;
}
// Run the executable
var info = this.CreateProcessInfo(result);
var processResult = this.TryToRun(info, result);
result.AddTaskResult(new ProcessTaskResult(processResult, false));
if (processResult.TimedOut)
{
result.AddTaskResult(MakeTimeoutBuildResult(info));
}
// Publish the results
if (this.PublishFiles) // && !processResult.Failed) - TODO: only publish files if successful
{
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "AntsPerformance");
this.PublishFile(string.IsNullOrEmpty(this.OutputFile) ? defaultOutput : this.OutputFile, publishDir);
this.PublishFile(this.SummaryCsvFile, publishDir);
this.PublishFile(this.SummaryXmlFile, publishDir);
this.PublishFile(this.SummaryHtmlFile, publishDir);
this.PublishFile(this.CallTreeXmlFile, publishDir);
this.PublishFile(this.CallTreeHtmlFile, publishDir);
this.PublishFile(this.DataFile, publishDir);
}
return processResult.Succeeded;
}
/// <summary>
/// Run the task.
/// </summary>
/// <param name="result"></param>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Running NCover reporting");
// Make sure there is a root directory
rootPath = BaseDirectory;
if (string.IsNullOrEmpty(rootPath)) rootPath = result.WorkingDirectory;
// Take a before snapshot of all the files
var outputDirectory = new DirectoryInfo(RootPath(OutputDir, false));
var oldFiles = GenerateOriginalFileList(outputDirectory);
// Run the executable
var processResult = TryToRun(CreateProcessInfo(result), result);
result.AddTaskResult(new ProcessTaskResult(processResult));
// Check for any new files and copy them to the artefact folder
if (!processResult.Failed)
{
outputDirectory.Refresh();
var newFiles = ListFileDifferences(oldFiles, outputDirectory);
if (newFiles.Length > 0)
{
// Copy all the new files over
var publishDir = Path.Combine(result.BaseFromArtifactsDirectory(result.Label), "NCover");
Log.Debug(string.Format("Copying {0} files to {1}", newFiles.Length, publishDir));
var index = outputDirectory.FullName.Length + 1;
foreach (FileInfo newFile in newFiles)
{
var fileInfo = new FileInfo(Path.Combine(publishDir, newFile.FullName.Substring(index)));
if (!fileInfo.Directory.Exists) fileInfo.Directory.Create();
newFile.CopyTo(fileInfo.FullName, true);
}
}
}
return !processResult.Failed;
}
/// <summary>
/// Execute the actual task functionality.
/// </summary>
/// <param name="result"></param>
/// <returns>
/// True if the task was successful, false otherwise.
/// </returns>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Publishing build results");
if (result.Succeeded || AlwaysPublish)
{
var srcDir = new DirectoryInfo(result.BaseFromWorkingDirectory(SourceDir));
var pubDir = new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir));
Log.Debug("Publish directory is '{0}'", pubDir.FullName);
Log.Debug("Source directory is '{0}'", srcDir.FullName);
if (!srcDir.Exists)
{
Log.Warning("Source directory '{0}' does not exist - cancelling task", srcDir.FullName);
var errorResult = new GeneralTaskResult(
false,
"Unable to find source directory '" + srcDir.FullName + "'");
result.AddTaskResult(errorResult);
return false;
}
if (!pubDir.Exists)
{
Log.Info("Publish directory '{0}' does not exist - creating", pubDir.FullName);
pubDir.Create();
}
else
{
if (CleanPublishDirPriorToCopy)
{
DeleteFolder(pubDir.FullName);
pubDir.Create();
}
}
if (UseLabelSubDirectory)
pubDir = pubDir.CreateSubdirectory(result.Label);
RecurseSubDirectories(srcDir, pubDir, this.Recurse);
switch (CleanUpMethod)
{
case CleanupPolicy.NoCleaning:
break;
case CleanupPolicy.DeleteBuildsOlderThanXDays:
DeleteSubDirsOlderThanXDays(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
case CleanupPolicy.KeepLastXBuilds:
KeepLastXSubDirs(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
default:
throw new System.Exception(string.Format(System.Globalization.CultureInfo.CurrentCulture, "unmapped cleaning method choosen {0}", CleanUpMethod));
}
}
return true;
}
/// <summary>
/// Execute the actual task functionality.
/// </summary>
/// <param name="result"></param>
/// <returns>
/// True if the task was successful, false otherwise.
/// </returns>
protected override bool Execute(IIntegrationResult result)
{
result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Publishing build results");
if (result.Succeeded || AlwaysPublish)
{
var srcDir = new DirectoryInfo(result.BaseFromWorkingDirectory(SourceDir));
var pubDir = new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir));
Log.Debug("Publish directory is '{0}'", pubDir.FullName);
Log.Debug("Source directory is '{0}'", srcDir.FullName);
if (!srcDir.Exists)
{
Log.Warning("Source directory '{0}' does not exist - cancelling task", srcDir.FullName);
var errorResult = new GeneralTaskResult(
false,
"Unable to find source directory '" + srcDir.FullName + "'");
result.AddTaskResult(errorResult);
return(false);
}
if (!pubDir.Exists)
{
Log.Info("Publish directory '{0}' does not exist - creating", pubDir.FullName);
pubDir.Create();
}
else
{
if (CleanPublishDirPriorToCopy)
{
DeleteFolder(pubDir.FullName);
pubDir.Create();
}
}
if (UseLabelSubDirectory)
{
pubDir = pubDir.CreateSubdirectory(result.Label);
}
RecurseSubDirectories(srcDir, pubDir);
switch (CleanUpMethod)
{
case CleanupPolicy.NoCleaning:
break;
case CleanupPolicy.DeleteBuildsOlderThanXDays:
DeleteSubDirsOlderThanXDays(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
case CleanupPolicy.KeepLastXBuilds:
KeepLastXSubDirs(new DirectoryInfo(result.BaseFromArtifactsDirectory(PublishDir)).FullName,
CleanUpValue, result.BuildLogDirectory);
break;
default:
throw new System.Exception(string.Format(System.Globalization.CultureInfo.CurrentCulture, "unmapped cleaning method choosen {0}", CleanUpMethod));
}
}
return(true);
}
/// <summary>
/// Add the package to the list of packages.
/// </summary>
/// <param name="result"></param>
/// <param name="listFile"></param>
/// <param name="fileName"></param>
/// <param name="numberOfFiles"></param>
/// <remarks>
/// This is to allow discoverability of packages. In future CruiseControl.Net will allow clients to download this
/// list to see which packages are available.
/// </remarks>
private void AddToPackageList(IIntegrationResult result, string listFile, string fileName, int numberOfFiles)
{
XmlDocument listXml = new XmlDocument();
// See if there is an existing list
listFile = result.BaseFromArtifactsDirectory(listFile);
if (File.Exists(listFile))
{
listXml.Load(listFile);
}
else
{
XmlElement rootElement = listXml.CreateElement("packages");
listXml.AppendChild(rootElement);
}
// See if the entry already exists
XmlElement packageElement = listXml.SelectSingleNode(
string.Format(CultureInfo.CurrentCulture, "/packages/package[@name='{0}']", PackageName)) as XmlElement;
if (packageElement == null)
{
packageElement = listXml.CreateElement("package");
listXml.DocumentElement.AppendChild(packageElement);
packageElement.SetAttribute("name", PackageName);
}
// Add the properties for the package
var packageFile = new FileInfo(fileName);
packageElement.SetAttribute("file", fileName);
packageElement.SetAttribute("label", result.Label);
packageElement.SetAttribute("time", DateTime.Now.ToString("s", CultureInfo.CurrentCulture));
packageElement.SetAttribute("files", numberOfFiles.ToString(CultureInfo.CurrentCulture));
packageElement.SetAttribute("size", packageFile.Length.ToString(CultureInfo.CurrentCulture));
// Save the updated list
var listDir = Path.GetDirectoryName(listFile);
if (!Directory.Exists(listDir))
{
Directory.CreateDirectory(listDir);
}
listXml.Save(listFile);
}
private string ModificationFile(IIntegrationResult result)
{
if (!AppendTimeStamp)
return Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename);
FileInfo fi = new FileInfo(Filename);
string dummy = Filename.Remove(Filename.Length - fi.Extension.Length, fi.Extension.Length);
string newFileName = string.Format(System.Globalization.CultureInfo.CurrentCulture,"{0}_{1}{2}", dummy, result.StartTime.ToString("yyyyMMddHHmmssfff", CultureInfo.CurrentCulture),
fi.Extension);
return Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), newFileName);
}