io.vertx.core.eventbus.DeliveryOptions Java Examples

@Test
public void testThatEventBusMessagesContainingNoBodyAreTransferredToStomp() {
  AtomicReference<Frame> reference = new AtomicReference<>();

  clients.add(StompClient.create(vertx).connect(ar -> {
        final StompClientConnection connection = ar.result();
        connection.subscribe("/bus", reference::set,
            f -> {
              vertx.eventBus().publish("/bus", null,
                  new DeliveryOptions().addHeader("foo", "bar"));
            }
        );
      }
  ));

  Awaitility.await().atMost(10, TimeUnit.SECONDS).until(() -> reference.get() != null);

  assertThat(reference.get().getHeaders().get("foo")).isEqualTo("bar");
  assertThat(reference.get().getHeaders().get("destination")).isEqualTo("/bus");
  byte[] body = reference.get().getBody().getBytes();
  assertThat(body).hasSize(0);
}
 

public ProductService retrieveProductPrice(String productId, Handler<AsyncResult<JsonObject>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("productId", productId);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveProductPrice");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

public void retrieveStore(String sellerId, Handler<AsyncResult<Store>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  _json.put("sellerId", sellerId);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveStore");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new Store(res.result().body())));
                    }
  });
}
 

public OrderService initializePersistence(Handler<AsyncResult<Void>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "initializePersistence");
  _vertx.eventBus().<Void>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

@Override
public void average(Handler<AsyncResult<JsonObject>> handler){
  if (closed) {
    handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();

  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "average");
  _vertx.eventBus().<JsonObject>request(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      handler.handle(Future.failedFuture(res.cause()));
    } else {
      handler.handle(Future.succeededFuture(res.result().body()));
    }
  });
}
 

public void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler) {
  if (closed) {
  resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "getPortfolio");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new Portfolio(res.result().body())));
                    }
  });
}
 

public AccountService retrieveByUsername(String username, Handler<AsyncResult<Account>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("username", username);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveByUsername");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new Account(res.result().body())));
                    }
  });
  return this;
}
 

public void evaluate(Handler<AsyncResult<Double>> resultHandler) {
  if (closed) {
  resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "evaluate");
  _vertx.eventBus().<Double>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body()));
    }
  });
}
 

/**
 * Execute the reply chain with given http status code
 *
 * @param deliveryOptions, the event b us deliver serverOptions
 */
public void execute(DeliveryOptions deliveryOptions) {
  Objects.requireNonNull(deliveryOptions);
  new ExecuteEventbusByte(
          methodId,
          vxmsShared,
          failure,
          errorMethodHandler,
          message,
          chain,
          byteConsumer,
          excecuteEventBusAndReply,
          errorHandler,
          onFailureRespond,
          deliveryOptions,
          retryCount,
          timeout,
          circuitBreakerTimeout)
      .execute();
}
 

public AccountService retrieveAllAccounts(Handler<AsyncResult<List<Account>>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveAllAccounts");
  _vertx.eventBus().<JsonArray>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body().stream().map(o -> o instanceof Map ? new Account(new JsonObject((Map) o)) : new Account((JsonObject) o)).collect(Collectors.toList())));
    }
  });
  return this;
}
 

public void manageError(Message<JsonObject> message, Throwable cause, String serviceName) {
    int code = MainApiException.INTERNAL_SERVER_ERROR.getStatusCode();
    String statusMessage = MainApiException.INTERNAL_SERVER_ERROR.getStatusMessage();
    DeliveryOptions deliveryOptions = new DeliveryOptions();
    if (cause instanceof MainApiException) {
        code = ((MainApiException)cause).getStatusCode();
        statusMessage = ((MainApiException)cause).getStatusMessage();
        deliveryOptions.setHeaders(((MainApiException)cause).getHeaders());
    } else {
        logUnexpectedError(serviceName, cause);
    }
    deliveryOptions.addHeader(SwaggerRouter.CUSTOM_STATUS_CODE_HEADER_KEY, String.valueOf(code));
    deliveryOptions.addHeader(SwaggerRouter.CUSTOM_STATUS_MESSAGE_HEADER_KEY, statusMessage);

    message.reply(null, deliveryOptions);
}
 

/**
 * Send message and redirect the event bus response directly to the initial request
 *
 * @param id the target id to send to
 * @param message the message to send
 * @param requestOptions the delivery serverOptions for the event bus request
 */
public void sendAndRespondRequest(String id, Object message, DeliveryOptions requestOptions) {
  final Vertx vertx = vxmsShared.getVertx();
  vertx
      .eventBus()
      .send(
          id,
          message,
          requestOptions != null ? requestOptions : new DeliveryOptions(),
          event -> {
            if (event.failed()) {
              requestmessage.fail(
                  HttpResponseStatus.SERVICE_UNAVAILABLE.code(), event.cause().getMessage());
            }
            Optional.ofNullable(event.result())
                .ifPresent(
                    result ->
                        Optional.ofNullable(result.body())
                            .ifPresent(resp -> respond(resp, requestOptions)));
          });
}
 

public <T> Handler<AsyncResult<ResourceResponse<T>>> getAsyncResultHandler(Message<JsonObject> message, String serviceName, boolean withJsonEncode, TypeReference<T> type) {
    return result -> {
        if (result.succeeded()) {
            DeliveryOptions deliveryOptions = new DeliveryOptions();
            deliveryOptions.setHeaders(result.result().getHeaders());
            if(withJsonEncode) {
                message.reply(result.result().toJson(), deliveryOptions);
            } else {
                message.reply(result.result().getResponse(), deliveryOptions);
            }
        } else {
            Throwable cause = result.cause();
            manageError(message, cause, serviceName);
        }
    };
}
 

public void manageError(Message<JsonObject> message, Throwable cause, String serviceName) {
    int code = MainApiException.INTERNAL_SERVER_ERROR.getStatusCode();
    String statusMessage = MainApiException.INTERNAL_SERVER_ERROR.getStatusMessage();
    DeliveryOptions deliveryOptions = new DeliveryOptions();
    if (cause instanceof MainApiException) {
        code = ((MainApiException)cause).getStatusCode();
        statusMessage = ((MainApiException)cause).getStatusMessage();
        deliveryOptions.setHeaders(((MainApiException)cause).getHeaders());
    } else {
        logUnexpectedError(serviceName, cause);
    }
    deliveryOptions.addHeader(SwaggerRouter.CUSTOM_STATUS_CODE_HEADER_KEY, String.valueOf(code));
    deliveryOptions.addHeader(SwaggerRouter.CUSTOM_STATUS_MESSAGE_HEADER_KEY, statusMessage);

    message.reply(null, deliveryOptions);
}
 

/**
 * Pass all parameters to execute the chain
 *
 * @param methodId the method identifier
 * @param requestmessage the message to responde
 * @param vxmsShared the vxmsShared instance, containing the Vertx instance and other shared
 *     objects per instance
 * @param failure the last failure
 * @param errorMethodHandler the error-method handler
 * @param targetId the event-bus message target-targetId
 * @param message the event-bus message
 * @param options the event-bus delivery serverOptions
 */
public EventbusBridgeResponse(
    String methodId,
    Message<Object> requestmessage,
    VxmsShared vxmsShared,
    Throwable failure,
    Consumer<Throwable> errorMethodHandler,
    String targetId,
    Object message,
    DeliveryOptions options) {
  this.methodId = methodId;
  this.vxmsShared = vxmsShared;
  this.t = failure;
  this.errorMethodHandler = errorMethodHandler;
  this.requestmessage = requestmessage;
  this.targetId = targetId;
  this.message = message;
  this.options = options;
}
 

public <T> Handler<AsyncResult<ResourceResponse<T>>> getAsyncResultHandler(Message<JsonObject> message, String serviceName, boolean withJsonEncode, TypeReference<T> type) {
    return result -> {
        if (result.succeeded()) {
            DeliveryOptions deliveryOptions = new DeliveryOptions();
            deliveryOptions.setHeaders(result.result().getHeaders());
            if(withJsonEncode) {
                message.reply(Json.encode(result.result().getResponse()), deliveryOptions);
            } else {
                message.reply(result.result().getResponse(), deliveryOptions);
            }
        } else {
            Throwable cause = result.cause();
            manageError(message, cause, serviceName);
        }
    };
}
 

public AccountService retrieveAccount(String id, Handler<AsyncResult<Account>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("id", id);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveAccount");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new Account(res.result().body())));
                    }
  });
  return this;
}
 

private void assertSend(TestContext context, String address, Object body, DeliveryOptions options, int times) {
  context.assertTrue(times > 0, "Could not send message " + body + " to address " + address);
  vertx.eventBus().request(address, body, options, ar -> {
    if (ar.failed()) {
      ReplyException ex = (ReplyException) ar.cause();
      if (ex.failureType() == NO_HANDLERS) {
        // Wait 10 ms to be sure consumer is deployed
        vertx.setTimer(10, id -> {
          assertSend(context, address, body, options, times - 1);
        });
      } else {
        context.fail();
      }
    }
  });
}
 

@Override
public void execute(DeliveryOptions deliveryOptions) {
  Objects.requireNonNull(deliveryOptions);
  new ExecuteEventbusObject(
          methodId,
          vxmsShared,
          failure,
          errorMethodHandler,
          message,
          chain,
          objectSupplier,
          excecuteEventBusAndReply,
          encoder,
          errorHandler,
          onFailureRespond,
          deliveryOptions,
          retryCount,
          delay,
          timeout,
          circuitBreakerTimeout)
      .execute();
}
 

public OrderService retrieveOrdersForAccount(String accountId, Handler<AsyncResult<List<Order>>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("accountId", accountId);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveOrdersForAccount");
  _vertx.eventBus().<JsonArray>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body().stream().map(o -> o instanceof Map ? new Order(new JsonObject((Map) o)) : new Order((JsonObject) o)).collect(Collectors.toList())));
    }
  });
  return this;
}
 

public JobService getJobLog(long id, Handler<AsyncResult<JsonArray>> handler) {
  if (closed) {
    handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("id", id);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "getJobLog");
  _vertx.eventBus().<JsonArray>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      handler.handle(Future.failedFuture(res.cause()));
    } else {
      handler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

public void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "getPortfolio");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new Portfolio(res.result().body())));
                    }
  });
}
 

public JobService cardByType(String type, JobState state, Handler<AsyncResult<Long>> handler) {
  if (closed) {
    handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("type", type);
  _json.put("state", state == null ? null : state.toString());
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "cardByType");
  _vertx.eventBus().<Long>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      handler.handle(Future.failedFuture(res.cause()));
    } else {
      handler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

public JobService failedCount(String type, Handler<AsyncResult<Long>> handler) {
  if (closed) {
    handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("type", type);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "failedCount");
  _vertx.eventBus().<Long>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      handler.handle(Future.failedFuture(res.cause()));
    } else {
      handler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

public AccountService deleteAllAccounts(Handler<AsyncResult<Void>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "deleteAllAccounts");
  _vertx.eventBus().<Void>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}
 

public ProductService retrieveProductsByPage(int page, Handler<AsyncResult<List<Product>>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("page", page);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "retrieveProductsByPage");
  _vertx.eventBus().<JsonArray>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body().stream().map(o -> o instanceof Map ? new Product(new JsonObject((Map) o)) : new Product((JsonObject) o)).collect(Collectors.toList())));
    }
  });
  return this;
}
 

public void checkout(String userId, Handler<AsyncResult<CheckoutResult>> handler) {
  if (closed) {
    handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  _json.put("userId", userId);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "checkout");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      handler.handle(Future.failedFuture(res.cause()));
    } else {
      handler.handle(Future.succeededFuture(res.result().body() == null ? null : new CheckoutResult(res.result().body())));
                    }
  });
}
 

public void example1(Vertx vertx) {
  // Assume database service is already deployed somewhere....
  // Save some data in the database
  JsonObject message = new JsonObject();

  message
    .put("collection", "mycollection")
    .put("document", new JsonObject().put("name", "tim"));

  DeliveryOptions options = new DeliveryOptions().addHeader("action", "save");

  vertx.eventBus()
    .request("database-service-address", message, options)
    .onSuccess(msg -> {
      // done
    }).onFailure(err -> {
    // failure
  });
}
 

public void queryWithVariables(String graphqlQuery, JsonObject variables, Handler<AsyncResult<QueryResult>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return;
  }
  JsonObject _json = new JsonObject();
  _json.put("graphqlQuery", graphqlQuery);
  _json.put("variables", variables);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "queryWithVariables");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body() == null ? null : new QueryResult(res.result().body())));
                    }
  });
}
 

@Override
public void execute(DeliveryOptions deliveryOptions) {
  Objects.requireNonNull(deliveryOptions);
  new ExecuteEventbusString(
          methodId,
          vxmsShared,
          failure,
          errorMethodHandler,
          message,
          chain,
          stringSupplier,
          excecuteAsyncEventBusAndReply,
          errorHandler,
          onFailureRespond,
          deliveryOptions,
          retryCount,
          timeout,
          delay,
          circuitBreakerTimeout)
      .execute();
}