// Indicates if sub-sys supports multiple targets.
	MultipleTargets bool `json:"multipleTargets"`
}

// HelpKVS - implement order of keys help messages.
type HelpKVS []HelpKV

// Lookup - lookup a key from help kvs.
func (hkvs HelpKVS) Lookup(key string) (HelpKV, bool) {
	for _, hkv := range hkvs {
		if hkv.Key == key {
			return hkv, true
		}
	}
	return HelpKV{}, false
}

// DefaultComment used across all sub-systems.

        // we carry over only "resident" things
        shadow.containerCapsule = mavenContext.containerCapsule;
        shadow.lookup = mavenContext.lookup;
        shadow.eventSpyDispatcher = mavenContext.eventSpyDispatcher;
        shadow.simplexTransferListener = mavenContext.simplexTransferListener;
        shadow.maven = mavenContext.maven;

    @Mock
    private Lookup lookup;

    @BeforeEach
    void onSetup() throws Exception {
        MockitoAnnotations.initMocks(this);

        Map<String, ToolchainFactory> factories = new HashMap<>();
        factories.put("basic", toolchainFactoryBasicType);
        factories.put("rare", toolchainFactoryRareType);

        when(lookup.lookupMap(ToolchainFactory.class)).thenReturn(factories);

    public Slf4jConfiguration.Level loggerLevel;
    public Boolean coloredOutput;
    public Terminal terminal;
    public Consumer<String> writer;

    public ContainerCapsule containerCapsule;
    public Lookup lookup;
    public EventSpyDispatcher eventSpyDispatcher;

    public BuildEventListener buildEventListener;

    // paths user can override from CLI, and we need to set on MavenExReq

import org.apache.maven.api.services.Lookup;

/**
 * Container capsule.
 */
public interface ContainerCapsule extends AutoCloseable {
    /**
     * Updates the existing capsule logging setup.
     */
    void updateLogging(LookupContext context);

    /**
     * The {@link Lookup} service backed by container in this capsule.
     */
    @Nonnull
    Lookup getLookup();

    /**

     */
    default MessageBuilderFactory messageBuilderFactory() {
        return parserRequest().messageBuilderFactory();
    }

    /**
     * Shorthand for {@link Lookup}.
     */
    default Lookup lookup() {
        return parserRequest().lookup();
    }

    /**
     * Returns a map of user-defined properties for the Maven execution.
     * These properties can be set using the -D command-line option.
     *

- CoreDNS (for DNS management based on populated bucket DNS service records, optional)

## Architecture

![bucket-lookup](https://github.com/minio/minio/blob/master/docs/federation/lookup/bucket-lookup.png?raw=true)

### Environment variables

#### MINIO_ETCD_ENDPOINTS

This is comma separated list of etcd servers that you want to use as the MinIO federation back-end. This should

 * fallbacks to guarantee that a fallback address is available.
 */
class DoubleInetAddressDns : Dns {
  override fun lookup(hostname: String): List<InetAddress> {
    val addresses = Dns.SYSTEM.lookup(hostname)
    return listOf(addresses[0], addresses[0])
  }

    }

    protected void lookup(C context) throws Exception {
        if (context.eventSpyDispatcher == null) {
            context.eventSpyDispatcher = context.lookup.lookup(EventSpyDispatcher.class);
        }
    }

    protected void init(C context) throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("plexus", context.lookup.lookup(PlexusContainer.class));

 *
 *  * A DNS lookup failed
 *  * The configuration is incapable of carrying the request, such as when the client is configured
 *    to use `H2_PRIOR_KNOWLEDGE` but the URL's scheme is `https:`.
 *  * Preemptive proxy authentication failed.
 *
 * Planning failures are not necessarily fatal. For example, even if we can't DNS lookup the first
 * proxy in a list, looking up a subsequent one may succeed.