proj_name
stringclasses 26
values | relative_path
stringlengths 42
188
| class_name
stringlengths 2
53
| func_name
stringlengths 2
49
| masked_class
stringlengths 68
178k
| func_body
stringlengths 56
6.8k
|
|---|---|---|---|---|---|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/AbstrDockerCmd.java | AbstrDockerCmd | registryAuth | class AbstrDockerCmd<CMD_T extends DockerCmd<RES_T>, RES_T> implements SyncDockerCmd<RES_T> {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstrDockerCmd.class);
protected transient DockerCmdSyncExec<CMD_T, RES_T> execution;
public AbstrDockerCmd(DockerCmdSyncExec<CMD_T, RES_T> execution) {
this.execution = Objects.requireNonNull(execution, "execution was not specified");
}
@Override
@SuppressWarnings("unchecked")
public RES_T exec() throws DockerException {
LOGGER.debug("Cmd: {}", this);
return execution.exec((CMD_T) this);
}
@Override
public void close() {
}
@Override
public String toString() {
return ReflectionToStringBuilder.toString(this, ToStringStyle.SIMPLE_STYLE);
}
@Deprecated
protected String registryAuth(AuthConfig authConfig) {<FILL_FUNCTION_BODY>}
} |
try {
return Base64.getEncoder().encodeToString(new ObjectMapper().writeValueAsBytes(authConfig));
} catch (IOException e) {
throw new RuntimeException(e);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/AttachContainerCmdImpl.java | AttachContainerCmdImpl | withContainerId | class AttachContainerCmdImpl extends AbstrAsyncDockerCmd<AttachContainerCmd, Frame>
implements AttachContainerCmd {
private String containerId;
private Boolean logs, followStream, timestamps, stdout, stderr;
private InputStream stdin;
public AttachContainerCmdImpl(AttachContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Boolean hasLogsEnabled() {
return logs;
}
@Override
public Boolean hasFollowStreamEnabled() {
return followStream;
}
@Override
public Boolean hasTimestampsEnabled() {
return timestamps;
}
@Override
public Boolean hasStdoutEnabled() {
return stdout;
}
@Override
public Boolean hasStderrEnabled() {
return stderr;
}
@Override
public InputStream getStdin() {
return stdin;
}
@Override
public AttachContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public AttachContainerCmd withFollowStream(Boolean followStream) {
this.followStream = followStream;
return this;
}
@Override
public AttachContainerCmd withTimestamps(Boolean timestamps) {
this.timestamps = timestamps;
return this;
}
@Override
public AttachContainerCmd withStdOut(Boolean stdout) {
this.stdout = stdout;
return this;
}
@Override
public AttachContainerCmd withStdErr(Boolean stderr) {
this.stderr = stderr;
return this;
}
@Override
public AttachContainerCmd withStdIn(InputStream stdin) {
this.stdin = Objects.requireNonNull(stdin, "stdin was not specified");
return this;
}
@Override
public AttachContainerCmd withLogs(Boolean logs) {
this.logs = logs;
return this;
}
} |
Objects.requireNonNull(containerId, "containerId was not specified");
this.containerId = containerId;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/BuildImageResultCallback.java | BuildImageResultCallback | getImageId | class BuildImageResultCallback extends ResultCallbackTemplate<BuildImageResultCallback, BuildResponseItem> {
private static final Logger LOGGER = LoggerFactory.getLogger(BuildImageResultCallback.class);
private String imageId;
private String error;
@Override
public void onNext(BuildResponseItem item) {
if (item.isBuildSuccessIndicated()) {
this.imageId = item.getImageId();
} else if (item.isErrorIndicated()) {
this.error = item.getError();
}
LOGGER.debug(item.toString());
}
/**
* Awaits the image id from the response stream.
*
* @throws DockerClientException
* if the build fails.
*/
public String awaitImageId() {
try {
awaitCompletion();
} catch (InterruptedException e) {
throw new DockerClientException("", e);
}
return getImageId();
}
/**
* Awaits the image id from the response stream.
*
* @throws DockerClientException
* if the build fails or the timeout occurs.
*/
public String awaitImageId(long timeout, TimeUnit timeUnit) {
try {
awaitCompletion(timeout, timeUnit);
} catch (InterruptedException e) {
throw new DockerClientException("Awaiting image id interrupted: ", e);
}
return getImageId();
}
private String getImageId() {<FILL_FUNCTION_BODY>}
} |
if (imageId != null) {
return imageId;
}
if (error == null) {
throw new DockerClientException("Could not build image");
}
throw new DockerClientException("Could not build image: " + error);
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ContainerDiffCmdImpl.java | ContainerDiffCmdImpl | withContainerId | class ContainerDiffCmdImpl extends AbstrDockerCmd<ContainerDiffCmd, List<ChangeLog>> implements ContainerDiffCmd {
private String containerId;
public ContainerDiffCmdImpl(ContainerDiffCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public ContainerDiffCmdImpl withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such container
* @throws InternalServerErrorException
* server error
* @throws DockerException
* unexpected http status code
*/
@Override
public List<ChangeLog> exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CopyArchiveFromContainerCmdImpl.java | CopyArchiveFromContainerCmdImpl | withResource | class CopyArchiveFromContainerCmdImpl extends AbstrDockerCmd<CopyArchiveFromContainerCmd, InputStream> implements
CopyArchiveFromContainerCmd {
private String containerId;
private String hostPath = ".";
private String resource;
public CopyArchiveFromContainerCmdImpl(CopyArchiveFromContainerCmd.Exec exec, String containerId, String resource) {
super(exec);
withContainerId(containerId);
withResource(resource);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public String getResource() {
return resource;
}
@Override
public CopyArchiveFromContainerCmdImpl withContainerId(String containerId) {
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
}
@Override
public CopyArchiveFromContainerCmdImpl withResource(String resource) {<FILL_FUNCTION_BODY>}
@Override
public String getHostPath() {
return hostPath;
}
@Override
public CopyArchiveFromContainerCmdImpl withHostPath(String hostPath) {
this.hostPath = Objects.requireNonNull(hostPath, "hostPath was not specified");
return this;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public InputStream exec() throws NotFoundException {
return super.exec();
}
} |
this.resource = Objects.requireNonNull(resource, "resource was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CopyArchiveToContainerCmdImpl.java | CopyArchiveToContainerCmdImpl | exec | class CopyArchiveToContainerCmdImpl extends AbstrDockerCmd<CopyArchiveToContainerCmd, Void> implements
CopyArchiveToContainerCmd {
private String containerId;
private String remotePath = ".";
private InputStream tarInputStream;
private String hostResource;
private boolean noOverwriteDirNonDir = false;
private boolean dirChildrenOnly = false;
private boolean copyUIDGID = false;
public CopyArchiveToContainerCmdImpl(CopyArchiveToContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public CopyArchiveToContainerCmd withContainerId(String containerId) {
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
}
@Override
public CopyArchiveToContainerCmd withHostResource(String hostResource) {
this.hostResource = Objects.requireNonNull(hostResource, "hostResource was not specified");
return this;
}
@Override
public CopyArchiveToContainerCmd withNoOverwriteDirNonDir(boolean noOverwriteDirNonDir) {
this.noOverwriteDirNonDir = noOverwriteDirNonDir;
return this;
}
@Override
public CopyArchiveToContainerCmd withCopyUIDGID(boolean copyUIDGID) {
this.copyUIDGID = copyUIDGID;
return this;
}
@Override
public CopyArchiveToContainerCmd withRemotePath(String remotePath) {
this.remotePath = Objects.requireNonNull(remotePath, "remotePath was not specified");
return this;
}
@Override
public CopyArchiveToContainerCmd withTarInputStream(InputStream tarInputStream) {
this.tarInputStream = Objects.requireNonNull(tarInputStream, "tarInputStream was not specified");
return this;
}
@Override
public CopyArchiveToContainerCmd withDirChildrenOnly(boolean dirChildrenOnly) {
this.dirChildrenOnly = dirChildrenOnly;
return this;
}
@Override
public InputStream getTarInputStream() {
return tarInputStream;
}
@Override
public String getContainerId() {
return this.containerId;
}
@Override
public String getHostResource() {
return this.hostResource;
}
@Override
public boolean isNoOverwriteDirNonDir() {
return this.noOverwriteDirNonDir;
}
@Override
public String getRemotePath() {
return this.remotePath;
}
@Override
public boolean isDirChildrenOnly() {
return this.dirChildrenOnly;
}
@Override
public boolean isCopyUIDGID() {
return this.copyUIDGID;
}
@Override
public String toString() {
return new ToStringBuilder(this).append("cp ").append(String.format("-a=%b ", isCopyUIDGID()))
.append(hostResource).append(" ").append(containerId).append(":").append(remotePath).toString();
}
/**
* @throws com.github.dockerjava.api.exception.NotFoundException
* No such container
*/
@Override
public Void exec() throws NotFoundException {<FILL_FUNCTION_BODY>}
} |
if (StringUtils.isNotEmpty(this.hostResource)) {
// User set host resource and not directly a stream
if (this.tarInputStream != null) {
throw new DockerClientException(
"Only one of host resource or tar input stream should be defined to perform the copy, not both");
}
// create TAR package for the given path so docker can consume it
Path toUpload = null;
try {
toUpload = Files.createTempFile("docker-java", ".tar.gz");
CompressArchiveUtil.tar(Paths.get(hostResource), toUpload, true, dirChildrenOnly);
} catch (IOException createFileIOException) {
if (toUpload != null) {
// remove tmp docker-javaxxx.tar.gz
toUpload.toFile().delete();
}
throw new DockerClientException("Unable to perform tar on host resource " + this.hostResource, createFileIOException);
}
// send the tar stream, call exec so that the stream is consumed and then closed by try-with-resources
try (InputStream uploadStream = Files.newInputStream(toUpload)) {
this.tarInputStream = uploadStream;
return super.exec();
} catch (IOException e) {
throw new DockerClientException("Unable to read temp file " + toUpload.toFile().getAbsolutePath(), e);
} finally {
this.tarInputStream = null;
// remove tmp docker-javaxxx.tar.gz
toUpload.toFile().delete();
}
} else if (this.tarInputStream == null) {
throw new DockerClientException("One of host resource or tar input stream must be defined to perform the copy");
}
// User set a stream, so we will just consume it and let the user close it by him self
return super.exec();
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CopyFileFromContainerCmdImpl.java | CopyFileFromContainerCmdImpl | withResource | class CopyFileFromContainerCmdImpl extends AbstrDockerCmd<CopyFileFromContainerCmd, InputStream> implements
CopyFileFromContainerCmd {
private String containerId;
@JsonProperty("HostPath")
private String hostPath = ".";
@JsonProperty("Resource")
private String resource;
public CopyFileFromContainerCmdImpl(CopyFileFromContainerCmd.Exec exec, String containerId, String resource) {
super(exec);
withContainerId(containerId);
withResource(resource);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public String getResource() {
return resource;
}
@Override
public CopyFileFromContainerCmdImpl withContainerId(String containerId) {
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
}
@Override
public CopyFileFromContainerCmdImpl withResource(String resource) {<FILL_FUNCTION_BODY>}
@Override
public String getHostPath() {
return hostPath;
}
@Override
public CopyFileFromContainerCmdImpl withHostPath(String hostPath) {
this.hostPath = Objects.requireNonNull(hostPath, "hostPath was not specified");
return this;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public InputStream exec() throws NotFoundException {
return super.exec();
}
} |
this.resource = Objects.requireNonNull(resource, "resource was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateConfigCmdImpl.java | CreateConfigCmdImpl | withData | class CreateConfigCmdImpl extends AbstrDockerCmd<CreateConfigCmd, CreateConfigResponse> implements CreateConfigCmd {
@JsonProperty("Name")
private String name;
@JsonProperty("Data")
private String data;
@JsonProperty("Labels")
private Map<String, String> labels;
@Override
public String getName() {
return name;
}
@Override
public String getData() {
return data;
}
@Override
public Map<String, String> getLabels() {
return labels;
}
public CreateConfigCmdImpl(CreateConfigCmd.Exec exec) {
super(exec);
}
@Override
public CreateConfigCmd withName(String name) {
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
}
@Override
public CreateConfigCmd withData(byte[] data) {<FILL_FUNCTION_BODY>}
@Override
public CreateConfigCmd withLabels(Map<String, String> labels) {
this.labels = Objects.requireNonNull(labels, "labels was not specified");
return this;
}
} |
Objects.requireNonNull(data, "data was not specified");
this.data = Base64.getEncoder().encodeToString(data);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateImageCmdImpl.java | CreateImageCmdImpl | withImageStream | class CreateImageCmdImpl extends AbstrDockerCmd<CreateImageCmd, CreateImageResponse> implements CreateImageCmd {
private String repository, tag, platform;
private InputStream imageStream;
/**
* @param repository
* the repository to import to
* @param imageStream
* the InputStream of the tar file
*/
public CreateImageCmdImpl(CreateImageCmd.Exec exec, String repository, InputStream imageStream) {
super(exec);
withRepository(repository);
withImageStream(imageStream);
}
@Override
public String getRepository() {
return repository;
}
@Override
public String getTag() {
return tag;
}
@Override
public String getPlatform() {
return platform;
}
@Override
public InputStream getImageStream() {
return imageStream;
}
/**
* @param repository
* the repository to import to
*/
@Override
public CreateImageCmdImpl withRepository(String repository) {
Objects.requireNonNull(repository, "repository was not specified");
this.repository = repository;
return this;
}
/**
* @param imageStream
* the InputStream of the tar file
*/
@Override
public CreateImageCmdImpl withImageStream(InputStream imageStream) {<FILL_FUNCTION_BODY>}
/**
* @param tag
* any tag for this image
*/
@Override
public CreateImageCmdImpl withTag(String tag) {
Objects.requireNonNull(tag, "tag was not specified");
this.tag = tag;
return this;
}
/**
* {@inheritDoc}
*/
@Override
public CreateImageCmd withPlatform(String platform) {
this.platform = platform;
return this;
}
} |
Objects.requireNonNull(imageStream, "imageStream was not specified");
this.imageStream = imageStream;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateNetworkCmdImpl.java | CreateNetworkCmdImpl | withLabels | class CreateNetworkCmdImpl extends AbstrDockerCmd<CreateNetworkCmd, CreateNetworkResponse>
implements CreateNetworkCmd {
@JsonProperty("Name")
private String name;
@JsonProperty("Driver")
private String driver;
@JsonProperty("IPAM")
private Network.Ipam ipam;
@JsonProperty("Options")
private Map<String, String> options = new HashMap<>();
@JsonProperty("CheckDuplicate")
private Boolean checkDuplicate;
@JsonProperty("Internal")
private Boolean internal;
@JsonProperty("EnableIPv6")
private Boolean enableIpv6;
@JsonProperty("Attachable")
private Boolean attachable;
@JsonProperty("Labels")
private Map<String, String> labels;
public CreateNetworkCmdImpl(DockerCmdSyncExec<CreateNetworkCmd, CreateNetworkResponse> execution) {
super(execution);
}
@Override
public String getName() {
return name;
}
@Override
public String getDriver() {
return driver;
}
@Override
public Network.Ipam getIpam() {
return ipam;
}
@Override
public Map<String, String> getOptions() {
return options;
}
@Override
public Boolean getCheckDuplicate() {
return checkDuplicate;
}
@Override
public Boolean getInternal() {
return internal;
}
@Override
public Boolean getEnableIPv6() {
return enableIpv6;
}
@Override
public CreateNetworkCmd withName(String name) {
this.name = name;
return this;
}
@Override
public CreateNetworkCmd withDriver(String driver) {
this.driver = driver;
return this;
}
@Override
public CreateNetworkCmd withIpam(Ipam ipam) {
this.ipam = ipam;
return this;
}
@Override
public CreateNetworkCmd withOptions(Map<String, String> options) {
this.options = options;
return this;
}
@Override
public CreateNetworkCmd withCheckDuplicate(boolean checkDuplicate) {
this.checkDuplicate = checkDuplicate;
return this;
}
@Override
public CreateNetworkCmd withInternal(boolean internal) {
this.internal = internal;
return this;
}
@Override
public CreateNetworkCmd withEnableIpv6(boolean enableIpv6) {
this.enableIpv6 = enableIpv6;
return this;
}
@Override
public Boolean getAttachable() {
return this.attachable;
}
/**
* {@inheritDoc}
*/
@Override
public CreateNetworkCmd withAttachable(Boolean attachable) {
this.attachable = attachable;
return this;
}
@Override
public Map<String, String> getLabels() {
return labels;
}
/**
* {@inheritDoc}
*/
@Override
public CreateNetworkCmd withLabels(Map<String, String> labels) {<FILL_FUNCTION_BODY>}
} |
Objects.requireNonNull(labels, "labels was not specified");
this.labels = labels;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateSecretCmdImpl.java | CreateSecretCmdImpl | withSecretSpec | class CreateSecretCmdImpl extends AbstrDockerCmd<CreateSecretCmd, CreateSecretResponse> implements
CreateSecretCmd {
private SecretSpec secretSpec;
public CreateSecretCmdImpl(Exec exec, SecretSpec secretSpec) {
super(exec);
Objects.requireNonNull(secretSpec, "secretSpec was not specified");
withSecretSpec(secretSpec);
}
@Override
public SecretSpec getSecretSpec() {
return secretSpec;
}
@Override
public CreateSecretCmd withSecretSpec(SecretSpec secretSpec) {<FILL_FUNCTION_BODY>}
} |
Objects.requireNonNull(secretSpec, "secretSpec was not specified");
this.secretSpec = secretSpec;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateServiceCmdImpl.java | CreateServiceCmdImpl | withAuthConfig | class CreateServiceCmdImpl extends AbstrDockerCmd<CreateServiceCmd, CreateServiceResponse> implements
CreateServiceCmd {
private ServiceSpec serviceSpec;
private AuthConfig authConfig;
public CreateServiceCmdImpl(CreateServiceCmd.Exec exec, ServiceSpec serviceSpec) {
super(exec);
Objects.requireNonNull(serviceSpec, "serviceSpec was not specified");
withServiceSpec(serviceSpec);
}
@Override
public ServiceSpec getServiceSpec() {
return serviceSpec;
}
@Override
public AuthConfig getAuthConfig() {
return authConfig;
}
@Override
public CreateServiceCmd withServiceSpec(ServiceSpec serviceSpec) {
Objects.requireNonNull(serviceSpec, "serviceSpec was not specified");
this.serviceSpec = serviceSpec;
return this;
}
@Override
public CreateServiceCmd withAuthConfig(AuthConfig authConfig) {<FILL_FUNCTION_BODY>}
} |
Objects.requireNonNull(authConfig, "authConfig was not specified");
this.authConfig = authConfig;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/CreateVolumeCmdImpl.java | CreateVolumeCmdImpl | withLabels | class CreateVolumeCmdImpl extends AbstrDockerCmd<CreateVolumeCmd, CreateVolumeResponse> implements
CreateVolumeCmd {
@JsonProperty("Name")
private String name;
@JsonProperty("Labels")
private Map<String, String> labels;
@JsonProperty("Driver")
private String driver;
@JsonProperty("DriverOpts")
private Map<String, String> driverOpts;
public CreateVolumeCmdImpl(CreateVolumeCmd.Exec exec) {
super(exec);
}
@Override
public String getName() {
return name;
}
@Override
public Map<String, String> getLabels() {
return labels;
}
@Override
public String getDriver() {
return driver;
}
@Override
public Map<String, String> getDriverOpts() {
return driverOpts;
}
@Override
public CreateVolumeCmdImpl withName(String name) {
Objects.requireNonNull(name, "name was not specified");
this.name = name;
return this;
}
@Override
public CreateVolumeCmdImpl withLabels(Map<String, String> labels) {<FILL_FUNCTION_BODY>}
@Override
public CreateVolumeCmdImpl withDriver(String driver) {
Objects.requireNonNull(driver, "driver was not specified");
this.driver = driver;
return this;
}
@Override
public CreateVolumeCmd withDriverOpts(Map<String, String> driverOpts) {
Objects.requireNonNull(driverOpts, "driverOpts was not specified");
this.driverOpts = driverOpts;
return this;
}
} |
Objects.requireNonNull(labels, "labels was not specified");
this.labels = labels;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/EventsCmdImpl.java | EventsCmdImpl | withEventTypeFilter | class EventsCmdImpl extends AbstrAsyncDockerCmd<EventsCmd, Event> implements EventsCmd {
private String since;
private String until;
private FiltersBuilder filters = new FiltersBuilder();
public EventsCmdImpl(EventsCmd.Exec exec) {
super(exec);
}
@Override
public EventsCmd withSince(String since) {
this.since = since;
return this;
}
@Override
public EventsCmd withUntil(String until) {
this.until = until;
return this;
}
@Override
public EventsCmd withContainerFilter(String... container) {
Objects.requireNonNull(container, "container have not been specified");
this.filters.withContainers(container);
return this;
}
@Override
public EventsCmd withImageFilter(String... image) {
Objects.requireNonNull(image, "image have not been specified");
this.filters.withImages(image);
return this;
}
@Override
public EventsCmd withEventFilter(String... event) {
Objects.requireNonNull(event, "event have not been specified");
this.filters.withFilter("event", event);
return this;
}
@Override
public EventsCmd withEventTypeFilter(String... eventTypes) {<FILL_FUNCTION_BODY>}
@Override
public EventsCmd withLabelFilter(String... label) {
Objects.requireNonNull(label, "label have not been specified");
this.filters.withLabels(label);
return this;
}
@Override
public EventsCmd withLabelFilter(Map<String, String> labels) {
Objects.requireNonNull(labels, "labels have not been specified");
this.filters.withLabels(labels);
return this;
}
@Override
public String getSince() {
return since;
}
@Override
public String getUntil() {
return until;
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
} |
Objects.requireNonNull(eventTypes, "event types have not been specified");
this.filters.withEventTypes(eventTypes);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ExecCreateCmdImpl.java | ExecCreateCmdImpl | withContainerId | class ExecCreateCmdImpl extends AbstrDockerCmd<ExecCreateCmd, ExecCreateCmdResponse> implements ExecCreateCmd {
private String containerId;
@JsonProperty("AttachStdin")
private Boolean attachStdin;
@JsonProperty("AttachStdout")
private Boolean attachStdout;
@JsonProperty("AttachStderr")
private Boolean attachStderr;
@JsonProperty("Tty")
private Boolean tty;
/**
* @since 1.21
**/
@JsonProperty("Privileged")
private Boolean privileged;
/**
* @since {@link com.github.dockerjava.core.RemoteApiVersion#VERSION_1_19}
*/
@JsonProperty("User")
private String user;
@JsonProperty("Cmd")
private String[] cmd;
/**
* @since {@link com.github.dockerjava.core.RemoteApiVersion#VERSION_1_25}
*/
@JsonProperty("Env")
private List<String> env;
/**
* @since {@link com.github.dockerjava.core.RemoteApiVersion#VERSION_1_35}
*/
@JsonProperty("WorkingDir")
private String workingDir;
public ExecCreateCmdImpl(ExecCreateCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public ExecCreateCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public ExecCreateCmd withAttachStdin(Boolean attachStdin) {
this.attachStdin = attachStdin;
return this;
}
@Override
public ExecCreateCmd withAttachStdout(Boolean attachStdout) {
this.attachStdout = attachStdout;
return this;
}
@Override
public ExecCreateCmd withAttachStderr(Boolean attachStderr) {
this.attachStderr = attachStderr;
return this;
}
@Override
public ExecCreateCmd withTty(Boolean tty) {
this.tty = tty;
return this;
}
@Override
public ExecCreateCmd withUser(String user) {
this.user = user;
return this;
}
@Override
public ExecCreateCmd withCmd(String... cmd) {
this.cmd = cmd;
return this;
}
@Override
public ExecCreateCmd withEnv(List<String> env) {
this.env = env;
return this;
}
@Override
public ExecCreateCmd withPrivileged(Boolean privileged) {
this.privileged = privileged;
return this;
}
@Override
public ExecCreateCmd withWorkingDir(String workingDir) {
this.workingDir = workingDir;
return this;
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Boolean hasAttachStdinEnabled() {
return attachStdin;
}
@Override
public Boolean hasAttachStdoutEnabled() {
return attachStdout;
}
@Override
public Boolean hasAttachStderrEnabled() {
return attachStderr;
}
@Override
public Boolean hasTtyEnabled() {
return tty;
}
@Override
public List<String> getEnv() {
return env;
}
@Override
public Boolean getPrivileged() {
return privileged;
}
@Override
public String getUser() {
return user;
}
@Override
public String getWorkingDir() {
return workingDir;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public ExecCreateCmdResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ExecStartCmdImpl.java | ExecStartCmdImpl | withExecId | class ExecStartCmdImpl extends AbstrAsyncDockerCmd<ExecStartCmd, Frame> implements ExecStartCmd {
@JsonIgnore
private String execId;
@JsonProperty("Detach")
private Boolean detach;
@JsonProperty("Tty")
private Boolean tty;
@JsonIgnore
private InputStream stdin;
public ExecStartCmdImpl(ExecStartCmd.Exec exec, String execId) {
super(exec);
withExecId(execId);
}
@Override
public String getExecId() {
return execId;
}
@Override
public ExecStartCmd withExecId(String execId) {<FILL_FUNCTION_BODY>}
@Override
public Boolean hasDetachEnabled() {
return detach;
}
@Override
public Boolean hasTtyEnabled() {
return tty;
}
@Override
@JsonIgnore
public InputStream getStdin() {
return stdin;
}
@Override
public ExecStartCmd withDetach(Boolean detach) {
this.detach = detach;
return this;
}
@Override
public ExecStartCmd withTty(Boolean tty) {
this.tty = tty;
return this;
}
@Override
public ExecStartCmd withStdIn(InputStream stdin) {
this.stdin = stdin;
return this;
}
/**
* @throws NotFoundException
* No such exec instance
*/
@Override
public <T extends ResultCallback<Frame>> T exec(T resultCallback) {
return super.exec(resultCallback);
}
} |
this.execId = Objects.requireNonNull(execId, "execId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ExecStartResultCallback.java | ExecStartResultCallback | onNext | class ExecStartResultCallback extends ResultCallbackTemplate<ExecStartResultCallback, Frame> {
private static final Logger LOGGER = LoggerFactory.getLogger(ExecStartResultCallback.class);
private OutputStream stdout, stderr;
public ExecStartResultCallback(OutputStream stdout, OutputStream stderr) {
this.stdout = stdout;
this.stderr = stderr;
}
public ExecStartResultCallback() {
this(null, null);
}
@Override
public void onNext(Frame frame) {<FILL_FUNCTION_BODY>}
} |
if (frame != null) {
try {
switch (frame.getStreamType()) {
case STDOUT:
case RAW:
if (stdout != null) {
stdout.write(frame.getPayload());
stdout.flush();
}
break;
case STDERR:
if (stderr != null) {
stderr.write(frame.getPayload());
stderr.flush();
}
break;
default:
LOGGER.error("unknown stream type:" + frame.getStreamType());
}
} catch (IOException e) {
onError(e);
}
LOGGER.debug(frame.toString());
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/FrameReader.java | FrameReader | readFrame | class FrameReader implements AutoCloseable {
private static final int HEADER_SIZE = 8;
private final byte[] rawBuffer = new byte[1000];
private final InputStream inputStream;
private Boolean rawStreamDetected = false;
public FrameReader(InputStream inputStream) {
this.inputStream = inputStream;
}
private static StreamType streamType(byte streamType) {
switch (streamType) {
case 0:
return StreamType.STDIN;
case 1:
return StreamType.STDOUT;
case 2:
return StreamType.STDERR;
default:
return StreamType.RAW;
}
}
/**
* @return A frame, or null if no more frames.
*/
@CheckForNull
public Frame readFrame() throws IOException {<FILL_FUNCTION_BODY>}
@Override
public void close() throws IOException {
inputStream.close();
}
} |
if (rawStreamDetected) {
int read = inputStream.read(rawBuffer);
if (read == -1) {
return null;
}
return new Frame(StreamType.RAW, Arrays.copyOf(rawBuffer, read));
} else {
byte[] header = new byte[HEADER_SIZE];
int actualHeaderSize = 0;
do {
int headerCount = inputStream.read(header, actualHeaderSize, HEADER_SIZE - actualHeaderSize);
if (headerCount == -1) {
return null;
}
actualHeaderSize += headerCount;
} while (actualHeaderSize < HEADER_SIZE);
// HexDump.dump(header, 0, System.err, 0);
StreamType streamType = streamType(header[0]);
if (streamType.equals(StreamType.RAW)) {
rawStreamDetected = true;
return new Frame(StreamType.RAW, Arrays.copyOf(header, HEADER_SIZE));
}
int payloadSize = ((header[4] & 0xff) << 24) + ((header[5] & 0xff) << 16) + ((header[6] & 0xff) << 8)
+ (header[7] & 0xff);
byte[] payload = new byte[payloadSize];
int actualPayloadSize = 0;
do {
int count = inputStream.read(payload, actualPayloadSize, payloadSize - actualPayloadSize);
if (count == -1) {
if (actualPayloadSize != payloadSize) {
throw new IOException(String.format("payload must be %d bytes long, but was %d", payloadSize,
actualPayloadSize));
}
break;
}
actualPayloadSize += count;
} while (actualPayloadSize < payloadSize);
return new Frame(streamType, payload);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectConfigCmdImpl.java | InspectConfigCmdImpl | withConfigId | class InspectConfigCmdImpl extends AbstrDockerCmd<InspectConfigCmd, Config> implements InspectConfigCmd {
private String configId;
public InspectConfigCmdImpl(Exec exec, String configId) {
super(exec);
withConfigId(configId);
}
@Override
public String getConfigId() {
return configId;
}
@Override
public InspectConfigCmd withConfigId(String configId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such config
*/
@Override
public Config exec() throws NotFoundException {
return super.exec();
}
} |
this.configId = Objects.requireNonNull(configId, "configId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectContainerCmdImpl.java | InspectContainerCmdImpl | withContainerId | class InspectContainerCmdImpl extends AbstrDockerCmd<InspectContainerCmd, InspectContainerResponse> implements
InspectContainerCmd {
private String containerId;
private boolean size;
public InspectContainerCmdImpl(InspectContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public InspectContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public InspectContainerCmd withSize(Boolean showSize) {
this.size = showSize;
return this;
}
@Override
public Boolean getSize() {
return size;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public InspectContainerResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectExecCmdImpl.java | InspectExecCmdImpl | withExecId | class InspectExecCmdImpl extends AbstrDockerCmd<InspectExecCmd, InspectExecResponse> implements InspectExecCmd {
private String execId;
public InspectExecCmdImpl(InspectExecCmd.Exec execution, String execId) {
super(execution);
withExecId(execId);
}
@Override
public String getExecId() {
return execId;
}
@Override
public InspectExecCmd withExecId(String execId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such exec
*/
@Override
public InspectExecResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.execId = Objects.requireNonNull(execId, "execId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectImageCmdImpl.java | InspectImageCmdImpl | withImageId | class InspectImageCmdImpl extends AbstrDockerCmd<InspectImageCmd, InspectImageResponse> implements
InspectImageCmd {
private String imageId;
public InspectImageCmdImpl(InspectImageCmd.Exec exec, String imageId) {
super(exec);
withImageId(imageId);
}
@Override
public String getImageId() {
return imageId;
}
@Override
public InspectImageCmd withImageId(String imageId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such image
*/
@Override
public InspectImageResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.imageId = Objects.requireNonNull(imageId, "imageId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectServiceCmdImpl.java | InspectServiceCmdImpl | withServiceId | class InspectServiceCmdImpl extends AbstrDockerCmd<InspectServiceCmd, Service> implements
InspectServiceCmd {
private String serviceId;
public InspectServiceCmdImpl(Exec exec, String serviceId) {
super(exec);
withServiceId(serviceId);
}
@Override
public String getServiceId() {
return serviceId;
}
@Override
public InspectServiceCmd withServiceId(String serviceId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such service
*/
@Override
public Service exec() throws NotFoundException {
return super.exec();
}
} |
this.serviceId = Objects.requireNonNull(serviceId, "serviceId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectSwarmNodeCmdImpl.java | InspectSwarmNodeCmdImpl | withSwarmNodeId | class InspectSwarmNodeCmdImpl extends AbstrDockerCmd<InspectSwarmNodeCmd, SwarmNode> implements
InspectSwarmNodeCmd {
private String swarmNodeId;
public InspectSwarmNodeCmdImpl(Exec exec, String swarmNodeId) {
super(exec);
withSwarmNodeId(swarmNodeId);
}
@Override
@CheckForNull
public String getSwarmNodeId() {
return swarmNodeId;
}
@Override
public InspectSwarmNodeCmd withSwarmNodeId(String swarmNodeId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such swarmNode
*/
@Override
public SwarmNode exec() throws NotFoundException {
return super.exec();
}
} |
this.swarmNodeId = Objects.requireNonNull(swarmNodeId, "swarmNodeId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/InspectVolumeCmdImpl.java | InspectVolumeCmdImpl | withName | class InspectVolumeCmdImpl extends AbstrDockerCmd<InspectVolumeCmd, InspectVolumeResponse> implements
InspectVolumeCmd {
private String name;
public InspectVolumeCmdImpl(InspectVolumeCmd.Exec exec, String name) {
super(exec);
withName(name);
}
@Override
public String getName() {
return name;
}
@Override
public InspectVolumeCmd withName(String name) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such volume
*/
@Override
public InspectVolumeResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/KillContainerCmdImpl.java | KillContainerCmdImpl | withSignal | class KillContainerCmdImpl extends AbstrDockerCmd<KillContainerCmd, Void> implements KillContainerCmd {
private String containerId, signal;
public KillContainerCmdImpl(KillContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public String getSignal() {
return signal;
}
@Override
public KillContainerCmd withContainerId(String containerId) {
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
}
@Override
public KillContainerCmd withSignal(String signal) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.signal = Objects.requireNonNull(signal, "signal was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListConfigsCmdImpl.java | ListConfigsCmdImpl | withFilters | class ListConfigsCmdImpl extends AbstrDockerCmd<ListConfigsCmd, List<Config>> implements ListConfigsCmd {
private Map<String, List<String>> filters = Collections.emptyMap();
public ListConfigsCmdImpl(Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filters;
}
public ListConfigsCmd withFilters(Map<String, List<String>> filters) {<FILL_FUNCTION_BODY>}
} |
this.filters = Objects.requireNonNull(filters, "filters was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListContainersCmdImpl.java | ListContainersCmdImpl | withExitedFilter | class ListContainersCmdImpl extends AbstrDockerCmd<ListContainersCmd, List<Container>> implements
ListContainersCmd {
private Integer limit = -1;
private Boolean showSize, showAll = false;
private String sinceId, beforeId;
private FiltersBuilder filters = new FiltersBuilder();
public ListContainersCmdImpl(ListContainersCmd.Exec exec) {
super(exec);
}
@Override
public Integer getLimit() {
return limit;
}
@Override
public Boolean hasShowSizeEnabled() {
return showSize;
}
@Override
public Boolean hasShowAllEnabled() {
return showAll;
}
@Override
public String getSinceId() {
return sinceId;
}
@Override
public String getBeforeId() {
return beforeId;
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public ListContainersCmd withShowAll(Boolean showAll) {
this.showAll = showAll;
return this;
}
@Override
public ListContainersCmd withShowSize(Boolean showSize) {
this.showSize = showSize;
return this;
}
@Override
public ListContainersCmd withLimit(Integer limit) {
Objects.requireNonNull(limit, "limit was not specified");
checkArgument(limit > 0, "limit must be greater 0");
this.limit = limit;
return this;
}
@Override
public ListContainersCmd withSince(String since) {
this.sinceId = Objects.requireNonNull(since, "since was not specified");
return this;
}
@Override
public ListContainersCmd withBefore(String before) {
this.beforeId = Objects.requireNonNull(before, "before was not specified");
return this;
}
@Override
public ListContainersCmd withNameFilter(Collection<String> name) {
return withFilter("name", name);
}
@Override
public ListContainersCmd withIdFilter(Collection<String> id) {
return withFilter("id", id);
}
@Override
public ListContainersCmd withAncestorFilter(Collection<String> ancestor) {
return withFilter("ancestor", ancestor);
}
@Override
public ListContainersCmd withVolumeFilter(Collection<String> volume) {
return withFilter("volume", volume);
}
@Override
public ListContainersCmd withNetworkFilter(Collection<String> network) {
return withFilter("network", network);
}
@Override
public ListContainersCmd withLabelFilter(Collection<String> labels) {
return withFilter("label", labels);
}
@Override
public ListContainersCmd withLabelFilter(Map<String, String> labels) {
Objects.requireNonNull(labels, "labels was not specified");
this.filters.withLabels(labels);
return this;
}
@Override
public ListContainersCmd withExitedFilter(Integer exited) {<FILL_FUNCTION_BODY>}
@Override
public ListContainersCmd withFilter(String filterName, Collection<String> filterValues) {
Objects.requireNonNull(filterValues, filterName + " was not specified");
this.filters.withFilter(filterName, filterValues);
return this;
}
@Override
public ListContainersCmd withStatusFilter(Collection<String> status) {
Objects.requireNonNull(status, "status was not specified");
this.filters.withFilter("status", status);
return this;
}
} |
Objects.requireNonNull(exited, "exited was not specified");
this.filters.withFilter("exited", exited.toString());
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListImagesCmdImpl.java | ListImagesCmdImpl | withLabelFilter | class ListImagesCmdImpl extends AbstrDockerCmd<ListImagesCmd, List<Image>> implements ListImagesCmd {
private String imageNameFilter;
private Boolean showAll = false;
private FiltersBuilder filters = new FiltersBuilder();
public ListImagesCmdImpl(ListImagesCmd.Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public Boolean hasShowAllEnabled() {
return showAll;
}
@Override
public ListImagesCmd withShowAll(Boolean showAll) {
this.showAll = showAll;
return this;
}
@Override
public ListImagesCmd withDanglingFilter(Boolean dangling) {
Objects.requireNonNull(dangling, "dangling have not been specified");
withFilter("dangling", Collections.singletonList(dangling.toString()));
return this;
}
@Override
public ListImagesCmd withLabelFilter(String... labels) {<FILL_FUNCTION_BODY>}
@Override
public ListImagesCmd withLabelFilter(Map<String, String> labels) {
Objects.requireNonNull(labels, "labels have not been specified");
filters.withLabels(labels);
return this;
}
@Override
public ListImagesCmd withImageNameFilter(String imageNameFilter) {
Objects.requireNonNull(imageNameFilter, "image name filter not specified");
this.imageNameFilter = imageNameFilter;
return this;
}
@Override
public ListImagesCmd withReferenceFilter(String reference) {
Objects.requireNonNull(reference, "reference filter not specified");
withFilter("reference", Collections.singletonList(reference));
return this;
}
@Override
public ListImagesCmd withFilter(String key, Collection<String> values) {
Objects.requireNonNull(key, "key not specified");
Objects.requireNonNull(values, "values not specified");
filters.withFilter(key, values);
return this;
}
@Override
public String getImageNameFilter() {
return this.imageNameFilter;
}
@Override
public String toString() {
return ReflectionToStringBuilder.toString(this, ToStringStyle.SHORT_PREFIX_STYLE);
}
} |
Objects.requireNonNull(labels, "labels have not been specified");
filters.withLabels(labels);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListNetworksCmdImpl.java | ListNetworksCmdImpl | withFilter | class ListNetworksCmdImpl extends AbstrDockerCmd<ListNetworksCmd, List<Network>> implements ListNetworksCmd {
private FiltersBuilder filtersBuilder = new FiltersBuilder();
public ListNetworksCmdImpl(ListNetworksCmd.Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filtersBuilder.build();
}
@Override
public ListNetworksCmd withIdFilter(String... networkId) {
this.filtersBuilder.withFilter("id", networkId);
return this;
}
@Override
public ListNetworksCmd withNameFilter(String... networkName) {
this.filtersBuilder.withFilter("name", networkName);
return this;
}
@Override
public ListNetworksCmd withFilter(String filterName, Collection<String> filterValues) {<FILL_FUNCTION_BODY>}
} |
Objects.requireNonNull(filterValues, filterName + " was not specified");
this.filtersBuilder.withFilter(filterName, filterValues);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListSecretsCmdImpl.java | ListSecretsCmdImpl | withNameFilter | class ListSecretsCmdImpl extends AbstrDockerCmd<ListSecretsCmd, List<Secret>> implements
ListSecretsCmd {
private FiltersBuilder filters = new FiltersBuilder();
public ListSecretsCmdImpl(Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public ListSecretsCmd withIdFilter(List<String> ids) {
Objects.requireNonNull(ids, "ids was not specified");
this.filters.withFilter("id", ids);
return this;
}
@Override
public ListSecretsCmd withNameFilter(List<String> names) {<FILL_FUNCTION_BODY>}
@Override
public ListSecretsCmd withLabelFilter(Map<String, String> labels) {
Objects.requireNonNull(labels, "labels was not specified");
this.filters.withLabels(labels);
return this;
}
} |
Objects.requireNonNull(names, "names was not specified");
this.filters.withFilter("name", names);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListServicesCmdImpl.java | ListServicesCmdImpl | withIdFilter | class ListServicesCmdImpl extends AbstrDockerCmd<ListServicesCmd, List<Service>> implements
ListServicesCmd {
private FiltersBuilder filters = new FiltersBuilder();
public ListServicesCmdImpl(Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public ListServicesCmd withIdFilter(List<String> ids) {<FILL_FUNCTION_BODY>}
@Override
public ListServicesCmd withNameFilter(List<String> names) {
Objects.requireNonNull(names, "names was not specified");
this.filters.withFilter("name", names);
return this;
}
@Override
public ListServicesCmd withLabelFilter(Map<String, String> labels) {
Objects.requireNonNull(labels, "labels was not specified");
this.filters.withLabels(labels);
return this;
}
} |
Objects.requireNonNull(ids, "ids was not specified");
this.filters.withFilter("id", ids);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListTasksCmdImpl.java | ListTasksCmdImpl | withStateFilter | class ListTasksCmdImpl extends AbstrDockerCmd<ListTasksCmd, List<Task>> implements ListTasksCmd {
private FiltersBuilder filters = new FiltersBuilder();
public ListTasksCmdImpl(Exec exec) {
super(exec);
}
@CheckForNull
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public ListTasksCmd withLabelFilter(Map<String, String> labels) {
filters.withLabels(labels);
return this;
}
@Override
public ListTasksCmd withLabelFilter(String... labels) {
filters.withLabels(labels);
return this;
}
@Override
public ListTasksCmd withIdFilter(String... ids) {
filters.withFilter("id", ids);
return this;
}
@Override
public ListTasksCmd withNameFilter(String... names) {
filters.withFilter("name", names);
return this;
}
@Override
public ListTasksCmd withNodeFilter(String... nodeNames) {
filters.withFilter("node", nodeNames);
return this;
}
@Override
public ListTasksCmd withServiceFilter(String... serviceNames) {
filters.withFilter("service", serviceNames);
return this;
}
@Override
public ListTasksCmd withStateFilter(TaskState... desiredStates) {<FILL_FUNCTION_BODY>}
} |
String[] states = new String[desiredStates.length];
for (int i = 0; i < desiredStates.length; i++) {
states[i] = desiredStates[i].getValue();
}
filters.withFilter("desired-state", states);
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ListVolumesCmdImpl.java | ListVolumesCmdImpl | withDanglingFilter | class ListVolumesCmdImpl extends AbstrDockerCmd<ListVolumesCmd, ListVolumesResponse> implements ListVolumesCmd {
private FiltersBuilder filters = new FiltersBuilder();
public ListVolumesCmdImpl(ListVolumesCmd.Exec exec) {
super(exec);
}
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public ListVolumesCmd withDanglingFilter(Boolean dangling) {<FILL_FUNCTION_BODY>}
@Override
public ListVolumesCmd withFilter(String filterName, Collection<String> filterValues) {
Objects.requireNonNull(filterValues, filterName + " was not specified");
this.filters.withFilter(filterName, filterValues);
return this;
}
} |
Objects.requireNonNull(dangling, "dangling have not been specified");
this.filters.withFilter("dangling", dangling.toString());
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/LoadImageAsyncCmdImpl.java | LoadImageAsyncCmdImpl | close | class LoadImageAsyncCmdImpl extends AbstrAsyncDockerCmd<LoadImageAsyncCmd, LoadResponseItem> implements LoadImageAsyncCmd {
private InputStream inputStream;
public LoadImageAsyncCmdImpl(LoadImageAsyncCmd.Exec exec, InputStream inputStream) {
super(exec);
this.inputStream = inputStream;
}
@Override
public InputStream getImageStream() {
return this.inputStream;
}
@Override
public LoadImageAsyncCmd withImageStream(InputStream imageStream) {
Objects.requireNonNull(imageStream, "imageStream was not specified");
this.inputStream = imageStream;
return this;
}
@Override
public void close() {<FILL_FUNCTION_BODY>}
} |
super.close();
try {
this.inputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/LoadImageCmdImpl.java | LoadImageCmdImpl | withImageStream | class LoadImageCmdImpl extends AbstrDockerCmd<LoadImageCmd, Void> implements LoadImageCmd {
private InputStream imageStream;
/**
* @param imageStream
* the InputStream of the tar file
*/
public LoadImageCmdImpl(LoadImageCmd.Exec exec, InputStream imageStream) {
super(exec);
withImageStream(imageStream);
}
@Override
public InputStream getImageStream() {
return imageStream;
}
/**
* @param imageStream
* the InputStream of the tar file
*/
@Override
public LoadImageCmdImpl withImageStream(@Nonnull InputStream imageStream) {<FILL_FUNCTION_BODY>}
} |
this.imageStream = Objects.requireNonNull(imageStream, "imageStream was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/LogContainerCmdImpl.java | LogContainerCmdImpl | withContainerId | class LogContainerCmdImpl extends AbstrAsyncDockerCmd<LogContainerCmd, Frame> implements LogContainerCmd {
private String containerId;
private Boolean followStream, timestamps, stdout, stderr;
private Integer tail, since, until;
public LogContainerCmdImpl(LogContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Integer getTail() {
return tail;
}
@Override
public Boolean hasFollowStreamEnabled() {
return followStream;
}
@Override
public Boolean hasTimestampsEnabled() {
return timestamps;
}
@Override
public Boolean hasStdoutEnabled() {
return stdout;
}
@Override
public Boolean hasStderrEnabled() {
return stderr;
}
@Override
public Integer getSince() {
return since;
}
@Override
public Integer getUntil() {
return until;
}
@Override
public LogContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public LogContainerCmd withFollowStream(Boolean followStream) {
this.followStream = followStream;
return this;
}
@Override
public LogContainerCmd withTimestamps(Boolean timestamps) {
this.timestamps = timestamps;
return this;
}
@Override
public LogContainerCmd withStdOut(Boolean stdout) {
this.stdout = stdout;
return this;
}
@Override
public LogContainerCmd withStdErr(Boolean stderr) {
this.stderr = stderr;
return this;
}
@Override
public LogContainerCmd withTailAll() {
this.tail = -1;
return this;
}
@Override
public LogContainerCmd withTail(Integer tail) {
this.tail = tail;
return this;
}
@Override
public LogContainerCmd withSince(Integer since) {
this.since = since;
return this;
}
@Override
public LogContainerCmd withUntil(Integer until) {
this.until = until;
return this;
}
@Override
public String toString() {
return ReflectionToStringBuilder.toString(this, ToStringStyle.SHORT_PREFIX_STYLE);
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PauseContainerCmdImpl.java | PauseContainerCmdImpl | withContainerId | class PauseContainerCmdImpl extends AbstrDockerCmd<PauseContainerCmd, Void> implements PauseContainerCmd {
private String containerId;
public PauseContainerCmdImpl(PauseContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public PauseContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PruneCmdImpl.java | PruneCmdImpl | getApiPath | class PruneCmdImpl extends AbstrDockerCmd<PruneCmd, PruneResponse> implements PruneCmd {
private static final String BUILD_API_PATH = "/build/prune";
private static final String CONTAINERS_API_PATH = "/containers/prune";
private static final String IMAGES_API_PATH = "/images/prune";
private static final String VOLUMES_API_PATH = "/volumes/prune";
private static final String NETWORKS_API_PATH = "/networks/prune";
private FiltersBuilder filters = new FiltersBuilder();
private PruneType pruneType;
public PruneCmdImpl(Exec exec, PruneType pruneType) {
super(exec);
this.pruneType = pruneType;
}
@Nonnull
@Override
public PruneType getPruneType() {
return pruneType;
}
@Nonnull
@Override
public String getApiPath() {<FILL_FUNCTION_BODY>}
@CheckForNull
@Override
public Map<String, List<String>> getFilters() {
return filters.build();
}
@Override
public PruneCmd withPruneType(final PruneType pruneType) {
Objects.requireNonNull(pruneType, "pruneType has not been specified");
this.pruneType = pruneType;
return this;
}
@Override
public PruneCmd withDangling(Boolean dangling) {
Objects.requireNonNull(dangling, "dangling has not been specified");
filters.withFilter("dangling", dangling ? "1" : "0");
return this;
}
@Override
public PruneCmd withUntilFilter(final String until) {
Objects.requireNonNull(until, "until has not been specified");
filters.withUntil(until);
return this;
}
@Override
public PruneCmd withLabelFilter(final String... labels) {
Objects.requireNonNull(labels, "labels have not been specified");
filters.withLabels(labels);
return this;
}
@Override
public PruneResponse exec() {
return super.exec();
}
} |
String apiPath;
switch (getPruneType()) {
case BUILD:
apiPath = BUILD_API_PATH;
break;
case IMAGES:
apiPath = IMAGES_API_PATH;
break;
case NETWORKS:
apiPath = NETWORKS_API_PATH;
break;
case VOLUMES:
apiPath = VOLUMES_API_PATH;
break;
default:
apiPath = CONTAINERS_API_PATH;
break;
}
return apiPath;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PullImageCmdImpl.java | PullImageCmdImpl | withRepository | class PullImageCmdImpl extends AbstrAsyncDockerCmd<PullImageCmd, PullResponseItem> implements PullImageCmd {
private String repository, tag, platform, registry;
private AuthConfig authConfig;
public PullImageCmdImpl(PullImageCmd.Exec exec, AuthConfig authConfig, String repository) {
super(exec);
withAuthConfig(authConfig);
withRepository(repository);
}
public AuthConfig getAuthConfig() {
return authConfig;
}
public PullImageCmd withAuthConfig(AuthConfig authConfig) {
this.authConfig = authConfig;
return this;
}
@Override
public String getRepository() {
return repository;
}
@Override
public String getTag() {
return tag;
}
@Override
public String getPlatform() {
return platform;
}
@Override
public String getRegistry() {
return registry;
}
@Override
public PullImageCmd withRepository(String repository) {<FILL_FUNCTION_BODY>}
@Override
public PullImageCmd withTag(String tag) {
this.tag = Objects.requireNonNull(tag, "tag was not specified");
return this;
}
@Override
public PullImageCmd withPlatform(String platform) {
this.platform = platform;
return this;
}
@Override
public PullImageCmd withRegistry(String registry) {
this.registry = Objects.requireNonNull(registry, "registry was not specified");
return this;
}
} |
this.repository = Objects.requireNonNull(repository, "repository was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PullImageResultCallback.java | PullImageResultCallback | checkDockerSwarmPullSuccessful | class PullImageResultCallback extends ResultCallbackTemplate<PullImageResultCallback, PullResponseItem> {
private static final Logger LOGGER = LoggerFactory.getLogger(PullImageResultCallback.class);
private boolean isSwarm = false;
private Map<String, PullResponseItem> results = null;
@CheckForNull
private PullResponseItem latestItem = null;
@Override
public void onNext(PullResponseItem item) {
// only do it once
if (results == null && latestItem == null) {
checkForDockerSwarmResponse(item);
}
if (isSwarm) {
handleDockerSwarmResponse(item);
} else {
handleDockerClientResponse(item);
}
LOGGER.debug(item.toString());
}
private void checkForDockerSwarmResponse(PullResponseItem item) {
if (item.getStatus().matches("Pulling\\s.+\\.{3}$")) {
isSwarm = true;
LOGGER.debug("Communicating with Docker Swarm.");
}
}
private void handleDockerSwarmResponse(final PullResponseItem item) {
if (results == null) {
results = new HashMap<>();
}
// Swarm terminates a pull sometimes with an empty line.
// Therefore keep first success message
PullResponseItem currentItem = results.get(item.getId());
if (currentItem == null || !currentItem.isPullSuccessIndicated()) {
results.put(item.getId(), item);
}
}
private void handleDockerClientResponse(PullResponseItem item) {
latestItem = item;
}
private void checkDockerSwarmPullSuccessful() {<FILL_FUNCTION_BODY>}
private void checkDockerClientPullSuccessful() {
if (latestItem == null) {
throw new DockerClientException("Could not pull image");
} else if (!latestItem.isPullSuccessIndicated()) {
throw new DockerClientException("Could not pull image: " + messageFromPullResult(latestItem));
}
}
private String messageFromPullResult(PullResponseItem pullResponseItem) {
return (pullResponseItem.getError() != null) ? pullResponseItem.getError() : pullResponseItem.getStatus();
}
@Override
protected void throwFirstError() {
super.throwFirstError();
if (isSwarm) {
checkDockerSwarmPullSuccessful();
} else {
checkDockerClientPullSuccessful();
}
}
/**
* Awaits the image to be pulled successful.
*
* @deprecated use {@link #awaitCompletion()} or {@link #awaitCompletion(long, TimeUnit)} instead
* @throws DockerClientException
* if the pull fails.
*/
public void awaitSuccess() {
try {
awaitCompletion();
} catch (InterruptedException e) {
throw new DockerClientException("", e);
}
}
} |
if (results.isEmpty()) {
throw new DockerClientException("Could not pull image through Docker Swarm");
} else {
boolean pullFailed = false;
StringBuilder sb = new StringBuilder();
for (PullResponseItem pullResponseItem : results.values()) {
if (!pullResponseItem.isPullSuccessIndicated()) {
pullFailed = true;
sb.append("[" + pullResponseItem.getId() + ":" + messageFromPullResult(pullResponseItem) + "]");
}
}
if (pullFailed) {
throw new DockerClientException("Could not pull image: " + sb.toString());
}
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PushImageCmdImpl.java | PushImageCmdImpl | withName | class PushImageCmdImpl extends AbstrAsyncDockerCmd<PushImageCmd, PushResponseItem> implements PushImageCmd {
private String name;
private String tag;
private AuthConfig authConfig;
public PushImageCmdImpl(PushImageCmd.Exec exec, AuthConfig authConfig, String name) {
super(exec);
withName(name);
withAuthConfig(authConfig);
}
@Override
public String getName() {
return name;
}
@Override
public String getTag() {
return tag;
}
/**
* @param name
* The name, e.g. "alexec/busybox" or just "busybox" if you want to default. Not null.
*/
@Override
public PushImageCmd withName(String name) {<FILL_FUNCTION_BODY>}
/**
* @param tag
* The image's tag. Can be null or empty.
*/
@Override
public PushImageCmd withTag(String tag) {
this.tag = Objects.requireNonNull(tag, "tag was not specified");
return this;
}
public AuthConfig getAuthConfig() {
return authConfig;
}
public PushImageCmd withAuthConfig(AuthConfig authConfig) {
this.authConfig = authConfig;
return this;
}
} |
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/PushImageResultCallback.java | PushImageResultCallback | awaitSuccess | class PushImageResultCallback extends ResultCallbackTemplate<PushImageResultCallback, PushResponseItem> {
private static final Logger LOGGER = LoggerFactory.getLogger(PushImageResultCallback.class);
@CheckForNull
private PushResponseItem latestItem = null;
@Override
public void onNext(PushResponseItem item) {
this.latestItem = item;
LOGGER.debug(item.toString());
}
@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());
}
}
/**
* Awaits the image to be pulled successful.
*
* @deprecated use {@link #awaitCompletion()} or {@link #awaitCompletion(long, TimeUnit)} instead
* @throws DockerClientException
* if the push fails.
*/
public void awaitSuccess() {<FILL_FUNCTION_BODY>}
} |
try {
awaitCompletion();
} catch (InterruptedException e) {
throw new DockerClientException("", e);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveConfigCmdImpl.java | RemoveConfigCmdImpl | withConfigId | class RemoveConfigCmdImpl extends AbstrDockerCmd<RemoveConfigCmd, Void> implements RemoveConfigCmd {
private String configId;
public RemoveConfigCmdImpl(Exec exec, String configId) {
super(exec);
withConfigId(configId);
}
@Override
public String getConfigId() {
return configId;
}
@Override
public RemoveConfigCmd withConfigId(String configId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such secret
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.configId = Objects.requireNonNull(configId, "configId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveContainerCmdImpl.java | RemoveContainerCmdImpl | withContainerId | class RemoveContainerCmdImpl extends AbstrDockerCmd<RemoveContainerCmd, Void> implements RemoveContainerCmd {
private String containerId;
private Boolean removeVolumes, force;
public RemoveContainerCmdImpl(RemoveContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Boolean hasRemoveVolumesEnabled() {
return removeVolumes;
}
@Override
public Boolean hasForceEnabled() {
return force;
}
@Override
public RemoveContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public RemoveContainerCmd withRemoveVolumes(Boolean removeVolumes) {
this.removeVolumes = removeVolumes;
return this;
}
@Override
public RemoveContainerCmd withForce(Boolean force) {
this.force = force;
return this;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveImageCmdImpl.java | RemoveImageCmdImpl | withImageId | class RemoveImageCmdImpl extends AbstrDockerCmd<RemoveImageCmd, Void> implements RemoveImageCmd {
private String imageId;
private Boolean force, noPrune;
public RemoveImageCmdImpl(RemoveImageCmd.Exec exec, String imageId) {
super(exec);
withImageId(imageId);
}
@Override
public String getImageId() {
return imageId;
}
@Override
public Boolean hasForceEnabled() {
return force;
}
@Override
public Boolean hasNoPruneEnabled() {
return noPrune;
}
@Override
public RemoveImageCmd withImageId(String imageId) {<FILL_FUNCTION_BODY>}
@Override
public RemoveImageCmd withForce(Boolean force) {
this.force = force;
return this;
}
@Override
public RemoveImageCmd withNoPrune(Boolean noPrune) {
this.noPrune = noPrune;
return this;
}
/**
* @throws NotFoundException
* No such image
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.imageId = Objects.requireNonNull(imageId, "imageId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveSecretCmdImpl.java | RemoveSecretCmdImpl | withSecretId | class RemoveSecretCmdImpl extends AbstrDockerCmd<RemoveSecretCmd, Void> implements RemoveSecretCmd {
private String secretId;
public RemoveSecretCmdImpl(Exec exec, String secretId) {
super(exec);
withSecretId(secretId);
}
@Override
public String getSecretId() {
return secretId;
}
@Override
public RemoveSecretCmd withSecretId(String secretId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such secret
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.secretId = Objects.requireNonNull(secretId, "secretId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveServiceCmdImpl.java | RemoveServiceCmdImpl | withServiceId | class RemoveServiceCmdImpl extends AbstrDockerCmd<RemoveServiceCmd, Void> implements RemoveServiceCmd {
private String serviceId;
public RemoveServiceCmdImpl(Exec exec, String serviceId) {
super(exec);
withServiceId(serviceId);
}
@Override
public String getServiceId() {
return serviceId;
}
@Override
public RemoveServiceCmd withServiceId(String serviceId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such service
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.serviceId = Objects.requireNonNull(serviceId, "serviceId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveSwarmNodeCmdImpl.java | RemoveSwarmNodeCmdImpl | withSwarmNodeId | class RemoveSwarmNodeCmdImpl extends AbstrDockerCmd<RemoveSwarmNodeCmd, Void> implements RemoveSwarmNodeCmd {
private String swarmNodeId;
private Boolean force;
public RemoveSwarmNodeCmdImpl(RemoveSwarmNodeCmd.Exec exec, String swarmNodeId) {
super(exec);
withSwarmNodeId(swarmNodeId);
}
@Override
@CheckForNull
public String getSwarmNodeId() {
return swarmNodeId;
}
@Override
@CheckForNull
public Boolean hasForceEnabled() {
return force;
}
@Override
public RemoveSwarmNodeCmd withSwarmNodeId(@Nonnull String swarmNodeId) {<FILL_FUNCTION_BODY>}
@Override
public RemoveSwarmNodeCmd withForce(Boolean force) {
this.force = force;
return this;
}
/**
* @throws NotFoundException No such swarmNode
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.swarmNodeId = Objects.requireNonNull(swarmNodeId, "swarmNodeId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RemoveVolumeCmdImpl.java | RemoveVolumeCmdImpl | withName | class RemoveVolumeCmdImpl extends AbstrDockerCmd<RemoveVolumeCmd, Void> implements RemoveVolumeCmd {
private String name;
public RemoveVolumeCmdImpl(RemoveVolumeCmd.Exec exec, String name) {
super(exec);
withName(name);
}
@Override
public String getName() {
return name;
}
@Override
public RemoveVolumeCmd withName(String name) {<FILL_FUNCTION_BODY>}
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RenameContainerCmdImpl.java | RenameContainerCmdImpl | withContainerId | class RenameContainerCmdImpl extends AbstrDockerCmd<RenameContainerCmd, Void> implements RenameContainerCmd {
private String containerId;
private String name;
public RenameContainerCmdImpl(RenameContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public String getName() {
return name;
}
@Override
public RenameContainerCmd withContainerId(@Nonnull String containerId) {<FILL_FUNCTION_BODY>}
@Override
public RenameContainerCmd withName(@Nonnull String name) {
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
}
/**
* @throws NotFoundException No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ResizeContainerCmdImpl.java | ResizeContainerCmdImpl | withContainerId | class ResizeContainerCmdImpl extends AbstrDockerCmd<ResizeContainerCmd, Void> implements ResizeContainerCmd {
private String containerId;
private Integer height;
private Integer width;
public ResizeContainerCmdImpl(ResizeContainerCmd.Exec exec, String execId) {
super(exec);
withContainerId(execId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Integer getHeight() {
return height;
}
@Override
public Integer getWidth() {
return width;
}
@Override
public ResizeContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public ResizeContainerCmd withSize(int height, int width) {
this.height = height;
this.width = width;
return this;
}
/**
* @throws NotFoundException no such exec instance
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/ResizeExecCmdImpl.java | ResizeExecCmdImpl | withExecId | class ResizeExecCmdImpl extends AbstrDockerCmd<ResizeExecCmd, Void> implements ResizeExecCmd {
private String execId;
private Integer height;
private Integer width;
public ResizeExecCmdImpl(ResizeExecCmd.Exec exec, String execId) {
super(exec);
withExecId(execId);
}
@Override
public String getExecId() {
return execId;
}
@Override
public Integer getHeight() {
return height;
}
@Override
public Integer getWidth() {
return width;
}
@Override
public ResizeExecCmd withExecId(String execId) {<FILL_FUNCTION_BODY>}
@Override
public ResizeExecCmd withSize(int height, int width) {
this.height = height;
this.width = width;
return this;
}
/**
* @throws NotFoundException no such exec instance
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.execId = Objects.requireNonNull(execId, "execId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/RestartContainerCmdImpl.java | RestartContainerCmdImpl | withTimeout | class RestartContainerCmdImpl extends AbstrDockerCmd<RestartContainerCmd, Void> implements RestartContainerCmd {
private String containerId;
private Integer timeout = 10;
private String signal;
public RestartContainerCmdImpl(RestartContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Integer getTimeout() {
return timeout;
}
/**
* @since {@link com.github.dockerjava.core.RemoteApiVersion#VERSION_1_42}
*/
@CheckForNull
@Override
public String getSignal() {
return signal;
}
@Override
public RestartContainerCmd withContainerId(String containerId) {
Objects.requireNonNull(containerId, "containerId was not specified");
this.containerId = containerId;
return this;
}
@Override
public RestartContainerCmd withTimeout(Integer timeout) {<FILL_FUNCTION_BODY>}
@Override
public RestartContainerCmd withSignal(String signal) {
Objects.requireNonNull(signal, "signal was not specified");
this.signal = signal;
return this;
}
/**
* @throws NotFoundException No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
Objects.requireNonNull(timeout, "timeout was not specified");
checkArgument(timeout >= 0, "timeout must be greater or equal 0");
this.timeout = timeout;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/SaveImageCmdImpl.java | SaveImageCmdImpl | withTag | class SaveImageCmdImpl extends AbstrDockerCmd<SaveImageCmd, InputStream> implements SaveImageCmd {
private String name;
private String tag;
public SaveImageCmdImpl(SaveImageCmd.Exec exec, String name) {
super(exec);
withName(name);
}
@Override
public String getName() {
return name;
}
@Override
public String getTag() {
return tag;
}
/**
* @param name
* The name, e.g. "alexec/busybox" or just "busybox" if you want to default. Not null.
*/
@Override
public SaveImageCmd withName(String name) {
this.name = Objects.requireNonNull(name, "name was not specified");
return this;
}
/**
* @param tag
* The image's tag. Can be null or empty.
*/
@Override
public SaveImageCmd withTag(String tag) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such image
*/
@Override
public InputStream exec() throws NotFoundException {
return super.exec();
}
} |
this.tag = Objects.requireNonNull(tag, "tag was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/SearchImagesCmdImpl.java | SearchImagesCmdImpl | withLimit | class SearchImagesCmdImpl extends AbstrDockerCmd<SearchImagesCmd, List<SearchItem>> implements SearchImagesCmd {
private static final int MIN_LIMIT = 1;
private static final int MAX_LIMIT = 100;
private String term;
private Integer limit;
public SearchImagesCmdImpl(SearchImagesCmd.Exec exec, String term) {
super(exec);
withTerm(term);
}
@Override
public String getTerm() {
return term;
}
@Override
public SearchImagesCmd withTerm(String term) {
this.term = Objects.requireNonNull(term, "term was not specified");
return this;
}
@Override
public Integer getLimit() {
return limit;
}
@Override
public SearchImagesCmd withLimit(@Nonnull Integer limit) {<FILL_FUNCTION_BODY>}
} |
String errorMessage = String.format("Limit %s is outside the range of [%s, %s]", limit, MIN_LIMIT, MAX_LIMIT);
checkArgument(limit <= MAX_LIMIT, errorMessage);
checkArgument(limit >= MIN_LIMIT, errorMessage);
this.limit = limit;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/StartContainerCmdImpl.java | StartContainerCmdImpl | withContainerId | class StartContainerCmdImpl extends AbstrDockerCmd<StartContainerCmd, Void> implements StartContainerCmd {
@JsonIgnore
private String containerId;
public StartContainerCmdImpl(StartContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public StartContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public String getContainerId() {
return containerId;
}
/**
* @throws NotFoundException
* No such container
* @throws NotModifiedException
* Container already started
*/
@Override
public Void exec() throws NotFoundException, NotModifiedException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/StatsCmdImpl.java | StatsCmdImpl | withContainerId | class StatsCmdImpl extends AbstrAsyncDockerCmd<StatsCmd, Statistics> implements StatsCmd {
private String containerId;
private Boolean noStream;
public StatsCmdImpl(StatsCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public StatsCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Boolean hasNoStream() {
return noStream;
}
@Override
public StatsCmd withNoStream(boolean noStream) {
this.noStream = noStream;
return this;
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/StopContainerCmdImpl.java | StopContainerCmdImpl | withTimeout | class StopContainerCmdImpl extends AbstrDockerCmd<StopContainerCmd, Void> implements StopContainerCmd {
private String containerId;
private Integer timeout = 10;
public StopContainerCmdImpl(StopContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public Integer getTimeout() {
return timeout;
}
@Override
public StopContainerCmd withContainerId(String containerId) {
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
}
@Override
public StopContainerCmd withTimeout(Integer timeout) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such container
* @throws NotModifiedException
* Container already stopped
*/
@Override
public Void exec() throws NotFoundException, NotModifiedException {
return super.exec();
}
} |
Objects.requireNonNull(timeout, "timeout was not specified");
checkArgument(timeout >= 0, "timeout must be greater or equal 0");
this.timeout = timeout;
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/TagImageCmdImpl.java | TagImageCmdImpl | withTag | class TagImageCmdImpl extends AbstrDockerCmd<TagImageCmd, Void> implements TagImageCmd {
private String imageId, repository, tag;
private Boolean force;
public TagImageCmdImpl(TagImageCmd.Exec exec, String imageId, String repository, String tag) {
super(exec);
withImageId(imageId);
withRepository(repository);
withTag(tag);
}
@Override
public String getImageId() {
return imageId;
}
@Override
public String getRepository() {
return repository;
}
@Override
public String getTag() {
return tag;
}
@Override
public Boolean hasForceEnabled() {
return force;
}
@Override
public TagImageCmd withImageId(String imageId) {
this.imageId = Objects.requireNonNull(imageId, "imageId was not specified");
return this;
}
@Override
public TagImageCmd withRepository(String repository) {
this.repository = Objects.requireNonNull(repository, "repository was not specified");
return this;
}
@Override
public TagImageCmd withTag(String tag) {<FILL_FUNCTION_BODY>}
@Override
public TagImageCmd withForce() {
return withForce(true);
}
@Override
public TagImageCmd withForce(Boolean force) {
this.force = force;
return this;
}
} |
this.tag = Objects.requireNonNull(tag, "tag was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/TopContainerCmdImpl.java | TopContainerCmdImpl | withContainerId | class TopContainerCmdImpl extends AbstrDockerCmd<TopContainerCmd, TopContainerResponse> implements
TopContainerCmd {
private String containerId;
private String psArgs;
public TopContainerCmdImpl(TopContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public String getPsArgs() {
return psArgs;
}
@Override
public TopContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
@Override
public TopContainerCmd withPsArgs(String psArgs) {
this.psArgs = Objects.requireNonNull(psArgs, "psArgs was not specified");
return this;
}
/**
* @throws NotFoundException
* No such container
*/
@Override
public TopContainerResponse exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/UnpauseContainerCmdImpl.java | UnpauseContainerCmdImpl | withContainerId | class UnpauseContainerCmdImpl extends AbstrDockerCmd<UnpauseContainerCmd, Void> implements UnpauseContainerCmd {
private String containerId;
public UnpauseContainerCmdImpl(UnpauseContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public UnpauseContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
/**
* @throws NotFoundException
* No such container
*/
@Override
public Void exec() throws NotFoundException {
return super.exec();
}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/UpdateSwarmCmdImpl.java | UpdateSwarmCmdImpl | withSwarmSpec | class UpdateSwarmCmdImpl extends AbstrDockerCmd<UpdateSwarmCmd, Void> implements
UpdateSwarmCmd {
private Long version;
private Boolean rotateWorkerToken;
private Boolean rotateManagerToken;
private SwarmSpec swarmSpec;
public UpdateSwarmCmdImpl(Exec exec, SwarmSpec swarmSpec) {
super(exec);
this.swarmSpec = swarmSpec;
}
@Override
public Long getVersion() {
return version;
}
@Override
public UpdateSwarmCmd withVersion(Long version) {
this.version = version;
return this;
}
@Override
public Boolean getRotateWorkerToken() {
return rotateWorkerToken;
}
@Override
public UpdateSwarmCmd withRotateWorkerToken(Boolean rotateWorkerToken) {
this.rotateWorkerToken = rotateWorkerToken;
return this;
}
@Override
public Boolean getRotateManagerToken() {
return rotateManagerToken;
}
@Override
public UpdateSwarmCmd withRotateManagerToken(Boolean rotateManagerToken) {
this.rotateManagerToken = rotateManagerToken;
return this;
}
@Override
public SwarmSpec getSwarmSpec() {
return swarmSpec;
}
@Override
public UpdateSwarmCmd withSwarmSpec(SwarmSpec swarmSpec) {<FILL_FUNCTION_BODY>}
} |
this.swarmSpec = Objects.requireNonNull(swarmSpec, "swarmSpec was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/WaitContainerCmdImpl.java | WaitContainerCmdImpl | withContainerId | class WaitContainerCmdImpl extends AbstrAsyncDockerCmd<WaitContainerCmd, WaitResponse> implements
WaitContainerCmd {
private String containerId;
public WaitContainerCmdImpl(WaitContainerCmd.Exec exec, String containerId) {
super(exec);
withContainerId(containerId);
}
@Override
public String getContainerId() {
return containerId;
}
@Override
public WaitContainerCmd withContainerId(String containerId) {<FILL_FUNCTION_BODY>}
} |
this.containerId = Objects.requireNonNull(containerId, "containerId was not specified");
return this;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/command/WaitContainerResultCallback.java | WaitContainerResultCallback | awaitStatusCode | class WaitContainerResultCallback extends ResultCallbackTemplate<WaitContainerResultCallback, WaitResponse> {
private static final Logger LOGGER = LoggerFactory.getLogger(WaitContainerResultCallback.class);
@CheckForNull
private WaitResponse waitResponse = null;
@Override
public void onNext(WaitResponse waitResponse) {
this.waitResponse = waitResponse;
LOGGER.debug(waitResponse.toString());
}
/**
* Awaits the status code from the container.
*
* @throws DockerClientException
* if the wait operation fails.
*/
public Integer awaitStatusCode() {
try {
awaitCompletion();
} catch (InterruptedException e) {
throw new DockerClientException("", e);
}
return getStatusCode();
}
/**
* Awaits the status code from the container.
*
* @throws DockerClientException
* if the wait operation fails.
*/
public Integer awaitStatusCode(long timeout, TimeUnit timeUnit) {<FILL_FUNCTION_BODY>}
private Integer getStatusCode() {
if (waitResponse == null) {
throw new DockerClientException("Error while wait container");
} else {
return waitResponse.getStatusCode();
}
}
} |
try {
if (!awaitCompletion(timeout, timeUnit)) {
throw new DockerClientException("Awaiting status code timeout.");
}
} catch (InterruptedException e) {
throw new DockerClientException("Awaiting status code interrupted: ", e);
}
return getStatusCode();
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/dockerfile/Dockerfile.java | Dockerfile | apply | class Dockerfile {
public final File dockerFile;
private final File baseDirectory;
public Dockerfile(File dockerFile, File baseDirectory) {
if (!dockerFile.exists()) {
throw new IllegalStateException(String.format("Dockerfile %s does not exist", dockerFile.getAbsolutePath()));
}
if (!dockerFile.isFile()) {
throw new IllegalStateException(String.format("Dockerfile %s is not a file", dockerFile.getAbsolutePath()));
}
this.dockerFile = dockerFile;
if (!baseDirectory.exists()) {
throw new IllegalStateException(String.format("Base directory %s does not exist", baseDirectory.getAbsolutePath()));
}
if (!baseDirectory.isDirectory()) {
throw new IllegalStateException(String.format("Base directory %s is not a directory", baseDirectory.getAbsolutePath()));
}
this.baseDirectory = baseDirectory;
}
private static class LineTransformer implements Function<String, Optional<? extends DockerfileStatement>> {
private int line = 0;
@Override
public Optional<? extends DockerfileStatement> apply(String input) {<FILL_FUNCTION_BODY>}
}
public Iterable<DockerfileStatement> getStatements() throws IOException {
Collection<String> dockerFileContent = FileUtils.readLines(dockerFile);
if (dockerFileContent.size() <= 0) {
throw new DockerClientException(String.format("Dockerfile %s is empty", dockerFile));
}
Collection<Optional<? extends DockerfileStatement>> optionals = Collections2.transform(dockerFileContent,
new LineTransformer());
return Optional.presentInstances(optionals);
}
public List<String> getIgnores() throws IOException {
List<String> ignores = new ArrayList<>();
File dockerIgnoreFile = new File(baseDirectory, ".dockerignore");
if (dockerIgnoreFile.exists()) {
int lineNumber = 0;
List<String> dockerIgnoreFileContent = FileUtils.readLines(dockerIgnoreFile);
for (String pattern : dockerIgnoreFileContent) {
lineNumber++;
pattern = pattern.trim();
if (pattern.isEmpty()) {
continue; // skip empty lines
}
pattern = FilenameUtils.normalize(pattern);
try {
ignores.add(pattern);
} catch (GoLangFileMatchException e) {
throw new DockerClientException(String.format(
"Invalid pattern '%s' on line %s in .dockerignore file", pattern, lineNumber));
}
}
}
return ignores;
}
public ScannedResult parse() throws IOException {
return new ScannedResult();
}
/**
* Result of scanning / parsing a docker file.
*/
public class ScannedResult {
final List<String> ignores;
final List<File> filesToAdd = new ArrayList<>();
public InputStream buildDockerFolderTar() {
return buildDockerFolderTar(baseDirectory);
}
public InputStream buildDockerFolderTar(File directory) {
File dockerFolderTar = null;
try {
final String archiveNameWithOutExtension = UUID.randomUUID().toString();
dockerFolderTar = CompressArchiveUtil.archiveTARFiles(directory, filesToAdd,
archiveNameWithOutExtension);
final FileInputStream tarInputStream = FileUtils.openInputStream(dockerFolderTar);
final File tarFile = dockerFolderTar;
return new InputStream() {
@Override
public int available() throws IOException {
return tarInputStream.available();
}
@Override
public int read() throws IOException {
return tarInputStream.read();
}
@Override
public int read(byte[] buff, int offset, int len) throws IOException {
return tarInputStream.read(buff, offset, len);
}
@Override
public void close() throws IOException {
IOUtils.closeQuietly(tarInputStream);
FileUtils.deleteQuietly(tarFile);
}
};
} catch (IOException ex) {
FileUtils.deleteQuietly(dockerFolderTar);
throw new DockerClientException("Error occurred while preparing Docker context folder.", ex);
}
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this).add("ignores", ignores).add("filesToAdd", filesToAdd).toString();
}
public ScannedResult() throws IOException {
ignores = getIgnores();
String matchingIgnorePattern = effectiveMatchingIgnorePattern(dockerFile);
if (matchingIgnorePattern != null) {
throw new DockerClientException(String.format(
"Dockerfile is excluded by pattern '%s' in .dockerignore file", matchingIgnorePattern));
}
addFilesInDirectory(baseDirectory);
}
/**
* Adds all files found in <code>directory</code> and subdirectories to
* <code>filesToAdd</code> collection. It also adds any empty directories
* if found.
*
* @param directory directory
* @throws DockerClientException when IO error occurs
*/
private void addFilesInDirectory(File directory) {
File[] files = directory.listFiles();
if (files == null) {
throw new DockerClientException("Failed to read build context directory: " + baseDirectory.getAbsolutePath());
}
if (files.length != 0) {
for (File f : files) {
if (f.isDirectory()) {
addFilesInDirectory(f);
} else if (effectiveMatchingIgnorePattern(f) == null) {
filesToAdd.add(f);
}
}
// base directory should at least contains Dockerfile, but better check
} else if (!isBaseDirectory(directory)) {
// add empty directory
filesToAdd.add(directory);
}
}
private boolean isBaseDirectory(File directory) {
return directory.compareTo(baseDirectory) == 0;
}
/**
* Returns all matching ignore patterns for the given file name.
*/
private List<String> matchingIgnorePatterns(String fileName) {
List<String> matches = new ArrayList<>();
int lineNumber = 0;
for (String pattern : ignores) {
String goLangPattern = pattern.startsWith("!") ? pattern.substring(1) : pattern;
lineNumber++;
try {
if (GoLangFileMatch.match(goLangPattern, fileName)) {
matches.add(pattern);
}
} catch (GoLangFileMatchException e) {
throw new DockerClientException(String.format(
"Invalid pattern '%s' on line %s in .dockerignore file", pattern, lineNumber));
}
}
return matches;
}
/**
* Returns the matching ignore pattern for the given file or null if it should NOT be ignored. Exception rules like "!Dockerfile"
* will be respected.
*/
private String effectiveMatchingIgnorePattern(File file) {
// normalize path to replace '/' to '\' on Windows
String relativeFilename = FilenameUtils.normalize(FilePathUtil.relativize(baseDirectory, file));
List<String> matchingPattern = matchingIgnorePatterns(relativeFilename);
if (matchingPattern.isEmpty()) {
return null;
}
String lastMatchingPattern = matchingPattern.get(matchingPattern.size() - 1);
return !lastMatchingPattern.startsWith("!") ? lastMatchingPattern : null;
}
}
} |
try {
line++;
return DockerfileStatement.createFromLine(input);
} catch (Exception ex) {
throw new DockerClientException("Error on dockerfile line " + line);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/dockerfile/DockerfileStatement.java | DockerfileStatement | getFileResources | class DockerfileStatement<T extends DockerfileStatement<?>> {
private DockerfileStatement() {
}
public T transform(Map<String, String> env) {
return (T) this;
}
protected String filterForEnvironmentVars(Map<String, String> environmentMap, String extractedResource) {
if (environmentMap.size() > 0) {
String currentResourceContent = extractedResource;
for (Map.Entry<String, String> entry : environmentMap.entrySet()) {
String variable = entry.getKey();
String replacementValue = entry.getValue();
// handle: $VARIABLE case
currentResourceContent = currentResourceContent.replaceAll("\\$" + variable,
Matcher.quoteReplacement(replacementValue));
// handle ${VARIABLE} case
currentResourceContent = currentResourceContent.replaceAll("\\$\\{" + variable + "\\}",
Matcher.quoteReplacement(replacementValue));
}
return currentResourceContent;
} else {
return extractedResource;
}
}
/**
* A statement that we don't particularly care about.
*/
public static class OtherLine extends DockerfileStatement {
public final String statement;
public OtherLine(String statement) {
this.statement = statement;
}
@Override
public String toString() {
return statement;
}
}
/**
* An ADD or a COPY
*/
public static class Add extends DockerfileStatement<Add> {
private static final Pattern ARGUMENT_TOKENIZER = Pattern.compile("(?:\"[^\"]+\")|(\\S+)");
public final Collection<String> sources;
public final String destination;
private Add(Collection<String> sources, String destination) {
this.sources = sources;
this.destination = destination;
}
@Override
public Add transform(final Map<String, String> env) {
Collection<String> resources = Collections2.transform(sources, source -> filterForEnvironmentVars(env, source).trim());
return new Add(resources, destination);
}
public Iterable<String> getFileResources() {<FILL_FUNCTION_BODY>}
/**
* Createa an Add if it matches, or missing if not.
*
* @param statement
* statement that may be an ADD or a COPY
* @return optional typed item.
*/
public static Optional<Add> create(String statement) {
Matcher argumentMatcher = ARGUMENT_TOKENIZER.matcher(statement.trim());
if (!argumentMatcher.find()) {
return Optional.absent();
}
String commandName = argumentMatcher.group();
if (!(StringUtils.equals(commandName, "ADD") || StringUtils.equals(commandName, "COPY"))) {
return Optional.absent();
}
String lastToken = null;
Collection<String> sources = new ArrayList<>();
while (argumentMatcher.find()) {
if (lastToken != null) {
sources.add(lastToken);
}
lastToken = argumentMatcher.group().replaceAll("(^\")|(\"$)", "");
}
if (sources.isEmpty()) {
throw new DockerClientException("Wrong ADD or COPY format");
}
return Optional.of(new Add(sources, lastToken));
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this).add("sources", sources).add("destination", destination).toString();
}
}
public static class Env extends DockerfileStatement<Env> {
private static final Pattern ENV_PATTERN = Pattern.compile("^ENV\\s+(.*)\\s+(.*)$");
public final String variable;
public final String value;
private Env(String variable, String value) {
this.variable = variable;
this.value = value;
}
private Env(Matcher envMatcher) {
this.variable = envMatcher.group(1).trim();
this.value = envMatcher.group(2).trim();
}
public static Optional<Env> create(String statement) {
Matcher matcher = ENV_PATTERN.matcher(statement.trim());
if (!matcher.find()) {
return Optional.absent();
}
if (matcher.groupCount() != 2) {
throw new DockerClientException("Wrong ENV format");
}
return Optional.of(new Env(matcher));
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this).add("variable", variable).add("value", value).toString();
}
}
/**
* Return a dockerfile statement
*/
public static Optional<? extends DockerfileStatement> createFromLine(String cmd) {
if (cmd.trim().isEmpty() || cmd.startsWith("#")) {
return Optional.absent();
}
Optional<? extends DockerfileStatement> line;
line = Add.create(cmd);
if (line.isPresent()) {
return line;
}
line = Env.create(cmd);
if (line.isPresent()) {
return line;
}
return Optional.of(new OtherLine(cmd));
}
} |
return Collections2.filter(sources, source -> {
URI uri;
try {
uri = new URI(source);
} catch (URISyntaxException e) {
return false;
}
return uri.getScheme() == null || "file".equals(uri.getScheme());
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/AbstrAsyncDockerCmdExec.java | AbstrAsyncDockerCmdExec | execute | class AbstrAsyncDockerCmdExec<CMD_T extends AsyncDockerCmd<CMD_T, A_RES_T>, A_RES_T> extends
AbstrDockerCmdExec implements DockerCmdAsyncExec<CMD_T, A_RES_T> {
public AbstrAsyncDockerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
public Void exec(CMD_T command, ResultCallback<A_RES_T> resultCallback) {
return execute(command, resultCallback);
}
protected final Void execute(final CMD_T command, final ResultCallback<A_RES_T> resultCallback) {<FILL_FUNCTION_BODY>}
protected abstract Void execute0(final CMD_T command, final ResultCallback<A_RES_T> resultCallback);
} |
ResultCallback<A_RES_T> delegatingResultCallback = new ResultCallback<A_RES_T>() {
@Override
public void close() throws IOException {
resultCallback.close();
command.close();
}
@Override
public void onStart(Closeable closeable) {
resultCallback.onStart(closeable);
}
@Override
public void onNext(A_RES_T object) {
resultCallback.onNext(object);
}
@Override
public void onError(Throwable throwable) {
resultCallback.onError(throwable);
}
@Override
public void onComplete() {
resultCallback.onComplete();
command.close();
}
};
execute0(command, delegatingResultCallback);
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/AbstrDockerCmdExec.java | AbstrDockerCmdExec | registryConfigs | class AbstrDockerCmdExec {
private final transient DockerClientConfig dockerClientConfig;
private final transient WebTarget baseResource;
public AbstrDockerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
this.baseResource = Objects.requireNonNull(baseResource, "baseResource was not specified");
this.dockerClientConfig = Objects.requireNonNull(dockerClientConfig, "dockerClientConfig was not specified");
}
protected WebTarget getBaseResource() {
return baseResource;
}
@CheckForNull
protected AuthConfigurations getBuildAuthConfigs() {
return dockerClientConfig.getAuthConfigurations();
}
protected String registryAuth(@Nonnull AuthConfig authConfig) {
try {
return BaseEncoding.base64Url().encode(dockerClientConfig.getObjectMapper().writeValueAsString(authConfig).getBytes());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Nonnull
protected String registryConfigs(@Nonnull AuthConfigurations authConfigs) {<FILL_FUNCTION_BODY>}
@Nonnull
protected InvocationBuilder resourceWithAuthConfig(@Nonnull AuthConfig authConfig,
@Nonnull InvocationBuilder request) {
return request.header("X-Registry-Auth", registryAuth(authConfig));
}
@Nonnull
protected InvocationBuilder resourceWithOptionalAuthConfig(@CheckForNull AuthConfig authConfig,
@Nonnull InvocationBuilder request) {
if (authConfig != null) {
request = resourceWithAuthConfig(authConfig, request);
}
return request;
}
protected boolean bool(Boolean bool) {
return bool != null && bool;
}
protected WebTarget booleanQueryParam(WebTarget webTarget, String name, Boolean value) {
if (bool(value)) {
webTarget = webTarget.queryParam(name, bool(value) + "");
}
return webTarget;
}
} |
try {
final String json;
final RemoteApiVersion apiVersion = dockerClientConfig.getApiVersion();
ObjectMapper objectMapper = dockerClientConfig.getObjectMapper();
if (apiVersion.equals(UNKNOWN_VERSION)) {
ObjectNode rootNode = objectMapper.valueToTree(authConfigs.getConfigs()); // all registries
final ObjectNode authNodes = objectMapper.valueToTree(authConfigs); // wrapped in "configs":{}
rootNode.setAll(authNodes); // merge 2 variants
json = rootNode.toString();
} else if (apiVersion.isGreaterOrEqual(VERSION_1_19)) {
json = objectMapper.writeValueAsString(authConfigs.getConfigs());
} else {
json = objectMapper.writeValueAsString(authConfigs);
}
return BaseEncoding.base64Url().encode(json.getBytes());
} catch (IOException e) {
throw new RuntimeException(e);
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/AbstrSyncDockerCmdExec.java | AbstrSyncDockerCmdExec | exec | class AbstrSyncDockerCmdExec<CMD_T extends DockerCmd<RES_T>, RES_T> extends AbstrDockerCmdExec
implements DockerCmdSyncExec<CMD_T, RES_T> {
public AbstrSyncDockerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
public RES_T exec(CMD_T command) {<FILL_FUNCTION_BODY>}
protected abstract RES_T execute(CMD_T command);
} |
// this hack works because of ResponseStatusExceptionFilter
try (CMD_T cmd = command) {
try {
return execute(cmd);
} catch (RuntimeException e) {
if (e.getCause() instanceof DockerException) {
throw (DockerException) e.getCause();
} else {
throw e;
}
}
}
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/AttachContainerCmdExec.java | AttachContainerCmdExec | execute0 | class AttachContainerCmdExec extends AbstrAsyncDockerCmdExec<AttachContainerCmd, Frame> implements
AttachContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(AttachContainerCmdExec.class);
public AttachContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute0(AttachContainerCmd command, ResultCallback<Frame> resultCallback) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/containers/{id}/attach").resolveTemplate("id",
command.getContainerId());
webTarget = booleanQueryParam(webTarget, "logs", command.hasLogsEnabled());
webTarget = booleanQueryParam(webTarget, "stdout", command.hasStdoutEnabled());
webTarget = booleanQueryParam(webTarget, "stderr", command.hasStderrEnabled());
webTarget = booleanQueryParam(webTarget, "stdin", command.getStdin() != null);
webTarget = booleanQueryParam(webTarget, "stream", command.hasFollowStreamEnabled());
LOGGER.trace("POST: {}", webTarget);
webTarget.request().post(null, command.getStdin(), resultCallback);
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/AuthCmdExec.java | AuthCmdExec | execute | class AuthCmdExec extends AbstrSyncDockerCmdExec<AuthCmd, AuthResponse> implements AuthCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(AuthCmdExec.class);
public AuthCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected AuthResponse execute(AuthCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/auth");
LOGGER.trace("POST: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command.getAuthConfig(), new TypeReference<AuthResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/BuildImageCmdExec.java | BuildImageCmdExec | execute0 | class BuildImageCmdExec extends AbstrAsyncDockerCmdExec<BuildImageCmd, BuildResponseItem> implements
BuildImageCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(BuildImageCmdExec.class);
public BuildImageCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
private InvocationBuilder resourceWithOptionalAuthConfig(BuildImageCmd command, InvocationBuilder request) {
final AuthConfigurations authConfigs = firstNonNull(command.getBuildAuthConfigs(), getBuildAuthConfigs());
if (authConfigs != null && !authConfigs.getConfigs().isEmpty()) {
request = request.header("X-Registry-Config", registryConfigs(authConfigs));
}
return request;
}
@CheckForNull
private static AuthConfigurations firstNonNull(@CheckForNull final AuthConfigurations fromCommand,
@CheckForNull final AuthConfigurations fromConfig) {
if (fromCommand != null) {
return fromCommand;
}
if (fromConfig != null) {
return fromConfig;
}
return null;
}
@Override
protected Void execute0(BuildImageCmd command, ResultCallback<BuildResponseItem> resultCallback) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/build");
String dockerFilePath = command.getPathToDockerfile();
if (dockerFilePath != null && command.getRemote() == null && !"Dockerfile".equals(dockerFilePath)) {
webTarget = webTarget.queryParam("dockerfile", dockerFilePath);
}
if (command.getTags() != null && !command.getTags().isEmpty()) {
webTarget = webTarget.queryParamsSet("t", command.getTags());
} else if (isNotBlank(command.getTag())) {
webTarget = webTarget.queryParam("t", command.getTag());
}
if (command.getCacheFrom() != null && !command.getCacheFrom().isEmpty()) {
webTarget = webTarget.queryParam("cachefrom", jsonEncode(command.getCacheFrom()));
}
if (command.getRemote() != null) {
webTarget = webTarget.queryParam("remote", command.getRemote().toString());
}
webTarget = booleanQueryParam(webTarget, "q", command.isQuiet());
webTarget = booleanQueryParam(webTarget, "nocache", command.hasNoCacheEnabled());
webTarget = booleanQueryParam(webTarget, "pull", command.hasPullEnabled());
webTarget = booleanQueryParam(webTarget, "rm", command.hasRemoveEnabled());
webTarget = booleanQueryParam(webTarget, "forcerm", command.isForcerm());
// this has to be handled differently as it should switch to 'false'
if (command.hasRemoveEnabled() == null || !command.hasRemoveEnabled()) {
webTarget = webTarget.queryParam("rm", "false");
}
if (command.getMemory() != null) {
webTarget = webTarget.queryParam("memory", command.getMemory());
}
if (command.getMemswap() != null) {
webTarget = webTarget.queryParam("memswap", command.getMemswap());
}
if (command.getCpushares() != null) {
webTarget = webTarget.queryParam("cpushares", command.getCpushares());
}
if (command.getCpusetcpus() != null) {
webTarget = webTarget.queryParam("cpusetcpus", command.getCpusetcpus());
}
if (command.getBuildArgs() != null) {
webTarget = webTarget.queryParamsJsonMap("buildargs", command.getBuildArgs());
}
if (command.getShmsize() != null) {
webTarget = webTarget.queryParam("shmsize", command.getShmsize());
}
if (command.getLabels() != null) {
webTarget = webTarget.queryParamsJsonMap("labels", command.getLabels());
}
if (command.getNetworkMode() != null) {
webTarget = webTarget.queryParam("networkmode", command.getNetworkMode());
}
if (command.getPlatform() != null) {
webTarget = webTarget.queryParam("platform", command.getPlatform());
}
if (command.getTarget() != null) {
webTarget = webTarget.queryParam("target", command.getTarget());
}
if (command.getExtraHosts() != null) {
webTarget = webTarget.queryParamsSet("extrahosts", command.getExtraHosts());
}
LOGGER.trace("POST: {}", webTarget);
InvocationBuilder builder = resourceWithOptionalAuthConfig(command, webTarget.request())
.accept(MediaType.APPLICATION_JSON)
.header("Content-Type", "application/tar")
.header("encoding", "gzip");
builder.post(new TypeReference<BuildResponseItem>() {
}, resultCallback, command.getTarInputStream());
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CommitCmdExec.java | CommitCmdExec | execute | class CommitCmdExec extends AbstrSyncDockerCmdExec<CommitCmd, String> implements CommitCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CommitCmdExec.class);
public CommitCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected String execute(CommitCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/commit").queryParam("container", command.getContainerId())
.queryParam("repo", command.getRepository()).queryParam("tag", command.getTag())
.queryParam("m", command.getMessage()).queryParam("author", command.getAuthor());
webTarget = booleanQueryParam(webTarget, "pause", command.hasPauseEnabled());
LOGGER.trace("POST: {}", webTarget);
ObjectNode objectNode = webTarget.request().accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<ObjectNode>() {
});
return objectNode.get("Id").asText();
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/ConnectToNetworkCmdExec.java | ConnectToNetworkCmdExec | execute | class ConnectToNetworkCmdExec extends AbstrSyncDockerCmdExec<ConnectToNetworkCmd, Void>
implements ConnectToNetworkCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(ConnectToNetworkCmdExec.class);
public ConnectToNetworkCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute(ConnectToNetworkCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/networks/" + command.getNetworkId() + "/connect");
LOGGER.trace("POST: {}", webTarget);
try {
webTarget.request().post(command).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/ContainerDiffCmdExec.java | ContainerDiffCmdExec | execute | class ContainerDiffCmdExec extends AbstrSyncDockerCmdExec<ContainerDiffCmd, List<ChangeLog>> implements
ContainerDiffCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(ContainerDiffCmdExec.class);
public ContainerDiffCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected List<ChangeLog> execute(ContainerDiffCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/changes").resolveTemplate("id",
command.getContainerId());
LOGGER.trace("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<List<ChangeLog>>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CopyArchiveFromContainerCmdExec.java | CopyArchiveFromContainerCmdExec | execute | class CopyArchiveFromContainerCmdExec extends AbstrSyncDockerCmdExec<CopyArchiveFromContainerCmd, InputStream>
implements CopyArchiveFromContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CopyArchiveFromContainerCmdExec.class);
public CopyArchiveFromContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InputStream execute(CopyArchiveFromContainerCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/archive").resolveTemplate("id",
command.getContainerId());
LOGGER.trace("Get: " + webResource.toString());
return webResource.queryParam("path", command.getResource()).request().accept(MediaType.APPLICATION_X_TAR)
.get();
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CopyArchiveToContainerCmdExec.java | CopyArchiveToContainerCmdExec | execute | class CopyArchiveToContainerCmdExec extends AbstrSyncDockerCmdExec<CopyArchiveToContainerCmd, Void> implements
CopyArchiveToContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CopyArchiveFromContainerCmdExec.class);
public CopyArchiveToContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute(CopyArchiveToContainerCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/archive").resolveTemplate("id",
command.getContainerId());
LOGGER.trace("PUT: " + webResource.toString());
InputStream streamToUpload = command.getTarInputStream();
webResource.queryParam("path", command.getRemotePath())
.queryParam("noOverwriteDirNonDir", command.isNoOverwriteDirNonDir())
.queryParam("copyUIDGID", command.isCopyUIDGID())
.request()
.put(streamToUpload, MediaType.APPLICATION_X_TAR);
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CopyFileFromContainerCmdExec.java | CopyFileFromContainerCmdExec | execute | class CopyFileFromContainerCmdExec extends AbstrSyncDockerCmdExec<CopyFileFromContainerCmd, InputStream>
implements CopyFileFromContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CopyFileFromContainerCmdExec.class);
public CopyFileFromContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InputStream execute(CopyFileFromContainerCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/copy").resolveTemplate("id",
command.getContainerId());
LOGGER.trace("POST: " + webResource.toString());
return webResource.request().accept(MediaType.APPLICATION_OCTET_STREAM)
.post(command);
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateConfigCmdExec.java | CreateConfigCmdExec | execute | class CreateConfigCmdExec extends AbstrSyncDockerCmdExec<CreateConfigCmd, CreateConfigResponse>
implements CreateConfigCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateConfigCmdExec.class);
public CreateConfigCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateConfigResponse execute(CreateConfigCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/configs/create");
LOGGER.trace("POST: {} ", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<CreateConfigResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateContainerCmdExec.java | CreateContainerCmdExec | execute | class CreateContainerCmdExec extends AbstrSyncDockerCmdExec<CreateContainerCmd, CreateContainerResponse>
implements CreateContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateContainerCmdExec.class);
public CreateContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateContainerResponse execute(CreateContainerCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/create");
if (command.getName() != null) {
webResource = webResource.queryParam("name", command.getName());
}
if (command.getPlatform() != null) {
webResource = webResource.queryParam("platform", command.getPlatform());
}
LOGGER.trace("POST: {} ", webResource);
return resourceWithOptionalAuthConfig(command.getAuthConfig(), webResource.request())
.accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<CreateContainerResponse>() { });
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateImageCmdExec.java | CreateImageCmdExec | execute | class CreateImageCmdExec extends AbstrSyncDockerCmdExec<CreateImageCmd, CreateImageResponse> implements
CreateImageCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateImageCmdExec.class);
public CreateImageCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateImageResponse execute(CreateImageCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/images/create").queryParam("repo", command.getRepository())
.queryParam("tag", command.getTag()).queryParam("fromSrc", "-");
if (command.getPlatform() != null) {
webResource = webResource.queryParam("platform", command.getPlatform());
}
LOGGER.trace("POST: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_OCTET_STREAM)
.post(new TypeReference<CreateImageResponse>() {
}, command.getImageStream());
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateNetworkCmdExec.java | CreateNetworkCmdExec | execute | class CreateNetworkCmdExec extends AbstrSyncDockerCmdExec<CreateNetworkCmd, CreateNetworkResponse> implements
CreateNetworkCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateNetworkCmdExec.class);
public CreateNetworkCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateNetworkResponse execute(CreateNetworkCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/networks/create");
LOGGER.trace("POST: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<CreateNetworkResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateSecretCmdExec.java | CreateSecretCmdExec | execute | class CreateSecretCmdExec extends AbstrSyncDockerCmdExec<CreateSecretCmd, CreateSecretResponse>
implements CreateSecretCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateSecretCmdExec.class);
public CreateSecretCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateSecretResponse execute(CreateSecretCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/secrets/create");
LOGGER.trace("POST: {} ", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command.getSecretSpec(), new TypeReference<CreateSecretResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateServiceCmdExec.java | CreateServiceCmdExec | execute | class CreateServiceCmdExec extends AbstrSyncDockerCmdExec<CreateServiceCmd, CreateServiceResponse>
implements CreateServiceCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateServiceCmdExec.class);
public CreateServiceCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateServiceResponse execute(CreateServiceCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/services/create");
LOGGER.trace("POST: {} ", webResource);
InvocationBuilder builder = resourceWithOptionalAuthConfig(command.getAuthConfig(), webResource.request())
.accept(MediaType.APPLICATION_JSON);
return builder.post(command.getServiceSpec(), new TypeReference<CreateServiceResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/CreateVolumeCmdExec.java | CreateVolumeCmdExec | execute | class CreateVolumeCmdExec extends AbstrSyncDockerCmdExec<CreateVolumeCmd, CreateVolumeResponse> implements
CreateVolumeCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateVolumeCmdExec.class);
public CreateVolumeCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected CreateVolumeResponse execute(CreateVolumeCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/volumes/create");
LOGGER.trace("POST: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<CreateVolumeResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/DisconnectFromNetworkCmdExec.java | DisconnectFromNetworkCmdExec | execute | class DisconnectFromNetworkCmdExec extends AbstrSyncDockerCmdExec<DisconnectFromNetworkCmd, Void>
implements DisconnectFromNetworkCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(DisconnectFromNetworkCmdExec.class);
public DisconnectFromNetworkCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute(DisconnectFromNetworkCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/networks/" + command.getNetworkId() + "/disconnect");
LOGGER.trace("POST: {}", webTarget);
try {
webTarget.request().post(command).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/EventsCmdExec.java | EventsCmdExec | execute0 | class EventsCmdExec extends AbstrAsyncDockerCmdExec<EventsCmd, Event> implements EventsCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(EventsCmdExec.class);
public EventsCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute0(EventsCmd command, ResultCallback<Event> resultCallback) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/events").queryParam("since", command.getSince())
.queryParam("until", command.getUntil());
if (command.getFilters() != null && !command.getFilters().isEmpty()) {
webTarget = webTarget
.queryParam("filters", FiltersEncoder.jsonEncode(command.getFilters()));
}
LOGGER.trace("GET: {}", webTarget);
webTarget.request().get(new TypeReference<Event>() {
}, resultCallback);
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/ExecCreateCmdExec.java | ExecCreateCmdExec | execute | class ExecCreateCmdExec extends AbstrSyncDockerCmdExec<ExecCreateCmd, ExecCreateCmdResponse> implements
ExecCreateCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(ExecCreateCmdExec.class);
public ExecCreateCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected ExecCreateCmdResponse execute(ExecCreateCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/exec").resolveTemplate("id",
command.getContainerId());
LOGGER.trace("POST: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.post(command, new TypeReference<ExecCreateCmdResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/ExecStartCmdExec.java | ExecStartCmdExec | execute0 | class ExecStartCmdExec extends AbstrAsyncDockerCmdExec<ExecStartCmd, Frame> implements ExecStartCmd.Exec {
public ExecStartCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute0(ExecStartCmd command, ResultCallback<Frame> resultCallback) {<FILL_FUNCTION_BODY>}
} |
WebTarget webTarget = getBaseResource().path("/exec/{id}/start").resolveTemplate("id", command.getExecId());
webTarget.request().accept(MediaType.APPLICATION_JSON).post(command, command.getStdin(), resultCallback);
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InitializeSwarmCmdExec.java | InitializeSwarmCmdExec | execute | class InitializeSwarmCmdExec extends AbstrSyncDockerCmdExec<InitializeSwarmCmd, Void>
implements InitializeSwarmCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InitializeSwarmCmdExec.class);
public InitializeSwarmCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Void execute(InitializeSwarmCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/swarm/init");
LOGGER.trace("POST: {} ", webResource);
try {
webResource.request().accept(MediaType.APPLICATION_JSON).post(command).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
return null;
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectConfigCmdExec.java | InspectConfigCmdExec | execute | class InspectConfigCmdExec extends AbstrSyncDockerCmdExec<InspectConfigCmd, Config>
implements InspectConfigCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectConfigCmdExec.class);
public InspectConfigCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Config execute(InspectConfigCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/configs/{id}")
.resolveTemplate("id", command.getConfigId());
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<Config>() { });
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectContainerCmdExec.java | InspectContainerCmdExec | execute | class InspectContainerCmdExec extends AbstrSyncDockerCmdExec<InspectContainerCmd, InspectContainerResponse>
implements InspectContainerCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectContainerCmdExec.class);
public InspectContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InspectContainerResponse execute(InspectContainerCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/containers/{id}/json").resolveTemplate("id",
command.getContainerId());
webResource = booleanQueryParam(webResource, "size", command.getSize());
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.get(new TypeReference<InspectContainerResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectExecCmdExec.java | InspectExecCmdExec | execute | class InspectExecCmdExec extends AbstrSyncDockerCmdExec<InspectExecCmd, InspectExecResponse> implements
InspectExecCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectExecCmdExec.class);
public InspectExecCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InspectExecResponse execute(InspectExecCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/exec/{id}/json").resolveTemplate("id", command.getExecId());
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<InspectExecResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectImageCmdExec.java | InspectImageCmdExec | execute | class InspectImageCmdExec extends AbstrSyncDockerCmdExec<InspectImageCmd, InspectImageResponse> implements
InspectImageCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectImageCmdExec.class);
public InspectImageCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InspectImageResponse execute(InspectImageCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/images/{id}/json").resolveTemplate("id", command.getImageId());
LOGGER.trace("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<InspectImageResponse>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectNetworkCmdExec.java | InspectNetworkCmdExec | execute | class InspectNetworkCmdExec extends AbstrSyncDockerCmdExec<InspectNetworkCmd, Network> implements
InspectNetworkCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectNetworkCmdExec.class);
public InspectNetworkCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Network execute(InspectNetworkCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/networks/{id}").resolveTemplate("id", command.getNetworkId());
LOGGER.trace("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<Network>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectServiceCmdExec.java | InspectServiceCmdExec | execute | class InspectServiceCmdExec extends AbstrSyncDockerCmdExec<InspectServiceCmd, Service>
implements InspectServiceCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectServiceCmdExec.class);
public InspectServiceCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Service execute(InspectServiceCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/services/{id}")
.resolveTemplate("id", command.getServiceId());
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<Service>() { });
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectSwarmCmdExec.java | InspectSwarmCmdExec | execute | class InspectSwarmCmdExec extends AbstrSyncDockerCmdExec<InspectSwarmCmd, Swarm>
implements InspectSwarmCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectSwarmCmdExec.class);
public InspectSwarmCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected Swarm execute(InspectSwarmCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/swarm");
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.get(new TypeReference<Swarm>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectSwarmNodeCmdExec.java | InspectSwarmNodeCmdExec | execute | class InspectSwarmNodeCmdExec extends AbstrSyncDockerCmdExec<InspectSwarmNodeCmd, SwarmNode>
implements InspectSwarmNodeCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectSwarmNodeCmdExec.class);
public InspectSwarmNodeCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected SwarmNode execute(InspectSwarmNodeCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/nodes/{id}").resolveTemplate("id",
command.getSwarmNodeId());
LOGGER.debug("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON)
.get(new TypeReference<SwarmNode>() {
});
|
docker-java_docker-java | docker-java/docker-java-core/src/main/java/com/github/dockerjava/core/exec/InspectVolumeCmdExec.java | InspectVolumeCmdExec | execute | class InspectVolumeCmdExec extends AbstrSyncDockerCmdExec<InspectVolumeCmd, InspectVolumeResponse> implements
InspectVolumeCmd.Exec {
private static final Logger LOGGER = LoggerFactory.getLogger(InspectVolumeCmdExec.class);
public InspectVolumeCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
super(baseResource, dockerClientConfig);
}
@Override
protected InspectVolumeResponse execute(InspectVolumeCmd command) {<FILL_FUNCTION_BODY>}
} |
WebTarget webResource = getBaseResource().path("/volumes/{name}").resolveTemplate("name", command.getName());
LOGGER.trace("GET: {}", webResource);
return webResource.request().accept(MediaType.APPLICATION_JSON).get(new TypeReference<InspectVolumeResponse>() {
});
|