Refine search
Optional<ContainerNetwork> getNetwork() { return Optional.ofNullable(container) .map(GenericContainer::getContainerInfo) .flatMap(it -> it.getNetworkSettings().getNetworks().values().stream().findFirst()); } }
@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); } } }
protected InspectContainerResponse.ContainerState getCurrentState(DockerClient dockerClient, String containerId) { return dockerClient.inspectContainerCmd(containerId).exec().getState(); }
String containerId = containerInfo.getId(); String containerName = containerInfo.getName(); .execCreateCmd(containerId) .withCmd(command); final ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(containerId) .withAttachStdout(true).withAttachStderr(true).withCmd(command).exec(); callback.addConsumer(OutputFrame.OutputType.STDERR, stderrConsumer); dockerClient.execStartCmd(execCreateCmdResponse.getId()).exec(callback).awaitCompletion();
@Test public void createContainerCmdHookTest() { // Use random name to avoid the conflicts between the tests String randomName = Base58.randomString(5); try( GenericContainer container = new GenericContainer<>("redis:3.0.2") .withCommand("redis-server", "--help") .withCreateContainerCmdModifier(cmd -> cmd.withName("overrideMe")) // Preserves the order .withCreateContainerCmdModifier(cmd -> cmd.withName(randomName)) // Allows to override pre-configured values by GenericContainer .withCreateContainerCmdModifier(cmd -> cmd.withCmd("redis-server", "--port", "6379")) ) { container.start(); assertEquals("Name is configured", "/" + randomName, container.getContainerInfo().getName()); assertEquals("Command is configured", "[redis-server, --port, 6379]", Arrays.toString(container.getContainerInfo().getConfig().getCmd())); } }
private void logNetworks(String containerId) { Map<String, ContainerNetwork> networks = getClient().inspectContainerCmd(containerId).exec().getNetworkSettings().getNetworks(); int networksSize = networks.size(); log.debug("There are {} network(s) in the container {}", networksSize, containerId); if (networksSize == 0) { return; } int i = 0; for (Entry<String, ContainerNetwork> network : networks.entrySet()) { log.debug("{}) {} -> {}", ++i, network.getKey(), network.getValue()); } }
CreateContainerCmd createCommand = dockerClient.createContainerCmd(dockerImageName); applyConfiguration(createCommand); dockerClient.startContainerCmd(containerId).exec(); containerInfo = dockerClient.inspectContainerCmd(containerId).exec(); containerName = containerInfo.getName(); containerIsStarting(containerInfo);
private void stopContainer(String containerId, String imageName) { boolean running; try { InspectContainerResponse containerInfo = dockerClient.inspectContainerCmd(containerId).exec(); running = containerInfo.getState().getRunning(); } catch (NotFoundException e) { LOGGER.trace("Was going to stop container but it apparently no longer exists: {}", containerId); try { LOGGER.trace("Stopping container: {}", containerId); dockerClient.killContainerCmd(containerId).exec(); LOGGER.trace("Stopped container: {}", imageName); } catch (DockerException e) { dockerClient.inspectContainerCmd(containerId).exec(); } catch (NotFoundException e) { LOGGER.trace("Was going to remove container but it apparently no longer exists: {}", containerId);
@Test @DisplayName("start a container without ports") public void shouldStartContainer() { String containerId = defaultDockerClient.startContainer(WANTED_IMAGE, emptyMap()); assertThat(dockerClient.listContainersCmd().exec()).hasSize(existingContainers.size() + 1); InspectContainerResponse startedContainer = dockerClient.inspectContainerCmd(containerId).exec(); assertThat(startedContainer.getConfig().getImage()).isEqualTo(WANTED_IMAGE); }
public static Binding binding(DockerClientExecutor executor, String cubeId) { InspectContainerResponse inspectResponse = executor.getDockerClient().inspectContainerCmd(cubeId).exec(); String dockerIp = getDockerServerIp(executor); String inernalIp = null; NetworkSettings networkSettings = inspectResponse.getNetworkSettings(); if (networkSettings != null) { inernalIp = networkSettings.getIpAddress(); } Binding binding = new Binding(dockerIp, inernalIp); HostConfig hostConfig = inspectResponse.getHostConfig(); if (hostConfig.getPortBindings() != null) { for (Entry<ExposedPort, com.github.dockerjava.api.model.Ports.Binding[]> bind : hostConfig.getPortBindings() .getBindings().entrySet()) { com.github.dockerjava.api.model.Ports.Binding[] allBindings = bind.getValue(); for (com.github.dockerjava.api.model.Ports.Binding bindings : allBindings) { binding.addPortBinding(bind.getKey().getPort(), Integer.parseInt(bindings.getHostPortSpec())); } } } else { ContainerConfig connectionConfig = inspectResponse.getConfig(); final ExposedPort[] exposedPorts = connectionConfig.getExposedPorts(); if (exposedPorts != null) { for (ExposedPort port : exposedPorts) { binding.addPortBinding(port.getPort(), -1); } } } return binding; }
for (Network network : networks) { log.info("Connecting container {} to network {}", containerId, network.getId(), context); connection.getDockerClient().connectToNetworkCmd().withContainerId(containerId).withNetworkId(network.getNetworkId()).exec(); log.info("Connected container {} to network {}", containerId, network.getId(), context); InspectContainerResponse response = connection.getDockerClient().inspectContainerCmd(containerId).exec(); if (response.getNetworkSettings().getNetworks() == null || response.getNetworkSettings().getNetworks().isEmpty()) { ipAddress = response.getNetworkSettings().getIpAddress(); } else { if (StringUtils.isNotBlank(connection.getDockerNetworkName()) && response.getNetworkSettings().getNetworks().containsKey(connection.getDockerNetworkName())) { ipAddress = response.getNetworkSettings().getNetworks().get(connection.getDockerNetworkName()).getIpAddress(); } else if (response.getNetworkSettings().getNetworks().containsKey("bridge")) { ipAddress = response.getNetworkSettings().getNetworks().get("bridge").getIpAddress(); } else { ipAddress = response.getNetworkSettings().getNetworks().values().iterator().next().getIpAddress(); for (Map.Entry<java.lang.String, ContainerNetwork> networkEntry : response.getNetworkSettings().getNetworks().entrySet()) { ipAddresses.put(networkEntry.getKey(), networkEntry.getValue().getIpAddress()); if (connection.getSwarmNodesIPsMappings() != null && !connection.getSwarmNodesIPsMappings().isEmpty() && response.getNode() != null) { String dockerHostIP = response.getNode().getIp(); setAttribute("docker_host_ip_address", dockerHostIP); publicIPAddress = connection.getSwarmNodesIPsMappings().get(dockerHostIP); setAttribute("provider_resource_name", response.getName()); log.info("Started container with id " + containerId + " and ip address " + ipAddress, context);
@Test public void container_should_be_attached_to_front_network() { final InspectContainerResponse pingpong = dockerClient.inspectContainerCmd("pingpong").exec(); final Network front = dockerClient.inspectNetworkCmd().withNetworkId("front").exec(); assertThat(front.getContainers()).containsOnlyKeys(pingpong.getId()); }
@Test public void container_should_have_static_ip_for_app_net_network() throws InterruptedException, IOException { final InspectContainerResponse pingpong = dockerClient.inspectContainerCmd("pingpong").exec(); ExecCreateCmdResponse execCreateCmdResponse = dockerClient.execCreateCmd(pingpong.getId()) .withAttachStdout(true).withAttachStdin(true).withAttachStderr(true).withTty(false).withCmd("ifconfig") .exec(); try (OutputStream outputStream = new ByteArrayOutputStream(); OutputStream errorStream = new ByteArrayOutputStream()) { dockerClient.execStartCmd(execCreateCmdResponse.getId()).withDetach(false) .exec(new ExecStartResultCallback(outputStream, errorStream)).awaitCompletion(); assertThat(outputStream.toString()).contains("inet addr:172.16.238.10", "inet6 addr: fe80::42:acff:fe10:ee0a/64"); } }
public static String getContainerHostname(GenericContainer container) { InspectContainerResponse containerInfo = container.getContainerInfo(); if (containerInfo == null) { containerInfo = container.getDockerClient().inspectContainerCmd(container.getContainerId()).exec(); } return containerInfo.getConfig().getHostName(); }
private Stream<Container> asContainer(String container) { return inspectContainerCmd(container) .map(response -> new Container( response.getConfig().getHostName(), new DockerImage(response.getConfig().getImage()), containerResourcesFromHostConfig(response.getHostConfig()), new ContainerName(decode(response.getName())), Container.State.valueOf(response.getState().getStatus().toUpperCase()), response.getState().getPid() )) .map(Stream::of) .orElse(Stream.empty()); }
private boolean isRunning(InspectContainerResponse containerInfo) { try { return containerInfo != null && containerInfo.getState().getRunning(); } catch (DockerException e) { return false; } } }
throw new IllegalStateException("execInContainer can only be used while the Container is running"); String containerId = containerInfo.getId(); String containerName = containerInfo.getName(); DockerClient dockerClient = DockerClientFactory.instance().client(); dockerClient.execCreateCmd(containerId).withCmd(command); callback.addConsumer(OutputFrame.OutputType.STDOUT, stdoutConsumer); callback.addConsumer(OutputFrame.OutputType.STDERR, stderrConsumer); dockerClient.execStartCmd(execCreateCmdResponse.getId()).exec(callback).awaitCompletion(); final Container.ExecResult result = new Container.ExecResult(stdoutConsumer.toString(outputCharset), stderrConsumer.toString(outputCharset)); log.trace("{}: stdout: {}", containerName, result.getStdout());
@Override public void transform(Map<String, Object> fromInspect, Instance instance) { InspectContainerResponse inspect = transformInspect(fromInspect); ContainerConfig containerConfig = inspect.getConfig(); HostConfig hostConfig = inspect.getHostConfig(); instance.setExternalId(inspect.getId()); instance.setKind(KIND_CONTAINER); setName(instance, inspect, fromInspect);
@Test public void customLabelTest() { try (final GenericContainer alpineCustomLabel = new GenericContainer("alpine:3.2") .withLabel("our.custom", "label") .withCommand("top")) { alpineCustomLabel.start(); Map<String, String> labels = alpineCustomLabel.getCurrentContainerInfo().getConfig().getLabels(); assertTrue("org.testcontainers label is present", labels.containsKey("org.testcontainers")); assertTrue("our.custom label is present", labels.containsKey("our.custom")); assertEquals("our.custom label value is label", labels.get("our.custom"), "label"); } }
@Override protected void waitUntilReady() { final String containerName = waitStrategyTarget.getContainerInfo().getName();