Revert "Add api listener test for k8s (#27534)" (#28719)

This reverts commit b4b6862352.
pull/28791/head
Lidi Zheng 3 years ago committed by GitHub
parent ae810df503
commit c35b93f28d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 2
      tools/internal_ci/linux/grpc_xds_k8s_lb.sh
  2. 2
      tools/internal_ci/linux/grpc_xds_k8s_lb_python.sh
  3. 28
      tools/run_tests/xds_k8s_test_driver/framework/infrastructure/gcp/compute.py
  4. 96
      tools/run_tests/xds_k8s_test_driver/framework/infrastructure/traffic_director.py
  5. 53
      tools/run_tests/xds_k8s_test_driver/framework/xds_k8s_testcase.py
  6. 102
      tools/run_tests/xds_k8s_test_driver/tests/api_listener_test.py

@ -155,7 +155,7 @@ main() {
cd "${TEST_DRIVER_FULL_DIR}" cd "${TEST_DRIVER_FULL_DIR}"
local failed_tests=0 local failed_tests=0
run_alpha_test subsetting_test || (( failed_tests++ )) run_alpha_test subsetting_test || (( failed_tests++ ))
test_suites=("api_listener_test" "change_backend_service_test" "failover_test" "remove_neg_test" "round_robin_test" "affinity_test") test_suites=("change_backend_service_test" "failover_test" "remove_neg_test" "round_robin_test" "affinity_test")
for test in "${test_suites[@]}"; do for test in "${test_suites[@]}"; do
run_test $test || (( failed_tests++ )) run_test $test || (( failed_tests++ ))
done done

@ -148,7 +148,7 @@ main() {
# Run tests # Run tests
cd "${TEST_DRIVER_FULL_DIR}" cd "${TEST_DRIVER_FULL_DIR}"
local failed_tests=0 local failed_tests=0
test_suites=("api_listener_test" "change_backend_service_test" "failover_test" "remove_neg_test" "round_robin_test") test_suites=("change_backend_service_test" "failover_test" "remove_neg_test" "round_robin_test")
for test in "${test_suites[@]}"; do for test in "${test_suites[@]}"; do
run_test $test || (( failed_tests++ )) run_test $test || (( failed_tests++ ))
done done

@ -219,14 +219,12 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
self, self,
name: str, name: str,
url_map: GcpResource, url_map: GcpResource,
validate_for_proxyless: bool = True,
) -> GcpResource: ) -> GcpResource:
return self._insert_resource( return self._insert_resource(self.api.targetGrpcProxies(), {
self.api.targetGrpcProxies(), { 'name': name,
'name': name, 'url_map': url_map.url,
'url_map': url_map.url, 'validate_for_proxyless': True,
'validate_for_proxyless': validate_for_proxyless, })
})
def delete_target_grpc_proxy(self, name): def delete_target_grpc_proxy(self, name):
self._delete_resource(self.api.targetGrpcProxies(), 'targetGrpcProxy', self._delete_resource(self.api.targetGrpcProxies(), 'targetGrpcProxy',
@ -246,13 +244,13 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
self._delete_resource(self.api.targetHttpProxies(), 'targetHttpProxy', self._delete_resource(self.api.targetHttpProxies(), 'targetHttpProxy',
name) name)
def create_forwarding_rule(self, def create_forwarding_rule(
name: str, self,
src_port: int, name: str,
target_proxy: GcpResource, src_port: int,
network_url: str, target_proxy: GcpResource,
*, network_url: str,
ip_address: str = '0.0.0.0') -> GcpResource: ) -> GcpResource:
return self._insert_resource( return self._insert_resource(
self.api.globalForwardingRules(), self.api.globalForwardingRules(),
{ {
@ -260,7 +258,7 @@ class ComputeV1(gcp.api.GcpProjectApiResource):
'loadBalancingScheme': 'loadBalancingScheme':
'INTERNAL_SELF_MANAGED', # Traffic Director 'INTERNAL_SELF_MANAGED', # Traffic Director
'portRange': src_port, 'portRange': src_port,
'IPAddress': ip_address, 'IPAddress': '0.0.0.0',
'network': network_url, 'network': network_url,
'target': target_proxy.url, 'target': target_proxy.url,
}) })

@ -56,12 +56,9 @@ class TrafficDirectorManager:
AFFINITY_BACKEND_SERVICE_NAME = "backend-service-affinity" AFFINITY_BACKEND_SERVICE_NAME = "backend-service-affinity"
HEALTH_CHECK_NAME = "health-check" HEALTH_CHECK_NAME = "health-check"
URL_MAP_NAME = "url-map" URL_MAP_NAME = "url-map"
ALTERNATIVE_URL_MAP_NAME = "url-map-alt"
URL_MAP_PATH_MATCHER_NAME = "path-matcher" URL_MAP_PATH_MATCHER_NAME = "path-matcher"
TARGET_PROXY_NAME = "target-proxy" TARGET_PROXY_NAME = "target-proxy"
ALTERNATIVE_TARGET_PROXY_NAME = "target-proxy-alt"
FORWARDING_RULE_NAME = "forwarding-rule" FORWARDING_RULE_NAME = "forwarding-rule"
ALTERNATIVE_FORWARDING_RULE_NAME = "forwarding-rule-alt"
FIREWALL_RULE_NAME = "allow-health-checks" FIREWALL_RULE_NAME = "allow-health-checks"
def __init__( def __init__(
@ -91,14 +88,11 @@ class TrafficDirectorManager:
# TODO(sergiitk): remove this flag once backend service resource loaded # TODO(sergiitk): remove this flag once backend service resource loaded
self.backend_service_protocol: Optional[BackendServiceProtocol] = None self.backend_service_protocol: Optional[BackendServiceProtocol] = None
self.url_map: Optional[GcpResource] = None self.url_map: Optional[GcpResource] = None
self.alternative_url_map: Optional[GcpResource] = None
self.firewall_rule: Optional[GcpResource] = None self.firewall_rule: Optional[GcpResource] = None
self.target_proxy: Optional[GcpResource] = None self.target_proxy: Optional[GcpResource] = None
# TODO(sergiitk): remove this flag once target proxy resource loaded # TODO(sergiitk): remove this flag once target proxy resource loaded
self.target_proxy_is_http: bool = False self.target_proxy_is_http: bool = False
self.alternative_target_proxy: Optional[GcpResource] = None
self.forwarding_rule: Optional[GcpResource] = None self.forwarding_rule: Optional[GcpResource] = None
self.alternative_forwarding_rule: Optional[GcpResource] = None
self.backends: Set[ZonalGcpResource] = set() self.backends: Set[ZonalGcpResource] = set()
self.alternative_backend_service: Optional[GcpResource] = None self.alternative_backend_service: Optional[GcpResource] = None
# TODO(sergiitk): remove this flag once backend service resource loaded # TODO(sergiitk): remove this flag once backend service resource loaded
@ -142,12 +136,9 @@ class TrafficDirectorManager:
def cleanup(self, *, force=False): def cleanup(self, *, force=False):
# Cleanup in the reverse order of creation # Cleanup in the reverse order of creation
self.delete_forwarding_rule(force=force) self.delete_forwarding_rule(force=force)
self.delete_alternative_forwarding_rule(force=force)
self.delete_target_http_proxy(force=force) self.delete_target_http_proxy(force=force)
self.delete_target_grpc_proxy(force=force) self.delete_target_grpc_proxy(force=force)
self.delete_alternative_target_grpc_proxy(force=force)
self.delete_url_map(force=force) self.delete_url_map(force=force)
self.delete_alternative_url_map(force=force)
self.delete_backend_service(force=force) self.delete_backend_service(force=force)
self.delete_alternative_backend_service(force=force) self.delete_alternative_backend_service(force=force)
self.delete_affinity_backend_service(force=force) self.delete_affinity_backend_service(force=force)
@ -408,7 +399,11 @@ class TrafficDirectorManager:
}], }],
} }
def create_url_map(self, src_host: str, src_port: int) -> GcpResource: def create_url_map(
self,
src_host: str,
src_port: int,
) -> GcpResource:
src_address = f'{src_host}:{src_port}' src_address = f'{src_host}:{src_port}'
name = self.make_resource_name(self.URL_MAP_NAME) name = self.make_resource_name(self.URL_MAP_NAME)
matcher_name = self.make_resource_name(self.URL_MAP_PATH_MATCHER_NAME) matcher_name = self.make_resource_name(self.URL_MAP_PATH_MATCHER_NAME)
@ -449,35 +444,6 @@ class TrafficDirectorManager:
self.compute.delete_url_map(name) self.compute.delete_url_map(name)
self.url_map = None self.url_map = None
def create_alternative_url_map(
self,
src_host: str,
src_port: int,
backend_service: Optional[GcpResource] = None) -> GcpResource:
name = self.make_resource_name(self.ALTERNATIVE_URL_MAP_NAME)
src_address = f'{src_host}:{src_port}'
matcher_name = self.make_resource_name(self.URL_MAP_PATH_MATCHER_NAME)
if backend_service is None:
backend_service = self.alternative_backend_service
logger.info('Creating alternative URL map "%s": %s -> %s', name,
src_address, backend_service.name)
resource = self.compute.create_url_map_with_content(
self._generate_url_map_body(name, matcher_name, [src_address],
backend_service))
self.alternative_url_map = resource
return resource
def delete_alternative_url_map(self, force=False):
if force:
name = self.make_resource_name(self.ALTERNATIVE_URL_MAP_NAME)
elif self.alternative_url_map:
name = self.alternative_url_map.name
else:
return
logger.info('Deleting alternative URL Map "%s"', name)
self.compute.delete_url_map(name)
self.url_map = None
def create_target_proxy(self): def create_target_proxy(self):
name = self.make_resource_name(self.TARGET_PROXY_NAME) name = self.make_resource_name(self.TARGET_PROXY_NAME)
if self.backend_service_protocol is BackendServiceProtocol.GRPC: if self.backend_service_protocol is BackendServiceProtocol.GRPC:
@ -519,28 +485,6 @@ class TrafficDirectorManager:
self.target_proxy = None self.target_proxy = None
self.target_proxy_is_http = False self.target_proxy_is_http = False
def create_alternative_target_proxy(self):
name = self.make_resource_name(self.ALTERNATIVE_TARGET_PROXY_NAME)
if self.backend_service_protocol is BackendServiceProtocol.GRPC:
logger.info(
'Creating alternative target GRPC proxy "%s" to URL map %s',
name, self.alternative_url_map.name)
self.alternative_target_proxy = self.compute.create_target_grpc_proxy(
name, self.alternative_url_map, False)
else:
raise TypeError('Unexpected backend service protocol')
def delete_alternative_target_grpc_proxy(self, force=False):
if force:
name = self.make_resource_name(self.ALTERNATIVE_TARGET_PROXY_NAME)
elif self.alternative_target_proxy:
name = self.alternative_target_proxy.name
else:
return
logger.info('Deleting alternative Target GRPC proxy "%s"', name)
self.compute.delete_target_grpc_proxy(name)
self.alternative_target_proxy = None
def find_unused_forwarding_rule_port( def find_unused_forwarding_rule_port(
self, self,
*, *,
@ -577,36 +521,6 @@ class TrafficDirectorManager:
self.compute.delete_forwarding_rule(name) self.compute.delete_forwarding_rule(name)
self.forwarding_rule = None self.forwarding_rule = None
def create_alternative_forwarding_rule(self,
src_port: int,
ip_address='0.0.0.0'):
name = self.make_resource_name(self.ALTERNATIVE_FORWARDING_RULE_NAME)
src_port = int(src_port)
logging.info(
'Creating alternative forwarding rule "%s" in network "%s": %s:%s -> %s',
name, self.network, ip_address, src_port,
self.alternative_target_proxy.url)
resource = self.compute.create_forwarding_rule(
name,
src_port,
self.alternative_target_proxy,
self.network_url,
ip_address=ip_address)
self.alternative_forwarding_rule = resource
return resource
def delete_alternative_forwarding_rule(self, force=False):
if force:
name = self.make_resource_name(
self.ALTERNATIVE_FORWARDING_RULE_NAME)
elif self.alternative_forwarding_rule:
name = self.alternative_forwarding_rule.name
else:
return
logger.info('Deleting alternative Forwarding rule "%s"', name)
self.compute.delete_forwarding_rule(name)
self.alternative_forwarding_rule = None
def create_firewall_rule(self, allowed_ports: List[str]): def create_firewall_rule(self, allowed_ports: List[str]):
name = self.make_resource_name(self.FIREWALL_RULE_NAME) name = self.make_resource_name(self.FIREWALL_RULE_NAME)
logging.info( logging.info(

@ -350,55 +350,6 @@ class XdsKubernetesTestCase(absltest.TestCase, metaclass=abc.ABCMeta):
json_format.MessageToJson(config, indent=2)) json_format.MessageToJson(config, indent=2))
self.assertSameElements(want, seen) self.assertSameElements(want, seen)
@staticmethod
def getRouteConfigVersion(test_client: XdsTestClient) -> Optional[str]:
config = test_client.csds.fetch_client_status(log_level=logging.INFO)
route_config_version = None
for xds_config in config.xds_config:
if xds_config.WhichOneof('per_xds_config') == "route_config":
route_config = xds_config.route_config
logger.info('Route config found: %s',
json_format.MessageToJson(route_config, indent=2))
route_config_version = route_config.dynamic_route_configs[
0].version_info
logger.info('found routing config version: %s',
route_config_version)
break
return route_config_version
def assertRouteConfigUpdateTrafficHandoff(
self, test_client: XdsTestClient,
previous_route_config_version: str, retry_wait_second: int,
timeout_second: int):
retryer = retryers.constant_retryer(
wait_fixed=datetime.timedelta(seconds=retry_wait_second),
timeout=datetime.timedelta(seconds=timeout_second),
retry_on_exceptions=(TdPropagationRetryableError,),
logger=logger,
log_level=logging.INFO)
try:
for attempt in retryer:
with attempt:
self.assertSuccessfulRpcs(test_client)
route_config_version = self.getRouteConfigVersion(
test_client)
if previous_route_config_version == route_config_version:
logger.info(
'Routing config not propagated yet. Retrying.')
raise TdPropagationRetryableError(
"CSDS not get updated routing config corresponding"
" to the second set of url maps")
else:
self.assertSuccessfulRpcs(test_client)
logger.info(
'[SUCCESS] Confirmed successful RPC with the updated routing config, version=%s',
route_config_version)
except retryers.RetryError as retry_error:
logger.info(
'Retry exhausted. TD routing config propagation failed after timeout %ds.',
timeout_second)
raise retry_error
def assertFailedRpcs(self, def assertFailedRpcs(self,
test_client: XdsTestClient, test_client: XdsTestClient,
num_rpcs: Optional[int] = 100): num_rpcs: Optional[int] = 100):
@ -427,10 +378,6 @@ class XdsKubernetesTestCase(absltest.TestCase, metaclass=abc.ABCMeta):
msg=f'Backend {backend} did not receive a single RPC') msg=f'Backend {backend} did not receive a single RPC')
class TdPropagationRetryableError(Exception):
pass
class RegularXdsKubernetesTestCase(XdsKubernetesTestCase): class RegularXdsKubernetesTestCase(XdsKubernetesTestCase):
@classmethod @classmethod

@ -1,102 +0,0 @@
# Copyright 2021 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 logging
from absl import flags
from absl.testing import absltest
from framework import xds_k8s_testcase
logger = logging.getLogger(__name__)
flags.adopt_module_key_flags(xds_k8s_testcase)
# Type aliases
_XdsTestServer = xds_k8s_testcase.XdsTestServer
_XdsTestClient = xds_k8s_testcase.XdsTestClient
_TD_CONFIG_RETRY_WAIT_SEC = 2
class ApiListenerTest(xds_k8s_testcase.RegularXdsKubernetesTestCase):
def test_api_listener(self) -> None:
with self.subTest('00_create_health_check'):
self.td.create_health_check()
with self.subTest('01_create_backend_services'):
self.td.create_backend_service()
with self.subTest('02_create_default_url_map'):
self.td.create_url_map(self.server_xds_host, self.server_xds_port)
with self.subTest('03_create_default_target_proxy'):
self.td.create_target_proxy()
with self.subTest('04_create_default_forwarding_rule'):
self.td.create_forwarding_rule(self.server_xds_port)
with self.subTest('05_start_test_server'):
test_server: _XdsTestServer = self.startTestServers()[0]
with self.subTest('06_add_server_backends_to_backend_services'):
self.setupServerBackends()
with self.subTest('07_start_test_client'):
test_client: _XdsTestClient = self.startTestClient(test_server)
with self.subTest('08_test_client_xds_config_exists'):
self.assertXdsConfigExists(test_client)
with self.subTest('09_test_server_received_rpcs'):
self.assertSuccessfulRpcs(test_client)
with self.subTest('10_create_alternate_url_map'):
self.td.create_alternative_url_map(self.server_xds_host,
self.server_xds_port,
self.td.backend_service)
# Create alternate target proxy pointing to alternate url_map with the same
# host name in host rule. The port is fixed because they point to the same backend service.
# Therefore we have to choose a non-`0.0.0.0` ip because ip:port needs to be unique.
# We also have to set validate_for_proxyless=false because requires `0.0.0.0` ip.
# See https://github.com/grpc/grpc-java/issues/8009
with self.subTest('11_create_alternate_target_proxy'):
self.td.create_alternative_target_proxy()
# Create a second suite of map+tp+fr with the same host name in host rule.
# We set fr ip_address to be different from `0.0.0.0` and then set
# validate_for_proxyless=false because ip:port needs to be unique.
with self.subTest('12_create_alternate_forwarding_rule'):
self.td.create_alternative_forwarding_rule(self.server_xds_port,
ip_address='10.10.10.10')
with self.subTest('13_test_server_received_rpcs_with_two_url_maps'):
self.assertSuccessfulRpcs(test_client)
previous_route_config_version = self.getRouteConfigVersion(
test_client)
with self.subTest('14_delete_one_url_map_target_proxy_forwarding_rule'):
self.td.delete_forwarding_rule()
self.td.delete_target_grpc_proxy()
self.td.delete_url_map()
with self.subTest('15_test_server_continues_to_receive_rpcs'):
self.assertRouteConfigUpdateTrafficHandoff(
test_client, previous_route_config_version,
_TD_CONFIG_RETRY_WAIT_SEC,
xds_k8s_testcase._TD_CONFIG_MAX_WAIT_SEC)
if __name__ == '__main__':
absltest.main(failfast=True)
Loading…
Cancel
Save