ManagementVerticle.java

package com.example;

import io.vertx.core.CompositeFuture;
import io.vertx.core.VerticleBase;
import io.vertx.core.Future;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.file.FileSystem;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.BodyHandler;

import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

public class ManagementVerticle extends VerticleBase {

  private static final String DEPLOYMENTS_DIR = "./deployments/";
  private final Map<String, String> deployments = new ConcurrentHashMap<>();
  private FileSystem fs;

  @Override
  public Future<?> start() {
    fs = vertx.fileSystem();
    Path dirPath = Paths.get(DEPLOYMENTS_DIR);

    return fs.mkdirs(dirPath.toString())
      .compose(v -> restoreDeployments())
      .compose(v -> setupRouter())
      .compose(v -> deployExampleApi());
  }

  private Future<?> restoreDeployments() {
    return fs.readDir(DEPLOYMENTS_DIR, ".*\\.json")
      .flatMap(files -> {
        List<Future<JsonObject>> reads = files.stream()
          .map(this::readDeploymentConfig)
          .toList();
        return Future.join(reads)
          .map(CompositeFuture::list)
          .map(results -> results.stream()
            .map(obj -> (JsonObject) obj)
            .filter(Objects::nonNull)
            .toList());
      })
      .compose(validConfigs -> {
        List<Future<String>> deploys = validConfigs.stream()
          .map(this::deployFromConfig)
          .toList();
        return Future.join(deploys)
          .map(cf -> cf.list())
          .mapEmpty()
          .onSuccess(v -> System.out.println("Restored " + validConfigs.size() + " deployments"));
      });
  }



  private Future<JsonObject> readDeploymentConfig(String filePath) {
    return fs.readFile(filePath)
      .map(Buffer::toJsonObject)
      .compose(config -> {
        String name = config.getString("name");
        String fname = filePath.replaceFirst("^.*?(([^/\\\\\\.]+))\\.[^\\.]+$", "$1");
        if (name == null) {
          System.err.println("Skipping " + filePath + ": no 'name'");
          return Future.succeededFuture(null);  // null = пропустить
        } else if (!name.equals(fname)) {
          System.err.println("Skipping " + filePath + ": filename is not equals to 'name' -> " + fname + " != "+name);
          return Future.succeededFuture(null);  // null = пропустить

        }
        return Future.succeededFuture(config
          .put("deploymentFile", filePath)
          .put("name", name));
      })
      .recover(err -> {
        System.err.println("Failed to load " + filePath + ": " + err.getMessage());
        return Future.succeededFuture(null);  // null = пропустить
      });
  }



  private Future<String> deployFromConfig(JsonObject config) {
    String name = config.getString("name");
    DeploymentOptions options = new DeploymentOptions().setConfig(config);
    return vertx.deployVerticle(ApiVerticle.class.getName(), options)
      .map(deploymentID -> {
        deployments.put(name, deploymentID);
        System.out.println("Restored deployment '" + name + "': " + deploymentID);
        return deploymentID;
      });
  }

  private Future<?> setupRouter() {
    Router router = Router.router(vertx);
    router.route().handler(BodyHandler.create());

    router.get("/verticles").handler(this::listVerticles);
    router.post("/verticles/:name/deploy").handler(this::deployVerticle);
    router.delete("/verticles/:name").handler(this::undeployVerticle);
    router.put("/verticles/:name/config").handler(this::updateConfig);

    return vertx.createHttpServer()
      .requestHandler(router)
      .listen(8080)
      .map(v -> {
        System.out.println("Management UI на http://localhost:8080");
        return v;
      });
  }

  private Future<?> deployExampleApi() {
    // Если api0 уже восстановлен — пропускаем
    if (deployments.containsKey("api0")) {
      return Future.succeededFuture();
    }

    JsonObject config = new JsonObject()
      .put("name", "api0")
      .put("httpPort", 8081)
      .put("endpoints", new JsonArray()
        .add(new JsonObject()
          .put("path", "/api/hello")
          .put("method", "GET")
          .put("response", new JsonObject()
            .put("status", 200)
            .put("headers", new JsonObject().put("Content-Type", "application/json"))
            .put("body", "{\"msg\":\"hello from example\"}")))
        .add(new JsonObject()
          .put("path", "/api/status")
          .put("method", "GET")
          .put("response", new JsonObject()
            .put("status", 200)
            .put("headers", new JsonObject().put("Content-Type", "application/json"))
            .put("body", "{\"status\":\"ok\"}"))));


    DeploymentOptions options = new DeploymentOptions().setConfig(config);
    return vertx.deployVerticle(ApiVerticle.class.getName(), options)
      .map(deploymentID -> {
        deployments.put("api0", deploymentID);
        return saveDeploymentConfig("api0", config).map(deploymentID);
      });
  }

  private void deployVerticle(RoutingContext ctx) {
    String name = ctx.pathParam("name");
    JsonObject config = ctx.body().asJsonObject();

    DeploymentOptions options = new DeploymentOptions().setConfig(config);
    vertx.deployVerticle(ApiVerticle.class.getName(), options)
      .onSuccess(deploymentID -> {
        deployments.put(name, deploymentID);
        saveDeploymentConfig(name, config)
          .onFailure(err -> System.err.println("Failed to save " + name + ": " + err));
        ctx.response()
          .putHeader("Content-Type", "application/json")
          .end(new JsonObject().put("deploymentID", deploymentID).put("name", name).encode());
      })
      .onFailure(err -> ctx.fail(500, err));
  }

  private void undeployVerticle(RoutingContext ctx) {
    String name = ctx.pathParam("name");
    String depId = deployments.remove(name);
    if (depId != null) {
      vertx.undeploy(depId)
        .onSuccess(v -> {
          fs.delete(DEPLOYMENTS_DIR + name + ".json")
            .onFailure(err -> System.err.println("Failed to delete " + name + ": " + err));
          ctx.response().end("Undeployed " + name);
        })
        .onFailure(err -> ctx.fail(500, err));
    } else {
      ctx.response().setStatusCode(404).end("Not found");
    }
  }

  private Future<?> updateConfig(RoutingContext ctx) {
    String name = ctx.pathParam("name");
    String depId = deployments.get(name);
    if (depId == null) {
      return ctx.response().setStatusCode(404).end("Not found");
    }

    JsonObject newConfig = ctx.body().asJsonObject();
    return vertx.undeploy(depId)
      .compose(v -> {
        deployments.remove(name);
        fs.delete(DEPLOYMENTS_DIR + name + ".json");
        return vertx.deployVerticle(ApiVerticle.class.getName(),
          new DeploymentOptions().setConfig(newConfig));
      })
      .map(newDepId -> {
        deployments.put(name, newDepId);
        return saveDeploymentConfig(name, newConfig).map(newDepId);
      })
      .onSuccess(id -> ctx.response().end("Updated"))
      .onFailure(err -> ctx.fail(500, err));
  }

  private Future<?> saveDeploymentConfig(String name, JsonObject config) {
    return fs.writeFile(DEPLOYMENTS_DIR + name + ".json",
      Buffer.buffer(config.encode()));
  }

  private void listVerticles(RoutingContext ctx) {
    JsonArray names = new JsonArray(new ArrayList<>(deployments.keySet()));
    JsonObject list = new JsonObject().put("deployed", new JsonObject().put("names", names));
    ctx.response().putHeader("Content-Type", "application/json").end(list.encode());
  }

  @Override
  public Future<?> stop() {
    if (deployments.isEmpty()) return Future.succeededFuture();
    return Future.join(deployments.values().stream()
        .map(vertx::undeploy)
        .toList())
      .mapEmpty();
  }
}