com.github.dockerjava.api.command.PullImageCmd Java Examples

@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void pullImageAsyncIfNeededWithError() {
    final DockerImage image = DockerImage.fromString("test:1.2.3");

    InspectImageCmd imageInspectCmd = mock(InspectImageCmd.class);
    when(imageInspectCmd.exec()).thenThrow(new NotFoundException("Image not found"));

    // Array to make it final
    ArgumentCaptor<ResultCallback> resultCallback = ArgumentCaptor.forClass(ResultCallback.class);
    PullImageCmd pullImageCmd = mock(PullImageCmd.class);
    when(pullImageCmd.exec(resultCallback.capture())).thenReturn(null);

    when(dockerClient.inspectImageCmd(image.asString())).thenReturn(imageInspectCmd);
    when(dockerClient.pullImageCmd(eq(image.asString()))).thenReturn(pullImageCmd);

    assertTrue("Should return true, we just scheduled the pull", docker.pullImageAsyncIfNeeded(image));
    assertTrue("Should return true, the pull i still ongoing", docker.pullImageAsyncIfNeeded(image));

    try {
        resultCallback.getValue().onComplete();
    } catch (Exception ignored) { }

    assertFalse(docker.imageIsDownloaded(image));
    assertTrue("Should return true, new pull scheduled", docker.pullImageAsyncIfNeeded(image));
}
 

@Override
protected Void execute0(PullImageCmd command, ResultCallback<PullResponseItem> resultCallback) {

    WebTarget webResource = getBaseResource().path("/images/create").queryParam("tag", command.getTag())
            .queryParam("fromImage", command.getRepository()).queryParam("registry", command.getRegistry());

    if (command.getPlatform() != null) {
        webResource = webResource.queryParam("platform", command.getPlatform());
    }

    LOGGER.trace("POST: {}", webResource);
    resourceWithOptionalAuthConfig(command.getAuthConfig(), webResource.request())
            .accept(MediaType.APPLICATION_OCTET_STREAM)
            .post(null, new TypeReference<PullResponseItem>() {
            }, resultCallback);

    return null;
}
 

private void executePullOnDocker(Run<?, ?> build, PrintStream llog, String xImage, DockerClient client)
        throws DockerException {
    PullImageResultCallback resultCallback = new PullImageResultCallback() {
        @Override
        public void onNext(PullResponseItem item) {
            if (item.getStatus() != null && item.getProgress() == null) {
                llog.print(item.getId() + ":" + item.getStatus());
                LOG.info("{} : {}", item.getId(), item.getStatus());
            }
            super.onNext(item);
        }
    };

    PullImageCmd cmd = client.pullImageCmd(xImage);
    DockerCloud.setRegistryAuthentication(cmd, getRegistry(), build.getParent().getParent());
    try {
        cmd.exec(resultCallback).awaitCompletion();
    } catch (InterruptedException e) {
        throw new DockerClientException("Interrupted while pulling image", e);
    }
}
 

@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void pullImageAsyncIfNeededSuccessfully() {
    final DockerImage image = DockerImage.fromString("test:1.2.3");

    InspectImageResponse inspectImageResponse = mock(InspectImageResponse.class);
    when(inspectImageResponse.getId()).thenReturn(image.asString());

    InspectImageCmd imageInspectCmd = mock(InspectImageCmd.class);
    when(imageInspectCmd.exec())
            .thenThrow(new NotFoundException("Image not found"))
            .thenReturn(inspectImageResponse);

    // Array to make it final
    ArgumentCaptor<ResultCallback> resultCallback = ArgumentCaptor.forClass(ResultCallback.class);
    PullImageCmd pullImageCmd = mock(PullImageCmd.class);
    when(pullImageCmd.exec(resultCallback.capture())).thenReturn(null);

    when(dockerClient.inspectImageCmd(image.asString())).thenReturn(imageInspectCmd);
    when(dockerClient.pullImageCmd(eq(image.asString()))).thenReturn(pullImageCmd);

    assertTrue("Should return true, we just scheduled the pull", docker.pullImageAsyncIfNeeded(image));
    assertTrue("Should return true, the pull i still ongoing", docker.pullImageAsyncIfNeeded(image));

    assertTrue(docker.imageIsDownloaded(image));
    resultCallback.getValue().onComplete();
    assertFalse(docker.pullImageAsyncIfNeeded(image));
}
 

@Restricted(NoExternalUse.class)
public static void setRegistryAuthentication(PullImageCmd cmd, DockerRegistryEndpoint registry, ItemGroup context) {
    if (registry != null && registry.getCredentialsId() != null) {
        AuthConfig auth = getAuthConfig(registry, context);
        cmd.withAuthConfig(auth);
    }
}
 

@Nonnull
InspectImageResponse pullImage(DockerAPI api, TaskListener listener) throws IOException, InterruptedException {
    final String image = getFullImageId();

    final boolean shouldPullImage;
    try(final DockerClient client = api.getClient()) {
        shouldPullImage = getPullStrategy().shouldPullImage(client, image);
    }
    if (shouldPullImage) {
        // TODO create a FlyWeightTask so end-user get visibility on pull operation progress
        LOGGER.info("Pulling image '{}'. This may take awhile...", image);

        long startTime = System.currentTimeMillis();

        try(final DockerClient client = api.getClient(pullTimeout)) {
            final PullImageCmd cmd =  client.pullImageCmd(image);
            final DockerRegistryEndpoint registry = getRegistry();
            DockerCloud.setRegistryAuthentication(cmd, registry, Jenkins.getInstance());
            cmd.exec(new PullImageResultCallback() {
                @Override
                public void onNext(PullResponseItem item) {
                    super.onNext(item);
                    listener.getLogger().println(item.getStatus());
                }
            }).awaitCompletion();
        }

        long pullTime = System.currentTimeMillis() - startTime;
        LOGGER.info("Finished pulling image '{}', took {} ms", image, pullTime);
    }

    final InspectImageResponse result;
    try(final DockerClient client = api.getClient()) {
        result = client.inspectImageCmd(image).exec();
    } catch (NotFoundException e) {
        throw new DockerClientException("Could not pull image: " + image, e);
    }
    return result;
}
 

/**
 * * IMAGE API *
 */
@Override
public PullImageCmd pullImageCmd(String repository) {
    return new PullImageCmdImpl(getDockerCmdExecFactory().createPullImageCmdExec(),
            dockerClientConfig.effectiveAuthConfig(repository), repository);
}
 

@Override
public PullImageCmd.Exec createPullImageCmdExec() {
    return new PullImageCmdExec(getBaseResource(), getDockerClientConfig());
}
 

public PullImageCmdImpl(PullImageCmd.Exec exec, AuthConfig authConfig, String repository) {
    super(exec);
    withAuthConfig(authConfig);
    withRepository(repository);
}
 

public PullImageCmd withAuthConfig(AuthConfig authConfig) {
    this.authConfig = authConfig;
    return this;
}
 

@Override
public PullImageCmd withRepository(String repository) {
    checkNotNull(repository, "repository was not specified");
    this.repository = repository;
    return this;
}
 

@Override
public PullImageCmd withTag(String tag) {
    checkNotNull(tag, "tag was not specified");
    this.tag = tag;
    return this;
}
 

@Override
public PullImageCmd withPlatform(String platform) {
    this.platform = platform;
    return this;
}
 

@Override
public PullImageCmd withRegistry(String registry) {
    checkNotNull(registry, "registry was not specified");
    this.registry = registry;
    return this;
}
 

@Override
public PullImageCmd pullImageCmd(String arg0) {
    return getDelegate().pullImageCmd(arg0);
}
 

/**
 * * IMAGE API *
 */

PullImageCmd pullImageCmd(@Nonnull String repository);