feat: Implemented rename enclave method in container engine lib

container-engine-lib/lib/backend_impls/docker/docker_kurtosis_backend/docker_kurtosis_backend_enclave_functions.go

@@ -357,6 +357,14 @@ func (backend *DockerKurtosisBackend) DestroyEnclaves(
 	return successfulNetworkRemovalEnclaveUuids, erroredEnclaveUuids, nil
 }
 
+func (backend *DockerKurtosisBackend) RenameEnclave(
+	ctx context.Context,
+	enclaveUuid enclave.EnclaveUUID,
+	newName string,
+) error {
+	return stacktrace.NewError("RenameEnclave isn't implemented for Docker yet")
+}
+
 // ====================================================================================================
 //
 //	Private helper methods

container-engine-lib/lib/backend_impls/kubernetes/kubernetes_kurtosis_backend/kubernetes_kurtosis_backend_enclave_functions.go

@@ -157,6 +157,48 @@ func (backend *KubernetesKurtosisBackend) GetEnclaves(
 	return matchingEnclaves, nil
 }
 
+func (backend *KubernetesKurtosisBackend) RenameEnclave(
+	ctx context.Context,
+	enclaveUuid enclave.EnclaveUUID,
+	newName string,
+) error {
+
+	// we need to call the K8s client in order to get the current annotations
+	enclave, kubernetesResources, err := backend.getSingleEnclaveAndKubernetesResources(ctx, enclaveUuid)
+	if err != nil {
+		return stacktrace.Propagate(err, "An error occurred getting enclave object and Kubernetes resources for enclave ID '%v'", enclaveUuid)
+	}
+	namespace := kubernetesResources.namespace
+	if namespace == nil {
+		return stacktrace.NewError("Cannot rename enclave '%v' because no Kubernetes namespace exists for it", enclaveUuid)
+	}
+
+	currentAnnotations := kubernetesResources.namespace.Annotations
+	if _, found := currentAnnotations[kubernetes_annotation_key_consts.EnclaveNameAnnotationKey.GetString()]; !found {
+		logrus.Debugf(
+			"Expected to find annotation with key '%s' for namespace with UUID '%s' while "+
+				"renaming it, but it was not found. It should not happens, it could be a "+
+				"bug in Kurtosis",
+			kubernetes_annotation_key_consts.EnclaveNameAnnotationKey.GetString(),
+			enclaveUuid,
+		)
+	}
+
+	// we need the copy the current annotations in order to preserve the values of the other keys
+	updatedAnnotations := currentAnnotations
+	updatedAnnotations[kubernetes_annotation_key_consts.EnclaveNameAnnotationKey.GetString()] = newName
+
+	namespaceApplyConfigurator := func(namespaceApplyConfig *applyconfigurationsv1.NamespaceApplyConfiguration) {
+		namespaceApplyConfig.WithAnnotations(updatedAnnotations)
+	}
+
+	if _, err := backend.kubernetesManager.UpdateNamespace(ctx, enclave.GetName(), namespaceApplyConfigurator); err != nil {
+		return stacktrace.Propagate(err, "An error occurred renaming enclave with UUID '%v', renaming from '%s' to '%s'", enclaveUuid, enclave.GetName(), newName)
+	}
+
+	return nil
+}
+
 func (backend *KubernetesKurtosisBackend) StopEnclaves(
 	ctx context.Context,
 	filters *enclave.EnclaveFilters,

container-engine-lib/lib/backend_impls/kubernetes/kubernetes_manager/kubernetes_manager.go

@@ -432,6 +432,35 @@ func (manager *KubernetesManager) CreateNamespace(
 	return namespaceResult, nil
 }
 
+func (manager *KubernetesManager) UpdateNamespace(
+	ctx context.Context,
+	namespaceName string,
+	// We use a configurator, rather than letting the user pass in their own NamespaceApplyConfiguration, so that we ensure
+	// they use the constructor (and don't do struct instantiation and forget to add the object name, etc. which
+	// would result in removing the object name)
+	updateConfigurator func(configuration *applyconfigurationsv1.NamespaceApplyConfiguration),
+) (*apiv1.Namespace, error) {
+	updatesToApply := applyconfigurationsv1.Namespace(namespaceName)
+	updateConfigurator(updatesToApply)
+
+	namespaceClient := manager.kubernetesClientSet.CoreV1().Namespaces()
+
+	applyOpts := metav1.ApplyOptions{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "",
+			APIVersion: "",
+		},
+		DryRun:       nil,
+		Force:        false,
+		FieldManager: fieldManager,
+	}
+	result, err := namespaceClient.Apply(ctx, updatesToApply, applyOpts)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "Failed to update namespace '%v' ", namespaceName)
+	}
+	return result, nil
+}
+
 func (manager *KubernetesManager) RemoveNamespace(ctx context.Context, namespace *apiv1.Namespace) error {
 	name := namespace.Name
 	namespaceClient := manager.kubernetesClientSet.CoreV1().Namespaces()

container-engine-lib/lib/backend_impls/metrics_reporting/metrics_reporting_kurtosis_backend.go

@@ -120,6 +120,19 @@ func (backend *MetricsReportingKurtosisBackend) GetEnclaves(
 	return results, nil
 }
 
+func (backend *MetricsReportingKurtosisBackend) RenameEnclave(
+	ctx context.Context,
+	enclaveUuid enclave.EnclaveUUID,
+	newName string,
+) error {
+
+	if err := backend.underlying.RenameEnclave(ctx, enclaveUuid, newName); err != nil {
+		return stacktrace.Propagate(err, "An error occurred renaming enclave with UUID '%v' to '%s'", enclaveUuid, newName)
+	}
+
+	return nil
+}
+
 func (backend *MetricsReportingKurtosisBackend) StopEnclaves(
 	ctx context.Context,
 	filters *enclave.EnclaveFilters,

container-engine-lib/lib/backend_interface/kurtosis_backend.go

@@ -67,9 +67,16 @@ type KurtosisBackend interface {
 	// Dumps all of Kurtosis (engines + all enclaves)
 	DumpKurtosis(ctx context.Context, outputDirpath string) error
 
-	// Creates an enclave with the given enclave ID
+	// Creates an enclave with the given enclave UUID
 	CreateEnclave(ctx context.Context, enclaveUuid enclave.EnclaveUUID, enclaveName string, isPartitioningEnabled bool) (*enclave.Enclave, error)
 
+	// Rename an enclave with a new name by UUID
+	RenameEnclave(
+		ctx context.Context,
+		enclaveUuid enclave.EnclaveUUID,
+		newName string,
+	) error
+
 	// Gets enclaves matching the given filters
 	GetEnclaves(
 		ctx context.Context,