public override void GetSource(IIntegrationResult result)
        {
            if (!_shim.AutoGetSource) return;
            Debug.Assert(_folderVersion > 0, "_folderVersion <= 0 when attempting to get source.  This shouldn't happen.");

            if (_shim.CleanCopy)
            {
                string cleanCopyWorkingFolder = null;
                if (StringUtil.IsBlank(_shim.WorkingDirectory))
                {
                    cleanCopyWorkingFolder = GetVaultWorkingFolder(result);
                    if (StringUtil.IsBlank(cleanCopyWorkingFolder))
                        throw new VaultException(
                            string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                          _shim.Username, _shim.Folder, _shim.Repository));
                }
                else
                    cleanCopyWorkingFolder = result.BaseFromWorkingDirectory(_shim.WorkingDirectory);

                Log.Debug("Cleaning out source folder: " + cleanCopyWorkingFolder);
                new IoService().EmptyDirectoryIncludingReadOnlyObjects(cleanCopyWorkingFolder);
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result));
        }

 public override void GetSource(IIntegrationResult result)
 {
     if (AutoGetSource && !UseHistory)
     {
         UpdateSource(result, null);
     }
 }

 public void GetSource(IIntegrationResult result)
 {
     if (FailGetSource)
     {
         throw new System.Exception("Failing getting the source");
     }
 }

        public void Setup()
        {
            this.mocks = new MockRepository();

            mockery = new Mockery();
            targetMock = mockery.NewDynamicMock(typeof(IIntegrationRunnerTarget));
            resultManagerMock = mockery.NewDynamicMock(typeof(IIntegrationResultManager));
            quietPeriodMock = mockery.NewDynamicMock(typeof(IQuietPeriod));

            runner = new IntegrationRunner((IIntegrationResultManager)resultManagerMock.MockInstance,
                                           (IIntegrationRunnerTarget)targetMock.MockInstance,
                                           (IQuietPeriod)quietPeriodMock.MockInstance);


            request = ModificationExistRequest();
            endTime = new DateTime(2005, 2, 1);
            modifications = new Modification[] { new Modification() };

            resultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
            resultMock.SetupResult("WorkingDirectory", TempFileUtil.GetTempPath("workingDir"));
            resultMock.SetupResult("ArtifactDirectory", TempFileUtil.GetTempPath("artifactDir"));
            resultMock.SetupResult("BuildProgressInformation", new ThoughtWorks.CruiseControl.Core.Util.BuildProgressInformation("",string.Empty));
            resultMock.SetupResult("IntegrationProperties", new Dictionary<string, string>());
            result = (IIntegrationResult)resultMock.MockInstance;

            lastResultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
            lastResult = (IIntegrationResult)lastResultMock.MockInstance;
        }

 public void Run(IIntegrationResult result)
 {
     foreach (string mergeFile in MergeFiles)
     {
         string fullMergeFile = mergeFile;
         if (!Path.IsPathRooted(mergeFile))
         {
             fullMergeFile = Path.Combine(result.WorkingDirectory, mergeFile);
         }
         WildCardPath path = new WildCardPath(fullMergeFile);
         FileInfo[] files = path.GetFiles();
         foreach (FileInfo fileInfo in files)
         {
             Log.Info("Merging file: " + fileInfo);
             if (fileInfo.Exists)
             {
                 result.AddTaskResult((new FileTaskResult(fileInfo)));
             }
             else
             {
                 Log.Warning("File not Found: " + fileInfo);
             }
         }
     }
 }

 public void Run(IIntegrationResult result)
 {
     XmlSerializer serializer = new XmlSerializer(typeof (Modification[]));
     StringWriter writer = new Utf8StringWriter();
     serializer.Serialize(writer, result.Modifications);
     fileSystem.Save(ModificationFile(result), writer.ToString());
 }

 public void LabelSourceControl(IIntegrationResult result)
 {
     var fileName = Path.Combine(
         Path.GetDirectoryName(this.FileName),
         DateTime.Now.ToString("yyyyMMddHHmmss") + ".label");
     File.WriteAllText(fileName, result.Label);
 }

 public void LabelSourceControl(IIntegrationResult result)
 {
     foreach (ISourceControl sourceControl in SourceControls)
     {
         sourceControl.LabelSourceControl(result);
     }
 }

 public void GetSource(IIntegrationResult result)
 {
     foreach (ISourceControl sourceControl in SourceControls)
     {
         sourceControl.GetSource(result);
     }
 }

        public override void GetSource(IIntegrationResult result)
        {
            if (!_shim.AutoGetSource) return;

            _labelApplied = false;

            if (StringUtil.IsBlank(_shim.WorkingDirectory) && !(!_shim.ApplyLabel && _shim.UseVaultWorkingDirectory && !_shim.CleanCopy))
            {
                _shim.WorkingDirectory = GetVaultWorkingFolder(result);
                if (StringUtil.IsBlank(_shim.WorkingDirectory))
                    throw new VaultException(
                        string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                      _shim.Username, _shim.Folder, _shim.Repository));
            }

            if (_shim.ApplyLabel)
            {
                Log.Info(string.Format("Applying label \"{0}\" to {1} in repository {2}.", result.Label, _shim.Folder, _shim.Repository));
                Execute(LabelProcessInfo(result));
                _labelApplied = true;
            }

            if (_shim.CleanCopy && !StringUtil.IsBlank(this._shim.WorkingDirectory))
            {
                Log.Debug("Cleaning out source folder: " + result.BaseFromWorkingDirectory(_shim.WorkingDirectory));
                new IoService().EmptyDirectoryIncludingReadOnlyObjects(result.BaseFromWorkingDirectory(_shim.WorkingDirectory));
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result, _shim.ApplyLabel));
        }

 public override void GetSource(IIntegrationResult result)
 {
     if (!AutoGetSource) return;
     git_clean(result);
     if (git_log_local_hash(result) != null) git_reset(result);
     git_merge(result);
 }

 /// <summary>
 ///     Appends a text string to the task_description attribute to each task in
 ///     the current selection set.
 /// </summary>
 /// <param name="connection">CM Synergy connection parameters.</param>
 /// <param name="project">Properties of the integration testing project.</param>
 /// <param name="result">The change set for the current integration run</param>
 /// <returns>A non-null initialized process structure.</returns>
 public static ProcessInfo AddLabelToTaskComment(SynergyConnectionInfo connection, SynergyProjectInfo project, IIntegrationResult result)
 {
     const string template = @"task /modify /description ""Integrated Successfully with CruiseControl.NET project '{0}' build '{1}' on {2}"" ""{3}""";
     string tasks = GetTaskList(result.Modifications);
     string arguments = String.Format(template, result.ProjectName, result.Label, result.StartTime, tasks);
     return CreateProcessInfo(connection, arguments);
 }

        public void Run(IIntegrationResult result)
        {
            if (IntegrationStatus != result.Status) return;

            ICruiseManager manager = (ICruiseManager) remotingService.Connect(typeof(ICruiseManager), ServerUri);
            manager.ForceBuild(Project);
        }

 public override Modification[] GetModifications(IIntegrationResult from, IIntegrationResult to)
 {
     _labelApplied = false;
     Log.Info(string.Format("Checking for modifications to {0} in Vault Repository \"{1}\" between {2} and {3}", _shim.Folder, _shim.Repository, from.StartTime, to.StartTime));
     ProcessResult result = ExecuteWithRetries(ForHistoryProcessInfo(from, to));
     return ParseModifications(result, from.StartTime, to.StartTime);
 }

        public override void GetSource(IIntegrationResult result)
        {
            result.BuildProgressInformation.SignalStartRunTask("Getting source from Vault");

            if (!_shim.AutoGetSource) return;
            if (_folderVersion <= 0)
            {
                throw new CruiseControlException("_folderVersion <= 0 when attempting to get source.  This shouldn't happen.");
            }

            if (_shim.CleanCopy)
            {
                string cleanCopyWorkingFolder = null;
                if (string.IsNullOrEmpty(_shim.WorkingDirectory))
                {
                    cleanCopyWorkingFolder = GetVaultWorkingFolder(result);
                    if (string.IsNullOrEmpty(cleanCopyWorkingFolder))
                        throw new VaultException(
                            string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                          _shim.Username, _shim.Folder, _shim.Repository));
                }
                else
                    cleanCopyWorkingFolder = result.BaseFromWorkingDirectory(_shim.WorkingDirectory);

                Log.Debug("Cleaning out source folder: " + cleanCopyWorkingFolder);
                fileDirectoryDeleter.DeleteIncludingReadOnlyObjects(cleanCopyWorkingFolder);
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result));
        }

 /// <summary>
 /// Convert the build results into XML.
 /// </summary>
 /// <param name="result">The build results.</param>
 /// <returns>The XML results.</returns>
 private static string ToXml(IIntegrationResult result)
 {
     StringWriter xmlResultString = new StringWriter();
     XmlIntegrationResultWriter writer = new XmlIntegrationResultWriter(xmlResultString);
     writer.Write(result);
     return xmlResultString.ToString();
 }

        internal static VersionInformation BuildVersion(string gitRevision, int gitCheckinCount, int major, int minor, IIntegrationResult resultFromLastBuild, bool incrementOnFailure)
        {
            var result = new VersionInformation();
            var hashes = gitRevision.Split('\n');
            result.GitCommitHash = hashes[0].Trim();
            result.GitParentHash = hashes[1].Trim();
            result.GitTreeHash = hashes[2].Trim();
            result.GitCheckinCount = gitCheckinCount;

            // major.minor.revision.rebuild
            const string format = "{0}.{1}.{2}.{3}";

            var rebuildNumber = 1;
            var previousVersion = resultFromLastBuild.LastSuccessfulIntegrationLabel;
            var parts = previousVersion.Split('.');

            int previousRebuildNumber = 0;
            int previousRevision = 0;
            if (parts.Length == 4)
            {
                int.TryParse(parts[3], out previousRebuildNumber);
                int.TryParse(parts[2], out previousRevision);
            }

            if (((resultFromLastBuild.LastIntegrationStatus == IntegrationStatus.Success) || incrementOnFailure) && (gitCheckinCount == previousRevision))
            {
                rebuildNumber = previousRebuildNumber + 1;
            }

            result.BuildCycleNumber = rebuildNumber;
            var assemblySafeLabel = string.Format(format, major, minor, gitCheckinCount, rebuildNumber);
            result.AssemblySafeLabel = assemblySafeLabel;

            return result;
        }

        /// <summary>
        /// Generates parameter values from the incoming request values.
        /// </summary>
        /// <param name="result">The result.</param>
        public void GenerateSystemParameterValues(IIntegrationResult result)
        {
            var props = result.IntegrationProperties;
            foreach (var property in props.Keys)
            {
                // Generate the build value
                var key = string.Format("${0}", property);
                var value = (props[property] ?? string.Empty).ToString();
                result.IntegrationRequest.BuildValues[key] = value;

                // Add to the parameters
                var namedValue = new NameValuePair(key, value);
                if (result.Parameters.Contains(namedValue))
                {
                    // Replace an existing value
                    var index = result.Parameters.IndexOf(namedValue);
                    result.Parameters[index] = namedValue;
                }
                else
                {
                    // Add a new value
                    result.Parameters.Add(namedValue);
                }
            }
        }

        public void Run(IIntegrationResult result)
        {
            if (IntegrationStatus != result.Status && !IgnoreIntegrationStatus) return;

            if (IgnoreIntegrationStatus && result.Status == IntegrationStatus.Cancelled) return;

            result.BuildProgressInformation.SignalStartRunTask("Running for build publisher");

            var logger = Logger ?? new DefaultLogger();
            var loggedIn = false;
            logger.Debug("Generating client for url '{0}'", ServerUri);
            var client = factory.GenerateClient(ServerUri);
            if ((SecurityCredentials != null) && (SecurityCredentials.Length > 0))
            {
                logger.Debug("Logging in");
                client.Login(new List<NameValuePair>(SecurityCredentials));
                loggedIn = true;
            }

            ProjectIntegratorState remoteProjectStatus = ProjectIntegratorState.Unknown;

            foreach (var projectStatus in client.GetProjectStatus())
                if (projectStatus.Name == Project) remoteProjectStatus = projectStatus.Status;

            if (remoteProjectStatus != ProjectIntegratorState.Running) return;

            logger.Info("Sending ForceBuild request to '{0}' on '{1}'", Project, ServerUri);
            client.ForceBuild(Project, new List<NameValuePair>(Parameters ?? new NameValuePair[0]));
            if (loggedIn)
            {
                logger.Debug("Logging out");
                client.Logout();
            }
        }

        public bool ShouldRunBuild(IIntegrationResult result)
        {
            this.Result = result;
            bool IsRunnable;

            if (result.BuildCondition != BuildCondition.ForceBuild)
            {
                IsRunnable = this.CheckIfRunnable(this.Triggered);
                if (!IsRunnable)
                {
                    Log.Info("Trigger blocked by integration filter.");
                    return false;
                }
            }

            if (result.BuildCondition == BuildCondition.ForceBuild)
            {
                IsRunnable = this.CheckIfRunnable(this.Forced);
                if (!IsRunnable)
                {
                    Log.Info("Force blocked by integration filter.");
                    return false;
                }
            }

            return true;
        }