/**
     * Lookup addresses for the given <tt>hostname</tt>.
     * 
     * @param hostname
     * @param possibleNTDomainOrWorkgroup
     * @return found addresses
     * @throws UnknownHostException
     */
    Address[] getAllByName ( String hostname, boolean possibleNTDomainOrWorkgroup ) throws UnknownHostException;


    /**

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

/**
 * Container capsule.
 */
public interface ContainerCapsule extends AutoCloseable {
    /**
     * The {@link Lookup} service backed by container in this capsule.
     */
    @Nonnull
    Lookup getLookup();

    /**
     * Performs a clean shutdown of backing container.
     */
    @Override

        if (getContainer().hasComponent(ProjectBuilder.class, "test")) {
            projectBuilder = getContainer().lookup(ProjectBuilder.class, "test");
        } else {
            // default over to the main project builder...
            projectBuilder = getContainer().lookup(ProjectBuilder.class);
        }
    }

    protected ProjectBuilder getProjectBuilder() {
        return projectBuilder;
    }

		return User{
			ID:      userid,
			Enabled: false,
		}, nil
	case http.StatusUnauthorized:
		return User{}, ErrAccessTokenExpired
	}
	return User{}, fmt.Errorf("Unable to lookup - keycloak user lookup returned %v", resp.Status)
}

// Option is a function type that accepts a pointer Target
type Option func(*KeycloakProvider)

// WithTransport provide custom transport

## 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])
  }

func (kvs KVS) LookupKV(key string) (KV, bool) {
	for _, kv := range kvs {
		if kv.Key == key {
			return kv, true
		}
	}
	return KV{}, false
}

// Lookup - lookup a key in a list of KVS
func (kvs KVS) Lookup(key string) (string, bool) {
	for _, kv := range kvs {
		if kv.Key == key {
			return kv.Value, true
		}
	}
	return "", false
}

// Config - MinIO server config structure.

            shadow.logger = logger;
            shadow.loggerFactory = loggerFactory;
            shadow.loggerLevel = loggerLevel;
            shadow.containerCapsule = containerCapsule;
            shadow.lookup = lookup;
            shadow.settingsBuilder = settingsBuilder;

            shadow.interactive = interactive;
            shadow.localRepositoryPath = localRepositoryPath;

    @BeforeEach
    public void setUp() throws Exception {
        super.setUp();

        ArtifactResolver resolver = getContainer().lookup(ArtifactResolver.class, "classpath");
        DefaultArtifactDescriptorReader pomReader =
                (DefaultArtifactDescriptorReader) getContainer().lookup(ArtifactDescriptorReader.class);
        Field field = DefaultArtifactDescriptorReader.class.getDeclaredField("artifactResolver");

                this.session,
                null,
                this.getClass().getName(),
                getContainer().lookup(ArtifactResolver.class),
                getContainer().lookup(VersionRangeResolver.class),
                getContainer().lookup(RemoteRepositoryManager.class),
                Arrays.asList(newTestRepository()));
    }