Implement KubectlRollout with generic type parameters for deployment lifecycle management #1700

Copilot · 2025-12-10T20:14:18Z

Adds kubectl rollout operations to match Java client and kubectl CLI functionality for managing deployment, daemonset, and statefulset rollouts.

Implementation

Core operations (AsyncKubectl.Rollout.cs):

RolloutRestartAsync<T> - triggers rollout via restart annotation (supports V1Deployment, V1DaemonSet, V1StatefulSet)
RolloutStatusAsync<T> - returns detailed rollout progress status for all workload types
RolloutHistoryAsync<T> - retrieves revision history with change-cause annotations
RolloutUndoAsync<T> - rolls back to specified or previous revision (Deployment only)
RolloutPauseAsync<T> / RolloutResumeAsync<T> - controls deployment rollouts (Deployment only)

Synchronous wrappers (Kubectl.Rollout.cs):

Generic sync wrappers following existing patterns (RolloutRestart, RolloutStatus, etc.)

Tests (KubectlTests.Rollout.cs):

Coverage for all operations across resource types

API Design

The API uses generic type parameters following the same pattern as existing Get<T> and List<T> methods, providing a clean and consistent interface:

using var kubernetes = new Kubernetes(config);
var kubectl = new Kubectl(kubernetes);

// Restart workloads
kubectl.RolloutRestart<V1Deployment>("my-app", "production");
kubectl.RolloutRestart<V1DaemonSet>("my-daemon", "default");
kubectl.RolloutRestart<V1StatefulSet>("my-sts", "default");

// Check status
var status = kubectl.RolloutStatus<V1Deployment>("my-app", "production");
// Returns: "deployment \"my-app\" successfully rolled out"

// View history
var history = kubectl.RolloutHistory<V1Deployment>("my-app", "production");

// Deployment-specific operations
kubectl.RolloutPause<V1Deployment>("my-app", "production");
kubectl.RolloutResume<V1Deployment>("my-app", "production");
kubectl.RolloutUndo<V1Deployment>("my-app", "production");

Technical Details

Uses JSON patch operations for resource updates
Generic type parameters with runtime type checking for resource-specific operations
Extracts label selectors via shared helper method
Defines annotation keys as constants (RestartedAtAnnotation, RevisionAnnotation, ChangeCauseAnnotation)
Handles ReplicaSets for deployments, ControllerRevisions for daemonsets/statefulsets

Original prompt

This section details on the original issue you should resolve

<issue_title>Implement KubectlRollout</issue_title>
<issue_description>Similar to this code in the Java client:
https://github.com/kubernetes-client/java/blob/master/extended/src/main/java/io/kubernetes/client/extended/kubectl/KubectlRollout.java

And this cli command:
https://kubernetes.io/docs/reference/kubectl/generated/kubectl_rollout/

We should support rollout in the Kubectl Library.</issue_description>

Comments on the Issue (you are @copilot in this section)

Fixes Implement KubectlRollout #1699

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

…, pause, and resume methods Co-authored-by: brendandburns <[email protected]>

Co-authored-by: brendandburns <[email protected]>

brendandburns · 2025-12-10T23:23:39Z

@copilot please update this PR to use a single method signature with different typed parameters instead of a separate method name for Deployments, StatefulSets, etc.

Changed API from separate methods per resource type to generic methods: - RolloutRestart<T>, RolloutStatus<T>, RolloutHistory<T> - RolloutPause<T>, RolloutResume<T>, RolloutUndo<T> Usage example: kubectl.RolloutRestart<V1Deployment>("my-app", "production"); kubectl.RolloutStatus<V1DaemonSet>("my-daemon", "default"); This provides a cleaner API that follows the pattern used by Get<T> and List<T>. Co-authored-by: brendandburns <[email protected]>

Copilot · 2025-12-10T23:33:49Z

@copilot please update this PR to use a single method signature with different typed parameters instead of a separate method name for Deployments, StatefulSets, etc.

Done! Refactored to use generic type parameters instead of separate method names. The new API follows the same pattern as Get and List:

kubectl.RolloutRestart<V1Deployment>("my-app", "production");
kubectl.RolloutStatus<V1DaemonSet>("my-daemon", "default");
kubectl.RolloutHistory<V1StatefulSet>("my-sts", "default");

Changes in commit f820e76.

brendandburns

/lgtm
/approve

k8s-ci-robot · 2025-12-12T16:54:02Z

[APPROVALNOTIFIER] This PR is APPROVED

This pull-request has been approved by: brendandburns, Copilot

The full list of commands accepted by this bot can be found here.

The pull request process is described here

Needs approval from an approver in each of these files:

~~OWNERS~~ [brendandburns]

Approvers can indicate their approval by writing /approve in a comment
Approvers can cancel approval by writing /approve cancel in a comment

Copilot

Pull request overview

This PR implements kubectl rollout operations for the C# Kubernetes client library, adding deployment lifecycle management capabilities equivalent to the kubectl CLI and Java client. The implementation uses generic type parameters to provide a clean, consistent API that matches the existing Get<T> and List<T> patterns in the codebase.

Adds six core rollout operations (restart, status, pause, resume, undo, history) with async implementations
Supports three workload types: V1Deployment, V1DaemonSet, and V1StatefulSet
Provides both async and synchronous API wrappers following existing codebase patterns

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 31 comments.

File	Description
`src/KubernetesClient.Kubectl/Beta/AsyncKubectl.Rollout.cs`	Core async implementation of rollout operations with type-specific handlers and status checking logic
`src/KubernetesClient.Kubectl/Beta/Kubectl.Rollout.cs`	Synchronous wrappers for rollout operations using GetAwaiter().GetResult() pattern
`tests/Kubectl.Tests/KubectlTests.Rollout.cs`	Integration tests covering restart, status, pause/resume, and history operations across all supported resource types

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2025-12-12T17:03:10Z

tests/Kubectl.Tests/KubectlTests.Rollout.cs

+using k8s.Autorest;
+using k8s.E2E;
+using k8s.kubectl.beta;
+using k8s.Models;
+using Xunit;
+
+namespace k8s.kubectl.Tests;
+
+public partial class KubectlTests
+{
+    [MinikubeFact]
+    public void RolloutRestartDeployment()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var deploymentName = "k8scsharp-e2e-rollout-deployment";
+
+        // Create a test deployment
+        var deployment = new V1Deployment
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = deploymentName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1DeploymentSpec
+            {
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-rollout" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-rollout" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDeployment(deployment, namespaceParameter);
+
+            // Wait a moment for the deployment to stabilize
+            System.Threading.Thread.Sleep(2000);
+
+            // Restart the deployment
+            client.RolloutRestart<V1Deployment>(deploymentName, namespaceParameter);
+
+            // Verify the restart annotation was added
+            var updatedDeployment = kubernetes.AppsV1.ReadNamespacedDeployment(deploymentName, namespaceParameter);
+            Assert.NotNull(updatedDeployment.Spec.Template.Metadata.Annotations);
+            Assert.Contains("kubectl.kubernetes.io/restartedAt", updatedDeployment.Spec.Template.Metadata.Annotations.Keys);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDeployment(deploymentName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutStatusDeployment()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var deploymentName = "k8scsharp-e2e-rollout-status";
+
+        // Create a test deployment
+        var deployment = new V1Deployment
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = deploymentName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1DeploymentSpec
+            {
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-status" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-status" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDeployment(deployment, namespaceParameter);
+
+            // Get rollout status
+            var status = client.RolloutStatus<V1Deployment>(deploymentName, namespaceParameter);
+
+            // Status should contain the deployment name
+            Assert.Contains(deploymentName, status);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDeployment(deploymentName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutPauseAndResumeDeployment()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var deploymentName = "k8scsharp-e2e-rollout-pause";
+
+        // Create a test deployment
+        var deployment = new V1Deployment
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = deploymentName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1DeploymentSpec
+            {
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-pause" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-pause" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDeployment(deployment, namespaceParameter);
+
+            // Pause the deployment
+            client.RolloutPause<V1Deployment>(deploymentName, namespaceParameter);
+
+            // Verify the deployment is paused
+            var pausedDeployment = kubernetes.AppsV1.ReadNamespacedDeployment(deploymentName, namespaceParameter);
+            Assert.True(pausedDeployment.Spec.Paused);
+
+            // Resume the deployment
+            client.RolloutResume<V1Deployment>(deploymentName, namespaceParameter);
+
+            // Verify the deployment is resumed
+            var resumedDeployment = kubernetes.AppsV1.ReadNamespacedDeployment(deploymentName, namespaceParameter);
+            Assert.False(resumedDeployment.Spec.Paused);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDeployment(deploymentName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutHistoryDeployment()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var deploymentName = "k8scsharp-e2e-rollout-history";
+
+        // Create a test deployment with change-cause annotation
+        var deployment = new V1Deployment
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = deploymentName,
+                NamespaceProperty = namespaceParameter,
+                Annotations = new Dictionary<string, string>
+                {
+                    { "kubernetes.io/change-cause", "Initial deployment" },
+                },
+            },
+            Spec = new V1DeploymentSpec
+            {
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-history" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-history" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDeployment(deployment, namespaceParameter);
+
+            // Wait for deployment to create ReplicaSets
+            System.Threading.Thread.Sleep(3000);
+
+            // Get rollout history
+            var history = client.RolloutHistory<V1Deployment>(deploymentName, namespaceParameter);
+
+            // Should have at least one revision
+            Assert.NotNull(history);
+            Assert.NotEmpty(history);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDeployment(deploymentName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutRestartDaemonSet()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var daemonSetName = "k8scsharp-e2e-rollout-daemonset";
+
+        // Create a test daemonset
+        var daemonSet = new V1DaemonSet
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = daemonSetName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1DaemonSetSpec
+            {
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-daemonset" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-daemonset" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                        Tolerations = new[]
+                        {
+                            new V1Toleration
+                            {
+                                OperatorProperty = "Exists",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDaemonSet(daemonSet, namespaceParameter);
+
+            // Wait a moment for the daemonset to stabilize
+            System.Threading.Thread.Sleep(2000);
+
+            // Restart the daemonset
+            client.RolloutRestart<V1DaemonSet>(daemonSetName, namespaceParameter);
+
+            // Verify the restart annotation was added
+            var updatedDaemonSet = kubernetes.AppsV1.ReadNamespacedDaemonSet(daemonSetName, namespaceParameter);
+            Assert.NotNull(updatedDaemonSet.Spec.Template.Metadata.Annotations);
+            Assert.Contains("kubectl.kubernetes.io/restartedAt", updatedDaemonSet.Spec.Template.Metadata.Annotations.Keys);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDaemonSet(daemonSetName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutStatusDaemonSet()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var daemonSetName = "k8scsharp-e2e-rollout-ds-status";
+
+        // Create a test daemonset
+        var daemonSet = new V1DaemonSet
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = daemonSetName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1DaemonSetSpec
+            {
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-ds-status" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-ds-status" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                        Tolerations = new[]
+                        {
+                            new V1Toleration
+                            {
+                                OperatorProperty = "Exists",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedDaemonSet(daemonSet, namespaceParameter);
+
+            // Get rollout status
+            var status = client.RolloutStatus<V1DaemonSet>(daemonSetName, namespaceParameter);
+
+            // Status should contain the daemonset name
+            Assert.Contains(daemonSetName, status);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedDaemonSet(daemonSetName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutRestartStatefulSet()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var statefulSetName = "k8scsharp-e2e-rollout-statefulset";
+
+        // Create a test statefulset
+        var statefulSet = new V1StatefulSet
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = statefulSetName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1StatefulSetSpec
+            {
+                ServiceName = "test-service",
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-statefulset" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-statefulset" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedStatefulSet(statefulSet, namespaceParameter);
+
+            // Wait a moment for the statefulset to stabilize
+            System.Threading.Thread.Sleep(2000);
+
+            // Restart the statefulset
+            client.RolloutRestart<V1StatefulSet>(statefulSetName, namespaceParameter);
+
+            // Verify the restart annotation was added
+            var updatedStatefulSet = kubernetes.AppsV1.ReadNamespacedStatefulSet(statefulSetName, namespaceParameter);
+            Assert.NotNull(updatedStatefulSet.Spec.Template.Metadata.Annotations);
+            Assert.Contains("kubectl.kubernetes.io/restartedAt", updatedStatefulSet.Spec.Template.Metadata.Annotations.Keys);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedStatefulSet(statefulSetName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+
+    [MinikubeFact]
+    public void RolloutStatusStatefulSet()
+    {
+        using var kubernetes = MinikubeTests.CreateClient();
+        var client = new Kubectl(kubernetes);
+        var namespaceParameter = "default";
+        var statefulSetName = "k8scsharp-e2e-rollout-sts-status";
+
+        // Create a test statefulset
+        var statefulSet = new V1StatefulSet
+        {
+            Metadata = new V1ObjectMeta
+            {
+                Name = statefulSetName,
+                NamespaceProperty = namespaceParameter,
+            },
+            Spec = new V1StatefulSetSpec
+            {
+                ServiceName = "test-service",
+                Replicas = 1,
+                Selector = new V1LabelSelector
+                {
+                    MatchLabels = new Dictionary<string, string>
+                    {
+                        { "app", "test-sts-status" },
+                    },
+                },
+                Template = new V1PodTemplateSpec
+                {
+                    Metadata = new V1ObjectMeta
+                    {
+                        Labels = new Dictionary<string, string>
+                        {
+                            { "app", "test-sts-status" },
+                        },
+                    },
+                    Spec = new V1PodSpec
+                    {
+                        Containers = new[]
+                        {
+                            new V1Container
+                            {
+                                Name = "test",
+                                Image = "nginx:latest",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        try
+        {
+            kubernetes.AppsV1.CreateNamespacedStatefulSet(statefulSet, namespaceParameter);
+
+            // Get rollout status
+            var status = client.RolloutStatus<V1StatefulSet>(statefulSetName, namespaceParameter);
+
+            // Status should contain the statefulset name or status information
+            Assert.NotNull(status);
+            Assert.NotEmpty(status);
+        }
+        finally
+        {
+            // Cleanup
+            try
+            {
+                kubernetes.AppsV1.DeleteNamespacedStatefulSet(statefulSetName, namespaceParameter);
+            }
+            catch (HttpOperationException)
+            {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}


Missing test coverage for RolloutUndo operation. The test file includes tests for RolloutRestart, RolloutStatus, RolloutPause/Resume, and RolloutHistory, but does not test the RolloutUndo functionality which is a critical operation for rolling back deployments.

Copilot · 2025-12-12T17:03:11Z