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();
}
}
private async Task <bool> startContainer(string id, ILogger logger)
{
logger.LogInformation($"Start container:{this.SafeName}");
var para = new ContainerStartParameters();
return(await this.client.Containers.StartContainerAsync(id, para, this.cancelTokenSource.Token));
}
public async Task InitVaultContainer()
{
var registryImage = await dockerWrapper.FindImage(repoTag);
using (var client = dockerWrapper.GetClient())
{
var p = new CreateContainerParameters();
p.Image = registryImage.ID;
//p.Volumes = new Dictionary<string, EmptyStruct>();
//p.Volumes.Add("/certs:/certs", new EmptyStruct());
p.ExposedPorts = new Dictionary <string, EmptyStruct>();
p.HostConfig = new HostConfig();
p.HostConfig.CapAdd = new List <string> {
"IPC_LOCK"
};
p.HostConfig.PortBindings = new Dictionary <string, IList <PortBinding> >();
p.HostConfig.PortBindings.Add("8200/tcp", new List <PortBinding> {
new PortBinding()
{
HostIP = "0.0.0.0",
HostPort = "8200"
}
});
p.Env = new List <string>()
{
"VAULT_DEV_ROOT_TOKEN_ID=myroottoken"
};
p.Name = containerName;
var containerResponse = await client.Containers.CreateContainerAsync(p);
var startP = new ContainerStartParameters();
await client.Containers.StartContainerAsync(containerResponse.ID, startP);
}
}
private async Task StartContainerAsync()
{
var containerStartParameters = new ContainerStartParameters();
try
{
await retryPolicy
.ExecuteAsync(async() =>
{
bool started = await _client.Containers.StartContainerAsync(
Instance.Id,
containerStartParameters);
if (!started)
{
throw new ContainerException(
"Docker container creation/startup failed.");
}
});
}
catch (Exception ex)
{
throw new ContainerException(
$"Error in StartContainer: {_settings.UniqueContainerName}", ex);
}
}
private static async Task <bool> StartContainer(string containerId)
{
var containerStartParameters = new ContainerStartParameters();
return(await _client.Containers.StartContainerAsync(
containerId,
containerStartParameters));
}
public bool Start(ContainerStartParameters startRequest)
{
bool returnValue = this.Docker.Containers.StartContainerAsync(this.CreateResponse.ID, startRequest).GetAwaiter().GetResult();
Console.WriteLine($"Container Started {this.CreateResponse.ID}");
return(returnValue);
}
public async Task <bool> StartContainerAsync(string containerID, ContainerStartParameters startParameters = null)
{
if (startParameters == null)
{
startParameters = new ContainerStartParameters();
}
return(await _client.Containers.StartContainerAsync(containerID, startParameters));
}
public async Task StartContainers(List <string> containerIds)
{
foreach (string containerId in containerIds)
{
ContainerStartParameters startParameters = new ContainerStartParameters();
await client.Containers.StartContainerAsync(containerId, startParameters);
}
await Refresh();
}
/// <summary>
/// <inheritdoc cref="IDockerManager.StartContainerAsync"/>
/// </summary>
/// <param name="container"></param>
/// <param name="cmdArgs"></param>
/// <returns></returns>
public virtual async Task <bool> StartContainerAsync(string container, string cmdArgs = "")
{
var parameters = new ContainerStartParameters()
{
DetachKeys = cmdArgs
};
var success = await Client.Containers.StartContainerAsync(container, parameters);
return(success);
}
public async Task <bool> StartContainerAsync(string id, ContainerStartParameters parameters)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id));
}
var queryParams = parameters == null ? null : new QueryString <ContainerStartParameters>(parameters);
var response = await this._client.MakeRequestAsync(new[] { NoSuchContainerHandler }, HttpMethod.Post, $"containers/{id}/start", queryParams, null).ConfigureAwait(false);
return(response.StatusCode != HttpStatusCode.NotModified);
}
private void RunContainer(Worker worker)
{
var start = new ContainerStartParameters();
var id = worker.createStatus.ID;
worker.runStatus = client.Containers
.StartContainerAsync(id, start)
.Result;
//return worker;
//client.Containers.StartContainerAsync(id, start);
}
public async Task <TestResults> RunTest(string url)
{
CancellationTokenSource cancellation = new CancellationTokenSource();
cancellation.CancelAfter(60000);
var createParams = new CreateContainerParameters {
Image = _imageName,
AttachStdout = true,
Name = Guid.NewGuid().ToString(),
Tty = true,
Env = new[] {
$"URL={url}"
}
};
var createResponse = await _client.Containers.CreateContainerAsync(createParams);
var containerId = createResponse.ID;
try
{
var startParams = new ContainerStartParameters();
var started = await _client.Containers.StartContainerAsync(containerId, startParams);
if (!started)
{
throw new Exception($"Container {containerId} failed to start");
}
var waitResponse = await _client.Containers.WaitContainerAsync(containerId, cancellation.Token);
var statusCode = waitResponse.StatusCode;
var logsResponse = await _client.Containers.GetContainerLogsAsync(containerId,
new ContainerLogsParameters { ShowStdout = true }, cancellation.Token);
using (var reader = new StreamReader(logsResponse))
{
var logs = await reader.ReadToEndAsync();
return(_parser.Parse(logs));
}
}
catch (TaskCanceledException)
{
throw new Exception("Test execution timed out");
}
finally
{
await _client.Containers.RemoveContainerAsync(containerId, new ContainerRemoveParameters { Force = true });
}
}
public async Task Install()
{
//docker run -d -p 8080:8080 -p 80:80 -v $PWD/traefik.toml:/etc/traefik/traefik.toml traefik
var traefikDir = cidataDir + "/traefik";
if (!Directory.Exists(traefikDir))
{
Directory.CreateDirectory(traefikDir);
}
File.WriteAllText(Path.Combine(traefikDir, "traefik.toml"), EmbeddedResourcesCiLib.TraefikToml.ReadAsText());
await dockerWrapper.CreateImageIfNotFound(traefikRepoTag);
var traefikImage = await dockerWrapper.FindImage(traefikRepoTag);
using (var client = this.dockerWrapper.GetClient())
{
var infraCidata = "/cidata";
var p = new CreateContainerParameters();
p.Image = traefikImage.ID;
p.ExposedPorts = new Dictionary <string, EmptyStruct>();
p.ExposedPorts.Add("8080/tcp", new EmptyStruct());
p.Name = containerName;
p.HostConfig = new DockerHostConfig()
.Bind(infraCidata + "/traefik/traefik.toml:/etc/traefik/traefik.toml")
.PortBinding("0.0.0.0", "8080", "8080/tcp")
.PortBinding("0.0.0.0", "80", "80/tcp")
.RestartAlways()
.GetConfig();
var response = await client.Containers.CreateContainerAsync(p);
var p2 = new ContainerStartParameters();
await client.Containers.StartContainerAsync(response.ID, p2);
}
// Traffic network so that traefic can communicate with other containers
using (var client = this.dockerWrapper.GetClient())
{
//client.Networks.CreateNetworkAsync();
}
}
private async void button9_Click(object sender, EventArgs e)
{
if (button9.Text == "操作")
{
return;
}
int selectednum = listBox1.SelectedIndex;
if (selectednum == -1)
{
return;
}
IList <ContainerListResponse> containers = await client.Containers.ListContainersAsync(
new ContainersListParameters()
{
Limit = 10,
});
string hostsid = listBox1.SelectedItem.ToString();
if (button9.Text == "开启容器")
{
ContainerStartParameters cp = new ContainerStartParameters();
await client.Containers.StartContainerAsync(hostsid, cp);
MessageBox.Show("已经发送指令", "Success", MessageBoxButtons.OK);
}
else if (button9.Text == "关闭容器")
{
ContainerStopParameters csp = new ContainerStopParameters
{
WaitBeforeKillSeconds = 10
};
var stopped = await client.Containers.StopContainerAsync(hostsid, csp, CancellationToken.None);
string stopstr = stopped.ToString();
if (stopstr == "True")
{
MessageBox.Show("已经关闭", "Success", MessageBoxButtons.OK);
}
else
{
MessageBox.Show("出现错误", "Error", MessageBoxButtons.OK);
}
}
}
public async Task EnsureRunning(string containerName, ContainerStartParameters parameters)
{
/*
* created : A container that has been created (e.g. with docker create) but not started
* restarting : A container that is in the process of being restarted
* running : A currently running container
* paused : A container whose processes have been paused
* exited : A container that ran and completed ("stopped" in other contexts, although a created container is technically also "stopped")
* dead : A container that the daemon tried and failed to stop (usually due to a busy device or resource used by the container)
*/
using (var client = GetClient())
{
var found = await this.FindContainerByName(containerName);
var state = found.State.ToLowerInvariant();
if (state == "running")
{
}
if (state == "restarting")
{
}
if (state == "exited")
{
await client.Containers.StartContainerAsync(found.ID, parameters);
}
if (state == "paused")
{
await client.Containers.UnpauseContainerAsync(found.ID);
}
if (state == "dead")
{
}
// check that container is really running
Thread.Sleep(1000);
found = await this.FindContainerByName(containerName);
state = found.State.ToLowerInvariant();
if (state != "running")
{
throw new Exception("Container not running : " + containerName);
}
}
}
public async Task <bool> StartContainerAsync(string id)
{
using var connection = await _dockerClient.ConnectAsync();
var containers = connection.Containers;
try
{
var parameters = new ContainerStartParameters();
var response = await containers.StartContainerAsync(id, parameters);
_logger.LogInformation("Container with '{Id}' started successfully.", id);
return(response);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Container with id '{Id}' could not be stopped.", id);
return(false);
}
}
public ContainerStartParameters StartContainer(ContainerStartParameters containerStartParameters) => _startContainer(containerStartParameters);
ContainerStartParameters IEnsureContainerIsRunningContext.StartContainer(ContainerStartParameters containerStartParameters)
{
return(containerStartParameters);
}
public void StartContainer(string id)
{
var parameter = new ContainerStartParameters();
_client.Containers.StartContainerAsync(id, parameter).Wait();
}
public void DatabaseIntegratedTest(string dbTechnology)
{
bool isUnderContainer = (System.Environment.OSVersion.Platform == PlatformID.Unix);
string buildTag = Environment.GetEnvironmentVariable("BUILD_TAG") ?? "jenkins-oragon-oragon-github-Oragon.Contexts-LOCAL-1";
Oragon.Spring.Context.Support.XmlApplicationContext context = new Oragon.Spring.Context.Support.XmlApplicationContext("assembly://Oragon.Context.Tests/Oragon.Context.Tests.Integrated/DatabaseIntegrationTests.docker.xml");
Skip.IfNot(context.ContainsObject($"{dbTechnology}.CreateContainerParameters"), "Has no configuration about " + dbTechnology);
TimeSpan dockerDefaultTimeout = context.GetObject <TimeSpan>($"{dbTechnology}.DefaultTimeout");
int getLogsRetryCount = context.GetObject <int>($"{dbTechnology}.GetLogsRetryCount");
string textTofound = context.GetObject <string>($"{dbTechnology}.ExpectedText");
TimeSpan getLogsWaitTime = context.GetObject <TimeSpan>($"{dbTechnology}.GetLogsWaitTime");
CreateContainerParameters createContainerParameters = context.GetObject <CreateContainerParameters>($"{dbTechnology}.CreateContainerParameters");
ContainerStartParameters containerStartParameters = context.GetObject <ContainerStartParameters>($"{dbTechnology}.ContainerStartParameters");
ContainerLogsParameters containerLogsParameters = context.GetObject <ContainerLogsParameters>($"{dbTechnology}.ContainerLogsParameters");
//Convention - If runnig outside docker, need expose port to perform the test
createContainerParameters.HostConfig.PublishAllPorts = !isUnderContainer;
using (DockerClient docker = new DockerClientConfiguration(this.GetEndpoint()).CreateClient())
{
//testing connectivity
docker.DefaultTimeout = dockerDefaultTimeout;
using (NetworkManager network = new NetworkManager(docker))
{
network.Create(buildTag);
using (ContainerManager container = new ContainerManager(docker))
{
container.Create(createContainerParameters);
if (container.Start(containerStartParameters))
{
network.Connect(container, dbTechnology);
container.WaitUntilTextFoundInLog(containerLogsParameters, textTofound, 10, getLogsWaitTime);
ContainerInspectResponse containerInfo = container.Inspect();
string portKey = createContainerParameters.ExposedPorts.Keys.Single();
string dbPort, dbHostname;
ContainerManager jenkinsTestContainer = null;
if (!isUnderContainer)
{
dbPort = containerInfo.NetworkSettings.Ports[portKey].Single().HostPort;
dbHostname = "127.0.0.1";
}
else
{
jenkinsTestContainer = ContainerManager.GetCurrent(docker) ?? throw new InvalidOperationException("ContainerManager.GetCurrent result nothing");
network.Connect(jenkinsTestContainer, "jenkins_worker");
dbPort = portKey.Split('/', StringSplitOptions.RemoveEmptyEntries).First();
dbHostname = dbTechnology;
}
try
{
this.DatabaseIntegratedTestInternal(dbTechnology, dbHostname, dbPort);
}
finally
{
if (jenkinsTestContainer != null)
{
network.Disconnect(jenkinsTestContainer);
}
}
}
}
}
}
}
public async Task Install()
{
// Image is alrady used by the mirror registry
await dockerWrapper.CreateImageIfNotFound(repoTag);
var registryImage = await dockerWrapper.FindImage(repoTag);
using (var client = dockerWrapper.GetClient())
{
/*
* https://docs.docker.com/registry/deploying/#get-a-certificate
*
* docker run -d \
* --restart=always \
*
* docker run \
* --name privateregistry \
* -v ${HOME}/cidata/privateregistry/var/lib/registry:/var/lib/registry \
* -v ${HOME}/cidata/privateregistry/certs:/certs \
* -e REGISTRY_HTTP_ADDR=0.0.0.0:443 \
* -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/privateregistry.mynetwork.local.crt \
* -e REGISTRY_HTTP_TLS_KEY=/certs/privateregistry.mynetwork.local.key \
* -p 5443:443 \
* registry:2
*/
// copy tls keys
shellHelper.Bash($"rm -rf {cidataDir}/privateregistry/certs");
shellHelper.Bash($"mkdir -p {cidataDir}/privateregistry/certs");
shellHelper.Bash($"cp {cidataDir}/tls/privateregistry.mynetwork.local.* {cidataDir}/privateregistry/certs");
// Registry data outside the container in /privateregistry
shellHelper.Bash("mkdir -p {cidataDir}/privateregistry/var/lib/registry");
var infraCidata = "/cidata";
var p = new CreateContainerParameters();
p.Image = registryImage.ID;
p.ExposedPorts = new Dictionary <string, EmptyStruct>();
p.ExposedPorts.Add("443/tcp", new EmptyStruct());
p.Env = new List <string>()
{
"REGISTRY_HTTP_ADDR=0.0.0.0:443",
"REGISTRY_HTTP_TLS_CERTIFICATE=/certs/privateregistry.mynetwork.local.crt",
"REGISTRY_HTTP_TLS_KEY=/certs/privateregistry.mynetwork.local.key",
"REGISTRY_STORAGE_DELETE_ENABLED=true"
};
p.Name = "privateregistry";
p.HostConfig = new DockerHostConfig()
.Bind($"{infraCidata}/privateregistry/var/lib/registry:/var/lib/registry")
.Bind($"{infraCidata}/privateregistry/certs:/certs")
.PortBinding("0.0.0.0", "5443", "443/tcp")
.RestartAlways()
.GetConfig();
var response = await client.Containers.CreateContainerAsync(p);
var p2 = new ContainerStartParameters();
await client.Containers.StartContainerAsync(response.ID, p2);
}
}
public async Task <bool> StartContainerAsync(string image)
{
ContainerStartParameters p = new ContainerStartParameters();
return(await _client.Containers.StartContainerAsync(image, p));
}
public Task ExecuteAsync(CancellationToken token)
{
var parameters = new ContainerStartParameters();
return(this.client.Containers.StartContainerAsync(this.module.Name, parameters, token));
}
public async void GetcontinerList()
{
DockerClient client = new DockerClientConfiguration(new Uri("http://192.168.0.25:4243")).CreateClient();
//ex) run 명령어 docker run -it --name "컨테이너 이름" centos:latest /bin/bash
//실행 중인 컨테이너 리스트 출력
IList <ContainerListResponse> containers = await client.Containers.ListContainersAsync(new ContainersListParameters()
{
Limit = 10
});
//docker images list
IList <ImagesListResponse> images = await client.Images.ListImagesAsync(new ImagesListParameters(), CancellationToken.None);
var aa = images[0].Labels.TryGetValue("org.label-schema.schema-version", out string outstring);
string continerid = "";
ContainerStartParameters param = new ContainerStartParameters();
await client.Containers.StartContainerAsync(continerid, param, CancellationToken.None);
//컨테이너 종료
//컨테이터 아이디 불러옴
string stopcontiner = containers[0].ID;
var stopped = await client.Containers.StopContainerAsync(stopcontiner, new ContainerStopParameters()
{
WaitBeforeKillSeconds = 10
},
CancellationToken.None);
//docker image 를 docker hub에서 다운로드함.
//임시로 내 테스트 업로드용 업데이트
//string image = "p82468/kgy";
//try
//{
// var report = new Progress<JSONMessage>(msg =>
// {
// Console.WriteLine($"{msg.Status}|{msg.ProgressMessage}|{msg.ErrorMessage}");
// });
// // pull image again
// await client.Images.CreateImageAsync(new ImagesCreateParameters
// {
// FromImage = image
// },
// new AuthConfig(),
// report
// );
// Console.WriteLine($"{Environment.NewLine}Successfully pulled image {image} to {client.Configuration.EndpointBaseUri}");
//}
//catch(Exception ex)
//{
// Console.WriteLine($"Exception thrown attempting to pull image {image} to {client.Configuration.EndpointBaseUri}");
// Console.WriteLine($"{ex}");
//}
}
/// <summary>
/// Called when the <see cref="Client"/> is ready to handle requests.
/// </summary>
void Ready()
{
// TODO: Handle termination of underlying Connection actor.
Receive <ListImages>(listImages =>
{
var executeCommand = new Connection.ExecuteCommand(listImages, async(dockerClient, cancellationToken) =>
{
var parameters = new ImagesListParameters
{
MatchName = listImages.MatchName,
All = listImages.All,
Filters = listImages.Filters.ToMutable()
};
IList <ImagesListResponse> images = await dockerClient.Images.ListImagesAsync(parameters);
return(new ImageList(listImages.CorrelationId, images));
});
_connection.Tell(executeCommand, Sender);
});
Receive <CreateContainer>(createContainer =>
{
var executeCommand = new Connection.ExecuteCommand(createContainer, async(dockerClient, cancellationToken) =>
{
var parameters = new CreateContainerParameters
{
Image = createContainer.Image,
Name = createContainer.Name,
AttachStdout = createContainer.AttachStdOut,
AttachStderr = createContainer.AttachStdErr,
AttachStdin = createContainer.AttachStdIn,
Tty = createContainer.TTY,
HostConfig = new HostConfig
{
// Hard-coded for now.
LogConfig = new LogConfig
{
Type = createContainer.LogType
}
}
// TODO: Add other parameters.
};
if (createContainer.EnvironmentVariables.Count > 0)
{
parameters.Env = createContainer.EnvironmentVariables
.Select(
environmentVariable => $"{environmentVariable.Key}={environmentVariable.Value}"
)
.ToList();
}
if (createContainer.Binds.Count > 0)
{
parameters.HostConfig.Binds = createContainer.Binds
.Select(
bind => $"{bind.Key}:{bind.Value}"
)
.ToList();
}
if (createContainer.Ports.Count > 0)
{
parameters.ExposedPorts = createContainer.Ports.ToDictionary(
port => port.Key,
port => (object)port.Value
);
}
CreateContainerResponse response = await dockerClient.Containers.CreateContainerAsync(parameters);
return(new ContainerCreated(createContainer.CorrelationId, response));
});
_connection.Tell(executeCommand, Sender);
});
Receive <StartContainer>(startContainer =>
{
var executeCommand = new Connection.ExecuteCommand(startContainer, async(dockerClient, cancellationToken) =>
{
ContainerStartParameters parameters = new ContainerStartParameters
{
DetachKeys = startContainer.DetachKeys
};
bool containerWasStarted = await dockerClient.Containers.StartContainerAsync(startContainer.ContainerId, parameters);
return(new ContainerStarted(startContainer.CorrelationId, startContainer.ContainerId,
alreadyStarted: !containerWasStarted
));
});
_connection.Tell(executeCommand, Sender);
});
Receive <StopContainer>(stopContainer =>
{
var executeCommand = new Connection.ExecuteCommand(stopContainer, async(dockerClient, cancellationToken) =>
{
var parameters = new ContainerStopParameters
{
WaitBeforeKillSeconds = stopContainer.WaitBeforeKillSeconds
};
bool containerWasStopped = await dockerClient.Containers.StopContainerAsync(stopContainer.ContainerId, parameters, cancellationToken);
return(new ContainerStopped(stopContainer.CorrelationId, stopContainer.ContainerId,
alreadyStopped: !containerWasStopped
));
});
_connection.Tell(executeCommand, Sender);
});
Receive <RemoveContainer>(removeContainer =>
{
var executeCommand = new Connection.ExecuteCommand(removeContainer, async(dockerClient, cancellationToken) =>
{
await dockerClient.Containers.RemoveContainerAsync(removeContainer.ContainerId, removeContainer.Parameters);
return(new ContainerRemoved(removeContainer.CorrelationId,
removeContainer.ContainerId
));
});
_connection.Tell(executeCommand, Sender);
});
Receive <GetContainerLogs>(getContainerLogs =>
{
Log.Debug("Received GetContainerLogs request '{0}' from '{1}'.", getContainerLogs.CorrelationId, Sender);
var executeCommand = new Connection.ExecuteCommand(getContainerLogs, async(dockerClient, cancellationToken) =>
{
Stream responseStream = await dockerClient.Containers.GetContainerLogsAsync(
getContainerLogs.ContainerId,
getContainerLogs.Parameters,
cancellationToken
);
return(new StreamedResponse(getContainerLogs.CorrelationId, responseStream, format: StreamedResponseFormat.Log));
});
_connection.Tell(executeCommand, Sender);
});
Receive <MonitorContainerEvents>(monitorContainerEvents =>
{
Log.Debug("Received MonitorContainerEvents request '{0}' from '{1}'.", monitorContainerEvents.CorrelationId, Sender);
var executeCommand = new Connection.ExecuteCommand(monitorContainerEvents, async(dockerClient, cancellationToken) =>
{
Stream responseStream = await dockerClient.Miscellaneous.MonitorEventsAsync(monitorContainerEvents.Parameters, cancellationToken);
return(new StreamedResponse(monitorContainerEvents.CorrelationId, responseStream, format: StreamedResponseFormat.Events));
});
_connection.Tell(executeCommand, Sender);
});
Receive <CancelRequest>(cancelRequest =>
{
_connection.Forward(cancelRequest);
});
Receive <EventBusActor.Subscribe>(subscribeToDockerEvents =>
{
if (_dockerEventBus == null)
{
_dockerEventBus = Context.ActorOf(
DockerEventBus.Create(Self),
name: DockerEventBus.ActorName
);
}
_dockerEventBus.Forward(subscribeToDockerEvents);
});
Receive <EventBusActor.Unsubscribe>(unsubscribeFromDockerEvents =>
{
if (_dockerEventBus == null)
{
return;
}
_dockerEventBus.Forward(unsubscribeFromDockerEvents);
});
}
public AdminTestsSetup()
{
var configDirectory =
System.IO.Directory.CreateDirectory(
System.IO.Path.Combine(
System.IO.Path.GetTempPath(),
System.IO.Path.GetRandomFileName()));
System.IO.File.WriteAllText(
System.IO.Path.Combine(configDirectory.FullName, "rippled.cfg"),
config);
System.IO.File.WriteAllText(
System.IO.Path.Combine(configDirectory.FullName, "validators.txt"),
validators);
Client = new DockerClientConfiguration(null, TimeSpan.FromMinutes(1.0)).CreateClient();
// Pull the latest image
var imagesCreateParameters = new ImagesCreateParameters
{
FromImage = "xrpllabsofficial/xrpld",
Tag = "latest"
};
var progress = new Progress <JSONMessage>();
Client.Images.CreateImageAsync(imagesCreateParameters, null, progress).Wait();
var createParameters = new CreateContainerParameters();
createParameters.Volumes = new Dictionary <string, EmptyStruct>(new [] {
KeyValuePair.Create("/config", new EmptyStruct()),
});
createParameters.Image = imagesCreateParameters.FromImage + ":" + imagesCreateParameters.Tag;
createParameters.HostConfig = new HostConfig {
Binds = new [] { configDirectory + ":/config:ro" },
PublishAllPorts = true
};
createParameters.Cmd = new[] { "-a", "--start" };
var container = Client.Containers.CreateContainerAsync(createParameters).Result;
ID = container.ID;
var startParameters = new ContainerStartParameters();
var started = Client.Containers.StartContainerAsync(ID, startParameters).Result;
if (!started)
{
Dispose();
throw new Exception("Could not start rippled container");
}
var inspect = Client.Containers.InspectContainerAsync(ID).Result;
foreach (var port in inspect.NetworkSettings.Ports)
{
if (port.Key == "5005/tcp")
{
HttpPort = port.Value[0].HostPort;
}
if (port.Key == "6006/tcp")
{
WsPort = port.Value[0].HostPort;
}
}
// Check we can ping the server
for (int i = 0; i < 10; ++i)
{
var address = new Uri("http://localhost:" + this.HttpPort);
var httpClient = new HttpClient();
httpClient.BaseAddress = address;
var api = new JsonRpcApi(httpClient);
try
{
api.Ping().Wait(TimeSpan.FromSeconds(5.0));
break;
}
catch
{
if (i == 9)
{
Dispose();
throw;
}
System.Threading.Thread.Sleep(500);
}
finally
{
api.DisposeAsync().AsTask().Wait();
}
}
}
public ContainerStartParameters StartContainer(ContainerStartParameters containerStartParameters)
{
return(_startContainer(containerStartParameters));
}
