/**
 * Exception occurring trying to resolve a plugin.
 *
 */
public class ExtensionResolutionException extends Exception {

    private final CoreExtension extension;

    public ExtensionResolutionException(CoreExtension extension, Throwable cause) {
        super(
                "Extension " + extension.getId() + " or one of its dependencies could not be resolved: "
                        + cause.getMessage(),

     * <p>
     * Initially, the SIDs within each ACE will not be resolved however when
     * <code>getType()</code>, <code>getDomainName()</code>, <code>getAccountName()</code>,
     * or <code>toString()</code> is called, the names will attempt to be
     * resolved. If the names cannot be resolved (e.g. due to temporary
     * network failure), the said methods will return default values (usually

import java.io.File;

/**
 * A path translator that resolves relative paths against a specific base directory.
 *
 */
public class BasedirBeanConfigurationPathTranslator implements BeanConfigurationPathTranslator {

    private final File basedir;

    /**
     * Creates a new path translator using the specified base directory.
     *
     * @param basedir The base directory to resolve relative paths against, may be {@code null} to disable path

     * @param queryLogReader The query log reader
     * @param docPerReq The number of documents to process per request
     * @param requestInterval The interval between requests
     * @return A Promise that will be resolved with the SuggestIndexResponse
     */
    public Deferred<SuggestIndexResponse>.Promise indexFromQueryLog(final ContentIndexingContext ctx, final QueryLogReader queryLogReader,

     * Constructs a new request.
     */
    public Request() {
        // nothing
    }

    /**
     * Executes the request.
     * @param client The OpenSearch client.
     * @return A Promise that will be resolved with the response or rejected with an error.
     */
    public Deferred<T>.Promise execute(final Client client) {
        final String error = getValidationError();
        if (!Strings.isNullOrEmpty(error)) {

    private final CountDownLatch latch = new CountDownLatch(1);

    /**
     * Resolves the deferred computation with the given response.
     * @param r The response.
     */
    public void resolve(final RESPONSE r) {
        final ArrayList<Consumer<RESPONSE>> executeCallbacks;
        synchronized (Deferred.this) {

        return interpolate(model, context, true);
    }

    /**
     * Serialize the inbound Model instance to a StringWriter, perform the regex replacement to resolve
     * POM expressions, then re-parse into the resolved Model instance.
     * <p>
     * <b>NOTE:</b> This will result in a different instance of Model being returned!!!
     *

    <configuration>
      <![CDATA[
<dependencies>
  ...
</dependencies>
    ]]></configuration>
    <description>
      <![CDATA[
      This is a set of Artifact instances resolved from the set of dependencies for
      the current project.

      NOTE: This will likely contain much more than the direct dependencies of the
      current POM, since Maven uses transitive, or chained, dependency resolution.

     * </p>
     * <p>
     * This method is the foundation for {@link SourceRoot#targetPath(Project)} path resolution.
     * When a {@link SourceRoot} has a relative {@code targetPath}, it is resolved against the
     * output directory returned by this method for the source root's scope. This ensures that:
     * </p>
     * <ul>

    }

    /**
     * Registers internal distribution resolutions.
     * <p>
     * Elasticsearch distributions are resolved as project dependencies either representing
     * the current version pointing to a project either under `:distribution:archives` or :distribution:packages`.
     * <p>
     * BWC versions are resolved as project to projects under `:distribution:bwc`.
     */