C# IIntegrationResult.BaseFromArtifactsDirectory方法代码示例

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

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

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

        /// <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>
        /// 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;
        }

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

        /// <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 : "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;
        }

 private string ModificationFile(IIntegrationResult result)
 {
     return Path.Combine(result.BaseFromArtifactsDirectory(OutputPath), Filename);
 }

 /// <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;
 }