import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@GetMapping ( "/configuration" )
public JsonNode dockerConfiguration () {

	ObjectNode result = jacksonMapper.createObjectNode();
	try {
		Info info = dockerClient.infoCmd().exec();
		result = jacksonMapper.convertValue( info, ObjectNode.class );
	} catch (Exception e) {
		logger.warn( "Failed connecting to docker: {}", CSAP.getCsapFilteredStackTrace( e ) );
		// result = jacksonMapper.createArrayNode();
		// ObjectNode item = result.addObject();
		result.put( DockerJson.error.key, UNABLE_TO_CONNECT_TO_DOCKER );
	}

	return result;
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
/**
 * Print running containers, with an asterisk (*) when a particular name is matched
 */
public static void containerInfo(@Nullable String nameToHighlight){
    Info info = DockerClientFacade.getClient().infoCmd().exec();
    int runningContainers = info.getContainersRunning();
    logger.info(String.format("Running containers: %d", runningContainers));

    for (Container container : dockerClient.listContainersCmd().exec()){
        String normalizedName = container.getNames()[0].substring(1);
        String shortHash = container.getId().substring(0,12);

        if (nameToHighlight != null && normalizedName.equals(nameToHighlight)){
            logger.info(String.format("* Running containers: %s, id: %s", normalizedName, shortHash));
        }
        else{
            logger.info(String.format("Running containers: %s, id: %s", normalizedName, shortHash));
        }
    }
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的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.api.model.Info; //导入依赖的package包/类
/**
 * Pulls the Docker image, whose name matches the String
 * passed as a parameter, from the repository.
 * @param imageName docker image to be pulled
 */
public void pullImage(String imageName) {
	Info info = getLocalDockerInfo();

	int imgCount = info.getImages();
	LOG.info("imgCount1: {}", imgCount);

	//If the image already exists, remove it first
	removeImage(imageName);

	info = dockerClient.infoCmd().exec();
	LOG.info("Client info: {}", info.toString());
	imgCount = info.getImages();
	LOG.info("imgCount2: {}", imgCount);
	LOG.info("Pulling image: {}", imageName);

	InputStream response = dockerClient.pullImageCmd(imageName).exec();
	System.out.println(responseAsString(response));

	info = dockerClient.infoCmd().exec();
	LOG.info("Client info after pull, {}", info.toString());

	InspectImageResponse inspectImageResponse = dockerClient
			.inspectImageCmd(imageName).exec();
	LOG.info("Image Inspect: {}", inspectImageResponse.toString());
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
public ObjectNode buildSummary () {

		ObjectNode summary = jacksonMapper.createObjectNode();
		summary.put( "version", "not installed" );
		summary.put( "isAvailable", false );

		// summary.put( "rootDirectory", "/not/available" );
		try {
			Info info = dockerClient.infoCmd().exec();

			summary.put( "imageCount", info.getImages() );
			summary.put( "containerCount", info.getContainers() );
			summary.put( "containerRunning", info.getContainersRunning() );
			summary.put( "version", info.getServerVersion() );

			summary.put( "rootDirectory", info.getDockerRootDir() );

			summary.put( "isAvailable", true );

			ListVolumesResponse volumeResponse = dockerClient.listVolumesCmd().exec();

			int volumeCount = 0;
			if ( volumeResponse.getVolumes() != null ) {
				volumeCount = volumeResponse.getVolumes().size();
			}

			summary.put( "volumeCount", volumeCount );
		} catch (Exception e) {
			logger.debug( "Failed connecting to docker: {}", CSAP.getCsapFilteredStackTrace( e ) );
		}
		return summary;
	}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Test
public void verify_docker_info ()
		throws Exception {
	Info info = dockerClient.infoCmd().exec();

	logger.info( "info: {}", info );
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
public static void hostInfo(){
    Info info = getClient().infoCmd().exec();
    String output = String.format("Docker host name: %s", info.getName());
    logger.info(output);

    output = String.format("Host labels: %s", info.getLabels());
    logger.info(output);
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
/**
 * Validate that we can connect to the provided client.
 *
 * @param client the client to validate.
 * @return true if we can connect.
 */
private boolean tryClient(DockerClient client) {
  try (InfoCmd cmd = client.infoCmd()) {
    Info info = cmd.exec();
    return info != null && !nullToEmpty(info.getOperatingSystem()).isEmpty();
  } catch (Exception e) {
    return false;
  }
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
public DockerTraceabilityReport(@Nonnull Event event, @Nonnull Info hostInfo, 
        @CheckForNull InspectContainerResponse container, 
        @CheckForNull String imageId, @CheckForNull String imageName, 
        @CheckForNull InspectImageResponse image,
        @Nonnull List<String> parents, @CheckForNull String environment) {
    this.event = event;
    this.hostInfo = hostInfo;
    this.container = container;
    this.imageId = imageId;
    this.image = image;
    this.parents = new ArrayList<String>(parents);
    this.imageName = imageName;
    this.environment = environment;
    
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Override
protected Info execute(InfoCmd command) {
    WebTarget webResource = getBaseResource().path("/info");

    LOGGER.trace("GET: {}", webResource);
    return webResource.request().accept(MediaType.APPLICATION_JSON).get(Info.class);
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Test
public void infoTest() throws DockerException {
    DockerClient dockerClient = dockerRule.getClient();
    // Make sure that there is at least one container for the assertion
    // TODO extract this into a shared method
    if (dockerClient.listContainersCmd().withShowAll(true).exec().size() == 0) {
        CreateContainerResponse container = dockerClient.createContainerCmd(DEFAULT_IMAGE)
                .withName("docker-java-itest-info")
                .withCmd("touch", "/test")
                .exec();

        LOG.info("Created container: {}", container);
        assertThat(container.getId(), not(isEmptyOrNullString()));

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

    Info dockerInfo = dockerClient.infoCmd().exec();
    LOG.info(dockerInfo.toString());

    assertThat(dockerInfo.getContainers(), notNullValue());
    assertThat(dockerInfo.getContainers(), greaterThan(0));

    assertThat(dockerInfo.getImages(), notNullValue());
    assertThat(dockerInfo.getImages(), greaterThan(0));
    assertThat(dockerInfo.getDebug(), notNullValue());

    if (isNotSwarm(dockerClient)) {
        assertThat(dockerInfo.getNFd(), greaterThan(0));
        assertThat(dockerInfo.getNGoroutines(), greaterThan(0));
        assertThat(dockerInfo.getNCPU(), greaterThan(0));
    }
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Override
protected Info run() throws Exception {
  try (InfoCmd cmd = dockerClient.infoCmd()) {
    return cmd.exec();
  }
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Override
public HystrixExecutable<Info> systemInfo() {
  return systemInfoCommandFactory.create();
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Test
public void dockerInfo() throws Exception {
    Info info = dockerClient.infoCmd().exec();
    Assert.assertNotNull(info);
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Override
public void infoCommand() {
    Info info = dockerClient.infoCmd().exec();
    System.out.print(info);
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
public @Nonnull Info getHostInfo() {
    return hostInfo;
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
/**
 * Gets information from a Docker client.
 * @return Info
 */
public Info getLocalDockerInfo() {
	Info info = dockerClient.infoCmd().exec();
	LOG.info("Client info: {}", info.toString());
	return info;
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Override
public Info exec(InfoCmd command) {
    return webResource.path("info").request().get(new TypeReference<Info>() {
    });
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
@Test
public void testPullImage() throws Exception {
    Info info = dockerRule.getClient().infoCmd().exec();
    LOG.info("Client info: {}", info.toString());

    int imgCount = info.getImages();
    LOG.info("imgCount1: {}", imgCount);

    // This should be an image that is not used by other repositories
    // already
    // pulled down, preferably small in size. If tag is not used pull will
    // download all images in that repository but tmpImgs will only
    // deleted 'latest' image but not images with other tags
    String testImage = "hackmann/empty";

    LOG.info("Removing image: {}", testImage);

    try {
        dockerRule.getClient().removeImageCmd(testImage).withForce(true).exec();
    } catch (NotFoundException e) {
        // just ignore if not exist
    }

    info = dockerRule.getClient().infoCmd().exec();
    LOG.info("Client info: {}", info.toString());

    imgCount = info.getImages();
    LOG.info("imgCount2: {}", imgCount);

    LOG.info("Pulling image: {}", testImage);

    dockerRule.getClient().pullImageCmd(testImage)
            .exec(new PullImageResultCallback())
            .awaitCompletion(30, TimeUnit.SECONDS);

    info = dockerRule.getClient().infoCmd().exec();
    LOG.info("Client info after pull, {}", info.toString());

    assertThat(imgCount, lessThanOrEqualTo(info.getImages()));

    InspectImageResponse inspectImageResponse = dockerRule.getClient().inspectImageCmd(testImage).exec();
    LOG.info("Image Inspect: {}", inspectImageResponse.toString());
    assertThat(inspectImageResponse, notNullValue());
}
 

import com.github.dockerjava.api.model.Info; //导入依赖的package包/类
public Info getInfo(){
    Info info = dockerClient.infoCmd().exec();
    return info;
}