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); resultCallback.addConsumer(STDOUT, new Slf4jLogConsumer(logger())); resultCallback.addConsumer(STDERR, new Slf4jLogConsumer(logger())); dockerClient.logContainerCmd(containerId).withStdOut(true).withStdErr(true).exec(resultCallback);
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); } } }
/** * Check whether the image is available locally and pull it otherwise */ public void checkAndPullImage(DockerClient client, String image) { List<Image> images = client.listImagesCmd().withImageNameFilter(image).exec(); if (images.isEmpty()) { client.pullImageCmd(image).exec(new PullImageResultCallback()).awaitSuccess(); } }
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); LOGGER.trace("Removing container: {}", containerId); try { dockerClient.removeContainerCmd(containerId).withRemoveVolumes(true).withForce(true).exec(); LOGGER.debug("Removed container and associated volume(s): {}", imageName); } catch (InternalServerErrorException e) {
public void startContainer(String id, CubeContainer containerConfiguration) { this.readWriteLock.readLock().lock(); try { StartContainerCmd startContainerCmd = this.dockerClient.startContainerCmd(id); startContainerCmd.exec(); } finally { this.readWriteLock.readLock().unlock(); } }
public void removeContainer(String containerId, boolean removeVolumes) { this.readWriteLock.readLock().lock(); try { this.dockerClient.removeContainerCmd(containerId).withRemoveVolumes(removeVolumes).exec(); } finally { this.readWriteLock.readLock().unlock(); } }
public void stopContainer(String containerId) { this.readWriteLock.readLock().lock(); try { this.dockerClient.stopContainerCmd(containerId).exec(); } finally { this.readWriteLock.readLock().unlock(); } }
public List<Container> listRunningContainers() { this.readWriteLock.readLock().lock(); try { return this.dockerClient.listContainersCmd().exec(); } finally { this.readWriteLock.readLock().unlock(); } }
public void execStartDetached(String containerId, String... commands) { this.readWriteLock.readLock().lock(); try { String id = execCreate(containerId, commands); this.dockerClient.execStartCmd(id).withDetach(true).exec(new ExecStartResultCallback()); } finally { this.readWriteLock.readLock().unlock(); } }
private String dockerRun(String imageId) { String containerId = dockerClient.createContainerCmd(imageId).exec().getId(); dockerClient.startContainerCmd(containerId).exec(); return containerId; }
.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());
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(); }
@Test @DisplayName("start a container after pulling the image") 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); }
protected InspectContainerResponse.ContainerState getCurrentState(DockerClient dockerClient, String containerId) { return dockerClient.inspectContainerCmd(containerId).exec().getState(); }
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(); }
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()); } }
@Override protected CreateContainerCmd dockerCommand() { return DockerClientFactory.build() .createContainerCmd(config.getImageName() + ":" + config.getImageTag()) .withEnv(newEnvironment() .withValues(getMesosDNSEnvVars()) .createEnvironment()) .withCmd("-v=2", "-config=/etc/mesos-dns/config.json") .withExposedPorts(new ExposedPort(Integer.valueOf(DNS_PORT), InternetProtocol.UDP), new ExposedPort(Integer.valueOf(DNS_PORT), InternetProtocol.TCP)) .withName(getName()); }
public String createContainer(String image, String... command){ CreateContainerResponse container = dockerClient .createContainerCmd(image) .withCmd(command) .exec(); return container.getId(); }
@Override protected CreateContainerCmd dockerCommand() { return DockerClientFactory.build().createContainerCmd(config.getImageName() + ":" + config.getImageTag()) .withNetworkMode("host") .withBinds(Bind.parse("/var/run/docker.sock:/tmp/docker.sock")) .withCmd("-internal", String.format("consul://%s:%d", consul.getIpAddress(), ConsulConfig.CONSUL_HTTP_PORT)) .withName(getName()); }