feat(client): add async/sync variants

BREAKING CHANGE: all calls that were
async before are now sync. There are
async variants of all calls with the
Async suffix.

Signed-off-by: Christoph Bühler <[email protected]>

Author: buehler

examples/Operator/Controller/V1TestEntityController.cs

@@ -38,9 +38,9 @@ public async Task ReconcileAsync(V1TestEntity entity)
         entity = await _finalizer2(entity);
 
         entity.Status.Status = "Reconciling";
-        entity = await _client.UpdateStatus(entity);
+        entity = await _client.UpdateStatusAsync(entity);
         entity.Status.Status = "Reconciled";
-        await _client.UpdateStatus(entity);
+        await _client.UpdateStatusAsync(entity);
     }
 
     public Task DeletedAsync(V1TestEntity entity)

examples/Operator/todos.txt

@@ -10,6 +10,5 @@
 - cache?
 - try .net 8 AOT?
 - client:
-        // TODO: make all sync calls as well.
         // TODO: test list / get call.
         // TODO: update list call

src/KubeOps.KubernetesClient/IKubernetesClient.cs

@@ -45,7 +45,10 @@ public interface IKubernetesClient<TEntity> : IDisposable
     /// </summary>
     /// <param name="downwardApiEnvName">Customizable name of the env var to check for the namespace.</param>
     /// <returns>A string containing the current namespace (or a fallback of it).</returns>
-    Task<string> GetCurrentNamespace(string downwardApiEnvName = "POD_NAMESPACE");
+    Task<string> GetCurrentNamespaceAsync(string downwardApiEnvName = "POD_NAMESPACE");
+
+    /// <inheritdoc cref="GetCurrentNamespaceAsync" />
+    string GetCurrentNamespace(string downwardApiEnvName = "POD_NAMESPACE");
 
     /// <summary>
     /// Fetch and return an entity from the Kubernetes API.
@@ -56,15 +59,18 @@ public interface IKubernetesClient<TEntity> : IDisposable
     /// If it is omitted, the entity must be a cluster wide entity.
     /// </param>
     /// <returns>The found entity of the given type, or null otherwise.</returns>
-    Task<TEntity?> Get(string name, string? @namespace = null);
+    Task<TEntity?> GetAsync(string name, string? @namespace = null);
+
+    /// <inheritdoc cref="GetAsync"/>
+    TEntity? Get(string name, string? @namespace = null);
 
     /// <summary>
     /// Fetch and return a list of entities from the Kubernetes API.
     /// </summary>
     /// <param name="namespace">If the entities are namespaced, provide the name of the namespace.</param>
     /// <param name="labelSelector">A string, representing an optional label selector for filtering fetched objects.</param>
     /// <returns>A list of Kubernetes entities.</returns>
-    Task<IList<TEntity>> List(
+    Task<IList<TEntity>> ListAsync(
         string? @namespace = null,
         string? labelSelector = null);
 
@@ -76,7 +82,17 @@ Task<IList<TEntity>> List(
     /// </param>
     /// <param name="labelSelectors">A list of label-selectors to apply to the search.</param>
     /// <returns>A list of Kubernetes entities.</returns>
-    Task<IList<TEntity>> List(
+    Task<IList<TEntity>> ListAsync(
+        string? @namespace = null,
+        params LabelSelector[] labelSelectors);
+
+    /// <inheritdoc cref="ListAsync(string?,string?)"/>
+    IList<TEntity> List(
+        string? @namespace = null,
+        string? labelSelector = null);
+
+    /// <inheritdoc cref="ListAsync(string?,LabelSelector[])"/>
+    IList<TEntity> List(
         string? @namespace = null,
         params LabelSelector[] labelSelectors);
 
@@ -86,61 +102,89 @@ Task<IList<TEntity>> List(
     /// </summary>
     /// <param name="entity">The entity in question.</param>
     /// <returns>The saved instance of the entity.</returns>
-    async Task<TEntity> Save(TEntity entity) => await Get(entity.Name(), entity.Namespace()) switch
+    async Task<TEntity> SaveAsync(TEntity entity) => await GetAsync(entity.Name(), entity.Namespace()) switch
+    {
+        { } e => await UpdateAsync(entity.WithResourceVersion(e)),
+        _ => await CreateAsync(entity),
+    };
+
+    /// <inheritdoc cref="SaveAsync"/>
+    TEntity Save(TEntity entity) => Get(entity.Name(), entity.Namespace()) switch
     {
-        { } e => await Update(entity.WithResourceVersion(e)),
-        _ => await Create(entity),
+        { } e => Update(entity.WithResourceVersion(e)),
+        _ => Create(entity),
     };
 
     /// <summary>
     /// Create the given entity on the Kubernetes API.
     /// </summary>
     /// <param name="entity">The entity instance.</param>
     /// <returns>The created instance of the entity.</returns>
-    Task<TEntity> Create(TEntity entity);
+    Task<TEntity> CreateAsync(TEntity entity);
+
+    /// <inheritdoc cref="CreateAsync"/>
+    TEntity Create(TEntity entity);
 
     /// <summary>
     /// Update the given entity on the Kubernetes API.
     /// </summary>
     /// <param name="entity">The entity instance.</param>
     /// <returns>The updated instance of the entity.</returns>
-    Task<TEntity> Update(TEntity entity);
+    Task<TEntity> UpdateAsync(TEntity entity);
+
+    /// <inheritdoc cref="UpdateAsync"/>
+    TEntity Update(TEntity entity);
 
     /// <summary>
     /// Update the status object of a given entity on the Kubernetes API.
     /// </summary>
     /// <param name="entity">The entity that contains a status object.</param>
+    /// <returns>The entity with the updated status.</returns>
+    Task<TEntity> UpdateStatusAsync(TEntity entity);
+
+    /// <inheritdoc cref="UpdateStatusAsync"/>
+    TEntity UpdateStatus(TEntity entity);
+
+    /// <inheritdoc cref="Delete(TEntity)"/>
     /// <returns>A task that completes when the call was made.</returns>
-    public Task<TEntity> UpdateStatus(TEntity entity);
+    Task DeleteAsync(TEntity entity);
+
+    /// <inheritdoc cref="Delete(IEnumerable{TEntity})"/>
+    /// <returns>A task that completes when the call was made.</returns>
+    Task DeleteAsync(IEnumerable<TEntity> entities);
+
+    /// <inheritdoc cref="Delete(TEntity[])"/>
+    /// <returns>A task that completes when the call was made.</returns>
+    Task DeleteAsync(params TEntity[] entities);
+
+    /// <inheritdoc cref="Delete(string,string?)"/>
+    /// <returns>A task that completes when the call was made.</returns>
+    Task DeleteAsync(string name, string? @namespace = null);
 
     /// <summary>
     /// Delete a given entity from the Kubernetes API.
     /// </summary>
     /// <param name="entity">The entity in question.</param>
-    /// <returns>A task that completes when the call was made.</returns>
-    Task Delete(TEntity entity);
+    void Delete(TEntity entity);
 
     /// <summary>
     /// Delete a given list of entities from the Kubernetes API.
     /// </summary>
     /// <param name="entities">The entities in question.</param>
-    /// <returns>A task that completes when the calls were made.</returns>
-    Task Delete(IEnumerable<TEntity> entities);
+    void Delete(IEnumerable<TEntity> entities);
 
     /// <summary>
     /// Delete a given list of entities from the Kubernetes API.
     /// </summary>
     /// <param name="entities">The entities in question.</param>
-    /// <returns>A task that completes when the calls were made.</returns>
-    Task Delete(params TEntity[] entities);
+    void Delete(params TEntity[] entities);
 
     /// <summary>
     /// Delete a given entity by name from the Kubernetes API.
     /// </summary>
     /// <param name="name">The name of the entity.</param>
     /// <param name="namespace">The optional namespace of the entity.</param>
-    /// <returns>A task that completes when the call was made.</returns>
-    Task Delete(string name, string? @namespace = null);
+    void Delete(string name, string? @namespace = null);
 
     /// <summary>
     /// Create a entity watcher on the Kubernetes API.

src/KubeOps.KubernetesClient/KubernetesClient.cs

@@ -72,7 +72,7 @@ public KubernetesClient(EntityMetadata metadata, KubernetesClientConfiguration c
     public Uri BaseUri => _client.BaseUri;
 
     /// <inheritdoc />
-    public async Task<string> GetCurrentNamespace(string downwardApiEnvName = "POD_NAMESPACE")
+    public async Task<string> GetCurrentNamespaceAsync(string downwardApiEnvName = "POD_NAMESPACE")
     {
         if (_clientConfig.Namespace is { } configValue)
         {
@@ -94,7 +94,29 @@ public async Task<string> GetCurrentNamespace(string downwardApiEnvName = "POD_N
     }
 
     /// <inheritdoc />
-    public async Task<TEntity?> Get(string name, string? @namespace = null)
+    public string GetCurrentNamespace(string downwardApiEnvName = "POD_NAMESPACE")
+    {
+        if (_clientConfig.Namespace is { } configValue)
+        {
+            return configValue;
+        }
+
+        if (Environment.GetEnvironmentVariable(downwardApiEnvName) is { } envValue)
+        {
+            return envValue;
+        }
+
+        if (File.Exists(DownwardApiNamespaceFile))
+        {
+            var ns = File.ReadAllText(DownwardApiNamespaceFile);
+            return ns.Trim();
+        }
+
+        return DefaultNamespace;
+    }
+
+    /// <inheritdoc />
+    public async Task<TEntity?> GetAsync(string name, string? @namespace = null)
     {
         var list = @namespace switch
         {
@@ -119,7 +141,32 @@ public async Task<string> GetCurrentNamespace(string downwardApiEnvName = "POD_N
     }
 
     /// <inheritdoc />
-    public async Task<IList<TEntity>> List(string? @namespace = null, string? labelSelector = null)
+    public TEntity? Get(string name, string? @namespace = null)
+    {
+        var list = @namespace switch
+        {
+            null => _client.CustomObjects.ListClusterCustomObject<EntityList<TEntity>>(
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                _metadata.PluralName,
+                fieldSelector: $"metadata.name={name}"),
+            _ => _client.CustomObjects.ListNamespacedCustomObject<EntityList<TEntity>>(
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                @namespace,
+                _metadata.PluralName,
+                fieldSelector: $"metadata.name={name}"),
+        };
+
+        return list switch
+        {
+            { Items: [var existing] } => existing,
+            _ => default,
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<IList<TEntity>> ListAsync(string? @namespace = null, string? labelSelector = null)
         => (@namespace switch
         {
             null => await _client.CustomObjects.ListClusterCustomObjectAsync<EntityList<TEntity>>(
@@ -136,27 +183,56 @@ public async Task<IList<TEntity>> List(string? @namespace = null, string? labelS
         }).Items;
 
     /// <inheritdoc />
-    public Task<IList<TEntity>> List(string? @namespace = null, params LabelSelector[] labelSelectors)
+    public Task<IList<TEntity>> ListAsync(string? @namespace = null, params LabelSelector[] labelSelectors)
+        => ListAsync(@namespace, labelSelectors.ToExpression());
+
+    /// <inheritdoc />
+    public IList<TEntity> List(string? @namespace = null, string? labelSelector = null)
+        => (@namespace switch
+        {
+            null => _client.CustomObjects.ListClusterCustomObject<EntityList<TEntity>>(
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                _metadata.PluralName,
+                labelSelector: labelSelector),
+            _ => _client.CustomObjects.ListNamespacedCustomObject<EntityList<TEntity>>(
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                @namespace,
+                _metadata.PluralName,
+                labelSelector: labelSelector),
+        }).Items;
+
+    /// <inheritdoc />
+    public IList<TEntity> List(string? @namespace = null, params LabelSelector[] labelSelectors)
         => List(@namespace, labelSelectors.ToExpression());
 
     /// <inheritdoc />
-    public Task<TEntity> Create(TEntity entity)
+    public Task<TEntity> CreateAsync(TEntity entity)
         => entity.Namespace() switch
         {
             { } ns => _genericClient.CreateNamespacedAsync(entity, ns),
             null => _genericClient.CreateAsync(entity),
         };
 
     /// <inheritdoc />
-    public Task<TEntity> Update(TEntity entity)
+    public TEntity Create(TEntity entity)
+        => CreateAsync(entity).GetAwaiter().GetResult();
+
+    /// <inheritdoc />
+    public Task<TEntity> UpdateAsync(TEntity entity)
         => entity.Namespace() switch
         {
             { } ns => _genericClient.ReplaceNamespacedAsync(entity, ns, entity.Name()),
             null => _genericClient.ReplaceAsync(entity, entity.Name()),
         };
 
     /// <inheritdoc />
-    public Task<TEntity> UpdateStatus(TEntity entity)
+    public TEntity Update(TEntity entity)
+        => UpdateAsync(entity).GetAwaiter().GetResult();
+
+    /// <inheritdoc />
+    public Task<TEntity> UpdateStatusAsync(TEntity entity)
         => entity.Namespace() switch
         {
             { } ns => _client.CustomObjects.ReplaceNamespacedCustomObjectStatusAsync<TEntity>(
@@ -175,20 +251,39 @@ public Task<TEntity> UpdateStatus(TEntity entity)
         };
 
     /// <inheritdoc />
-    public Task Delete(TEntity entity) => Delete(
+    public TEntity UpdateStatus(TEntity entity)
+        => entity.Namespace() switch
+        {
+            { } ns => _client.CustomObjects.ReplaceNamespacedCustomObjectStatus<TEntity>(
+                entity,
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                ns,
+                _metadata.PluralName,
+                entity.Name()),
+            _ => _client.CustomObjects.ReplaceClusterCustomObjectStatus<TEntity>(
+                entity,
+                _metadata.Group ?? string.Empty,
+                _metadata.Version,
+                _metadata.PluralName,
+                entity.Name()),
+        };
+
+    /// <inheritdoc />
+    public Task DeleteAsync(TEntity entity) => DeleteAsync(
         entity.Name(),
         entity.Namespace());
 
     /// <inheritdoc />
-    public Task Delete(IEnumerable<TEntity> entities) =>
-        Task.WhenAll(entities.Select(Delete));
+    public Task DeleteAsync(IEnumerable<TEntity> entities) =>
+        Task.WhenAll(entities.Select(DeleteAsync));
 
     /// <inheritdoc />
-    public Task Delete(params TEntity[] entities) =>
-        Task.WhenAll(entities.Select(Delete));
+    public Task DeleteAsync(params TEntity[] entities) =>
+        Task.WhenAll(entities.Select(DeleteAsync));
 
     /// <inheritdoc />
-    public async Task Delete(string name, string? @namespace = null)
+    public async Task DeleteAsync(string name, string? @namespace = null)
     {
         try
         {
@@ -208,6 +303,22 @@ public async Task Delete(string name, string? @namespace = null)
         }
     }
 
+    /// <inheritdoc />
+    public void Delete(TEntity entity)
+        => DeleteAsync(entity).GetAwaiter().GetResult();
+
+    /// <inheritdoc />
+    public void Delete(IEnumerable<TEntity> entities)
+        => DeleteAsync(entities).GetAwaiter().GetResult();
+
+    /// <inheritdoc />
+    public void Delete(params TEntity[] entities)
+        => DeleteAsync(entities).GetAwaiter().GetResult();
+
+    /// <inheritdoc />
+    public void Delete(string name, string? @namespace = null)
+        => DeleteAsync(name, @namespace).GetAwaiter().GetResult();
+
     /// <inheritdoc />
     public Watcher<TEntity> Watch(
         Action<WatchEventType, TEntity> onEvent,

src/KubeOps.Operator/Builder/OperatorBuilder.cs

@@ -72,7 +72,7 @@ public IOperatorBuilder AddFinalizer<TImplementation, TEntity>(string identifier
                 identifier,
                 entity.Kind,
                 entity.Name());
-            return await client.Update(entity);
+            return await client.UpdateAsync(entity);
         });
 
         return this;

src/KubeOps.Operator/Watcher/ResourceWatcher{TEntity}.cs

@@ -202,7 +202,7 @@ private async Task ReconcileFinalizer(TEntity entity)
 
         await finalizer.FinalizeAsync(entity);
         entity.RemoveFinalizer(identifier);
-        await _client.Update(entity);
+        await _client.UpdateAsync(entity);
         _logger.LogInformation(
             """Entity "{kind}/{name}" finalized with "{finalizer}".""",
             entity.Kind,