private CompositeFuture createConsumer(final HonoClient connectedClient) { final Handler<Void> closeHandler = closeHook -> { LOG.info("close handler of consumer is called"); vertx.setTimer(connectionRetryInterval, reconnect -> { LOG.info("attempting to re-open the consumer link ..."); createConsumer(connectedClient); }); }; @SuppressWarnings("rawtypes") final List<Future> consumerFutures = new ArrayList<>(); if (messageType.equals(TYPE_EVENT) || messageType.equals(TYPE_ALL)) { consumerFutures.add( connectedClient.createEventConsumer(tenantId, msg -> handleMessage(TYPE_EVENT, msg), closeHandler)); } if (messageType.equals(TYPE_TELEMETRY) || messageType.equals(TYPE_ALL)) { consumerFutures.add(connectedClient .createTelemetryConsumer(tenantId, msg -> handleMessage(TYPE_TELEMETRY, msg), closeHandler)); } if (consumerFutures.isEmpty()) { consumerFutures.add(Future.failedFuture( String.format( "Invalid message type [\"%s\"]. Valid types are \"telemetry\", \"event\" or \"all\"", messageType))); } return CompositeFuture.all(consumerFutures); }
private Future<MessageConsumer> createConsumer(final String endpoint, final String tenant) { if (amqpNetworkClient == null) { return Future.failedFuture(new IllegalStateException("not connected to Hono")); } else if (endpoint.equals(HonoSampler.Endpoint.telemetry.toString())) { return amqpNetworkClient .createTelemetryConsumer(tenant, this::messageReceived, closeHook -> { LOGGER.error("telemetry consumer was closed"); }).map(consumer -> { LOGGER.info("created telemetry consumer [{}]", tenant); return consumer; }); } else { return amqpNetworkClient .createEventConsumer(tenant, this::messageReceived, closeHook -> { LOGGER.error("event consumer was closed"); }).map(consumer -> { LOGGER.info("created event consumer [{}]", tenant); return consumer; }); } }
/** * Create the message consumer that handles the downstream messages and invokes the notification callback * {@link #handleCommandReadinessNotification(TimeUntilDisconnectNotification)} if the message indicates that it * stays connected for a specified time. Supported are telemetry and event MessageConsumer. * * @return Future A succeeded future that contains the MessageConsumer if the creation was successful, a failed * Future otherwise. */ private Future<MessageConsumer> createConsumer() { // create the eventHandler by using the helper functionality for demultiplexing messages to callbacks final Consumer<Message> eventHandler = MessageTap.getConsumer( this::handleEventMessage, this::handleCommandReadinessNotification); // create the telemetryHandler by using the helper functionality for demultiplexing messages to // callbacks final Consumer<Message> telemetryHandler = MessageTap.getConsumer( this::handleTelemetryMessage, this::handleCommandReadinessNotification); return honoClient.createEventConsumer(HonoExampleConstants.TENANT_ID, eventHandler, closeHook -> LOG.error("remotely detached consumer link") ).compose(messageConsumer -> honoClient.createTelemetryConsumer(HonoExampleConstants.TENANT_ID, telemetryHandler, closeHook -> LOG.error("remotely detached consumer link") ).compose(telemetryMessageConsumer -> { LOG.info("Consumer ready for telemetry and event messages."); return Future.succeededFuture(telemetryMessageConsumer); }).recover(t -> Future.failedFuture(t) )); }
private Future<MessageConsumer> createMessageConsumers() { return client .createEventConsumer(tenant, getConsumer(message -> handleMessage("Event", message), this::handleCommandReadinessNotification), closeHook -> LOG.error("remotely detached consumer link")) .compose(consumer -> client.createTelemetryConsumer(tenant, getConsumer(message -> handleMessage("Telemetry", message), this::handleCommandReadinessNotification), closeHook -> LOG.error("remotely detached consumer link"))) .map(consumer -> { LOG.info("Ready to receive command readiness notifications for tenant [{}]", tenant); return consumer; }) .recover(Future::failedFuture); }