Examples with VolumesFrom com.github.dockerjava.api.model.VolumesFrom used on opensource projects

Example 1 with VolumesFrom

use of com.github.dockerjava.api.model.VolumesFrom in project camel by apache.

the class CreateContainerCmdHeaderTest method createContainerHeaderTest.

@Test
public void createContainerHeaderTest() {
    String image = "busybox";
    ExposedPort exposedPort = ExposedPort.tcp(22);
    boolean tty = true;
    String name = "cameldocker";
    String workingDir = "/opt";
    boolean disableNetwork = false;
    String domainName = "apache.org";
    String hostname = "dockerjava";
    String user = "docker";
    boolean stdInOpen = false;
    boolean stdInOnce = false;
    boolean attachStdErr = true;
    boolean attachStdOut = true;
    boolean attachStdIn = false;
    Long memoryLimit = 2048L;
    Long swapMemory = 512L;
    Integer cpuShares = 512;
    Volume volumes = new Volume("/example");
    VolumesFrom volumesFromContainer = new VolumesFrom("/etc");
    String env = "FOO=bar";
    String cmd = "whoami";
    HostConfig hostConfig = new HostConfig();
    Capability capAdd = Capability.NET_BROADCAST;
    Capability capDrop = Capability.BLOCK_SUSPEND;
    String[] entrypoint = new String[] { "sleep", "9999" };
    String portSpecs = "80";
    String dns = "8.8.8.8";
    Map<String, Object> headers = getDefaultParameters();
    headers.put(DockerConstants.DOCKER_IMAGE, image);
    headers.put(DockerConstants.DOCKER_EXPOSED_PORTS, exposedPort);
    headers.put(DockerConstants.DOCKER_TTY, tty);
    headers.put(DockerConstants.DOCKER_NAME, name);
    headers.put(DockerConstants.DOCKER_WORKING_DIR, workingDir);
    headers.put(DockerConstants.DOCKER_DISABLE_NETWORK, disableNetwork);
    headers.put(DockerConstants.DOCKER_HOSTNAME, hostname);
    headers.put(DockerConstants.DOCKER_USER, user);
    headers.put(DockerConstants.DOCKER_STD_IN_OPEN, stdInOpen);
    headers.put(DockerConstants.DOCKER_STD_IN_ONCE, stdInOnce);
    headers.put(DockerConstants.DOCKER_ATTACH_STD_IN, attachStdIn);
    headers.put(DockerConstants.DOCKER_ATTACH_STD_ERR, attachStdErr);
    headers.put(DockerConstants.DOCKER_ATTACH_STD_OUT, attachStdOut);
    headers.put(DockerConstants.DOCKER_MEMORY_LIMIT, memoryLimit);
    headers.put(DockerConstants.DOCKER_MEMORY_SWAP, swapMemory);
    headers.put(DockerConstants.DOCKER_CPU_SHARES, cpuShares);
    headers.put(DockerConstants.DOCKER_VOLUMES, volumes);
    headers.put(DockerConstants.DOCKER_VOLUMES_FROM, volumesFromContainer);
    headers.put(DockerConstants.DOCKER_ENV, env);
    headers.put(DockerConstants.DOCKER_CMD, cmd);
    headers.put(DockerConstants.DOCKER_HOST_CONFIG, hostConfig);
    headers.put(DockerConstants.DOCKER_CAP_ADD, capAdd);
    headers.put(DockerConstants.DOCKER_CAP_DROP, capDrop);
    headers.put(DockerConstants.DOCKER_ENTRYPOINT, entrypoint);
    headers.put(DockerConstants.DOCKER_PORT_SPECS, portSpecs);
    headers.put(DockerConstants.DOCKER_DNS, dns);
    headers.put(DockerConstants.DOCKER_DOMAIN_NAME, domainName);
    template.sendBodyAndHeaders("direct:in", "", headers);
    Mockito.verify(dockerClient, Mockito.times(1)).createContainerCmd(image);
    Mockito.verify(mockObject, Mockito.times(1)).withExposedPorts(Matchers.eq(exposedPort));
    Mockito.verify(mockObject, Mockito.times(1)).withTty(Matchers.eq(tty));
    Mockito.verify(mockObject, Mockito.times(1)).withName(Matchers.eq(name));
    Mockito.verify(mockObject, Mockito.times(1)).withWorkingDir(workingDir);
    Mockito.verify(mockObject, Mockito.times(1)).withNetworkDisabled(disableNetwork);
    Mockito.verify(mockObject, Mockito.times(1)).withHostName(hostname);
    Mockito.verify(mockObject, Mockito.times(1)).withUser(user);
    Mockito.verify(mockObject, Mockito.times(1)).withStdinOpen(stdInOpen);
    Mockito.verify(mockObject, Mockito.times(1)).withStdInOnce(stdInOnce);
    Mockito.verify(mockObject, Mockito.times(1)).withAttachStderr(attachStdErr);
    Mockito.verify(mockObject, Mockito.times(1)).withAttachStdin(attachStdIn);
    Mockito.verify(mockObject, Mockito.times(1)).withAttachStdout(attachStdOut);
    Mockito.verify(mockObject, Mockito.times(1)).withMemory(memoryLimit);
    Mockito.verify(mockObject, Mockito.times(1)).withMemorySwap(swapMemory);
    Mockito.verify(mockObject, Mockito.times(1)).withCpuShares(cpuShares);
    Mockito.verify(mockObject, Mockito.times(1)).withVolumes(volumes);
    Mockito.verify(mockObject, Mockito.times(1)).withVolumesFrom(volumesFromContainer);
    Mockito.verify(mockObject, Mockito.times(1)).withEnv(env);
    Mockito.verify(mockObject, Mockito.times(1)).withCmd(cmd);
    Mockito.verify(mockObject, Mockito.times(1)).withHostConfig(hostConfig);
    Mockito.verify(mockObject, Mockito.times(1)).withCapAdd(capAdd);
    Mockito.verify(mockObject, Mockito.times(1)).withCapDrop(capDrop);
    Mockito.verify(mockObject, Mockito.times(1)).withEntrypoint(entrypoint);
    Mockito.verify(mockObject, Mockito.times(1)).withPortSpecs(portSpecs);
    Mockito.verify(mockObject, Mockito.times(1)).withDns(dns);
    Mockito.verify(mockObject, Mockito.times(1)).withDomainName(domainName);
}

Example 2 with VolumesFrom

use of com.github.dockerjava.api.model.VolumesFrom in project testcontainers-java by testcontainers.

the class GenericContainer method applyConfiguration.

private void applyConfiguration(CreateContainerCmd createCommand) {
    // Set up exposed ports (where there are no host port bindings defined)
    ExposedPort[] portArray = exposedPorts.stream().map(ExposedPort::new).toArray(ExposedPort[]::new);
    createCommand.withExposedPorts(portArray);
    // Set up exposed ports that need host port bindings
    PortBinding[] portBindingArray = portBindings.stream().map(PortBinding::parse).toArray(PortBinding[]::new);
    createCommand.withPortBindings(portBindingArray);
    if (commandParts != null) {
        createCommand.withCmd(commandParts);
    }
    String[] envArray = env.entrySet().stream().map(it -> it.getKey() + "=" + it.getValue()).toArray(String[]::new);
    createCommand.withEnv(envArray);
    Bind[] bindsArray = binds.stream().toArray(Bind[]::new);
    createCommand.withBinds(bindsArray);
    VolumesFrom[] volumesFromsArray = volumesFroms.stream().toArray(VolumesFrom[]::new);
    createCommand.withVolumesFrom(volumesFromsArray);
    Set<Link> allLinks = new HashSet<>();
    Set<String> allLinkedContainerNetworks = new HashSet<>();
    for (Map.Entry<String, LinkableContainer> linkEntries : linkedContainers.entrySet()) {
        String alias = linkEntries.getKey();
        LinkableContainer linkableContainer = linkEntries.getValue();
        Set<Link> links = findLinksFromThisContainer(alias, linkableContainer);
        allLinks.addAll(links);
        if (allLinks.size() == 0) {
            throw new ContainerLaunchException("Aborting attempt to link to container " + linkableContainer.getContainerName() + " as it is not running");
        }
        Set<String> linkedContainerNetworks = findAllNetworksForLinkedContainers(linkableContainer);
        allLinkedContainerNetworks.addAll(linkedContainerNetworks);
    }
    createCommand.withLinks(allLinks.toArray(new Link[allLinks.size()]));
    allLinkedContainerNetworks.remove("bridge");
    if (allLinkedContainerNetworks.size() > 1) {
        logger().warn("Container needs to be on more than one custom network to link to other " + "containers - this is not currently supported. Required networks are: {}", allLinkedContainerNetworks);
    }
    Optional<String> networkForLinks = allLinkedContainerNetworks.stream().findFirst();
    if (networkForLinks.isPresent()) {
        logger().debug("Associating container with network: {}", networkForLinks.get());
        createCommand.withNetworkMode(networkForLinks.get());
    }
    createCommand.withPublishAllPorts(true);
    String[] extraHostsArray = extraHosts.stream().toArray(String[]::new);
    createCommand.withExtraHosts(extraHostsArray);
    if (network != null) {
        createCommand.withNetworkMode(network.getId());
        createCommand.withAliases(this.networkAliases);
    } else if (networkMode != null) {
        createCommand.withNetworkMode(networkMode);
    }
    if (workingDirectory != null) {
        createCommand.withWorkingDir(workingDirectory);
    }
    if (privilegedMode) {
        createCommand.withPrivileged(privilegedMode);
    }
    createContainerCmdModifiers.forEach(hook -> hook.accept(createCommand));
    Map<String, String> labels = createCommand.getLabels();
    labels = new HashMap<>(labels != null ? labels : Collections.emptyMap());
    labels.putAll(DockerClientFactory.DEFAULT_LABELS);
    createCommand.withLabels(labels);
}

Example 3 with VolumesFrom

use of com.github.dockerjava.api.model.VolumesFrom in project camel by apache.

the class DockerProducer method executeCreateContainerRequest.

/**
     * Produce a create container request
     *
     * @param client
     * @param message
     * @return
     */
private CreateContainerCmd executeCreateContainerRequest(DockerClient client, Message message) {
    LOGGER.debug("Executing Docker Create Container Request");
    String image = DockerHelper.getProperty(DockerConstants.DOCKER_IMAGE, configuration, message, String.class);
    ObjectHelper.notNull(image, "Image must be specified");
    CreateContainerCmd createContainerCmd = client.createContainerCmd(image);
    Boolean attachStdErr = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_ERR, configuration, message, Boolean.class);
    if (attachStdErr != null) {
        createContainerCmd.withAttachStderr(attachStdErr);
    }
    Boolean attachStdIn = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_IN, configuration, message, Boolean.class);
    if (attachStdIn != null) {
        createContainerCmd.withAttachStdin(attachStdIn);
    }
    Boolean attachStdOut = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_OUT, configuration, message, Boolean.class);
    if (attachStdOut != null) {
        createContainerCmd.withAttachStdout(attachStdOut);
    }
    Capability[] capAdd = DockerHelper.getArrayProperty(DockerConstants.DOCKER_CAP_ADD, message, Capability.class);
    if (capAdd != null) {
        createContainerCmd.withCapAdd(capAdd);
    }
    Capability[] capDrop = DockerHelper.getArrayProperty(DockerConstants.DOCKER_CAP_DROP, message, Capability.class);
    if (capDrop != null) {
        createContainerCmd.withCapDrop(capDrop);
    }
    String[] cmd = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_CMD, message);
    if (cmd != null) {
        createContainerCmd.withCmd(cmd);
    }
    Integer cpuShares = DockerHelper.getProperty(DockerConstants.DOCKER_CPU_SHARES, configuration, message, Integer.class);
    if (cpuShares != null) {
        createContainerCmd.withCpuShares(cpuShares);
    }
    Boolean disableNetwork = DockerHelper.getProperty(DockerConstants.DOCKER_DISABLE_NETWORK, configuration, message, Boolean.class);
    if (disableNetwork != null) {
        createContainerCmd.withNetworkDisabled(disableNetwork);
    }
    String[] dns = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_DNS, message);
    if (dns != null) {
        createContainerCmd.withDns(dns);
    }
    String domainName = DockerHelper.getProperty(DockerConstants.DOCKER_DOMAIN_NAME, configuration, message, String.class);
    if (domainName != null) {
        createContainerCmd.withDomainName(domainName);
    }
    String[] env = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_ENV, message);
    if (env != null) {
        createContainerCmd.withEnv(env);
    }
    String[] entrypoint = DockerHelper.getArrayProperty(DockerConstants.DOCKER_ENTRYPOINT, message, String.class);
    if (entrypoint != null) {
        createContainerCmd.withEntrypoint(entrypoint);
    }
    ExposedPort[] exposedPorts = DockerHelper.getArrayProperty(DockerConstants.DOCKER_EXPOSED_PORTS, message, ExposedPort.class);
    if (exposedPorts != null) {
        createContainerCmd.withExposedPorts(exposedPorts);
    }
    HostConfig hostConfig = DockerHelper.getProperty(DockerConstants.DOCKER_HOST_CONFIG, configuration, message, HostConfig.class);
    if (hostConfig != null) {
        createContainerCmd.withHostConfig(hostConfig);
    }
    String hostName = DockerHelper.getProperty(DockerConstants.DOCKER_HOSTNAME, configuration, message, String.class);
    if (hostName != null) {
        createContainerCmd.withHostName(hostName);
    }
    Long memoryLimit = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY_LIMIT, configuration, message, Long.class);
    if (memoryLimit != null) {
        createContainerCmd.withMemory(memoryLimit);
    }
    Long memorySwap = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY_SWAP, configuration, message, Long.class);
    if (memorySwap != null) {
        createContainerCmd.withMemorySwap(memorySwap);
    }
    String name = DockerHelper.getProperty(DockerConstants.DOCKER_NAME, configuration, message, String.class);
    if (name != null) {
        createContainerCmd.withName(name);
    }
    String[] portSpecs = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_PORT_SPECS, message);
    if (portSpecs != null) {
        createContainerCmd.withPortSpecs(portSpecs);
    }
    Boolean stdInOpen = DockerHelper.getProperty(DockerConstants.DOCKER_STD_IN_OPEN, configuration, message, Boolean.class);
    if (stdInOpen != null) {
        createContainerCmd.withStdinOpen(stdInOpen);
    }
    Boolean stdInOnce = DockerHelper.getProperty(DockerConstants.DOCKER_STD_IN_ONCE, configuration, message, Boolean.class);
    if (stdInOnce != null) {
        createContainerCmd.withStdInOnce(stdInOnce);
    }
    Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);
    if (tty != null) {
        createContainerCmd.withTty(tty);
    }
    String user = DockerHelper.getProperty(DockerConstants.DOCKER_USER, configuration, message, String.class);
    if (user != null) {
        createContainerCmd.withUser(user);
    }
    Volume[] volume = DockerHelper.getArrayProperty(DockerConstants.DOCKER_VOLUMES, message, Volume.class);
    if (volume != null) {
        createContainerCmd.withVolumes(volume);
    }
    VolumesFrom[] volumesFrom = DockerHelper.getArrayProperty(DockerConstants.DOCKER_VOLUMES_FROM, message, VolumesFrom.class);
    if (volumesFrom != null) {
        createContainerCmd.withVolumesFrom(volumesFrom);
    }
    String workingDir = DockerHelper.getProperty(DockerConstants.DOCKER_WORKING_DIR, configuration, message, String.class);
    if (workingDir != null) {
        createContainerCmd.withWorkingDir(workingDir);
    }
    return createContainerCmd;
}