io.vertx.rx.java.ObservableFuture Java Examples

@Test
public void testFailTwice() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  Throwable failure = new Throwable();
  o.toHandler().handle(Future.failedFuture(failure));
  o.toHandler().handle(Future.failedFuture(new Throwable()));
  subscriber.assertError(failure).assertEmpty();
}
 

@Test
public void testCompleteTwice() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  o.toHandler().handle(Future.succeededFuture("abc"));
  o.toHandler().handle(Future.succeededFuture("def"));
  subscriber.assertItem("abc").assertCompleted().assertEmpty();
}
 

@Test
public void testUnsubscribeBeforeResolve() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  subscriber.unsubscribe();
  assertTrue(subscriber.isUnsubscribed());
  subscriber.assertEmpty();
}
 

@Test
public void testCompleteWithFailureAfterSubscribe() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  subscriber.assertEmpty();
  Throwable failure = new Throwable();
  o.toHandler().handle(Future.failedFuture(failure));
  subscriber.assertError(failure).assertEmpty();
}
 

@Override
public Observable<BulkResponse> bulk(List<BulkIndexOptions> bulkIndexOptions,
                                     List<BulkUpdateOptions> bulkUpdateOptions,
                                     List<BulkDeleteOptions> bulkDeleteOptions,
                                     BulkOptions bulkOptions) {
    final ObservableFuture<BulkResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.bulk(bulkIndexOptions, bulkUpdateOptions, bulkDeleteOptions, bulkOptions, observableFuture.toHandler());
    return observableFuture;
}
 

@Test
public void testCompleteWithFailureBeforeSubscribe() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  Throwable failure = new Throwable();
  o.toHandler().handle(Future.failedFuture(failure));
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  subscriber.assertError(failure).assertEmpty();
}
 

@Test
public void testCompleteWithSuccessAfterSubscribe() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  subscriber.assertEmpty();
  o.toHandler().handle(Future.succeededFuture("abc"));
  subscriber.assertItem("abc").assertCompleted().assertEmpty();
}
 

@Test
public void testCompleteWithSuccessBeforeSubscribe() {
  ObservableFuture<String> o = RxHelper.observableFuture();
  o.toHandler().handle(Future.succeededFuture("abc"));
  TestSubscriber<String> subscriber = new TestSubscriber<>();
  subscribe(o, subscriber);
  subscriber.assertItem("abc").assertCompleted().assertEmpty();
}
 

public void observableFuture(Vertx vertx) {
  ObservableFuture<HttpServer> observable = RxHelper.observableFuture();
  observable.subscribe(
      server -> {
        // Server is listening
      },
      failure -> {
        // Server could not start
      }
  );
  vertx.createHttpServer(new HttpServerOptions().
      setPort(1234).
      setHost("localhost")
  ).listen(observable.toHandler());
}
 

@Test
public void testDeleteRx(TestContext testContext) throws Exception {
    final Async async = testContext.async();
    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("obj", new JsonObject()
                    .put("array", new JsonArray()
                            .add("1")
                            .add("2")));

    final UUID documentId = UUID.randomUUID();
    final IndexOptions indexOptions = new IndexOptions().setId(documentId.toString());

    rxService.index(index, type, source, indexOptions)
            .flatMap(indexResponse -> {
                final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(2000l, event -> observableFuture.toHandler().handle(Future.succeededFuture()));
                return observableFuture;
            })
            .flatMap(indexResponse -> rxService.delete(index, type, documentId.toString(), new DeleteOptions().setRefresh(RefreshPolicy.IMMEDIATE)))
            .subscribe(
                    deleteResponse -> {
                        assertDelete(testContext, deleteResponse, documentId);
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

@Test
public void testMultiSearchRx(TestContext testContext) throws Exception {

    final Async async = testContext.async();
    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("obj", new JsonObject()
                    .put("array", new JsonArray()
                            .add("1")
                            .add("2")));

    final SearchOptions searchOptions = new SearchOptions()
            .setTimeoutInMillis(1000l)
            .setSize(10)
            .setSourceIncludes(Arrays.asList("user", "message"))
            .addFieldSort("user", SortOrder.DESC)
            .addScripSort("doc['message'].value", "painless", ScriptSortOption.Type.STRING, new JsonObject().put("param1", ImmutableList.of("1", "2", "3")), SortOrder.ASC)
            .addScriptField("script_field", "doc['message'].value", "painless", new JsonObject().put("param1", ImmutableList.of("1", "2", "3")))
            .setQuery(new JsonObject().put("match_all", new JsonObject()));

    final IndexOptions indexOptions = new IndexOptions().setId(id);
    rxService.index(index, type, source, indexOptions)
            .flatMap(indexResponse -> {
                final ObservableFuture<IndexResponse> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(2000l, event -> observableFuture.toHandler().handle(Future.succeededFuture(indexResponse)));
                return observableFuture;
            })
            .flatMap(indexResponse -> rxService.multiSearch(ImmutableList.of(new MultiSearchQueryOptions().addIndex(index).setSearchOptions(searchOptions))))
            .subscribe(
                    multiSearchResponse -> {
                        assertMultiSearch(testContext, multiSearchResponse);
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

@Test
public void testDeleteByQuerySimpleRx(TestContext testContext) throws Exception {

    final Async async = testContext.async();
    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("obj", new JsonObject()
                    .put("array", new JsonArray()
                            .add("1")
                            .add("2")));

    final UUID documentId = UUID.randomUUID();
    final IndexOptions indexOptions = new IndexOptions().setId(documentId.toString());

    rxService.index(index, type, source, indexOptions)
            .flatMap(result -> {
                final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(2000, id -> observableFuture.toHandler().handle(Future.succeededFuture()));
                return observableFuture;
            })
            .flatMap(aVoid -> {
                final DeleteByQueryOptions deleteByQueryOptions = new DeleteByQueryOptions().setTimeoutInMillis(1000l);
                return rxService.deleteByQuery(index, deleteByQueryOptions.setQuery(new JsonObject().put("ids", new JsonObject().put("values", new JsonArray().add(documentId.toString())))));
            })
            .subscribe(
                    deleteByQueryResponse -> {
                        assertDeleteByQuerySimple(testContext, deleteByQueryResponse);
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

@Test
public void testSearchRx(TestContext testContext) throws Exception {

    final Async async = testContext.async();
    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("obj", new JsonObject()
                    .put("array", new JsonArray()
                            .add("1")
                            .add("2")));

    final SearchOptions searchOptions = new SearchOptions()
            .setTimeoutInMillis(1000l)
            .setSize(10)
            .setSourceIncludes(Arrays.asList("user", "message"))
            .addFieldSort("user", SortOrder.DESC)
            .addScripSort("doc['message'].value", "painless", ScriptSortOption.Type.STRING, new JsonObject().put("param1", ImmutableList.of("1", "2", "3")), SortOrder.ASC)
            .addScriptField("script_field", "doc['message'].value", "painless", new JsonObject().put("param1", ImmutableList.of("1", "2", "3")))
            .setQuery(new JsonObject().put("match_all", new JsonObject()));

    final IndexOptions indexOptions = new IndexOptions().setId(id);
    rxService.index(index, type, source, indexOptions)
            .flatMap(indexResponse -> {
                final ObservableFuture<IndexResponse> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(2000l, event -> observableFuture.toHandler().handle(Future.succeededFuture(indexResponse)));
                return observableFuture;
            })
            .flatMap(indexResponse -> rxService.search(index, searchOptions))
            .subscribe(
                    searchResponse -> {
                        assertSearch(testContext, searchResponse);
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

@Test
public void testSearch_SuggestRx(TestContext testContext) throws Exception {

    final Async async = testContext.async();
    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("message_suggest", source_message);

    rxService.index(index, type, source)
            .flatMap(result -> {
                final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(1000, id -> observableFuture.toHandler().handle(Future.succeededFuture()));
                return observableFuture;
            })
            .flatMap(aVoid -> {
                final SearchOptions options = new SearchOptions();
                final CompletionSuggestOption completionSuggestOption = new CompletionSuggestOption()
                        .setText("v")
                        .setField("message_suggest");
                options.addSuggestion("test-suggest", completionSuggestOption);

                return rxService.search(index, options);
            })
            .subscribe(
                    searchResponse -> {
                        assertSuggest(testContext, searchResponse);
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

@Test
public void testScrollRx(TestContext testContext) throws Exception {

    final Async async = testContext.async();
    final SearchOptions options = new SearchOptions()
            .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
            .setScroll("5m")
            .setQuery(new JsonObject().put("match_all", new JsonObject()));

    final JsonObject source = new JsonObject()
            .put("user", source_user)
            .put("message", source_message)
            .put("obj", new JsonObject()
                    .put("array", new JsonArray()
                            .add("1")
                            .add("2")));

    final UUID documentId = UUID.randomUUID();
    final IndexOptions indexOptions = new IndexOptions().setId(documentId.toString());

    rxService.index(index, type, source, indexOptions)
            .flatMap(indexResponse -> {
                final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
                vertx.setTimer(2000l, event -> observableFuture.toHandler().handle(Future.succeededFuture()));
                return observableFuture;
            })
            .flatMap(aVoid -> rxService.search(index, options))
            .flatMap(searchResponse -> {
                String scrollId = searchResponse.getScrollId();
                assertScroll(testContext, searchResponse);
                SearchScrollOptions scrollOptions = new SearchScrollOptions().setScroll("5m");
                return rxService.searchScroll(scrollId, scrollOptions);
            })
            .subscribe(
                    searchResponse -> {
                        assertThat(testContext, searchResponse.getHits().getTotal(), greaterThan(0l));
                        async.complete();
                    },
                    error -> testContext.fail(error)
            );
}
 

private Single<Void> rxPublish(Record record) {
  ObservableFuture<Void> adapter = RxHelper.observableFuture();
  publish(record, adapter.toHandler());
  return adapter.toSingle();
}
 

@Override
public Observable<UpdateResponse> update(String index, String type, String id, UpdateOptions options) {
    final ObservableFuture<UpdateResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.update(index, type, id, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<Void> deleteTemplate(String name, TemplateOptions options) {
    final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
    elasticSearchAdminService.deleteTemplate(name, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<Void> putTemplate(String name, JsonObject source, TemplateOptions options) {
    final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
    elasticSearchAdminService.putTemplate(name, source, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<Void> deleteIndex(List<String> indices, DeleteIndexOptions options) {
    final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
    elasticSearchAdminService.deleteIndex(indices, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<Void> createIndex(String index, JsonObject source, CreateIndexOptions options) {
    final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
    elasticSearchAdminService.createIndex(index, source, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<Void> putMapping(List<String> indices, String type, JsonObject source, MappingOptions options) {
    final ObservableFuture<Void> observableFuture = RxHelper.observableFuture();
    elasticSearchAdminService.putMapping(indices, type, source, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<DeleteByQueryResponse> deleteByQuery(List<String> indices, DeleteByQueryOptions options) {
    final ObservableFuture<DeleteByQueryResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.deleteByQuery(indices, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<MultiGetResponse> multiGet(List<MultiGetQueryOptions> multiGetQueryOptions, MultiGetOptions options) {
    final ObservableFuture<MultiGetResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.multiGet(multiGetQueryOptions, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<MultiSearchResponse> multiSearch(final List<MultiSearchQueryOptions> multiSearchQueryOptions, MultiSearchOptions options) {
    final ObservableFuture<MultiSearchResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.multiSearch(multiSearchQueryOptions, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<DeleteResponse> delete(String index, String type, String id, DeleteOptions options) {
    final ObservableFuture<DeleteResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.delete(index, type, id, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<SearchResponse> searchScroll(String scrollId, SearchScrollOptions options) {
    final ObservableFuture<SearchResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.searchScroll(scrollId, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<SearchResponse> search(List<String> indices, SearchOptions options) {
    final ObservableFuture<SearchResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.search(indices, options, observableFuture.toHandler());
    return observableFuture;
}
 

@Override
public Observable<GetResponse> get(String index, String type, String id, GetOptions options) {
    final ObservableFuture<GetResponse> observableFuture = RxHelper.observableFuture();
    elasticSearchService.get(index, type, id, options, observableFuture.toHandler());
    return observableFuture;
}
 

/**
 * Like {@link #deployVerticle(Vertx, Verticle)}, but {@link io.vertx.core.DeploymentOptions} are provided to configure the
 * deployment.
 *
 * @param vertx the vertx instance
 * @param verticle the verticle instance to deploy
 * @param options the deployment options.
 * @return the response observable
 */
public static Observable<String> deployVerticle(Vertx vertx, Verticle verticle, DeploymentOptions options) {
  ObservableFuture<String> completionHandler = io.vertx.rx.java.RxHelper.observableFuture();
  vertx.getDelegate().deployVerticle(verticle, options, completionHandler.toHandler());
  return completionHandler;
}