RHOAIENG-30720: Remove GCS FT for Lifecycled RayClusters

Author: kryanbeane

src/codeflare_sdk/ray/rayjobs/config.py

@@ -139,20 +139,12 @@ class ManagedClusterConfig:
             A list of V1Volume objects to add to the Cluster
         volume_mounts:
             A list of V1VolumeMount objects to add to the Cluster
-        enable_gcs_ft:
-            A boolean indicating whether to enable GCS fault tolerance.
-        redis_address:
-            The address of the Redis server to use for GCS fault tolerance, required when enable_gcs_ft is True.
-        redis_password_secret:
-            Kubernetes secret reference containing Redis password. ex: {"name": "secret-name", "key": "password-key"}
-        external_storage_namespace:
-            The storage namespace to use for GCS fault tolerance. By default, KubeRay sets it to the UID of RayCluster.
     """
 
     head_cpu_requests: Union[int, str] = 2
     head_cpu_limits: Union[int, str] = 2
-    head_memory_requests: Union[int, str] = 8
-    head_memory_limits: Union[int, str] = 8
+    head_memory_requests: Union[int, str] = 2
+    head_memory_limits: Union[int, str] = 2
     head_accelerators: Dict[str, Union[str, int]] = field(default_factory=dict)
     head_tolerations: Optional[List[V1Toleration]] = None
     worker_cpu_requests: Union[int, str] = 1
@@ -173,35 +165,10 @@ class ManagedClusterConfig:
     annotations: Dict[str, str] = field(default_factory=dict)
     volumes: list[V1Volume] = field(default_factory=list)
     volume_mounts: list[V1VolumeMount] = field(default_factory=list)
-    enable_gcs_ft: bool = False
-    redis_address: Optional[str] = None
-    redis_password_secret: Optional[Dict[str, str]] = None
-    external_storage_namespace: Optional[str] = None
 
     def __post_init__(self):
         self.envs["RAY_USAGE_STATS_ENABLED"] = "0"
 
-        if self.enable_gcs_ft:
-            if not self.redis_address:
-                raise ValueError(
-                    "redis_address must be provided when enable_gcs_ft is True"
-                )
-
-            if self.redis_password_secret and not isinstance(
-                self.redis_password_secret, dict
-            ):
-                raise ValueError(
-                    "redis_password_secret must be a dictionary with 'name' and 'key' fields"
-                )
-
-            if self.redis_password_secret and (
-                "name" not in self.redis_password_secret
-                or "key" not in self.redis_password_secret
-            ):
-                raise ValueError(
-                    "redis_password_secret must contain both 'name' and 'key' fields"
-                )
-
         self._validate_types()
         self._memory_to_string()
         self._validate_gpu_config(self.head_accelerators)
@@ -286,11 +253,6 @@ def build_ray_cluster_spec(self, cluster_name: str) -> Dict[str, Any]:
             "workerGroupSpecs": [self._build_worker_group_spec(cluster_name)],
         }
 
-        # Add GCS fault tolerance if enabled
-        if self.enable_gcs_ft:
-            gcs_ft_options = self._build_gcs_ft_options()
-            ray_cluster_spec["gcsFaultToleranceOptions"] = gcs_ft_options
-
         return ray_cluster_spec
 
     def _build_head_group_spec(self) -> Dict[str, Any]:
@@ -493,117 +455,3 @@ def _generate_volumes(self) -> list:
     def _build_env_vars(self) -> list:
         """Build environment variables list."""
         return [V1EnvVar(name=key, value=value) for key, value in self.envs.items()]
-
-    def _build_gcs_ft_options(self) -> Dict[str, Any]:
-        """Build GCS fault tolerance options."""
-        gcs_ft_options = {"redisAddress": self.redis_address}
-
-        if (
-            hasattr(self, "external_storage_namespace")
-            and self.external_storage_namespace
-        ):
-            gcs_ft_options["externalStorageNamespace"] = self.external_storage_namespace
-
-        if hasattr(self, "redis_password_secret") and self.redis_password_secret:
-            gcs_ft_options["redisPassword"] = {
-                "valueFrom": {
-                    "secretKeyRef": {
-                        "name": self.redis_password_secret["name"],
-                        "key": self.redis_password_secret["key"],
-                    }
-                }
-            }
-
-        return gcs_ft_options
-
-    def add_script_volumes(
-        self, configmap_name: str, mount_path: str = "/home/ray/scripts"
-    ):
-        """
-        Add script volume and mount references to cluster configuration.
-
-        Args:
-            configmap_name: Name of the ConfigMap containing scripts
-            mount_path: Where to mount scripts in containers (default: /home/ray/scripts)
-        """
-        # Check if script volume already exists
-        volume_name = "ray-job-scripts"
-        existing_volume = next(
-            (v for v in self.volumes if getattr(v, "name", None) == volume_name), None
-        )
-        if existing_volume:
-            logger.debug(f"Script volume '{volume_name}' already exists, skipping...")
-            return
-
-        # Check if script mount already exists
-        existing_mount = next(
-            (m for m in self.volume_mounts if getattr(m, "name", None) == volume_name),
-            None,
-        )
-        if existing_mount:
-            logger.debug(
-                f"Script volume mount '{volume_name}' already exists, skipping..."
-            )
-            return
-
-        # Add script volume to cluster configuration
-        script_volume = V1Volume(
-            name=volume_name, config_map=V1ConfigMapVolumeSource(name=configmap_name)
-        )
-        self.volumes.append(script_volume)
-
-        # Add script volume mount to cluster configuration
-        script_mount = V1VolumeMount(name=volume_name, mount_path=mount_path)
-        self.volume_mounts.append(script_mount)
-
-        logger.info(
-            f"Added script volume '{configmap_name}' to cluster config: mount_path={mount_path}"
-        )
-
-    def validate_configmap_size(self, scripts: Dict[str, str]) -> None:
-        total_size = sum(len(content.encode("utf-8")) for content in scripts.values())
-        if total_size > 1024 * 1024:  # 1MB
-            raise ValueError(
-                f"ConfigMap size exceeds 1MB limit. Total size: {total_size} bytes"
-            )
-
-    def build_script_configmap_spec(
-        self, job_name: str, namespace: str, scripts: Dict[str, str]
-    ) -> Dict[str, Any]:
-        """
-        Build ConfigMap specification for scripts
-
-        Args:
-            job_name: Name of the RayJob (used for ConfigMap naming)
-            namespace: Kubernetes namespace
-            scripts: Dictionary of script_name -> script_content
-
-        Returns:
-            Dict: ConfigMap specification ready for Kubernetes API
-        """
-        configmap_name = f"{job_name}-scripts"
-        return {
-            "apiVersion": "v1",
-            "kind": "ConfigMap",
-            "metadata": {"name": configmap_name, "namespace": namespace},
-            "data": scripts,
-        }
-
-    def build_script_volume_specs(
-        self, configmap_name: str, mount_path: str = "/home/ray/scripts"
-    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        """
-        Build volume and mount specifications for scripts
-
-        Args:
-            configmap_name: Name of the ConfigMap containing scripts
-            mount_path: Where to mount scripts in containers
-
-        Returns:
-            Tuple of (volume_spec, mount_spec) as dictionaries
-        """
-        volume_spec = {"name": "ray-job-scripts", "configMap": {"name": configmap_name}}
-
-        mount_spec = {"name": "ray-job-scripts", "mountPath": mount_path}
-
-        return volume_spec, mount_spec

src/codeflare_sdk/ray/rayjobs/test_rayjob.py

@@ -1007,27 +1007,6 @@ def test_rayjob_user_override_shutdown_behavior(mocker):
     assert rayjob_override_priority.shutdown_after_job_finishes is True
 
 
-def test_build_ray_cluster_spec_with_gcs_ft(mocker):
-    """Test build_ray_cluster_spec with GCS fault tolerance enabled."""
-    from codeflare_sdk.ray.rayjobs.config import ManagedClusterConfig
-
-    # Create a test cluster config with GCS FT enabled
-    cluster_config = ManagedClusterConfig(
-        enable_gcs_ft=True,
-        redis_address="redis://redis-service:6379",
-        external_storage_namespace="storage-ns",
-    )
-
-    # Build the spec using the method on the cluster config
-    spec = cluster_config.build_ray_cluster_spec("test-cluster")
-
-    # Verify GCS fault tolerance options
-    assert "gcsFaultToleranceOptions" in spec
-    gcs_ft = spec["gcsFaultToleranceOptions"]
-    assert gcs_ft["redisAddress"] == "redis://redis-service:6379"
-    assert gcs_ft["externalStorageNamespace"] == "storage-ns"
-
-
 class TestRayVersionValidation:
     """Test Ray version validation in RayJob."""