endpoint.publishHandler(message -> {
endpoint.publishHandler(message -> {
/** * Set the publish handler on the MQTT endpoint. This handler is called when a PUBLISH * message is received by the remote MQTT client * @param handler the handler * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.mqtt.MqttEndpoint publishHandler(Handler<io.vertx.rxjava.mqtt.messages.MqttPublishMessage> handler) { delegate.publishHandler(new Handler<io.vertx.mqtt.messages.MqttPublishMessage>() { public void handle(io.vertx.mqtt.messages.MqttPublishMessage event) { handler.handle(io.vertx.rxjava.mqtt.messages.MqttPublishMessage.newInstance(event)); } }); return this; }
/** * Set the publish handler on the MQTT endpoint. This handler is called when a PUBLISH * message is received by the remote MQTT client * @param handler the handler * @return a reference to this, so the API can be used fluently */ public MqttEndpoint publishHandler(Handler<MqttPublishMessage> handler) { delegate.publishHandler(new Handler<io.vertx.mqtt.messages.MqttPublishMessage>() { public void handle(io.vertx.mqtt.messages.MqttPublishMessage event) { handler.handle(MqttPublishMessage.newInstance(event)); } }); return this; }
/** * Set the publish handler on the MQTT endpoint. This handler is called when a PUBLISH * message is received by the remote MQTT client * @param handler the handler * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.mqtt.MqttEndpoint publishHandler(Handler<io.vertx.rxjava.mqtt.messages.MqttPublishMessage> handler) { delegate.publishHandler(new Handler<io.vertx.mqtt.messages.MqttPublishMessage>() { public void handle(io.vertx.mqtt.messages.MqttPublishMessage event) { handler.handle(io.vertx.rxjava.mqtt.messages.MqttPublishMessage.newInstance(event)); } }); return this; }
private Future<Device> registerHandlers(final MqttEndpoint endpoint, final Device authenticatedDevice) { endpoint.closeHandler(v -> close(endpoint, authenticatedDevice)); endpoint.publishHandler( message -> handlePublishedMessage(new MqttContext(message, endpoint, authenticatedDevice))); endpoint.subscribeHandler(subscribeMsg -> onSubscribe(endpoint, authenticatedDevice, subscribeMsg)); endpoint.unsubscribeHandler(unsubscribeMsg -> onUnsubscribe(endpoint, authenticatedDevice, unsubscribeMsg)); metrics.incrementConnections(authenticatedDevice.getTenantId()); return Future.succeededFuture(authenticatedDevice); }
/** * Invoked when a client sends its <em>CONNECT</em> packet and client authentication has been disabled by setting * the {@linkplain ProtocolAdapterProperties#isAuthenticationRequired() authentication required} configuration * property to {@code false}. * <p> * Registers a close handler on the endpoint which invokes {@link #close(MqttEndpoint, Device)}. Registers a publish * handler on the endpoint which invokes {@link #onPublishedMessage(MqttContext)} for each message being published * by the client. Accepts the connection request. * * @param endpoint The MQTT endpoint representing the client. */ private Future<Device> handleEndpointConnectionWithoutAuthentication(final MqttEndpoint endpoint) { endpoint.closeHandler(v -> close(endpoint, null)); endpoint.publishHandler(message -> handlePublishedMessage(new MqttContext(message, endpoint))); endpoint.subscribeHandler(subscribeMsg -> onSubscribe(endpoint, null, subscribeMsg)); endpoint.unsubscribeHandler(unsubscribeMsg -> onUnsubscribe(endpoint, null, unsubscribeMsg)); LOG.debug("unauthenticated device [clientId: {}] connected", endpoint.clientIdentifier()); metrics.incrementUnauthenticatedConnections(); return Future.succeededFuture(); }
/** * Setup handlers for MQTT endpoint */ private void setupMqttEndpoint() { this.mqttEndpoint .publishHandler(this::publishHandler) .publishAcknowledgeHandler(this::pubackHandler) .publishReleaseHandler(this::pubrelHandler) .publishReceivedHandler(this::pubrecHandler) .publishCompletionHandler(this::pubcompHandler) .subscribeHandler(this::subscribeHandler) .unsubscribeHandler(this::unsubscribeHandler) .disconnectHandler(this::disconnectHandler) .closeHandler(this::closeHandler); }
private Future<Device> registerHandlers(final MqttEndpoint endpoint, final Device authenticatedDevice) { final CommandHandler<T> cmdHandler = new CommandHandler<>(vertx, getConfig()); endpoint.closeHandler(v -> close(endpoint, authenticatedDevice, cmdHandler)); endpoint.publishHandler( message -> handlePublishedMessage(MqttContext.fromPublishPacket(message, endpoint, authenticatedDevice))); endpoint.publishAcknowledgeHandler(msgId -> cmdHandler.handlePubAck(msgId, afterCommandPubAckedConsumer)); endpoint.subscribeHandler(subscribeMsg -> onSubscribe(endpoint, authenticatedDevice, subscribeMsg, cmdHandler)); endpoint.unsubscribeHandler(unsubscribeMsg -> onUnsubscribe(endpoint, authenticatedDevice, unsubscribeMsg, cmdHandler)); if (authenticatedDevice == null) { metrics.incrementUnauthenticatedConnections(); } else { metrics.incrementConnections(authenticatedDevice.getTenantId()); } return Future.succeededFuture(authenticatedDevice); }
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.publishHandler(message -> { log.info("Just received message on [" + message.topicName() + "] payload [" + message.payload().toString(Charset.defaultCharset()) + "] with QoS [" + message.qosLevel() + "]"); switch (message.qosLevel()) { case AT_LEAST_ONCE: endpoint.publishAcknowledge(message.messageId()); this.async.complete(); break; case EXACTLY_ONCE: endpoint.publishReceived(message.messageId()); break; case AT_MOST_ONCE: this.async.complete(); break; } }).publishReleaseHandler(messageId -> { endpoint.publishComplete(messageId); this.async.complete(); }); endpoint.accept(false); }
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.publishHandler(message -> { log.info("Just received message on [" + message.topicName() + "] payload [" + message.payload().toString(Charset.defaultCharset()) + "] with QoS [" + message.qosLevel() + "]"); switch (message.qosLevel()) { case AT_LEAST_ONCE: endpoint.publishAcknowledge(message.messageId()); this.async.complete(); break; case EXACTLY_ONCE: endpoint.publishReceived(message.messageId()); break; case AT_MOST_ONCE: this.async.complete(); break; } }).publishReleaseHandler(messageId -> { endpoint.publishComplete(messageId); this.async.complete(); }); endpoint.accept(false); }
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.publishHandler(message -> {
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.publishHandler(message -> {
endpoint.publishHandler(message -> {
endpoint.publishHandler(message -> {
private static void serverLogic(MqttEndpoint mqttEndpoint) { log.info("[SERVER] Client connected"); mqttEndpoint.publishHandler(p -> { log.info("[SERVER] Received PUBLISH with message id = " + p.messageId());
private static void serverLogic(MqttEndpoint mqttEndpoint) { log.info("[SERVER] Client connected"); mqttEndpoint.publishHandler(p -> { log.info("[SERVER] Received PUBLISH with message id = " + p.messageId());