running tests

bin/lib/common.py

@@ -22,12 +22,12 @@
 
 from framework import xds_flags
 from framework import xds_k8s_flags
-from framework.infrastructure.gcp import c6n
+from framework.infrastructure.gcp import cloud_run
 from framework.infrastructure import gcp
 from framework.infrastructure import k8s
 from framework.test_app import client_app
 from framework.test_app import server_app
-from framework.test_app.runners.c6n import c6n_xds_server_runner
+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
@@ -47,7 +47,7 @@
 KubernetesClientRunner = k8s_xds_client_runner.KubernetesClientRunner
 KubernetesServerRunner = k8s_xds_server_runner.KubernetesServerRunner
 GammaServerRunner = gamma_server_runner.GammaServerRunner
-CloudRunServerRunner=c6n_xds_server_runner.CloudRunServerRunner
+CloudRunServerRunner=cloud_run_xds_server_runner.CloudRunServerRunner
 _XdsTestServer = server_app.XdsTestServer
 _XdsTestClient = client_app.XdsTestClient
 
@@ -64,7 +64,7 @@ def gcp_api_manager():
 
 @functools.cache
 def c6n_api_manager():
-    return c6n.CloudRunApiManager()
+    return cloud_run.CloudRunApiManager()
 
 def td_attrs():
     return dict(

bin/run_test_server_c6n.py

@@ -17,23 +17,23 @@
 Typical usage examples:
 
     # Help.
-    ./run.sh ./bin/run_test_server_c6n.py --help
+    ./run.sh ./bin/run_test_server_cloud_run.py --help
 
     # Run modes.
-    ./run.sh ./bin/run_test_server_c6n.py --mode=app_net
-    ./run.sh ./bin/run_test_server_c6n.py --mode=secure
+    ./run.sh ./bin/run_test_server_cloud_run.py --mode=app_net
+    ./run.sh ./bin/run_test_server_cloud_run.py --mode=secure
 
     # Gamma run mode: uses HTTPRoute by default.
-    ./run.sh ./bin/run_test_server_c6n.py --mode=gamma
+    ./run.sh ./bin/run_test_server_cloud_run.py --mode=gamma
 
     # Gamma run mode: use GRPCRoute.
-    ./run.sh ./bin/run_test_server_c6n.py --mode=gamma --gamma_route_kind=grpc
+    ./run.sh ./bin/run_test_server_cloud_run.py --mode=gamma --gamma_route_kind=grpc
 
     # Running multipler server replicas.
-    ./run.sh ./bin/run_test_server_c6n.py --server_replica_count=3
+    ./run.sh ./bin/run_test_server_cloud_run.py --server_replica_count=3
 
     # Cleanup: make sure to set the same mode used to create.
-    ./run.sh ./bin/run_test_server_c6n.py --mode=gamma --cmd=cleanup
+    ./run.sh ./bin/run_test_server_cloud_run.py --mode=gamma --cmd=cleanup
 """
 import logging
 
@@ -58,7 +58,7 @@ def main(argv):
     xds_flags.set_socket_default_timeout_from_flag()
 
     run_kwargs = dict()
-    server_runner = common.make_c6n_server_runner()
+    server_runner = common.make_cloud_run_server_runner()
     server_runner.run(**run_kwargs)
 
 

framework/infrastructure/gcp/c6n.py → framework/infrastructure/gcp/cloud_run.py

@@ -11,8 +11,6 @@
 # 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.
-
-#emchandwani : check
 import abc
 import logging
 
@@ -58,8 +56,7 @@ def deploy_service(self, service_name: str, image_name: str, *,test_port: int =
                         image=image_name,
                         ports=[
                             run_v2.ContainerPort(
-                                name="http1",
-                                # emchandwani : change to self.server_xds_port
+                                name="h2c",
                                 container_port=test_port,
                             ),
                         ],
@@ -74,8 +71,7 @@ def deploy_service(self, service_name: str, image_name: str, *,test_port: int =
 
         try:
             operation = self._client.create_service(request=request)
-            # operation=GcpProjectApiResource.wait_for_operation(operation_request=request,test_success_fn=logger.info("done"))
-            self._service = operation.result(timeout=800)
+            self._service = operation.result(timeout=600)
             logger.info("Deployed service: %s", self._service.uri)
             return self._service.uri
         except Exception as e:

framework/infrastructure/gcp/compute.py

@@ -581,7 +581,6 @@ def create_serverless_neg(
             name: The name of the NEG.
             region: The region in which to create the NEG.
             service_name: The name of the Cloud Run service.  Format: "namespaces/{namespace}/services/{service}"
-            network: The network of the NEG. Format: "projects/{project}/global/networks/{network}"
 
         Returns:
             The NEG selfLink URL

framework/infrastructure/gcp/network_services.py

@@ -112,19 +112,14 @@ class RouteMatch:
         @classmethod
         def from_response(cls, d: Dict[str, Any]) -> "GrpcRoute.RouteMatch":
             return cls(
-                method=(
-                    GrpcRoute.MethodMatch.from_response(d["method"])
-                    if "method" in d
-                    else None
-                ),
-                headers=(
-                    tuple(
-                        GrpcRoute.HeaderMatch.from_response(h)
-                        for h in d["headers"]
-                    )
-                    if "headers" in d
-                    else ()
-                ),
+                method=GrpcRoute.MethodMatch.from_response(d["method"])
+                if "method" in d
+                else None,
+                headers=tuple(
+                    GrpcRoute.HeaderMatch.from_response(h) for h in d["headers"]
+                )
+                if "headers" in d
+                else (),
             )
 
     @dataclasses.dataclass(frozen=True)
@@ -229,19 +224,14 @@ class RouteMatch:
         @classmethod
         def from_response(cls, d: Dict[str, Any]) -> "HttpRoute.RouteMatch":
             return cls(
-                method=(
-                    HttpRoute.MethodMatch.from_response(d["method"])
-                    if "method" in d
-                    else None
-                ),
-                headers=(
-                    tuple(
-                        HttpRoute.HeaderMatch.from_response(h)
-                        for h in d["headers"]
-                    )
-                    if "headers" in d
-                    else ()
-                ),
+                method=HttpRoute.MethodMatch.from_response(d["method"])
+                if "method" in d
+                else None,
+                headers=tuple(
+                    HttpRoute.HeaderMatch.from_response(h) for h in d["headers"]
+                )
+                if "headers" in d
+                else (),
             )
 
     @dataclasses.dataclass(frozen=True)
@@ -484,4 +474,4 @@ def delete_http_route(self, name: str) -> bool:
         return self._delete_resource(
             collection=self._api_locations.httpRoutes(),
             full_name=self.resource_full_name(name, self.HTTP_ROUTES),
-        )
+        )

framework/infrastructure/traffic_director.py

@@ -1286,130 +1286,4 @@ def _get_certificate_provider(cls):
             "certificateProviderInstance": {
                 "pluginInstance": cls.CERTIFICATE_PROVIDER_INSTANCE,
             },
-        }
-
-
-class TrafficDirectorCloudRunManager(TrafficDirectorAppNetManager):
-    MESH_NAME = "grpc-mesh"
-    SERVER_TLS_POLICY_NAME = "server-tls-policy"
-    CLIENT_TLS_POLICY_NAME = "client-tls-policy"
-    AUTHZ_POLICY_NAME = "authz-policy"
-    ENDPOINT_POLICY = "endpoint-policy"
-    CERTIFICATE_PROVIDER_INSTANCE = "google_cloud_private_spiffe"
-
-    netsec: _NetworkSecurityV1Beta1
-    netsvc: _NetworkServicesV1Beta1
-
-    def __init__(
-        self,
-        gcp_api_manager: gcp.api.GcpApiManager,
-        project: str,
-        *,
-        resource_prefix: str,
-        resource_suffix: Optional[str] = None,
-        network: str = "default",
-        compute_api_version: str = "v1",
-        enable_dualstack: bool = False,
-    ):
-        super().__init__(
-            gcp_api_manager,
-            project,
-            resource_prefix=resource_prefix,
-            resource_suffix=resource_suffix,
-            network=network,
-            compute_api_version=compute_api_version,
-            enable_dualstack=enable_dualstack,
-        )
-
-        # API
-        # netsvc: gcp.network_services.NetworkServicesV1
-        # self.netsvc = _NetworkServicesV1Beta1(gcp_api_manager, project)
-        # self.netsvc = gcp.network_services.NetworkServicesV1(
-        #     gcp_api_manager, project
-        # )
-
-        # Managed resources
-        # TODO(gnossen) PTAL at the pylint error
-        self.grpc_route: Optional[GrpcRoute] = None
-        self.http_route: Optional[HttpRoute] = None
-        self.mesh: Optional[Mesh] = None
-
-        # Managed resources
-        self.server_tls_policy: Optional[ServerTlsPolicy] = None
-        self.client_tls_policy: Optional[ClientTlsPolicy] = None
-        self.authz_policy: Optional[AuthorizationPolicy] = None
-        self.endpoint_policy: Optional[EndpointPolicy] = None
-
-    def backend_service_add_backends(
-        self,
-        backends: Sequence[str],
-        region: Optional[str] = None,
-        balancing_mode: str = "CONNECTION",
-        max_rate_per_endpoint: Optional[int] = None,
-        capacity_scaler: float = 1.0,
-        *,
-        circuit_breakers: Optional[dict[str, int]] = None,
-    ):
-
-        new_backends = []
-        for backend in backends:
-            new_backend = {
-                "group": backend,
-                "balancingMode": balancing_mode,
-                "maxRatePerEndpoint": max_rate_per_endpoint,
-                "capacityScaler": capacity_scaler,
-            }
-
-            if circuit_breakers is not None:
-                new_backend["circuitBreakers"] = circuit_breakers
-
-            new_backends.append(new_backend)
-
-        # self.backends.update(new_backends)
-        backend_service = self.backend_service
-
-        logging.info(
-            "Adding backends to Backend Service %s: %r",
-            backend_service.name,
-            new_backends,
-        )
-
-        self.compute.backend_service_patch_backends(
-            backend_service,
-            backends,
-            is_cloudrun=True,
-        )
-
-    # def create_grpc_route(self, src_host: str, src_port: int):
-    #     self.create_grpc_route(src_host, src_port)
-        # hostname = f"{src_host}:{src_port}"
-        # route_name = f"{self.resource_prefix}-grpc-route-{self.resource_suffix}"
-        # logger.info("Creating gRPC route: %s", route_name)
-        # service_name=self.netsvc.resource_full_name(
-        #     self.backend_service.name, "backendServices"
-        # )
-        # try:
-        #     # backend_service_url = self.backend_service.url.split("v1/")[-1]
-        #     # URL of the backend service
-        #     route_body = {
-        #         "name": route_name,
-        #         "hostnames": [hostname],
-        #         "rules": [
-        #             {
-        #                 "action": {
-        #                     "destinations": [
-        #                         {"serviceName": service_name}
-        #                     ]
-        #                 },
-        #             }
-        #         ],
-        #     }
-        #     if hasattr(self, "mesh") and self.mesh:
-        #         route_body["meshes"] = self.mesh.url
-        #     resource = self.netsvc.create_grpc_route(route_name, route_body)
-        #     self.grpc_route = self.netsvc.get_grpc_route(route_name)
-        #     logger.info("gRPC Route created successfully: %s", self.grpc_route)
-
-        # except Exception as e:  # Catching generic exceptions for now
-        #     logger.exception("Error creating gRPC route: %s", e)
-        #     raise
+        }