// based on image name.
func (dk *providersDockerKeyring) Lookup(image string) ([]AuthConfig, bool) {
	keyring := &BasicDockerKeyring{}

	for _, p := range dk.Providers {
		keyring.Add(p.Provide(image))
	}

	return keyring.Lookup(image)
}

// FakeKeyring a fake config credentials
type FakeKeyring struct {
	auth []AuthConfig
	ok   bool
}

        Fingerprint fingerprint = Fingerprint.wrap(bytes);
        PGPPublicKeyRing keyring = load().keyToKeyring.get(fingerprint);
        if (keyring != null) {
            builder.keyRing(keyring);
            Iterator<PGPPublicKey> pkIt = keyring.getPublicKeys();
            while (pkIt.hasNext()) {
                PGPPublicKey key = pkIt.next();

        }
    }

    /**
     * A response was sent from the server. This is a keyring, we need to find
     * within the keyring the matching key.
     */
    private void findMatchingKey(long id, PGPPublicKeyRing keyRing, PublicKeyResultBuilder builder) {
        for (PGPPublicKey publicKey : keyRing) {
            if (publicKey.getKeyID() == id) {
                builder.publicKey(publicKey);

		},
	}

	for _, testcase := range testcases {
		t.Run(testcase.name, func(t *testing.T) {
			keyring, err := MakeDockerKeyring(testcase.pullSecrets, testcase.defaultKeyring)
			if err != nil {
				t.Fatalf("error creating secret-based docker keyring: %v", err)
			}

			authConfigs, found := keyring.Lookup(testcase.image)
			if found != testcase.found {
				t.Logf("actual lookup status: %v", found)

    @Nullable
    private PGPSecretKey findSecretKey(PGPSecretKeyRingCollection keyRings, PgpKeyId keyId) {
        Iterator<PGPSecretKeyRing> keyRingIterator = uncheckedCast(keyRings.getKeyRings());
        while (keyRingIterator.hasNext()) {
            PGPSecretKeyRing keyRing = keyRingIterator.next();
            Iterator<PGPSecretKey> secretKeyIterator = uncheckedCast(keyRing.getSecretKeys());
            while (secretKeyIterator.hasNext()) {

        given:
        def keyringFile = new File(this.class.getResource("/keyrings/valid-with-extra-metadata.keys").getFile())

        when:
        def keyrings = SecuritySupport.loadKeyRingFile(keyringFile)

        then:
        keyrings.size() == 5
        keyrings.forEach { keyRing ->
            keyRing.publicKeys.forEachRemaining { publicKey ->
                assert publicKey.getUserAttributes().size() == 0

	for _, key := range stringKeys {
		provider := providers[key]
		if provider.Enabled() {
			klog.V(4).Infof("Registering credential provider: %v", key)
			keyring.Providers = append(keyring.Providers, provider)
		}
	}

	return keyring

        private FirstMatchBuilder(PublicKeyResultBuilder delegate) {
            this.delegate = delegate;
        }

        @Override
        public void keyRing(PGPPublicKeyRing keyring) {
            delegate.keyRing(keyring);
            hasResult = true;
        }

        @Override
        public void publicKey(PGPPublicKey publicKey) {
            delegate.publicKey(publicKey);

            } else {
                PgpKeyId expectedKeyId = new PgpKeyId(keyId);
                for (PGPSecretKeyRing keyring : new JcaPGPSecretKeyRingCollection(in)) {
                    for (PGPSecretKey key : keyring) {
                        if (expectedKeyId.equals(new PgpKeyId(key.getKeyID()))) {
                            return factory.createSignatory(name, key, password);

	RBDPool      *string                            `json:"pool,omitempty"`
	RadosUser    *string                            `json:"user,omitempty"`
	Keyring      *string                            `json:"keyring,omitempty"`
	SecretRef    *SecretReferenceApplyConfiguration `json:"secretRef,omitempty"`
	ReadOnly     *bool                              `json:"readOnly,omitempty"`
}