return []string{s.keyID}, "", nil
	}
	return []string{}, "", nil
}

// CreateKey returns ErrKeyExists unless req.Name is equal to the secretKey name.
// The builtin KMS does not support creating multiple keys.
func (s secretKey) CreateKey(_ context.Context, req *CreateKeyRequest) error {
	if req.Name != s.keyID {
		return ErrNotSupported
	}
	return ErrKeyExists
}

            throws PluginResolutionException, PluginDescriptorParsingException, InvalidPluginDescriptorException {
        PluginDescriptorCache.Key cacheKey = pluginDescriptorCache.createKey(plugin, repositories, session);

        PluginDescriptor pluginDescriptor = pluginDescriptorCache.get(cacheKey, () -> {
            org.eclipse.aether.artifact.Artifact artifact =

    private Map<Key, Key> keys = new ConcurrentHashMap<>();

    public void flush() {
        descriptors.clear();
    }

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
    }

        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();
    protected final Map<Key, Key> keys = new ConcurrentHashMap<>();

    @Override
    public Key createKey(
            MavenProject project,
            Collection<String> scopesToCollect,
            Collection<String> scopesToResolve,
            boolean aggregating,
            RepositorySystemSession session) {

        if (logger.isDebugEnabled()) {
            logger.debug("Extension realms for project " + model.getId() + ": " + extensionRealms);
        }

        ProjectRealmCache.Key projectRealmKey = projectRealmCache.createKey(extensionRealms);

        ProjectRealmCache.CacheRecord record = projectRealmCache.get(projectRealmKey);

        if (record == null) {

	if objectAPI == nil {
		return
	}

	if GlobalKMS == nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrKMSNotConfigured), r.URL)
		return
	}

	if err := GlobalKMS.CreateKey(ctx, &kms.CreateKeyRequest{Name: r.Form.Get("key-id")}); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	writeSuccessResponseHeadersOnly(w)
}

            boolean aggregating,
            Set<Artifact> projectArtifacts)
            throws LifecycleExecutionException {
        ProjectArtifactsCache.Key cacheKey = projectArtifactsCache.createKey(
                project, scopesToCollect, scopesToResolve, aggregating, session.getRepositorySession());

        ProjectArtifactsCache.CacheRecord recordArtifacts;

        const std::string dst_device =
            absl::StrCat(task_prefix, "/device:CPU:0");
        const std::string& rendezvous_key =
            Rendezvous::CreateKey(src_device, /*src_incarnation=*/1, dst_device,
                                  rendezvous_key_base, FrameAndIter(0, 0));
        VLOG(2) << "Rendezvous Key for receiving at host: " << rendezvous_key;

// using Google Test have exited when main() returns.
template <typename T>
class ThreadLocal {
 public:
  ThreadLocal() : key_(CreateKey()),
                  default_() {}
  explicit ThreadLocal(const T& value) : key_(CreateKey()),
                                         default_(value) {}

  ~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.

	})
	if err != nil {
		logger.Fatal(err, "Failed to connect to KMS")
	}

	if _, err = KMS.GenerateKey(GlobalContext, &kms.GenerateKeyRequest{}); errors.Is(err, kms.ErrKeyNotFound) {
		err = KMS.CreateKey(GlobalContext, &kms.CreateKeyRequest{Name: KMS.DefaultKey})
	}
	if err != nil && !errors.Is(err, kms.ErrKeyExists) && !errors.Is(err, kms.ErrPermission) {
		logger.Fatal(err, "Failed to connect to KMS")
	}