protected override void DoExecute(ITaskContext context)
{
string root = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
string dnx = Path.Combine(root, string.Format(CultureInfo.InvariantCulture, @".dnx\runtimes\{0}\bin", ClrVersionName));
IRunProgramTask t = CommonTasksFactory.CreateRunProgramTask(Path.Combine(dnx, "dnx.exe"))
.EncloseParametersInQuotes(false);
if (Timeout != null)
{
t.ExecutionTimeout(Timeout.Value);
}
if (!string.IsNullOrEmpty(WorkFolder))
{
t.SetWorkingDir(WorkFolder);
}
foreach (string s in Parameters)
{
t.AddArgument(s);
}
t.Execute(context);
}
protected override void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
{
var args = GetArguments();
if (string.IsNullOrEmpty(_projectName))
{
if (args.Count == 0 || args[0].StartsWith("-"))
{
var solustionFileName = context.Properties.Get <string>(BuildProps.SolutionFileName, null);
if (solustionFileName != null)
{
InsertArgument(0, solustionFileName);
}
}
}
else
{
InsertArgument(0, _projectName);
}
if (!args.Exists(x => x == "-c" || x == "--configuration"))
{
var configuration = context.Properties.Get <string>(BuildProps.BuildConfiguration, null);
if (configuration != null)
{
Configuration(configuration);
}
}
base.BeforeExecute(context, runProgramTask);
}
protected override void DoExecute(ITaskContext context)
{
string msbuildPath = FindMSBuildPath(context);
IRunProgramTask task = CommonTasksFactory.CreateRunProgramTask(msbuildPath);
task
.AddArgument(solutionFileName)
.AddArgument("/p:Configuration={0}", buildConfiguration)
.AddArgument("/p:Platform=Any CPU")
.AddArgument("/consoleloggerparameters:NoSummary")
.AddArgument("/maxcpucount:{0}", MaxCpuCount);
if (UseSolutionDirAsWorkingDir)
{
task.SetWorkingDir(Path.GetDirectoryName(solutionFileName));
}
if (Target != null)
{
task.AddArgument("/t:{0}", Target);
}
task.Execute(context);
}
protected override void DoExecute(ITaskContext context)
{
string msbuildPath = FindExecutableBuildPath(context);
IRunProgramTask task = CommonTasksFactory.CreateRunProgramTask(msbuildPath);
task.EncloseParametersInQuotes(false);
if (!string.IsNullOrEmpty(WorkFolder))
{
task.SetWorkingDir(WorkFolder);
}
if (!string.IsNullOrEmpty(SolutionFile))
{
task.AddArgument(SolutionFile);
}
if (Timeout != null)
{
task.ExecutionTimeout(Timeout.Value);
}
foreach (var p in Parameters)
{
task.AddArgument(p);
}
if (CpuCount > 0)
{
task.AddArgument("/maxcpucount:{0}", CpuCount);
}
task.Execute(context);
}
/// <inheritdoc />
protected override TResult DoExecute(ITaskContextInternal context)
{
if (string.IsNullOrEmpty(ExecutablePath))
{
throw new TaskExecutionException($"{nameof(ExecutablePath)} must be set.", 5);
}
_task = context.Tasks()
.RunProgramTask(ExecutablePath)
.DoNotLogTaskExecutionInfo()
.WorkingFolder(ExecuteWorkingFolder);
if (NoOutputLog)
{
_task.DoNotLogOutput();
}
if (DoNotLog)
{
_task.NoLog();
}
if (KeepProgramOutput)
{
_task.CaptureOutput();
}
if (KeepProgramErrorOutput)
{
_task.CaptureErrorOutput();
}
BeforeExecute(context, _task);
AddOrOverrideArgumentsFromConsole(context);
var argumentsFlat = ValidateAndGetArgumentsFlat();
foreach (var arg in argumentsFlat)
{
_task.WithArguments(arg.arg, arg.maskArg);
}
var result = _task
.ChangeDefaultAdditionalOptionPrefix(AdditionalOptionPrefix)
.AddPrefixToAdditionalOptionKey(_prefixToAdditionalOptionKeyFunc)
.ChangeAdditionalOptionKeyValueSeperator(_additionalOptionKeyValueSeperator)
.AddNewAdditionalOptionPrefix(_additionalOptionPrefixes)
.Execute(context);
if (typeof(TResult) == typeof(int))
{
return((TResult)(object)result);
}
return(default(TResult));
}
public void ResolveRunProgramTask()
{
IServiceCollection sc = new ServiceCollection();
sc.AddTransient <ICommandFactory, CommandFactory>();
IServiceProvider pr = sc.BuildServiceProvider();
IRunProgramTask instance = ActivatorUtilities.CreateInstance <RunProgramTask>(pr, "test");
Assert.IsType <RunProgramTask>(instance);
}
protected override void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
{
if (!GetArguments().Exists(x => x == "-c" || x == "--configuration"))
{
var configuration = context.Properties.Get <string>(BuildProps.BuildConfiguration, null);
if (configuration != null)
{
Configuration(configuration);
}
}
base.BeforeExecute(context, runProgramTask);
}
protected override int DoExecute(ITaskContextInternal context)
{
IRunProgramTask task = context
.Tasks()
.RunProgramTask("systemctl")
.WithArguments(_command, _service);
if (DoNotFail)
{
task.DoNotFailOnError();
}
return(task.Execute(context));
}
protected override void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
{
var args = GetArguments();
if (args.Count == 0 || args[0].StartsWith("-"))
{
var solustionFileName = context.Properties.Get <string>(BuildProps.SolutionFileName, null);
if (solustionFileName != null)
{
Project(solustionFileName);
}
}
base.BeforeExecute(context, runProgramTask);
}
protected override int DoExecute(ITaskContextInternal context)
{
string program = ExecutablePath;
if (string.IsNullOrEmpty(program))
{
program = context.Properties.GetDotnetExecutable();
}
if (string.IsNullOrEmpty(program))
{
context.Fail("Dotnet executable not set!", -1);
return(-1);
}
IRunProgramTask task = context.Tasks().RunProgramTask(program);
if (NoOutputLog)
{
task.DoNotLogOutput();
}
if (DoNotLog)
{
task.NoLog();
}
BeforeExecute(context);
var argumentsFlat = ValidateAndGetArgumentsFlat();
task
.WithArguments(Command);
foreach (var arg in argumentsFlat)
{
task.WithArguments(arg.arg, arg.maskArg);
}
task
.WorkingFolder(ExecuteWorkingFolder)
.CaptureErrorOutput()
.CaptureOutput()
.ExecuteVoid(context);
return(0);
}
protected override int DoExecute(ITaskContextInternal context)
{
string program = _dotnetExecutable;
if (string.IsNullOrEmpty(program))
{
program = context.Properties.GetDotnetExecutable();
}
if (string.IsNullOrEmpty(program))
{
context.Fail("Dotnet executable not set!", -1);
return(-1);
}
BeforeExecute(context);
IRunProgramTask task = context.Tasks().RunProgramTask(program);
if (_doNotLogOutput)
{
task.DoNotLogOutput();
}
if (DoNotLog)
{
task.NoLog();
}
task
.WithArguments(Command)
.WithArguments(Arguments.ToArray())
.WorkingFolder(_workingFolder)
.CaptureErrorOutput()
.CaptureOutput()
.ExecuteVoid(context);
return(0);
}
/// <inheritdoc />
protected override int DoExecute(ITaskContextInternal context)
{
PrepareExecutableParameters(context);
IRunProgramTask task = context.Tasks().RunProgramTask(ExecutablePath);
if (NoOutputLog)
{
task.DoNotLogOutput();
}
if (DoNotLog)
{
task.NoLog();
}
task
.CaptureErrorOutput()
.CaptureOutput()
.WorkingFolder(ExecuteWorkingFolder)
.WithArguments(_arguments.ToArray());
return(task.Execute(context));
}
protected override void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
{
runProgramTask.WithArguments(Command);
base.BeforeExecute(context, runProgramTask);
}
protected virtual void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
{
}
