internal static async Task StartContainerAsync(
DockerClient client,
string containerId,
ContainerAttachParameters attachParams,
bool?isTTY,
ContainerStartParameters startParams,
CancellationToken token)
{
MultiplexedStream stream = null;
Task streamTask = null;
try
{
if (attachParams != null)
{
stream = await client.Containers.AttachContainerAsync(containerId, isTTY.GetValueOrDefault(), attachParams, token);
streamTask = stream.CopyToConsoleAsync(isTTY.GetValueOrDefault(), attachParams.Stdin.GetValueOrDefault(), token);
}
if (!await client.Containers.StartContainerAsync(containerId, new ContainerStartParameters()))
{
throw new ApplicationFailedException("The container has already started.");
}
if (attachParams != null)
{
await streamTask;
}
}
finally
{
stream?.Dispose();
}
}
protected override async Task ProcessRecordAsync()
{
foreach (var id in ParameterResolvers.GetContainerIds(Container, ContainerIdOrName))
{
ContainerAttachParameters attachParams = null;
if (this.Attach)
{
attachParams = new ContainerAttachParameters
{
Stdin = this.Input,
Stdout = true,
Stderr = true,
Stream = true
};
}
var cDetail = await DkrClient.Containers.InspectContainerAsync(id);
await ContainerOperations.StartContainerAsync(
this.DkrClient,
id,
attachParams,
cDetail.Config.Tty,
null,
this.CmdletCancellationToken);
if (PassThru)
{
WriteObject((await ContainerOperations.GetContainersByIdOrName(id, DkrClient)).Single());
}
}
}
public async Task <(string stdOut, string stdErr)> AwaitContainer(string id)
{
try
{
var config = new ContainerAttachParameters
{
Stream = true,
Stderr = true,
Stdin = false,
Stdout = true,
Logs = "1"
};
(string stdOut, string stdErr)containerResult;
using (var stream = await _client.Containers.AttachContainerAsync(id, false, config, default(CancellationToken)))
{
containerResult = await stream.ReadOutputToEndAsync(default(CancellationToken));
}
return(containerResult);
} catch (Exception ex)
{
return("", ex.Message);
}
}
/// <summary>
/// Creates a new container and lists it to output.
/// </summary>
protected override async Task ProcessRecordAsync()
{
foreach (var id in ParameterResolvers.GetImageIds(Image, ImageIdOrName))
{
var createResult = await ContainerOperations.CreateContainer(
id,
this.MemberwiseClone() as CreateContainerCmdlet,
DkrClient);
if (createResult.Warnings != null)
{
foreach (var w in createResult.Warnings)
{
if (!String.IsNullOrEmpty(w))
{
WriteWarning(w);
}
}
}
if (!String.IsNullOrEmpty(createResult.ID))
{
ContainerAttachParameters attachParams = null;
if (!Detach)
{
attachParams = new ContainerAttachParameters
{
Stdin = Input,
Stdout = true,
Stderr = true,
Stream = true
};
}
await ContainerOperations.StartContainerAsync(
this.DkrClient,
createResult.ID,
attachParams,
this.Terminal,
null,
this.CmdletCancellationToken);
if (RemoveAutomatically && !Detach)
{
await DkrClient.Containers.RemoveContainerAsync(createResult.ID,
new ContainerRemoveParameters());
}
else if (PassThru)
{
WriteObject((await ContainerOperations.GetContainersById(createResult.ID, DkrClient)).Single());
}
}
}
}
public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken ct = default)
{
Logger.LogInformation("Attaching {outputConsumer} at container {id}", outputConsumer.GetType(), id);
var attachParameters = new ContainerAttachParameters
{
Stdout = true,
Stderr = true,
Stream = true,
};
var stream = await this.Docker.Containers.AttachContainerAsync(id, false, attachParameters, ct)
.ConfigureAwait(false);
_ = stream.CopyOutputToAsync(Stream.Null, outputConsumer.Stdout, outputConsumer.Stderr, ct)
.ConfigureAwait(false);
}
public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken ct = default)
{
if (outputConsumer is null)
{
return;
}
var attachParameters = new ContainerAttachParameters
{
Stdout = true,
Stderr = true,
Stream = true,
};
var stream = await this.Docker.Containers.AttachContainerAsync(id, false, attachParameters, ct);
_ = stream.CopyOutputToAsync(Stream.Null, outputConsumer.Stdout, outputConsumer.Stderr, ct);
}
public async Task <string> AttachContainer(string id)
{
var config = new ContainerAttachParameters
{
Stream = true,
Stderr = true,
Stdin = false,
Stdout = true,
};
string stdOut;
string stdErr;
var buffer = new byte[1024];
using (var stream = await _client.Containers.AttachContainerAsync(id, false, config, default(CancellationToken)))
{
(stdOut, stdErr) = await stream.ReadOutputToEndAsync(default(CancellationToken));
}
return(stdOut);
}
public async Task AttachAsync(string id, IOutputConsumer outputConsumer, CancellationToken ct = default)
{
if (!outputConsumer.Enabled)
{
return;
}
this.logger.AttachToDockerContainer(id, outputConsumer.GetType());
var attachParameters = new ContainerAttachParameters
{
Stdout = true,
Stderr = true,
Stream = true,
};
var stream = await this.Docker.Containers.AttachContainerAsync(id, false, attachParameters, ct)
.ConfigureAwait(false);
_ = stream.CopyOutputToAsync(Stream.Null, outputConsumer.Stdout, outputConsumer.Stderr, ct)
.ConfigureAwait(false);
}
protected override async Task ProcessRecordAsync()
{
var id = Id ?? Container.ID;
var inspect = await DkrClient.Containers.InspectContainerAsync(id);
if (!inspect.State.Running || inspect.State.Paused)
{
throw new Exception("Cannot enter a stopped or paused container.");
}
var parameters = new ContainerAttachParameters
{
Stdin = inspect.Config.OpenStdin,
Stdout = true,
Stream = true
};
using (var stream = await DkrClient.Containers.AttachContainerAsync(inspect.ID, inspect.Config.Tty, parameters, CmdletCancellationToken))
{
await stream.CopyToConsoleAsync(inspect.Config, CmdletCancellationToken);
}
}
public async Task <MultiplexedStream> AttachContainerAsync(string id, bool tty, ContainerAttachParameters parameters, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var queryParameters = new QueryString <ContainerAttachParameters>(parameters);
var stream = await this._client.MakeRequestForHijackedStreamAsync(new[] { NoSuchContainerHandler }, HttpMethod.Post, $"containers/{id}/attach", queryParameters, null, null, cancellationToken).ConfigureAwait(false);
if (!stream.CanCloseWrite)
{
stream.Dispose();
throw new NotSupportedException("Cannot shutdown write on this transport");
}
return(new MultiplexedStream(stream, !tty));
}
public async void RunAsync(Guid dadosCampanhaCampanhaId, string servico)
{
var client = new DockerClientConfiguration(new Uri("tcp://docker.for.win.localhost:2375"))
.CreateClient();
if (Environment.OSVersion.ToString().Contains("Windows"))
{
var argumento =
string.Format(
"docker run {0} --alias={1} --network={2} --links={3}:{0} -e CAMPANHA={1} -v tcp://docker.for.win.localhost:2375:/var/run/docker.sock {0}",
servico, dadosCampanhaCampanhaId, "dotnetcorerabbitmq_net.workflow", "mssql.workflow");
Process.Start("cmd.exe", "/c " + argumento);
}
else
{
var parameters = new Config
{
Image = servico,
ArgsEscaped = true,
AttachStderr = true,
AttachStdin = false,
AttachStdout = true,
OpenStdin = false,
StdinOnce = false,
Env = new[]
{
"CAMPANHA=" + dadosCampanhaCampanhaId + ""
},
Labels = new Dictionary <string, string>
{
{ "Links", "mssql.workflow:nyom.workflow.manager" }
},
Cmd = new[]
{
string.Format(
"--name {0} --net={1} -links={2}:{0}",
servico, "dotnetcorerabbitmq_net.workflow", "mssql.workflow"),
"bash"
}
};
var net = new NetworkingConfig
{
EndpointsConfig = new Dictionary <string, EndpointSettings>
{
{
"dotnetcorerabbitmq_net.workflow", new EndpointSettings
{
Links = new List <string>
{
"mssql.workflow:nyom.workflow.manager"
}
}
}
}
};
var response =
await client.Containers.CreateContainerAsync(
new CreateContainerParameters(parameters) { Name = servico, NetworkingConfig = net });
Task task = client.Containers.StartContainerAsync(response.ID, new ContainerStartParameters());
var config = new ContainerAttachParameters
{
Stream = true,
Stderr = false,
Stdin = true,
Stdout = true
};
var buffer = new byte[1024];
using (var stream =
await client.Containers.AttachContainerAsync(response.ID, false, config))
{
using (var fileStream = File.Create($"{DateTime.Now.Ticks}.jpg"))
{
await stream.CopyOutputToAsync(null, fileStream, null, default(CancellationToken));
}
}
}
}
/// <summary>
/// Creates a new container and lists it to output.
/// </summary>
protected override async Task ProcessRecordAsync()
{
foreach (var id in ParameterResolvers.GetImageIds(Image, Id))
{
var createResult = await ContainerOperations.CreateContainer(
id,
this.MemberwiseClone() as CreateContainerCmdlet,
DkrClient);
if (createResult.Warnings != null)
{
foreach (var w in createResult.Warnings)
{
if (!String.IsNullOrEmpty(w))
{
WriteWarning(w);
}
}
}
if (!String.IsNullOrEmpty(createResult.ID))
{
MultiplexedStream stream = null;
Task streamTask = null;
try
{
if (!Detach)
{
var parameters = new ContainerAttachParameters
{
Stdin = Input,
Stdout = true,
Stderr = true,
Stream = true
};
stream = await DkrClient.Containers.AttachContainerAsync(createResult.ID, Terminal, parameters, CmdletCancellationToken);
streamTask = stream.CopyToConsoleAsync(Terminal, Input, CmdletCancellationToken);
}
if (!await DkrClient.Containers.StartContainerAsync(createResult.ID, new ContainerStartParameters()))
{
throw new ApplicationFailedException("The container has already started.");
}
if (!Detach)
{
await streamTask;
}
}
finally
{
stream?.Dispose();
}
if (RemoveAutomatically && !Detach)
{
await DkrClient.Containers.RemoveContainerAsync(createResult.ID,
new ContainerRemoveParameters());
}
else if (PassThru)
{
WriteObject((await ContainerOperations.GetContainersById(createResult.ID, DkrClient)).Single());
}
}
}
}
