Java Examples for io.vertx.core.eventbus.Message

@Test
public void testSend() throws Exception {
    VertxConnection vc = connectionFactory.getVertxConnection();
    VertxEventBus eventBus = vc.vertxEventBus();
    VertxPlatformConfiguration config = new VertxPlatformConfiguration();
    config.setClusterHost("localhost");
    config.setClusterPort(0);
    config.setClustered(true);
    VertxPlatformFactory.instance().getOrCreateVertx(config, this);
    CountDownLatch latch = new CountDownLatch(1);
    vertx.deployVerticle(OutboundTestVerticle.class.getName(),  ar -> {
        if (ar.succeeded()) {
            latch.countDown();
        }
    });
    Assert.assertTrue("Verticle was not deployed", latch.await(5, TimeUnit.SECONDS));
    CountDownLatch consumerLatch = new CountDownLatch(1);
    vertx.eventBus().<String>consumer(INBOUND_ADDRESS).handler((Message<String> msg) -> {
        consumerLatch.countDown();
    });
    eventBus.send(OUTBOUND_ADDRESS, "JCA");
    consumerLatch.await();
    vc.close();
}

@Override
public void run() {
    SlideshowFXServer.this.vertx.eventBus().send(service, data, (AsyncResult<Message<JsonObject>> ar) -> {
        response.setValue(ar.result().body());
        continueProcess = true;
    });
    while (!continueProcess) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            LOGGER.log(Level.SEVERE, "Can not wait result when calling a service", e);
        }
    }
}

private void listAlbums(Message<JsonObject> msg) {
    // issue a find command to mongo to fetch all documents from the "albums" collection.
    mongo.find("albums", new JsonObject(),  lookup -> {
        if (lookup.failed()) {
            msg.fail(500, lookup.cause().getMessage());
            return;
        }
        final JsonArray json = new JsonArray();
        for (JsonObject o : lookup.result()) {
            json.add(o);
        }
        msg.reply(json);
    });
}

// ------------\ AmqpService -----------------
// -- Handler method for receiving messages from the event-bus -----------
@Override
public void handle(Message<JsonObject> vertxMsg) {
    try {
        LOG.debug(format("Received msg from Vert.x event bus : {address : %s, reply-to : %s, body : %s} ", vertxMsg.address(), vertxMsg.replyAddress(), vertxMsg.body() == null ? "" : vertxMsg.body().encodePrettily()));
        org.apache.qpid.proton.message.Message outMsg = _msgTranslator.convert(vertxMsg.body());
        JsonObject inMsg = vertxMsg.body();
        if (outMsg.getReplyTo() == null && vertxMsg.replyAddress() != null) {
            outMsg.setReplyTo(_replyToAddressPrefix + "/" + vertxMsg.replyAddress());
            _vertxReplyTo.put(vertxMsg.replyAddress(), vertxMsg);
        }
        // First attempt link routing (covers links created via Service API)
        String linkId = _linkBasedRouter.routeOutgoing(vertxMsg.address());
        if (linkId != null) {
            try {
                _linkManager.sendViaLink(linkId, outMsg, inMsg);
                LogMsgHelper.logVertxMsgForLinkBasedRouting(LOG, vertxMsg, linkId);
            } catch (MessagingException e) {
                LOG.warn(e, "Error {code=%s, msg='%s'} sending to link %s", e.getErrorCode(), e.getMessage(), linkId);
            }
        } else {
            // Message based routing (routes added through static or dynamic
            // config)
            List<String> amqpAddressList = _msgBasedRouter.routeOutgoing(vertxMsg);
            for (String amqpAddress : amqpAddressList) {
                try {
                    _linkManager.sendViaAddress(amqpAddress, outMsg, inMsg);
                } catch (MessagingException e) {
                    LOG.warn(e, "Error {code=%s, msg='%s'} sending to AMQP address %s", e.getErrorCode(), e.getMessage(), amqpAddress);
                }
            }
            LogMsgHelper.logVertxMsgForMsgBasedRouting(LOG, vertxMsg, amqpAddressList);
        }
    } catch (MessagingException e) {
        LOG.warn(e, "Error {code=%s, msg='%s'} routing outbound", e.getErrorCode(), e.getMessage());
    }
}

@Test
public void testInvalidAction(TestContext context) throws Exception {
    JsonObject metric = new JsonObject();
    Async async = context.async();
    eb.send(topic, metric, new Handler<AsyncResult<Message<JsonObject>>>() {

        @Override
        public void handle(AsyncResult<Message<JsonObject>> result) {
            context.assertTrue(result.failed());
            context.assertTrue(result.cause() instanceof ReplyException);
            context.assertEquals(result.cause().getMessage(), "You must specify an action");
            async.complete();
        }
    });
    Async async1 = context.async();
    metric = new JsonObject().put("action", "badCommand");
    eb.send(topic, metric, new Handler<AsyncResult<Message<JsonObject>>>() {

        @Override
        public void handle(AsyncResult<Message<JsonObject>> result) {
            context.assertTrue(result.failed());
            context.assertTrue(result.cause() instanceof ReplyException);
            context.assertEquals(result.cause().getMessage(), "Invalid action: badCommand specified.");
            async1.complete();
        }
    });
}

@Test
public //public void testPing(TestContext context) {
void testPing() {
    TestContext context = null;
    System.out.printf("in testPing()%n");
    logger.info("in testPing()");
    EventBus eb = vertx.eventBus();
    eb.publish("ping-address", "ping!");
    eb.consumer("ping-address", (Message<JsonObject> reply) -> {
        context.assertEquals("pong! 12", reply.body());
        /*
          If we get here, the test is complete
          You must always call `testComplete()` at the end. Remember that testing is *asynchronous* so
          we cannot assume the test is complete by the time the test method has finished executing like
          in standard synchronous tests
          */
        testComplete();
    });
}

@Override
public void handle(final Message<JsonObject> message) {
    final JsonObject json = new JsonObject();
    String sessionID = message.body().getString("sessionID");
    if (sessionID == null) {
        json.put("status", "denied");
        message.reply(json);
        return;
    }
    sessionStore.get(sessionID, new Handler<JsonObject>() {

        @Override
        public void handle(JsonObject session) {
            if (session == null) {
                json.put("status", "denied");
                message.reply(json);
                return;
            }
            json.put("status", "ok");
            json.put("username", session.getString("username"));
            message.reply(json);
        }
    });
}

@SuppressWarnings("nls")
default void listenProxyHandler() {
    System.out.println("Setting up a listener on " + address());
    vertx().eventBus().consumer(address(), (Message<JsonObject> message) -> {
        String uuid = message.body().getString("uuid");
        System.out.println("UUID == " + uuid + " vs " + uuid());
        if (shouldIgnore(uuid))
            return;
        String type = message.body().getString("type");
        String action = message.body().getString("action");
        String body = message.body().getString("body");
        switch(type) {
            case "client":
                Client app = Json.decodeValue(body, Client.class);
                if (action == "register") {
                    registerClient(app);
                } else if (action == "unregister") {
                    unregisterClient(app);
                }
                break;
            case "api":
                Api api = Json.decodeValue(body, Api.class);
                if (action == "publish") {
                    //$NON-NLS-1$
                    publishApi(api);
                } else if (action == "retire") {
                    retireApi(api);
                }
                break;
            default:
                throw new IllegalStateException("Unknown type: " + type);
        }
    });
}

@Override
public void handle(AsyncResult<Message<Object>> event) {
    try {
        // preserve headers
        MessageHelper.copyHeaders(exchange.getIn(), exchange.getOut(), false);
        Throwable e = event.cause();
        if (e != null) {
            exchange.setException(e);
        } else {
            exchange.getOut().setBody(event.result().body());
        }
    } finally {
        callback.done(false);
    }
}

void pausingServer(Handler<AsyncResult<NetServer>> listenHandler) {
    server.connectHandler( sock -> {
        sock.pause();
        Handler<Message<Buffer>> resumeHandler = ( m) -> sock.resume();
        MessageConsumer reg = vertx.eventBus().<Buffer>consumer("server_resume").handler(resumeHandler);
        sock.closeHandler( v -> reg.unregister());
    }).listen(listenHandler);
}

@Override
public void start(final Future<Void> startedResult) {
    try {
        producerConfig = config();
        Properties properties = populateKafkaConfig();
        busAddress = producerConfig.getString(ConfigConstants.EVENTBUS_ADDRESS, EVENTBUS_DEFAULT_ADDRESS);
        defaultTopic = producerConfig.getString(ConfigConstants.DEFAULT_TOPIC);
        sender = Executors.newSingleThreadExecutor();
        producer = new KafkaProducer(properties);
        vertx.eventBus().consumer(busAddress, (Message<JsonObject> message) -> sendMessage(message));
        Runtime.getRuntime().addShutdownHook(new Thread() {

            // try to disconnect from ZK as gracefully as possible
            public void run() {
                shutdown();
            }
        });
        startedResult.complete();
    } catch (Exception ex) {
        logger.error("Message producer initialization failed with ex: {}", ex);
        startedResult.fail(ex);
    }
}

private <T> String assertBusSend(TestContext context, String cmd, Handler<Message<T>> handler) {
    Async terminatedLatch = context.async();
    vertx.eventBus().consumer("the_address", handler);
    Shell shell = server.createShell();
    Pty pty = Pty.create();
    StringBuffer result = new StringBuffer();
    pty.stdoutHandler(result::append);
    Job job = shell.createJob(cmd).setTty(pty.slave());
    job.statusUpdateHandler( status -> {
        if (status == ExecStatus.TERMINATED) {
            terminatedLatch.complete();
        }
    });
    job.run();
    terminatedLatch.awaitSuccess(5000);
    return result.toString();
}

@org.junit.Test
public void testEventBusReport() throws Exception {
    long now = System.currentTimeMillis();
    String address = TestUtils.randomAlphaString(10);
    String testSuiteName = TestUtils.randomAlphaString(10);
    String testCaseName1 = TestUtils.randomAlphaString(10);
    String testCaseName2 = TestUtils.randomAlphaString(10);
    String testCaseName3 = TestUtils.randomAlphaString(10);
    MessageConsumer<JsonObject> consumer = vertx.eventBus().localConsumer(address);
    Handler<Message<JsonObject>> messageHandler = EventBusCollector.create(vertx,  testSuite -> {
        Map<TestCaseReport, TestResult> results = new LinkedHashMap<>();
        testSuite.handler( testCase -> {
            testCase.endHandler( result -> {
                results.put(testCase, result);
            });
        });
        testSuite.endHandler( done -> {
            assertEquals(testSuiteName, testSuite.name());
            assertEquals(3, results.size());
            Iterator<Map.Entry<TestCaseReport, TestResult>> it = results.entrySet().iterator();
            Map.Entry<TestCaseReport, TestResult> entry1 = it.next();
            assertEquals(entry1.getKey().name(), entry1.getValue().name());
            assertEquals(testCaseName1, entry1.getValue().name());
            assertTrue(entry1.getValue().succeeded());
            assertTrue(entry1.getValue().beginTime() >= now);
            assertEquals(10, entry1.getValue().durationTime());
            assertNull(entry1.getValue().failure());
            Map.Entry<TestCaseReport, TestResult> entry2 = it.next();
            assertEquals(entry2.getKey().name(), entry2.getValue().name());
            assertEquals(testCaseName2, entry2.getValue().name());
            assertFalse(entry2.getValue().succeeded());
            assertTrue(entry2.getValue().beginTime() >= now);
            assertEquals(5, entry2.getValue().durationTime());
            assertNotNull(entry2.getValue().failure());
            assertEquals(false, entry2.getValue().failure().isError());
            assertEquals("the_failure_message", entry2.getValue().failure().message());
            assertEquals("the_failure_stackTrace", entry2.getValue().failure().stackTrace());
            assertTrue(entry2.getValue().failure().cause() instanceof IOException);
            Map.Entry<TestCaseReport, TestResult> entry3 = it.next();
            assertEquals(entry3.getKey().name(), entry3.getValue().name());
            assertEquals(testCaseName3, entry3.getValue().name());
            assertFalse(entry3.getValue().succeeded());
            assertTrue(entry3.getValue().beginTime() >= now);
            assertEquals(7, entry3.getValue().durationTime());
            assertNotNull(entry3.getValue().failure());
            assertEquals(false, entry3.getValue().failure().isError());
            assertEquals(null, entry3.getValue().failure().message());
            assertEquals("the_failure_stackTrace", entry3.getValue().failure().stackTrace());
            assertTrue(entry3.getValue().failure().cause() instanceof IOException);
            consumer.unregister();
            testComplete();
        });
    }).asMessageHandler();
    consumer.completionHandler( ar -> {
        assertTrue(ar.succeeded());
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_SUITE_BEGIN).put("name", testSuiteName));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_BEGIN).put("name", testCaseName1));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_END).put("name", testCaseName1).put("beginTime", System.currentTimeMillis()).put("durationTime", 10L));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_BEGIN).put("name", testCaseName2));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_END).put("name", testCaseName2).put("beginTime", System.currentTimeMillis()).put("durationTime", 5L).put("failure", new FailureImpl(false, "the_failure_message", "the_failure_stackTrace", new IOException()).toJson()));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_BEGIN).put("name", testCaseName3));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_CASE_END).put("name", testCaseName3).put("beginTime", System.currentTimeMillis()).put("durationTime", 7L).put("failure", new FailureImpl(false, null, "the_failure_stackTrace", new IOException()).toJson()));
        vertx.eventBus().publish(address, new JsonObject().put("type", EventBusCollector.EVENT_TEST_SUITE_END));
    });
    consumer.handler(messageHandler);
    await();
}

private void createConsumer(Object service, Consumer consumes, Method method) {
    Class<?>[] parameterTypes = method.getParameterTypes();
    if (parameterTypes.length != 1 || !parameterTypes[0].equals(Message.class)) {
        String msg = "Cannot register consumer on method : " + getFullName(service, method);
        msg += " .Method should only declare one parameter of io.vertx.core.eventbus.Message type.";
        throw new VertxException(msg);
    }
    vertx.eventBus().consumer(consumes.value(),  message -> {
        try {
            method.invoke(service, message);
        } catch (Exception e) {
            LOG.error("Exception happened during message handling on method : " + getFullName(service, method), e);
        }
    });
}

private void handleIncomingMessage(final String address, final Message<String> message) {
    try {
        logger.debug(message.body());
        final String method = message.headers().get("method");
        final String body = message.body();
        final List<String> errors = new ArrayList<>();
        final MethodCall<Object> transform = standardRequestTransformer.transFormBridgeBody(body, errors, address, method);
        if (errors.size() > 0) {
            logger.error("Error marshaling message body to method call to service errors {}", errors);
            message.fail(500, errors.toString());
            return;
        }
        final CallbackBuilder callbackBuilder = CallbackBuilder.callbackBuilder();
        callbackBuilder.setOnError( throwable -> {
            logger.error("Error from calling " + address, throwable);
            message.fail(500, throwable.getMessage());
        });
        callbackBuilder.setCallback( returnedValue -> message.reply(encodeOutput(returnedValue)));
        callbackBuilder.setOnTimeout(() -> {
            logger.error("Timed out call to " + address + " method " + method);
            message.fail(408, "Timed out call to " + address + " method " + method);
        });
        final MethodCall<Object> methodCall = MethodCallBuilder.methodCallBuilder().setAddress(address).setBody(transform.body()).setTimestamp(this.timer.time()).setName(method).setId(messageId++).setCallback(callbackBuilder.build()).build();
        if (logger.isDebugEnabled()) {
            logger.debug("Calling method {} {}", methodCall.name(), message.body());
        }
        if (methodCallPredicate.test(methodCall)) {
            this.methodCallSendQueue.send(methodCall);
        }
    } catch (IndexOutOfBoundsExceptionJsonException |  ix) {
        logger.error("Error marshaling message body to method call to service", ix);
        message.fail(500, "IllegalArgumentException");
    } catch (Exception ex) {
        logger.error("Error marshaling message body to method call to service", ex);
        message.fail(500, ex.getClass().getSimpleName() + ": " + ex.getMessage());
    }
}

@Test
public void testInvalidAction(TestContext context) throws Exception {
    JsonObject metric = new JsonObject();
    Async async = context.async();
    eb.send(topic, metric, new Handler<AsyncResult<Message<JsonObject>>>() {

        @Override
        public void handle(AsyncResult<Message<JsonObject>> result) {
            context.assertTrue(result.failed());
            context.assertTrue(result.cause() instanceof ReplyException);
            context.assertEquals(result.cause().getMessage(), "You must specify an action");
            async.complete();
        }
    });
    Async async1 = context.async();
    metric = new JsonObject().put("action", "badCommand");
    eb.send(topic, metric, new Handler<AsyncResult<Message<JsonObject>>>() {

        @Override
        public void handle(AsyncResult<Message<JsonObject>> result) {
            context.assertTrue(result.failed());
            context.assertTrue(result.cause() instanceof ReplyException);
            context.assertEquals(result.cause().getMessage(), "Invalid action: badCommand specified.");
            async1.complete();
        }
    });
}

@Test
public void testPubSub() {
    final String message = makeKey();
    // register a handler for the incoming message
    vertx.eventBus().consumer("io.vertx.redis.ch1", (Message<JsonObject> msg) -> {
        JsonObject value = msg.body().getJsonObject("value");
        assertEquals("ch1", value.getString("channel"));
        assertEquals(message, value.getString("message"));
        testComplete();
    });
    // on sub address subscribe to channel ch1
    redis.subscribe("ch1",  subscribe -> {
        assertTrue(subscribe.succeeded());
        assertEquals("subscribe", subscribe.result().getValue(0));
        assertEquals("ch1", subscribe.result().getValue(1));
        assertEquals(1l, subscribe.result().getValue(2));
        redis.publish("ch1", message,  res -> {
            assertTrue(res.succeeded());
            assertEquals(Long.valueOf(1l), res.result());
        });
    });
    await();
}

/**
     * Handles starting the server listening on all interfaces
     *
     * @return a callback to hit when ready for the server to open up listening
     */
private Handler<Message<Object>> getStartupHandler() {
    return  message -> {
        server = vertx.createHttpServer();
        Router router = Router.router(vertx);
        buildApi(router);
        setupSockJSServer(router);
        server.requestHandler(router::accept);
        server.listen(svrConfig.port, "0.0.0.0",  event -> {
            if (event.failed()) {
                logger.error("Failed to start server, error:", event.cause());
                stop();
            } else {
                logger.info("Thread: {} starting to handle request", Thread.currentThread().getId());
            }
        });
    };
}

/**
     * Handles posting to the index endpoint
     *
     * @param message the message to send
     */
private void doIndex(Message<JsonObject> message) {
    OpenTsDbMetric metric = getMetricFromMessage(message);
    if (metric == null) {
        return;
    }
    // ignore it we've seen it lately
    String key = metric.getDistinctKey();
    if (distinctMetrics.getIfPresent(key) != null) {
        message.reply(new JsonObject().put(RESULT_FIELD, BosunResponse.EXISTS_MSG));
        return;
    }
    // cache it
    distinctMetrics.put(key, true);
    metricsIndexed.incrementAndGet();
    sendData(INDEX_API, metric.asJson().encode(), message);
}

public void handle(Message<JsonObject> msg) {
    try {
        JsonObject json = msg.body();
        String action = msg.headers().get("action");
        if (action == null) {
            throw new IllegalStateException("action not specified");
        }
        accessed();
        switch(action) {
            case "longDeliverySuccess":
                {
                    service.longDeliverySuccess(createHandler(msg));
                    break;
                }
            case "longDeliveryFailed":
                {
                    service.longDeliveryFailed(createHandler(msg));
                    break;
                }
            case "createConnection":
                {
                    service.createConnection((java.lang.String) json.getValue("str"),  res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            String proxyAddress = UUID.randomUUID().toString();
                            ProxyHelper.registerService(TestConnection.class, vertx, res.result(), proxyAddress, false, timeoutSeconds);
                            msg.reply(null, new DeliveryOptions().addHeader("proxyaddr", proxyAddress));
                        }
                    });
                    break;
                }
            case "createConnectionWithCloseFuture":
                {
                    service.createConnectionWithCloseFuture( res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            String proxyAddress = UUID.randomUUID().toString();
                            ProxyHelper.registerService(TestConnectionWithCloseFuture.class, vertx, res.result(), proxyAddress, false, timeoutSeconds);
                            msg.reply(null, new DeliveryOptions().addHeader("proxyaddr", proxyAddress));
                        }
                    });
                    break;
                }
            case "noParams":
                {
                    service.noParams();
                    break;
                }
            case "basicTypes":
                {
                    service.basicTypes((java.lang.String) json.getValue("str"), json.getValue("b") == null ? null : (json.getLong("b").byteValue()), json.getValue("s") == null ? null : (json.getLong("s").shortValue()), json.getValue("i") == null ? null : (json.getLong("i").intValue()), json.getValue("l") == null ? null : (json.getLong("l").longValue()), json.getValue("f") == null ? null : (json.getDouble("f").floatValue()), json.getValue("d") == null ? null : (json.getDouble("d").doubleValue()), json.getInteger("c") == null ? null : (char) (int) (json.getInteger("c")), (boolean) json.getValue("bool"));
                    break;
                }
            case "basicBoxedTypes":
                {
                    service.basicBoxedTypes((java.lang.String) json.getValue("str"), json.getValue("b") == null ? null : (json.getLong("b").byteValue()), json.getValue("s") == null ? null : (json.getLong("s").shortValue()), json.getValue("i") == null ? null : (json.getLong("i").intValue()), json.getValue("l") == null ? null : (json.getLong("l").longValue()), json.getValue("f") == null ? null : (json.getDouble("f").floatValue()), json.getValue("d") == null ? null : (json.getDouble("d").doubleValue()), json.getInteger("c") == null ? null : (char) (int) (json.getInteger("c")), (java.lang.Boolean) json.getValue("bool"));
                    break;
                }
            case "basicBoxedTypesNull":
                {
                    service.basicBoxedTypesNull((java.lang.String) json.getValue("str"), json.getValue("b") == null ? null : (json.getLong("b").byteValue()), json.getValue("s") == null ? null : (json.getLong("s").shortValue()), json.getValue("i") == null ? null : (json.getLong("i").intValue()), json.getValue("l") == null ? null : (json.getLong("l").longValue()), json.getValue("f") == null ? null : (json.getDouble("f").floatValue()), json.getValue("d") == null ? null : (json.getDouble("d").doubleValue()), json.getInteger("c") == null ? null : (char) (int) (json.getInteger("c")), (java.lang.Boolean) json.getValue("bool"));
                    break;
                }
            case "jsonTypes":
                {
                    service.jsonTypes((io.vertx.core.json.JsonObject) json.getValue("jsonObject"), (io.vertx.core.json.JsonArray) json.getValue("jsonArray"));
                    break;
                }
            case "jsonTypesNull":
                {
                    service.jsonTypesNull((io.vertx.core.json.JsonObject) json.getValue("jsonObject"), (io.vertx.core.json.JsonArray) json.getValue("jsonArray"));
                    break;
                }
            case "enumType":
                {
                    service.enumType(json.getString("someEnum") == null ? null : io.vertx.serviceproxy.testmodel.SomeEnum.valueOf(json.getString("someEnum")));
                    break;
                }
            case "enumTypeNull":
                {
                    service.enumTypeNull(json.getString("someEnum") == null ? null : io.vertx.serviceproxy.testmodel.SomeEnum.valueOf(json.getString("someEnum")));
                    break;
                }
            case "enumTypeAsResult":
                {
                    service.enumTypeAsResult(createHandler(msg));
                    break;
                }
            case "enumTypeAsResultNull":
                {
                    service.enumTypeAsResultNull(createHandler(msg));
                    break;
                }
            case "dataObjectType":
                {
                    service.dataObjectType(json.getJsonObject("options") == null ? null : new io.vertx.serviceproxy.testmodel.TestDataObject(json.getJsonObject("options")));
                    break;
                }
            case "dataObjectTypeNull":
                {
                    service.dataObjectTypeNull(json.getJsonObject("options") == null ? null : new io.vertx.serviceproxy.testmodel.TestDataObject(json.getJsonObject("options")));
                    break;
                }
            case "listParams":
                {
                    service.listParams(convertList(json.getJsonArray("listString").getList()), json.getJsonArray("listByte").stream().map( o -> ((Number) o).byteValue()).collect(Collectors.toList()), json.getJsonArray("listShort").stream().map( o -> ((Number) o).shortValue()).collect(Collectors.toList()), json.getJsonArray("listInt").stream().map( o -> ((Number) o).intValue()).collect(Collectors.toList()), json.getJsonArray("listLong").stream().map( o -> ((Number) o).longValue()).collect(Collectors.toList()), convertList(json.getJsonArray("listJsonObject").getList()), convertList(json.getJsonArray("listJsonArray").getList()), json.getJsonArray("listDataObject").stream().map( o -> new TestDataObject((JsonObject) o)).collect(Collectors.toList()));
                    break;
                }
            case "setParams":
                {
                    service.setParams(convertSet(json.getJsonArray("setString").getList()), json.getJsonArray("setByte").stream().map( o -> ((Number) o).byteValue()).collect(Collectors.toSet()), json.getJsonArray("setShort").stream().map( o -> ((Number) o).shortValue()).collect(Collectors.toSet()), json.getJsonArray("setInt").stream().map( o -> ((Number) o).intValue()).collect(Collectors.toSet()), json.getJsonArray("setLong").stream().map( o -> ((Number) o).longValue()).collect(Collectors.toSet()), convertSet(json.getJsonArray("setJsonObject").getList()), convertSet(json.getJsonArray("setJsonArray").getList()), json.getJsonArray("setDataObject").stream().map( o -> new TestDataObject((JsonObject) o)).collect(Collectors.toSet()));
                    break;
                }
            case "mapParams":
                {
                    service.mapParams(convertMap(json.getJsonObject("mapString").getMap()), json.getJsonObject("mapByte").getMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,  entry -> ((java.lang.Number) entry.getValue()).byteValue())), json.getJsonObject("mapShort").getMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,  entry -> ((java.lang.Number) entry.getValue()).shortValue())), json.getJsonObject("mapInt").getMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,  entry -> ((java.lang.Number) entry.getValue()).intValue())), json.getJsonObject("mapLong").getMap().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,  entry -> ((java.lang.Number) entry.getValue()).longValue())), convertMap(json.getJsonObject("mapJsonObject").getMap()), convertMap(json.getJsonObject("mapJsonArray").getMap()));
                    break;
                }
            case "stringHandler":
                {
                    service.stringHandler(createHandler(msg));
                    break;
                }
            case "stringNullHandler":
                {
                    service.stringNullHandler(createHandler(msg));
                    break;
                }
            case "byteHandler":
                {
                    service.byteHandler(createHandler(msg));
                    break;
                }
            case "byteNullHandler":
                {
                    service.byteNullHandler(createHandler(msg));
                    break;
                }
            case "shortHandler":
                {
                    service.shortHandler(createHandler(msg));
                    break;
                }
            case "shortNullHandler":
                {
                    service.shortNullHandler(createHandler(msg));
                    break;
                }
            case "intHandler":
                {
                    service.intHandler(createHandler(msg));
                    break;
                }
            case "intNullHandler":
                {
                    service.intNullHandler(createHandler(msg));
                    break;
                }
            case "longHandler":
                {
                    service.longHandler(createHandler(msg));
                    break;
                }
            case "longNullHandler":
                {
                    service.longNullHandler(createHandler(msg));
                    break;
                }
            case "floatHandler":
                {
                    service.floatHandler(createHandler(msg));
                    break;
                }
            case "floatNullHandler":
                {
                    service.floatNullHandler(createHandler(msg));
                    break;
                }
            case "doubleHandler":
                {
                    service.doubleHandler(createHandler(msg));
                    break;
                }
            case "doubleNullHandler":
                {
                    service.doubleNullHandler(createHandler(msg));
                    break;
                }
            case "charHandler":
                {
                    service.charHandler(createHandler(msg));
                    break;
                }
            case "charNullHandler":
                {
                    service.charNullHandler(createHandler(msg));
                    break;
                }
            case "booleanHandler":
                {
                    service.booleanHandler(createHandler(msg));
                    break;
                }
            case "booleanNullHandler":
                {
                    service.booleanNullHandler(createHandler(msg));
                    break;
                }
            case "jsonObjectHandler":
                {
                    service.jsonObjectHandler(createHandler(msg));
                    break;
                }
            case "jsonObjectNullHandler":
                {
                    service.jsonObjectNullHandler(createHandler(msg));
                    break;
                }
            case "jsonArrayHandler":
                {
                    service.jsonArrayHandler(createHandler(msg));
                    break;
                }
            case "jsonArrayNullHandler":
                {
                    service.jsonArrayNullHandler(createHandler(msg));
                    break;
                }
            case "dataObjectHandler":
                {
                    service.dataObjectHandler( res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            msg.reply(res.result() == null ? null : res.result().toJson());
                        }
                    });
                    break;
                }
            case "dataObjectNullHandler":
                {
                    service.dataObjectNullHandler( res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            msg.reply(res.result() == null ? null : res.result().toJson());
                        }
                    });
                    break;
                }
            case "voidHandler":
                {
                    service.voidHandler(createHandler(msg));
                    break;
                }
            case "fluentMethod":
                {
                    service.fluentMethod((java.lang.String) json.getValue("str"), createHandler(msg));
                    break;
                }
            case "fluentNoParams":
                {
                    service.fluentNoParams();
                    break;
                }
            case "failingMethod":
                {
                    service.failingMethod(createHandler(msg));
                    break;
                }
            case "invokeWithMessage":
                {
                    service.invokeWithMessage((io.vertx.core.json.JsonObject) json.getValue("object"), (java.lang.String) json.getValue("str"), json.getValue("i") == null ? null : (json.getLong("i").intValue()), json.getInteger("chr") == null ? null : (char) (int) (json.getInteger("chr")), json.getString("senum") == null ? null : io.vertx.serviceproxy.testmodel.SomeEnum.valueOf(json.getString("senum")), createHandler(msg));
                    break;
                }
            case "listStringHandler":
                {
                    service.listStringHandler(createListHandler(msg));
                    break;
                }
            case "listByteHandler":
                {
                    service.listByteHandler(createListHandler(msg));
                    break;
                }
            case "listShortHandler":
                {
                    service.listShortHandler(createListHandler(msg));
                    break;
                }
            case "listIntHandler":
                {
                    service.listIntHandler(createListHandler(msg));
                    break;
                }
            case "listLongHandler":
                {
                    service.listLongHandler(createListHandler(msg));
                    break;
                }
            case "listFloatHandler":
                {
                    service.listFloatHandler(createListHandler(msg));
                    break;
                }
            case "listDoubleHandler":
                {
                    service.listDoubleHandler(createListHandler(msg));
                    break;
                }
            case "listCharHandler":
                {
                    service.listCharHandler(createListCharHandler(msg));
                    break;
                }
            case "listBoolHandler":
                {
                    service.listBoolHandler(createListHandler(msg));
                    break;
                }
            case "listJsonObjectHandler":
                {
                    service.listJsonObjectHandler(createListHandler(msg));
                    break;
                }
            case "listJsonArrayHandler":
                {
                    service.listJsonArrayHandler(createListHandler(msg));
                    break;
                }
            case "listDataObjectHandler":
                {
                    service.listDataObjectHandler( res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            msg.reply(new JsonArray(res.result().stream().map(TestDataObject::toJson).collect(Collectors.toList())));
                        }
                    });
                    break;
                }
            case "setStringHandler":
                {
                    service.setStringHandler(createSetHandler(msg));
                    break;
                }
            case "setByteHandler":
                {
                    service.setByteHandler(createSetHandler(msg));
                    break;
                }
            case "setShortHandler":
                {
                    service.setShortHandler(createSetHandler(msg));
                    break;
                }
            case "setIntHandler":
                {
                    service.setIntHandler(createSetHandler(msg));
                    break;
                }
            case "setLongHandler":
                {
                    service.setLongHandler(createSetHandler(msg));
                    break;
                }
            case "setFloatHandler":
                {
                    service.setFloatHandler(createSetHandler(msg));
                    break;
                }
            case "setDoubleHandler":
                {
                    service.setDoubleHandler(createSetHandler(msg));
                    break;
                }
            case "setCharHandler":
                {
                    service.setCharHandler(createSetCharHandler(msg));
                    break;
                }
            case "setBoolHandler":
                {
                    service.setBoolHandler(createSetHandler(msg));
                    break;
                }
            case "setJsonObjectHandler":
                {
                    service.setJsonObjectHandler(createSetHandler(msg));
                    break;
                }
            case "setJsonArrayHandler":
                {
                    service.setJsonArrayHandler(createSetHandler(msg));
                    break;
                }
            case "setDataObjectHandler":
                {
                    service.setDataObjectHandler( res -> {
                        if (res.failed()) {
                            if (res.cause() instanceof ServiceException) {
                                msg.reply(res.cause());
                            } else {
                                msg.reply(new ServiceException(-1, res.cause().getMessage()));
                            }
                        } else {
                            msg.reply(new JsonArray(res.result().stream().map(TestDataObject::toJson).collect(Collectors.toList())));
                        }
                    });
                    break;
                }
            case "failingCall":
                {
                    service.failingCall((java.lang.String) json.getValue("value"), createHandler(msg));
                    break;
                }
            case "ignoredMethod":
                {
                    service.ignoredMethod();
                    break;
                }
            default:
                {
                    throw new IllegalStateException("Invalid action: " + action);
                }
        }
    } catch (Throwable t) {
        msg.reply(new ServiceException(500, t.getMessage()));
        throw t;
    }
}

@Override
public <R> void reply(Object message, DeliveryOptions deliveryOptions, Handler<AsyncResult<Message<R>>> replyHandler) {
    if (this.replyAddress != null) {
        EventBusBridge.this.send(replyAddress, message.toString(), ( result,  eb) -> {
            if (replyHandler != null) {
                replyHandler.handle(new AsyncResult<Message<R>>() {

                    @Override
                    public Message<R> result() {
                        return new EventBusMessage(result);
                    }

                    @Override
                    public Throwable cause() {
                        return null;
                    }

                    @Override
                    public boolean succeeded() {
                        return true;
                    }

                    @Override
                    public boolean failed() {
                        return false;
                    }
                });
            }
        });
    }
}

public void handle(final Message<JsonObject> event) {
    String operation = event.body().getString(OPERATION);
    if (log.isTraceEnabled()) {
        log.trace("RedisQues got operation:" + operation);
    }
    QueueOperation queueOperation = QueueOperation.fromString(operation);
    if (queueOperation == null) {
        unsupportedOperation(operation, event);
        return;
    }
    switch(queueOperation) {
        case enqueue:
            updateTimestamp(event.body().getJsonObject(PAYLOAD).getString(QUEUENAME), null);
            String keyEnqueue = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            String valueEnqueue = event.body().getString(MESSAGE);
            redisClient.rpush(keyEnqueue, valueEnqueue,  event2 -> {
                JsonObject reply = new JsonObject();
                if (event2.succeeded()) {
                    log.debug("RedisQues Enqueued message into queue " + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME));
                    notifyConsumer(event.body().getJsonObject(PAYLOAD).getString(QUEUENAME));
                    reply.put(STATUS, OK);
                    reply.put(MESSAGE, "enqueued");
                    event.reply(reply);
                } else {
                    String message = "RedisQues QUEUE_ERROR: Error while enqueueing message into queue " + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
                    log.error(message);
                    reply.put(STATUS, ERROR);
                    reply.put(MESSAGE, message);
                    event.reply(reply);
                }
            });
            break;
        case check:
            checkQueues();
            break;
        case reset:
            resetConsumers();
            break;
        case stop:
            gracefulStop( event1 -> {
                JsonObject reply = new JsonObject();
                reply.put(STATUS, OK);
            });
            break;
        case getQueueItems:
            String keyListRange = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            int maxQueueItemCountIndex = getMaxQueueItemCountIndex(event.body().getJsonObject(PAYLOAD).getString(LIMIT));
            redisClient.llen(keyListRange,  countReply -> redisClient.lrange(keyListRange, 0, maxQueueItemCountIndex, new GetQueueItemsHandler(event, countReply.result())));
            break;
        case addQueueItem:
            String key1 = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            String valueAddItem = event.body().getJsonObject(PAYLOAD).getString(BUFFER);
            redisClient.rpush(key1, valueAddItem, new AddQueueItemHandler(event));
            break;
        case deleteQueueItem:
            String keyLset = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            int indexLset = event.body().getJsonObject(PAYLOAD).getInteger(INDEX);
            redisClient.lset(keyLset, indexLset, "TO_DELETE",  event1 -> {
                if (event1.succeeded()) {
                    String keyLrem = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
                    redisClient.lrem(keyLrem, 0, "TO_DELETE",  replyLrem -> event.reply(new JsonObject().put(STATUS, OK)));
                } else {
                    event.reply(new JsonObject().put(STATUS, ERROR));
                }
            });
            break;
        case getQueueItem:
            String key = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            int index = event.body().getJsonObject(PAYLOAD).getInteger(INDEX);
            redisClient.lindex(key, index, new GetQueueItemHandler(event));
            break;
        case replaceQueueItem:
            String keyReplaceItem = getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            int indexReplaceItem = event.body().getJsonObject(PAYLOAD).getInteger(INDEX);
            String bufferReplaceItem = event.body().getJsonObject(PAYLOAD).getString(BUFFER);
            redisClient.lset(keyReplaceItem, indexReplaceItem, bufferReplaceItem, new ReplaceQueueItemHandler(event));
            break;
        case deleteAllQueueItems:
            redisClient.del(getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME), new DeleteAllQueueItems(event));
            break;
        case getAllLocks:
            redisClient.hkeys(getLocksKey(), new GetAllLocksHandler(event));
            break;
        case putLock:
            JsonObject lockInfo = extractLockInfo(event.body().getJsonObject(PAYLOAD).getString(REQUESTED_BY));
            if (lockInfo != null) {
                redisClient.hmset(getLocksKey(), new JsonObject().put(event.body().getJsonObject(PAYLOAD).getString(QUEUENAME), lockInfo.encode()), new PutLockHandler(event));
            } else {
                event.reply(new JsonObject().put(STATUS, ERROR).put(MESSAGE, "Property '" + REQUESTED_BY + "' missing"));
            }
            break;
        case getLock:
            redisClient.hget(getLocksKey(), event.body().getJsonObject(PAYLOAD).getString(QUEUENAME), new GetLockHandler(event));
            break;
        case deleteLock:
            String queueName = event.body().getJsonObject(PAYLOAD).getString(QUEUENAME);
            redisClient.exists(getQueuesPrefix() + queueName,  event1 -> {
                if (event1.succeeded() && event1.result() == 1) {
                    notifyConsumer(queueName);
                }
                redisClient.hdel(getLocksKey(), queueName, new DeleteLockHandler(event));
            });
            break;
        case getQueueItemsCount:
            redisClient.llen(getQueuesPrefix() + event.body().getJsonObject(PAYLOAD).getString(QUEUENAME), new GetQueueItemsCountHandler(event));
            break;
        case getQueuesCount:
            redisClient.zcount(getQueuesKey(), getMaxAgeTimestamp(), Double.MAX_VALUE, new GetQueuesCountHandler(event));
            break;
        case getQueues:
            redisClient.zrangebyscore(getQueuesKey(), String.valueOf(getMaxAgeTimestamp()), "+inf", RangeLimitOptions.NONE, new GetQueuesHandler(event));
            break;
        default:
            unsupportedOperation(operation, event);
    }
}

@Test
public void testThatStompMessagesAreTransferredToTheEventBus() {
    AtomicReference<Message> reference = new AtomicReference<>();
    consumers.add(vertx.eventBus().consumer("/bus", reference::set));
    clients.add(StompClient.create(vertx).connect( ar -> {
        final StompClientConnection connection = ar.result();
        connection.send("/bus", Headers.create("foo", "bar"), Buffer.buffer("Hello from STOMP"));
    }));
    Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> reference.get() != null);
    assertThat(reference.get().headers().get("foo")).isEqualTo("bar");
    assertThat(reference.get().headers().get("destination")).isEqualTo("/bus");
    assertThat(reference.get().headers().get("content-length")).isEqualTo("16");
    assertThat(reference.get().address()).isEqualTo("/bus");
    assertThat(reference.get().replyAddress()).isNullOrEmpty();
    assertThat(reference.get().body().toString()).isEqualTo("Hello from STOMP");
}

/**
     * Something has happened, so handle it.
     *
     * @param msg the event to handle
     */
@Override
public void handle(Message<Void> msg) {
    msg.reply(dependency.getConfig());
}

/**
     * Something has happened, so handle it.
     *
     * @param msg the event to handle
     */
@Override
public void handle(Message<Void> msg) {
    msg.reply(dependency.getClass().getName());
}

/**
   * decode a message to json object
   * @param val
   * @return
   */
public static JsonObject decode(Message val) {
    JsonObject jo = new JsonObject(val.body().toString());
    return jo;
}

@Override
public void handle(Message<Buffer> message) {
    requestHandler.handle(new MappedHttpServerRequest(vertx, message));
}