@Override
public void execute() throws DockerException {
	if (!StringUtils.isNotBlank(image)) {
		throw new IllegalArgumentException("Image name must be provided");
	}
	// Don't include tag in the image name. Docker daemon can't handle it.
	// put tag in query string parameter.
	String imageFullName = CommandUtils.imageFullNameFrom(registry, image, tag);
	final DockerClient client = getClient();
	PushImageCmd pushImageCmd = client.pushImageCmd(imageFullName).withTag(tag);
	PushImageResultCallback callback = new PushImageResultCallback() {
		@Override
		public void onNext(PushResponseItem item) {
			super.onNext(item);
		}

		@Override
		public void onError(Throwable throwable) {
			logger.error("Failed to push image:" + throwable.getMessage());
			super.onError(throwable);
		}
	};
	pushImageCmd.exec(callback).awaitSuccess();
}
 

/**
 * Push.
 *
 * @param imageName the image name
 * @param auth      the auth
 * @param awaitSec  the await sec
 */
public void push(String imageName, boolean auth, long awaitSec) {
    PushImageCmd pushImageCmd = docker.pushImageCmd(imageName);
    if (auth) {
        pushImageCmd.withAuthConfig(defaultAuthConfig);
    }
    try {
        pushImageCmd.exec(new PushImageResultCallback() {
            @Override
            public void onNext(PushResponseItem item) {
                super.onNext(item);
                log.debug(item.toString());
            }
        }).awaitCompletion(awaitSec, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        log.error("Push image error.", e);
    }
}
 

private void pushImage(DockerfileRequest request, DockerfileResponse response) {
    logger.info(String.format("begin pushImage: %s", request));

    try {
        String repositoryName = buildRepositoryName(request);
        Repository repository = new Repository(repositoryName);
        Identifier identifier = new Identifier(repository, request.getAppTag());
        dockerClient.pushImageCmd(identifier).exec(new PushImageResultCallback() {
            @Override
            public void onNext(PushResponseItem item) {
                super.onNext(item);
                if (logger.isDebugEnabled()) {
                    logger.debug(item);
                }
            }
        }).awaitSuccess();

        response.setRepository(String.format("%s:%s", repositoryName, request.getAppTag()));
    } catch (Exception e) {
        response.fail(e.toString());
        logger.error(String.format("error pushImage: %s", request), e);
    }

    logger.info(String.format("end pushImage: %s", response));
}
 

@Override
default ResultCallback.Adapter<PushResponseItem> start() {
    return exec(new ResultCallback.Adapter<PushResponseItem>() {

        @Nullable
        private PushResponseItem latestItem = null;

        @Override
        public void onNext(PushResponseItem item) {
            this.latestItem = item;
        }

        @Override
        protected void throwFirstError() {
            super.throwFirstError();

            if (latestItem == null) {
                throw new DockerClientException("Could not push image");
            } else if (latestItem.isErrorIndicated()) {
                throw new DockerClientException("Could not push image: " + latestItem.getError());
            }
        }
    });
}
 

@Override
protected Void execute0(PushImageCmd command, ResultCallback<PushResponseItem> resultCallback) {
    WebTarget webResource = getBaseResource().path("/images/{imageName}/push")
        .resolveTemplate("imageName", command.getName())
        .queryParam("tag", command.getTag());

    LOGGER.trace("POST: {}", webResource);

    InvocationBuilder builder = resourceWithAuthConfig(command.getAuthConfig(), webResource.request())
            .accept(MediaType.APPLICATION_JSON);

    builder.post(null, new TypeReference<PushResponseItem>() {
    }, resultCallback);

    return null;
}
 

@Override
public void onNext(PushResponseItem item) {
    // handling error
    if (item.isErrorIndicated()) {
        StringBuilder errString = new StringBuilder("[push][error]: ");

        ResponseItem.ErrorDetail errDetail = null;
        if (null != item.getErrorDetail()) {
            errDetail = item.getErrorDetail();
        }
        if (null != errDetail && null != errDetail.getCode()) {
            errString.append("(").append(errDetail.getCode()).append(") ");
        }

        if (null != errDetail && null != errDetail.getMessage()) {
            errString.append(errDetail.getMessage());
        }

        String errorMessage = errString.toString();
        printDebug(errorMessage);
        dockerPushError.setErrorMsg("unable to push docker image: " + errorMessage);
    }

    String streamLog = item.getStream();
    if (null != streamLog && !"".equals(streamLog.replaceAll("\n", ""))) {
        printDebug("[push][stream] " + streamLog.replaceAll("\n", ""));
    }

    String statusLog = item.getStatus();
    if (null != statusLog && !"".equals(statusLog.replaceAll("\n", ""))) {
        printDebug("[push][status] " + statusLog.replaceAll("\n", ""));
    }

    String idLog = item.getId();
    if (null != idLog) {
        printDebug("[push][ID]: " + idLog);
    }

    super.onNext(item);
}
 

private void pushImages() throws IOException {
    for (String tagToUse : tagsToUse) {
        Identifier identifier = Identifier.fromCompoundString(tagToUse);
        PushImageResultCallback resultCallback = new PushImageResultCallback() {
            @Override
            public void onNext(PushResponseItem item) {
                if (item == null) {
                    // docker-java not happy if you pass it nulls.
                    log("Received NULL Push Response. Ignoring");
                    return;
                }
                printResponseItemToListener(listener, item);
                super.onNext(item);
            }
        };
        try(final DockerClient client = getClientWithNoTimeout()) {
            PushImageCmd cmd = client.pushImageCmd(identifier);

            int i = identifier.repository.name.indexOf('/');
            String regName = i >= 0 ?
                    identifier.repository.name.substring(0,i) : null;

            DockerCloud.setRegistryAuthentication(cmd,
                    new DockerRegistryEndpoint(regName, getPushCredentialsId()),
                    run.getParent().getParent());
            cmd.exec(resultCallback).awaitSuccess();
        } catch (DockerException ex) {
            // Private Docker registries fall over regularly. Tell the user so they
            // have some clue as to what to do as the exception gives no hint.
            log("Exception pushing docker image. Check that the destination registry is running.");
            throw ex;
        }
    }
}
 

@Override
public void onNext(PushResponseItem item) {
    this.latestItem = item;
    LOGGER.debug(item.toString());
}
 

/**
 * @throws NotFoundException
 *             No such image
 */
@Override
<T extends ResultCallback<PushResponseItem>> T exec(T resultCallback);