How to use

info

method

in

org.vertx.java.core.logging.Logger

private void deployHADeployments() {
 int size = toDeployOnQuorum.size();
 if (size != 0) {
  log.info("There are " + size + " HA deployments waiting on a quorum. These will now be deployed");
  Runnable task;
  while ((task = toDeployOnQuorum.poll()) != null) {
   try {
    task.run();
   } catch (Throwable t) {
    log.error("Failed to run redeployment task", t);
   }
  }
 }
}

public void uninstallMod(String moduleName) {
 log.info("Uninstalling module " + moduleName + " from directory " + modRoot);
 File modDir = new File(modRoot, moduleName);
 if (!modDir.exists()) {
  log.error("Cannot find module to uninstall");
 } else {
  try {
   vertx.fileSystem().deleteSync(modDir.getAbsolutePath(), true);
   log.info("Module " + moduleName + " successfully uninstalled");
  } catch (Exception e) {
   log.error("Failed to delete directory: " + e.getMessage());
  }
 }
}

@Test
protected void runTestInLoop(String testName, int iters) throws Exception {
 Method meth = getClass().getMethod(testName, (Class<?>[])null);
 for (int i = 0; i < iters; i++) {
  log.info("****************************** ITER " + i);
  meth.invoke(this);
  tearDown();
  if (i != iters - 1) {
   setUp();
  }
 }
}

private void fatJar(String modName, Args args) {
 log.info("Attempting to make a fat jar for module " + modName);
 String directory = args.map.get("-d");
 if (directory != null && !new File(directory).exists()) {
  log.info("Directory does not exist: " + directory);
  return;
 }
 createPM().makeFatJar(modName, directory, createLoggingHandler("making fat jar", unblockHandler()));
 block();
}

 public void handle(HttpClientResponse resp) {
  if (resp.statusCode == 200) {
   log.info("Downloading module...");
   resp.bodyHandler(new Handler<Buffer>() {
    public void handle(Buffer buffer) {
     mod.set(buffer);
     latch.countDown();
    }
   });
  } else if (resp.statusCode == 404) {
   log.error("Can't find module " + moduleName + " in repository");
   latch.countDown();
  } else {
   log.error("Failed to download module: " + resp.statusCode);
   latch.countDown();
  }
 }
});

  @Override
  public void handle(HttpClientResponse event) {
    log.info(event.statusCode() + " - "+event.statusMessage());
    removeHandler(401);
  }
});

 @Override
 public void handle(AsyncResult<String> result) {
  if (result.succeeded()) {
   log.info("Successfully redeployed module " + moduleName + " after failover");
  } else {
   log.error("Failed to redeploy module after failover", result.cause());
   err.set(result.cause());
  }
  latch.countDown();
  Throwable t = err.get();
  if (t != null) {
   throw new VertxException(t);
  }
 }
});

  @Override
  public void handle(HttpClientResponse event) {
    log.info(event.statusCode() + " - "+event.statusMessage());
    removeHandler(401);
  }
});

 @Override
 public void handle(AsyncResult<Void> result) {
  if (result.succeeded()) {
   final Deployment dep = entry.getValue();
   log.info("Successfully undeployed HA deployment " + dep.modID + " as there is no quorum");
   addToHADeployList(dep.modID.toString(), dep.config, dep.instances, new AsyncResultHandler<String>() {
    @Override
    public void handle(AsyncResult<String> result) {
     if (result.succeeded()) {
      log.info("Successfully redeployed module " + entry.getValue().modID + " after quorum was re-attained");
     } else {
      log.error("Failed to redeploy module " + entry.getValue().modID + " after quorum was re-attained", result.cause());
     }
    }
   });
  } else {
   log.error("Failed to undeploy deployment on lost quorum", result.cause());
  }
 }
});

private void pullDependencies(String modName) {
 log.info("Attempting to pull in dependencies for module " + modName);
 createPM().pullInDependencies(modName, createLoggingHandler("pulling in dependencies", unblockHandler()));
 block();
}

private void installModule(String modName) {
 log.info("Attempting to install module " + modName);
 createPM().installModule(modName, createLoggingHandler("installing module", unblockHandler()));
 block();
}

protected void startTest(String testName, boolean wait) {
 log.info("Starting test: " + testName);
 EventLog.addEvent("Starting test " + testName);
 tu.startTest(testName);
 if (wait) {
  EventLog.addEvent("Waiting for test to complete");
  waitTestComplete();
  EventLog.addEvent("Test is now complete");
 }
}

private void createModuleLink(String modName) {
 log.info("Attempting to create module link for module " + modName);
 createPM().createModuleLink(modName, createLoggingHandler("creating module link", unblockHandler()));
 block();
}

private void uninstallModule(String modName) {
 log.info("Attempting to uninstall module " + modName);
 createPM().uninstallModule(modName, createLoggingHandler("uninstalling module", unblockHandler()));
 block();
}

 @Override
 public void handle(AsyncResult<String> result) {
  if (result.succeeded()) {
   // Tell the other nodes of the cluster about the verticle for HA purposes
   addVerticleToHA(deploymentInfo.getString("id"), result.result(), deploymentInfo.getString("main"), deploymentInfo.getObject("config"), deploymentInfo.getInteger("instances", 1), true);
   log.info("Successfully redeployed verticle " + deploymentInfo.getString("main") + " after failover");
  } else {
   log.error("Failed to redeploy verticle after failover", result.cause());
   err.set(result.cause());
  }
  latch.countDown();
  Throwable t = err.get();
  if (t != null) {
   throw new VertxException(t);
  }
 }
});

 @Override
 public void handle(AsyncResult<String> result) {
  if (result.succeeded()) {
   // Tell the other nodes of the cluster about the module for HA purposes
   addModuleToHA(deploymentInfo.getString("id"), result.result(), deploymentInfo.getString("module"), deploymentInfo.getObject("config"), deploymentInfo.getInteger("instances", 1), true);
   log.info("Successfully redeployed module " + deploymentInfo.getString("module") + " after failover");
  } else {
   log.error("Failed to redeploy module after failover", result.cause());
   err.set(result.cause());
  }
  latch.countDown();
  Throwable t = err.get();
  if (t != null) {
   throw new VertxException(t);
  }
 }
});

 @Override
 public void handle(AsyncResult<String> result) {
  if (result.succeeded()) {
   // Tell the other nodes of the cluster about the verticle for HA purposes
   addWorkerVerticleToHA(deploymentInfo.getString("id"), result.result(), deploymentInfo.getString("main"), deploymentInfo.getObject("config"), deploymentInfo.getInteger("instances", 1), deploymentInfo.getBoolean("multi-threaded", false), true);
   log.info("Successfully redeployed verticle " + deploymentInfo.getString("main") + " after failover");
  } else {
   log.error("Failed to redeploy verticle after failover", result.cause());
   err.set(result.cause());
  }
  latch.countDown();
  Throwable t = err.get();
  if (t != null) {
   throw new VertxException(t);
  }
 }
});

  @Override
  public void handle(AsyncResult<HttpServer> result) {
    final String listenPath = (configurator.getSSL() ? "https" : "http") + "://" + host + ":" + port;
    if (result.succeeded()) {
      container.logger().info("Http server listening for " + listenPath);
    } else {
      container.logger().error("Failed to start http server listening for " + listenPath, result.cause());
    }
    if (doneHandler != null) {
      doneHandler.handle(result);
    }
  }
});

 @Override
 public void handle(AsyncResult<Void> result) {
  if (result.succeeded()) {
   log.info("Successfully undeployed HA deployment " + deploymentInfo.getString("id") + " as there is no quorum");
   addModuleToHADeployList(deploymentID, deploymentInfo.getString("module"), deploymentInfo.getObject("config"),
     deploymentInfo.getInteger("instances"), new AsyncResultHandler<String>() {
    @Override
    public void handle(AsyncResult<String> result) {
     if (result.succeeded()) {
      log.info("Successfully redeployed module " + deploymentInfo.getString("module") + " after quorum was re-attained");
     } else {
      log.error("Failed to redeploy module " + deploymentInfo.getString("module") + " after quorum was re-attained", result.cause());
     }
    }
   });
  } else {
   log.error("Failed to undeploy deployment on lost quorum", result.cause());
  }
 }
});

 @Override
 public void handle(AsyncResult<Void> result) {
  if (result.succeeded()) {
   log.info("Successfully undeployed HA deployment " + deploymentInfo.getString("id") + " as there is no quorum");
   addVerticleToHADeployList(deploymentID, deploymentInfo.getString("main"), deploymentInfo.getObject("config"),
     deploymentInfo.getInteger("instances"), new AsyncResultHandler<String>() {
    @Override
    public void handle(AsyncResult<String> result) {
     if (result.succeeded()) {
      log.info("Successfully redeployed verticle " + deploymentInfo.getString("main") + " after quorum was re-attained");
     } else {
      log.error("Failed to redeploy verticle " + deploymentInfo.getString("main") + " after quorum was re-attained", result.cause());
     }
    }
   });
  } else {
   log.error("Failed to undeploy deployment on lost quorum", result.cause());
  }
 }
});