Examples with ProtonSubscriber io.vertx.proton.streams.ProtonSubscriber used on opensource projects

Example 1 with ProtonSubscriber

use of io.vertx.proton.streams.ProtonSubscriber in project vertx-proton by vert-x3.

the class ProtonSubscriberIntTest method testCreateAnonymousRelaySubscriber.

@Test(timeout = 20000)
public void testCreateAnonymousRelaySubscriber(TestContext context) throws Exception {
    server.close();
    final Async serverLinkOpenAsync = context.async();
    final Async serverReceivedMessageAsync = context.async();
    final Async serverLinkCloseAsync = context.async();
    final String address1 = "testCreateAnonymousRelaySubscriber1";
    final String address2 = "testCreateAnonymousRelaySubscriber2";
    final AtomicInteger msgCounter = new AtomicInteger(0);
    final AtomicInteger acceptedMsgCounter = new AtomicInteger(0);
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> session.open());
            serverConnection.receiverOpenHandler(serverReceiver -> {
                LOG.trace("Server receiver opened");
                context.assertFalse(serverLinkOpenAsync.isCompleted(), "should only be one link opened");
                context.assertNull(serverReceiver.getRemoteTarget().getAddress(), "link target should have null address for anonymous relay");
                serverReceiver.handler((delivery, msg) -> {
                    int count = msgCounter.incrementAndGet();
                    if (LOG.isTraceEnabled()) {
                        LOG.trace("Server got msg: " + getMessageBody(context, msg));
                    }
                    switch(count) {
                        case 1:
                            {
                                validateMessage(context, 1, "1", msg);
                                context.assertEquals(address1, msg.getAddress(), "Unexpected message1 'to' address");
                                break;
                            }
                        case 2:
                            {
                                validateMessage(context, 2, "2", msg);
                                context.assertEquals(address2, msg.getAddress(), "Unexpected message2 'to' address");
                                // Complete the test
                                serverReceivedMessageAsync.complete();
                                break;
                            }
                    }
                });
                serverReceiver.closeHandler(x -> {
                    serverReceiver.close();
                    serverLinkCloseAsync.complete();
                });
                // Set the local terminus details [naively]
                serverReceiver.setTarget(serverReceiver.getRemoteTarget().copy());
                serverReceiver.open();
                serverLinkOpenAsync.complete();
            });
        });
        // ===== Client Handling =====
        ProtonClient client = ProtonClient.create(vertx);
        client.connect("localhost", protonServer.actualPort(), res -> {
            context.assertTrue(res.succeeded());
            ProtonConnection connection = res.result();
            connection.open();
            // Create subscriber without an address, to send to the anonymous relay
            ProtonSubscriber<Tracker> subscriber = ProtonStreams.createTrackerProducer(connection, null);
            Tracker envelope1 = Tracker.create(message(address1, "1"), env1 -> {
                context.assertTrue(env1.isAccepted(), "msg1 should be accepted");
                context.assertTrue(env1.isRemotelySettled(), "msg1 should be remotely settled");
                context.assertTrue(acceptedMsgCounter.compareAndSet(0, 1), "unexpected acceptedMsgCounter:" + acceptedMsgCounter);
            });
            Tracker envelope2 = Tracker.create(message(address2, "2"), env2 -> {
                context.assertTrue(env2.isAccepted(), "msg1 should be accepted");
                context.assertTrue(env2.isRemotelySettled(), "msg1 should be remotely settled");
                context.assertTrue(acceptedMsgCounter.compareAndSet(1, 2), "unexpected acceptedMsgCounter:" + acceptedMsgCounter);
            });
            Publisher<Tracker> producer = Flowable.just(envelope1, envelope2);
            producer.subscribe(subscriber);
        });
        serverLinkOpenAsync.awaitSuccess();
        serverReceivedMessageAsync.awaitSuccess();
        serverLinkCloseAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 2 with ProtonSubscriber

use of io.vertx.proton.streams.ProtonSubscriber in project vertx-proton by vert-x3.

the class ProtonSubscriberIntTest method testCreateUsingCustomTarget.

@Test(timeout = 20000)
public void testCreateUsingCustomTarget(TestContext context) throws Exception {
    server.close();
    final Async serverLinkOpenAsync = context.async();
    final Async serverReceivedMessageAsync = context.async();
    final Async serverLinkCloseAsync = context.async();
    final String address = "testCreateUsingCustomTarget";
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> session.open());
            serverConnection.receiverOpenHandler(serverReceiver -> {
                serverReceiver.handler((delivery, msg) -> {
                    // We got the message that was sent, complete the test
                    if (LOG.isTraceEnabled()) {
                        LOG.trace("Server got msg: " + getMessageBody(context, msg));
                    }
                    validateMessage(context, 1, "1", msg);
                    serverReceivedMessageAsync.complete();
                });
                // Verify the remote terminus details used were as expected
                context.assertNotNull(serverReceiver.getRemoteTarget(), "target should not be null");
                org.apache.qpid.proton.amqp.messaging.Target remoteTarget = (org.apache.qpid.proton.amqp.messaging.Target) serverReceiver.getRemoteTarget();
                context.assertEquals(address, remoteTarget.getAddress(), "unexpected target address");
                Symbol[] capabilities = remoteTarget.getCapabilities();
                context.assertTrue(Arrays.equals(new Symbol[] { Symbol.valueOf("custom") }, capabilities), "Unexpected capabilities: " + Arrays.toString(capabilities));
                // Set the local terminus details
                serverReceiver.setTarget(remoteTarget.copy());
                serverReceiver.closeHandler(x -> {
                    serverReceiver.close();
                    serverLinkCloseAsync.complete();
                });
                LOG.trace("Server receiver opened");
                serverReceiver.open();
                serverLinkOpenAsync.complete();
            });
        });
        // ===== Client Handling =====
        ProtonClient client = ProtonClient.create(vertx);
        client.connect("localhost", protonServer.actualPort(), res -> {
            context.assertTrue(res.succeeded());
            ProtonConnection connection = res.result();
            connection.open();
            // Create subscriber with custom target configured to be dynamic
            ProtonSubscriber<Tracker> subscriber = ProtonStreams.createTrackerProducer(connection, address);
            org.apache.qpid.proton.amqp.messaging.Target target = (org.apache.qpid.proton.amqp.messaging.Target) subscriber.getTarget();
            target.setCapabilities(new Symbol[] { Symbol.valueOf("custom") });
            Tracker envelope = Tracker.create(message("1"));
            Publisher<Tracker> publisher = Flowable.just(envelope);
            publisher.subscribe(subscriber);
        });
        serverLinkOpenAsync.awaitSuccess();
        serverReceivedMessageAsync.awaitSuccess();
        serverLinkCloseAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 3 with ProtonSubscriber

use of io.vertx.proton.streams.ProtonSubscriber in project vertx-proton by vert-x3.

the class ProtonSubscriberIntTest method testConfigureProducerLinkName.

@Test(timeout = 20000)
public void testConfigureProducerLinkName(TestContext context) throws Exception {
    server.close();
    final Async serverLinkOpenAsync = context.async();
    final Async serverReceivedMessageAsync = context.async();
    final Async serverLinkCloseAsync = context.async();
    final String linkName = "testConfigureProducerLinkName";
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> session.open());
            serverConnection.receiverOpenHandler(serverReceiver -> {
                LOG.trace("Server receiver opened");
                // Verify the link details used were as expected
                context.assertEquals(linkName, serverReceiver.getName(), "unexpected link name");
                serverReceiver.handler((delivery, msg) -> {
                    // We got the message that was sent, complete the test
                    if (LOG.isTraceEnabled()) {
                        LOG.trace("Server got msg: " + getMessageBody(context, msg));
                    }
                    validateMessage(context, 1, "1", msg);
                    serverReceivedMessageAsync.complete();
                });
                serverReceiver.closeHandler(x -> {
                    serverReceiver.close();
                    serverLinkCloseAsync.complete();
                });
                // Set the local terminus details [naively]
                serverReceiver.setTarget(serverReceiver.getRemoteTarget().copy());
                serverReceiver.open();
                serverLinkOpenAsync.complete();
            });
        });
        // ===== Client Handling =====
        ProtonClient client = ProtonClient.create(vertx);
        client.connect("localhost", protonServer.actualPort(), res -> {
            context.assertTrue(res.succeeded());
            ProtonConnection connection = res.result();
            connection.open();
            // Create subscriber with given link name
            ProtonSubscriberOptions options = new ProtonSubscriberOptions().setLinkName(linkName);
            ProtonSubscriber<Tracker> subscriber = ProtonStreams.createTrackerProducer(connection, "myAddress", options);
            Tracker envelope = Tracker.create(message("1"));
            Publisher<Tracker> producer = Flowable.just(envelope);
            producer.subscribe(subscriber);
        });
        serverLinkOpenAsync.awaitSuccess();
        serverReceivedMessageAsync.awaitSuccess();
        serverLinkCloseAsync.awaitSuccess();
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}

Example 4 with ProtonSubscriber

use of io.vertx.proton.streams.ProtonSubscriber in project vertx-proton by vert-x3.

the class MessageSubscriberBlackboxVerificationTckTest method createSubscriber.

@Override
public Subscriber<Message> createSubscriber() {
    int actualPort = server.actualPort();
    ProtonClient client = ProtonClient.create(vertx);
    AtomicReference<Subscriber<Message>> ref = new AtomicReference<>();
    CountDownLatch latch = new CountDownLatch(1);
    client.connect("localhost", actualPort, result -> {
        if (result.succeeded()) {
            ProtonConnection conn = result.result();
            conn.open();
            ProtonSubscriber<Message> stream = ProtonStreams.createProducer(conn, "myAddress");
            ((ProtonSubscriberWrapperImpl) stream).setEmitOnConnectionEnd(false);
            ref.set(stream);
        } else {
            LOG.error("Connection failed");
        }
        latch.countDown();
    });
    try {
        LOG.trace("Awaiting connection");
        boolean res = latch.await(2, TimeUnit.SECONDS);
        LOG.trace("Client connected: " + res);
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while creating subscriber", e);
    }
    return ref.get();
}

Example 5 with ProtonSubscriber

use of io.vertx.proton.streams.ProtonSubscriber in project vertx-proton by vert-x3.

the class MessageSubscriberWhiteboxVerificationTckTest method createSubscriber.

@Override
public Subscriber<Message> createSubscriber(WhiteboxSubscriberProbe<Message> probe) {
    int actualPort = server.actualPort();
    ProtonClient client = ProtonClient.create(vertx);
    AtomicReference<Subscriber<Message>> ref = new AtomicReference<>();
    CountDownLatch latch = new CountDownLatch(1);
    client.connect("localhost", actualPort, result -> {
        if (result.succeeded()) {
            ProtonConnection conn = result.result();
            conn.open();
            // Modified stream impl, overriding methods to add test probe instrumentation
            ProtonSubscriberImpl subscriber = new ProtonSubscriberImpl("myAddress", (ProtonConnectionImpl) conn);
            ProtonSubscriber<Message> stream = new ProtonSubscriberWrapperImpl(subscriber) {

                @Override
                public void onSubscribe(final Subscription s) {
                    super.onSubscribe(s);
                    probe.registerOnSubscribe(new SubscriberPuppet() {

                        @Override
                        public void triggerRequest(long n) {
                            s.request(n);
                        }

                        @Override
                        public void signalCancel() {
                            s.cancel();
                        }
                    });
                }

                @Override
                public void onNext(Message value) {
                    probe.registerOnNext(value);
                    super.onNext(value);
                }

                @Override
                public void onError(Throwable t) {
                    probe.registerOnError(t);
                    super.onError(t);
                }

                @Override
                public void onComplete() {
                    probe.registerOnComplete();
                    super.onComplete();
                }
            };
            ref.set(stream);
        } else {
            LOG.error("Connection failed");
        }
        latch.countDown();
    });
    try {
        LOG.trace("Awaiting connection");
        boolean res = latch.await(2, TimeUnit.SECONDS);
        LOG.trace("Client connected: " + res);
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while creating subscriber", e);
    }
    return ref.get();
}