Java DockerClient.killContainer方法代碼示例

import com.spotify.docker.client.DockerClient; //導入方法依賴的package包/類
@After
public void tearDown() throws Exception {
    DockerClient client = DefaultDockerClient.fromEnv().build();
    logger.info("Stopping and removing registry");
    client.killContainer(this.registryid);
    client.removeContainer(this.registryid);
}
 

import com.spotify.docker.client.DockerClient; //導入方法依賴的package包/類
private void cleanup(DockerClient dockerClient, String containerId) throws DockerException, InterruptedException {
    try {
        if (containerExists(dockerClient, containerId)) {
            ContainerInfo containerInfo = dockerClient.inspectContainer(containerId);
            if (containerInfo.state().running()) {
                dockerClient.killContainer(containerId);
            }
            dockerClient.removeContainer(containerId, DockerClient.RemoveContainerParam.removeVolumes());
        }
    } catch (DockerRequestException dockerRequestException) {
        throw new IllegalStateException(dockerRequestException.message(), dockerRequestException);
    }
}
 

import com.spotify.docker.client.DockerClient; //導入方法依賴的package包/類
public static boolean deployServer(Server server) {
    Credentials mongoCreds = MineCloud.instance().mongo().credentials();
    Credentials redisCreds = MineCloud.instance().redis().credentials();
    String name = server.type().name() + server.number();
    World defaultWorld = server.type().defaultWorld();
    ContainerConfig config = ContainerConfig.builder()
            .hostname(name)
            .image("minecloud/server")
            .openStdin(true)
            .env(new EnvironmentBuilder()
                    .append("mongo_hosts", mongoCreds.formattedHosts())
                    .append("mongo_username", mongoCreds.username())
                    .append("mongo_password", new String(mongoCreds.password()))
                    .append("mongo_database", mongoCreds.database())

                    .append("redis_host", redisCreds.hosts()[0])
                    .append("redis_password", new String(redisCreds.password()))
                    .append("SERVER_MOD", server.type().mod())
                    .append("DEDICATED_RAM", String.valueOf(server.type().dedicatedRam()))
                    .append("MAX_PLAYERS", String.valueOf(server.type().maxPlayers()))

                    .append("server_id", server.entityId())
                    .append("DEFAULT_WORLD", defaultWorld.name())
                    .append("DEFAULT_WORLD_VERSION", defaultWorld.version())
                    .build())
            .build();

    ContainerCreation creation;

    try {
        DockerClient client = MineCloudDaemon.instance().dockerClient();

        try {
            ContainerInfo info = client.inspectContainer(name);

            if (info.state().running()) {
                client.killContainer(name);
            }

            client.removeContainer(info.id());
        } catch (ContainerNotFoundException ignored) {}

        creation = client.createContainer(config, name);

        client.startContainer(creation.id(), HostConfig.builder()
                .binds("/mnt/minecloud:/mnt/minecloud")
                .publishAllPorts(true)
                .build());
    } catch (InterruptedException | DockerException ex) {
        MineCloud.logger().log(Level.SEVERE, "Was unable to create server with type " + server.type().name(),
                ex);
        return false;
    }

    MineCloud.logger().info("Started server " + server.name()
            + " with container id " + server.containerId());
    return true;
}
 

import com.spotify.docker.client.DockerClient; //導入方法依賴的package包/類
public static Bungee deployBungeeCord(Network network, BungeeType type) {
    DockerClient client = MineCloudDaemon.instance().dockerClient();
    BungeeRepository repository = MineCloud.instance().mongo().repositoryBy(Bungee.class);
    Node node = MineCloudDaemon.instance().node();
    Bungee bungee = new Bungee();

    if (repository.count("_id", node.publicIp()) > 0) {
        MineCloud.logger().log(Level.WARNING, "Did not create bungee on this node; public ip is already in use");
        return null;
    }

    bungee.setId(node.publicIp());

    Credentials mongoCreds = MineCloud.instance().mongo().credentials();
    Credentials redisCreds = MineCloud.instance().redis().credentials();
    ContainerConfig config = ContainerConfig.builder()
            .image("minecloud/bungee")
            .hostname("bungee" + bungee.publicIp())
            .exposedPorts("25565")
            .openStdin(true)
            .env(new EnvironmentBuilder()
                    .append("mongo_hosts", mongoCreds.formattedHosts())
                    .append("mongo_username", mongoCreds.username())
                    .append("mongo_password", new String(mongoCreds.password()))
                    .append("mongo_database", mongoCreds.database())

                    .append("redis_host", redisCreds.hosts()[0])
                    .append("redis_password", new String(redisCreds.password()))
                    .append("DEDICATED_RAM", String.valueOf(type.dedicatedRam()))

                    .append("bungee_id", node.publicIp())
                    .build())
            .build();
    HostConfig hostConfig = HostConfig.builder()
            .binds("/mnt/minecloud:/mnt/minecloud")
            .portBindings(new HashMap<String, List<PortBinding>>() {{
                put("25565", Arrays.asList(PortBinding.of(node.publicIp(), 25565))); // I'm sorry
            }})
            .publishAllPorts(true)
            .build();

    try {
        ContainerInfo info = client.inspectContainer("bungee");

        if (info.state().running()) {
            client.killContainer("bungee");
        }

        client.removeContainer(info.id());
    } catch (DockerException | InterruptedException ignored) {}

    ContainerCreation creation;

    try {
        creation = client.createContainer(config, type.name());

        client.startContainer(creation.id(), hostConfig);
    } catch (InterruptedException | DockerException ex) {
        MineCloud.logger().log(Level.SEVERE, "Was unable to create bungee with type " + type.name(),
                ex);
        return bungee;
    }

    bungee.setNetwork(network);
    bungee.setNode(node);
    bungee.setPublicIp(node.publicIp());
    bungee.setType(type);

    repository.save(bungee);
    MineCloud.logger().info("Started bungee " + bungee.name() + " with container id " + bungee.containerId());
    return bungee;
}