Java DockerClientBuilder类代码示例

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的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.core.DockerClientBuilder; //导入依赖的package包/类
private DockerClient getDockerClient() {
    /*
    TLS connection: ...

    DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost("tcp://192.168.99.100:2376")
            .withDockerTlsVerify(true)
            .withDockerCertPath("/Users/jon/.docker/machine/machines/default")
            .build();
    */

    final String localDockerHost = SystemUtils.IS_OS_WINDOWS ? "tcp://localhost:2375" : "unix:///var/run/docker.sock";

    final DefaultDockerClientConfig config = DefaultDockerClientConfig
            .createDefaultConfigBuilder()
            .withDockerHost(localDockerHost)
            .build();

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

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
private DockerClient buildDockerClientWithShutdown () {

		logger.warn( "\n\n\n *********** Dockerclient: {} poolsize: {}  *** \n\n\n", 
			dockerConfiguration.getDockerHost(), dockerPoolSize );

		// need to support connection leaks in docker java image load code
		// means shutdown needs to occur - which can then cause intermittent
		// race conditions.
		//
		if ( lastFactory != null ) {
			try {
				lastFactory.close();
			} catch (IOException e) {
				logger.error( "Failed closing factory", e );
			}
		}
		// Netty: use 2*core count threads
		// lastFactory = buildNettyDockerCommandFactory() ;
		lastFactory = buildDockerJerseyCommandFactory();
		return DockerClientBuilder
			.getInstance( dockerConfiguration )
			.withDockerCmdExecFactory( lastFactory )
			.build();
	}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
/**
 * TODO delete and make method with serverId param after thinking about it
 *
 * @return default connection to system docker
 */
public DockerClient getDefaultConnection() {
    return connections.computeIfAbsent(DEFAULT_CONNECTION, id -> {
        DockerClientConfig config = null;

        if (SystemUtils.IS_OS_MAC_OSX) {
            config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                    .withDockerHost("unix:///var/run/docker.sock")
                    .build();
        }
        if (SystemUtils.IS_OS_LINUX) {
            config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                    .withDockerHost("unix:///var/run/docker.sock")
                    .build();
        }
        if (SystemUtils.IS_OS_WINDOWS) {
            config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                    .withDockerHost("tcp://localhost:2376")
                    .withDockerTlsVerify(true)
                    .withDockerTlsVerify("1")
                    .build();
        }

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

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
@Before
public void setUp() {
  init();

  client = DockerClientBuilder.getInstance().build();
  List<Container> running = client.listContainersCmd().withStatusFilter("running").exec();
  if (running != null) {
    running.forEach(container -> client.stopContainerCmd(container.getId()).exec());
  }

  vertx = Vertx.vertx();
  discovery = ServiceDiscovery.create(vertx);
  bridge = new DockerServiceImporter();
  discovery.registerServiceImporter(bridge,
      new JsonObject().put("scan-period", -1));

  await().until(() -> bridge.started);
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
public static void init() {
  DefaultDockerClientConfig conf = DefaultDockerClientConfig
      .createDefaultConfigBuilder()
      .withRegistryUrl("https://index.docker.io/v1/").build();

  dockerClient =
      DockerClientBuilder.getInstance(conf).withDockerCmdExecFactory(new NettyDockerCmdExecFactory()).build();
  try {
    dockerClient.inspectImageCmd("busybox").exec();
  } catch (Exception e) {
    LOGGER.info("Pulling image 'busybox'");
    // need to block until image is pulled completely
    dockerClient.pullImageCmd("busybox").withTag("latest").exec(new PullImageResultCallback()).awaitSuccess();
  }

  String logRecord = "This is magic string keyToFind=42 and some text at the end";
  container = dockerClient.createContainerCmd("busybox")
      .withCmd("/bin/sh", "-c", "while true; do echo " + logRecord + "; sleep 1; done")
      .withTty(true)
      .exec();

  dockerClient.startContainerCmd(container.getId()).exec();
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
/**
 * connects to Docker daemon
 * 
 * @throws Exception
 */
public void connect() throws Exception {
	DockerClientConfig config = DockerClientConfig.createDefaultConfigBuilder()
			.withVersion(Constants.DOCKER_API_VERSION)
			.withUri(Configuration.getDockerUrl())
			.build();

	dockerClient = DockerClientBuilder.getInstance(config).build();

	try {
		Info info = dockerClient.infoCmd().exec();
		LoggingService.logInfo(MODULE_NAME, "connected to docker daemon: " + info.getName());
	} catch (Exception e) {
		LoggingService.logInfo(MODULE_NAME, "connecting to docker failed: " + e.getClass().getName() + " - " + e.getMessage());
		throw e;
	}
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
public void removeContainer(Server server) throws Exception {
    DockerClient dockerClient = DockerClientBuilder.getInstance("http://" + server.getNode().getPrivateAddress() + ":4243").build();

    for (Container container : dockerClient.listContainersCmd().withShowAll(true).exec()) {
        String name = container.getNames()[0];
        if (name.equals("/" + server.getServerType().getName() + "." + server.getNumber())) {
            log.info("Deleting " + Arrays.toString(container.getNames()));
            try {
                dockerClient.killContainerCmd(container.getId()).exec();
            } catch (Exception ignored) {
            }
            dockerClient.removeContainerCmd(container.getId()).withForce(true).exec();
            break;
        }
    }
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
public void removeContainer(Bungee bungee) {
    DockerClient dockerClient = DockerClientBuilder.getInstance("http://" + bungee.getNode().getPrivateAddress() + ":4243").build();

    for (Container container : dockerClient.listContainersCmd().withShowAll(true).exec()) {
        String name = container.getNames()[0];
        if (name.equals("/" + bungee.getBungeeType().getName()+"."+bungee.getPublicAddress().getPublicAddress()) || name.contains(bungee.getPublicAddress().getPublicAddress())) {
            log.info("Deleting " + Arrays.toString(container.getNames()));
            try {
                dockerClient.killContainerCmd(container.getId()).exec();
            } catch (Exception ignored) {
            }
            dockerClient.removeContainerCmd(container.getId()).withForce(true).exec();
            break;
        }
    }
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的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.core.DockerClientBuilder; //导入依赖的package包/类
/**
 * Creates a Docker client from target properties.
 * @param targetProperties a non-null map
 * @return a Docker client
 * @throws TargetException if something went wrong
 */
public static DockerClient createDockerClient( Map<String,String> targetProperties ) throws TargetException {

	// Validate what needs to be validated.
	Logger logger = Logger.getLogger( DockerHandler.class.getName());
	logger.fine( "Setting the target properties." );

	String edpt = targetProperties.get( DockerHandler.ENDPOINT );
	if( Utils.isEmptyOrWhitespaces( edpt ))
		edpt = DockerHandler.DEFAULT_ENDPOINT;

	// The configuration is straight-forward.
	Builder config =
			DefaultDockerClientConfig.createDefaultConfigBuilder()
			.withDockerHost( edpt )
			.withRegistryUsername( targetProperties.get( DockerHandler.USER ))
			.withRegistryPassword( targetProperties.get( DockerHandler.PASSWORD ))
			.withRegistryEmail( targetProperties.get( DockerHandler.EMAIL ))
			.withApiVersion( targetProperties.get( DockerHandler.VERSION ));

	// Build the client.
	DockerClientBuilder clientBuilder = DockerClientBuilder.getInstance( config.build());

	return clientBuilder.build();
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
@VsoMethod(showInApi = false)
public DockerClient getDockerClient()
{
	DockerClient dockerClient = null;
	try
	{
		configureNode();
		dockerClient = DockerClientBuilder.getInstance(config).withServiceLoaderClassLoader(CooptoPluginAdaptor.class.getClassLoader()).build();
		
	}
	catch (Exception e)
	{
		final StringWriter sw = new StringWriter();
		final PrintWriter pw = new PrintWriter(sw, true);
		e.printStackTrace(pw);
		log.error("Error while creating Docker client. Details:\n" + sw.getBuffer().toString());
	}

	return dockerClient;
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
public DockerClient getClient() {
    if (cmdIT.getFactoryType() == NETTY) {
        if (nettyClient == null) {
            nettyClient = DockerClientBuilder.getInstance(config())
                    .withDockerCmdExecFactory((new NettyDockerCmdExecFactory())
                            .withConnectTimeout(10 * 1000))
                    .build();
        }

        return nettyClient;
    } else if (cmdIT.getFactoryType() == JERSEY) {
        if (jerseyClient == null) {
            jerseyClient = DockerClientBuilder.getInstance(config())
                    .withDockerCmdExecFactory((new JerseyDockerCmdExecFactory())
                            .withConnectTimeout(10 * 1000))
                    .build();
        }
        return jerseyClient;
    }

    throw new IllegalStateException("Why factory type is not set?");
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
@Test
public void testNettyDockerCmdExecFactoryConfigWithoutApiVersion() throws Exception {
    int dockerPort = getFreePort();

    NettyDockerCmdExecFactory factory = new NettyDockerCmdExecFactory();
    Builder configBuilder = new DefaultDockerClientConfig.Builder()
        .withDockerTlsVerify(false)
        .withDockerHost("tcp://localhost:" + dockerPort);

    DockerClient client = DockerClientBuilder.getInstance(configBuilder)
        .withDockerCmdExecFactory(factory)
        .build();

    FakeDockerServer server = new FakeDockerServer(dockerPort);
    server.start();
    try {
        client.versionCmd().exec();

        List<HttpRequest> requests = server.getRequests();

        assertEquals(requests.size(), 1);
        assertEquals(requests.get(0).uri(), "/version");
    } finally {
        server.stop();
    }
}
 

import com.github.dockerjava.core.DockerClientBuilder; //导入依赖的package包/类
public DockerClient getClient() {
    if (client == null) {
        final Integer readTimeoutInMillisecondsOrNull = readTimeout > 0 ? Integer.valueOf(readTimeout * 1000) : null;
        final Integer connectTimeoutInMillisecondsOrNull = connectTimeout > 0 ? Integer.valueOf(connectTimeout * 1000) : null;
        client = DockerClientBuilder.getInstance(
            new DefaultDockerClientConfig.Builder()
                .withDockerHost(dockerHost.getUri())
                .withCustomSslConfig(toSSlConfig(dockerHost.getCredentialsId()))
            )
            .withDockerCmdExecFactory(new NettyDockerCmdExecFactory()
            .withReadTimeout(readTimeoutInMillisecondsOrNull)
            .withConnectTimeout(connectTimeoutInMillisecondsOrNull))
            .build();
    }
    return client;
}