Search in sources :

Example 1 with ProtonServer

use of io.vertx.proton.ProtonServer 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();
        }
    }
}
Also used : TestContext(io.vertx.ext.unit.TestContext) ProtonConnection(io.vertx.proton.ProtonConnection) Async(io.vertx.ext.unit.Async) Arrays(java.util.Arrays) ProtonStreams(io.vertx.proton.streams.ProtonStreams) LoggerFactory(io.vertx.core.impl.logging.LoggerFactory) Rejected(org.apache.qpid.proton.amqp.messaging.Rejected) RunWith(org.junit.runner.RunWith) ProtonServer(io.vertx.proton.ProtonServer) MockServerTestBase(io.vertx.proton.MockServerTestBase) Flowable(io.reactivex.Flowable) ProtonHelper.message(io.vertx.proton.ProtonHelper.message) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) Symbol(org.apache.qpid.proton.amqp.Symbol) AmqpValue(org.apache.qpid.proton.amqp.messaging.AmqpValue) Modified(org.apache.qpid.proton.amqp.messaging.Modified) Message(org.apache.qpid.proton.message.Message) AsyncResult(io.vertx.core.AsyncResult) Logger(io.vertx.core.impl.logging.Logger) Tracker(io.vertx.proton.streams.Tracker) Publisher(org.reactivestreams.Publisher) Test(org.junit.Test) ProtonClient(io.vertx.proton.ProtonClient) VertxUnitRunner(io.vertx.ext.unit.junit.VertxUnitRunner) Released(org.apache.qpid.proton.amqp.messaging.Released) ExecutionException(java.util.concurrent.ExecutionException) Section(org.apache.qpid.proton.amqp.messaging.Section) FutureHandler(io.vertx.proton.FutureHandler) ProtonSubscriber(io.vertx.proton.streams.ProtonSubscriber) Handler(io.vertx.core.Handler) Accepted(org.apache.qpid.proton.amqp.messaging.Accepted) ProtonConnection(io.vertx.proton.ProtonConnection) Tracker(io.vertx.proton.streams.Tracker) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) ProtonServer(io.vertx.proton.ProtonServer) Async(io.vertx.ext.unit.Async) ProtonClient(io.vertx.proton.ProtonClient) Test(org.junit.Test)

Example 2 with ProtonServer

use of io.vertx.proton.ProtonServer 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();
        }
    }
}
Also used : TestContext(io.vertx.ext.unit.TestContext) ProtonConnection(io.vertx.proton.ProtonConnection) Async(io.vertx.ext.unit.Async) Arrays(java.util.Arrays) ProtonStreams(io.vertx.proton.streams.ProtonStreams) LoggerFactory(io.vertx.core.impl.logging.LoggerFactory) Rejected(org.apache.qpid.proton.amqp.messaging.Rejected) RunWith(org.junit.runner.RunWith) ProtonServer(io.vertx.proton.ProtonServer) MockServerTestBase(io.vertx.proton.MockServerTestBase) Flowable(io.reactivex.Flowable) ProtonHelper.message(io.vertx.proton.ProtonHelper.message) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) Symbol(org.apache.qpid.proton.amqp.Symbol) AmqpValue(org.apache.qpid.proton.amqp.messaging.AmqpValue) Modified(org.apache.qpid.proton.amqp.messaging.Modified) Message(org.apache.qpid.proton.message.Message) AsyncResult(io.vertx.core.AsyncResult) Logger(io.vertx.core.impl.logging.Logger) Tracker(io.vertx.proton.streams.Tracker) Publisher(org.reactivestreams.Publisher) Test(org.junit.Test) ProtonClient(io.vertx.proton.ProtonClient) VertxUnitRunner(io.vertx.ext.unit.junit.VertxUnitRunner) Released(org.apache.qpid.proton.amqp.messaging.Released) ExecutionException(java.util.concurrent.ExecutionException) Section(org.apache.qpid.proton.amqp.messaging.Section) FutureHandler(io.vertx.proton.FutureHandler) ProtonSubscriber(io.vertx.proton.streams.ProtonSubscriber) Handler(io.vertx.core.Handler) Accepted(org.apache.qpid.proton.amqp.messaging.Accepted) Tracker(io.vertx.proton.streams.Tracker) ProtonServer(io.vertx.proton.ProtonServer) ProtonClient(io.vertx.proton.ProtonClient) ProtonConnection(io.vertx.proton.ProtonConnection) Async(io.vertx.ext.unit.Async) Test(org.junit.Test)

Example 3 with ProtonServer

use of io.vertx.proton.ProtonServer 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();
        }
    }
}
Also used : TestContext(io.vertx.ext.unit.TestContext) ProtonConnection(io.vertx.proton.ProtonConnection) Async(io.vertx.ext.unit.Async) Arrays(java.util.Arrays) ProtonStreams(io.vertx.proton.streams.ProtonStreams) LoggerFactory(io.vertx.core.impl.logging.LoggerFactory) Rejected(org.apache.qpid.proton.amqp.messaging.Rejected) RunWith(org.junit.runner.RunWith) ProtonServer(io.vertx.proton.ProtonServer) MockServerTestBase(io.vertx.proton.MockServerTestBase) Flowable(io.reactivex.Flowable) ProtonHelper.message(io.vertx.proton.ProtonHelper.message) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) Symbol(org.apache.qpid.proton.amqp.Symbol) AmqpValue(org.apache.qpid.proton.amqp.messaging.AmqpValue) Modified(org.apache.qpid.proton.amqp.messaging.Modified) Message(org.apache.qpid.proton.message.Message) AsyncResult(io.vertx.core.AsyncResult) Logger(io.vertx.core.impl.logging.Logger) Tracker(io.vertx.proton.streams.Tracker) Publisher(org.reactivestreams.Publisher) Test(org.junit.Test) ProtonClient(io.vertx.proton.ProtonClient) VertxUnitRunner(io.vertx.ext.unit.junit.VertxUnitRunner) Released(org.apache.qpid.proton.amqp.messaging.Released) ExecutionException(java.util.concurrent.ExecutionException) Section(org.apache.qpid.proton.amqp.messaging.Section) FutureHandler(io.vertx.proton.FutureHandler) ProtonSubscriber(io.vertx.proton.streams.ProtonSubscriber) Handler(io.vertx.core.Handler) Accepted(org.apache.qpid.proton.amqp.messaging.Accepted) ProtonConnection(io.vertx.proton.ProtonConnection) Tracker(io.vertx.proton.streams.Tracker) ProtonServer(io.vertx.proton.ProtonServer) Async(io.vertx.ext.unit.Async) ProtonClient(io.vertx.proton.ProtonClient) Test(org.junit.Test)

Example 4 with ProtonServer

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

the class ProtonSubscriberIntTest method createServer.

private ProtonServer createServer(Handler<ProtonConnection> serverConnHandler) throws InterruptedException, ExecutionException {
    ProtonServer server = ProtonServer.create(vertx);
    server.connectHandler(serverConnHandler);
    FutureHandler<ProtonServer, AsyncResult<ProtonServer>> handler = FutureHandler.asyncResult();
    server.listen(0, handler);
    handler.get();
    return server;
}
Also used : ProtonServer(io.vertx.proton.ProtonServer) AsyncResult(io.vertx.core.AsyncResult)

Example 5 with ProtonServer

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

the class HelloWorldServer method main.

public static void main(String[] args) {
    // Create the Vert.x instance
    Vertx vertx = Vertx.vertx();
    // Create the Vert.x AMQP client instance
    ProtonServer server = ProtonServer.create(vertx).connectHandler((connection) -> {
        helloProcessConnection(vertx, connection);
    }).listen(5672, (res) -> {
        if (res.succeeded()) {
            System.out.println("Listening on: " + res.result().actualPort());
        } else {
            res.cause().printStackTrace();
        }
    });
    // Just stop main() from exiting
    try {
        System.in.read();
    } catch (Exception ignore) {
    }
}
Also used : ProtonConnection(io.vertx.proton.ProtonConnection) Section(org.apache.qpid.proton.amqp.messaging.Section) AmqpValue(org.apache.qpid.proton.amqp.messaging.AmqpValue) ProtonHelper.message(io.vertx.proton.ProtonHelper.message) Vertx(io.vertx.core.Vertx) Message(org.apache.qpid.proton.message.Message) ProtonServer(io.vertx.proton.ProtonServer) ProtonServer(io.vertx.proton.ProtonServer) Vertx(io.vertx.core.Vertx)

Aggregations

ProtonServer (io.vertx.proton.ProtonServer)22 AsyncResult (io.vertx.core.AsyncResult)21 ProtonConnection (io.vertx.proton.ProtonConnection)19 ProtonHelper.message (io.vertx.proton.ProtonHelper.message)19 AmqpValue (org.apache.qpid.proton.amqp.messaging.AmqpValue)19 Section (org.apache.qpid.proton.amqp.messaging.Section)19 Message (org.apache.qpid.proton.message.Message)19 Handler (io.vertx.core.Handler)18 Logger (io.vertx.core.impl.logging.Logger)18 LoggerFactory (io.vertx.core.impl.logging.LoggerFactory)18 Async (io.vertx.ext.unit.Async)18 TestContext (io.vertx.ext.unit.TestContext)18 VertxUnitRunner (io.vertx.ext.unit.junit.VertxUnitRunner)18 FutureHandler (io.vertx.proton.FutureHandler)18 MockServerTestBase (io.vertx.proton.MockServerTestBase)18 ProtonClient (io.vertx.proton.ProtonClient)18 ProtonStreams (io.vertx.proton.streams.ProtonStreams)18 Arrays (java.util.Arrays)18 ExecutionException (java.util.concurrent.ExecutionException)18 AtomicInteger (java.util.concurrent.atomic.AtomicInteger)18