private void onDisconnect() { LOG.info("Connecting client..."); vertx.setTimer(connectionRetryInterval, reconnect -> { LOG.info("attempting to re-connect to Hono ..."); client.connect(con -> onDisconnect()); }); }
private Future<RegistrationClient> getRegistrationClient() { return honoRegistryClient .connect(new ProtonClientOptions()) .compose(connectedClient -> connectedClient.getOrCreateRegistrationClient(HonoExampleConstants.TENANT_ID)); }
/** * Gets a client for the Credentials service. * * @param tenantId The tenant to get the client for. * @return A future containing the client. */ protected final Future<CredentialsClient> getCredentialsClient(final String tenantId) { if (credentialsServiceClient == null) { return Future.failedFuture(new IllegalStateException("no credentials client set")); } else { return credentialsServiceClient.getOrCreateCredentialsClient(tenantId); } }
private Future<MessageSender> getSender(final String endpoint, final String tenant) { if (endpoint.equals(HonoSampler.Endpoint.telemetry.toString())) { LOGGER.trace("getting telemetry sender for tenant [{}]", tenant); return honoClient.getOrCreateTelemetrySender(tenant); } else { LOGGER.trace("getting event sender for tenant [{}]", tenant); return honoClient.getOrCreateEventSender(tenant); } }
private Future<MessageSender> getMessageSender() { return honoMessagingClient .connect(new ProtonClientOptions()) .compose(connectedClient -> { if (isEventMode()) { return connectedClient.getOrCreateEventSender(HonoExampleConstants.TENANT_ID); } else { return connectedClient.getOrCreateTelemetrySender(HonoExampleConstants.TENANT_ID); } }); }
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; }); } }
private Future<RegistrationClient> getRegistrationClient(final String tenant) { return registrationHonoClient.getOrCreateRegistrationClient(tenant); }
private Future<Void> closeServiceClient(final HonoClient client) { final Future<Void> shutdownTracker = Future.future(); if (client == null) { shutdownTracker.complete(); } else { client.shutdown(shutdownTracker.completer()); } return shutdownTracker; }
/** * Gets a client for interacting with the Tenant service. * * @return The client. */ protected final Future<TenantClient> getTenantClient() { return getTenantServiceClient().getOrCreateTenantClient(); }
private void sendCommandAndReceiveResponse(final String tenantId, final String deviceId) { client.getOrCreateCommandClient(tenantId, deviceId) .map(this::setCommandTimeOut) .compose(commandClient -> commandClient .sendCommand(sampler.getCommand(), Buffer.buffer(sampler.getCommandPayload())) .map(commandResponse -> { final String commandResponseText = Optional.ofNullable(commandResponse.getPayload()) .orElse(Buffer.buffer()).toString(); LOG.debug("Command response from device [{}:{}] received [{}]", tenantId, deviceId, commandResponseText); synchronized (lock) { successCount.incrementAndGet(); bytesReceived.addAndGet(sampler.getCommandPayload().getBytes().length); bytesSent.addAndGet(commandResponseText.getBytes().length); } return commandResponse; }) .map(x -> closeCommandClient(commandClient, tenantId, deviceId)) .recover(error -> { if (triggerType.equals("device") || devicesReadyToReceiveCommands.contains(deviceId)) { errorCount.incrementAndGet(); } LOG.error("Error processing command [{}] to device [{}:{}]", error.getMessage(), tenantId, deviceId); closeCommandClient(commandClient, tenantId, deviceId); return Future.failedFuture(error); })); }
/** * Gets a client for sending telemetry data for a tenant. * * @param tenantId The tenant to send the telemetry data for. * @return The client. */ protected final Future<MessageSender> getTelemetrySender(final String tenantId) { return getHonoMessagingClient().getOrCreateTelemetrySender(tenantId); }
/** * Gets a client for sending events for a tenant. * * @param tenantId The tenant to send the events for. * @return The client. */ protected final Future<MessageSender> getEventSender(final String tenantId) { return getHonoMessagingClient().getOrCreateEventSender(tenantId); }
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); }
/** * Gets a client for interacting with the Device Registration service. * * @param tenantId The tenant that the client is scoped to. * @return The client. */ protected final Future<RegistrationClient> getRegistrationClient(final String tenantId) { return getRegistrationServiceClient().getOrCreateRegistrationClient(tenantId); }
private Future<Void> closeServiceClient(final HonoClient client) { final Future<Void> shutdownTracker = Future.future(); if (client == null) { shutdownTracker.complete(); } else { client.shutdown(shutdownTracker.completer()); } return shutdownTracker; }
/** * Gets a client for interacting with the Tenant service. * * @return The client. */ protected final Future<TenantClient> getTenantClient() { return getTenantServiceClient().getOrCreateTenantClient(); }
private Future<Void> processCommand(final Command command) { LOG.info("Command sent to device... [request will timeout in {} seconds]", requestTimeoutInSecs); final Future<CommandClient> commandClient = client.getOrCreateCommandClient(tenantId, deviceId); return commandClient .map(this::setRequestTimeOut) .compose(c -> { if (command.isOneWay()) { return c .sendOneWayCommand(command.getName(), command.getContentType(), Buffer.buffer(command.getPayload()), null) .map(ok -> c); } else { return c .sendCommand(command.getName(), command.getContentType(), Buffer.buffer(command.getPayload()), null) .map(this::printResponse) .map(ok -> c); } }) .map(this::closeCommandClient) .otherwise(error -> { LOG.error("Error sending command: {}", error.getMessage()); if (commandClient.succeeded()) { return closeCommandClient(commandClient.result()); } else { return null; } }); }
/** * Gets a client for sending telemetry data for a tenant. * * @param tenantId The tenant to send the telemetry data for. * @return The client. */ protected final Future<MessageSender> getTelemetrySender(final String tenantId) { return getHonoMessagingClient().getOrCreateTelemetrySender(tenantId); }
/** * Gets a client for sending events for a tenant. * * @param tenantId The tenant to send the events for. * @return The client. */ protected final Future<MessageSender> getEventSender(final String tenantId) { return getHonoMessagingClient().getOrCreateEventSender(tenantId); }
private void onDisconnect(final ProtonConnection con) { // give Vert.x some time to clean up NetClient vertx.setTimer(connectionRetryInterval, reconnect -> { LOG.info("attempting to re-connect to Hono ..."); client.connect(this::onDisconnect) .compose(this::createConsumer); }); }