How to use

actionGet

method

in

org.elasticsearch.action.support.PlainActionFuture

private Transport.Connection internalOpenConnection(DiscoveryNode node, ConnectionProfile connectionProfile) {
  PlainActionFuture<Transport.Connection> future = PlainActionFuture.newFuture();
  Releasable pendingConnection = transport.openConnection(node, connectionProfile, future);
  Transport.Connection connection;
  try {
    connection = future.actionGet();
  } catch (IllegalStateException e) {
    // If the future was interrupted we must cancel the pending connection to avoid channels leaking
    if (e.getCause() instanceof InterruptedException) {
      pendingConnection.close();
    }
    throw e;
  }
  try {
    connectionListener.onConnectionOpened(connection);
  } finally {
    connection.addCloseListener(ActionListener.wrap(() -> connectionListener.onConnectionClosed(connection)));
  }
  if (connection.isClosed()) {
    throw new ConnectTransportException(node, "a channel closed while connecting");
  }
  return connection;
}

private static <S extends ESSelector> void startSelectors(Iterable<S> selectors, ThreadFactory threadFactory) {
  for (ESSelector acceptor : selectors) {
    if (acceptor.isRunning() == false) {
      threadFactory.newThread(acceptor::runLoop).start();
      acceptor.isRunningFuture().actionGet();
    }
  }
}

  protected QueryBuilder rewriteAndFetch(QueryBuilder builder, QueryRewriteContext context) throws IOException {
    PlainActionFuture<QueryBuilder> future = new PlainActionFuture<>();
    Rewriteable.rewriteAndFetch(builder, context, future);
    return future.actionGet();
  }
}

@Override
protected void doRun() throws Exception {
  go.await();
  for (int iter = 0; iter < 10; iter++) {
    PlainActionFuture<TestResponse> listener = new PlainActionFuture<>();
    final String info = sender + "_B_" + iter;
    serviceB.sendRequest(nodeA, "test", new TestRequest(info),
      new ActionListenerResponseHandler<>(listener, TestResponse::new));
    try {
      listener.actionGet();
    } catch (Exception e) {
      logger.trace(
        (Supplier<?>) () -> new ParameterizedMessage("caught exception while sending to node {}", nodeA), e);
    }
  }
}

@Override
protected void doRun() throws Exception {
  go.await();
  for (int iter = 0; iter < 10; iter++) {
    PlainActionFuture<TestResponse> listener = new PlainActionFuture<>();
    final String info = sender + "_" + iter;
    final DiscoveryNode node = nodeB; // capture now
    try {
      serviceA.sendRequest(node, "test", new TestRequest(info),
        new ActionListenerResponseHandler<>(listener, TestResponse::new));
      try {
        listener.actionGet();
      } catch (ConnectTransportException e) {
        // ok!
      } catch (Exception e) {
        logger.error(
          (Supplier<?>) () -> new ParameterizedMessage("caught exception while sending to node {}", node), e);
        sendingErrors.add(e);
      }
    } catch (NodeNotConnectedException ex) {
      // ok
    }
  }
}

@Override
public void parse(ParseContext context) throws IOException {
  QueryShardContext queryShardContext = this.queryShardContext.get();
  if (context.doc().getField(queryBuilderField.name()) != null) {
    // If a percolator query has been defined in an array object then multiple percolator queries
    // could be provided. In order to prevent this we fail if we try to parse more than one query
    // for the current document.
    throw new IllegalArgumentException("a document can only contain one percolator query");
  }
  XContentParser parser = context.parser();
  QueryBuilder queryBuilder = parseQueryBuilder(
      parser, parser.getTokenLocation()
  );
  verifyQuery(queryBuilder);
  // Fetching of terms, shapes and indexed scripts happen during this rewrite:
  PlainActionFuture<QueryBuilder> future = new PlainActionFuture<>();
  Rewriteable.rewriteAndFetch(queryBuilder, queryShardContext, future);
  queryBuilder = future.actionGet();
  Version indexVersion = context.mapperService().getIndexSettings().getIndexVersionCreated();
  createQueryBuilderField(indexVersion, queryBuilderField, queryBuilder, context);
  QueryBuilder queryBuilderForProcessing = queryBuilder.rewrite(new QueryShardContext(queryShardContext) {
    @Override
    public boolean convertNowRangeToMatchAll() {
      return true;
    }
  });
  Query query = toQuery(queryShardContext, isMapUnmappedFieldAsText(), queryBuilderForProcessing);
  processQuery(query, context);
}

@Override
public void parse(ParseContext context) throws IOException {
  QueryShardContext queryShardContext = this.queryShardContext.get();
  if (context.doc().getField(queryBuilderField.name()) != null) {
    // If a percolator query has been defined in an array object then multiple percolator queries
    // could be provided. In order to prevent this we fail if we try to parse more than one query
    // for the current document.
    throw new IllegalArgumentException("a document can only contain one percolator query");
  }
  XContentParser parser = context.parser();
  QueryBuilder queryBuilder = parseQueryBuilder(
      parser, parser.getTokenLocation()
  );
  verifyQuery(queryBuilder);
  // Fetching of terms, shapes and indexed scripts happen during this rewrite:
  PlainActionFuture<QueryBuilder> future = new PlainActionFuture<>();
  Rewriteable.rewriteAndFetch(queryBuilder, queryShardContext, future);
  queryBuilder = future.actionGet();
  Version indexVersion = context.mapperService().getIndexSettings().getIndexVersionCreated();
  createQueryBuilderField(indexVersion, queryBuilderField, queryBuilder, context);
  QueryBuilder queryBuilderForProcessing = queryBuilder.rewrite(new QueryShardContext(queryShardContext) {
    @Override
    public boolean convertNowRangeToMatchAll() {
      return true;
    }
  });
  Query query = toQuery(queryShardContext, isMapUnmappedFieldAsText(), queryBuilderForProcessing);
  processQuery(query, context);
}