public void deployVerticle(
     String verticleName,
     DeploymentOptions options,
     Handler<AsyncResult<String>> completionHandler) {
   ContextImpl currentContext = vertx.getOrCreateContext();
   ClassLoader cl = getClassLoader(options.getIsolationGroup());
   int pos = verticleName.indexOf(':');
   if (pos == -1) {
     throw new IllegalArgumentException("verticleName must start with prefix");
   }
   String prefix = verticleName.substring(0, pos);
   if (pos + 1 >= verticleName.length()) {
     throw new IllegalArgumentException("Invalid name: " + verticleName);
   }
   String actualName = verticleName.substring(pos + 1);
   VerticleFactory verticleFactory = verticleFactories.get(prefix);
   if (verticleFactory == null) {
     // Use default Java verticle factory
     verticleFactory = DEFAULT_VERTICLE_FACTORY;
   }
   try {
     Verticle verticle = verticleFactory.createVerticle(actualName, cl);
     if (verticle == null) {
       reportFailure(
           new NullPointerException("VerticleFactory::createVerticle returned null"),
           currentContext,
           completionHandler);
     } else {
       doDeploy(verticle, options, currentContext, completionHandler);
     }
   } catch (Exception e) {
     reportFailure(e, currentContext, completionHandler);
   }
 }
  public static void main(String... args) throws FileNotFoundException {

    DeploymentOptions deploymentOptions = new DeploymentOptions().setInstances(1);
    deploymentOptions.setConfig(new JsonObject().put("http.port", 8082));
    Vertx vertx = Vertx.vertx();
    vertx.deployVerticle(
        "com.stepan.verticles.ClientVerticle",
        deploymentOptions,
        event -> {
          System.out.println("Client Verticle successfully deployed: " + event.succeeded());
        });
    vertx.deployVerticle(
        "com.stepan.verticles.ServerVerticle",
        deploymentOptions,
        event -> {
          System.out.println("Server Verticle successfully deployed: " + event.succeeded());
        });
  }
  @Before
  public void runEnvironment(TestContext context) {

    PropertiesReader propertiesReader = new PropertiesReader();
    propertiesReader.read();

    DeploymentOptions dopts = new DeploymentOptions();
    dopts.setConfig(propertiesReader.getAsJson());

    PotatoVerticle potatoVerticle = new PotatoVerticle();
    rule.vertx().deployVerticle(potatoVerticle, dopts, context.asyncAssertSuccess());

    Guice.createInjector(
            new GuiceModuleForTests(propertiesReader.getAsProperties()),
            new DbModule(),
            new GuiceModule(rule.vertx()))
        .injectMembers(this);

    // Clear DB before running tests
    dBCleaner.apply();
  }
Beispiel #4
0
 // Add some information on a deployment in the cluster so other nodes know about it
 private void addToHA(
     String deploymentID, String verticleName, DeploymentOptions deploymentOptions) {
   String encoded;
   synchronized (haInfo) {
     JsonObject verticleConf = new JsonObject().put("dep_id", deploymentID);
     verticleConf.put("verticle_name", verticleName);
     verticleConf.put("options", deploymentOptions.toJson());
     JsonArray haMods = haInfo.getJsonArray("verticles");
     haMods.add(verticleConf);
     encoded = haInfo.encode();
     clusterMap.put(nodeID, encoded);
   }
 }
 private void doDeploy(
     Verticle verticle,
     DeploymentOptions options,
     ContextImpl currentContext,
     Handler<AsyncResult<String>> completionHandler) {
   if (options.isMultiThreaded() && !options.isWorker()) {
     throw new IllegalArgumentException("If multi-threaded then must be worker too");
   }
   ContextImpl context =
       options.isWorker()
           ? vertx.createWorkerContext(options.isMultiThreaded())
           : vertx.createEventLoopContext();
   String deploymentID = UUID.randomUUID().toString();
   DeploymentImpl deployment = new DeploymentImpl(deploymentID, context, verticle);
   context.setDeployment(deployment);
   Deployment parent = currentContext.getDeployment();
   if (parent != null) {
     parent.addChild(deployment);
   }
   JsonObject conf = options.getConfig() == null ? null : options.getConfig().copy(); // Copy it
   context.runOnContext(
       v -> {
         try {
           verticle.setVertx(vertx);
           verticle.setConfig(conf);
           verticle.setDeploymentID(deploymentID);
           Future<Void> startFuture = new FutureResultImpl<>();
           verticle.start(startFuture);
           startFuture.setHandler(
               ar -> {
                 if (ar.succeeded()) {
                   deployments.put(deploymentID, deployment);
                   reportSuccess(deploymentID, currentContext, completionHandler);
                 } else {
                   reportFailure(ar.cause(), currentContext, completionHandler);
                 }
               });
         } catch (Throwable t) {
           reportFailure(t, currentContext, completionHandler);
         }
       });
 }
  /** Iterate and deploy verticles */
  private void deployVerticle(final Message<JsonObject> event) {

    // iterate over all candidates to be deployed
    Set<String> candidates = this.workingCopy.fieldNames();

    // detach from underlying json
    Map<String, JsonObject> initiants = new HashMap<>();
    candidates.forEach(
        id -> {
          JsonObject info = this.workingCopy.getJsonObject(id);
          JsonArray dependsOn = info.getJsonArray("dependsOn");
          if (dependsOn != null && deployed.getList().containsAll(dependsOn.getList())
              || dependsOn == null
              || dependsOn.isEmpty()) {
            initiants.put(id, info);
          }
        });

    // remove the initiants
    initiants.keySet().forEach(id -> this.workingCopy.remove(id));

    // setup latch for the reply
    CountDownLatch latch = new CountDownLatch(initiants.size());
    if (initiants.isEmpty()) {
      event.reply(Boolean.TRUE);
      return;
    }

    // run over all dependencies
    initiants.forEach(
        (id, info) -> {

          // get the name of the verticle
          String name = info.getString("name");
          final JsonObject localConfig = new JsonObject();
          localConfig.mergeIn(globalConfig);
          localConfig.mergeIn(info.getJsonObject("config", new JsonObject()));

          Handler<AsyncResult<String>> handler =
              innerEvent -> {
                if (innerEvent.succeeded()) {
                  // add service to deployed-list
                  deployed.add(id);

                  // re-emit
                  vertx
                      .eventBus()
                      .send(
                          LOOPBACK,
                          workingCopy,
                          (AsyncResult<Message<Boolean>> recursiveReply) -> {
                            // always decrease latch
                            latch.countDown();

                            if (recursiveReply.succeeded() && recursiveReply.result().body()) {
                              if (latch.getCount() == 0) {
                                event.reply(recursiveReply.result().body() & Boolean.TRUE);
                              }
                            } else {
                              event.fail(500, this.getFailure(id, recursiveReply));
                            }
                          });

                } else {
                  event.fail(500, id + " >> " + innerEvent.cause().getMessage());
                }
              };

          LOG.log(Level.INFO, "Deploying: ''{0}''", new Object[] {id});
          DeploymentOptions deploymentOptions = new DeploymentOptions(info);
          vertx.deployVerticle(name, deploymentOptions.setConfig(localConfig), handler);
        });
  }