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); } } }
this.readWriteLock.readLock().lock(); CreateContainerCmd createContainerCmd = this.dockerClient.createContainerCmd(image); createContainerCmd.withName(name); createContainerCmd.withExposedPorts(allExposedPorts.toArray(new ExposedPort[numberOfExposedPorts])); createContainerCmd.withReadonlyRootfs(containerConfiguration.getReadonlyRootfs()); return createContainerCmd.exec().getId(); } catch (NotFoundException e) { if (!alwaysPull) { "Docker Image %s is not on DockerHost and it is going to be automatically pulled.", image)); this.pullImage(image); return createContainerCmd.exec().getId(); } else { throw e; return createContainerCmd.exec().getId(); } else { throw e;
@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, CreateContainerResponse kmsContainer = createContainerCmd.exec(); dockerClient.getClient().startContainerCmd(kmsContainer.getId()).exec(); } else { CreateContainerResponse kmsContainer = createContainerCmd.exec(); dockerClient.getClient().startContainerCmd(kmsContainer.getId()).exec(); kmsAddress = dockerClient.inspectContainer(dockerContainerName).getNetworkSettings()
public String call() throws Exception { DockerClient client = DockerCommand.getClient(descriptor, cfgData.dockerUrlRes, cfgData.dockerVersionRes, cfgData.dockerCertPathRes, null); 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()); 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()) .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(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(); docker.removeContainerCmd(container.getId()).exec(); if (exitCode != 0) { throw new PluginException("Build Project Error ExitCode: " + exitCode); docker.removeContainerCmd(container.getId()); log.error("Docker build error ", e); throw new PluginException("Docker build error " + e.getMessage());
.createContainerCmd(imageName) .withWorkingDir(workingDir) .withCmd(command) .withBinds(volumeBinds.entrySet().stream() .map(e -> new Bind(e.getKey(), new Volume(e.getValue()))) .collect(toList()) 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); return dockerClient.inspectContainerCmd(exec.getId()).exec().getState().getExitCode(); } finally { dockerClient.removeContainerCmd(exec.getId()).exec();
private String createNewContainer(Id id) throws DockerException { CreateContainerCmd cmd = docker.createContainerCmd(findImageId(id)); cmd.withPublishAllPorts(true); cmd.withPrivileged(conf.isPrivileged()); cmd.withNetworkMode(conf.getNetworkMode()); final CreateContainerResponse createResponse = cmd.exec(); final String[] warnings = createResponse.getWarnings(); if (warnings != null) { for (final String warning : warnings) { final String returnId = createResponse.getId();
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);
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.withCmd(commands); containerId = createContainerCmd.exec().getId(); log.info("Created container with id " + containerId, context);
client.createContainerCmd(config.getImageName()) .withPortBindings(ports) .withLxcConf(new LxcConf("icc", "false")) .withEnv(EnvironmentVar.asEnvVars(config.getEnvVars())); 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()) 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); } }); } }
final CreateContainerCmd createContainerCmd = Docker.CLIENT .createContainerCmd(imageNameWithVer) .withName(imageName().replace('/', '_') + '_' + this.hashCode()) .withExposedPorts(exposedPorts) .withCmd(args); if (env != null && !env.isEmpty()) { createContainerCmd.withEnv(env); final CreateContainerResponse container = createContainerCmd.exec(); return container.getId();
protected void createContainer(DockerClient dockerClient) throws InterruptedException { pullImage(dockerClient); CreateContainerCmd createContainerCmd = dockerClient.createContainerCmd(properties.getDockerImage()) // NOSONAR .withLabels(getAllLabels()) .withEnv(getEnvs()) .withHostConfig(buildHostConfig()); adjustCreateCommand(createContainerCmd); String containerId = createContainerCmd.exec().getId(); dockerClient.startContainerCmd(containerId).exec(); containerInfo = dockerClient.inspectContainerCmd(containerId).exec(); }
public String createContainer(String image, String... command){ CreateContainerResponse container = dockerClient .createContainerCmd(image) .withCmd(command) .exec(); return container.getId(); }
CreateContainerResponse container = this.dockerClient.createContainerCmd(this.containerImage) .withHostConfig(hostConfig) .withExposedPorts(port) .withEnv(env) .exec(); this.dockerClient.startContainerCmd(container.getId()).exec(); return container;
private String createContainer(String wantedImage, Ports bindings, List<String> environmentStrings) { String imageWithVersion = wantedImage; if (!imageWithVersion.contains(":")) { imageWithVersion += ":latest"; } this.ensureImageExists(imageWithVersion); return dockerClient.createContainerCmd(imageWithVersion) .withEnv(environmentStrings) .withPortBindings(bindings) .exec().getId(); }
@Override public String createVM( String messagingIp, String messagingUsername, String messagingPassword, String rootInstanceName, String applicationName ) throws IaasException { CreateContainerResponse container = this.docker .createContainerCmd(this.machineImageId) .withCmd("/etc/rc.local", applicationName, rootInstanceName, messagingIp, messagingUsername, messagingPassword) .exec(); this.docker.startContainerCmd(container.getId()).exec(); //this.docker.waitContainerCmd(container.getId()).exec(); return container.getId(); }