diff --git a/Makefile b/Makefile index 3cf7f8cce..70e4428b7 100644 --- a/Makefile +++ b/Makefile @@ -342,10 +342,10 @@ endef # E2E Test targets E2E_CLUSTER_NAME ?= agentcube-e2e AGENT_SANDBOX_REPO ?= https://github.com/kubernetes-sigs/agent-sandbox.git -AGENT_SANDBOX_VERSION ?= main +AGENT_SANDBOX_VERSION ?= v0.5.0rc1 e2e: - ./test/e2e/run_e2e.sh + AGENT_SANDBOX_VERSION=$(AGENT_SANDBOX_VERSION) ./test/e2e/run_e2e.sh e2e-clean: @echo "Cleaning up E2E environment..." diff --git a/cmd/agentd/main.go b/cmd/agentd/main.go index 16e72ac79..3300beacf 100644 --- a/cmd/agentd/main.go +++ b/cmd/agentd/main.go @@ -23,7 +23,7 @@ import ( "k8s.io/apimachinery/pkg/runtime" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/client-go/kubernetes/scheme" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" ctrl "sigs.k8s.io/controller-runtime" metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" @@ -36,7 +36,7 @@ var ( func init() { utilruntime.Must(scheme.AddToScheme(schemeBuilder)) - utilruntime.Must(sandboxv1alpha1.AddToScheme(schemeBuilder)) + utilruntime.Must(sandboxv1beta1.AddToScheme(schemeBuilder)) } func main() { @@ -54,7 +54,7 @@ func main() { } err = ctrl.NewControllerManagedBy(mgr). - For(&sandboxv1alpha1.Sandbox{}). + For(&sandboxv1beta1.Sandbox{}). Complete(&agentd.Reconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), diff --git a/cmd/workload-manager/main.go b/cmd/workload-manager/main.go index 7cfe2ea0e..399182144 100644 --- a/cmd/workload-manager/main.go +++ b/cmd/workload-manager/main.go @@ -29,8 +29,8 @@ import ( utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/client-go/kubernetes/scheme" "k8s.io/klog/v2" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/log/zap" metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" @@ -46,8 +46,8 @@ var ( func init() { utilruntime.Must(scheme.AddToScheme(schemeBuilder)) - utilruntime.Must(sandboxv1alpha1.AddToScheme(schemeBuilder)) - utilruntime.Must(extensionsv1alpha1.AddToScheme(schemeBuilder)) + utilruntime.Must(sandboxv1beta1.AddToScheme(schemeBuilder)) + utilruntime.Must(extensionsv1beta1.AddToScheme(schemeBuilder)) utilruntime.Must(runtimev1alpha1.AddToScheme(schemeBuilder)) } @@ -187,7 +187,7 @@ func main() { func setupControllers(mgr ctrl.Manager, sandboxReconciler *workloadmanager.SandboxReconciler, codeInterpreterReconciler *workloadmanager.CodeInterpreterReconciler) error { // Setup Sandbox controller if err := ctrl.NewControllerManagedBy(mgr). - For(&sandboxv1alpha1.Sandbox{}). + For(&sandboxv1beta1.Sandbox{}). Complete(sandboxReconciler); err != nil { return fmt.Errorf("unable to create sandbox controller: %w", err) } diff --git a/go.mod b/go.mod index 202320702..8bf42d58e 100644 --- a/go.mod +++ b/go.mod @@ -19,7 +19,7 @@ require ( k8s.io/client-go v0.35.4 k8s.io/klog/v2 v2.140.0 k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 - sigs.k8s.io/agent-sandbox v0.4.6 + sigs.k8s.io/agent-sandbox v0.4.7-0.20260608211546-6af1bbd0cf64 sigs.k8s.io/controller-runtime v0.23.3 ) diff --git a/go.sum b/go.sum index 2b8cb6a4b..2325a7856 100644 --- a/go.sum +++ b/go.sum @@ -252,8 +252,8 @@ k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 h1:SjGebBtkBqHFOli+05xYbK8YF1Dzk k8s.io/utils v0.0.0-20251002143259-bc988d571ff4/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50= rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= -sigs.k8s.io/agent-sandbox v0.4.6 h1:dUUvQ+rlv4kT3CB9p2MgnPcNSMAQg6eTBrWyCiYgxYs= -sigs.k8s.io/agent-sandbox v0.4.6/go.mod h1:rrBXoA+nKZO2MIs3pTG+qOuKadX5gzMvO/nrlwC9W1w= +sigs.k8s.io/agent-sandbox v0.4.7-0.20260608211546-6af1bbd0cf64 h1:dekixt66KCBkSC7rk35SiGE1irxnvVK/e6mvIm5PhtA= +sigs.k8s.io/agent-sandbox v0.4.7-0.20260608211546-6af1bbd0cf64/go.mod h1:++skTINslx4yHlnoqWoijeZuzhh0DobbtjPanh/JgRI= sigs.k8s.io/controller-runtime v0.23.3 h1:VjB/vhoPoA9l1kEKZHBMnQF33tdCLQKJtydy4iqwZ80= sigs.k8s.io/controller-runtime v0.23.3/go.mod h1:B6COOxKptp+YaUT5q4l6LqUJTRpizbgf9KSRNdQGns0= sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 h1:IpInykpT6ceI+QxKBbEflcR5EXP7sU1kvOlxwZh5txg= diff --git a/pkg/agentd/agentd.go b/pkg/agentd/agentd.go index 855ceb5bf..76b639455 100644 --- a/pkg/agentd/agentd.go +++ b/pkg/agentd/agentd.go @@ -22,7 +22,7 @@ import ( "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/runtime" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" @@ -36,7 +36,7 @@ type Reconciler struct { } func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} err := r.Get(ctx, req.NamespacedName, sandbox) if err != nil { if errors.IsNotFound(err) { @@ -80,6 +80,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu // SetupWithManager sets up the controller with the Manager. func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error { return ctrl.NewControllerManagedBy(mgr). - For(&sandboxv1alpha1.Sandbox{}). + For(&sandboxv1beta1.Sandbox{}). Complete(r) } diff --git a/pkg/agentd/agentd_test.go b/pkg/agentd/agentd_test.go index e638e432c..07ccfbb18 100644 --- a/pkg/agentd/agentd_test.go +++ b/pkg/agentd/agentd_test.go @@ -28,7 +28,7 @@ import ( "k8s.io/apimachinery/pkg/types" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/client-go/scale/scheme" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" "sigs.k8s.io/controller-runtime/pkg/reconcile" @@ -39,7 +39,7 @@ import ( func setupTestScheme() *runtime.Scheme { testScheme := runtime.NewScheme() utilruntime.Must(scheme.AddToScheme(testScheme)) - utilruntime.Must(sandboxv1alpha1.AddToScheme(testScheme)) + utilruntime.Must(sandboxv1beta1.AddToScheme(testScheme)) return testScheme } @@ -49,13 +49,13 @@ func TestReconciler_Reconcile_RuntimeRegistration(t *testing.T) { tests := []struct { name string - sandbox *sandboxv1alpha1.Sandbox + sandbox *sandboxv1beta1.Sandbox expectRequeue bool expectDeletion bool }{ { name: "Newly registered sandbox without last-activity-time should not be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "new-sandbox", Namespace: "default", @@ -67,7 +67,7 @@ func TestReconciler_Reconcile_RuntimeRegistration(t *testing.T) { }, { name: "Sandbox with empty last-activity-time annotation should not be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "empty-annotation-sandbox", Namespace: "default", @@ -108,7 +108,7 @@ func TestReconciler_Reconcile_RuntimeRegistration(t *testing.T) { } // Verify sandbox still exists - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} err = fakeClient.Get(context.Background(), types.NamespacedName{ Name: tt.sandbox.Name, Namespace: tt.sandbox.Namespace, @@ -131,7 +131,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { tests := []struct { name string - sandbox *sandboxv1alpha1.Sandbox + sandbox *sandboxv1beta1.Sandbox expectDeletion bool expectRequeue bool expectedRequeueAt time.Duration @@ -139,7 +139,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }{ { name: "Sandbox with recent activity should be requeued", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "recent-activity-sandbox", Namespace: "default", @@ -155,7 +155,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox exactly at expiration boundary should be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "expired-sandbox", Namespace: "default", @@ -170,7 +170,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox past expiration should be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "past-expired-sandbox", Namespace: "default", @@ -185,7 +185,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with activity just before expiration should be requeued", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "near-expiration-sandbox", Namespace: "default", @@ -201,7 +201,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with custom short timeout should be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "custom-short-timeout-sandbox", Namespace: "default", @@ -217,7 +217,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with custom long timeout should be requeued", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "custom-long-timeout-sandbox", Namespace: "default", @@ -234,7 +234,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with invalid custom timeout should fallback to default", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "invalid-timeout-sandbox", Namespace: "default", @@ -251,7 +251,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with negative custom timeout should fallback to default", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "negative-timeout-sandbox", Namespace: "default", @@ -268,7 +268,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { }, { name: "Sandbox with zero custom timeout should fallback to default", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "zero-timeout-sandbox", Namespace: "default", @@ -318,7 +318,7 @@ func TestReconciler_Reconcile_LifecycleOrchestration(t *testing.T) { } // Verify deletion status - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} err = fakeClient.Get(context.Background(), types.NamespacedName{ Name: tt.sandbox.Name, Namespace: tt.sandbox.Namespace, @@ -366,7 +366,7 @@ func TestReconciler_Reconcile_ErrorPaths(t *testing.T) { { name: "Invalid time format should return error and requeue", setupClient: func() client.Client { - sandbox := &sandboxv1alpha1.Sandbox{ + sandbox := &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "invalid-time-sandbox", Namespace: "default", @@ -425,14 +425,14 @@ func TestReconciler_Reconcile_EdgeCases(t *testing.T) { tests := []struct { name string - sandbox *sandboxv1alpha1.Sandbox + sandbox *sandboxv1beta1.Sandbox expectRequeue bool expectDeletion bool description string }{ { name: "Sandbox with future last-activity-time should not be deleted", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "future-time-sandbox", Namespace: "default", @@ -447,7 +447,7 @@ func TestReconciler_Reconcile_EdgeCases(t *testing.T) { }, { name: "Sandbox with multiple annotations should work correctly", - sandbox: &sandboxv1alpha1.Sandbox{ + sandbox: &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "multi-annotation-sandbox", Namespace: "default", @@ -491,7 +491,7 @@ func TestReconciler_Reconcile_EdgeCases(t *testing.T) { } // Verify deletion status - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} err = fakeClient.Get(context.Background(), types.NamespacedName{ Name: tt.sandbox.Name, Namespace: tt.sandbox.Namespace, diff --git a/pkg/workloadmanager/codeinterpreter_controller.go b/pkg/workloadmanager/codeinterpreter_controller.go index bce73a0d5..09770a0b7 100644 --- a/pkg/workloadmanager/codeinterpreter_controller.go +++ b/pkg/workloadmanager/codeinterpreter_controller.go @@ -36,11 +36,11 @@ import ( "sigs.k8s.io/controller-runtime/pkg/predicate" runtimev1alpha1 "github.com/volcano-sh/agentcube/pkg/apis/runtime/v1alpha1" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) -const codeInterpreterNetworkPolicyManagement = extensionsv1alpha1.NetworkPolicyManagementUnmanaged +const codeInterpreterNetworkPolicyManagement = extensionsv1beta1.NetworkPolicyManagementUnmanaged // CodeInterpreterReconciler reconciles a CodeInterpreter object type CodeInterpreterReconciler struct { @@ -143,7 +143,7 @@ func (r *CodeInterpreterReconciler) ensureSandboxTemplate(ctx context.Context, c } templateName := ci.Name - sandboxTemplate := &extensionsv1alpha1.SandboxTemplate{} + sandboxTemplate := &extensionsv1beta1.SandboxTemplate{} err := r.Get(ctx, types.NamespacedName{Name: templateName, Namespace: ci.Namespace}, sandboxTemplate) // Convert CodeInterpreterSandboxTemplate to PodTemplate @@ -151,12 +151,12 @@ func (r *CodeInterpreterReconciler) ensureSandboxTemplate(ctx context.Context, c if errors.IsNotFound(err) { // Create new SandboxTemplate - sandboxTemplate = &extensionsv1alpha1.SandboxTemplate{ + sandboxTemplate = &extensionsv1beta1.SandboxTemplate{ ObjectMeta: metav1.ObjectMeta{ Name: templateName, Namespace: ci.Namespace, }, - Spec: extensionsv1alpha1.SandboxTemplateSpec{ + Spec: extensionsv1beta1.SandboxTemplateSpec{ PodTemplate: podTemplate, NetworkPolicyManagement: codeInterpreterNetworkPolicyManagement, }, @@ -204,19 +204,19 @@ func (r *CodeInterpreterReconciler) ensureSandboxWarmPool(ctx context.Context, c templateName := ci.Name warmPoolName := ci.Name - warmPool := &extensionsv1alpha1.SandboxWarmPool{} + warmPool := &extensionsv1beta1.SandboxWarmPool{} err := r.Get(ctx, types.NamespacedName{Name: warmPoolName, Namespace: ci.Namespace}, warmPool) if errors.IsNotFound(err) { // Create new SandboxWarmPool - warmPool = &extensionsv1alpha1.SandboxWarmPool{ + warmPool = &extensionsv1beta1.SandboxWarmPool{ ObjectMeta: metav1.ObjectMeta{ Name: warmPoolName, Namespace: ci.Namespace, }, - Spec: extensionsv1alpha1.SandboxWarmPoolSpec{ + Spec: extensionsv1beta1.SandboxWarmPoolSpec{ Replicas: *ci.Spec.WarmPoolSize, - TemplateRef: extensionsv1alpha1.SandboxTemplateRef{ + TemplateRef: extensionsv1beta1.SandboxTemplateRef{ Name: templateName, }, }, @@ -260,7 +260,7 @@ func (r *CodeInterpreterReconciler) ensureSandboxWarmPool(ctx context.Context, c // deleteSandboxWarmPool deletes the SandboxWarmPool if it exists func (r *CodeInterpreterReconciler) deleteSandboxWarmPool(ctx context.Context, ci *runtimev1alpha1.CodeInterpreter) error { warmPoolName := ci.Name - warmPool := &extensionsv1alpha1.SandboxWarmPool{} + warmPool := &extensionsv1beta1.SandboxWarmPool{} err := r.Get(ctx, types.NamespacedName{Name: warmPoolName, Namespace: ci.Namespace}, warmPool) if errors.IsNotFound(err) { return nil @@ -280,7 +280,7 @@ func (r *CodeInterpreterReconciler) deleteSandboxWarmPool(ctx context.Context, c // deleteSandboxTemplate deletes the SandboxTemplate if it exists func (r *CodeInterpreterReconciler) deleteSandboxTemplate(ctx context.Context, ci *runtimev1alpha1.CodeInterpreter) error { templateName := ci.Name - sandboxTemplate := &extensionsv1alpha1.SandboxTemplate{} + sandboxTemplate := &extensionsv1beta1.SandboxTemplate{} err := r.Get(ctx, types.NamespacedName{Name: templateName, Namespace: ci.Namespace}, sandboxTemplate) if errors.IsNotFound(err) { return nil @@ -297,8 +297,8 @@ func (r *CodeInterpreterReconciler) deleteSandboxTemplate(ctx context.Context, c return nil } -// convertToPodTemplate converts CodeInterpreterSandboxTemplate to sandboxv1alpha1.PodTemplate -func (r *CodeInterpreterReconciler) convertToPodTemplate(template *runtimev1alpha1.CodeInterpreterSandboxTemplate, ci *runtimev1alpha1.CodeInterpreter) sandboxv1alpha1.PodTemplate { +// convertToPodTemplate converts CodeInterpreterSandboxTemplate to sandboxv1beta1.PodTemplate +func (r *CodeInterpreterReconciler) convertToPodTemplate(template *runtimev1alpha1.CodeInterpreterSandboxTemplate, ci *runtimev1alpha1.CodeInterpreter) sandboxv1beta1.PodTemplate { // Normalize RuntimeClassName: if it's an empty string, set it to nil runtimeClassName := template.RuntimeClassName if runtimeClassName != nil && *runtimeClassName == "" { @@ -333,13 +333,13 @@ func (r *CodeInterpreterReconciler) convertToPodTemplate(template *runtimev1alph RuntimeClassName: runtimeClassName, } - return sandboxv1alpha1.PodTemplate{ + return sandboxv1beta1.PodTemplate{ Spec: podSpec, } } // podTemplateEqual checks if two PodTemplates are equal -func (r *CodeInterpreterReconciler) podTemplateEqual(a, b sandboxv1alpha1.PodTemplate) bool { +func (r *CodeInterpreterReconciler) podTemplateEqual(a, b sandboxv1beta1.PodTemplate) bool { // Use reflect.DeepEqual for a comprehensive comparison. return reflect.DeepEqual(a.Spec, b.Spec) } diff --git a/pkg/workloadmanager/codeinterpreter_controller_test.go b/pkg/workloadmanager/codeinterpreter_controller_test.go index b33c65b2e..dd7243d6d 100644 --- a/pkg/workloadmanager/codeinterpreter_controller_test.go +++ b/pkg/workloadmanager/codeinterpreter_controller_test.go @@ -28,14 +28,14 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" runtimev1alpha1 "github.com/volcano-sh/agentcube/pkg/apis/runtime/v1alpha1" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) func setupTestReconciler() *CodeInterpreterReconciler { scheme := runtime.NewScheme() _ = runtimev1alpha1.AddToScheme(scheme) - _ = sandboxv1alpha1.AddToScheme(scheme) + _ = sandboxv1beta1.AddToScheme(scheme) _ = corev1.AddToScheme(scheme) client := fake.NewClientBuilder().WithScheme(scheme).Build() @@ -49,8 +49,8 @@ func setupTestReconciler() *CodeInterpreterReconciler { func newTestReconcilerWithObjects(objects ...runtime.Object) *CodeInterpreterReconciler { scheme := runtime.NewScheme() _ = runtimev1alpha1.AddToScheme(scheme) - _ = sandboxv1alpha1.AddToScheme(scheme) - _ = extensionsv1alpha1.AddToScheme(scheme) + _ = sandboxv1beta1.AddToScheme(scheme) + _ = extensionsv1beta1.AddToScheme(scheme) _ = corev1.AddToScheme(scheme) client := fake.NewClientBuilder().WithScheme(scheme).WithRuntimeObjects(objects...).Build() @@ -90,25 +90,25 @@ func TestEnsureSandboxTemplateDisablesAgentSandboxDefaultNetworkPolicy(t *testin _, err := reconciler.ensureSandboxTemplate(context.Background(), ci) assert.NoError(t, err) - sandboxTemplate := &extensionsv1alpha1.SandboxTemplate{} + sandboxTemplate := &extensionsv1beta1.SandboxTemplate{} err = reconciler.Get(context.Background(), types.NamespacedName{ Name: ci.Name, Namespace: ci.Namespace, }, sandboxTemplate) assert.NoError(t, err) - assert.Equal(t, extensionsv1alpha1.NetworkPolicyManagementUnmanaged, sandboxTemplate.Spec.NetworkPolicyManagement) + assert.Equal(t, extensionsv1beta1.NetworkPolicyManagementUnmanaged, sandboxTemplate.Spec.NetworkPolicyManagement) } func TestEnsureSandboxTemplateUpdatesManagedNetworkPolicyToUnmanaged(t *testing.T) { ci := testCodeInterpreterWithWarmPool() - existing := &extensionsv1alpha1.SandboxTemplate{ + existing := &extensionsv1beta1.SandboxTemplate{ ObjectMeta: metav1.ObjectMeta{ Name: ci.Name, Namespace: ci.Namespace, }, - Spec: extensionsv1alpha1.SandboxTemplateSpec{ - NetworkPolicyManagement: extensionsv1alpha1.NetworkPolicyManagementManaged, - PodTemplate: sandboxv1alpha1.PodTemplate{ + Spec: extensionsv1beta1.SandboxTemplateSpec{ + NetworkPolicyManagement: extensionsv1beta1.NetworkPolicyManagementManaged, + PodTemplate: sandboxv1beta1.PodTemplate{ Spec: corev1.PodSpec{ Containers: []corev1.Container{{ Name: "codeinterpreter", @@ -123,13 +123,13 @@ func TestEnsureSandboxTemplateUpdatesManagedNetworkPolicyToUnmanaged(t *testing. _, err := reconciler.ensureSandboxTemplate(context.Background(), ci) assert.NoError(t, err) - sandboxTemplate := &extensionsv1alpha1.SandboxTemplate{} + sandboxTemplate := &extensionsv1beta1.SandboxTemplate{} err = reconciler.Get(context.Background(), types.NamespacedName{ Name: ci.Name, Namespace: ci.Namespace, }, sandboxTemplate) assert.NoError(t, err) - assert.Equal(t, extensionsv1alpha1.NetworkPolicyManagementUnmanaged, sandboxTemplate.Spec.NetworkPolicyManagement) + assert.Equal(t, extensionsv1beta1.NetworkPolicyManagementUnmanaged, sandboxTemplate.Spec.NetworkPolicyManagement) } func TestConvertToPodTemplate_RuntimeClassName_TableDriven(t *testing.T) { diff --git a/pkg/workloadmanager/handlers.go b/pkg/workloadmanager/handlers.go index 3cc7d4be7..2568c1ffe 100644 --- a/pkg/workloadmanager/handlers.go +++ b/pkg/workloadmanager/handlers.go @@ -27,8 +27,8 @@ import ( apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/client-go/dynamic" "k8s.io/klog/v2" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" "github.com/volcano-sh/agentcube/pkg/api" "github.com/volcano-sh/agentcube/pkg/common/types" @@ -109,8 +109,8 @@ func (s *Server) handleSandboxCreate(c *gin.Context, kind string) { return } - var sandbox *sandboxv1alpha1.Sandbox - var sandboxClaim *extensionsv1alpha1.SandboxClaim + var sandbox *sandboxv1beta1.Sandbox + var sandboxClaim *extensionsv1beta1.SandboxClaim var sandboxEntry *sandboxEntry var err error switch sandboxReq.Kind { @@ -163,7 +163,7 @@ func (s *Server) handleSandboxCreate(c *gin.Context, kind string) { respondJSON(c, http.StatusOK, response) } -func (s *Server) respondSandboxCreateError(c *gin.Context, sandbox *sandboxv1alpha1.Sandbox, err error) { +func (s *Server) respondSandboxCreateError(c *gin.Context, sandbox *sandboxv1beta1.Sandbox, err error) { if errors.Is(err, context.Canceled) { klog.Warningf("create sandbox aborted %s/%s: client disconnected", sandbox.Namespace, sandbox.Name) c.AbortWithStatus(499) @@ -196,7 +196,7 @@ func isInternalSandboxCreateError(err error) bool { } // createK8sResources creates the K8s sandbox or sandbox claim resource. -func (s *Server) createK8sResources(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox, sandboxClaim *extensionsv1alpha1.SandboxClaim) error { +func (s *Server) createK8sResources(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1beta1.Sandbox, sandboxClaim *extensionsv1beta1.SandboxClaim) error { if sandboxClaim != nil { if err := createSandboxClaim(ctx, dynamicClient, sandboxClaim); err != nil { if isContextError(err) { @@ -215,7 +215,7 @@ func (s *Server) createK8sResources(ctx context.Context, dynamicClient dynamic.I return nil } -func (s *Server) waitForDirectSandboxReady(ctx context.Context, sandbox *sandboxv1alpha1.Sandbox, resultChan <-chan SandboxStatusUpdate) (*sandboxv1alpha1.Sandbox, error) { +func (s *Server) waitForDirectSandboxReady(ctx context.Context, sandbox *sandboxv1beta1.Sandbox, resultChan <-chan SandboxStatusUpdate) (*sandboxv1beta1.Sandbox, error) { if resultChan == nil { return nil, errSandboxReadyWatcherNotRegistered } @@ -247,7 +247,7 @@ func (s *Server) waitForDirectSandboxReady(ctx context.Context, sandbox *sandbox } } -func (s *Server) waitForClaimSandboxReady(ctx context.Context, dynamicClient dynamic.Interface, sandboxClaim *extensionsv1alpha1.SandboxClaim) (*sandboxv1alpha1.Sandbox, error) { +func (s *Server) waitForClaimSandboxReady(ctx context.Context, dynamicClient dynamic.Interface, sandboxClaim *extensionsv1beta1.SandboxClaim) (*sandboxv1beta1.Sandbox, error) { timer := time.NewTimer(2 * time.Minute) // consistent with router settings defer timer.Stop() ticker := time.NewTicker(1 * time.Second) @@ -288,7 +288,7 @@ func (s *Server) waitForClaimSandboxReady(ctx context.Context, dynamicClient dyn } } -func (s *Server) waitForCreatedSandbox(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox, sandboxClaim *extensionsv1alpha1.SandboxClaim, resultChan <-chan SandboxStatusUpdate) (*sandboxv1alpha1.Sandbox, error) { +func (s *Server) waitForCreatedSandbox(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1beta1.Sandbox, sandboxClaim *extensionsv1beta1.SandboxClaim, resultChan <-chan SandboxStatusUpdate) (*sandboxv1beta1.Sandbox, error) { if sandboxClaim != nil { return s.waitForClaimSandboxReady(ctx, dynamicClient, sandboxClaim) } @@ -296,7 +296,7 @@ func (s *Server) waitForCreatedSandbox(ctx context.Context, dynamicClient dynami } // createSandbox performs sandbox creation and returns the response payload or an error with an HTTP status code. -func (s *Server) createSandbox(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox, sandboxClaim *extensionsv1alpha1.SandboxClaim, sandboxEntry *sandboxEntry, resultChan <-chan SandboxStatusUpdate) (*types.CreateSandboxResponse, error) { +func (s *Server) createSandbox(ctx context.Context, dynamicClient dynamic.Interface, sandbox *sandboxv1beta1.Sandbox, sandboxClaim *extensionsv1beta1.SandboxClaim, sandboxEntry *sandboxEntry, resultChan <-chan SandboxStatusUpdate) (*types.CreateSandboxResponse, error) { placeholder := buildSandboxPlaceHolder(sandbox, sandboxEntry) if err := s.storeClient.StoreSandbox(ctx, placeholder); err != nil { if isContextError(err) { @@ -329,7 +329,7 @@ func (s *Server) createSandbox(ctx context.Context, dynamicClient dynamic.Interf // if warmpool is used, the pod name is stored in sandbox's annotation `agents.x-k8s.io/pod-name` sandboxNameForPod := createdSandbox.Name sandboxPodName := createdSandbox.Name - if podName, exists := createdSandbox.Annotations[sandboxv1alpha1.SandboxPodNameAnnotation]; exists { + if podName, exists := createdSandbox.Annotations[sandboxv1beta1.SandboxPodNameAnnotation]; exists { sandboxPodName = podName } @@ -379,7 +379,7 @@ func (s *Server) createSandbox(ctx context.Context, dynamicClient dynamic.Interf // rollbackSandboxCreation deletes the sandbox (or sandbox claim) and its store // placeholder when creation fails. It runs in a fresh context so that a // canceled request context does not prevent cleanup. -func (s *Server) rollbackSandboxCreation(dynamicClient dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox, sandboxClaim *extensionsv1alpha1.SandboxClaim, sessionID string) { +func (s *Server) rollbackSandboxCreation(dynamicClient dynamic.Interface, sandbox *sandboxv1beta1.Sandbox, sandboxClaim *extensionsv1beta1.SandboxClaim, sessionID string) { ctxTimeout, cancel := context.WithTimeout(context.Background(), storeCleanupTimeout) defer cancel() if sandboxClaim != nil { diff --git a/pkg/workloadmanager/handlers_test.go b/pkg/workloadmanager/handlers_test.go index 19366e915..5a938c6c7 100644 --- a/pkg/workloadmanager/handlers_test.go +++ b/pkg/workloadmanager/handlers_test.go @@ -41,8 +41,8 @@ import ( "k8s.io/client-go/dynamic" dynamicfake "k8s.io/client-go/dynamic/fake" k8stesting "k8s.io/client-go/testing" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) type fakeStore struct { @@ -77,17 +77,17 @@ func (f *fakeStore) UpdateSessionLastActivity(_ context.Context, _ string, _ tim } func (f *fakeStore) Close() error { return nil } -func readySandbox() *sandboxv1alpha1.Sandbox { - return &sandboxv1alpha1.Sandbox{ +func readySandbox() *sandboxv1beta1.Sandbox { + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "sandbox-1", Namespace: "ns-1", UID: "uid-123", - Annotations: map[string]string{sandboxv1alpha1.SandboxPodNameAnnotation: "pod-1"}, + Annotations: map[string]string{sandboxv1beta1.SandboxPodNameAnnotation: "pod-1"}, CreationTimestamp: metav1.Now(), }, - Status: sandboxv1alpha1.SandboxStatus{Conditions: []metav1.Condition{{ - Type: string(sandboxv1alpha1.SandboxConditionReady), + Status: sandboxv1beta1.SandboxStatus{Conditions: []metav1.Condition{{ + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }}}, } @@ -209,14 +209,14 @@ func TestServerCreateSandbox(t *testing.T) { patches := gomonkey.NewPatches() defer patches.Reset() - patches.ApplyFunc(createSandbox, func(_ context.Context, _ dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox) (*SandboxInfo, error) { + patches.ApplyFunc(createSandbox, func(_ context.Context, _ dynamic.Interface, sandbox *sandboxv1beta1.Sandbox) (*SandboxInfo, error) { createCalls++ if cur.createSandboxErr != nil { return nil, cur.createSandboxErr } return &SandboxInfo{Name: sandbox.Name, Namespace: sandbox.Namespace}, nil }) - patches.ApplyFunc(createSandboxClaim, func(_ context.Context, _ dynamic.Interface, _ *extensionsv1alpha1.SandboxClaim) error { + patches.ApplyFunc(createSandboxClaim, func(_ context.Context, _ dynamic.Interface, _ *extensionsv1beta1.SandboxClaim) error { claimCalls++ return cur.createClaimErr }) @@ -237,7 +237,7 @@ func TestServerCreateSandbox(t *testing.T) { patches.ApplyPrivateMethod(reflect.TypeOf(server), "waitForSandboxEntryPointsReady", func(_ *Server, _ context.Context, _ string, _ *sandboxEntry) error { return cur.readyErr }) - patches.ApplyPrivateMethod(reflect.TypeOf(server), "waitForCreatedSandbox", func(_ *Server, _ context.Context, _ dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox, _ *extensionsv1alpha1.SandboxClaim, resultChan <-chan SandboxStatusUpdate) (*sandboxv1alpha1.Sandbox, error) { + patches.ApplyPrivateMethod(reflect.TypeOf(server), "waitForCreatedSandbox", func(_ *Server, _ context.Context, _ dynamic.Interface, sandbox *sandboxv1beta1.Sandbox, _ *extensionsv1beta1.SandboxClaim, resultChan <-chan SandboxStatusUpdate) (*sandboxv1beta1.Sandbox, error) { if resultChan == nil { return readySandbox(), nil } @@ -266,9 +266,9 @@ func TestServerCreateSandbox(t *testing.T) { resultChan <- SandboxStatusUpdate{Sandbox: sb.DeepCopy()} } - claim := (*extensionsv1alpha1.SandboxClaim)(nil) + claim := (*extensionsv1beta1.SandboxClaim)(nil) if tt.sandboxClaim { - claim = &extensionsv1alpha1.SandboxClaim{ObjectMeta: metav1.ObjectMeta{Name: sb.Name, Namespace: sb.Namespace}} + claim = &extensionsv1beta1.SandboxClaim{ObjectMeta: metav1.ObjectMeta{Name: sb.Name, Namespace: sb.Namespace}} } resp, err := server.createSandbox(context.Background(), nil, sb, claim, makeEntry(), resultChan) @@ -300,17 +300,17 @@ func TestServerCreateSandbox(t *testing.T) { } func TestServerCreateSandboxClaimUsesAdoptedSandboxButStoresClaimName(t *testing.T) { - claim := &extensionsv1alpha1.SandboxClaim{ + claim := &extensionsv1beta1.SandboxClaim{ TypeMeta: metav1.TypeMeta{ - APIVersion: "extensions.agents.x-k8s.io/v1alpha1", + APIVersion: "extensions.agents.x-k8s.io/v1beta1", Kind: types.SandboxClaimsKind, }, ObjectMeta: metav1.ObjectMeta{ Name: "ci-claim", Namespace: "ns-1", }, - Status: extensionsv1alpha1.SandboxClaimStatus{ - SandboxStatus: extensionsv1alpha1.SandboxStatus{ + Status: extensionsv1beta1.SandboxClaimStatus{ + SandboxStatus: extensionsv1beta1.SandboxStatus{ Name: "warm-pool-sandbox-abc", }, }, @@ -321,7 +321,7 @@ func TestServerCreateSandboxClaimUsesAdoptedSandboxButStoresClaimName(t *testing adoptedSandboxUnstructured := &unstructured.Unstructured{ Object: map[string]interface{}{ - "apiVersion": "agents.x-k8s.io/v1alpha1", + "apiVersion": "agents.x-k8s.io/v1beta1", "kind": types.SandboxKind, "metadata": map[string]interface{}{ "name": "warm-pool-sandbox-abc", @@ -329,13 +329,13 @@ func TestServerCreateSandboxClaimUsesAdoptedSandboxButStoresClaimName(t *testing "uid": "adopted-uid", "creationTimestamp": metav1.Now().Format(time.RFC3339), "annotations": map[string]interface{}{ - sandboxv1alpha1.SandboxPodNameAnnotation: "warm-pool-pod-abc", + sandboxv1beta1.SandboxPodNameAnnotation: "warm-pool-pod-abc", }, }, "status": map[string]interface{}{ "conditions": []interface{}{ map[string]interface{}{ - "type": string(sandboxv1alpha1.SandboxConditionReady), + "type": string(sandboxv1beta1.SandboxConditionReady), "status": string(metav1.ConditionTrue), }, }, @@ -364,7 +364,7 @@ func TestServerCreateSandboxClaimUsesAdoptedSandboxButStoresClaimName(t *testing patches := gomonkey.NewPatches() defer patches.Reset() - patches.ApplyFunc(createSandboxClaim, func(_ context.Context, _ dynamic.Interface, _ *extensionsv1alpha1.SandboxClaim) error { + patches.ApplyFunc(createSandboxClaim, func(_ context.Context, _ dynamic.Interface, _ *extensionsv1beta1.SandboxClaim) error { return nil }) patches.ApplyFunc(deleteSandboxClaim, func(_ context.Context, _ dynamic.Interface, _, _ string) error { @@ -380,7 +380,7 @@ func TestServerCreateSandboxClaimUsesAdoptedSandboxButStoresClaimName(t *testing return nil }) - templateSandbox := &sandboxv1alpha1.Sandbox{ + templateSandbox := &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: claim.Name, Namespace: claim.Namespace, @@ -439,7 +439,7 @@ func newFakeServer() *Server { } } -func makeSandbox(kind, ns, name string) (*sandboxv1alpha1.Sandbox, *sandboxEntry) { +func makeSandbox(kind, ns, name string) (*sandboxv1beta1.Sandbox, *sandboxEntry) { entry := &sandboxEntry{ Kind: kind, SessionID: "sess-1", @@ -447,10 +447,10 @@ func makeSandbox(kind, ns, name string) (*sandboxv1alpha1.Sandbox, *sandboxEntry {Port: 8080, Protocol: runtimev1alpha1.ProtocolTypeHTTP, PathPrefix: "/api"}, }, } - return &sandboxv1alpha1.Sandbox{ + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: ns}, - Status: sandboxv1alpha1.SandboxStatus{Conditions: []metav1.Condition{{ - Type: string(sandboxv1alpha1.SandboxConditionReady), + Status: sandboxv1beta1.SandboxStatus{Conditions: []metav1.Condition{{ + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }}}, }, entry @@ -576,12 +576,12 @@ func TestHandleSandboxCreate(t *testing.T) { c.Request = req sb, entry := makeSandbox(tc.kind, "ns", "sandbox-1") - claim := &extensionsv1alpha1.SandboxClaim{ObjectMeta: metav1.ObjectMeta{Name: sb.Name, Namespace: sb.Namespace}} + claim := &extensionsv1beta1.SandboxClaim{ObjectMeta: metav1.ObjectMeta{Name: sb.Name, Namespace: sb.Namespace}} patches := gomonkey.NewPatches() defer patches.Reset() - patches.ApplyFunc(buildSandboxByAgentRuntime, func(_, _ string, _ *Informers) (*sandboxv1alpha1.Sandbox, *sandboxEntry, error) { + patches.ApplyFunc(buildSandboxByAgentRuntime, func(_, _ string, _ *Informers) (*sandboxv1beta1.Sandbox, *sandboxEntry, error) { if tc.kind != types.AgentRuntimeKind { return nil, nil, errors.New("unexpected kind") } @@ -591,7 +591,7 @@ func TestHandleSandboxCreate(t *testing.T) { return sb, entry, nil }) - patches.ApplyFunc(buildSandboxByCodeInterpreter, func(_, _ string, _ *Informers) (*sandboxv1alpha1.Sandbox, *extensionsv1alpha1.SandboxClaim, *sandboxEntry, error) { + patches.ApplyFunc(buildSandboxByCodeInterpreter, func(_, _ string, _ *Informers) (*sandboxv1beta1.Sandbox, *extensionsv1beta1.SandboxClaim, *sandboxEntry, error) { if tc.kind != types.CodeInterpreterKind { return nil, nil, nil, errors.New("unexpected kind") } @@ -602,7 +602,7 @@ func TestHandleSandboxCreate(t *testing.T) { }) createCalls := 0 - patches.ApplyPrivateMethod(reflect.TypeOf(fakeServer), "createSandbox", func(_ *Server, _ context.Context, _ dynamic.Interface, _ *sandboxv1alpha1.Sandbox, _ *extensionsv1alpha1.SandboxClaim, _ *sandboxEntry, _ <-chan SandboxStatusUpdate) (*types.CreateSandboxResponse, error) { + patches.ApplyPrivateMethod(reflect.TypeOf(fakeServer), "createSandbox", func(_ *Server, _ context.Context, _ dynamic.Interface, _ *sandboxv1beta1.Sandbox, _ *extensionsv1beta1.SandboxClaim, _ *sandboxEntry, _ <-chan SandboxStatusUpdate) (*types.CreateSandboxResponse, error) { createCalls++ if tc.createErr != nil { return nil, tc.createErr diff --git a/pkg/workloadmanager/informers.go b/pkg/workloadmanager/informers.go index 22ed6c882..519490984 100644 --- a/pkg/workloadmanager/informers.go +++ b/pkg/workloadmanager/informers.go @@ -41,12 +41,12 @@ var ( } SandboxGVR = schema.GroupVersionResource{ Group: "agents.x-k8s.io", - Version: "v1alpha1", + Version: "v1beta1", Resource: "sandboxes", } SandboxClaimGVR = schema.GroupVersionResource{ Group: "extensions.agents.x-k8s.io", - Version: "v1alpha1", + Version: "v1beta1", Resource: "sandboxclaims", } ) diff --git a/pkg/workloadmanager/k8s_client.go b/pkg/workloadmanager/k8s_client.go index 602fb08f5..dd8cb2923 100644 --- a/pkg/workloadmanager/k8s_client.go +++ b/pkg/workloadmanager/k8s_client.go @@ -40,8 +40,8 @@ import ( "k8s.io/client-go/rest" "k8s.io/client-go/tools/cache" "k8s.io/client-go/tools/clientcmd" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) const ( @@ -127,7 +127,7 @@ func NewK8sClient() (*K8sClient, error) { // Create scheme and register agent-sandbox types scheme := runtime.NewScheme() - if err := sandboxv1alpha1.AddToScheme(scheme); err != nil { + if err := sandboxv1beta1.AddToScheme(scheme); err != nil { return nil, fmt.Errorf("failed to add agent-sandbox scheme: %w", err) } @@ -213,7 +213,7 @@ func (c *K8sClient) GetOrCreateUserK8sClient(userToken, namespace, serviceAccoun } // createSandbox creates a Sandbox using the provided dynamic client -func createSandbox(ctx context.Context, client dynamic.Interface, sandbox *sandboxv1alpha1.Sandbox) (*SandboxInfo, error) { +func createSandbox(ctx context.Context, client dynamic.Interface, sandbox *sandboxv1beta1.Sandbox) (*SandboxInfo, error) { // Convert to unstructured for dynamic client unstructuredObj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(sandbox) if err != nil { @@ -239,13 +239,13 @@ func createSandbox(ctx context.Context, client dynamic.Interface, sandbox *sandb } // getSandbox gets a Sandbox using the provided dynamic client. -func getSandbox(ctx context.Context, client dynamic.Interface, namespace, sandboxName string) (*sandboxv1alpha1.Sandbox, error) { +func getSandbox(ctx context.Context, client dynamic.Interface, namespace, sandboxName string) (*sandboxv1beta1.Sandbox, error) { obj, err := client.Resource(SandboxGVR).Namespace(namespace).Get(ctx, sandboxName, metav1.GetOptions{}) if err != nil { return nil, fmt.Errorf("failed to get sandbox %s/%s: %w", namespace, sandboxName, err) } - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} if err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, sandbox); err != nil { return nil, fmt.Errorf("failed to convert sandbox %s/%s: %w", namespace, sandboxName, err) } @@ -253,7 +253,7 @@ func getSandbox(ctx context.Context, client dynamic.Interface, namespace, sandbo } // createSandboxClaim creates a SandboxClaim using the provided dynamic client -func createSandboxClaim(ctx context.Context, client dynamic.Interface, sandboxClaim *extensionsv1alpha1.SandboxClaim) error { +func createSandboxClaim(ctx context.Context, client dynamic.Interface, sandboxClaim *extensionsv1beta1.SandboxClaim) error { // Convert to unstructured for dynamic client unstructuredObj, err := runtime.DefaultUnstructuredConverter.ToUnstructured(sandboxClaim) if err != nil { @@ -276,13 +276,13 @@ func createSandboxClaim(ctx context.Context, client dynamic.Interface, sandboxCl } // getSandboxClaim gets a SandboxClaim using the provided dynamic client. -func getSandboxClaim(ctx context.Context, client dynamic.Interface, namespace, sandboxClaimName string) (*extensionsv1alpha1.SandboxClaim, error) { +func getSandboxClaim(ctx context.Context, client dynamic.Interface, namespace, sandboxClaimName string) (*extensionsv1beta1.SandboxClaim, error) { obj, err := client.Resource(SandboxClaimGVR).Namespace(namespace).Get(ctx, sandboxClaimName, metav1.GetOptions{}) if err != nil { return nil, fmt.Errorf("failed to get sandbox claim %s/%s: %w", namespace, sandboxClaimName, err) } - sandboxClaim := &extensionsv1alpha1.SandboxClaim{} + sandboxClaim := &extensionsv1beta1.SandboxClaim{} if err := runtime.DefaultUnstructuredConverter.FromUnstructured(obj.Object, sandboxClaim); err != nil { return nil, fmt.Errorf("failed to convert sandbox claim %s/%s: %w", namespace, sandboxClaimName, err) } @@ -318,12 +318,12 @@ func deleteSandboxClaim(ctx context.Context, client dynamic.Interface, namespace } // CreateSandboxClaim creates a new SandboxClaim using user's permissions -func (u *UserK8sClient) CreateSandboxClaim(ctx context.Context, sandboxClaim *extensionsv1alpha1.SandboxClaim) error { +func (u *UserK8sClient) CreateSandboxClaim(ctx context.Context, sandboxClaim *extensionsv1beta1.SandboxClaim) error { return createSandboxClaim(ctx, u.dynamicClient, sandboxClaim) } // CreateSandbox creates a new Sandbox using user's permissions -func (u *UserK8sClient) CreateSandbox(ctx context.Context, sandbox *sandboxv1alpha1.Sandbox) (*SandboxInfo, error) { +func (u *UserK8sClient) CreateSandbox(ctx context.Context, sandbox *sandboxv1beta1.Sandbox) (*SandboxInfo, error) { return createSandbox(ctx, u.dynamicClient, sandbox) } diff --git a/pkg/workloadmanager/sandbox_controller.go b/pkg/workloadmanager/sandbox_controller.go index ccc4632c5..91a6b1e09 100644 --- a/pkg/workloadmanager/sandbox_controller.go +++ b/pkg/workloadmanager/sandbox_controller.go @@ -26,7 +26,7 @@ import ( ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" ) type SandboxReconciler struct { @@ -39,11 +39,11 @@ type SandboxReconciler struct { } type SandboxStatusUpdate struct { - Sandbox *sandboxv1alpha1.Sandbox + Sandbox *sandboxv1beta1.Sandbox } func (r *SandboxReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - sandbox := &sandboxv1alpha1.Sandbox{} + sandbox := &sandboxv1beta1.Sandbox{} if err := r.Get(ctx, req.NamespacedName, sandbox); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } diff --git a/pkg/workloadmanager/sandbox_helper.go b/pkg/workloadmanager/sandbox_helper.go index fb7c96cd5..5bff88eb3 100644 --- a/pkg/workloadmanager/sandbox_helper.go +++ b/pkg/workloadmanager/sandbox_helper.go @@ -26,7 +26,7 @@ import ( runtimev1alpha1 "github.com/volcano-sh/agentcube/pkg/apis/runtime/v1alpha1" "github.com/volcano-sh/agentcube/pkg/common/types" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" ) const ( @@ -47,7 +47,7 @@ var sandboxEntrypointDial = func(ctx context.Context, endpoint string, timeout t return conn.Close() } -func buildSandboxPlaceHolder(sandboxCR *sandboxv1alpha1.Sandbox, entry *sandboxEntry) *types.SandboxInfo { +func buildSandboxPlaceHolder(sandboxCR *sandboxv1beta1.Sandbox, entry *sandboxEntry) *types.SandboxInfo { createdAt := sandboxCR.GetCreationTimestamp().Time if createdAt.IsZero() { createdAt = time.Now() @@ -74,7 +74,7 @@ func buildSandboxPlaceHolder(sandboxCR *sandboxv1alpha1.Sandbox, entry *sandboxE } } -func buildSandboxInfo(sandbox *sandboxv1alpha1.Sandbox, podIP string, entry *sandboxEntry) *types.SandboxInfo { +func buildSandboxInfo(sandbox *sandboxv1beta1.Sandbox, podIP string, entry *sandboxEntry) *types.SandboxInfo { createdAt := sandbox.GetCreationTimestamp().Time expiresAt := createdAt.Add(DefaultSandboxTTL) if sandbox.Spec.Lifecycle.ShutdownTime != nil { @@ -108,9 +108,9 @@ func buildSandboxInfo(sandbox *sandboxv1alpha1.Sandbox, podIP string, entry *san // getSandboxStatus extracts status from Sandbox CRD conditions. // Returns sandboxStatusReady when the sandbox is ready, sandboxStatusNotReady otherwise. -func getSandboxStatus(sandbox *sandboxv1alpha1.Sandbox) string { +func getSandboxStatus(sandbox *sandboxv1beta1.Sandbox) string { for _, condition := range sandbox.Status.Conditions { - if condition.Type == string(sandboxv1alpha1.SandboxConditionReady) && condition.Status == metav1.ConditionTrue { + if condition.Type == string(sandboxv1beta1.SandboxConditionReady) && condition.Status == metav1.ConditionTrue { return sandboxStatusReady } } diff --git a/pkg/workloadmanager/sandbox_helper_test.go b/pkg/workloadmanager/sandbox_helper_test.go index 793108ada..11830e31f 100644 --- a/pkg/workloadmanager/sandbox_helper_test.go +++ b/pkg/workloadmanager/sandbox_helper_test.go @@ -22,7 +22,7 @@ import ( "github.com/stretchr/testify/assert" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" runtimev1alpha1 "github.com/volcano-sh/agentcube/pkg/apis/runtime/v1alpha1" "github.com/volcano-sh/agentcube/pkg/common/types" @@ -35,14 +35,14 @@ func TestBuildSandboxPlaceHolder_TableDriven(t *testing.T) { tests := []struct { name string - setupSandbox func() *sandboxv1alpha1.Sandbox + setupSandbox func() *sandboxv1beta1.Sandbox entry *sandboxEntry validate func(t *testing.T, result *types.SandboxInfo) }{ { name: "no ShutdownTime falls back to DefaultSandboxTTL", - setupSandbox: func() *sandboxv1alpha1.Sandbox { - return &sandboxv1alpha1.Sandbox{ + setupSandbox: func() *sandboxv1beta1.Sandbox { + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", @@ -62,15 +62,15 @@ func TestBuildSandboxPlaceHolder_TableDriven(t *testing.T) { }, { name: "ShutdownTime set to 24h is used as ExpiresAt", - setupSandbox: func() *sandboxv1alpha1.Sandbox { + setupSandbox: func() *sandboxv1beta1.Sandbox { shutdownTime := now.Add(24 * time.Hour) - return &sandboxv1alpha1.Sandbox{ + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", }, - Spec: sandboxv1alpha1.SandboxSpec{ - Lifecycle: sandboxv1alpha1.Lifecycle{ + Spec: sandboxv1beta1.SandboxSpec{ + Lifecycle: sandboxv1beta1.Lifecycle{ ShutdownTime: &metav1.Time{Time: shutdownTime}, }, }, @@ -87,15 +87,15 @@ func TestBuildSandboxPlaceHolder_TableDriven(t *testing.T) { }, { name: "ShutdownTime set to 30m overrides DefaultSandboxTTL", - setupSandbox: func() *sandboxv1alpha1.Sandbox { + setupSandbox: func() *sandboxv1beta1.Sandbox { shutdownTime := now.Add(30 * time.Minute) - return &sandboxv1alpha1.Sandbox{ + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "short-sandbox", Namespace: "default", }, - Spec: sandboxv1alpha1.SandboxSpec{ - Lifecycle: sandboxv1alpha1.Lifecycle{ + Spec: sandboxv1beta1.SandboxSpec{ + Lifecycle: sandboxv1beta1.Lifecycle{ ShutdownTime: &metav1.Time{Time: shutdownTime}, }, }, @@ -115,11 +115,11 @@ func TestBuildSandboxPlaceHolder_TableDriven(t *testing.T) { }, { name: "warm-pool path: ShutdownTime set on simpleSandbox reflects MaxSessionDuration", - setupSandbox: func() *sandboxv1alpha1.Sandbox { + setupSandbox: func() *sandboxv1beta1.Sandbox { // Simulates the simpleSandbox built by the warm-pool CodeInterpreter path // after the fix in workload_builder.go sets ShutdownTime from MaxSessionDuration. shutdownTime := now.Add(24 * time.Hour) - return &sandboxv1alpha1.Sandbox{ + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Namespace: "default", Name: "ci-warmpool-abc", @@ -127,8 +127,8 @@ func TestBuildSandboxPlaceHolder_TableDriven(t *testing.T) { SessionIdLabelKey: "session-wp-001", }, }, - Spec: sandboxv1alpha1.SandboxSpec{ - Lifecycle: sandboxv1alpha1.Lifecycle{ + Spec: sandboxv1beta1.SandboxSpec{ + Lifecycle: sandboxv1beta1.Lifecycle{ ShutdownTime: &metav1.Time{Time: shutdownTime}, }, }, @@ -162,25 +162,25 @@ func TestBuildSandboxInfo_TableDriven(t *testing.T) { tests := []struct { name string - setupSandbox func() *sandboxv1alpha1.Sandbox + setupSandbox func() *sandboxv1beta1.Sandbox podIP string entry *sandboxEntry validateResult func(t *testing.T, result *types.SandboxInfo) }{ { name: "basic sandbox with ports", - setupSandbox: func() *sandboxv1alpha1.Sandbox { - return &sandboxv1alpha1.Sandbox{ + setupSandbox: func() *sandboxv1beta1.Sandbox { + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", UID: "test-uid-123", CreationTimestamp: metav1.NewTime(now), }, - Status: sandboxv1alpha1.SandboxStatus{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, @@ -215,24 +215,24 @@ func TestBuildSandboxInfo_TableDriven(t *testing.T) { }, { name: "sandbox with shutdown time", - setupSandbox: func() *sandboxv1alpha1.Sandbox { + setupSandbox: func() *sandboxv1beta1.Sandbox { shutdownTime := now.Add(2 * time.Hour) - return &sandboxv1alpha1.Sandbox{ + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", UID: "test-uid-123", CreationTimestamp: metav1.NewTime(now), }, - Spec: sandboxv1alpha1.SandboxSpec{ - Lifecycle: sandboxv1alpha1.Lifecycle{ + Spec: sandboxv1beta1.SandboxSpec{ + Lifecycle: sandboxv1beta1.Lifecycle{ ShutdownTime: &metav1.Time{Time: shutdownTime}, }, }, - Status: sandboxv1alpha1.SandboxStatus{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, @@ -253,18 +253,18 @@ func TestBuildSandboxInfo_TableDriven(t *testing.T) { }, { name: "sandbox with no ports", - setupSandbox: func() *sandboxv1alpha1.Sandbox { - return &sandboxv1alpha1.Sandbox{ + setupSandbox: func() *sandboxv1beta1.Sandbox { + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", UID: "test-uid-123", CreationTimestamp: metav1.NewTime(now), }, - Status: sandboxv1alpha1.SandboxStatus{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, @@ -283,18 +283,18 @@ func TestBuildSandboxInfo_TableDriven(t *testing.T) { }, { name: "sandbox with empty pod IP", - setupSandbox: func() *sandboxv1alpha1.Sandbox { - return &sandboxv1alpha1.Sandbox{ + setupSandbox: func() *sandboxv1beta1.Sandbox { + return &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Name: "test-sandbox", Namespace: "default", UID: "test-uid-123", CreationTimestamp: metav1.NewTime(now), }, - Status: sandboxv1alpha1.SandboxStatus{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, @@ -331,16 +331,16 @@ func TestBuildSandboxInfo_TableDriven(t *testing.T) { func TestGetSandboxStatus_TableDriven(t *testing.T) { tests := []struct { name string - sandbox *sandboxv1alpha1.Sandbox + sandbox *sandboxv1beta1.Sandbox expected string }{ { name: "ready condition true", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, @@ -350,11 +350,11 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "ready condition false without reason", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionFalse, }, }, @@ -364,11 +364,11 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "ready condition false with reason is not-ready", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionFalse, Reason: "ErrImagePull", Message: "Back-off pulling image", @@ -380,11 +380,11 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "ready condition unknown", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionUnknown, }, }, @@ -394,8 +394,8 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "no conditions", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{}, }, }, @@ -403,8 +403,8 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "nil conditions", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: nil, }, }, @@ -412,8 +412,8 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "other condition type", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { Type: "OtherCondition", @@ -426,15 +426,15 @@ func TestGetSandboxStatus_TableDriven(t *testing.T) { }, { name: "multiple conditions with ready true", - sandbox: &sandboxv1alpha1.Sandbox{ - Status: sandboxv1alpha1.SandboxStatus{ + sandbox: &sandboxv1beta1.Sandbox{ + Status: sandboxv1beta1.SandboxStatus{ Conditions: []metav1.Condition{ { Type: "OtherCondition", Status: metav1.ConditionFalse, }, { - Type: string(sandboxv1alpha1.SandboxConditionReady), + Type: string(sandboxv1beta1.SandboxConditionReady), Status: metav1.ConditionTrue, }, }, diff --git a/pkg/workloadmanager/workload_builder.go b/pkg/workloadmanager/workload_builder.go index 7e97c7dc0..b7eb05582 100644 --- a/pkg/workloadmanager/workload_builder.go +++ b/pkg/workloadmanager/workload_builder.go @@ -33,9 +33,8 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" "k8s.io/klog/v2" - "k8s.io/utils/ptr" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) // Constants for Router's identity resources @@ -151,7 +150,7 @@ type buildSandboxClaimParams struct { } // buildSandboxObject builds a Sandbox object from parameters -func buildSandboxObject(params *buildSandboxParams) *sandboxv1alpha1.Sandbox { +func buildSandboxObject(params *buildSandboxParams) *sandboxv1beta1.Sandbox { if params.ttl == 0 { params.ttl = DefaultSandboxTTL } @@ -172,9 +171,9 @@ func buildSandboxObject(params *buildSandboxParams) *sandboxv1alpha1.Sandbox { maps.Copy(podAnnotations, params.podAnnotations) // Create Sandbox object using agent-sandbox types - sandbox := &sandboxv1alpha1.Sandbox{ + sandbox := &sandboxv1beta1.Sandbox{ TypeMeta: metav1.TypeMeta{ - APIVersion: "agents.x-k8s.io/v1alpha1", + APIVersion: "agents.x-k8s.io/v1beta1", Kind: types.SandboxKind, }, ObjectMeta: metav1.ObjectMeta{ @@ -189,31 +188,31 @@ func buildSandboxObject(params *buildSandboxParams) *sandboxv1alpha1.Sandbox { IdleTimeoutAnnotationKey: params.idleTimeout.String(), }, }, - Spec: sandboxv1alpha1.SandboxSpec{ - PodTemplate: sandboxv1alpha1.PodTemplate{ + Spec: sandboxv1beta1.SandboxSpec{ + PodTemplate: sandboxv1beta1.PodTemplate{ Spec: params.podSpec, - ObjectMeta: sandboxv1alpha1.PodMetadata{ + ObjectMeta: sandboxv1beta1.PodMetadata{ Labels: podLabels, Annotations: podAnnotations, }, }, - Lifecycle: sandboxv1alpha1.Lifecycle{ + Lifecycle: sandboxv1beta1.Lifecycle{ ShutdownTime: &shutdownTime, }, - Replicas: ptr.To[int32](1), + OperatingMode: sandboxv1beta1.SandboxOperatingModeRunning, }, } return sandbox } -func buildSandboxClaimObject(params *buildSandboxClaimParams) *extensionsv1alpha1.SandboxClaim { +func buildSandboxClaimObject(params *buildSandboxClaimParams) *extensionsv1beta1.SandboxClaim { idleTimeout := params.idleTimeout if idleTimeout == 0 { idleTimeout = DefaultSandboxIdleTimeout } - sandboxClaim := &extensionsv1alpha1.SandboxClaim{ + sandboxClaim := &extensionsv1beta1.SandboxClaim{ TypeMeta: metav1.TypeMeta{ - APIVersion: "extensions.agents.x-k8s.io/v1alpha1", + APIVersion: "extensions.agents.x-k8s.io/v1beta1", Kind: types.SandboxClaimsKind, }, ObjectMeta: metav1.ObjectMeta{ @@ -227,8 +226,8 @@ func buildSandboxClaimObject(params *buildSandboxClaimParams) *extensionsv1alpha IdleTimeoutAnnotationKey: idleTimeout.String(), }, }, - Spec: extensionsv1alpha1.SandboxClaimSpec{ - TemplateRef: extensionsv1alpha1.SandboxTemplateRef{ + Spec: extensionsv1beta1.SandboxClaimSpec{ + WarmPoolRef: extensionsv1beta1.SandboxWarmPoolRef{ Name: params.sandboxTemplateName, }, }, @@ -240,7 +239,7 @@ func buildSandboxClaimObject(params *buildSandboxClaimParams) *extensionsv1alpha return sandboxClaim } -func buildSandboxByAgentRuntime(namespace string, name string, ifm *Informers) (*sandboxv1alpha1.Sandbox, *sandboxEntry, error) { +func buildSandboxByAgentRuntime(namespace string, name string, ifm *Informers) (*sandboxv1beta1.Sandbox, *sandboxEntry, error) { agentRuntimeObj, err := ifm.AgentRuntimeLister.AgentRuntimes(namespace).Get(name) if err != nil { if apierrors.IsNotFound(err) { @@ -305,7 +304,7 @@ func buildCodeInterpreterEnvVars(templateEnv []corev1.EnvVar, authMode runtimev1 return envVars } -func buildSandboxByCodeInterpreter(namespace string, codeInterpreterName string, informer *Informers) (*sandboxv1alpha1.Sandbox, *extensionsv1alpha1.SandboxClaim, *sandboxEntry, error) { +func buildSandboxByCodeInterpreter(namespace string, codeInterpreterName string, informer *Informers) (*sandboxv1beta1.Sandbox, *extensionsv1beta1.SandboxClaim, *sandboxEntry, error) { codeInterpreterObj, err := informer.CodeInterpreterLister.CodeInterpreters(namespace).Get(codeInterpreterName) if err != nil { if apierrors.IsNotFound(err) { @@ -359,7 +358,7 @@ func buildSandboxByCodeInterpreter(namespace string, codeInterpreterName string, UID: codeInterpreterObj.UID, }, }) - simpleSandbox := &sandboxv1alpha1.Sandbox{ + simpleSandbox := &sandboxv1beta1.Sandbox{ ObjectMeta: metav1.ObjectMeta{ Namespace: namespace, Name: sandboxName, diff --git a/pkg/workloadmanager/workload_builder_test.go b/pkg/workloadmanager/workload_builder_test.go index b7e44c38f..aa62bdc8b 100644 --- a/pkg/workloadmanager/workload_builder_test.go +++ b/pkg/workloadmanager/workload_builder_test.go @@ -182,8 +182,8 @@ func TestBuildSandboxClaimObject(t *testing.T) { if claim.Name != "claim-abc" { t.Errorf("expected name claim-abc, got %q", claim.Name) } - if claim.Spec.TemplateRef.Name != "my-ci" { - t.Errorf("expected templateRef name my-ci, got %q", claim.Spec.TemplateRef.Name) + if claim.Spec.WarmPoolRef.Name != "my-ci" { + t.Errorf("expected warmPoolRef name my-ci, got %q", claim.Spec.WarmPoolRef.Name) } if claim.Labels[SessionIdLabelKey] != "session-claim-test" { t.Errorf("expected label %s=session-claim-test, got %q", SessionIdLabelKey, claim.Labels[SessionIdLabelKey]) @@ -677,8 +677,8 @@ func TestBuildSandboxByCodeInterpreter_SuccessWithWarmPool(t *testing.T) { if entry.Kind != types.SandboxClaimsKind { t.Errorf("expected entry.Kind to be %q, got %q", types.SandboxClaimsKind, entry.Kind) } - if claim.Spec.TemplateRef.Name != testCodeInterpreterWarmPool { - t.Errorf("expected templateRef name %q, got %q", testCodeInterpreterWarmPool, claim.Spec.TemplateRef.Name) + if claim.Spec.WarmPoolRef.Name != testCodeInterpreterWarmPool { + t.Errorf("expected warmPoolRef name %q, got %q", testCodeInterpreterWarmPool, claim.Spec.WarmPoolRef.Name) } if len(claim.OwnerReferences) != 1 { t.Fatalf("expected 1 owner reference, got %d", len(claim.OwnerReferences)) diff --git a/test/e2e/README.md b/test/e2e/README.md index 8f7e044a0..d8537772d 100644 --- a/test/e2e/README.md +++ b/test/e2e/README.md @@ -104,6 +104,7 @@ Local subprocess MCP tests use **Streamable HTTP** at `/mcp` on `127.0.0.1:19245 | `E2E_CLUSTER_NAME` | `agentcube-e2e` | Kind cluster name | | `E2E_CLEAN_CLUSTER` | `true` | Delete and recreate cluster before tests | | `E2E_SKIP_SETUP` | `false` | Skip all setup steps (cluster creation, image building, deployments) and run tests directly against existing cluster | +| `AGENT_SANDBOX_VERSION` | `v0.5.0rc1` | agent-sandbox release manifest version installed by the e2e setup | | `AGENTCUBE_NAMESPACE` | `agentcube` | Kubernetes namespace for deployments | | `E2E_VENV_DIR` | `/tmp/agentcube-e2e-venv` | Python virtual environment path | | `WORKLOAD_MANAGER_LOCAL_PORT` | `8080` | Local port for WorkloadManager | diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go index 0053d0110..e2dda4dab 100644 --- a/test/e2e/e2e_test.go +++ b/test/e2e/e2e_test.go @@ -46,8 +46,8 @@ import ( "k8s.io/client-go/tools/clientcmd" "sigs.k8s.io/controller-runtime/pkg/client" - sandboxv1alpha1 "sigs.k8s.io/agent-sandbox/api/v1alpha1" - extensionsv1alpha1 "sigs.k8s.io/agent-sandbox/extensions/api/v1alpha1" + sandboxv1beta1 "sigs.k8s.io/agent-sandbox/api/v1beta1" + extensionsv1beta1 "sigs.k8s.io/agent-sandbox/extensions/api/v1beta1" ) const ( @@ -68,8 +68,8 @@ var ( func init() { utilruntime.Must(clientgoscheme.AddToScheme(scheme)) - utilruntime.Must(sandboxv1alpha1.AddToScheme(scheme)) - utilruntime.Must(extensionsv1alpha1.AddToScheme(scheme)) + utilruntime.Must(sandboxv1beta1.AddToScheme(scheme)) + utilruntime.Must(extensionsv1beta1.AddToScheme(scheme)) utilruntime.Must(v1alpha1.AddToScheme(scheme)) } @@ -1157,7 +1157,7 @@ func (ctx *e2eTestContext) deleteYamlFile(yamlPath string) error { // countSandboxClaims counts the number of SandboxClaim resources owned by a CodeInterpreter func (ctx *e2eTestContext) countSandboxClaims(namespace, codeInterpreterName string) (int, error) { - sandboxClaimList := &extensionsv1alpha1.SandboxClaimList{} + sandboxClaimList := &extensionsv1beta1.SandboxClaimList{} err := ctx.ctrlClient.List(context.Background(), sandboxClaimList, client.InNamespace(namespace)) if err != nil { if apierrors.IsNotFound(err) { @@ -1213,7 +1213,7 @@ func (ctx *e2eTestContext) getWarmPoolPodNames(namespace, codeInterpreterName st func (ctx *e2eTestContext) listWarmPoolPods(namespace, codeInterpreterName string) ([]corev1.Pod, error) { listCtx := context.Background() - sandboxList := &sandboxv1alpha1.SandboxList{} + sandboxList := &sandboxv1beta1.SandboxList{} if err := ctx.ctrlClient.List(listCtx, sandboxList, client.InNamespace(namespace)); err != nil { return nil, fmt.Errorf("failed to list sandboxes: %w", err) } @@ -1250,7 +1250,7 @@ func (ctx *e2eTestContext) listWarmPoolPods(namespace, codeInterpreterName strin return pods, nil } -func isWarmPoolSandbox(sandbox sandboxv1alpha1.Sandbox, codeInterpreterName string) bool { +func isWarmPoolSandbox(sandbox sandboxv1beta1.Sandbox, codeInterpreterName string) bool { if sandbox.DeletionTimestamp != nil || sandbox.UID == "" { return false } @@ -1327,14 +1327,14 @@ func (ctx *e2eTestContext) arePodsReady(namespace, codeInterpreterName string) ( } // getSandboxClaimByOwner finds exactly one SandboxClaim owned by the specified owner -func (ctx *e2eTestContext) getSandboxClaimByOwner(namespace, ownerKind, ownerName string) (*extensionsv1alpha1.SandboxClaim, error) { - sandboxClaimList := &extensionsv1alpha1.SandboxClaimList{} +func (ctx *e2eTestContext) getSandboxClaimByOwner(namespace, ownerKind, ownerName string) (*extensionsv1beta1.SandboxClaim, error) { + sandboxClaimList := &extensionsv1beta1.SandboxClaimList{} err := ctx.ctrlClient.List(context.Background(), sandboxClaimList, client.InNamespace(namespace)) if err != nil { return nil, fmt.Errorf("failed to list sandboxclaims: %w", err) } - var found *extensionsv1alpha1.SandboxClaim + var found *extensionsv1beta1.SandboxClaim for i := range sandboxClaimList.Items { claim := &sandboxClaimList.Items[i] for _, ownerRef := range claim.OwnerReferences { @@ -1352,14 +1352,14 @@ func (ctx *e2eTestContext) getSandboxClaimByOwner(namespace, ownerKind, ownerNam } // getSandboxByOwner finds exactly one Sandbox owned by the specified owner -func (ctx *e2eTestContext) getSandboxByOwner(namespace, ownerKind, ownerName string) (*sandboxv1alpha1.Sandbox, error) { - sandboxList := &sandboxv1alpha1.SandboxList{} +func (ctx *e2eTestContext) getSandboxByOwner(namespace, ownerKind, ownerName string) (*sandboxv1beta1.Sandbox, error) { + sandboxList := &sandboxv1beta1.SandboxList{} err := ctx.ctrlClient.List(context.Background(), sandboxList, client.InNamespace(namespace)) if err != nil { return nil, fmt.Errorf("failed to list sandboxes: %w", err) } - var found *sandboxv1alpha1.Sandbox + var found *sandboxv1beta1.Sandbox for i := range sandboxList.Items { sandbox := &sandboxList.Items[i] for _, ownerRef := range sandbox.OwnerReferences { diff --git a/test/e2e/run_e2e.sh b/test/e2e/run_e2e.sh index e14c1c5bf..b250772e5 100755 --- a/test/e2e/run_e2e.sh +++ b/test/e2e/run_e2e.sh @@ -13,7 +13,7 @@ if [ -z "${MTLS_ENABLED+x}" ]; then MTLS_ENABLED=true fi fi -AGENT_SANDBOX_VERSION=${AGENT_SANDBOX_VERSION:-v0.1.1} +AGENT_SANDBOX_VERSION=${AGENT_SANDBOX_VERSION:-v0.5.0rc1} WORKLOAD_MANAGER_IMAGE=${WORKLOAD_MANAGER_IMAGE:-workloadmanager:latest} ROUTER_IMAGE=${ROUTER_IMAGE:-agentcube-router:latest} PICOD_IMAGE=${PICOD_IMAGE:-picod:latest}