/** * Set the URI for connections to Docker. * * @param uri URI String for connections to Docker * @return Builder */ public Builder uri(final String uri) { return uri(URI.create(uri)); }
builder.uri(endpoint); } else if (endpoint.startsWith(NPIPE_SCHEME + "://")) { builder.uri(endpoint); } else { final String stripped = endpoint.replaceAll(".*://", ""); final String address = isNullOrEmpty(hostText) ? DockerHost.defaultAddress() : hostText; builder.uri(scheme + "://" + address + ":" + port);
private DockerClient createDockerClient(final AgentConfig config) throws IOException { final DefaultDockerClient.Builder builder = DefaultDockerClient.builder() .uri(config.getDockerHost().uri()); if (config.getConnectionPoolSize() != -1) { builder.connectionPoolSize(config.getConnectionPoolSize()); } if (!isNullOrEmpty(config.getDockerHost().dockerCertPath())) { final Path dockerCertPath = java.nio.file.Paths.get(config.getDockerHost().dockerCertPath()); final DockerCertificates dockerCertificates; try { dockerCertificates = new DockerCertificates(dockerCertPath); } catch (DockerCertificateException e) { throw new RuntimeException(e); } builder.dockerCertificates(dockerCertificates); } if (config.getGoogleCredentials() != null) { builder.registryAuthSupplier( ContainerRegistryAuthSupplier .forCredentials(config.getGoogleCredentials()) .build() ); } return new PollingDockerClient(builder); }
try { if (System.getProperty("os.name").toLowerCase().contains("mac")) { dockerClient = DefaultDockerClient.builder().uri(DefaultDockerClient.DEFAULT_UNIX_ENDPOINT).build();
/** * Create a new {@link DefaultDockerClient} builder prepopulated with values loaded from the * DOCKER_HOST and DOCKER_CERT_PATH environment variables. * * @return Returns a builder that can be used to further customize and then build the client. * @throws DockerCertificateException if we could not build a DockerCertificates object */ public static Builder fromEnv() throws DockerCertificateException { final String endpoint = DockerHost.endpointFromEnv(); final Path dockerCertPath = Paths.get(firstNonNull(DockerHost.certPathFromEnv(), DockerHost.defaultCertPath())); final Builder builder = new Builder(); final Optional<DockerCertificatesStore> certs = DockerCertificates.builder() .dockerCertPath(dockerCertPath).build(); if (endpoint.startsWith(UNIX_SCHEME + "://")) { builder.uri(endpoint); } else { final String stripped = endpoint.replaceAll(".*://", ""); final HostAndPort hostAndPort = HostAndPort.fromString(stripped); final String hostText = hostAndPort.getHost(); final String scheme = certs.isPresent() ? "https" : "http"; final int port = hostAndPort.getPortOrDefault(DockerHost.defaultPort()); final String address = isNullOrEmpty(hostText) ? DockerHost.defaultAddress() : hostText; builder.uri(scheme + "://" + address + ":" + port); } if (certs.isPresent()) { builder.dockerCertificates(certs.get()); } return builder; }
public DockerService(Config config, InternalPreferences preferences) { this.config = config; this.preferences = preferences; dockerDefaultSocket = getConfig().getDockerDefaultSocket(); dockerWaitTimeoutSec = getConfig().getDockerWaitTimeoutSec(); dockerPollTimeMs = getConfig().getDockerPollTimeMs(); String dockerServerUrl = getConfig().getDockerServerUrl(); Builder dockerClientBuilder = null; if (dockerServerUrl.isEmpty()) { try { dockerClientBuilder = DefaultDockerClient.fromEnv(); } catch (DockerCertificateException e) { throw new SeleniumJupiterException(e); } } else { log.debug("Using Docker server URL {}", dockerServerUrl); dockerClientBuilder = DefaultDockerClient.builder() .uri(dockerServerUrl); } dockerClient = dockerClientBuilder.build(); }
public static void main(String[] args) throws DockerException, InterruptedException { System.out.println("Testing"); // Create a client based on DOCKER_HOST and DOCKER_CERT_PATH env vars try { final DockerClient docker = DefaultDockerClient.builder() .uri("http://192.168.99.100:2375") .build(); //Create a container ContainerConfig cc = ContainerConfig.builder() .image("nginx") .build(); final ContainerCreation container = docker.createContainer(cc); docker.startContainer(container.id()); } catch (Exception ex) { ex.printStackTrace(); } } }
@Override public Map<String, String> validateSettings(Map<String, String> settings) { Map<String, String> errors = new HashMap<>(); String url = settings.get(DOCKER_URL); logger().info("Testing docker container for url {}", url); try { DockerClient testClient; if (url.startsWith("unix://")) { testClient = new DefaultDockerClient(url); } else { testClient = DefaultDockerClient.builder().uri(settings.get(DOCKER_URL)).build(); } testClient.ping(); } catch (DockerException | InterruptedException | NullPointerException e) { errors.put("Connection error", "Impossible to connect to " + settings.get(DOCKER_URL)); } return errors; }
/** * Public constructor. * * @param path {@code Path} of the file to write * @param append whether to append to the file or overwrite * @param targetImageName the {@code Pattern} for matching the name of the Docker image being profiled * @param dockerDaemonAddress the address of the Docker daemon */ public DockerJsonBenchmarkConsumer( final Path path, final boolean append, final Pattern targetImageName, final String dockerDaemonAddress) { super(path, append); _targetImageName = targetImageName; _dockerClient = DefaultDockerClient.builder() .uri(dockerDaemonAddress) .build(); }
public static DockerClient buildClient(URI dockerHost, Path certificatesPath) { try { if (dockerHost == null) { logger.info("Configuring docker host from environment"); return DefaultDockerClient.fromEnv().build(); } else { logger.info("Configuring docker host from configuration"); DefaultDockerClient.Builder builder = DefaultDockerClient.builder().uri(dockerHost); if (certificatesPath != null) { builder.dockerCertificates(new DockerCertificates(certificatesPath)); } return builder.build(); } } catch (DockerCertificateException e) { logger.error("Could not read certificates", e); throw new IllegalArgumentException("Could not read certificates: " + e.getMessage()); } }
public void updateDockerClient(String url) { log.debug("Updating Docker client using URL {}", url); dockerClient = DefaultDockerClient.builder().uri(url).build(); }
@Override protected void init() { String url = settings.get(DOCKER_URL); if (url.startsWith("unix://")) { client = new DefaultDockerClient(url); } else { client = DefaultDockerClient.builder().uri(url).build(); } }
public DockerClient buildDockerClient(Registry registry, String dockerHostUri, long connectTimeout, long readTimeout) { final DockerClient dockerClient = DefaultDockerClient.builder() .authConfig(registry.toAuthConfig()) .uri(dockerHostUri) .connectTimeoutMillis(connectTimeout) .readTimeoutMillis(readTimeout) .build(); return dockerClient; } }
DockerClient build(Registry registry, String dockerHost, long connectTimeout, long readTimeout) { final DockerClient dockerClient = DefaultDockerClient.builder() .authConfig(registry.toAuthConfig()) .uri(dockerHost) .connectTimeoutMillis(connectTimeout) .readTimeoutMillis(readTimeout) .build(); return dockerClient; } }
/** * Create a new client with default configuration. * * @param uri The docker rest api uri. * @param dockerCertificatesStore The certificates to use for HTTPS. */ public DefaultDockerClient(final URI uri, final DockerCertificatesStore dockerCertificatesStore) { this(new Builder().uri(uri).dockerCertificates(dockerCertificatesStore)); }
/** * Set the URI for connections to Docker. * * @param uri URI String for connections to Docker * @return Builder */ public Builder uri(final String uri) { return uri(URI.create(uri)); }
/** * Create a new client with default configuration. * * @param uri The docker rest api uri. */ public DefaultDockerClient(final URI uri) { this(new Builder().uri(uri)); }
@Provides @Singleton public DockerClient providesDockerClient(SingularityExecutorConfiguration configuration) { Builder dockerClientBuilder = DefaultDockerClient.builder() .uri(URI.create("unix://localhost/var/run/docker.sock")) .connectionPoolSize(configuration.getDockerClientConnectionPoolSize()); if(configuration.getDockerAuthConfig().isPresent()) { SingularityExecutorDockerAuthConfig authConfig = configuration.getDockerAuthConfig().get(); if(authConfig.isFromDockerConfig()) { try { dockerClientBuilder.registryAuth(RegistryAuth.fromDockerConfig().build()); } catch(IOException e) { throw Throwables.propagate(e); } } else { dockerClientBuilder.registryAuth(RegistryAuth.builder() .email(authConfig.getEmail()) .username(authConfig.getUsername()) .password(authConfig.getPassword()) .serverAddress(authConfig.getServerAddress()) .build()); } } return dockerClientBuilder.build(); }
/** * Create a new client with default configuration. * * @param uri The docker rest api uri. * @param dockerCertificatesStore The certificates to use for HTTPS. */ public DefaultDockerClient(final URI uri, final DockerCertificatesStore dockerCertificatesStore) { this(new Builder().uri(uri).dockerCertificates(dockerCertificatesStore)); }
/** * Create a new client with default configuration. * * @param uri The docker rest api uri. */ public DefaultDockerClient(final URI uri) { this(new Builder().uri(uri)); }