public static DockerContainer fromContainerInfo(ContainerInfo container) {
   Map<String, String> labels = container.config().labels();
   return new DockerContainer(
       container.name().substring(1),
       container.created(),
       GSON.fromJson(labels.get(Constants.CONFIGURATION_LABEL_KEY), HashMap.class),
       labels.get(Constants.ENVIRONMENT_LABEL_KEY));
 }
  public static DockerContainer create(
      CreateAgentRequest request, PluginSettings settings, DockerClient docker)
      throws InterruptedException, DockerException, IOException {
    String containerName = UUID.randomUUID().toString();

    HashMap<String, String> labels = labelsFrom(request);
    String imageName = image(request.properties());
    List<String> env = environmentFrom(request, settings, containerName);

    try {
      docker.inspectImage(imageName);
    } catch (ImageNotFoundException ex) {
      LOG.info("Image " + imageName + " not found, attempting to download.");
      docker.pull(imageName);
    }

    ContainerConfig.Builder containerConfigBuilder = ContainerConfig.builder();
    if (request.properties().containsKey("Command")) {
      containerConfigBuilder.cmd(
          splitIntoLinesAndTrimSpaces(request.properties().get("Command"))
              .toArray(new String[] {}));
    }

    ContainerConfig containerConfig =
        containerConfigBuilder.image(imageName).labels(labels).env(env).build();
    ContainerCreation container = docker.createContainer(containerConfig, containerName);
    String id = container.id();

    ContainerInfo containerInfo = docker.inspectContainer(id);

    LOG.debug("Created container " + containerName);
    docker.startContainer(containerName);

    return new DockerContainer(
        containerName, containerInfo.created(), request.properties(), request.environment());
  }
  @Override
  public int execute(
      final List<String> commandLine,
      final File executionDirectory,
      final Map<String, String> environmentVariables,
      final File temporaryDirectory,
      final File stdoutFile,
      final File stderrFile,
      final boolean redirectErrorStream)
      throws EoulsanException {

    checkNotNull(commandLine, "commandLine argument cannot be null");
    checkNotNull(executionDirectory, "executionDirectory argument cannot be null");
    checkNotNull(stdoutFile, "stdoutFile argument cannot be null");
    checkNotNull(stderrFile, "stderrFile argument cannot be null");

    checkArgument(
        executionDirectory.isDirectory(),
        "execution directory does not exists or is not a directory: "
            + executionDirectory.getAbsolutePath());

    try {

      final List<String> env = new ArrayList<>();

      if (environmentVariables != null) {
        for (Map.Entry<String, String> e : environmentVariables.entrySet()) {
          env.add(e.getKey() + '=' + e.getValue());
        }
      }

      // Pull image if needed
      pullImageIfNotExists(this.dockerClient, this.dockerImage);

      // Create container configuration
      getLogger().fine("Configure container, command to execute: " + commandLine);

      final ContainerConfig.Builder builder =
          ContainerConfig.builder().image(dockerImage).cmd(commandLine);

      // Set the working directory
      builder.workingDir(executionDirectory.getAbsolutePath());

      // Set the UID and GID of the docker process
      if (this.userUid >= 0 && this.userGid >= 0) {
        builder.user(this.userUid + ":" + this.userGid);
      }

      // Define temporary directory
      final List<File> toBind;
      if (temporaryDirectory.isDirectory()) {
        toBind = singletonList(temporaryDirectory);
        env.add(TMP_DIR_ENV_VARIABLE + "=" + temporaryDirectory.getAbsolutePath());
      } else {
        toBind = Collections.emptyList();
      }

      builder.hostConfig(createBinds(executionDirectory, toBind));

      // Set environment variables
      builder.env(env);

      // Create container
      final ContainerCreation creation = this.dockerClient.createContainer(builder.build());

      // Get container id
      final String containerId = creation.id();

      // Start container
      getLogger().fine("Start of the Docker container: " + containerId);
      this.dockerClient.startContainer(containerId);

      // Redirect stdout and stderr
      final LogStream logStream =
          this.dockerClient.logs(
              containerId, LogsParameter.FOLLOW, LogsParameter.STDERR, LogsParameter.STDOUT);
      redirect(logStream, stdoutFile, stderrFile, redirectErrorStream);

      // Wait the end of the container
      getLogger().fine("Wait the end of the Docker container: " + containerId);
      this.dockerClient.waitContainer(containerId);

      // Get process exit code
      final ContainerInfo info = this.dockerClient.inspectContainer(containerId);
      final int exitValue = info.state().exitCode();
      getLogger().fine("Exit value: " + exitValue);

      // Stop container before removing it
      this.dockerClient.stopContainer(containerId, SECOND_TO_WAIT_BEFORE_KILLING_CONTAINER);

      // Remove container
      getLogger().fine("Remove Docker container: " + containerId);
      try {
        this.dockerClient.removeContainer(containerId);
      } catch (DockerException | InterruptedException e) {
        EoulsanLogger.getLogger().severe("Unable to remove Docker container: " + containerId);
      }

      return exitValue;
    } catch (DockerException | InterruptedException e) {
      throw new EoulsanException(e);
    }
  }
Ejemplo n.º 4
0
  private MineCloudDaemon(Properties properties) {
    redis = MineCloud.instance().redis();
    mongo = MineCloud.instance().mongo();
    dockerClient = new DefaultDockerClient("unix:///var/run/docker.sock");

    node = (String) properties.get("node-name");
    instance = this;

    redis.addChannel(
        SimpleRedisChannel.create("server-create", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();

                  if (!stream.readString().equalsIgnoreCase(node)) {
                    return;
                  }

                  Network network =
                      mongo.repositoryBy(Network.class).findFirst(stream.readString());
                  ServerType type =
                      mongo.repositoryBy(ServerType.class).findFirst(stream.readString());
                  List<ServerMetadata> metadata = new ArrayList<>();
                  int size = stream.readVarInt32();

                  for (int i = 0; i < size; i++) {
                    metadata.add(new ServerMetadata(stream.readString(), stream.readString()));
                  }

                  Deployer.deployServer(network, type, metadata);
                }));

    redis.addChannel(
        SimpleRedisChannel.create("server-kill", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();

                  if (!stream.readString().equalsIgnoreCase(node)) return;

                  Server server = mongo.repositoryBy(Server.class).findFirst(stream.readString());

                  if (!server.node().name().equals(node)) {
                    MineCloud.logger()
                        .log(
                            Level.SEVERE,
                            "Invalid request was sent to kill a server "
                                + "not on the current node");
                    return;
                  }

                  try {
                    dockerClient.killContainer(server.containerId());
                    MineCloud.logger()
                        .info(
                            "Killed server "
                                + server.name()
                                + " with container id "
                                + server.containerId());

                    mongo.repositoryBy(Server.class).delete(server);
                  } catch (DockerException | InterruptedException e) {
                    MineCloud.logger().log(Level.SEVERE, "Was unable to kill a server", e);
                  }
                }));

    redis.addChannel(
        SimpleRedisChannel.create("bungee-create", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();

                  if (!stream.readString().equalsIgnoreCase(node)) return;

                  Network network =
                      mongo.repositoryBy(Network.class).findFirst(stream.readString());
                  BungeeType type =
                      mongo.repositoryBy(BungeeType.class).findFirst(stream.readString());

                  Deployer.deployBungee(network, type);
                }));

    redis.addChannel(
        SimpleRedisChannel.create("bungee-kill", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();

                  if (!stream.readString().equalsIgnoreCase(node)) return;

                  Bungee bungee = mongo.repositoryBy(Bungee.class).findFirst(stream.readString());

                  if (!bungee.node().name().equals(node)) {
                    MineCloud.logger()
                        .log(
                            Level.SEVERE,
                            "Invalid request was sent to kill a bungee "
                                + "not on the current node");
                    return;
                  }

                  try {
                    dockerClient.killContainer(bungee.containerId());
                    MineCloud.logger()
                        .info(
                            "Killed bungee "
                                + bungee.name()
                                + " with container id "
                                + bungee.containerId());

                    mongo.repositoryBy(Bungee.class).delete(bungee);
                  } catch (DockerException | InterruptedException e) {
                    MineCloud.logger().log(Level.SEVERE, "Was unable to kill a server", e);
                  }
                }));

    redis.addChannel(
        SimpleRedisChannel.create("server-start-notif", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) return;

                  MessageInputStream stream = message.contents();

                  Server server = mongo.repositoryBy(Server.class).findFirst(stream.readString());

                  if (!server.node().name().equals(node)) return;

                  if (server.port() != -1) return; // don't even know how this would happen

                  try {
                    ContainerInfo info = dockerClient.inspectContainer(server.containerId());

                    info.networkSettings()
                        .ports()
                        .forEach(
                            (s, l) -> {
                              if (!s.contains("25565")) return;

                              server.setPort(Integer.parseInt(l.get(0).hostPort()));
                              MineCloud.logger()
                                  .log(
                                      Level.INFO,
                                      "Set " + server.name() + "'s port to " + server.port());
                            });

                    mongo.repositoryBy(Server.class).save(server);
                  } catch (Exception e) {
                    MineCloud.logger()
                        .log(Level.SEVERE, "Was unable to set the port of a started server", e);
                  }
                }));

    redis.addChannel(SimpleRedisChannel.create("server-shutdown-notif", redis));

    new StatisticsWatcher().start();

    while (!Thread.currentThread().isInterrupted()) {
      try {
        dockerClient
            .listContainers(DockerClient.ListContainersParam.allContainers())
            .stream()
            .filter(
                (container) ->
                    !container.status().toLowerCase().contains("up")
                        && ((System.currentTimeMillis() / 1000L) - container.created()) > 5L)
            .forEach(
                (container) -> {
                  try {
                    String name =
                        container.names() == null || container.names().isEmpty()
                            ? "null"
                            : container.names().get(0);
                    dockerClient.removeContainer(container.id());

                    if (container.image().contains("minecloud")) {
                      String type = container.image().substring(9);

                      switch (type.toLowerCase()) {
                        case "bungee":
                          AbstractMongoRepository<Bungee> repository =
                              mongo.repositoryBy(Bungee.class);
                          Query<Bungee> query =
                              repository.createQuery().field("_id").equal(node().publicIp());
                          repository.deleteByQuery(query);
                          break;

                        case "server":
                          Server server =
                              mongo
                                  .repositoryBy(Server.class)
                                  .findOne("containerId", container.names().get(0));

                          if (server != null) {
                            mongo.repositoryBy(Server.class).delete(server);
                          }
                          break;
                      }
                    }

                    MineCloud.logger()
                        .info("Killed dead container " + container.id() + " (" + name + ")");
                  } catch (DockerException | InterruptedException e) {
                    MineCloud.logger()
                        .log(
                            Level.SEVERE,
                            "Was unable to kill exited container " + container.id(),
                            e);
                  }
                });
        ServerRepository repository = mongo.repositoryBy(Server.class);
        Query<Server> query =
            repository
                .createQuery()
                .field("node")
                .equal(node())
                .field("port")
                .notEqual(-1)
                .field("tps")
                .notEqual(-1);

        repository
            .find(query)
            .asList()
            .forEach(
                (server) -> {
                  boolean exists;

                  try {
                    dockerClient.inspectContainer(server.containerId());
                    exists = true;
                  } catch (DockerException | InterruptedException ex) {
                    exists = false;
                  }

                  if (exists) {
                    return;
                  }

                  repository.delete(server);
                  MineCloud.logger()
                      .info(
                          "Removed "
                              + server.containerId()
                              + " from DB due to not existing as a container");
                });
      } catch (DockerException | InterruptedException e) {
        MineCloud.logger().log(Level.SEVERE, "Was unable to list containers for update", e);
      }

      try {
        Thread.sleep(2000L);
      } catch (InterruptedException ignored) {
        // I don't care
      }
    }
  }