Refine search
private <T> T runInsideDocker(DockerClient client, Consumer<CreateContainerCmd> createContainerCmdConsumer, BiFunction<DockerClient, String, T> block) { checkAndPullImage(client, TINY_IMAGE); CreateContainerCmd createContainerCmd = client.createContainerCmd(TINY_IMAGE) .withLabels(DEFAULT_LABELS); createContainerCmdConsumer.accept(createContainerCmd); String id = createContainerCmd.exec().getId(); try { client.startContainerCmd(id).exec(); return block.apply(client, id); } finally { try { client.removeContainerCmd(id).withRemoveVolumes(true).withForce(true).exec(); } catch (NotFoundException | InternalServerErrorException ignored) { log.debug("", ignored); } } }
private void applyConfiguration(CreateContainerCmd createCommand) { HostConfig hostConfig = buildHostConfig(); createCommand.withHostConfig(hostConfig); createCommand.withExposedPorts(portArray); createCommand.withPortBindings(portBindingArray); createCommand.withCmd(commandParts); .map(it -> it.getKey() + "=" + it.getValue()) .toArray(String[]::new); createCommand.withEnv(envArray); createCommand.withBinds(bindsArray); createCommand.withVolumesFrom(volumesFromsArray); createCommand.withLinks(allLinks.toArray(new Link[allLinks.size()])); if (networkForLinks.isPresent()) { logger().debug("Associating container with network: {}", networkForLinks.get()); createCommand.withNetworkMode(networkForLinks.get()); createCommand.withPublishAllPorts(true); createCommand.withExtraHosts(extraHostsArray); createCommand.withNetworkMode(network.getId()); createCommand.withAliases(this.networkAliases);
Info dockerInfo = client.infoCmd().exec(); Version version = client.versionCmd().exec(); activeApiVersion = version.getApiVersion(); activeExecutionDriver = dockerInfo.getExecutionDriver(); client, createContainerCmd -> { createContainerCmd.withName("testcontainers-checks-" + SESSION_ID); createContainerCmd.getHostConfig().withAutoRemove(true); createContainerCmd.withCmd("tail", "-f", "/dev/null"); }, (__, containerId) -> {
public SocatContainer() { super(TestcontainersConfiguration.getInstance().getSocatContainerImage()); withCreateContainerCmdModifier(it -> it.withEntrypoint("/bin/sh")); withCreateContainerCmdModifier(it -> it.withName("testcontainers-socat-" + Base58.randomString(8))); }
CreateContainerCmd createContainerCmd = this.dockerClient.createContainerCmd(image); createContainerCmd.withName(name); createContainerCmd.withExposedPorts(allExposedPorts.toArray(new ExposedPort[numberOfExposedPorts])); createContainerCmd.withReadonlyRootfs(containerConfiguration.getReadonlyRootfs()); createContainerCmd.withLabels(containerConfiguration.getLabels()); createContainerCmd.withWorkingDir(containerConfiguration.getWorkingDir()); createContainerCmd.withNetworkDisabled(containerConfiguration.getDisableNetwork()); createContainerCmd.withHostName(containerConfiguration.getHostName()); createContainerCmd.withPortSpecs(containerConfiguration.getPortSpecs().toArray(new String[0])); createContainerCmd.withUser(containerConfiguration.getUser()); createContainerCmd.withTty(containerConfiguration.getTty()); createContainerCmd.withStdinOpen(containerConfiguration.getStdinOpen()); createContainerCmd.withStdInOnce(containerConfiguration.getStdinOnce()); createContainerCmd.withMemory(containerConfiguration.getMemoryLimit()); createContainerCmd.withMemorySwap(containerConfiguration.getMemorySwap());
@Test public void testWithAContainerWithLabels() throws InterruptedException { Map<String, String> labels = new LinkedHashMap<>(); labels.put("service.type", "http-endpoint"); labels.put("ssl", "true"); CreateContainerResponse container = client.createContainerCmd("nginx") .withExposedPorts(ExposedPort.tcp(80), ExposedPort.tcp(443)) .withPortBindings(PortBinding.parse("80")) .withLabels(labels) .exec(); AtomicBoolean done = new AtomicBoolean(); Future<Void> future = Future.future(); future.setHandler(ar -> done.set(ar.succeeded())); bridge.scan(future); await().untilAtomic(done, is(true)); assertThat(bridge.getServices()).hasSize(0); done.set(false); client.startContainerCmd(container.getId()).exec(); Future<Void> future2 = Future.future(); future2.setHandler(ar -> done.set(ar.succeeded())); bridge.scan(future2); await().untilAtomic(done, is(true)); assertThat(bridge.getServices()).hasSize(1); DockerService service = bridge.getServices().get(0); assertThat(service.records()).hasSize(1); assertThat(service.records().get(0).getLocation().getString("endpoint")).startsWith("https"); }
log.debug("Turn Server {}", kmsTurnIp); createContainerCmd = dockerClient.getClient().createContainerCmd(kmsImageName).withName(dockerContainerName) .withEnv("GST_DEBUG=" + getDebugOptions(), "S3_ACCESS_BUCKET_NAME=" + s3BucketName, "S3_ACCESS_KEY_ID=" + s3AccessKeyId, "S3_SECRET_ACCESS_KEY=" + s3SecretAccessKey, "S3_HOSTNAME=" + s3Hostname, "KMS_TURN_URL=" + kmsTurnIp, "KURENTO_GENERATE_RTP_PTS_STATS=" + getKurentoGenerateRtpPtsStats()) .withCmd("--gst-debug-no-color").withVolumes(new Volume("/var/run/docker.sock")); } else { if (kmsDnat && seleniumDnat && RELAY.toString().toUpperCase().equals(seleniumCandidateType) dockerClient.getClient().createContainerCmd(kmsImageName).withName(dockerContainerName) .withEnv("GST_DEBUG=" + getDebugOptions(), "S3_ACCESS_BUCKET_NAME=" + s3BucketName, "S3_ACCESS_KEY_ID=" + s3AccessKeyId, "S3_SECRET_ACCESS_KEY=" + s3SecretAccessKey, "S3_HOSTNAME=" + s3Hostname, "KMS_STUN_IP=" + kmsStunIp, "KMS_STUN_PORT=" + kmsStunPort, "KURENTO_GENERATE_RTP_PTS_STATS=" + getKurentoGenerateRtpPtsStats()) .withCmd("--gst-debug-no-color").withVolumes(new Volume("/var/run/docker.sock")); createContainerCmd.withVolumesFrom(new VolumesFrom(dockerClient.getContainerId())); } else { String testFilesPath = KurentoTest.getTestFilesDiskPath(); Paths.get(KurentoTest.getDefaultOutputFolder().toURI()).toAbsolutePath().toString(); Volume volumeTest = new Volume(targetPath); createContainerCmd.withVolumes(volume, volumeTest).withBinds( new Bind(testFilesPath, volume, AccessMode.ro), new Bind(targetPath, volumeTest, AccessMode.rw));
CreateContainerCmd cfgCmd = client.createContainerCmd(imageRes); if (commandRes != null) { cfgCmd.withCmd(commandRes); cfgCmd.withHostName(hostNameRes); cfgCmd.withName(containerNameRes); HostConfig hc = new HostConfig(); cfgCmd.withLinks(LinkUtils.parseLinks(linksRes).getLinks()); if (envVarsRes != null) { cfgCmd.withEnv(envVarsRes); cfgCmd.withExposedPorts(ports); cfgCmd.withCpuShares(cpuSharesRes); cfgCmd.withMemory(memoryLimitRes); cfgCmd.withDns(dnsRes); cfgCmd.withExtraHosts(extraHostsRes); cfgCmd.withPortBindings(PortBindingParser.parse(portBindingsRes)); cfgCmd.withBinds(BindParser.parse(bindMountsRes)); cfgCmd.withRestartPolicy(RestartPolicy.alwaysRestart()); CreateContainerResponse resp = cfgCmd.withPublishAllPorts(publishAllPorts).withPrivileged(privileged).exec(); InspectContainerResponse inspectResp = client.inspectContainerCmd(resp.getId()).exec();
CreateContainerResponse container = dockerClient.createContainerCmd(image.getName()) .withEnv(containerConfig.getEnv()) .withExposedPorts(exposedPorts) .withCmd(containerConfig.getCmd()) .withAttachStderr(containerConfig.isAttachStderr()) .withAttachStdin(containerConfig.isAttachStdin()) .withAttachStdout(containerConfig.isAttachStdout()) .withCpuShares(containerConfig.getCpuShares()) .withDisableNetwork(containerConfig.isNetworkDisabled()) .withWorkingDir(containerConfig.getWorkingDir()) .withMemoryLimit(containerConfig.getMemoryLimit()) .withMemorySwap(containerConfig.getMemorySwap()) .withHostName(containerConfig.getHostName()) .withUser(containerConfig.getUser()) .withPortSpecs(containerConfig.getPortSpecs()) .withStdinOpen(containerConfig.isStdinOpen()) .withTty(containerConfig.isTty()).exec(); dockerClient.startContainerCmd(container.getId()) .withPortBindings(hostConfig.getPortBindings()) .withPublishAllPorts(hostConfig.isPublishAllPorts()) .exec(); DockerRegistry.getInstance().register(new ContainerHolder(getDockerUrl(), image.getName(), container.getId()));
.createContainerCmd(imageName) .withWorkingDir(workingDir) .withCmd(command) .withBinds(volumeBinds.entrySet().stream() .map(e -> new Bind(e.getKey(), new Volume(e.getValue()))) .collect(toList()) .exec(); if (fr.getBytes() != null) stdoutConsumer.accept(fr.getUtf8String().trim()); }); dockerClient.startContainerCmd(exec.getId()).exec(); dockerClient.logContainerCmd(exec.getId()).withFollowStream(true).withStdErr(true).withStdOut(true).exec(callback); while (dockerClient.inspectContainerCmd(exec.getId()).exec().getState().getRunning()) { try { Thread.sleep(300);
private String createNewContainer(Id id) throws DockerException { CreateContainerCmd cmd = docker.createContainerCmd(findImageId(id)); cmd.withPublishAllPorts(true); cmd.withPrivileged(conf.isPrivileged()); cmd.withNetworkMode(conf.getNetworkMode()); cmd.withLinks(links); cmd.withVolumesFrom(volumesFrom); new ExposedPort(containerPort, InternetProtocol.TCP))); cmd.withPortBindings(portBindings.toArray(new PortBinding[portBindings.size()])); cmd.withVolumes(volumes.toArray(new Volume[volumes.size()])); cmd.withBinds(binds.toArray(new Bind[binds.size()])); cmd.withHostName(conf.getHostname()); cmd.withName(repo.containerName(id)); logger.info(" - env " + conf.getEnv()); cmd.withEnv(asEnvList(conf.getEnv())); cmd.withExtraHosts(extraHosts.toArray(new String[extraHosts.size()])); logger.info(" - extra hosts " + conf.getExtraHosts()); final CreateContainerResponse createResponse = cmd.exec();
.createContainerCmd(image) .withBinds(new Bind(repoPath.toString(), volume), new Bind(Paths.get(repoPath.getParent().toString(), REPOSITORY).toString(), mvnVolume)) .withWorkingDir(File.separator + fileName) .withCmd(BASH, "-c", cmd) .withTty(true) .exec(); docker.startContainerCmd(container.getId()).exec(); .logContainerCmd(container.getId()) .withStdErr(true) .withStdOut(true) .waitContainerCmd(container.getId()) .exec(new WaitContainerResultCallback()) .awaitStatusCode();
public void startNode(String id, BrowserType browserType, String nodeName, String imageId, boolean record, String containerIp) { // Create node pullImageIfNecessary(imageId, true); log.debug("Creating container for browser '{}'", id); CreateContainerCmd createContainerCmd = getClient().createContainerCmd(imageId).withPrivileged(true).withCapAdd(SYS_ADMIN).withName(nodeName); mountDefaultFolders(createContainerCmd); mountFiles(createContainerCmd); createContainerCmd.withNetworkMode("none"); Map<String, String> labels = new HashMap<>(); labels.put("KurentoDnat", "true"); labels.put("Transport", getProperty(TEST_SELENIUM_TRANSPORT)); labels.put("IpAddress", containerIp); createContainerCmd.withLabels(labels); createContainerCmd.exec(); log.debug("Container {} started...", nodeName); // Start node if stopped startContainer(nodeName); startRecordingIfNeeded(id, nodeName, record); logMounts(nodeName); logNetworks(nodeName); }
log.info("Pulling image " + imageId, context); try { connection.getDockerClient().pullImageCmd(imageId).withTag(tag).exec(new PullImageResultCallback()).awaitCompletion(); } catch (InterruptedException e) { throw new InvalidOperationExecutionException("Pull interrupted", e); log.info("Using local image " + imageId, context); CreateContainerCmd createContainerCmd = connection.getDockerClient().createContainerCmd(imageId + ":" + tag) .withStdinOpen((Boolean) getProperty("interactive", true)) .withName(DockerUtil.normalizeResourceName(config.getDeploymentName() + "_" + getId())) .withExposedPorts(exposedPorts.toArray(new ExposedPort[exposedPorts.size()])) .withPortBindings(portBindings); if (volumes != null && !volumes.isEmpty()) { createContainerCmd.withBinds(volumes.stream().map(volume -> new Bind(volume.getVolumeId(), new com.github.dockerjava.api.model.Volume(volume.getLocation()))).collect(Collectors.toList())); createContainerCmd.withEnv(envs); createContainerCmd.withCmd(commands); containerId = createContainerCmd.exec().getId(); log.info("Created container with id " + containerId, context);
createContainerCmd.withAttachStderr(attachStdErr); createContainerCmd.withAttachStdin(attachStdIn); createContainerCmd.withAttachStdout(attachStdOut); createContainerCmd.withCapAdd(capAdd); createContainerCmd.withCapDrop(capDrop); createContainerCmd.withCmd(cmd); createContainerCmd.withCpuShares(cpuShares); createContainerCmd.withNetworkDisabled(disableNetwork); createContainerCmd.withDns(dns); createContainerCmd.withDomainName(domainName); createContainerCmd.withEnv(env); createContainerCmd.withEntrypoint(entrypoint); createContainerCmd.withExposedPorts(exposedPorts); createContainerCmd.withHostConfig(hostConfig); createContainerCmd.withHostName(hostName);
client.createContainerCmd(config.getImageName()) .withPortBindings(ports) .withLxcConf(new LxcConf("icc", "false")) .withEnv(EnvironmentVar.asEnvVars(config.getEnvVars())); createContainerCmd.withCmd(config.getArguments().split(" ")); createContainerCmd.withName(config.getContainerName()); final PullImageResultCallback pullImageResultCallback = new PullImageResultCallback(); final PullImageCmd pullImageCmd = client.pullImageCmd(config.getImageName()); final CreateContainerResponse containerResponse = createContainerCmd.exec(); client.startContainerCmd(containerResponse.getId()).exec(); logger.info("Starting container id " + containerResponse.getId() + ", " + config.getImageName()); logger.info("Container id " + containerResponse.getId() + " ready");
LogConfig containerLog = new LogConfig(LogConfig.LoggingType.DEFAULT, containerLogConfig); CreateContainerCmd cmd = dockerClient.createContainerCmd(microservice.getImageName()) .withLogConfig(containerLog) .withCpusetCpus("0") .withExposedPorts(exposedPorts.toArray(new ExposedPort[0])) .withPortBindings(portBindings) .withEnv("SELFNAME=" + microservice.getMicroserviceUuid()) .withName(Constants.IOFOG_DOCKER_CONTAINER_NAME_PREFIX + microservice.getMicroserviceUuid()) .withRestartPolicy(restartPolicy); if (microservice.getVolumeMappings() != null) { cmd = cmd .withVolumes(volumes.toArray(new Volume[volumes.size()])) .withBinds(volumeBindings.toArray(new Bind[volumeBindings.size()])); ? cmd.withNetworkMode("host").withExtraHosts(extraHosts).withPrivileged(true) : cmd.withExtraHosts(extraHosts).withPrivileged(true); } else if (SystemUtils.IS_OS_LINUX || SystemUtils.IS_OS_MAC) { cmd = microservice.isRootHostAccess() ? cmd.withNetworkMode("host").withPrivileged(true) : cmd.withExtraHosts(extraHosts).withPrivileged(true); CreateContainerResponse resp = cmd.exec(); return resp.getId();
private void startContainer(Map<String, String> env, Map<Integer, Integer> ports, Map<String, String> cmd, Consumer<String> log) { final CreateContainerResponse container = client.createContainerCmd(image) .withCmd(cmd.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(toList())) .withLabels(map(label, "true")) .withEnv(env.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(toList())) .withPortBindings(ports.entrySet().stream().map(e -> new PortBinding(Ports.Binding.bindPort(e.getKey()), ExposedPort.tcp(e.getValue()))).collect(toList())) .exec(); client.startContainerCmd(container.getId()).exec(); client.logContainerCmd(container.getId()).withFollowStream(true).withStdOut(true).withStdErr(true).exec( new LogContainerResultCallback() { public void onNext(Frame frame) { final String msg = new String(frame.getPayload()); log.accept(msg.endsWith("\n") ? msg.substring(0, msg.length() - 1) : msg); } }); } }
CreateContainerCmd createCommand = dockerClient.createContainerCmd(dockerImageName); applyConfiguration(createCommand); containerId = createCommand.exec().getId(); connectToPortForwardingNetwork(createCommand.getNetworkMode()); dockerClient.startContainerCmd(containerId).exec(); containerInfo = dockerClient.inspectContainerCmd(containerId).exec(); containerName = containerInfo.getName(); containerIsStarting(containerInfo);
final CreateContainerCmd createContainerCmd = Docker.CLIENT .createContainerCmd(imageNameWithVer) .withName(imageName().replace('/', '_') + '_' + this.hashCode()) .withExposedPorts(exposedPorts) .withCmd(args); if (env != null && !env.isEmpty()) { createContainerCmd.withEnv(env); createContainerCmd.withAttachStdout(attachOutputFlag).withAttachStderr(attachOutputFlag); binds.add(bind); }); createContainerCmd.withVolumes(volumes); hostConfig.withBinds(binds); createContainerCmd.withHostConfig(hostConfig); final String entrypoint = entrypoint(); if (entrypoint != null && !entrypoint.isEmpty()) { createContainerCmd.withEntrypoint(entrypoint); final CreateContainerResponse container = createContainerCmd.exec(); return container.getId();