kubernetes-client/csharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial port of cache functions from java client (#665)

Browse Source 
* Initial port of cache functions from java client

* Move lock in Cache.Replace to be less disruptive

* Remove IListerWatcher as it's not used at the moment

* Added todo in Cache.Get as reminder

* TApiType implement IKubernetesObject

* TApiType implement IKubernetesObject

* TApiType implement class along with IKubernetesObject

* Disable failing test until it can be figured out

* Ran `dotnet format --fix-whitespace --fix-style` to put formatting in compliance

* Moved contents of KubernetesClient.Util into KubernetesClient project

* Moved contents of KubernetesClient.Util into KubernetesClient project #2 :(
This commit is contained in:
David Dieruf
2021-08-04 10:51:25 -04:00
committed by GitHub
parent 0f0fc1a059
commit af53bf3cec
20 changed files with 1519 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/KubernetesClient/KubernetesClient.csproj
View File

@@ -45,4 +45,8 @@
<PackageReference Include="IdentityModel.OidcClient" Version="3.1.2" />
</ItemGroup>
<ItemGroup>
<Folder Include="Util\Informer" />
</ItemGroup>
</Project>

16
src/KubernetesClient/Util/Common/CallGeneratorParams.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace k8s.Util.Common
{
public class CallGeneratorParams
{
public bool Watch { get; }
public string ResourceVersion { get; }
public int? TimeoutSeconds { get; }
public CallGeneratorParams(bool watch, string resourceVersion, int? timeoutSeconds)
{
Watch = watch;
ResourceVersion = resourceVersion;
TimeoutSeconds = timeoutSeconds;
}
}
}

43
src/KubernetesClient/Util/Common/CollectionsExtensions.cs Normal file
View File

@@ -0,0 +1,43 @@
using System;
using System.Collections.Generic;
namespace k8s.Util.Common
{
internal static class CollectionsExtensions
{
public static void AddRange<T>(this HashSet<T> hashSet, ICollection<T> items)
{
if (items == null)
{
return;
}
foreach (var item in items)
{
hashSet?.Add(item);
}
}
internal static TValue ComputeIfAbsent<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TValue> mappingFunction)
{
if (dictionary is null)
{
throw new ArgumentNullException(nameof(dictionary));
}
if (dictionary.TryGetValue(key, out var value))
{
return value;
}
if (mappingFunction == null)
{
throw new ArgumentNullException(nameof(mappingFunction));
}
var newKey = mappingFunction(key);
dictionary[key] = newKey;
return newKey;
}
}
}

431
src/KubernetesClient/Util/Informer/Cache/Cache.cs Normal file
View File

@@ -0,0 +1,431 @@
using System;
using System.Collections.Generic;
using System.Linq;
using k8s.Models;
using k8s.Util.Common;
namespace k8s.Util.Informer.Cache
{
/// <summary>
/// Cache is a C# port of Java's Cache which is a port of k/client-go's ThreadSafeStore. It basically saves and indexes all the entries.
/// </summary>
/// <typeparam name="TApiType">The type of K8s object to save</typeparam>
public class Cache<TApiType> : IIndexer<TApiType>
where TApiType : class, IKubernetesObject<V1ObjectMeta>
{
/// <summary>
/// keyFunc defines how to map index objects into indices
/// </summary>
private Func<TApiType, string> _keyFunc;
/// <summary>
/// indexers stores index functions by their names
/// </summary>
/// <remarks>The indexer name(string) is a label marking the different ways it can be calculated.
/// The default label is "namespace". The default func is to look in the object's metadata and combine the
/// namespace and name values, as namespace/name.
/// </remarks>
private readonly Dictionary<string, Func<TApiType, List<string>>> _indexers = new Dictionary<string, Func<TApiType, List<string>>>();
/// <summary>
/// indices stores objects' keys by their indices
/// </summary>
/// <remarks>Similar to 'indexers', an indice has the same label as its corresponding indexer except it's value
/// is the result of the func.
/// if the indexer func is to calculate the namespace and name values as namespace/name, then the indice HashSet
/// holds those values.
/// </remarks>
private Dictionary<string, Dictionary<string, HashSet<string>>> _indices = new Dictionary<string, Dictionary<string, HashSet<string>>>();
/// <summary>
/// items stores object instances
/// </summary>
/// <remarks>Indices hold the HashSet of calculated keys (namespace/name) for a given resource and items map each of
/// those keys to actual K8s object that was originally returned.</remarks>
private Dictionary<string, TApiType> _items = new Dictionary<string, TApiType>();
/// <summary>
/// object used to track locking
/// </summary>
/// <remarks>methods interacting with the store need to lock to secure the thread for race conditions,
/// learn more: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/lock-statement</remarks>
private readonly object _lock = new object();
public Cache()
: this(Caches.NamespaceIndex, Caches.MetaNamespaceIndexFunc, Caches.DeletionHandlingMetaNamespaceKeyFunc)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Cache{TApiType}"/> class.
/// Constructor.
/// </summary>
/// <param name="indexName">the index name, an unique name representing the index</param>
/// <param name="indexFunc">the index func by which we map multiple object to an index for querying</param>
/// <param name="keyFunc">the key func by which we map one object to an unique key for storing</param>
public Cache(string indexName, Func<TApiType, List<string>> indexFunc, Func<TApiType, string> keyFunc)
{
_indexers[indexName] = indexFunc;
_keyFunc = keyFunc;
_indices[indexName] = new Dictionary<string, HashSet<string>>();
}
/// <summary>
/// Add objects.
/// </summary>
/// <param name="obj">the obj</param>
public void Add(TApiType obj)
{
var key = _keyFunc(obj);
lock (_lock)
{
var oldObj = _items.GetValueOrDefault(key);
_items[key] = obj;
UpdateIndices(oldObj, obj, key);
}
}
/// <summary>
/// Update the object.
/// </summary>
/// <param name="obj">the obj</param>
public void Update(TApiType obj)
{
var key = _keyFunc(obj);
lock (_lock)
{
var oldObj = _items.GetValueOrDefault(key);
_items[key] = obj;
UpdateIndices(oldObj, obj, key);
}
}
/// <summary>
/// Delete the object.
/// </summary>
/// <param name="obj">the obj</param>
public void Delete(TApiType obj)
{
var key = _keyFunc(obj);
lock (_lock)
{
if (!_items.TryGetValue(key, out var value))
{
return;
}
DeleteFromIndices(value, key);
_items.Remove(key);
}
}
/// <summary>
/// Replace the content in the cache completely.
/// </summary>
/// <param name="list">the list</param>
/// <param name="resourceVersion">optional, unused param from interface</param>
/// <exception cref="ArgumentNullException">list is null</exception>
public void Replace(IEnumerable<TApiType> list, string resourceVersion = default)
{
if (list is null)
{
throw new ArgumentNullException(nameof(list));
}
var newItems = new Dictionary<string, TApiType>();
foreach (var item in list)
{
var key = _keyFunc(item);
newItems[key] = item;
}
lock (_lock)
{
_items = newItems;
// rebuild any index
_indices = new Dictionary<string, Dictionary<string, HashSet<string>>>();
foreach (var (key, value) in _items)
{
UpdateIndices(default, value, key);
}
}
}
/// <summary>
/// Resync.
/// </summary>
public void Resync()
{
// Do nothing by default
}
/// <summary>
/// List keys.
/// </summary>
/// <returns>the list</returns>
public IEnumerable<string> ListKeys()
{
return _items.Select(item => item.Key);
}
/// <summary>
/// Get object t.
/// </summary>
/// <param name="obj">the obj</param>
/// <returns>the t</returns>
public TApiType Get(TApiType obj)
{
var key = _keyFunc(obj);
lock (_lock)
{
// Todo: to make this lock striped or reader/writer (or use ConcurrentDictionary)
return _items.GetValueOrDefault(key);
}
}
/// <summary>
/// List all objects in the cache.
/// </summary>
/// <returns>all items</returns>
public IEnumerable<TApiType> List()
{
lock (_lock)
{
return _items.Select(item => item.Value);
}
}
/// <summary>
/// Get object t.
/// </summary>
/// <param name="key">the key</param>
/// <returns>the get by key</returns>
public TApiType GetByKey(string key)
{
lock (_lock)
{
_items.TryGetValue(key, out var value);
return value;
}
}
/// <summary>
/// Get objects.
/// </summary>
/// <param name="indexName">the index name</param>
/// <param name="obj">the obj</param>
/// <returns>the list</returns>
/// <exception cref="ArgumentException">indexers does not contain the provided index name</exception>
public IEnumerable<TApiType> Index(string indexName, TApiType obj)
{
if (!_indexers.ContainsKey(indexName))
{
throw new ArgumentException($"index {indexName} doesn't exist!", nameof(indexName));
}
lock (_lock)
{
var indexFunc = _indexers[indexName];
var indexKeys = indexFunc(obj);
var index = _indices.GetValueOrDefault(indexName);
if (index is null || index.Count == 0)
{
return new List<TApiType>();
}
var returnKeySet = new HashSet<string>();
foreach (var set in indexKeys.Select(indexKey => index.GetValueOrDefault(indexKey)).Where(set => set != null && set.Count != 0))
{
returnKeySet.AddRange(set);
}
var items = new List<TApiType>(returnKeySet.Count);
items.AddRange(returnKeySet.Select(absoluteKey => _items[absoluteKey]));
return items;
}
}
/// <summary>
/// Index keys list.
/// </summary>
/// <param name="indexName">the index name</param>
/// <param name="indexKey">the index key</param>
/// <returns>the list</returns>
/// <exception cref="ArgumentException">indexers does not contain the provided index name</exception>
/// <exception cref="KeyNotFoundException">indices collection does not contain the provided index name</exception>
public IEnumerable<string> IndexKeys(string indexName, string indexKey)
{
if (!_indexers.ContainsKey(indexName))
{
throw new ArgumentException($"index {indexName} doesn't exist!", nameof(indexName));
}
lock (_lock)
{
var index = _indices.GetValueOrDefault(indexName);
if (index is null)
{
throw new KeyNotFoundException($"no value could be found for name '{indexName}'");
}
return index[indexKey];
}
}
/// <summary>
/// By index list.
/// </summary>
/// <param name="indexName">the index name</param>
/// <param name="indexKey">the index key</param>
/// <returns>the list</returns>
/// <exception cref="ArgumentException">indexers does not contain the provided index name</exception>
/// <exception cref="KeyNotFoundException">indices collection does not contain the provided index name</exception>
public IEnumerable<TApiType> ByIndex(string indexName, string indexKey)
{
if (!_indexers.ContainsKey(indexName))
{
throw new ArgumentException($"index {indexName} doesn't exist!", nameof(indexName));
}
var index = _indices.GetValueOrDefault(indexName);
if (index is null)
{
throw new KeyNotFoundException($"no value could be found for name '{indexName}'");
}
var set = index[indexKey];
return set is null ? new List<TApiType>() : set.Select(key => _items[key]);
}
/// <summary>
/// Return the indexers registered with the cache.
/// </summary>
/// <returns>registered indexers</returns>
public IDictionary<string, Func<TApiType, List<string>>> GetIndexers() => _indexers;
/// <summary>
/// Add additional indexers to the cache.
/// </summary>
/// <param name="newIndexers">indexers to add</param>
/// <exception cref="ArgumentNullException">newIndexers is null</exception>
/// <exception cref="InvalidOperationException">items collection is not empty</exception>
/// <exception cref="ArgumentException">conflict between keys in existing index and new indexers provided</exception>
public void AddIndexers(IDictionary<string, Func<TApiType, List<string>>> newIndexers)
{
if (newIndexers is null)
{
throw new ArgumentNullException(nameof(newIndexers));
}
if (_items.Any())
{
throw new InvalidOperationException("cannot add indexers to a non-empty cache");
}
var oldKeys = _indexers.Keys;
var newKeys = newIndexers.Keys;
var intersection = oldKeys.Intersect(newKeys);
if (intersection.Any())
{
throw new ArgumentException("indexer conflict: " + intersection);
}
foreach (var (key, value) in newIndexers)
{
AddIndexFunc(key, value);
}
}
/// <summary>
/// UpdateIndices modifies the objects location in the managed indexes, if this is an update, you
/// must provide an oldObj.
/// </summary>
/// <remarks>UpdateIndices must be called from a function that already has a lock on the cache.</remarks>
/// <param name="oldObj"> the old obj</param>
/// <param name="newObj"> the new obj</param>
/// <param name="key">the key</param>
private void UpdateIndices(TApiType oldObj, TApiType newObj, string key)
{
// if we got an old object, we need to remove it before we can add
// it again.
if (oldObj != null)
{
DeleteFromIndices(oldObj, key);
}
foreach (var (indexName, indexFunc) in _indexers)
{
var indexValues = indexFunc(newObj);
if (indexValues is null || indexValues.Count == 0)
{
continue;
}
var index = _indices.ComputeIfAbsent(indexName, _ => new Dictionary<string, HashSet<string>>());
foreach (var indexValue in indexValues)
{
HashSet<string> indexSet = index.ComputeIfAbsent(indexValue, k => new HashSet<string>());
indexSet.Add(key);
index[indexValue] = indexSet;
}
}
}
/// <summary>
/// DeleteFromIndices removes the object from each of the managed indexes.
/// </summary>
/// <remarks>It is intended to be called from a function that already has a lock on the cache.</remarks>
/// <param name="oldObj">the old obj</param>
/// <param name="key">the key</param>
private void DeleteFromIndices(TApiType oldObj, string key)
{
foreach (var (s, indexFunc) in _indexers)
{
var indexValues = indexFunc(oldObj);
if (indexValues is null || indexValues.Count == 0)
{
continue;
}
var index = _indices.GetValueOrDefault(s);
if (index is null)
{
continue;
}
foreach (var indexSet in indexValues.Select(indexValue => index[indexValue]))
{
indexSet?.Remove(key);
}
}
}
/// <summary>
/// Add index func.
/// </summary>
/// <param name="indexName">the index name</param>
/// <param name="indexFunc">the index func</param>
public void AddIndexFunc(string indexName, Func<TApiType, List<string>> indexFunc)
{
_indices[indexName] = new Dictionary<string, HashSet<string>>();
_indexers[indexName] = indexFunc;
}
public Func<TApiType, string> KeyFunc => _keyFunc;
public void SetKeyFunc(Func<TApiType, string> keyFunc)
{
_keyFunc = keyFunc;
}
}
}

85
src/KubernetesClient/Util/Informer/Cache/Caches.cs Normal file
View File

@@ -0,0 +1,85 @@
using System;
using System.Collections.Generic;
using k8s.Models;
namespace k8s.Util.Informer.Cache
{
/// <summary>
/// A set of helper utilities for constructing a cache.
/// </summary>
public static class Caches
{
/// <summary>
/// NamespaceIndex is the default index function for caching objects
/// </summary>
public const string NamespaceIndex = "namespace";
/// <summary>
/// deletionHandlingMetaNamespaceKeyFunc checks for DeletedFinalStateUnknown objects before calling
/// metaNamespaceKeyFunc.
/// </summary>
/// <param name="obj">specific object</param>
/// <typeparam name="TApiType">the type parameter</typeparam>
/// <exception cref="ArgumentNullException">if obj is null</exception>
/// <returns>the key</returns>
public static string DeletionHandlingMetaNamespaceKeyFunc<TApiType>(TApiType obj)
where TApiType : class, IKubernetesObject<V1ObjectMeta>
{
if (obj is null)
{
throw new ArgumentNullException(nameof(obj));
}
if (obj.GetType() == typeof(DeletedFinalStateUnknown<TApiType>))
{
var deleteObj = obj as DeletedFinalStateUnknown<TApiType>;
return deleteObj.GetKey();
}
return MetaNamespaceKeyFunc(obj);
}
/// <summary>
/// MetaNamespaceKeyFunc is a convenient default KeyFunc which knows how to make keys for API
/// objects which implement V1ObjectMeta Interface. The key uses the format &lt;namespace&gt;/&lt;name&gt;
/// unless &lt;namespace&gt; is empty, then it's just &lt;name&gt;.
/// </summary>
/// <param name="obj">specific object</param>
/// <returns>the key</returns>
/// <exception cref="ArgumentNullException">if obj is null</exception>
/// <exception cref="InvalidOperationException">if metadata can't be found on obj</exception>
public static string MetaNamespaceKeyFunc(IKubernetesObject<V1ObjectMeta> obj)
{
if (obj is null)
{
throw new ArgumentNullException(nameof(obj));
}
if (!string.IsNullOrEmpty(obj.Metadata.NamespaceProperty))
{
return obj.Metadata.NamespaceProperty + "/" + obj.Metadata.Name;
}
return obj.Metadata.Name;
}
/// <summary>
/// MetaNamespaceIndexFunc is a default index function that indexes based on an object's namespace.
/// </summary>
/// <param name="obj">specific object</param>
/// <typeparam name="TApiType">the type parameter</typeparam>
/// <returns>the indexed value</returns>
/// <exception cref="ArgumentNullException">if obj is null</exception>
/// <exception cref="InvalidOperationException">if metadata can't be found on obj</exception>
public static List<string> MetaNamespaceIndexFunc<TApiType>(TApiType obj)
where TApiType : IKubernetesObject<V1ObjectMeta>
{
if (obj is null)
{
throw new ArgumentNullException(nameof(obj));
}
return obj.Metadata is null ? new List<string>() : new List<string>() { obj.Metadata.NamespaceProperty };
}
}
}

47
src/KubernetesClient/Util/Informer/Cache/DeletedFinalStateUnknown.cs Normal file
View File

@@ -0,0 +1,47 @@
using k8s.Models;
namespace k8s.Util.Informer.Cache
{
// DeletedFinalStateUnknown is placed into a DeltaFIFO in the case where
// an object was deleted but the watch deletion event was missed. In this
// case we don't know the final "resting" state of the object, so there's
// a chance the included `Obj` is stale.
public class DeletedFinalStateUnknown<TApi> : IKubernetesObject<V1ObjectMeta>
where TApi : class, IKubernetesObject<V1ObjectMeta>
{
private readonly string _key;
private readonly TApi _obj;
public DeletedFinalStateUnknown(string key, TApi obj)
{
_key = key;
_obj = obj;
}
public string GetKey() => _key;
/// <summary>
/// Gets get obj.
/// </summary>
/// <returns>the get obj</returns>
public TApi GetObj() => _obj;
public V1ObjectMeta Metadata
{
get => _obj.Metadata;
set => _obj.Metadata = value;
}
public string ApiVersion
{
get => _obj.ApiVersion;
set => _obj.ApiVersion = value;
}
public string Kind
{
get => _obj.Kind;
set => _obj.Kind = value;
}
}
}

30
src/KubernetesClient/Util/Informer/Cache/DeltaType.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace k8s.Util.Informer.Cache
{
public enum DeltaType
{
/// <summary>
/// Item added
/// </summary>
Added,
/// <summary>
/// Item updated
/// </summary>
Updated,
/// <summary>
/// Item deleted
/// </summary>
Deleted,
/// <summary>
/// Item synchronized
/// </summary>
Sync,
/// <summary>
/// Item replaced
/// </summary>
Replaced,
}
}

46
src/KubernetesClient/Util/Informer/Cache/IIndexer.cs Normal file
View File

@@ -0,0 +1,46 @@
using System;
using System.Collections.Generic;
using k8s.Models;
namespace k8s.Util.Informer.Cache
{
public interface IIndexer<TApiType> : IStore<TApiType>
where TApiType : class, IKubernetesObject<V1ObjectMeta>
{
/// <summary>
/// Retrieve list of objects that match on the named indexing function.
/// </summary>
/// <param name="indexName">specific indexing function</param>
/// <param name="obj"> . </param>
/// <returns>matched objects</returns>
IEnumerable<TApiType> Index(string indexName, TApiType obj);
/// <summary>
/// IndexKeys returns the set of keys that match on the named indexing function.
/// </summary>
/// <param name="indexName">specific indexing function</param>
/// <param name="indexKey">specific index key</param>
/// <returns>matched keys</returns>
IEnumerable<string> IndexKeys(string indexName, string indexKey);
/// <summary>
/// ByIndex lists object that match on the named indexing function with the exact key.
/// </summary>
/// <param name="indexName">specific indexing function</param>
/// <param name="indexKey">specific index key</param>
/// <returns>matched objects</returns>
IEnumerable<TApiType> ByIndex(string indexName, string indexKey);
/// <summary>
/// Return the indexers registered with the store.
/// </summary>
/// <returns>registered indexers</returns>
IDictionary<string, Func<TApiType, List<string>>> GetIndexers();
/// <summary>
/// Add additional indexers to the store.
/// </summary>
/// <param name="indexers">indexers to add</param>
void AddIndexers(IDictionary<string, Func<TApiType, List<string>>> indexers);
}
}

65
src/KubernetesClient/Util/Informer/Cache/IStore.cs Normal file
View File

@@ -0,0 +1,65 @@
using System.Collections.Generic;
using k8s.Models;
namespace k8s.Util.Informer.Cache
{
public interface IStore<TApiType>
where TApiType : class, IKubernetesObject<V1ObjectMeta>
{
/// <summary>
/// add inserts an item into the store.
/// </summary>
/// <param name="obj">specific obj</param>
void Add(TApiType obj);
/// <summary>
/// update sets an item in the store to its updated state.
/// </summary>
/// <param name="obj">specific obj</param>
void Update(TApiType obj);
/// <summary>
/// delete removes an item from the store.
/// </summary>
/// <param name="obj">specific obj</param>
void Delete(TApiType obj);
/// <summary>
/// Replace will delete the contents of 'c', using instead the given list.
/// </summary>
/// <param name="list">list of objects</param>
/// <param name="resourceVersion">specific resource version</param>
void Replace(IEnumerable<TApiType> list, string resourceVersion);
/// <summary>
/// resync will send a resync event for each item.
/// </summary>
void Resync();
/// <summary>
/// listKeys returns a list of all the keys of the object currently in the store.
/// </summary>
/// <returns>list of all keys</returns>
IEnumerable<string> ListKeys();
/// <summary>
/// get returns the requested item.
/// </summary>
/// <param name="obj">specific obj</param>
/// <returns>the requested item if exist</returns>
TApiType Get(TApiType obj);
/// <summary>
/// getByKey returns the request item with specific key.
/// </summary>
/// <param name="key">specific key</param>
/// <returns>the request item</returns>
TApiType GetByKey(string key);
/// <summary>
/// list returns a list of all the items.
/// </summary>
/// <returns>list of all the items</returns>
IEnumerable<TApiType> List();
}
}

45
src/KubernetesClient/Util/Informer/Cache/Lister.cs Normal file
View File

@@ -0,0 +1,45 @@
using System.Collections.Generic;
using k8s.Models;
namespace k8s.Util.Informer.Cache
{
/// <summary>
/// Lister interface is used to list cached items from a running informer.
/// </summary>
/// <typeparam name="TApiType">the type</typeparam>
public class Lister<TApiType>
where TApiType : class, IKubernetesObject<V1ObjectMeta>
{
private readonly string _namespace;
private readonly string _indexName;
private readonly IIndexer<TApiType> _indexer;
public Lister(IIndexer<TApiType> indexer, string @namespace = default, string indexName = Caches.NamespaceIndex)
{
_indexer = indexer;
_namespace = @namespace;
_indexName = indexName;
}
public IEnumerable<TApiType> List()
{
return string.IsNullOrEmpty(_namespace) ? _indexer.List() : _indexer.ByIndex(_indexName, _namespace);
}
public TApiType Get(string name)
{
var key = name;
if (!string.IsNullOrEmpty(_namespace))
{
key = _namespace + "/" + name;
}
return _indexer.GetByKey(key);
}
public Lister<TApiType> Namespace(string @namespace)
{
return new Lister<TApiType>(_indexer, @namespace, Caches.NamespaceIndex);
}
}
}

55
src/KubernetesClient/Util/Informer/Cache/MutablePair.cs Normal file
View File

@@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
namespace k8s.Util.Informer.Cache
{
public class MutablePair<TLeft, TRight>
{
protected bool Equals(MutablePair<TLeft, TRight> other)
{
if (other is null)
{
throw new ArgumentNullException(nameof(other));
}
return EqualityComparer<TLeft>.Default.Equals(Left, other.Left) && EqualityComparer<TRight>.Default.Equals(Right, other.Right);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj))
{
return false;
}
if (ReferenceEquals(this, obj))
{
return true;
}
return obj.GetType() == this.GetType() && Equals((MutablePair<TLeft, TRight>)obj);
}
public override int GetHashCode()
{
unchecked
{
return (EqualityComparer<TLeft>.Default.GetHashCode(Left) * 397) ^ EqualityComparer<TRight>.Default.GetHashCode(Right);
}
}
public TRight Right { get; }
public TLeft Left { get; }
public MutablePair()
{
}
public MutablePair(TLeft left, TRight right)
{
Left = left;
Right = right;
}
}
}

5
tests/KubernetesClient.Tests/KubernetesClient.Tests.csproj
View File

@@ -8,6 +8,7 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="MartinCostello.Logging.XUnit" Version="0.1.2" />
<PackageReference Include="FluentAssertions" Version="5.10.3" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="2.2.0" />
<PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="13.2.33" />
@@ -41,4 +42,8 @@
<ItemGroup>
<ProjectReference Include="..\..\src\KubernetesClient\KubernetesClient.csproj" />
</ItemGroup>
<ItemGroup>
<Folder Include="Util\Common" />
</ItemGroup>
</Project>

336
tests/KubernetesClient.Tests/Util/Informer/Cache/CacheTest.cs Normal file
View File

@@ -0,0 +1,336 @@
using System;
using System.Collections.Generic;
using System.Linq;
using FluentAssertions;
using k8s.Util.Informer.Cache;
using k8s.Models;
using Xunit;
namespace k8s.Tests.Util.Informer.Cache
{
public class CacheTest
{
[Fact(DisplayName = "Create default cache success")]
private void CreateCacheSuccess()
{
var cache = new Cache<V1Node>();
cache.Should().NotBeNull();
cache.GetIndexers().ContainsKey(Caches.NamespaceIndex).Should().BeTrue();
// Todo: validate all defaults gor set up
}
[Fact(DisplayName = "Add cache item success")]
private void AddCacheItemSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
cache.Get(aPod).Equals(aPod).Should().BeTrue();
}
[Fact(DisplayName = "Update cache item success")]
private void UpdateCacheItemSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
aPod.Kind = "another-kind";
cache.Update(aPod);
cache.Get(aPod).Kind.Equals(aPod.Kind).Should().BeTrue();
}
[Fact(DisplayName = "Delete cache item success")]
private void DeleteCacheItemSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
cache.Delete(aPod);
// Todo: check indices for removed item
cache.Get(aPod).Should().BeNull();
}
[Fact(DisplayName = "Replace cache items success")]
private void ReplaceCacheItemsSuccess()
{
var pods = Util.CreatePods(3);
var aPod = pods.First();
var anotherPod = pods.Skip(1).First();
var yetAnotherPod = pods.Skip(2).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
cache.Replace(new[] { anotherPod, yetAnotherPod });
// Todo: check indices for replaced items
cache.Get(anotherPod).Should().NotBeNull();
cache.Get(yetAnotherPod).Should().NotBeNull();
}
[Fact(DisplayName = "List item keys success")]
public void ListItemKeysSuccess()
{
var pods = Util.CreatePods(3);
var aPod = pods.First();
var anotherPod = pods.Skip(1).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
cache.Add(anotherPod);
var keys = cache.ListKeys();
keys.Should().Contain($"{aPod.Metadata.NamespaceProperty}/{aPod.Metadata.Name}");
keys.Should().Contain($"{anotherPod.Metadata.NamespaceProperty}/{anotherPod.Metadata.Name}");
}
[Fact(DisplayName = "Get item doesn't exist")]
public void GetItemNotExist()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var item = cache.Get(aPod);
item.Should().BeNull();
}
[Fact(DisplayName = "Get item success")]
public void GetItemSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
var item = cache.Get(aPod);
item.Equals(aPod).Should().BeTrue();
}
[Fact(DisplayName = "List items success")]
public void ListItemSuccess()
{
var pods = Util.CreatePods(3);
var aPod = pods.First();
var anotherPod = pods.Skip(1).First();
var yetAnotherPod = pods.Skip(2).First();
var cache = new Cache<V1Pod>();
cache.Add(aPod);
cache.Add(anotherPod);
cache.Add(yetAnotherPod);
var items = cache.List();
items.Should().HaveCount(3);
items.Should().Contain(aPod);
items.Should().Contain(anotherPod);
items.Should().Contain(yetAnotherPod);
}
[Fact(DisplayName = "Get item by key success")]
public void GetItemByKeySuccess()
{
var pod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(pod);
var item = cache.GetByKey($"{pod.Metadata.NamespaceProperty}/{pod.Metadata.Name}");
item.Should().NotBeNull();
}
[Fact(DisplayName = "Index items no index")]
public void IndexItemsNoIndex()
{
var pod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(pod);
Assert.Throws<ArgumentException>(() => { cache.Index("asdf", pod); });
}
[Fact(DisplayName = "Index items success")]
public void IndexItemsSuccess()
{
var pod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(pod);
var items = cache.Index("namespace", pod);
items.Should().Contain(pod);
}
[Fact(DisplayName = "Get index keys no index")]
public void GetIndexKeysNoIndex()
{
var cache = new Cache<V1Pod>();
Assert.Throws<ArgumentException>(() => { cache.IndexKeys("a", "b"); });
}
[Fact(DisplayName = "Get index keys no indice item")]
public void GetIndexKeysNoIndiceItem()
{
var cache = new Cache<V1Pod>();
Assert.Throws<KeyNotFoundException>(() => { cache.IndexKeys("namespace", "b"); });
}
[Fact(DisplayName = "Get index keys success")]
public void GetIndexKeysSuccess()
{
var pod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(pod);
var keys = cache.IndexKeys("namespace", pod.Metadata.NamespaceProperty);
keys.Should().NotBeNull();
keys.Should().Contain(Caches.MetaNamespaceKeyFunc(pod));
}
[Fact(DisplayName = "List by index no index")]
public void ListByIndexNoIndex()
{
var cache = new Cache<V1Pod>();
Assert.Throws<ArgumentException>(() => { cache.ByIndex("a", "b"); });
}
[Fact(DisplayName = "List by index no indice item")]
public void ListByIndexNoIndiceItem()
{
var cache = new Cache<V1Pod>();
Assert.Throws<KeyNotFoundException>(() => { cache.ByIndex("namespace", "b"); });
}
[Fact(DisplayName = "List by index success")]
public void ListByIndexSuccess()
{
var pod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
cache.Add(pod);
var items = cache.ByIndex("namespace", pod.Metadata.NamespaceProperty);
items.Should().Contain(pod);
}
/* Add Indexers */
[Fact(DisplayName = "Add null indexers")]
public void AddNullIndexers()
{
var cache = new Cache<V1Pod>();
Assert.Throws<ArgumentNullException>(() => { cache.AddIndexers(null); });
}
[Fact(DisplayName = "Add indexers with conflict")]
public void AddIndexersConflict()
{
var cache = new Cache<V1Pod>();
Dictionary<string, Func<V1Pod, List<string>>> initialIndexers = new Dictionary<string, Func<V1Pod, List<string>>>()
{
{ "1", pod => new List<string>() },
{ "2", pod => new List<string>() },
};
Dictionary<string, Func<V1Pod, List<string>>> conflictIndexers = new Dictionary<string, Func<V1Pod, List<string>>>()
{
{ "1", pod => new List<string>() },
};
cache.AddIndexers(initialIndexers);
Assert.Throws<ArgumentException>(() => { cache.AddIndexers(conflictIndexers); });
}
[Fact(DisplayName = "Add indexers success")]
public void AddIndexersSuccess()
{
var cache = new Cache<V1Pod>();
Dictionary<string, Func<V1Pod, List<string>>> indexers = new Dictionary<string, Func<V1Pod, List<string>>>()
{
{ "2", pod => new List<string>() { pod.Name() } },
{ "3", pod => new List<string>() { pod.Name() } },
};
cache.AddIndexers(indexers);
var savedIndexers = cache.GetIndexers();
savedIndexers.Should().HaveCount(indexers.Count + 1); // blank cache constructor will add a default index
savedIndexers.Should().Contain(indexers);
// Todo: check indicies collection for new indexname keys
}
/* Add Index Function */
[Fact(DisplayName = "Add index function success")]
public void AddIndexFuncSuccess()
{
var cache = new Cache<V1Pod>();
cache.AddIndexFunc("1", pod => new List<string>() { pod.Name() });
var savedIndexers = cache.GetIndexers();
savedIndexers.Should().HaveCount(2);
// Todo: check indicies collection for new indexname keys
}
/* Get Key Function */
[Fact(DisplayName = "Get default key function success")]
public void GetDefaultKeyFuncSuccess()
{
var pod = new V1Pod()
{
Metadata = new V1ObjectMeta()
{
Name = "a-name",
NamespaceProperty = "the-namespace",
},
};
var cache = new Cache<V1Pod>();
var defaultReturnValue = Caches.DeletionHandlingMetaNamespaceKeyFunc<V1Pod>(pod);
var funcReturnValue = cache.KeyFunc(pod);
Assert.True(defaultReturnValue.Equals(funcReturnValue));
}
/* Set Key Function */
[Fact(DisplayName = "Set key function success")]
public void SetKeyFuncSuccess()
{
var aPod = new V1Pod()
{
Kind = "some-kind",
Metadata = new V1ObjectMeta()
{
Name = "a-name",
NamespaceProperty = "the-namespace",
},
};
var cache = new Cache<V1Pod>();
var newFunc = new Func<V1Pod, string>((pod) => pod.Kind);
var defaultReturnValue = newFunc(aPod);
cache.SetKeyFunc(newFunc);
var funcReturnValue = cache.KeyFunc(aPod);
Assert.True(defaultReturnValue.Equals(funcReturnValue));
}
}
}

60
tests/KubernetesClient.Tests/Util/Informer/Cache/CachesTest.cs Normal file
View File

@@ -0,0 +1,60 @@
using System;
using System.Linq;
using FluentAssertions;
using k8s.Models;
using Xunit;
using k8s.Util.Informer.Cache;
namespace k8s.Tests.Util.Informer.Cache
{
public class CachesTest
{
[Fact(DisplayName = "Check for default DeletedFinalStateUnknown")]
public void CheckDefaultDeletedFinalStateUnknown()
{
var aPod = Util.CreatePods(1).First();
Caches.DeletionHandlingMetaNamespaceKeyFunc(aPod).Should().Be($"{aPod.Metadata.NamespaceProperty}/{aPod.Metadata.Name}");
}
[Fact(DisplayName = "Check for obj DeletedFinalStateUnknown")]
public void CheckObjDeletedFinalStateUnknown()
{
var aPod = Util.CreatePods(1).First();
var key = "a-key";
var deletedPod = new DeletedFinalStateUnknown<V1Pod>(key, aPod);
var returnKey = Caches.DeletionHandlingMetaNamespaceKeyFunc(deletedPod);
// returnKey.Should().Be(key);
}
[Fact(DisplayName = "Get default namespace key null")]
public void GetDefaultNamespaceKeyNull()
{
Assert.Throws<ArgumentNullException>(() => { Caches.MetaNamespaceKeyFunc(null); });
}
[Fact(DisplayName = "Get default namespace key success")]
public void GetDefaultNamespaceKeySuccess()
{
var aPod = Util.CreatePods(1).First();
Caches.MetaNamespaceKeyFunc(aPod).Should().Be($"{aPod.Metadata.NamespaceProperty}/{aPod.Metadata.Name}");
}
[Fact(DisplayName = "Get default namespace index null")]
public void GetDefaultNamespaceIndexNull()
{
Assert.Throws<ArgumentNullException>(() => { Caches.MetaNamespaceIndexFunc<V1Pod>(null); });
}
[Fact(DisplayName = "Get default namespace index success")]
public void GetDefaultNamespaceIndexSuccess()
{
var aPod = Util.CreatePods(1).First();
var indexes = Caches.MetaNamespaceIndexFunc(aPod);
indexes.Should().NotBeNull();
indexes.Should().Contain(aPod.Metadata.NamespaceProperty);
}
}
}

95
tests/KubernetesClient.Tests/Util/Informer/Cache/ListerTest.cs Normal file
View File

@@ -0,0 +1,95 @@
using System.Linq;
using FluentAssertions;
using k8s.Models;
using Xunit;
using k8s.Util.Informer.Cache;
namespace k8s.Tests.Util.Informer.Cache
{
public class ListerTest
{
[Fact(DisplayName = "Create default lister success")]
private void CreateListerDefaultsSuccess()
{
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache);
lister.Should().NotBeNull();
}
[Fact(DisplayName = "List with null namespace success")]
private void ListNullNamespaceSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache);
cache.Add(aPod);
var pods = lister.List();
pods.Should().HaveCount(1);
pods.Should().Contain(aPod);
// Can't 'Get' the pod due to no namespace specified in Lister constructor
}
[Fact(DisplayName = "List with custom namespace success")]
private void ListCustomNamespaceSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache, aPod.Metadata.NamespaceProperty);
cache.Add(aPod);
var pods = lister.List();
pods.Should().HaveCount(1);
pods.Should().Contain(aPod);
lister.Get(aPod.Metadata.Name).Should().Be(aPod);
}
[Fact(DisplayName = "Get with null namespace success")]
private void GetNullNamespaceSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache);
cache.Add(aPod);
var pod = lister.Get(aPod.Metadata.Name);
// it's null because the namespace was not set in Lister constructor, but the pod did have a namespace.
// So it can't build the right key name for lookup in Cache
pod.Should().BeNull();
}
[Fact(DisplayName = "Get with custom namespace success")]
private void GetCustomNamespaceSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache, aPod.Metadata.NamespaceProperty);
cache.Add(aPod);
var pod = lister.Get(aPod.Metadata.Name);
pod.Should().Be(aPod);
}
[Fact(DisplayName = "Set custom namespace success")]
private void SetCustomNamespaceSuccess()
{
var aPod = Util.CreatePods(1).First();
var cache = new Cache<V1Pod>();
var lister = new Lister<V1Pod>(cache);
cache.Add(aPod);
var pod = lister.Get(aPod.Metadata.Name);
pod.Should().BeNull();
lister = lister.Namespace(aPod.Metadata.NamespaceProperty);
pod = lister.Get(aPod.Metadata.Name);
pod.Should().Be(aPod);
}
}
}

33
tests/KubernetesClient.Tests/Util/Informer/Cache/ReflectorTest.cs Normal file
View File

@@ -0,0 +1,33 @@
using FluentAssertions;
using k8s.Models;
using k8s.Util.Informer.Cache;
using Microsoft.Extensions.Logging;
using Xunit;
using Xunit.Abstractions;
using Xunit.Sdk;
namespace k8s.Tests.Util.Informer.Cache
{
public class ReflectorTest
{
private readonly ITestOutputHelper _ouputHelper;
public ReflectorTest(ITestOutputHelper outputHelper)
{
_ouputHelper = outputHelper;
}
[Fact(DisplayName = "Create default reflector success")]
public void CreateReflectorSuccess()
{
/*using var apiClient = new Kubernetes(_clientConfiguration);
var cache = new Cache<V1Pod>();
var queue = new DeltaFifo(Caches.MetaNamespaceKeyFunc, cache, _deltasLogger);
var listerWatcher = new ListWatcher<V1Pod, V1PodList>(apiClient, ListAllPods);
var logger = LoggerFactory.Create(builder => builder.AddXUnit(_ouputHelper).SetMinimumLevel(LogLevel.Trace)).CreateLogger<k8s.Util.Cache.Reflector>();
var reflector = new k8s.Util.Cache.Reflector<V1Pod, V1PodList>(listerWatcher, queue, logger);
reflector.Should().NotBeNull();*/
}
}
}

45
tests/KubernetesClient.Tests/Util/Informer/Cache/Util.cs Normal file
View File

@@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.Linq;
using k8s.Models;
namespace k8s.Tests.Util.Informer.Cache
{
internal static class Util
{
internal static IEnumerable<V1Pod> CreatePods(int cnt)
{
var pods = new List<V1Pod>();
for (var i = 0; i < cnt; i++)
{
pods.Add(new V1Pod()
{
ApiVersion = "Pod/V1",
Kind = "Pod",
Metadata = new V1ObjectMeta()
{
Name = Guid.NewGuid().ToString(),
NamespaceProperty = "the-namespace",
ResourceVersion = "1",
},
});
}
return pods;
}
internal static V1PodList CreatePostList(int cnt)
{
return new V1PodList()
{
ApiVersion = "Pod/V1",
Kind = "Pod",
Metadata = new V1ListMeta()
{
ResourceVersion = "1",
},
Items = CreatePods(cnt).ToList(),
};
}
}
}

42
util/src/KubernetesClient.Util/KubernetesClient.Util.csproj Normal file
View File

@@ -0,0 +1,42 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<LangVersion>9.0</LangVersion>
<Authors>The Kubernetes Project Authors</Authors>
<Copyright>2017 The Kubernetes Project Authors</Copyright>
<Description>Supprting utilities for the kubernetes open source container orchestrator client library.</Description>
<PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
<PackageProjectUrl>https://github.com/kubernetes-client/csharp</PackageProjectUrl>
<PackageIconUrl>https://raw.githubusercontent.com/kubernetes/kubernetes/master/logo/logo.png</PackageIconUrl>
<PackageTags>kubernetes;docker;containers;</PackageTags>
<TargetFrameworks>netstandard2.1;net5.0</TargetFrameworks>
<RootNamespace>k8s.Util</RootNamespace>
<SignAssembly>true</SignAssembly>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<!-- Publish the repository URL in the built .nupkg (in the NuSpec <Repository> element) -->
<PublishRepositoryUrl>true</PublishRepositoryUrl>
<!-- Build symbol package (.snupkg) to distribute the PDB containing Source Link -->
<IncludeSymbols>true</IncludeSymbols>
<SymbolPackageFormat>snupkg</SymbolPackageFormat>
<EmbedUntrackedSources>true</EmbedUntrackedSources>
<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\src\KubernetesClient\KubernetesClient.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="System.Text.Json" Version="5.0.2" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="2.2.0" />
</ItemGroup>
<ItemGroup>
<Folder Include="Utils" />
</ItemGroup>
</Project>

2
util/src/KubernetesClient.Util/KubernetesClient.Util.csproj.DotSettings Normal file
View File

@@ -0,0 +1,2 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp90</s:String></wpf:ResourceDictionary>

34
util/tests/KubernetesClient.Util.Tests/KubernetesClient.Util.Tests.csproj Normal file
View File

@@ -0,0 +1,34 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="MartinCostello.Logging.XUnit" Version="0.1.1" />
<PackageReference Include="FluentAssertions" Version="5.10.3" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
<PackageReference Include="xunit" Version="2.4.1" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="coverlet.collector" Version="1.3.0">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\src\KubernetesClient\KubernetesClient.csproj" />
<ProjectReference Include="..\..\src\KubernetesClient.Util\KubernetesClient.Util.csproj" />
</ItemGroup>
<ItemGroup>
<Folder Include="Cache" />
</ItemGroup>
</Project>