Java Container类代码示例

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
private static List<String> getAllHostContainerId(){
    String cacheKey = "allHostContainerIds";
    int cacheTime = 28;//28秒缓存周期，保证一次采集job只需要访问一次docker即可

    List<String> ids = (List<String>) getCache(cacheKey);
    if (ids != null){
        return ids;
    }else {
        ids = new ArrayList<>();
    }
    synchronized (LockForGetAllHostContainerId){
        try {
            List<Container> containerList = getContainers(DockerClient.ListContainersParam.allContainers());
            for (Container container : containerList) {
                ids.add(container.id());
            }
        } catch (Exception e) {
            log.error("",e);
        }
    }
    setCache(cacheKey,ids,cacheTime);
    return ids;
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
private void cleanDocker(Set<String> runningTaskIds) {
  try {
    for (Container container : dockerUtils.listContainers()) {
      for (String name : container.names()) {
        if (name.startsWith(executorConfiguration.getDockerPrefix())) {
          if (!runningTaskIds.contains(name.substring(executorConfiguration.getDockerPrefix().length()))) {
            stopContainer(container);
          }
        }
      }
    }
  } catch (Exception e) {
    LOG.error("Could not get list of Docker containers", e);
    exceptionNotifier.notify(e, Collections.<String, String>emptyMap());
  }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Override
public void stopParentAndChildren(String parentId) {
    // stop parent
    stopContainer(parentId);

    // find children
    try {
        List<Container> containers = dockerClient.listContainers();
        for (Container c : containers) {
            if (c != null && c.labels().get(LABEL_PARENT) != null
                    && c.labels().get(LABEL_PARENT).equals(parentId)) {
                stopParentAndChildren(c.id());
            }
        }
    } catch (Exception e) {
        LOGGER.error("Error while stopping containers: " + e.toString());
    }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Override
public void removeParentAndChildren(String parentId) {
    // stop parent
    removeContainer(parentId);

    // find children
    try {
        List<Container> containers = dockerClient.listContainers(DockerClient.ListContainersParam.allContainers());
        for (Container c : containers) {
            if (c != null && c.labels().get(LABEL_PARENT) != null
                    && c.labels().get(LABEL_PARENT).equals(parentId)) {
                removeParentAndChildren(c.id());
            }
        }
    } catch (Exception e) {
        LOGGER.error("Error while removing containers: " + e.toString());
    }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Autowired
public void setDockerClient(DockerClientProxy dockerClientProxy) {
    try {

        dockerClientProxy.access(dockerClient -> {
            final List<Container> containers = dockerClient.listContainers(withLabel(MccyConstants.MCCY_LABEL), allContainers());

            if (containers.isEmpty()) {
                LOG.info("NO CONTAINERS currently running");
            }
            else {
                containers.forEach(c -> LOG.info("CURRENT CONTAINER: {}", c));
            }

            return null;
        });
    } catch (InterruptedException | DockerException e) {
        LOG.warn("Failed to access or list containers", e);
    }

}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
public List<DockerContainerElement> getServiceOfferings(IProgressMonitor monitor) throws CoreException {
	return new BehaviourRequest<List<DockerContainerElement>>("Getting available service options") { //$NON-NLS-1$
		@Override
		protected List<DockerContainerElement> doRun(DockerClient client, SubMonitor progress) throws CoreException {
			// return client.getServiceOfferings();
			try {
				List<Container> containers = client.listContainers();
				return DomainHelper.convert(containers);					
			}
			catch (DockerException | InterruptedException e) {
				e.printStackTrace();
			}
			return null;
		}
	}.run(monitor);
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
void updateContainerState() {

        // TODO: Handle state properly.

        try {
            List<Container> latestRunningContainers = getContainers();

            LOGGER.info(
                String.format("Found %d running containers", latestRunningContainers.size()));

            Map<String, String> latestRunningContainerIdAndNames = getContainerIdAndNames(
                latestRunningContainers);

            if (!latestRunningContainerIdAndNames.keySet()
                .equals(this.runningContainers.keySet())) {
                LOGGER.info("Container list changed!");

                this.runningContainers = latestRunningContainerIdAndNames;

                notifyFrameworkListener();
            }
        } catch (DockerException | InterruptedException e) {
            throw new IllegalStateException("Failed to onNewConfigsFromScheduler container states", e);
        }
    }
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Input
public void trigger() {
    if (dockerClient != null) {
        try {
            final Optional<Container> container = dockerKiller.randomlyPickOneMatchingElement(dockerClient, key, value);
            if(container.isPresent()) {
                final String containerId = container.get().id();
                dockerClient.stopContainer(containerId, secondsToWaitBeforeKilling);
                killedContainer.send(containerId);
            }
        } catch (DockerException | InterruptedException e) {
            Log.error(e.getMessage());
        }
    } else {
        Log.info("No action because of null docker client");
    }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
public Optional<Container> randomlyPickOneMatchingElement(final DefaultDockerClient dockerClient, final String key, final String value) throws DockerException, InterruptedException {
    final List<Container> containers = dockerClient.listContainers();

    final List<Container> collect = new ArrayList<>();
    for (Container container : containers) {
        final ContainerInfo containerInfo = dockerClient.inspectContainer(container.id());
        boolean res;
        res = containsKeyAndValue(containerInfo.config().env(), key, value);
        if (res) {
            collect.add(container);
        }

    }
    final Optional<Container> ret;
    if (collect.isEmpty()) {
        ret = Optional.empty();
    } else {
        ret = Optional.of(collect.get(random.nextInt(collect.size())));
    }
    return ret;
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
private void cleanDocker(Set<String> runningTaskIds) {
  try {
    for (Container container : dockerUtils.listContainers()) {
      for (String name : container.names()) {
        if (name.startsWith(executorConfiguration.getDockerPrefix())) {
          if (!runningTaskIds.contains(name.substring(executorConfiguration.getDockerPrefix().length()))) {
            stopContainer(container);
          }
        }
      }
    }
  } catch (Exception e) {
    LOG.error("Could not get list of Docker containers", e);
    exceptionNotifier.notify(String.format("Error listing docker containers (%s)", e.getMessage()), e, Collections.<String, String>emptyMap());
  }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Override
public List<String> listContainers() throws FatalDockerJSONException {
    List<String> containersId = null;
    try {
        List<Container> containers = dockerClient.listContainers(DockerClient.ListContainersParam.allContainers());
        containersId = containers.stream().map(c -> c.id()).collect(Collectors.toList());
    } catch (DockerException | InterruptedException e) {
        logger.error(e.getMessage());
    }
    return containersId;
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
@Given("^added custom flow rules")
public void addRules() throws Exception {
    Container mininetContainer = dockerClient.listContainers()
            .stream()
            .filter(container -> container.image().startsWith(MININET_CONTAINER_PREFIX))
            .findFirst().orElseThrow(() -> new IllegalStateException("Floodlight controller should be active"));

    final String[] commands = {"ovs-ofctl", "-O", "Openflow13", "add-flow", SWITCH_NAME, RULE};
    ExecCreation execCreation = dockerClient.execCreate(mininetContainer.id(), commands,
            DockerClient.ExecCreateParam.attachStdout(), DockerClient.ExecCreateParam.attachStderr());

    final LogStream output = dockerClient.execStart(execCreation.id());
    final String execOutput = output.readFully();
    assertTrue(StringUtils.isEmpty(execOutput));
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
/**
 * 获取主机上所有运行容器的proc信息
 * @return
 */
public static List<ContainerProcInfoToHost> getAllHostContainerProcInfos(){
    String cacheKey = "ALL_HOST_CONTAINER_PROC_INFOS";
    List<ContainerProcInfoToHost> procInfoToHosts = (List<ContainerProcInfoToHost>) getCache(cacheKey);
    if (procInfoToHosts != null){
        //返回缓存数据
        return procInfoToHosts;
    }else {
        procInfoToHosts = new ArrayList<>();
    }
    synchronized (LockForGetAllHostContainerProcInfos){
        try {
            List<Container> containers = getContainers(DockerClient.ListContainersParam.withStatusRunning());
            for (Container container : containers) {
                ContainerInfo info = getContainerInfo(container.id());
                if (info != null) {
                    String pid = String.valueOf(info.state().pid());
                    procInfoToHosts.add(new ContainerProcInfoToHost(container.id(),PROC_HOST_VOLUME + "/" + pid + "/root",pid));
                }
            }
        } catch (Exception e) {
            log.error("",e);
        }
    }
    if (!procInfoToHosts.isEmpty()) {
        //设置缓存
        setCache(cacheKey,procInfoToHosts);
    }
    return procInfoToHosts;
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
private void removeContainer(Container container) {
    try {
        dockerClient.removeContainer(container.id(), DockerClient.RemoveContainerParam.forceKill(true));
    } catch (Exception e) {
        log.error("remove container failed: " + e.getMessage(), e);
    }
}
 

import com.spotify.docker.client.messages.Container; //导入依赖的package包/类
private String tryGetContainerId(String functionName) throws Exception {
    final List<Container> containers = dockerClient.listContainers(
            allContainers(),
            withLabel(Constants.LABEL_DSHELL_FUNCTION, functionName)
    );

    assertTrue(containers.size() > 0);
    return containers.get(0).id();
}