io.vertx.mqtt

## Interface MqttServer

-     public interface MqttServer

  An MQTT server

  You can accept incoming MQTT connection requests providing a `endpointHandler(Handler)`. As the requests arrive, the handler will be called with an instance of `MqttEndpoint` in order to manage the communication with the remote MQTT client.

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `actualPort()` The actual port the server is listening on.
    `Future<Void>` | `close()` Close the server.
    `void` | `close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `static MqttServer` | `create(Vertx vertx)` Return an MQTT server instance using default options
    `static MqttServer` | `create(Vertx vertx, MqttServerOptions options)` Return an MQTT server instance
    `MqttServer` | `endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttServer` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
    `Future<MqttServer>` | `listen()` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | `listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `Future<MqttServer>` | `listen(int port)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | `listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `Future<MqttServer>` | `listen(int port, String host)` Start the server listening for incoming connections on the port and host specified
    `MqttServer` | `listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor

- - ### Method Detail

    - #### create

          static MqttServer create(Vertx vertx,
                                   MqttServerOptions options)

      Return an MQTT server instance
      Parameters:
        `vertx` - Vert.x instance
        `options` - MQTT server options
      Returns:
        MQTT server instance

    - #### create

          static MqttServer create(Vertx vertx)

      Return an MQTT server instance using default options
      Parameters:
        `vertx` - Vert.x instance
      Returns:
        MQTT server instance

    - #### listen

          Future<MqttServer> listen()

      Start the server listening for incoming connections using the specified options through the constructor
      Returns:
        a `Future` completed with this server instance

    - #### listen

          Future<MqttServer> listen(int port,
                                    String host)

      Start the server listening for incoming connections on the port and host specified
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
      Returns:
        a `Future` completed with this server instance

    - #### listen

          MqttServer listen(int port,
                            String host,
                            Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          Future<MqttServer> listen(int port)

      Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host. It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
      Returns:
        a `Future` completed with this server instance

    - #### listen

          MqttServer listen(int port,
                            Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host. It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          MqttServer listen(Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections using the specified options through the constructor
      Parameters:
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### endpointHandler

          MqttServer endpointHandler(Handler<MqttEndpoint> handler)

      Set the endpoint handler for the server. If an MQTT client connect to the server a new MqttEndpoint instance will be created and passed to the handler
      Parameters:
        `handler` - the endpoint handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          MqttServer exceptionHandler(Handler<Throwable> handler)

      Set an exception handler for the server, that will be called when an error happens independantly of an accepted `MqttEndpoint`, like a rejected connection
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### actualPort

          int actualPort()

      The actual port the server is listening on. This is useful if you bound the server specifying 0 as port number signifying an ephemeral port
      Returns:
        the actual port the server is listening on.

    - #### close

          Future<Void> close()

      Close the server.

      The close happens asynchronously and the server may not be closed until some time after the call has returned.

      Returns:
        a `Future` completed with this server is closed

    - #### close

          void close(Handler<AsyncResult<Void>> completionHandler)

      Close the server supplying an handler that will be called when the server is actually closed (or has failed).
      Parameters:
        `completionHandler` - the handler called on completion

Copyright © 2021 Eclipse. All rights reserved.