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)); }