cloudrun: GKE client to cloudrun server test

.kokoro/psm_interop_kokoro_lib.sh

@@ -195,6 +195,11 @@ psm::cloud_run::get_tests() {
 #######################################
 psm::cloud_run::run_test() {
   local test_name="${1:?${FUNCNAME[0]} missing the test name argument}"
+
+  PSM_TEST_FLAGS+=(
+    "--flagfile=config/common-cloudrun.cfg"
+  )
+
   psm::run::finalize_test_flags "${test_name}"
   psm::tools::run_verbose python -m "tests.${test_name}" "${PSM_TEST_FLAGS[@]}"
 }

bin/lib/common.py

@@ -24,8 +24,10 @@
 from framework import xds_k8s_flags
 from framework.infrastructure import gcp
 from framework.infrastructure import k8s
+from framework.infrastructure.gcp import cloud_run
 from framework.test_app import client_app
 from framework.test_app import server_app
+from framework.test_app.runners.cloud_run import cloud_run_xds_server_runner
 from framework.test_app.runners.k8s import gamma_server_runner
 from framework.test_app.runners.k8s import k8s_xds_client_runner
 from framework.test_app.runners.k8s import k8s_xds_server_runner
@@ -45,6 +47,7 @@
 KubernetesClientRunner = k8s_xds_client_runner.KubernetesClientRunner
 KubernetesServerRunner = k8s_xds_server_runner.KubernetesServerRunner
 GammaServerRunner = gamma_server_runner.GammaServerRunner
+CloudRunServerRunner = cloud_run_xds_server_runner.CloudRunServerRunner
 _XdsTestServer = server_app.XdsTestServer
 _XdsTestClient = client_app.XdsTestClient
 
@@ -59,6 +62,12 @@ def gcp_api_manager():
     return gcp.api.GcpApiManager()
 
 
+@functools.cache
+def cloud_run_api_manager():
+    return cloud_run.CloudRunV2(project=xds_flags.PROJECT.value,
+                                        region=xds_flags.CLOUD_RUN_REGION.value,
+                                        api_manager=gcp_api_manager())
+
 def td_attrs():
     return dict(
         gcp_api_manager=gcp_api_manager(),
@@ -155,6 +164,18 @@ def make_server_runner(
 
     return server_runner(namespace, **runner_kwargs)
 
+def make_cloud_run_server_runner() -> CloudRunServerRunner:
+    # CloudRunServerRunner arguments.
+    runner_kwargs = dict(
+        project=xds_flags.PROJECT.value,
+        service_name=xds_flags.SERVER_NAME.value,
+        image_name=xds_k8s_flags.SERVER_IMAGE.value,
+        network=xds_flags.NETWORK.value,
+        region=xds_flags.CLOUD_RUN_REGION.value,
+        gcp_api_manager=gcp.api.GcpApiManager(),
+    )
+    server_runner = CloudRunServerRunner
+    return server_runner(**runner_kwargs)
 
 def _ensure_atexit(signum, frame):
     """Needed to handle signals or atexit handler won't be called."""

bin/run_test_server_cloud_run.py

@@ -0,0 +1,50 @@
+# Copyright 2025 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Run test xds server.
+
+Typical usage examples:
+
+    # Help.
+    ./run.sh ./bin/run_test_server_cloud_run.py --help
+
+"""
+import logging
+
+from absl import app
+from absl import flags
+
+from bin.lib import common
+from framework import xds_flags
+from framework import xds_k8s_flags
+
+logger = logging.getLogger(__name__)
+
+flags.adopt_module_key_flags(xds_flags)
+flags.adopt_module_key_flags(xds_k8s_flags)
+flags.adopt_module_key_flags(common)
+
+
+def main(argv):
+    if len(argv) > 1:
+        raise app.UsageError("Too many command-line arguments.")
+
+    xds_flags.set_socket_default_timeout_from_flag()
+
+    server_runner = common.make_cloud_run_server_runner()
+    server_runner.run()
+
+
+if __name__ == "__main__":
+    app.run(main)

config/common-cloudrun.cfg

@@ -0,0 +1,2 @@
+# Common config file for Cloudrun PSM tests.
+--cloud_run_region=us-central1

framework/infrastructure/gcp/__init__.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from framework.infrastructure.gcp import api
+from framework.infrastructure.gcp import cloud_run
 from framework.infrastructure.gcp import compute
 from framework.infrastructure.gcp import iam
 from framework.infrastructure.gcp import network_security

framework/infrastructure/gcp/api.py

@@ -190,6 +190,13 @@ def networksecurity(self, version):
 
         raise NotImplementedError(f"Network Security {version} not supported")
 
+    @functools.lru_cache(None)
+    def cloudrun(self, version):
+        api_name = "run"
+        if version == "v2":
+            return self._build_from_discovery_v2(api_name, version)
+        raise NotImplementedError(f"Cloud Run {version} not supported")
+
     @functools.lru_cache(None)
     def networkservices(self, version):
         api_name = "networkservices"
@@ -520,20 +527,27 @@ def parent(self, location: Optional[str] = GLOBAL_LOCATION):
             location = self.GLOBAL_LOCATION
         return f"projects/{self.project}/locations/{location}"
 
-    def resource_full_name(self, name, collection_name):
-        return f"{self.parent()}/{collection_name}/{name}"
+    def resource_full_name(
+        self, name: str, collection_name: str, location: str = GLOBAL_LOCATION
+    ):
+        return f"{self.parent(location)}/{collection_name}/{name}"
 
     def _create_resource(
-        self, collection: discovery.Resource, body: dict, **kwargs
+        self,
+        collection: discovery.Resource,
+        body: dict,
+        location: Optional[str] = None,
+        **kwargs,
     ):
         logger.info(
             "Creating %s resource:\n%s",
             self.api_name,
             self.resource_pretty_format(body),
         )
         create_req = collection.create(
-            parent=self.parent(), body=body, **kwargs
+            parent=self.parent(location), body=body, **kwargs
         )
+
         self._execute(create_req)
 
     @property

framework/infrastructure/gcp/cloud_run.py

@@ -0,0 +1,93 @@
+# Copyright 2025 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import abc
+import dataclasses
+import logging
+from typing import Any, Final
+
+from framework.infrastructure import gcp
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass(frozen=True)
+class CloudRunService:
+    service_name: str
+    url: str
+
+    @classmethod
+    def from_response(
+        cls, name: str, response: dict[str, Any]
+    ) -> "CloudRunService":
+        return cls(
+            service_name=name,
+            url=response["uri"],
+        )
+
+
+class CloudRunV2(gcp.api.GcpStandardCloudApiResource, metaclass=abc.ABCMeta):
+    """Cloud Run API v2."""
+
+    SERVICES: Final[str] = "services"
+
+    region: str
+
+    def __init__(
+        self, api_manager: gcp.api.GcpApiManager, project: str, region: str
+    ):
+        if not project:
+            raise ValueError("Project ID cannot be empty or None.")
+        if not region:
+            raise ValueError("Region cannot be empty or None.")
+        self.region = region
+        super().__init__(api_manager.cloudrun(self.api_version), project)
+        self._services_collection = self.api.projects().locations().services()
+
+    @property
+    def api_name(self) -> str:
+        """Returns the API name for Cloud Run."""
+        return "Cloud Run"
+
+    @property
+    def api_version(self) -> str:
+        """Returns the API version for Cloud Run."""
+        return "v2"
+
+    def create_service(self, service_name: str, body: dict) -> None:
+        return self._create_resource(
+            collection=self._services_collection,
+            location=self.region,
+            serviceId=service_name,
+            body=body,
+        )
+
+    def get_service(self, service_name: str) -> CloudRunService:
+        result = self._get_resource(
+            collection=self._services_collection,
+            full_name=self.resource_full_name(
+                service_name, self.SERVICES, self.region
+            ),
+        )
+        return CloudRunService.from_response(
+            self.resource_full_name(service_name, self.SERVICES, self.region),
+            result,
+        )
+
+    def delete_service(self, service_name: str):
+        self._delete_resource(
+            self._services_collection,
+            full_name=self.resource_full_name(
+                service_name, self.SERVICES, self.region
+            ),
+        )