System.out.println("MQTT client [" + endpoint.clientIdentifier() + "] request to connect, clean session = " + endpoint.isCleanSession()); if (endpoint.auth() != null) { System.out.println("[username = " + endpoint.auth().userName() + ", password = " + endpoint.auth().password() + "]"); if (endpoint.will() != null) { System.out.println("[will flag = " + endpoint.will().isWillFlag() + " topic = " + endpoint.will().willTopic() + " msg = " + endpoint.will().willMessage() + " QoS = " + endpoint.will().willQos() + " isRetain = " + endpoint.will().isWillRetain() + "]"); System.out.println("[keep alive timeout = " + endpoint.keepAliveTimeSeconds() + "]"); endpoint.accept(false); endpoint.subscribeHandler(subscribe -> { endpoint.subscribeAcknowledge(subscribe.messageId(), grantedQosLevels); endpoint.publish(subscribe.topicSubscriptions().get(0).topicName(), Buffer.buffer("Hello from the Vert.x MQTT server"), subscribe.topicSubscriptions().get(0).qualityOfService(), endpoint.publishAcknowledgeHandler(messageId -> { }).publishReceivedHandler(messageId -> { endpoint.publishRelease(messageId); }).publishCompletionHandler(messageId -> {
System.out.println("connected client " + endpoint.clientIdentifier()); endpoint.publishHandler(message -> { }); endpoint.accept(false); });
System.out.println("MQTT client [" + endpoint.clientIdentifier() + "] request to connect, " + "clean session = " + endpoint.isCleanSession()); endpoint.accept(false);
private static void serverLogic(MqttEndpoint mqttEndpoint) { log.info("[SERVER] Client connected"); mqttEndpoint.publishHandler(p -> { log.info("[SERVER] Received PUBLISH with message id = " + p.messageId()); mqttEndpoint.publishReceived(3); mqttEndpoint.publishReceived(2); mqttEndpoint.publishReceived(1); mqttEndpoint.publishAcknowledge(2); mqttEndpoint.publishAcknowledge(1); mqttEndpoint.publishAcknowledge(3); mqttEndpoint.publishReleaseHandler(pr -> { log.info("[SERVER] Receive PUBREL with message id = " + pr); mqttEndpoint.publishComplete(2); mqttEndpoint.publishComplete(1); mqttEndpoint.publishComplete(3); mqttEndpoint.disconnectHandler(d -> log.info("[SERVER] Client disconnected")); mqttEndpoint.accept(false);
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.subscribeHandler(subscribe -> { endpoint.subscribeAcknowledge(subscribe.messageId(), subscribe.topicSubscriptions() .stream() .collect(Collectors.toList())); endpoint.publish(this.topic, Buffer.buffer(this.message), subscribe.topicSubscriptions().get(0).qualityOfService(), false, false, publishSent -> { context.assertTrue(publishSent.succeeded()); this.async.complete(); }); }).publishAcknowledgeHandler(messageId -> { }).publishReceivedHandler(messageId -> { endpoint.publishRelease(messageId); }).publishCompletionHandler(messageId -> { }); endpoint.accept(false);
this.clientConnectedWithSsl = endpoint.isSsl(); receivedClientPeerCertificates = endpoint.sslSession().getPeerCertificates(); receivedClientCertificateValidated = true; log.info("Trusted client connected"); if (disconnectUntrustedClient) { log.info("Disconnecting untrusted client"); endpoint.close(); this.async.complete(); return; endpoint.publishHandler(message -> { endpoint.publishAcknowledge(message.messageId()); this.async.complete(); break; endpoint.publishReceived(message.messageId()); break; }).publishReleaseHandler(messageId -> { endpoint.publishComplete(messageId); this.async.complete(); }); endpoint.accept(false);
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); }
/** * 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); }
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.subscribeHandler(subscribe -> { List<MqttQoS> qos = new ArrayList<>(); qos.add(subscribe.topicSubscriptions().get(0).qualityOfService()); endpoint.subscribeAcknowledge(subscribe.messageId(), qos); this.subscribeAsync.complete(); }).unsubscribeHandler(unsubscribe -> { endpoint.unsubscribeAcknowledge(unsubscribe.messageId()); this.unsubscribeAsync.complete(); }); endpoint.accept(false); } }
clientOptions.setHeartbeat(this.mqttEndpoint.keepAliveTimeSeconds() * 1000); String userName = (this.mqttEndpoint.auth() != null) ? this.mqttEndpoint.auth().userName() : null; String password = (this.mqttEndpoint.auth() != null) ? this.mqttEndpoint.auth().password() : null; String clientIdentifier = this.mqttEndpoint.clientIdentifier(); if (done.succeeded()) { this.mqttEndpoint.accept(!amqpSubscriptionsMessage.topicSubscriptions().isEmpty()); this.mqttEndpoint.accept(false); this.grantedQoSLevels = new HashMap<>(); this.mqttEndpoint.reject(CONNECTION_REFUSED_SERVER_UNAVAILABLE); LOG.error("CONNACK [{}] to MQTT client {} at {}", CONNECTION_REFUSED_SERVER_UNAVAILABLE.ordinal(), clientIdentifier, this.remoteAddress); if (this.mqttEndpoint.will().isWillFlag()) { MqttWill will = this.mqttEndpoint.will(); if (this.mqttEndpoint.isCleanSession()) { this.mqttEndpoint.reject(code);
(endpoint.auth().getUsername().equals(MQTT_USERNAME) && endpoint.auth().getPassword().equals(MQTT_PASSWORD)) ? MqttConnectReturnCode.CONNECTION_ACCEPTED : MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USER_NAME_OR_PASSWORD; returnCode = endpoint.protocolVersion() == MqttConnectOptions.MQTT_VERSION_3_1_1 ? MqttConnectReturnCode.CONNECTION_ACCEPTED : MqttConnectReturnCode.CONNECTION_REFUSED_UNACCEPTABLE_PROTOCOL_VERSION; log.info("client id = " + endpoint.clientIdentifier()); endpoint.accept(false); } else { endpoint.reject(returnCode);
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.subscribeHandler(subscribe -> { List<MqttQoS> qos = new ArrayList<>(); MqttQoS grantedQos = subscribe.topicSubscriptions().get(0).topicName().equals(MQTT_TOPIC_FAILURE) ? MqttQoS.FAILURE : subscribe.topicSubscriptions().get(0).qualityOfService(); qos.add(grantedQos); endpoint.subscribeAcknowledge(subscribe.messageId(), qos); this.async.complete(); }); endpoint.accept(false); } }
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.disconnectHandler(v -> { log.info("MQTT remote client disconnected"); }); endpoint.closeHandler(v -> { log.info("MQTT remote client connection closed"); }); endpoint.accept(false); } }
.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_SERVER) .withTag(Tags.COMPONENT.getKey(), getTypeName()) .withTag(TracingHelper.TAG_CLIENT_ID.getKey(), endpoint.clientIdentifier()) .withTag(TracingHelper.TAG_AUTHENTICATED.getKey(), authenticatedDevice != null) .start(); endpoint.closeHandler(c -> { .collect(Collectors.toList()); if (endpoint.isConnected()) { endpoint.subscribeAcknowledge(subscribeMsg.messageId(), grantedQosLevels);
/** * @return the client identifier as provided by the remote MQTT client */ public String clientIdentifier() { if (cached_2 != null) { return cached_2; } String ret = delegate.clientIdentifier(); cached_2 = ret; return ret; }
/** * @return the Authentication information as provided by the remote MQTT client */ public MqttAuth auth() { if (cached_3 != null) { return cached_3; } MqttAuth ret = delegate.auth(); cached_3 = ret; return ret; }
/** * Sends the CONNACK message to the remote MQTT client with "connection accepted" * return code. See {@link io.vertx.rxjava.mqtt.MqttEndpoint#reject} for refusing connection * @param sessionPresent if a previous session is present * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.mqtt.MqttEndpoint accept(boolean sessionPresent) { delegate.accept(sessionPresent); return this; }
metrics.incrementCommandResponseDeliveredToApplication(targetAddress.getTenantId()); if (ctx.deviceEndpoint().isConnected() && ctx.message().qosLevel() == MqttQoS.AT_LEAST_ONCE) { ctx.deviceEndpoint().publishAcknowledge(ctx.message().messageId());
@Override protected void endpointHandler(MqttEndpoint endpoint, TestContext context) { endpoint.closeHandler(v -> { log.info("MQTT remote client connection closed"); }); endpoint.accept(false); } }
TracingHelper.TAG_CLIENT_ID.set(commandContext.getCurrentSpan(), endpoint.clientIdentifier()); final Command command = commandContext.getCommand(); final String topic = String.format("%s/%s/%s/%s/%s/%s", subscription.getEndpoint(), tenantId, deviceId, subscription.getRequestPart(), commandRequestId, command.getName()); endpoint.publish(topic, command.getPayload(), qos, false, false); metrics.incrementCommandDeliveredToDevice(subscription.getTenant()); LOG.trace("command published to device [tenant-id: {}, device-id: {}, MQTT client-id: {}]", subscription.getTenant(), subscription.getDeviceId(), endpoint.clientIdentifier()); final Map<String, String> items = new HashMap<>(3); items.put(Fields.EVENT, "command published to device");