/// <summary>
/// Appends the arguments required to authenticate against Subversion.
/// </summary>
/// <param name="buffer">The argument builder.</param>
protected virtual void AppendCommonSwitches(ProcessArgumentBuilder buffer)
{
buffer.AddArgument("--username", Username);
buffer.AddArgument("--password", Password);
buffer.AddArgument("--non-interactive");
buffer.AddArgument("--no-auth-cache");
}
/// <summary>
/// Gets the process arguments.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
/// <remarks></remarks>
protected override string GetProcessArguments(IIntegrationResult result)
{
ProcessArgumentBuilder b = new ProcessArgumentBuilder();
b.AddArgument("/nologo");
if (!string.IsNullOrEmpty(Targets))
{
b.AddArgument("/t:");
string targets = string.Empty;
foreach (string target in Targets.Split(';'))
{
if (!(targets != null && targets.Length == 0))
{
targets = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0};{1}", targets, StringUtil.AutoDoubleQuoteString(target));
}
else
{
targets = StringUtil.AutoDoubleQuoteString(target);
}
}
b.Append(targets);
}
b.AppendArgument(GetPropertyArgs(result));
b.AppendArgument(BuildArgs);
b.AddArgument(ProjectFile);
b.AppendArgument(GetLoggerArgs(result));
return(b.ToString());
}
/// <summary>
/// Gets the branch head for the current branch or the tip if no branch is configured.
/// </summary>
/// <param name="result">The integration result.</param>
/// <returns>The process result.</returns>
/// <remarks>Uses the output template to render the process output as XML.</remarks>
private ProcessResult HgTip(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("log");
if (!string.IsNullOrEmpty(Branch))
{
buffer.AddArgument("-b", Branch);
buffer.AddArgument("-r", Branch);
}
else
{
buffer.AddArgument("-r", "tip");
}
buffer.AddArgument("--template", "{rev}");
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessResult processResult = Execute(NewProcessInfo(buffer.ToString(), result));
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
private void RemoveReadOnlyAttribute()
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("-R");
buffer.AddArgument("/s", System.IO.Path.Combine(SandboxRoot, "*"));
Execute(new ProcessInfo("attrib", buffer.ToString()));
}
private ProcessInfo VersionHistoryProcessInfo(IIntegrationResult from, IIntegrationResult to, bool bForceGetLatestVersion)
{
ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
builder.AddArgument("versionhistory", _shim.Folder);
// Look only for changes, unless caller asked us to get the latest folder
// version regardless of whether there's been a change.
if (!bForceGetLatestVersion)
{
// use folderVersion when possible because it's faster and more accurate
if (_folderVersion != 0)
{
builder.AddArgument("-beginversion", (_folderVersion + 1).ToString());
}
else
{
builder.AddArgument("-begindate", from.StartTime.ToString("s"));
builder.AddArgument("-enddate", to.StartTime.ToString("s"));
}
}
// we only ever need the most recent change
builder.AddArgument("-rowlimit", "1");
AddCommonOptionalArguments(builder);
return(ProcessInfoFor(builder.ToString(), from));
}
/// <summary>
/// Get the list of changesets within a range of revisions (from, to).
/// </summary>
/// <param name="to">The integration result.</param>
/// <param name="fromId">The start of the range of revisions</param>
/// <param name="toId">The end of the range of revisions.</param>
/// <returns>The process result.</returns>
/// <remarks>Uses the output template to render the process output as XML.</remarks>
private ProcessResult HgLog(IIntegrationResult to, int fromId, int toId)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("log");
if (!string.IsNullOrEmpty(Branch))
{
buffer.AddArgument("-b", Branch);
}
buffer.AddArgument("-r", string.Format("{0}:{1}", fromId, toId));
buffer.AddArgument("--style", "xml");
buffer.AddArgument("-v");
var bpi = GetBuildProgressInformation(to);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessResult processResult = Execute(NewProcessInfo(buffer.ToString(), to));
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
/// <summary>
/// Commits modifications that have been made during the integration and if configured also newly created files to the local repository.
/// </summary>
/// <param name="addRemove">Bool to indicate if the add-remove option should be used.</param>
/// <param name="commitMessage">The commit message to be used.</param>
/// <param name="result">The integration result.</param>
/// <returns>The process result.</returns>
/// <remarks>Optionally uses the add-remove flag (-A) to allow to commit untracked files and file deletions.</remarks>
private ProcessResult HgCommit(bool addRemove, string commitMessage, IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("commit");
if (addRemove)
{
buffer.AddArgument("-A");
}
if (!string.IsNullOrEmpty(CommitterName))
{
buffer.AddArgument("-u", CommitterName);
}
buffer.AddArgument("-m", commitMessage);
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessResult processResult = Execute(NewProcessInfo(buffer.ToString(), result, ProcessPriorityClass.Normal, new int[] { 0, 1 }));
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
public override string ToString()
{
ProcessArgumentBuilder processArgumentBuilder = new ProcessArgumentBuilder();
string[] strArrays = this.assemblies;
for (int i = 0; i < (int)strArrays.Length; i++)
{
processArgumentBuilder.AddArgument(strArrays[i]);
}
if (!string.IsNullOrEmpty(outputfile))
{
processArgumentBuilder.AddArgument("--output", "=", outputfile);
}
this.AppendCategoriesArg(processArgumentBuilder);
if (Options != null)
{
foreach (var kv in Options)
{
if (string.IsNullOrEmpty(kv.Value))
{
processArgumentBuilder.AddArgument("--" + kv.Key);
}
else
{
processArgumentBuilder.AddArgument("--" + kv.Key, "=", kv.Value);
}
}
}
Log.Info("ProcessArgumentBuilder : " + processArgumentBuilder.ToString());
return(processArgumentBuilder.ToString());
}
/// <summary>
/// Pushes the committed changesets and created tags to the configured remote repository.
/// </summary>
/// <param name="result">The integration result.</param>
/// <returns>The process result.</returns>
/// <remarks>Uses the force flag (-f) to push even if new remote heads are created.</remarks>
private ProcessResult HgPush(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("push");
if (!string.IsNullOrEmpty(Branch))
{
buffer.AddArgument("-b", Branch);
}
buffer.AddArgument("-f");
buffer.AddArgument(Repository);
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessResult processResult = Execute(NewProcessInfo(buffer.ToString(), result));
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
/// <summary>
/// Creates a named tag (label) for the currently used revision in the local repository.
/// </summary>
/// <param name="tagName">The name of the tag.</param>
/// <param name="tagMessage">The log message to be used.</param>
/// <param name="result">The integration result.</param>
/// <returns>The process result.</returns>
/// <remarks>Uses the force flag (-f) to even create the tag if a tag with the same name already exists.</remarks>
private ProcessResult HgTag(string tagName, string tagMessage, IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("tag");
buffer.AddArgument("-m", tagMessage);
if (!string.IsNullOrEmpty(CommitterName))
{
buffer.AddArgument("-u", CommitterName);
}
buffer.AddArgument("-f");
buffer.AddArgument(tagName);
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessResult processResult = Execute(NewProcessInfo(buffer.ToString(), result));
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
/// <summary>
/// Clone a repository into a new directory with "git clone 'repository' 'working directory'".
/// </summary>
/// <param name="result">IIntegrationResult of the current build.</param>
private void GitClone(IIntegrationResult result)
{
string wd = BaseWorkingDirectory(result);
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("clone");
buffer.AddArgument(Repository);
buffer.AddArgument(wd);
// initialize progress information
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("git ", buffer.ToString()));
// enable Stdout monitoring
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessInfo pi = NewProcessInfo(buffer.ToString(), result);
// Use upper level of the working directory, because the
// working directory currently does not exist and
// will be created by "git clone". "git clone" will fail if
// the working directory already exist.
pi.WorkingDirectory = Path.GetDirectoryName(wd.Trim().TrimEnd(Path.DirectorySeparatorChar));
Execute(pi);
// remove Stdout monitoring
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
}
// cvs [-d :ext:mycvsserver:/cvsroot/myrepo] -q log -N "-d>2004-12-24 12:00:00 GMT" -rmy_branch (with branch)
// cvs [-d :ext:mycvsserver:/cvsroot/myrepo] -q log -Nb "-d>2004-12-24 12:00:00 GMT" (without branch)
// public const string HISTORY_COMMAND_FORMAT = @"{0}-q log -N{3} ""-d>{1}""{2}"; // -N means 'do not show tags'
private string BuildLogProcessInfoArgs(DateTime from)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
AppendCvsRoot(buffer);
buffer.AddArgument("-q"); // quiet
buffer.AddArgument("rlog");
buffer.AddArgument("-N"); // do not show tags
buffer.AppendIf(SuppressRevisionHeader, "-S");
if (string.IsNullOrEmpty(Branch))
{
buffer.AddArgument("-b"); // only list revisions on HEAD
}
else
{
buffer.AppendArgument("-r{0}", Branch); // list revisions on branch
}
buffer.AppendArgument(@"""-d>{0}""", FormatCommandDate(from));
if (!string.IsNullOrEmpty(RestrictLogins))
{
foreach (string login in RestrictLogins.Split(','))
{
buffer.AppendArgument("-w{0}", login.Trim());
}
}
buffer.AddArgument(Module);
return(buffer.ToString());
}
/// <summary>
/// Gets the process arguments.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
/// <remarks></remarks>
protected override string GetProcessArguments(IIntegrationResult result)
{
ProcessArgumentBuilder args = new ProcessArgumentBuilder();
args.AddArgument("--rakefile", Rakefile);
if (Silent)
{
args.AddArgument("--silent");
}
else if (Quiet)
{
args.AddArgument("--quiet");
}
if (Trace)
{
args.AddArgument("--trace");
}
args.AppendArgument(BuildArgs);
foreach (string t in Targets)
{
args.AppendArgument(t);
}
return(args.ToString());
}
/// <summary>
/// Initialize the working directory with the hg init command
/// </summary>
/// <param name="result">The integration result.</param>
/// <returns>The process result.</returns>
/// <remarks>Uses the file system to ensure the working directory exists before calling hg init.</remarks>
private ProcessResult HgInit(IIntegrationResult result)
{
string wd = BaseWorkingDirectory(result);
_fileSystem.EnsureFolderExists(wd);
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("init");
buffer.AddArgument(wd);
var bpi = GetBuildProgressInformation(result);
bpi.SignalStartRunTask(string.Concat("hg ", buffer.ToString()));
ProcessExecutor.ProcessOutput += ProcessExecutor_ProcessOutput;
ProcessInfo pi = NewProcessInfo(buffer.ToString(), result);
pi.WorkingDirectory = Path.GetDirectoryName(wd.Trim().TrimEnd(Path.DirectorySeparatorChar));
ProcessResult processResult = Execute(pi);
ProcessExecutor.ProcessOutput -= ProcessExecutor_ProcessOutput;
return(processResult);
}
private ProcessInfo GetSourceProcessInfo(IIntegrationResult result, bool getByLabel)
{
ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
if (getByLabel)
{
builder.AddArgument("getlabel", Folder);
builder.AddArgument(result.Label);
}
else
{
builder.AddArgument("get", Folder);
}
if (UseVaultWorkingDirectory)
{
builder.AppendArgument("-merge overwrite -performdeletions removeworkingcopy");
}
else
{
builder.AddArgument("-destpath", result.BaseFromWorkingDirectory(WorkingDirectory));
builder.AppendArgument("-merge overwrite");
}
builder.AppendArgument("-setfiletime checkin -makewritable");
AddCommonOptionalArguments(builder);
return(ProcessInfoFor(builder.ToString(), result));
}
private void AddCommonOptionalArguments(ProcessArgumentBuilder builder)
{
builder.AddArgument("-host", Host);
builder.AddArgument("-user", Username);
builder.AddArgument("-password", Password);
builder.AddArgument("-repository", Repository);
builder.AppendIf(Ssl, "-ssl");
}
private void git_push_tags(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("push");
buffer.AddArgument("--tags");
Execute(NewProcessInfo(buffer.ToString(), BaseWorkingDirectory(result)));
}
private void git_merge(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("merge");
buffer.AddArgument(string.Format("origin/{0}", Branch));
Execute(NewProcessInfo(buffer.ToString(), BaseWorkingDirectory(result)));
}
private void RemoveReadOnlyAttribute()
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("-R");
buffer.AddArgument("/s", SandboxRoot + "\\*");
Execute(new ProcessInfo("attrib", buffer.ToString()));
}
/// <summary>
/// Add all modified and all untracked files that are not ignored by .gitignore
/// to the git index with the "git add --all" command.
/// </summary>
/// <param name="result">IIntegrationResult of the current build.</param>
private void GitAddAll(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("add");
buffer.AddArgument("--all");
Execute(NewProcessInfo(buffer.ToString(), result));
}
/// <summary>
/// Initialize the git submodules.
/// </summary>
/// <param name="result">IIntegrationResult of the current build.</param>
private void GitInitSubmodules(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("submodule");
buffer.AddArgument("init");
Execute(NewProcessInfo(buffer.ToString(), result));
}
private void git_clone(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("clone");
buffer.AddArgument(Repository);
buffer.AddArgument(BaseWorkingDirectory(result));
Execute(NewProcessInfo(buffer.ToString(), BaseWorkingDirectory(result)));
}
/// <summary>
/// Call "git config 'name' 'value'" to set local repository properties.
/// </summary>
/// <param name="name">Name of the config parameter.</param>
/// <param name="value">Value of the config parameter.</param>
/// <param name="result">IIntegrationResult of the current build.</param>
private void GitConfigSet(string name, string value, IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("config");
buffer.AddArgument(name);
buffer.AddArgument(value);
Execute(NewProcessInfo(buffer.ToString(), result));
}
private ProcessResult GitLogHistory(string branchNameOrRevision, IIntegrationResult to)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("log");
buffer.AddArgument(branchNameOrRevision);
AppendLogOptions(buffer);
return(Execute(NewProcessInfo(buffer.ToString(), to)));
}
private void git_config(string name, string value, IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("config");
buffer.AddArgument(name);
buffer.AddArgument(value);
Execute(NewProcessInfo(buffer.ToString(), BaseWorkingDirectory(result)));
}
private void git_reset(IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("reset");
buffer.AddArgument("HEAD");
buffer.AddArgument("--hard");
Execute(NewProcessInfo(buffer.ToString(), BaseWorkingDirectory(result)));
}
/// <summary>
/// Get the commit history including changes between <paramref name="from"/> and origin/<paramref name="branchName"/>
/// </summary>
/// <param name="branchName">Name of the branch.</param>
/// <param name="from">The commit from which to start logging.</param>
/// <param name="to">IIntegrationResult of the current build.</param>
/// <returns>Result of the "git log" command.</returns>
private ProcessResult GitLogHistory(string branchName, string from, IIntegrationResult to)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("log");
buffer.AddArgument(string.Concat(from, "..origin/", branchName));
AppendLogOptions(buffer);
return(Execute(NewProcessInfo(buffer.ToString(), to)));
}
private void AddStandardArguments(
ProcessArgumentBuilder builder,
string destinationDirectory)
{
builder.AddArgument(RepositoryRoot);
builder.AddArgument(destinationDirectory);
builder.Append(standardArguments);
builder.Append(AdditionalArguments);
}
private ProcessInfo RemoveLabelProcessInfo(IIntegrationResult result)
{
ProcessArgumentBuilder builder = new ProcessArgumentBuilder();
builder.AddArgument("deletelabel", _shim.Folder);
builder.AddArgument(result.Label);
AddCommonOptionalArguments(builder);
return(ProcessInfoFor(builder.ToString(), result));
}
/// <summary>
/// Create a unsigned tag with "git tag -a -m 'message' 'tag name'".
/// </summary>
/// <param name="tagName">Name of the tag.</param>
/// <param name="tagMessage">Tag commit message.</param>
/// <param name="result">IIntegrationResult of the current build.</param>
private void GitCreateTag(string tagName, string tagMessage, IIntegrationResult result)
{
ProcessArgumentBuilder buffer = new ProcessArgumentBuilder();
buffer.AddArgument("tag");
buffer.AddArgument("-a");
buffer.AddArgument("-m", tagMessage);
buffer.AddArgument(tagName);
Execute(NewProcessInfo(buffer.ToString(), result));
}
public void Test_With_Single_Argument(Type escapeHandlerType, string sigil)
{
// Arrange
var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler;
var builder = new ProcessArgumentBuilder(escapeHandler);
builder.AddArgument("somefile.txt");
// Act
var result = builder.Build();
// Assert
Assert.Equal("somefile.txt", result);
}
public void Test_That_Argument_Starting_With_Sigil_Is_Quoted(Type escapeHandlerType, string sigil)
{
// Arrange
var escapeHandler = Activator.CreateInstance(escapeHandlerType, new object[] { sigil }) as IArgumentEscapeHandler;
var builder = new ProcessArgumentBuilder(escapeHandler);
builder.AddArgument($"{sigil}test");
// Act
var result = builder.Build();
// Assert
Assert.Equal($"\"{sigil}test\"", result);
}
