docker.pull(image); listener.pulled(); log.info("Pulled image {} in {}s", image, pullTime.elapsed(SECONDS));
try { if (pullNewerImage || !imageExistLocally(dockerClient, image)) { dockerClient.pull(image);
dockerClient.pull(imageToPull, new AnsiProgressHandler());
@Override public Void call() throws Exception { dockerClient.pull(imageName); return null; } };
private void startContainer(final String name) throws DockerException, InterruptedException { docker.pull(BUSYBOX); final HostConfig hostConfig = HostConfig.builder().build(); final ContainerConfig config = ContainerConfig.builder() .image(BUSYBOX) .cmd(IDLE_COMMAND) .hostConfig(hostConfig) .build(); final ContainerCreation creation = docker.createContainer(config, name); final String containerId = creation.id(); docker.startContainer(containerId); } }
final String expose = port + "/udp"; docker.pull(ALPINE);
DockerInstanceBuilder(String imageName) { this.imageName = imageName; this.imageStrategy = (client) -> client.pull(imageName); }
private void pullContainer(DockerClient docker) { try { if (!findImage(docker, COUCHBASE_LATEST_IMAGE_NAME).isPresent()) { docker.pull(COUCHBASE_LATEST_IMAGE_NAME); } } catch (DockerException | InterruptedException e) { throw new EnvironmentBuilderException("Unable to pull container: " + COUCHBASE_LATEST_IMAGE_NAME, e); } }
private void pullContainer() { try { if (!findImage().isPresent()) { dockerClient.pull(imageName); } } catch (DockerException | InterruptedException e) { throw new EnvironmentBuilderException("Unable to pull container: " + imageName, e); } }
private void createImage(DockerImage image) throws DockerException { try { try { dockerClient.inspectImage(image.name()); } catch (ImageNotFoundException e) { logger.info(String.format("Image %s is absent, try pulling it", image.name())); dockerClient.pull(image.name()); } } catch (InterruptedException e) { logger.error("", e); } }
DockerRule(DockerRuleParams params) { this.params = params; dockerClient = createDockerClient(); ContainerConfig containerConfig = createContainerConfig(params.imageName, params.ports, params.cmd); try { if (!params.isLocalImage) { dockerClient.pull(params.imageName); } container = dockerClient.createContainer(containerConfig); } catch (DockerException | InterruptedException e) { throw new IllegalStateException(e); } }
private void pullImage() throws DockerException, InterruptedException { // equivalent to "docker pull" final long startTime = System.currentTimeMillis(); final String image = containerConfig.image(); try { boolean found = false; try { client.inspectImage(image); LOGGER.info("Docker image already exists: {}", image); found = true; } catch (final ImageNotFoundException e) { found = false; } if (config.isAlwaysPullLatestImage() || !found) { LOGGER.info("Pulling docker image: {}", image); client.pull(image); } } catch (final DockerException e) { throw new DockerException("Unable to pull docker image " + image, e); } finally { final long elapsedMillis = System.currentTimeMillis() - startTime; LOGGER.info("Docker image {} pulled in {}ms", image, elapsedMillis); } }
public Result pull(final DockerClient dockerClient, ReadOnlyImage readOnlyImage) { String repository = readOnlyImage.getRepository(); String errMsg; try { dockerClient.pull(repository); return new Result().success(); } catch (DockerException e) { errMsg = e.getMessage(); logger.error("pull image exception.", e); } catch (InterruptedException e) { errMsg = e.getMessage(); logger.error("pull image exception.", e); } catch (Exception e) { errMsg = e.getMessage(); logger.error("pull image exception.", e); } return new Result().fail(errMsg); }
docker.pull(image); listener.pulled(); log.info("Pulled image {} in {}s", image, pullTime.elapsed(SECONDS));
DockerRule(DockerRuleBuilder builder) { this.builder = builder; this.imageNameWithTag = imageNameWithTag(builder.imageName()); try { dockerClient = DefaultDockerClient.fromEnv().build(); log.debug("server.info: {}", dockerClient.info()); log.debug("server.version: {}", dockerClient.version()); if (builder.imageAlwaysPull() || ! imageAvaliable(dockerClient, imageNameWithTag)) { dockerClient.pull(imageNameWithTag); } } catch (ImageNotFoundException e) { throw new ImagePullException(String.format("Image '%s' not found", imageNameWithTag), e); } catch (DockerCertificateException | DockerException | InterruptedException e) { throw new IllegalStateException(e); } }
public void pullImage(String imageId) throws DockerException, InterruptedException { if (!preferences.checkKeyInPreferences(imageId) || !getConfig().isUsePreferences()) { log.info("Pulling Docker image {}", imageId); dockerClient.pull(imageId, new ProgressHandler() { @Override public void progress(ProgressMessage message) throws DockerException { log.trace("Pulling Docker image {} ... {}", imageId, message); } }); log.trace("Docker image {} downloaded", imageId); if (getConfig().isUsePreferences()) { preferences.putValueInPreferencesIfEmpty(imageId, "pulled"); } } }
public void runContainer() { try { buildImageConfig(); try { createImage(); } catch (ImageNotFoundException e) { dockerClient.pull(dockerHost.getImage(), new ProcessHandlerLogger()); createImage(); } dockerClient.startContainer(containerId); final ContainerInfo info = dockerClient.inspectContainer(containerId); portMappings = info.networkSettings().ports(); } catch (InterruptedException | DockerException e) { logger.error("Error while setting up docker container", e); throw new RuntimeException("Error while setting up docker container", e); } }
@Override public void start(WorkflowInstance workflowInstance, RunSpec runSpec) { final String imageTag = runSpec.imageName().contains(":") ? runSpec.imageName() : runSpec.imageName() + ":latest"; final ContainerCreation creation; try { boolean found = false; for (Image image : client.listImages()) { found |= image.repoTags().contains(imageTag); } if (!found) { client.pull(imageTag, System.out::println); // blocking } final ContainerConfig containerConfig = ContainerConfig.builder() .image(imageTag) .cmd(runSpec.args()) .build(); creation = client.createContainer(containerConfig, runSpec.executionId()); client.startContainer(creation.id()); } catch (DockerException | InterruptedException e) { throw new RuntimeException(e); } inFlight.put(creation.id(), workflowInstance); LOG.info("Started container with id " + creation.id() + " and name " + runSpec.executionId()); }
public static FakeS3 create(DockerClient dockerClient) throws DockerException, InterruptedException, IOException { // make sure we have the image dockerClient.pull(IMAGE, System.err::println); Path directory = Files.createTempDirectory("fakeS3"); // bind a fakes3 image to a random host port int port = InstanceSpec.getRandomPort(); return new FakeS3(port, dockerClient.createContainer(ContainerConfig.builder() .hostConfig(HostConfig.builder().portBindings(ImmutableMap.of( CONTAINER_PORT, ImmutableList.of(PortBinding.of("0.0.0.0", port)) )).build()) .image(IMAGE) .exposedPorts(ImmutableSet.of(CONTAINER_PORT)) .build())); }