protected InspectContainerResponse.ContainerState getCurrentState(DockerClient dockerClient, String containerId) { return dockerClient.inspectContainerCmd(containerId).exec().getState(); }
/** * {@inheritDoc} */ public void followOutput(DockerClient dockerClient, String containerId, Consumer<OutputFrame> consumer, OutputFrame.OutputType... types) { final LogContainerCmd cmd = dockerClient.logContainerCmd(containerId) .withFollowStream(true) .withSince(0); final FrameConsumerResultCallback callback = new FrameConsumerResultCallback(); for (OutputFrame.OutputType type : types) { callback.addConsumer(type, consumer); if (type == STDOUT) cmd.withStdOut(true); if (type == STDERR) cmd.withStdErr(true); } cmd.exec(callback); }
private void exposePortThroughProxy(String networkAlias, int originalPort, int mappedPort) { ExecCreateCmdResponse createCmdResponse = dockerClient .execCreateCmd(proxy.getContainerId()) .withCmd("/usr/bin/socat", "TCP-LISTEN:" + originalPort + ",fork,reuseaddr", "TCP:" + networkAlias + ":" + mappedPort) .exec(); dockerClient.execStartCmd(createCmdResponse.getId()) .exec(new ExecStartResultCallback()); }
/** * Check whether the image is available locally and pull it otherwise */ public void checkAndPullImage(DockerClient client, String image) { List<Image> images = client.listImagesCmd().withImageNameFilter(image).exec(); if (images.isEmpty()) { client.pullImageCmd(image).exec(new PullImageResultCallback()).awaitSuccess(); } }
public boolean isServiceReady() { try { List<Container> allContainers = dockerClient.listContainersCmd().withShowAll(true).exec(); for (Container container : allContainers) { if (asList(container.getNames()).contains("/" + otherContainerName) && !container.getStatus().contains("Exited")) { return true; } } } catch (DockerException e) { return false; } return false; } }
@Override public CreateContainerCmd createContainerCmd(@NotNull String image) { return wrappedCommand(CreateContainerCmd.class, wrappedClient.createContainerCmd(image), (cmd, res) -> doLog("CREATE", image, res.getId(), cmd), (cmd, e) -> doLog("CREATE", image, null, cmd, e)); }
@Test public void sharedMemorySetTest() { try (GenericContainer containerWithSharedMemory = new GenericContainer("busybox:1.29") .withSharedMemorySize(1024L * FileUtils.ONE_MB)) { containerWithSharedMemory.start(); HostConfig hostConfig = containerWithSharedMemory.getDockerClient().inspectContainerCmd(containerWithSharedMemory.getContainerId()) .exec().getHostConfig(); assertEquals("Shared memory not set on container", hostConfig.getShmSize(), 1024 * FileUtils.ONE_MB); } } }
private void tagImage(String sourceImage, String targetImage, String targetTag) throws InterruptedException { DockerClient client = DockerClientFactory.instance().client(); client.pullImageCmd(sourceImage).exec(new PullImageResultCallback()).awaitCompletion(); client.tagImageCmd(sourceImage, targetImage, targetTag).exec(); } }
default InspectContainerResponse getCurrentContainerInfo() { return DockerClientFactory.instance().client().inspectContainerCmd(getContainerId()).exec(); }
@Override public StartContainerCmd startContainerCmd(@NotNull String containerId) { return wrappedCommand(StartContainerCmd.class, wrappedClient.startContainerCmd(containerId), (cmd, res) -> doLog("START", null, containerId, cmd), (cmd, e) -> doLog("START", null, containerId, cmd, e)); }
@AfterClass public static void tearDown() { RegistryAuthLocator.setInstance(originalAuthLocatorSingleton); client.removeImageCmd(testImageNameWithTag).withForce(true).exec(); }
@Override public RemoveContainerCmd removeContainerCmd(@NotNull String containerId) { return wrappedCommand(RemoveContainerCmd.class, wrappedClient.removeContainerCmd(containerId), (cmd, res) -> doLog("REMOVE", null, containerId, cmd), (cmd, e) -> doLog("REMOVE", null, containerId, cmd, e)); }
@Override public StopContainerCmd stopContainerCmd(@NotNull String containerId) { return wrappedCommand(StopContainerCmd.class, wrappedClient.stopContainerCmd(containerId), (cmd, res) -> doLog("STOP", null, containerId, cmd), (cmd, e) -> doLog("STOP", null, containerId, cmd, e)); }
private void connectToPortForwardingNetwork(String networkMode) { PortForwardingContainer.INSTANCE.getNetwork().map(ContainerNetwork::getNetworkID).ifPresent(networkId -> { if (!Arrays.asList(networkId, "none", "host").contains(networkMode)) { dockerClient.connectToNetworkCmd().withContainerId(containerId).withNetworkId(networkId).exec(); } }); }
private List<String> findAllNetworks() { return DockerClientFactory.instance().client().listNetworksCmd().exec().stream() .map(Network::getName) .sorted() .collect(Collectors.toList()); } }
@Override public KillContainerCmd killContainerCmd(@NotNull String containerId) { return wrappedCommand(KillContainerCmd.class, wrappedClient.killContainerCmd(containerId), (cmd, res) -> doLog("KILL", null, containerId, cmd), (cmd, e) -> doLog("KILL", null, containerId, cmd, e)); }
@SneakyThrows public InputStream streamRecording() { TarArchiveInputStream archiveInputStream = new TarArchiveInputStream( dockerClient.copyArchiveFromContainerCmd(containerId, RECORDING_FILE_NAME).exec() ); archiveInputStream.getNextEntry(); return archiveInputStream; }
@Override public RemoveNetworkCmd removeNetworkCmd(@NotNull String networkId) { return wrappedCommand(RemoveNetworkCmd.class, wrappedClient.removeNetworkCmd(networkId), (cmd, res) -> doLog("REMOVE_NETWORK", null, null, cmd), (cmd, e) -> doLog("REMOVE_NETWORK", null, null, cmd, e)); }
@Override public CreateNetworkCmd createNetworkCmd() { return wrappedCommand(CreateNetworkCmd.class, wrappedClient.createNetworkCmd(), (cmd, res) -> doLog("CREATE_NETWORK", null, null, cmd), (cmd, e) -> doLog("CREATE_NETWORK", null, null, cmd, e)); }