com.github.dockerjava.core.DockerConfigFile Maven / Gradle / Ivy
package com.github.dockerjava.core;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.dockerjava.api.model.AuthConfig;
import com.github.dockerjava.api.model.AuthConfigurations;
import java.util.Objects;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class DockerConfigFile {
private static final String DOCKER_LEGACY_CFG = ".dockercfg";
private static final String DOCKER_CFG = "config.json";
private static final TypeReference> CONFIG_MAP_TYPE = new TypeReference>() {
};
@JsonProperty
private Map auths;
@JsonProperty
private String currentContext;
public DockerConfigFile() {
this(new HashMap<>());
}
private DockerConfigFile(Map authConfigMap) {
auths = authConfigMap;
}
@Nonnull
public Map getAuths() {
return auths;
}
@JsonSetter
public void setAuths(Map authConfigMap) {
auths = (authConfigMap == null || authConfigMap.size() == 0) ? new HashMap<>() : authConfigMap;
}
void addAuthConfig(AuthConfig config) {
auths.put(config.getRegistryAddress(), config);
}
void setCurrentContext(String currentContext) {
this.currentContext = currentContext;
}
public String getCurrentContext() {
return currentContext;
}
@CheckForNull
public AuthConfig resolveAuthConfig(@CheckForNull String hostname) {
if (StringUtils.isEmpty(hostname) || AuthConfig.DEFAULT_SERVER_ADDRESS.equals(hostname)) {
return auths.get(AuthConfig.DEFAULT_SERVER_ADDRESS);
}
AuthConfig c = auths.get(hostname);
if (c != null) {
return c;
}
// Maybe they have a legacy config file, we will iterate the keys converting
// them to the new format and testing
String normalizedHostname = convertToHostname(hostname);
for (Map.Entry entry : auths.entrySet()) {
String registry = entry.getKey();
AuthConfig config = entry.getValue();
if (convertToHostname(registry).equals(normalizedHostname)) {
return config;
}
}
return null;
}
@Nonnull
public AuthConfigurations getAuthConfigurations() {
final AuthConfigurations authConfigurations = new AuthConfigurations();
for (Map.Entry authConfigEntry : auths.entrySet()) {
authConfigurations.addConfig(authConfigEntry.getValue());
}
return authConfigurations;
}
// CHECKSTYLE:OFF
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((auths == null) ? 0 : auths.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DockerConfigFile other = (DockerConfigFile) obj;
if (auths == null) {
if (other.auths != null)
return false;
} else if (!auths.equals(other.auths))
return false;
if (!Objects.equals(currentContext, other.currentContext)) {
return false;
}
return true;
}
// CHECKSTYLE:ON
@Override
public String toString() {
return "DockerConfigFile [auths=" + auths + ", currentContext='" + currentContext + "']";
}
@Nonnull
@Deprecated
public static DockerConfigFile loadConfig(@CheckForNull String dockerConfigPath) throws IOException {
return loadConfig(DefaultObjectMapperHolder.INSTANCE.getObjectMapper(), dockerConfigPath);
}
@Nonnull
public static DockerConfigFile loadConfig(ObjectMapper objectMapper, @CheckForNull String dockerConfigPath) throws IOException {
// no any configs, but for empty auths return non null object
if (dockerConfigPath == null) {
return new DockerConfigFile();
}
//parse new docker config file format
DockerConfigFile dockerConfig = loadCurrentConfig(objectMapper, dockerConfigPath);
//parse old auth config file format
if (dockerConfig == null) {
dockerConfig = loadLegacyConfig(objectMapper, dockerConfigPath);
}
//otherwise create default config
if (dockerConfig == null) {
dockerConfig = new DockerConfigFile();
}
for (Map.Entry entry : dockerConfig.getAuths().entrySet()) {
AuthConfig authConfig = entry.getValue();
decodeAuth(authConfig);
authConfig.withAuth(null);
authConfig.withRegistryAddress(entry.getKey());
}
return dockerConfig;
}
@CheckForNull
private static DockerConfigFile loadCurrentConfig(ObjectMapper objectMapper, @CheckForNull String dockerConfigPath) throws IOException {
File dockerCfgFile = new File(dockerConfigPath, DOCKER_CFG);
if (!dockerCfgFile.exists() || !dockerCfgFile.isFile()) {
return null;
}
try {
return objectMapper.readValue(dockerCfgFile, DockerConfigFile.class);
} catch (IOException e) {
throw new IOException("Failed to parse docker " + DOCKER_CFG, e);
}
}
@CheckForNull
private static DockerConfigFile loadLegacyConfig(ObjectMapper objectMapper, String dockerConfigPath) throws IOException {
File dockerLegacyCfgFile = new File(dockerConfigPath, DOCKER_LEGACY_CFG);
if (!dockerLegacyCfgFile.exists() || !dockerLegacyCfgFile.isFile()) {
return null;
}
//parse legacy auth config file format
try {
return new DockerConfigFile(objectMapper.>readValue(dockerLegacyCfgFile, CONFIG_MAP_TYPE));
} catch (IOException e) {
// pass
}
List authFileContent = FileUtils.readLines(dockerLegacyCfgFile, StandardCharsets.UTF_8);
if (authFileContent.size() < 2) {
throw new IOException("The Auth Config file is empty");
}
AuthConfig config = new AuthConfig();
String[] origAuth = authFileContent.get(0).split(" = ");
if (origAuth.length != 2) {
throw new IOException("Invalid Auth config file");
}
config.withAuth(origAuth[1]);
String[] origEmail = authFileContent.get(1).split(" = ");
if (origEmail.length != 2) {
throw new IOException("Invalid Auth config file");
}
config.withEmail(origEmail[1]);
return new DockerConfigFile(new HashMap<>(Collections.singletonMap(config.getRegistryAddress(), config)));
}
private static void decodeAuth(AuthConfig config) throws IOException {
if (config.getAuth() == null) {
return;
}
String str = new String(Base64.getDecoder().decode(config.getAuth()), StandardCharsets.UTF_8);
String[] parts = str.split(":", 2);
if (parts.length != 2) {
throw new IOException("Invalid auth configuration file");
}
config.withUsername(parts[0]);
config.withPassword(parts[1]);
}
static String convertToHostname(String server) {
String stripped = server;
if (server.startsWith("http://")) {
stripped = server.substring(7);
} else if (server.startsWith("https://")) {
stripped = server.substring(8);
}
String[] numParts = stripped.split("/", 2);
return numParts[0];
}
}