How to use org.apache.james.backends.es

public static Client applyMapping(Client client, IndexName indexName, TypeName typeName, XContentBuilder mappingsSources) {
  if (!mappingAlreadyExist(client, indexName, typeName)) {
    createMapping(client, indexName, typeName, mappingsSources);
  }
  return client;
}

public Future<Void> deleteAllMatchingQuery(QueryBuilder queryBuilder) {
  return deleteByQueryPerformer.perform(queryBuilder);
}

public static Client prepareClient(Client client,
                  ReadAliasName readAlias,
                  WriteAliasName writeAlias,
                  IndexName indexName) {
  return NodeMappingFactory.applyMapping(
    new IndexCreationFactory()
      .useIndex(indexName)
      .addAlias(readAlias)
      .addAlias(writeAlias)
      .createIndexAndAliases(client),
    indexName,
    MailboxElasticSearchConstants.MESSAGE_TYPE,
    MailboxMappingFactory.getMappingContent());
}

protected Void doDeleteByQuery(QueryBuilder queryBuilder) {
  new ScrollIterable(client,
    client.prepareSearch(aliasName.getValue())
      .setTypes(typeName.getValue())
      .setScroll(TIMEOUT)
      .setNoFields()
      .setQuery(queryBuilder)
      .setSize(batchSize))
    .stream()
    .map(searchResponse -> deleteRetrievedIds(client, searchResponse))
    .forEach(ListenableActionFuture::actionGet);
  return null;
}

public IndexResponse index(String id, String content) {
  checkArgument(content);
  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug("Indexing {}: {}", id, StringUtils.left(content, DEBUG_MAX_LENGTH_CONTENT));
  }
  return client.prepareIndex(aliasName.getValue(), typeName.getValue(), id)
    .setSource(content)
    .get();
}

private void createAliasIfNeeded(Client client, IndexName indexName, AliasName aliasName) {
  if (!aliasExist(client, aliasName)) {
    client.admin()
      .indices()
      .aliases(new IndicesAliasesRequest()
        .addAlias(aliasName.getValue(), indexName.getValue()))
      .actionGet();
  }
}

public static void createMapping(Client client, IndexName indexName, TypeName typeName, XContentBuilder mappingsSources) {
  client.admin()
    .indices()
    .preparePutMapping(indexName.getValue())
    .setType(typeName.getValue())
    .setSource(mappingsSources)
    .execute()
    .actionGet();
}

private ListenableActionFuture<BulkResponse> deleteRetrievedIds(Client client, SearchResponse searchResponse) {
  BulkRequestBuilder bulkRequestBuilder = client.prepareBulk();
  for (SearchHit hit : searchResponse.getHits()) {
    bulkRequestBuilder.add(client.prepareDelete()
      .setIndex(aliasName.getValue())
      .setType(typeName.getValue())
      .setId(hit.getId()));
  }
  return bulkRequestBuilder.execute();
}

@Override
public void await() {
  embeddedElasticSearch.awaitForElasticSearch();
}

  public Node getNode() {
    return embeddedElasticSearch.getNode();
  }
}

private void handleEvent(User user, QuotaUsageUpdatedEvent event) throws JsonProcessingException {
  indexer.index(user.getUserName(), 
      quotaRatioToElasticSearchJson.convertToJson(user.getUserName(), event));
}

@Override
public void afterEach(ExtensionContext extensionContext) throws Exception {
  embeddedElasticSearch.after();
  folderExtension.afterEach(extensionContext);
}

@Override
public void beforeEach(ExtensionContext context) throws Exception {
  temporaryFolder.create();
  embeddedElasticSearch.before();
}

@VisibleForTesting
public ElasticSearchIndexer(Client client, ExecutorService executor,
              WriteAliasName aliasName,
              TypeName typeName,
              int batchSize) {
  this.client = client;
  this.deleteByQueryPerformer = new DeleteByQueryPerformer(client, executor, batchSize, aliasName, typeName);
  this.aliasName = aliasName;
  this.typeName = typeName;
}

public static ClientProviderImpl fromHosts(ImmutableList<Host> hosts) {
  Preconditions.checkNotNull(hosts, "Hosts should not be null");
  return new ClientProviderImpl(hosts);
}

public Future<Void> perform(QueryBuilder queryBuilder) {
  return executor.submit(() -> doDeleteByQuery(queryBuilder));
}

public static Client prepareClient(Client client,
                  AliasName readAlias,
                  AliasName writeAlias,
                  IndexName indexName) {
  return NodeMappingFactory.applyMapping(
    new IndexCreationFactory()
      .useIndex(indexName)
      .addAlias(readAlias)
      .addAlias(writeAlias)
      .createIndexAndAliases(client),
    indexName,
    QuotaRatioElasticSearchConstants.QUOTA_RATIO_TYPE,
    QuotaRatioMappingFactory.getMappingContent());
}

@Override
public void await() {
  embeddedElasticSearch.awaitForElasticSearch();
}

  @Override
  public void afterEach(ExtensionContext context) {
    embeddedElasticSearch.after();
    temporaryFolder.delete();
  }
}

@Override
protected void await() {
  embeddedElasticSearch.awaitForElasticSearch();
}