Generic/dynamic resource client about dotnet-kube-client HOT 14 OPEN

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace KubeClient.Metadata
{
    using Models;

    public sealed class KubeMetadataCache
    {
        static readonly IReadOnlyCollection<string> ApiGroupPrefixes = new string[] { "api", "apis" };

        readonly object _stateLock = new object();

        readonly Dictionary<string, KubeApiMetadata> _metadata = new Dictionary<string, KubeApiMetadata>();

        public KubeMetadataCache()
        {
        }

        public bool IsEmpty
        {
            get
            {
                lock (_stateLock)
                {
                    return _metadata.Count == 0;
                }
            }
        }

        public KubeApiMetadata Get<TModel>()
            where TModel : KubeObjectV1
        {
            return Get(
                typeof(TModel)
            );
        }

        public KubeApiMetadata Get(Type modelType)
        {
            if (modelType == null)
                throw new ArgumentNullException(nameof(modelType));

            (string kind, string apiVersion) = KubeObjectV1.GetKubeKind(modelType);
            if (String.IsNullOrWhiteSpace(kind))
                throw new ArgumentException($"Model type {modelType.FullName} has not been decorated with KubeResourceAttribute or KubeResourceListAttribute.", nameof(modelType));

            return Get(kind, apiVersion);
        }

        public KubeApiMetadata Get(string kind, string apiVersion)
        {
            if (String.IsNullOrWhiteSpace(kind))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'kind'.", nameof(kind));

            if (String.IsNullOrWhiteSpace(apiVersion))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'apiVersion'.", nameof(apiVersion));

            lock (_stateLock)
            {
                string cacheKey = CreateCacheKey(kind, apiVersion);
                if (_metadata.TryGetValue(cacheKey, out KubeApiMetadata metadata))
                    return metadata;
            }

            return null;
        }

        public string GetPrimaryPath<TModel>()
            where TModel : KubeObjectV1
        {
            return GetPrimaryPath(
                typeof(TModel)
            );
        }

        public string GetPrimaryPath(Type modelType)
        {
            if (modelType == null)
                throw new ArgumentNullException(nameof(modelType));
            
            (string kind, string apiVersion) = KubeObjectV1.GetKubeKind(modelType);
            if (String.IsNullOrWhiteSpace(kind))
                throw new ArgumentException($"Model type {modelType.FullName} has not been decorated with KubeResourceAttribute or KubeResourceListAttribute.", nameof(modelType));

            return GetPrimaryPath(kind, apiVersion);
        }

        public string GetPrimaryPath(string kind, string apiVersion)
        {
            if (String.IsNullOrWhiteSpace(kind))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'kind'.", nameof(kind));

            if (String.IsNullOrWhiteSpace(apiVersion))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'apiVersion'.", nameof(apiVersion));

            lock (_stateLock)
            {
                KubeApiMetadata metadata = Get(kind, apiVersion);
                if (metadata == null)
                    throw new KeyNotFoundException($"No API metadata found for '{kind}/{apiVersion}'");

                return metadata.Paths.Select(pathMetadata => pathMetadata.Path).FirstOrDefault();
            }
        }

        public void Clear()
        {
            lock (_stateLock)
            {
                _metadata.Clear();
            }
        }

        public async Task Load(KubeApiClient kubeClient, CancellationToken cancellationToken = default)
        {
            if (kubeClient == null)
                throw new ArgumentNullException(nameof(kubeClient));

            var loadedMetadata = new List<KubeApiMetadata>();

            foreach (string apiGroupPrefix in ApiGroupPrefixes)
            {
                APIGroupListV1 apiGroups = await kubeClient.APIGroupsV1().List(apiGroupPrefix, cancellationToken);
                if (apiGroupPrefix == "api")
                {
                    // Special case for old-style ("api/v1") APIs.
                    apiGroups.Groups.Add(new APIGroupV1
                    {
                        Name = "Core",
                        PreferredVersion = new GroupVersionForDiscoveryV1
                        {
                            GroupVersion = "v1"
                        }
                    });
                }

                foreach (APIGroupV1 apiGroup in apiGroups.Groups)
                {
                    List<string> groupVersions = new List<string>();
                    if (apiGroupPrefix == "api")
                    {
                        groupVersions.Add("v1");
                    }
                    else
                    {
                        groupVersions.AddRange(
                            apiGroup.Versions.Select(
                                version => version.GroupVersion
                            )
                        );
                    }

                    foreach (string groupVersion in groupVersions)
                    {
                        APIResourceListV1 apis = await kubeClient.APIResourcesV1().List(apiGroupPrefix, groupVersion, cancellationToken);
                        foreach (var apisForKind in apis.Resources.GroupBy(api => api.Kind))
                        {
                            string kind = apisForKind.Key;

                            var apiPaths = new List<KubeApiPathMetadata>();

                            foreach (APIResourceV1 api in apisForKind)
                            {
                                string apiPath = $"{apiGroupPrefix}/{apiGroup.PreferredVersion.GroupVersion}/{api.Name}";

                                apiPaths.Add(
                                    new KubeApiPathMetadata(apiPath,
                                        verbs: api.Verbs.ToArray()
                                    )
                                );
                            }

                            loadedMetadata.Add(
                                new KubeApiMetadata(kind, groupVersion, apiPaths)
                            );
                        }
                    }
                }
            }

            lock (_stateLock)
            {
                _metadata.Clear();

                foreach (KubeApiMetadata apiMetadata in loadedMetadata)
                {
                    string cacheKey = CreateCacheKey(apiMetadata.Kind, apiMetadata.ApiVersion);
                    _metadata[cacheKey] = apiMetadata;
                }
            }
        }

        static string CreateCacheKey(string kind, string apiVersion)
        {
            if (String.IsNullOrWhiteSpace(kind))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'kind'.", nameof(kind));

            if (String.IsNullOrWhiteSpace(apiVersion))
                throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'apiVersion'.", nameof(apiVersion));

            return $"{apiVersion}/{kind}";
        }
    }

    public class KubeApiMetadata
    {
        public KubeApiMetadata(string kind, string apiVersion, IReadOnlyList<KubeApiPathMetadata> paths)
        {
            Kind = kind;
            ApiVersion = apiVersion;
            Paths = paths;
        }

        public string Kind { get; }
        public string ApiVersion { get; }
        public IReadOnlyList<KubeApiPathMetadata> Paths { get; }
    }

    public class KubeApiPathMetadata
    {
        public KubeApiPathMetadata(string path, IReadOnlyCollection<string> verbs)
        {
            Path = path;
            Verbs = verbs;
        }

        public string Path { get; }
        public IReadOnlyCollection<string> Verbs { get; }
    }
}