@Override public void start() throws Exception { ProtonClient client = ProtonClient.create(vertx); client.connect("localhost", 5672, res -> { if(!res.succeeded()) { System.out.println("Connect failed: " + res.cause()); return; } ProtonConnection connection = res.result(); connection.open(); connection.createReceiver(address).handler((delivery, msg) -> { String content = (String) ((AmqpValue) msg.getBody()).getValue(); System.out.println("Received message with content: " + content); // By default, receivers automatically accept (and settle) the delivery // when the handler returns, if no other disposition has been applied. // To change this and always manage dispositions yourself, use the // setAutoAccept method on the receiver. }).open(); }); } }
receiver.handler((delivery, msg) -> { String address = remoteTarget.getAddress() ; if (address == null) {
/** * Open the control endpoint, attaching the link */ public void openControl() { this.deliveries = new HashMap<>(); // attach receiver link on the $mqtt.to.<client-id>.control address for receiving messages (from SS) // define handler for received messages // - AMQP_SUBSCRIPTIONS after sent AMQP_LIST -> for writing CONNACK (session-present) this.receiver.receiverControl() .setQoS(ProtonQoS.AT_LEAST_ONCE) .handler(this::messageHandler) .open(); }
/** * Open the publish endpoint, attaching the link */ public void openPublish() { // attach receiver link on the $mqtt.to.<client-id>.publish address for receiving published messages // define handler for received messages // - AMQP_PUBLISH for every AMQP published message // - AMQP_PUBREL for handling QoS 2 this.receiver.receiverPublish() .setQoS(ProtonQoS.AT_LEAST_ONCE) .handler(this::messageHandler) .open(); }
receiver.setPrefetch(0); receiver.openHandler(r -> receiver.flow(1)); receiver.handler((delivery, message) -> { messages.add(message); if (messages.size() == numMessages) {
/** * Initializes common fixture. */ @Before public void setUp() { receiver = mock(ProtonReceiver.class); when(receiver.handler(any())).thenReturn(receiver); when(receiver.closeHandler(any())).thenReturn(receiver); when(receiver.setAutoAccept(any(Boolean.class))).thenReturn(receiver); when(receiver.setPrefetch(any(Integer.class))).thenReturn(receiver); when(receiver.setQoS(any(ProtonQoS.class))).thenReturn(receiver); when(vertx.eventBus()).thenReturn(eventBus); when(eventBus.<JsonObject> consumer(any(), any())).thenReturn(messageConsumer); sender = mock(ProtonSender.class); }
private static Future<ProtonReceiver> openReceiver(final ProtonConnection openConnection, final ProtonMessageHandler messageHandler) { final Future<ProtonReceiver> result = Future.future(); openConnection.createReceiver(AuthenticationConstants.ENDPOINT_NAME_AUTHENTICATION).openHandler(result.completer()).handler(messageHandler).open(); return result; } }
/** * Verifies that the endpoint opens a receiver under normal circumstances. */ @Test public void testOnLinkAttachOpensReceiver() { final RequestResponseEndpoint<ServiceConfigProperties> endpoint = getEndpoint(true); when(receiver.getRemoteQoS()).thenReturn(ProtonQoS.AT_LEAST_ONCE); endpoint.onLinkAttach(connection, receiver, resource); verify(receiver).handler(any(ProtonMessageHandler.class)); verify(receiver).open(); verify(receiver, never()).close(); }
receiver.setTarget(target); log.info("[{}]: Got publish request from {} on {}", containerId, connection.getRemoteContainer(), target.getAddress()); receiver.handler((delivery, message) -> { vertx.executeBlocking(promise -> { try {
private void createReceiver(Vertx vertx, String address, CompletableFuture<Void> promise, int retries) { receiver = connection.createReceiver(address); Source source = new Source(); source.setDynamic(true); receiver.setSource(source); receiver.openHandler(h -> { if (h.succeeded()) { context = vertx.getOrCreateContext(); replyTo = receiver.getRemoteSource().getAddress(); promise.complete(null); } else { if (retries > maxRetries) { promise.completeExceptionally(h.cause()); } else { log.info("Error creating receiver, retries = {}", retries); vertx.setTimer(1000, id -> createReceiver(vertx, address, promise, retries + 1)); } } }); receiver.handler(((protonDelivery, message) -> { try { replies.put(message); ProtonHelper.accepted(protonDelivery, true); } catch (Exception e) { ProtonHelper.rejected(protonDelivery, true); } })); receiver.open(); }
}); receiver.handler((delivery, message) -> { Delivery envelope = new DeliveryImpl(message, delivery, connCtx); if(!subscription.onNextWrapper(envelope)){
receiver.flow(sender.getCredit()); receiver.setSource(source); receiver.handler(((delivery, message) -> handleMessage(sender, receiver, delivery, message))); receiver.open(); } else {
receiver.setSource(source); receiver.setPrefetch(0); receiver.handler((protonDelivery, message) -> { messages.add(message); messageCount.incrementAndGet();
@Override public final void onLinkAttach(final ProtonReceiver receiver, final ResourceIdentifier targetAddress) { final String linkId = UUID.randomUUID().toString(); final UpstreamReceiver link = UpstreamReceiver.newUpstreamReceiver(linkId, receiver, getEndpointQos()); downstreamAdapter.onClientAttach(link, s -> { if (s.succeeded()) { receiver.closeHandler(clientDetached -> { // client has closed link -> inform TelemetryAdapter about client detach onLinkDetach(link); downstreamAdapter.onClientDetach(link); }).handler((delivery, message) -> { if (passesFormalVerification(targetAddress, message)) { forwardMessage(link, delivery, message); } else { MessageHelper.rejected(delivery, AmqpError.DECODE_ERROR.toString(), "malformed message"); onLinkDetach(link, condition(AmqpError.DECODE_ERROR.toString(), "invalid message received")); } }).open(); logger.debug("accepted link from telemetry client [{}]", linkId); } else { // we cannot connect to downstream container, reject client link.close(condition(AmqpError.PRECONDITION_FAILED, "no consumer available for target")); } }); }
private void receiverHandler(ProtonReceiver receiver) { LOG.info("Attaching link request"); // the LWT service supports only the control address if (!receiver.getRemoteTarget().getAddress().equals(LWT_SERVICE_ENDPOINT)) { ErrorCondition errorCondition = new ErrorCondition(AmqpError.NOT_FOUND, "The provided address isn't supported"); receiver.setCondition(errorCondition) .close(); } else { receiver.setTarget(receiver.getRemoteTarget()) .setQoS(ProtonQoS.AT_LEAST_ONCE) .handler((delivery, message) -> { this.messageHandler(receiver, delivery, message); }) .closeHandler(ar -> { this.closeHandler(receiver, ar); }) .detachHandler(ar -> { this.closeHandler(receiver, ar); }) .setPrefetch(0) .open(); receiver.flow(AMQP_WILL_CREDITS); } }
receiver.handler((delivery, message) -> { handleMessage(con, receiver, targetAddress, delivery, message); });
receiver.handler((delivery, message) -> { handleMessage(con, receiver, targetAddress, delivery, message); });
@Override public void onLinkAttach(final ProtonReceiver receiver, final ResourceIdentifier targetAddress) { if (ProtonQoS.AT_MOST_ONCE.equals(receiver.getRemoteQoS())) { logger.debug("client wants to use AT MOST ONCE delivery mode for registration endpoint, this is not supported."); receiver.setCondition(condition(AmqpError.PRECONDITION_FAILED.toString(), "endpoint requires AT_LEAST_ONCE QoS")); receiver.close(); } else { logger.debug("establishing link for receiving registration messages from client [{}]", MessageHelper.getLinkName(receiver)); receiver .setQoS(ProtonQoS.AT_LEAST_ONCE) .setAutoAccept(true) // settle received messages if the handler succeeds .setPrefetch(20) .handler((delivery, message) -> { if (RegistrationMessageFilter.verify(targetAddress, message)) { try { processRequest(message); } catch (DecodeException e) { MessageHelper.rejected(delivery, AmqpError.DECODE_ERROR.toString(), "malformed payload"); } } else { MessageHelper.rejected(delivery, AmqpError.DECODE_ERROR.toString(), "malformed registration message"); // we close the link if the client sends a message that does not comply with the API spec onLinkDetach(receiver, condition(AmqpError.DECODE_ERROR.toString(), "invalid message received")); } }).closeHandler(clientDetached -> onLinkDetach(clientDetached.result())) .open(); } }
this.processCloseReceiver(receiver); }) .handler((delivery, message) -> { this.processMessage(receiver, delivery, message); });
receiver.handler((d, m) -> { Section body = m.getBody(); context.assertNotNull(body);