Future based Verticle deployment contract

[vietj]

Motivation

Vert.x 4 has introduced a future based programming model, yet the Verticle and AbstractVerticle contracts doe not leverage this model for writing deployments. In addition the current API only provides anonymous classes preventing use cases where a simple lambda would fit.

Changes

Introduce a new io.vertx.core.Deployable interface:

@FunctionnalInterface
public interfacer Deployable {
  Future<?> deploy(Context context);
  default Future<?> undeploy(Context context) { /* implementation */ }
}

New deploy methods are added to Vertx providing

vertx.deployVerticle(context -> vertx
  .createHttpServer()
  .requestHandler(req -> req.response().end())
  .listen(port, host));

In addition Verticle extends now Deployable and Vertx only needs to handle deployments of Deployable.

A new VerticleBase class can be used as a replacement of AbstractVerticle:

public abstract class VerticleBase implements Deployable {

  /**
   * Reference to the Vert.x instance that deployed this verticle
   */
  protected Vertx vertx;

  /**
   * Reference to the context of the verticle
   */
  protected Context context;

  public void init(Vertx vertx, Context context) {
    this.vertx = vertx;
    this.context = context;
  }

  public String deploymentID() {
    return context.deploymentID();
  }

  public JsonObject config() {
    return context.config();
  }

  ...

  public Future<?> start() throws Exception { ... }
  public Future<?> stop() throws Exception { ... }
}

Users migrating to VerticleBase need to change the the base class of their verticle and return a Future<?> instead of completing a promise or returning void (they can return super.start()).

Verticle and AbstractVerticle are not deprecated but we do not encourage anymore to use these contracts.

The VerticleFactory contract has been updated to provide the ability to deploy vanilla deployable.