static void Main(string[] args)
{
Arguments = new Arguments(args);
if (Arguments.ShowHelp || !Arguments.IsValid)
{
ShowHelp(!Arguments.ShowHelp && !Arguments.IsValid);
return;
}
DockerCommands = new DockerCommands(Arguments.Registry, Arguments.Username, Arguments.Password, Arguments.Image, Arguments.Container, Arguments.Expose);
using var cli = new CommandLine(Arguments.Shell, ProcessOutput);
using var scheduler = new TaskScheduler(Arguments.Interval, (object obj) =>
{
Console.WriteLine($"Trying to schedule new task. Next execution at {DateTime.Now.AddSeconds(Arguments.Interval)}");
if (!cli.IsBusy)
{
cli.Command(DockerCommands.Login, DockerCommands.PullImage).Process();
}
});
while (true)
{
Console.WriteLine("Idle...");
Thread.Sleep(Defaults.IdleTime * 1000);
}
}
public async Task <BufferedCommandResult> StartAsync()
{
string command = DockerCommands.Run(this);
Console.WriteLine(command);
BufferedCommandResult result = await Cli.Wrap(ContainerConfiguration.DefaultShell)
.WithArguments(command)
.ExecuteBufferedAsync();
return(result);
}
public static async Task <BufferedCommandResult> Stop(List <string> containerNames)
{
string containers = String.Join(" ", containerNames);
string command = DockerCommands.Stop(containers);
Console.WriteLine(command);
BufferedCommandResult result = await Cli.Wrap(ContainerConfiguration.DefaultShell)
.WithArguments(command)
.ExecuteBufferedAsync();
return(result);
}
public async Task <BufferedCommandResult> RunAsync(SolutionInfo solutionInfo)
{
string runCommand = CppCommands.Run(solutionInfo);
string command = DockerCommands.Exec(this, runCommand);
Console.WriteLine(command);
using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(ContainerConfiguration.ProcessTimeoutSeconds));
BufferedCommandResult result = await Cli.Wrap(ContainerConfiguration.DefaultShell)
.WithArguments(command)
.WithValidation(CommandResultValidation.None)
.ExecuteBufferedAsync(cts.Token); // cts
// throws OperationCanceledException
return(result);
}
public DockerCommands ParseCommandsAndAddCommands(Models.Docker docker, Task task)
{
var dockerCommands = new DockerCommands();
var mainCommands = docker.Command.Split(' ').ToList();
var allCommands = docker.Usage.Split(' ').ToList();
bool foundOption = !allCommands.Contains(DockerCommands.OptionKey);
for (var i = 0; i < allCommands.Count; i++)
{
if (mainCommands.Contains(allCommands[i]))
{
continue;
}
var command = allCommands[i];
if (command == DockerCommands.OptionKey)
{
foundOption = true;
continue;
}
string paramName = command;
ConstructorArgument argument = new ConstructorArgument()
{
Parameter = new Parameter(),
};
if (paramName.TrimStart().StartsWith("|"))
{
if (allCommands[i + 2] == "|")
{
var arg = task.Constructor.Arguments.Last();
arg.Parameter.ParameterName = $"{arg.Parameter.ParameterName}Or{allCommands[i + 1].FirstCharToUpper()}";
i = i + 2;
}
else
{
continue;
}
}
if (paramName.StartsWith("[") && paramName.EndsWith("]"))
{
argument.Parameter.IsOptional = true;
paramName = command.Remove(0, 1);
paramName = paramName.Remove(paramName.Length - 1, 1);
}
if (i != allCommands.Count - 1 && allCommands[i + 1].Contains(paramName))
{
i++;
argument.Parameter.AsParams = true;
}
if (paramName.EndsWith(".."))
{
argument.Parameter.AsParams = true;
paramName = paramName.TrimEnd('.');
}
if (paramName.Contains("|"))
{
var splited = paramName.Split('|');
paramName = splited[0];
}
if (paramName.Contains("[:"))
{
var splited = paramName.Split('[');
paramName = splited[0];
}
if (paramName.Contains(":"))
{
var splited = paramName.Split(':');
paramName = splited[0];
}
if (paramName.Contains("-"))
{
paramName = paramName.Replace("-", string.Empty);
}
if (paramName.Contains("="))
{
continue;
}
paramName = paramName.Trim('(', ')');
argument.Parameter.ParameterName = paramName.ToLowerInvariant();
argument.Parameter.ParameterType = "string";
if (foundOption)
{
argument.AfterOptions = true;
}
if (!string.IsNullOrEmpty(argument.Parameter.ParameterName))
{
task.Constructor.Arguments.Add(argument);
}
}
return(dockerCommands);
}
