com.github.dockerjava.core.DockerClientConfig Java Examples

protected DockerClient getClientForConfig(DockerClientConfig config) {
    config = new AuthDelegatingDockerClientConfig(config);
    final DockerHttpClient dockerHttpClient;

    String transportType = TestcontainersConfiguration.getInstance().getTransportType();
    switch (transportType) {
        case "okhttp":
            dockerHttpClient = new OkDockerHttpClient.Builder()
                .dockerHost(config.getDockerHost())
                .sslConfig(config.getSSLConfig())
                .build();
            break;
        case "httpclient5":
            dockerHttpClient = new ZerodepDockerHttpClient.Builder()
                .dockerHost(config.getDockerHost())
                .sslConfig(config.getSSLConfig())
                .build();
            break;
        default:
            throw new IllegalArgumentException("Unknown transport type '" + transportType + "'");
    }

    return DockerClientImpl.getInstance(config, dockerHttpClient);
}
 

@Override
public EventLoopGroup init(Bootstrap bootstrap, final DockerClientConfig dockerClientConfig) {
    EventLoopGroup nioEventLoopGroup = new NioEventLoopGroup(0, new DefaultThreadFactory(threadPrefix));

    InetAddress addr = InetAddress.getLoopbackAddress();

    final SocketAddress proxyAddress = new InetSocketAddress(addr, 8008);

    Security.addProvider(new BouncyCastleProvider());

    ChannelFactory<NioSocketChannel> factory = () -> configure(new NioSocketChannel());

    bootstrap.group(nioEventLoopGroup).channelFactory(factory)
            .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(final SocketChannel channel) throws Exception {
                    // channel.pipeline().addLast(new
                    // HttpProxyHandler(proxyAddress));
                    channel.pipeline().addLast(new HttpClientCodec());
                    channel.pipeline().addLast(new HttpContentDecompressor());
                }
            });

    return nioEventLoopGroup;
}
 

@BeforeEach
public void init() {
  String dockerHost = (OVERRIDDEN_DOCKER_HOST != null) ? OVERRIDDEN_DOCKER_HOST : DEFAULT_DOCKER_HOST;
  // Assuming insecure docker engine
  DockerClientConfig config =
      DefaultDockerClientConfig.createDefaultConfigBuilder().withDockerHost(dockerHost).build();
  // using jaxrs/jersey implementation here (netty impl is also available)
  DockerCmdExecFactory dockerCmdExecFactory = new JerseyDockerCmdExecFactory().withConnectTimeout(1000)
      .withMaxTotalConnections(100).withMaxPerRouteConnections(10);
  dockerClient = DockerClientBuilder.getInstance(config).withDockerCmdExecFactory(dockerCmdExecFactory).build();
  await().atMost(60, SECONDS).until(this::servicesUp);
}
 

@NotNull
private DockerClientConfig tryConfiguration() {
    config = new DelegatingDockerClientConfig(
        DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(SOCKET_LOCATION)
            .withDockerTlsVerify(false)
            .build()
    );
    client = getClientForConfig(config);

    final int timeout = Integer.parseInt(System.getProperty(PING_TIMEOUT_PROPERTY_NAME, PING_TIMEOUT_DEFAULT));
    ping(client, timeout);

    return config;
}
 

@Override
public DockerClientImpl createDockerClient(DockerClientConfig config) {
    return (DockerClientImpl) DockerClientBuilder.getInstance(config)
        .withDockerHttpClient(
            new TrackingDockerHttpClient(
                new JerseyDockerHttpClient.Builder()
                    .dockerHost(config.getDockerHost())
                    .sslConfig(config.getSSLConfig())
                    .connectTimeout(30 * 1000)
                    .build()
            )
        )
        .build();
}
 

/**
 * builds the DockerClientConfig based on Gaia's settings
 * @param settings Gaia's settings
 * @return a docker client configuration
 */
@Bean
DockerClientConfig dockerClientConfig(Settings settings) {
    return DefaultDockerClientConfig.createDefaultConfigBuilder()
        .withDockerHost(settings.getDockerDaemonUrl())
        .build();
}
 

@Override
public void init(DockerClientConfig dockerClientConfig) {
    clientBuilder = clientBuilder
        .dockerHost(dockerClientConfig.getDockerHost())
        .sslConfig(dockerClientConfig.getSSLConfig());
    dockerCmdExecFactory = new DefaultDockerCmdExecFactory(
        clientBuilder.build(),
        dockerClientConfig.getObjectMapper()
    );
    dockerCmdExecFactory.init(dockerClientConfig);
}
 

public static DockerClient build() {
    if (dockerClient == null) {
        DefaultDockerClientConfig.Builder builder = new DefaultDockerClientConfig.Builder();
        builder = builder.withApiVersion("1.12");

        String dockerHostEnv = System.getenv("DOCKER_HOST");
        if (StringUtils.isBlank(dockerHostEnv)) {
            builder.withDockerHost("unix:///var/run/docker.sock");
        }

        DockerClientConfig config = builder.build();
        dockerClient = DockerClientBuilder.getInstance(config).build();
    }
    return dockerClient;
}
 

public DockerClient getObject() throws Exception {
    DockerClientConfig config = DockerClientConfig.createDefaultConfigBuilder()
            .withVersion(version)
            .withUri(uri)
            .withUsername(username)
            .withPassword(password)
            .withEmail(email)
            .withServerAddress(serverAddress)
            .withDockerCertPath(dockerCertPath)
            .build();
    return DockerClientBuilder.getInstance(config).build();
}
 

@Override
public DockerClientImpl createDockerClient(DockerClientConfig config) {
    return (DockerClientImpl) DockerClientBuilder.getInstance(config)
        .withDockerHttpClient(
            new TrackingDockerHttpClient(
                new ApacheDockerHttpClient.Builder()
                    .dockerHost(config.getDockerHost())
                    .sslConfig(config.getSSLConfig())
                    .build()
            )
        )
        .build();
}
 

@Override
public void init(DockerClientConfig dockerClientConfig) {
    clientBuilder = clientBuilder
        .dockerHost(dockerClientConfig.getDockerHost())
        .sslConfig(dockerClientConfig.getSSLConfig());
    dockerCmdExecFactory = new DefaultDockerCmdExecFactory(
        clientBuilder.build(),
        dockerClientConfig.getObjectMapper()
    );
    dockerCmdExecFactory.init(dockerClientConfig);
}
 

@Override
public DuplexChannel connect(Bootstrap bootstrap) throws InterruptedException {
    DockerClientConfig dockerClientConfig = getDockerClientConfig();
    String host = dockerClientConfig.getDockerHost().getHost();
    int port = dockerClientConfig.getDockerHost().getPort();

    if (port == -1) {
        throw new RuntimeException("no port configured for " + host);
    }

    final DuplexChannel channel = (DuplexChannel) bootstrap.connect(host, port).sync().channel();

    final SslHandler ssl = initSsl(dockerClientConfig);

    if (ssl != null) {
        channel.pipeline().addFirst(ssl);

        // https://tools.ietf.org/html/rfc5246#section-7.2.1
        // TLS has its own special message about connection termination. Because TLS is a
        // session-level protocol, it can be covered by any transport-level protocol like
        // TCP, UTP and so on. But we know exactly that data being transferred over TCP and
        // that other side will never send any byte into this TCP connection, so this
        // channel should be closed.
        // RFC says that we must notify opposite side about closing. This could be done only
        // in sun.security.ssl.SSLEngineImpl and unfortunately it does not send this
        // message. On the other hand RFC does not enforce the opposite side to wait for
        // such message.
        ssl.sslCloseFuture().addListener(future -> channel.eventLoop().execute(channel::close));
    }

    return channel;
}
 

@Override
public DuplexChannel connect(Bootstrap bootstrap) throws InterruptedException {
    DockerClientConfig dockerClientConfig = getDockerClientConfig();
    String path = dockerClientConfig.getDockerHost().getPath();

    return (DuplexChannel) bootstrap.connect(new DomainSocketAddress(path)).sync().channel();
}
 

/**
 * Creates a DockerClientConfig object to be used when creating the Java Docker client using a secured connection.
 * @param host - Docker host address (IP) to connect to
 * @param registryServerUrl - address of the private container registry
 * @param username - user name to connect with to the private container registry
 * @param password - password to connect with to the private container registry
 * @param caPemContent - content of the ca.pem certificate file
 * @param keyPemContent - content of the key.pem certificate file
 * @param certPemContent - content of the cert.pem certificate file
 * @return an instance of DockerClient configuration
 */
public static DockerClientConfig createDockerClientConfig(String host, String registryServerUrl, String username, String password,
                                                          String caPemContent, String keyPemContent, String certPemContent) {
    return DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(host)
            .withDockerTlsVerify(true)
            .withCustomSslConfig(new DockerSSLConfig(caPemContent, keyPemContent, certPemContent))
            .withRegistryUrl(registryServerUrl)
            .withRegistryUsername(username)
            .withRegistryPassword(password)
            .build();
}
 

public DockerConnector(String endPoint, String version){
    DockerClientConfig config = DockerClientConfig.createDefaultConfigBuilder()
            .withVersion(version)
            .withUri(endPoint)
            .build();
    dockerClient = DockerClientBuilder.getInstance(config).build();
}
 

private static DockerClient get(
        String host,
        Boolean tlsVerify,
        String certPath,
        String registryUsername,
        String registryPass,
        String registryMail,
        String registryUrl
) {
    DefaultDockerClientConfig.Builder configBuilder = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(host);

    configBuilder.withDockerTlsVerify(tlsVerify);

    if (!certPath.equals("")) {
        configBuilder.withDockerCertPath(certPath);
    }

    if(!registryUrl.equals("")) {
        configBuilder.withRegistryUrl(registryUrl);
        if (!registryUsername.equals("")) {
            configBuilder.withRegistryUsername(registryUsername);
        }

        if (!registryMail.equals("")) {
            configBuilder.withRegistryEmail(registryMail);
        }

        if (!registryPass.equals("")) {
            configBuilder.withRegistryPassword(registryPass);
        }
    }

    DockerClientConfig config = configBuilder.build();

    return DockerClientBuilder.getInstance(config).build();
}
 

public DockerClient newDockerClient(String host) {
    String url = String.format("tcp://%s:%d", host,dockerRemoteProperties.getPort());
    if(dockerRemoteProperties.getEnableTls() == true){
        DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                .withDockerHost(url)
                .withDockerTlsVerify(true)
                .withDockerCertPath(dockerRemoteProperties.getCertPath())
                .build();
        return DockerClientBuilder.getInstance(config).build();
    }else{
        return DockerClientBuilder.getInstance(url).build();
    }
}
 

public CreateImageCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public PingCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public InitializeSwarmCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public WaitContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public ResizeContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public StopContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public RestartContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public StartContainerCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public ExecStartCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public RemoveServiceCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public ContainerDiffCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public DisconnectFromNetworkCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}
 

public SaveImagesCmdExec(WebTarget baseResource, DockerClientConfig dockerClientConfig) {
    super(baseResource, dockerClientConfig);
}