public async Task <string> Run(string imageName, Dictionary <string, string> environmentVariables = null, string command = null, CancellationToken cancellationToken = default(CancellationToken))
{
StringBuilder result = new StringBuilder();
StringBuilder error = new StringBuilder();
StringBuilder s = new StringBuilder();
foreach (var key in environmentVariables.Keys)
{
s.Append($" -e {key}={environmentVariables[key]} ");
}
ExecutionInput input = new ExecutionInput($"run --rm {s.ToString()} {imageName} {command}");
//input.StandardInput = s.ToString();
var handler = new BufferHandler(stdOutLine => result.Append(stdOutLine), stdErrLine => error.Append(stdErrLine));
//if (environmentVariables != null)
//{
// input.EnvironmentVariables = environmentVariables;
//}
ExecutionOutput output = await _cliDocker.ExecuteAsync(input, cancellationToken, handler);
if (output.ExitCode != 0)
{
throw new CliException("Could not run image", result.ToString(), error.ToString());
}
return(result.ToString());
}
public TestVerdict CheckTime(ExecutionOutput executionOutput, ExecutingOptions executingOptions)
{
TypeVerdicts verdict = TypeVerdicts.OK;
if (executionOutput.Time.TotalMilliseconds < executingOptions.TimeLimit.TotalMilliseconds)
{
verdict = TypeVerdicts.TimeLimit;
}
return(new TestVerdict(executionOutput.Memory, executionOutput.Time, executionOutput.ExitCode, verdict));
}
public TestVerdict CheckMemory(ExecutionOutput executionOutput, ExecutingOptions executingOptions)
{
TypeVerdicts verdict = TypeVerdicts.OK;
if (executionOutput.Memory.TotalKilobytes > executingOptions.MemoryLimit.TotalKilobytes)
{
verdict = TypeVerdicts.MemoryLimit;
}
return(new TestVerdict(executionOutput.Memory, executionOutput.Time, executionOutput.ExitCode, verdict));
}
public void ApplyOverrides(string[] args)
{
this.MinOthersPercent = DefaultMinOthersPercent;
string formatArgument = GetArgument(args, nameof(Format)).FirstOrDefault();
string referenceFormatArgument = GetArgument(args, nameof(ReferenceFormat)).FirstOrDefault();
string metaArgument = GetArgument(args, nameof(Meta)).FirstOrDefault();
string metaWeekArgument = GetArgument(args, nameof(MetaWeek)).FirstOrDefault();
string[] filterArgument = GetArgument(args, nameof(Filter));
string[] excludeArgument = GetArgument(args, nameof(Exclude));
string archetypeArgument = GetArgument(args, nameof(Archetype)).FirstOrDefault();
string[] cardArgument = GetArgument(args, nameof(Card));
string[] excludeCardArgument = GetArgument(args, nameof(ExcludeCard));
string breakdownArgument = GetArgument(args, nameof(MetaBreakdown)).FirstOrDefault();
string breakdownCountArgument = GetArgument(args, nameof(MetaBreakdownShowCount)).FirstOrDefault();
string decklistsArgument = GetArgument(args, nameof(IncludeDecklists)).FirstOrDefault();
string[] cacheFoldersArgument = GetArgument(args, nameof(TournamentFolder));
string dataFolderArgument = GetArgument(args, nameof(FormatDataFolder)).FirstOrDefault();
string outputFileArgument = GetArgument(args, nameof(OutputFile)).FirstOrDefault();
string maxDecksPerEventArgument = GetArgument(args, nameof(MaxDecksPerEvent)).FirstOrDefault();
string minOthersPercentArgument = GetArgument(args, nameof(MinOthersPercent)).FirstOrDefault();
if (formatArgument != null)
{
this.Format = formatArgument;
}
if (referenceFormatArgument != null)
{
this.ReferenceFormat = referenceFormatArgument;
}
if (metaArgument != null)
{
this.Meta = metaArgument;
}
if (metaWeekArgument != null)
{
this.MetaWeek = metaWeekArgument;
}
if (filterArgument.Length > 0)
{
this.Filter = filterArgument;
}
if (excludeArgument.Length > 0)
{
this.Exclude = excludeArgument;
}
if (archetypeArgument != null)
{
this.Archetype = archetypeArgument;
}
if (cardArgument.Length > 0)
{
this.Card = cardArgument;
}
if (excludeArgument.Length > 0)
{
this.ExcludeCard = excludeCardArgument;
}
if (breakdownArgument != null)
{
this.MetaBreakdown = (breakdownArgument.ToLowerInvariant() == "true");
}
if (breakdownCountArgument != null)
{
this.MetaBreakdownShowCount = (breakdownCountArgument.ToLowerInvariant() == "true");
}
if (decklistsArgument != null)
{
this.IncludeDecklists = (decklistsArgument.ToLowerInvariant() == "true");
}
if (cacheFoldersArgument.Length > 0)
{
this.TournamentFolder = cacheFoldersArgument;
}
if (dataFolderArgument != null)
{
this.FormatDataFolder = dataFolderArgument;
}
if (outputFileArgument != null)
{
this.OutputFile = outputFileArgument;
}
if (maxDecksPerEventArgument != null && Int32.TryParse(maxDecksPerEventArgument, out int parsedMaxDecks))
{
this.MaxDecksPerEvent = parsedMaxDecks;
}
if (minOthersPercentArgument != null && float.TryParse(minOthersPercentArgument, NumberStyles.Any, CultureInfo.InvariantCulture, out float parsedMinOthers))
{
this.MinOthersPercent = parsedMinOthers;
}
ExecutionAction actionArgument = ExecutionAction.NotSpecified;
if (args.Length > 1)
{
Enum.TryParse <ExecutionAction>(args[1], true, out actionArgument);
}
if (actionArgument != ExecutionAction.NotSpecified)
{
this.Action = actionArgument;
}
ExecutionOutput outputArgument = ExecutionOutput.NotSpecified;
if (args.Length > 0)
{
Enum.TryParse <ExecutionOutput>(args[0], true, out outputArgument);
}
if (outputArgument != ExecutionOutput.NotSpecified)
{
this.Output = outputArgument;
}
}
