def keyring = newKeyRing()
        keyServerFixture.registerPublicKey(keyring.publicKey)
        def pkId = toHexString(keyring.publicKey.fingerprint)
        createMetadataFile {
            keyServer(keyServerFixture.uri)
            verifySignatures()
            // only the new keyring key is published and available

        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

        generator
    }

    private static class Holder {
        static final KeyRing VALID_KEYRING = new KeyRing("gradle")
        static final KeyRing INVALID_KEYRING = new KeyRing("invalid-key-ring")
    }

    private static class KeyRing {
        private final PgpSignatory signatory
        private final PGPPublicKey publicKey
        private final PGPSecretKey secretKey

	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"`
}

[source,bash]
----
$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 8756c4f765c9ac3cb6b85d62379ce192d401ab61

gpg: keybox 'gradle/verification-keyring.gpg' created
gpg: key 379CE192D401AB61: public key "Bintray (by JFrog) <****>" imported
gpg: Total number processed: 1
gpg:               imported: 1

import javax.annotation.Nullable;
import java.io.File;

public class BuildTreeDefinedKeys {
    private static final String VERIFICATION_KEYRING_GPG = "verification-keyring.gpg";
    private static final String VERIFICATION_KEYRING_ASCII = "verification-keyring.keys";

    private final KeyringFilePublicKeyService keyService;
    private final File keyringsRoot;

    private final File effectiveKeyringsFile;

	return b
}

// WithKeyring sets the Keyring field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Keyring field is set to the value of the last call.
func (b *RBDVolumeSourceApplyConfiguration) WithKeyring(value string) *RBDVolumeSourceApplyConfiguration {
	b.Keyring = &value
	return b
}