io.vertx.reactivex.core.RxHelper Java Examples

private void hydrate() {
  WebClient webClient = WebClient.create(vertx);
  webClient
    .get(3001, "localhost", "/ranking-last-24-hours")
    .as(BodyCodec.jsonArray())
    .rxSend()
    .delay(5, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .retry(5)
    .map(HttpResponse::body)
    .flattenAsFlowable(Functions.identity())
    .cast(JsonObject.class)
    .flatMapSingle(json -> whoOwnsDevice(webClient, json))
    .flatMapSingle(json -> fillWithUserProfile(webClient, json))
    .subscribe(
      this::hydrateEntryIfPublic,
      err -> logger.error("Hydratation error", err),
      () -> logger.info("Hydratation completed"));
}
 

@BeforeEach
void prepare(Vertx vertx, VertxTestContext testContext) {
  Map<String, String> conf = new HashMap<>();
  conf.put("bootstrap.servers", "localhost:9092");
  conf.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  conf.put("value.serializer", "io.vertx.kafka.client.serialization.JsonObjectSerializer");
  conf.put("acks", "1");
  producer = KafkaProducer.create(vertx, conf);
  webClient = WebClient.create(vertx);
  KafkaAdminClient adminClient = KafkaAdminClient.create(vertx, conf);
  adminClient
    .rxDeleteTopics(Arrays.asList("incoming.steps", "daily.step.updates"))
    .onErrorComplete()
    .andThen(vertx.rxDeployVerticle(new CongratsVerticle()))
    .ignoreElement()
    .andThen(vertx.rxDeployVerticle(new FakeUserService()))
    .ignoreElement()
    .andThen(webClient.delete(8025, "localhost", "/api/v1/messages").rxSend())
    .ignoreElement()
    .delay(1, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .subscribe(testContext::completeNow, testContext::failNow);
}
 

@Test
@DisplayName("No email must be sent below 10k steps")
void checkNothingBelow10k(Vertx vertx, VertxTestContext testContext) {
  producer
    .rxSend(record("123", 5000))
    .ignoreElement()
    .delay(3, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .andThen(webClient
      .get(8025, "localhost", "/api/v2/search?kind=to&[email protected]")
      .as(BodyCodec.jsonObject()).rxSend())
    .map(HttpResponse::body)
    .subscribe(
      json -> {
        testContext.verify(() -> assertThat(json.getInteger("total")).isEqualTo(0));
        testContext.completeNow();
      },
      testContext::failNow);
}
 

private void deployReporterVerticle(Collection<Reporter> reporters) {
    Single<String> deployment = RxHelper.deployVerticle(vertx, applicationContext.getBean(AuditReporterVerticle.class));

    deployment.subscribe(id -> {
        // Deployed
        deploymentId = id;
        if (!reporters.isEmpty()) {
            for (io.gravitee.reporter.api.Reporter reporter : reporters) {
                try {
                    logger.info("Starting reporter: {}", reporter);
                    reporter.start();
                } catch (Exception ex) {
                    logger.error("Unexpected error while starting reporter", ex);
                }
            }
        } else {
            logger.info("\tThere is no reporter to start");
        }
    }, err -> {
        // Could not deploy
        logger.error("Reporter service can not be started", err);
    });
}
 

@Test
@DisplayName("Ingest a badly-formed JSON data over HTTP and observe no Kafka record")
void httpIngestWrong(Vertx vertx, VertxTestContext testContext) {
  JsonObject body = new JsonObject();

  given(requestSpecification)
    .contentType(ContentType.JSON)
    .body(body.encode())
    .post("/ingest")
    .then()
    .assertThat()
    .statusCode(400);

  kafkaConsumer.subscribe("incoming.steps")
    .toFlowable()
    .timeout(3, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .subscribe(
      record -> testContext.failNow(new IllegalStateException("We must not get a record")),
      err -> {
        if (err instanceof TimeoutException) {
          testContext.completeNow();
        } else {
          testContext.failNow(err);
        }
      });
}
 

@Override
public void afterPropertiesSet() throws Exception {
    logger.info("Initializing reporters for domain {}", domain.getName());
    logger.info("\t Starting reporter verticle for domain {}", domain.getName());

    Single<String> deployment = RxHelper.deployVerticle(vertx, applicationContext.getBean(AuditReporterVerticle.class));
    deployment.subscribe(id -> {
        // Deployed
        deploymentId = id;
        // Start reporters
        List<Reporter> reporters = reporterRepository.findByDomain(domain.getId()).blockingGet();
        if (!reporters.isEmpty()) {
            reporters.forEach(reporter -> startReporterProvider(reporter));
            logger.info("Reporters loaded for domain {}", domain.getName());
        } else {
            logger.info("\tThere is no reporter to start");
        }
    }, err -> {
        // Could not deploy
        logger.error("Reporter service can not be started", err);
    });
}
 

@Override
public Completable rxStart() {
  Router router = Router.router(vertx);

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumerConfig("dashboard-webapp-throughput"))
    .subscribe("event-stats.throughput")
    .toFlowable()
    .subscribe(record -> forwardKafkaRecord(record, "client.updates.throughput"));

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumerConfig("dashboard-webapp-city-trend"))
    .subscribe("event-stats.city-trend.updates")
    .toFlowable()
    .subscribe(record -> forwardKafkaRecord(record, "client.updates.city-trend"));

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumerConfig("dashboard-webapp-ranking"))
    .subscribe("event-stats.user-activity.updates")
    .toFlowable()
    .filter(record -> record.value().getBoolean("makePublic"))
    .buffer(5, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .subscribe(this::updatePublicRanking);

  hydrate();

  SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
  SockJSBridgeOptions bridgeOptions = new SockJSBridgeOptions()
    .addInboundPermitted(new PermittedOptions().setAddressRegex("client.updates.*"))
    .addOutboundPermitted(new PermittedOptions().setAddressRegex("client.updates.*"));
  sockJSHandler.bridge(bridgeOptions);
  router.route("/eventbus/*").handler(sockJSHandler);

  router.get("/").handler(ctx -> ctx.reroute("/index.html"));
  router.route().handler(StaticHandler.create("webroot/assets"));

  return vertx.createHttpServer()
    .requestHandler(router)
    .rxListen(HTTP_PORT)
    .ignoreElement();
}
 

@Test
public void testDeployVerticle() throws Exception {
  CountDownLatch deployLatch = new CountDownLatch(2);
  RxHelper.deployVerticle(vertx, new AbstractVerticle() {
    @Override
    public void start() {
      deployLatch.countDown();
    }
  }).subscribe(resp -> {
    deployLatch.countDown();
  });
  awaitLatch(deployLatch);
}
 

@Test
public void deployVerticleFailure() throws Exception {
  CoreVerticle verticle = new CoreVerticle(true);
  Single<String> single = RxHelper.deployVerticle(vertx, verticle);
  assertNull(verticle.config);
  try {
    single.blockingGet();
    fail("Verticle deployment should fail");
  } catch (RuntimeException e) {
    assertThat(e.getCause(), instanceOf(MyException.class));
    assertNotNull(verticle.config);
    assertTrue(verticle.config.isEmpty());
  }
}
 

@Test
public void deployVerticleWithOptions() throws Exception {
  CoreVerticle verticle = new CoreVerticle();
  JsonObject expected = new JsonObject()
    .put("bim", 1).put("bam", new JsonArray().add(1).add(2).add(3)).put("boum", new JsonObject().put("toto", "titi"));
  Single<String> single = RxHelper.deployVerticle(vertx, verticle, new DeploymentOptions().setConfig(expected));
  assertNull(verticle.config);
  single.blockingGet();
  assertEquals(expected, verticle.config);
}
 

@Test
public void deployVerticle() throws Exception {
  CoreVerticle verticle = new CoreVerticle();
  Single<String> single = RxHelper.deployVerticle(vertx, verticle);
  assertNull(verticle.config);
  single.blockingGet();
  assertNotNull(verticle.config);
  assertTrue(verticle.config.isEmpty());
}
 

public void deployVerticle(Vertx vertx, Verticle verticle) {
  Single<String> deployment = RxHelper.deployVerticle(vertx, verticle);

  deployment.subscribe(id -> {
    // Deployed
  }, err -> {
    // Could not deploy
  });
}
 

@Test
@DisplayName("Check the deployment and interaction of a Rx1 verticle")
void check_deployment_and_message_send(Vertx vertx, VertxTestContext testContext) {
  RxHelper
    .deployVerticle(vertx, new RxVerticle())
    .flatMap(id -> vertx.eventBus().rxRequest("check", "Ok?"))
    .subscribe(
      message -> testContext.verify(() -> {
        assertThat(message.body()).isEqualTo("Check!");
        testContext.completeNow();
      }),
      testContext::failNow);
}
 

@Override
public Flowable apply(Flowable input) {
    Context context = Vertx.currentContext();
    if (context != null && context.getDelegate() != null) {
        return input.compose(f -> f.observeOn(RxHelper.scheduler(context)));
    }
    return input;
}
 

@Override
public Completable rxStart() {
  Observable
    .interval(1, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .subscribe(n -> System.out.println("tick"));

  return vertx.createHttpServer()
    .requestHandler(r -> r.response().end("Ok"))
    .rxListen(8080)
    .ignoreElement();
}
 

@Override
public Completable rxStart() {
  webClient = WebClient.create(vertx);
  producer = KafkaProducer.create(vertx, KafkaConfig.producer());

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumer("event-stats-throughput"))
    .subscribe("incoming.steps")
    .toFlowable()
    .buffer(5, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .flatMapCompletable(this::publishThroughput)
    .doOnError(err -> logger.error("Woops", err))
    .retryWhen(this::retryLater)
    .subscribe();

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumer("event-stats-user-activity-updates"))
    .subscribe("daily.step.updates")
    .toFlowable()
    .flatMapSingle(this::addDeviceOwner)
    .flatMapSingle(this::addOwnerData)
    .flatMapCompletable(this::publishUserActivityUpdate)
    .doOnError(err -> logger.error("Woops", err))
    .retryWhen(this::retryLater)
    .subscribe();

  KafkaConsumer.<String, JsonObject>create(vertx, KafkaConfig.consumer("event-stats-city-trends"))
    .subscribe("event-stats.user-activity.updates")
    .toFlowable()
    .groupBy(this::city)
    .flatMap(groupedFlowable -> groupedFlowable.buffer(5, TimeUnit.SECONDS, RxHelper.scheduler(vertx)))
    .flatMapCompletable(this::publishCityTrendUpdate)
    .doOnError(err -> logger.error("Woops", err))
    .retryWhen(this::retryLater)
    .subscribe();

  return Completable.complete();
}
 

@Test
@DisplayName("Ingest a badly-formed AMQP message and observe no Kafka record")
void amqIngestWrong(Vertx vertx, VertxTestContext testContext) {
  JsonObject body = new JsonObject();

  amqpClient.rxConnect()
    .flatMap(connection -> connection.rxCreateSender("step-events"))
    .subscribe(
      sender -> {
        AmqpMessage msg = AmqpMessage.create()
          .durable(true)
          .ttl(5000)
          .withJsonObjectAsBody(body).build();
        sender.send(msg);
      },
      testContext::failNow);

  kafkaConsumer.subscribe("incoming.steps")
    .toFlowable()
    .timeout(3, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .subscribe(
      record -> testContext.failNow(new IllegalStateException("We must not get a record")),
      err -> {
        if (err instanceof TimeoutException) {
          testContext.completeNow();
        } else {
          testContext.failNow(err);
        }
      });
}
 

@BeforeEach
void setup(Vertx vertx, VertxTestContext testContext) {
  kafkaConsumer = KafkaConsumer.create(vertx, kafkaConfig());
  amqpClient = AmqpClient.create(vertx, amqClientOptions());
  KafkaAdminClient adminClient = KafkaAdminClient.create(vertx, kafkaConfig());
  vertx
    .rxDeployVerticle(new IngesterVerticle())
    .delay(500, TimeUnit.MILLISECONDS, RxHelper.scheduler(vertx))
    .flatMapCompletable(id -> adminClient.rxDeleteTopics(singletonList("incoming.steps")))
    .onErrorComplete()
    .subscribe(testContext::completeNow, testContext::failNow);
}
 

@Override
public void start() {
  SensorDataService service = SensorDataService.createProxy(vertx, "sensor.data-service");
  service.rxAverage()
    .delaySubscription(3, TimeUnit.SECONDS, RxHelper.scheduler(vertx))
    .repeat()
    .map(data -> "avg = " + data.getDouble("average"))
    .subscribe(System.out::println);
}
 

private Flowable<Throwable> retryLater(Flowable<Throwable> errs) {
  return errs.delay(10, TimeUnit.SECONDS, RxHelper.scheduler(vertx));
}
 

public void schedulerHook(Vertx vertx) {
  RxJavaPlugins.setComputationSchedulerHandler(s -> RxHelper.scheduler(vertx));
  RxJavaPlugins.setIoSchedulerHandler(s -> RxHelper.blockingScheduler(vertx));
  RxJavaPlugins.setNewThreadSchedulerHandler(s -> RxHelper.scheduler(vertx));
}
 

private Flowable<Throwable> retryLater(Flowable<Throwable> errs) {
  return errs.delay(10, TimeUnit.SECONDS, RxHelper.scheduler(vertx));
}
 

public void writeStreamSubscriberAdapter(Flowable<io.vertx.core.buffer.Buffer> flowable, io.vertx.core.http.HttpServerResponse response) {
  response.setChunked(true);
  WriteStreamSubscriber<io.vertx.core.buffer.Buffer> subscriber = io.vertx.reactivex.RxHelper.toSubscriber(response);
  flowable.subscribe(subscriber);
}
 

private Flowable<Long> retryLater(Vertx vertx, Flowable<Throwable> errs) {
  return errs
    .flatMap(d -> Flowable.timer(10, TimeUnit.SECONDS, RxHelper.scheduler(vertx)));
}
 

private Flowable<Throwable> retryLater(Flowable<Throwable> errs) {
  return errs.delay(10, TimeUnit.SECONDS, RxHelper.scheduler(vertx));
}
 

private Flowable<Throwable> retryLater(Flowable<Throwable> errs) {
  return errs.delay(10, TimeUnit.SECONDS, RxHelper.scheduler(vertx));
}