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

Example 1 with Volume

use of com.github.dockerjava.api.model.Volume 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 Volume

use of com.github.dockerjava.api.model.Volume in project elastest-torm by elastest.

the class DockerComposeService method setup.

public void setup() throws IOException, InterruptedException {
    // 1. Start docker-compose-ui container
    dockerComposeUiContainerName = dockerService.generateContainerName(dockerComposeUiPrefix);
    int dockerComposeBindPort = dockerService.findRandomOpenPort();
    Binding bindNoVncPort = bindPort(dockerComposeBindPort);
    ExposedPort exposedNoVncPort = tcp(dockerComposeUiPort);
    String dockerComposeServiceUrl = "http://" + dockerService.getDockerServerIp() + ":" + dockerComposeBindPort;
    log.debug("Starting docker-compose-ui container: {}", dockerComposeUiContainerName);
    List<PortBinding> portBindings = asList(new PortBinding(bindNoVncPort, exposedNoVncPort));
    Volume volume = new Volume(dockerDefaultSocket);
    List<Volume> volumes = asList(volume);
    List<Bind> binds = asList(new Bind(dockerDefaultSocket, volume));
    DockerBuilder dockerBuilder = dockerBuilder(dockerComposeUiImageId, dockerComposeUiContainerName).portBindings(portBindings).volumes(volumes).binds(binds);
    dockerService.startAndWaitContainer(dockerBuilder.build());
    // 2. Create Retrofit object to call docker-compose-ui REST API
    OkHttpClient okHttpClient = new OkHttpClient.Builder().readTimeout(dockerComposeTimeout, SECONDS).connectTimeout(dockerComposeTimeout, SECONDS).build();
    Retrofit retrofit = new Retrofit.Builder().client(okHttpClient).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).addConverterFactory(GsonConverterFactory.create()).baseUrl(dockerComposeServiceUrl).build();
    dockerComposeApi = retrofit.create(DockerComposeApi.class);
    log.debug("docker-compose-ui up and running on URL: {}", dockerComposeServiceUrl);
    // 3.Delete default example projects
    dockerService.waitForHostIsReachable(dockerComposeServiceUrl);
    String[] defaultProjects = { "env-demo", "hello-node", "node-redis", "volumes-demo", "volumes-relative-paths" };
    removeProjects(defaultProjects);
}

Example 3 with Volume

use of com.github.dockerjava.api.model.Volume in project elastest-torm by elastest.

the class DockerService2 method startDockbeat.

public void startDockbeat(DockerExecution dockerExec) throws TJobStoppedException {
    TJobExecution tJobExec = dockerExec.gettJobexec();
    TJob tJob = tJobExec.getTjob();
    Long execution = dockerExec.getExecutionId();
    String containerName = getDockbeatContainerName(dockerExec);
    // Environment variables
    ArrayList<String> envList = new ArrayList<>();
    String envVar;
    // Get Parameters and insert into Env Vars¡
    String lsHostEnvVar = "LOGSTASHHOST" + "=" + logstashHost;
    if (tJob.isSelectedService("ems")) {
        envVar = "FILTER_CONTAINERS" + "=" + "\"^sut\\d*_.*_" + execution + "|^test\\d*_.*_" + execution + "\"";
        envList.add(envVar);
        // envVar = "FILTER_EXCLUDE" + "=" + "\"\"";
        // envList.add(envVar);
        envVar = "LOGSTASHPORT" + "=" + tJobExec.getEnvVars().get("ET_EMS_LSBEATS_PORT");
        envList.add(envVar);
        lsHostEnvVar = "LOGSTASHHOST" + "=" + tJobExec.getEnvVars().get("ET_EMS_LSBEATS_HOST");
    }
    envList.add(lsHostEnvVar);
    // dockerSock
    Volume volume1 = new Volume(dockerSock);
    // Pull Image
    this.pullETExecImage(dockbeatImage, "Dockbeat");
    // Create Container
    logger.debug("Creating Dockbeat Container...");
    CreateContainerResponse container = dockerExec.getDockerClient().createContainerCmd(dockbeatImage).withEnv(envList).withName(containerName).withBinds(new Bind(dockerSock, volume1)).withNetworkMode(dockerExec.getNetwork()).exec();
    dockerExec.getDockerClient().startContainerCmd(container.getId()).exec();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
    this.insertCreatedContainer(container.getId(), containerName);
}

Example 4 with Volume

use of com.github.dockerjava.api.model.Volume in project elastest-torm by elastest.

the class DockerService2 method createContainer.

public CreateContainerResponse createContainer(DockerExecution dockerExec, String type) throws TJobStoppedException {
    TJobExecution tJobExec = dockerExec.gettJobexec();
    TJob tJob = tJobExec.getTjob();
    SutSpecification sut = tJob.getSut();
    String image = "";
    String commands = null;
    List<Parameter> parametersList = new ArrayList<Parameter>();
    String prefix = "";
    String suffix = "";
    String containerName = "";
    int logPort = 5000;
    String sutHost = null;
    String sutPath = null;
    if ("sut".equals(type.toLowerCase())) {
        parametersList = sut.getParameters();
        commands = sut.getCommands();
        image = sut.getSpecification();
        prefix = "sut_";
        if (sut.isSutInNewContainer()) {
            suffix = sut.getSutInContainerAuxLabel();
        }
        containerName = getSutName(dockerExec);
        sutPath = filesService.buildFilesPath(tJobExec, ElastestConstants.SUT_FOLDER);
        filesService.createExecFilesFolder(sutPath);
    } else if ("tjob".equals(type.toLowerCase())) {
        parametersList = tJobExec.getParameters();
        commands = tJob.getCommands();
        image = tJob.getImageName();
        prefix = "test_";
        containerName = getTestName(dockerExec);
        if (dockerExec.isWithSut()) {
            sutHost = dockerExec.getSutExec().getIp();
        }
    }
    // Environment variables (optional)
    ArrayList<String> envList = new ArrayList<>();
    String envVar;
    // Get TJob Exec Env Vars
    for (Map.Entry<String, String> entry : dockerExec.gettJobexec().getEnvVars().entrySet()) {
        envVar = entry.getKey() + "=" + entry.getValue();
        envList.add(envVar);
    }
    // Get Parameters and insert into Env Vars
    for (Parameter parameter : parametersList) {
        envVar = parameter.getName() + "=" + parameter.getValue();
        envList.add(envVar);
    }
    if (sutHost != null) {
        envList.add("ET_SUT_HOST=" + dockerExec.getSutExec().getIp());
    }
    // Commands (optional)
    ArrayList<String> cmdList = new ArrayList<>();
    ArrayList<String> entrypointList = new ArrayList<>();
    if (commands != null && !commands.isEmpty()) {
        cmdList.add("-c");
        if (sut != null) {
            if (sut.isSutInNewContainer()) {
                commands = sutPath != null ? ("cd " + sutPath + ";" + commands) : commands;
            }
        } else {
            commands = "export ET_SUT_HOST=$(" + this.getThisContainerIpCmd + ") || echo;" + commands;
        }
        cmdList.add(commands);
        entrypointList.add("/bin/sh");
    }
    // Load Log Config
    LogConfig logConfig = null;
    if (tJob.isSelectedService("ems")) {
        try {
            logConfig = getEMSLogConfig(type, prefix, suffix, dockerExec);
        } catch (Exception e) {
            logger.error("", e);
        }
    } else {
        logConfig = getDefaultLogConfig(logPort, prefix, suffix, dockerExec);
    }
    // Pull Image
    this.pullETExecImage(image, type);
    // Create docker sock volume
    Volume dockerSockVolume = new Volume(dockerSock);
    CreateContainerCmd containerCmd = dockerExec.getDockerClient().createContainerCmd(image).withEnv(envList).withLogConfig(logConfig).withName(containerName).withCmd(cmdList).withEntrypoint(entrypointList).withNetworkMode(dockerExec.getNetwork());
    Volume sharedDataVolume = null;
    if (dockerExec.gettJobexec().getTjob().getSut() != null && dockerExec.gettJobexec().getTjob().getSut().isSutInNewContainer()) {
        sharedDataVolume = new Volume(sharedFolder);
    }
    if (sharedDataVolume != null) {
        containerCmd = containerCmd.withVolumes(dockerSockVolume, sharedDataVolume).withBinds(new Bind(dockerSock, dockerSockVolume), new Bind(sharedFolder, sharedDataVolume));
    } else {
        containerCmd = containerCmd.withVolumes(dockerSockVolume).withBinds(new Bind(dockerSock, dockerSockVolume));
    }
    // Create Container
    return containerCmd.exec();
}

Example 5 with Volume

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

the class GenericContainer method addFileSystemBind.

/**
 * {@inheritDoc}
 */
@Override
public void addFileSystemBind(final String hostPath, final String containerPath, final BindMode mode, final SelinuxContext selinuxContext) {
    final MountableFile mountableFile = MountableFile.forHostPath(hostPath);
    binds.add(new Bind(mountableFile.getResolvedPath(), new Volume(containerPath), mode.accessMode, selinuxContext.selContext));
}