import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
private void setupDockerClient() throws
    InvalidCredentialsException {
  if (dockerClient != null) {
    return;
  }

  final DockerClientConfig config = createClientConfig();

  final DockerCmdExecFactory dockerCmdExecFactory = new JerseyDockerCmdExecFactory();
  dockerClient = DockerClientBuilder.getInstance(config)
      .withDockerCmdExecFactory(dockerCmdExecFactory)
      .build();

  // Check if client was successfully created
  final AuthResponse response = dockerClient.authCmd().exec();
  if (!response.getStatus().equalsIgnoreCase("Login Succeeded")) {
    throw new InvalidCredentialsException("Could not create DockerClient");
  }
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
private static DockerClient createDockerClient(String dockerUrl, String dockerVersion, String dockerCertPath,
                                               AuthConfig authConfig) {
    // TODO JENKINS-26512
    SSLConfig dummySSLConf = (new SSLConfig() {
        public SSLContext getSSLContext() throws KeyManagementException, UnrecoverableKeyException,
                NoSuchAlgorithmException, KeyStoreException {
            return null;
        }
    });

    if (dockerCertPath != null) {
        dummySSLConf = new LocalDirectorySSLConfig(dockerCertPath);
    }
    
    DefaultDockerClientConfig.Builder configBuilder = new DefaultDockerClientConfig.Builder().withDockerHost(dockerUrl)
            .withApiVersion(dockerVersion).withCustomSslConfig(dummySSLConf);
    if (authConfig != null) {
        configBuilder.withRegistryUsername(authConfig.getUsername())
                .withRegistryEmail(authConfig.getEmail())
                .withRegistryPassword(authConfig.getPassword())
                .withRegistryUrl(authConfig.getRegistryAddress());
    }
    // using jaxrs/jersey implementation here (netty impl is also available)
    DockerCmdExecFactory dockerCmdExecFactory = new DockerCmdExecFactoryImpl()
            .withConnectTimeout(1000)
            .withMaxTotalConnections(1)
            .withMaxPerRouteConnections(1);
    return DockerClientBuilder.getInstance(configBuilder).withDockerCmdExecFactory(dockerCmdExecFactory).build();
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
@Test
public void testConcurrentClientBuilding() throws Exception {
    // we use it to check instance uniqueness
    final Set<DockerCmdExecFactory> instances = Collections.synchronizedSet(new HashSet<DockerCmdExecFactory>());

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            DockerCmdExecFactory factory = DockerClientBuilder.getDefaultDockerCmdExecFactory();
            // factory created
            assertNotNull(factory);
            // and is unique
            assertFalse(instances.contains(factory));
            instances.add(factory);
        }
    };

    parallel(AMOUNT, runnable);
    // set contains all required unique instances
    assertEquals(instances.size(), AMOUNT);
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
@SuppressWarnings("resource")
@Override
public DockerCmdExecFactory get() {
  JerseyDockerCmdExecFactory factory = new JerseyDockerCmdExecFactory()
      .withMaxTotalConnections(config.getMaxTotalConnections())
      .withMaxPerRouteConnections(config.getMaxPerRouteConnections())
      .withClientRequestFilters(config.getClientRequestFilters())
      .withClientResponseFilters(config.getClientResponseFilters());

  config.getReadTimeout().ifPresent(value -> factory.withReadTimeout(value));
  config.getConnectTimeout().ifPresent(value -> factory.withConnectTimeout(value));
  config.getConnectionRequestTimeout().ifPresent(value -> factory.withConnectionRequestTimeout(value));

  return factory;
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
@Bean
	public DockerClient getDockerClient () {
		logger.info( "Creating pooled docker: {} ", docker.toString() );

		DockerClient client = null;
		try {
			DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
				.withDockerHost( docker.getUrl() )
				.build();

			DockerCmdExecFactory dockerCmdExecFactory = new JerseyDockerCmdExecFactory()
				.withReadTimeout( docker.getReadTimeoutSeconds() *1000 )
				.withConnectTimeout( docker.getConnectionTimeoutSeconds() *1000  )
				.withMaxTotalConnections( docker.getConnectionPool() )
				.withMaxPerRouteConnections( 3 );
			
//			DockerCmdExecFactory dockerCmdExecFactory = new NettyDockerCmdExecFactory()
//					.withConnectTimeout( docker.getReadTimeoutSeconds() *1000 ) ;

			client = DockerClientBuilder
				.getInstance( config )
				.withDockerCmdExecFactory( dockerCmdExecFactory )
				.build();

			// client = DefaultDockerClient.builder()
			// .uri( docker.getUrl() )
			// .connectionPoolSize( docker.getConnectionPool() )
			// .build();
		} catch (Throwable t) {
			logger.warn( "Failed connecting to docker: {}", CSAP.getCsapFilteredStackTrace( t ) );
		}

		return client;
	}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
@Override
protected void configure() {
  requireBinding(Config.class);

  bind(DockerCmdExecFactory.class).toProvider(DockerCmdExecFactoryProvider.class).in(Singleton.class);
  bind(DockerClient.class).toProvider(DockerClientProvider.class).in(Singleton.class);
  bind(DockerHostProvider.class).in(Singleton.class);
  bind(DockerHost.class).toProvider(DockerHostProvider.class);

  bind(DockerFacade.class).to(DockerFacadeImpl.class);
  bind(ContainerFacade.class).to(ContainerFacadeImpl.class);
  bind(ImageFacade.class).to(ImageFacadeImpl.class);
  bind(InfoFacade.class).to(InfoFacadeImpl.class);
  bind(NetworkingFacade.class).to(NetworkFacadeImpl.class);
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
@Inject
protected DockerClientFactory(DockerCmdExecFactory cmdExecFactory) {
  super();
  this.cmdExecFactory = cmdExecFactory;
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
public DockerClientImpl withDockerCmdExecFactory(DockerCmdExecFactory dockerCmdExecFactory) {
    checkNotNull(dockerCmdExecFactory, "dockerCmdExecFactory was not specified");
    this.dockerCmdExecFactory = dockerCmdExecFactory;
    this.dockerCmdExecFactory.init(dockerClientConfig);
    return this;
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
private DockerCmdExecFactory getDockerCmdExecFactory() {
    checkNotNull(dockerCmdExecFactory, "dockerCmdExecFactory was not specified");
    return dockerCmdExecFactory;
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
public static DockerCmdExecFactory getDefaultDockerCmdExecFactory() {
    return new JerseyDockerCmdExecFactory();
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
public DockerClientBuilder withDockerCmdExecFactory(DockerCmdExecFactory dockerCmdExecFactory) {
    this.dockerCmdExecFactory = dockerCmdExecFactory;
    return this;
}
 

import com.github.dockerjava.api.command.DockerCmdExecFactory; //导入依赖的package包/类
public TestDockerCmdExecFactory(DockerCmdExecFactory delegate) {
    this.delegate = delegate;
}