def transport_server_setup(
request, kube_apis, ingress_controller_prerequisites, test_namespace,
ingress_controller_endpoint) -> TransportServerSetup:
"""
Prepare Transport Server Example.
:param ingress_controller_endpoint:
:param ingress_controller_prerequisites:
:param request: internal pytest fixture to parametrize this method
:param kube_apis: client apis
:param test_namespace:
:return: TransportServerSetup
"""
print(
"------------------------- Deploy Transport Server Example -----------------------------------"
)
# deploy global config
global_config_file = (
f"{TEST_DATA}/{request.param['example']}/standard/global-configuration.yaml"
)
gc_resource = create_gc_from_yaml(kube_apis.custom_objects,
global_config_file, "nginx-ingress")
# deploy service_file
service_file = f"{TEST_DATA}/{request.param['example']}/standard/service_deployment.yaml"
create_items_from_yaml(kube_apis, service_file, test_namespace)
# deploy transport server
transport_server_file = f"{TEST_DATA}/{request.param['example']}/standard/transport-server.yaml"
ts_resource = create_ts_from_yaml(kube_apis.custom_objects,
transport_server_file, test_namespace)
wait_until_all_pods_are_ready(kube_apis.v1, test_namespace)
def fin():
print("Clean up TransportServer Example:")
delete_ts(kube_apis.custom_objects, ts_resource, test_namespace)
delete_items_from_yaml(kube_apis, service_file, test_namespace)
delete_gc(kube_apis.custom_objects, gc_resource, "nginx-ingress")
request.addfinalizer(fin)
ic_pod_name = get_first_pod_name(
kube_apis.v1, ingress_controller_prerequisites.namespace)
ic_namespace = ingress_controller_prerequisites.namespace
return TransportServerSetup(
ts_resource['metadata']['name'],
test_namespace,
ic_pod_name,
ic_namespace,
ingress_controller_endpoint,
ts_resource,
)
def restore_ts(self, kube_apis,
transport_server_tls_passthrough_setup) -> None:
"""
Function to create std TS resource
"""
ts_std_src = f"{TEST_DATA}/transport-server-tls-passthrough/standard/transport-server.yaml"
ts_std_res = create_ts_from_yaml(
kube_apis.custom_objects,
ts_std_src,
transport_server_tls_passthrough_setup.namespace,
)
wait_before_test(1)
pprint(ts_std_res)
def test_total_metrics(self, crd_ingress_controller, ts_setup,
ingress_controller_endpoint, kube_apis,
test_namespace, ts):
"""
Tests nginx_ingress_controller_transportserver_resources_total metric for a given TransportServer type.
"""
ts_file = ts[0]
ts_type = ts[1]
# initially, the number of TransportServers is 0
assert_ts_total_metric(ingress_controller_endpoint, ts_type, 0)
# create a TS and check the metric is 1
ts_resource = create_ts_from_yaml(kube_apis.custom_objects, ts_file,
test_namespace)
wait_before_test()
assert_ts_total_metric(ingress_controller_endpoint, ts_type, 1)
# make the TS invalid and check the metric is 0
ts_resource["spec"]["listener"]["protocol"] = "invalid"
patch_ts(kube_apis.custom_objects, test_namespace, ts_resource)
wait_before_test()
assert_ts_total_metric(ingress_controller_endpoint, ts_type, 0)
# restore the TS and check the metric is 1
patch_ts_from_yaml(kube_apis.custom_objects,
ts_resource["metadata"]["name"], ts_file,
test_namespace)
wait_before_test()
assert_ts_total_metric(ingress_controller_endpoint, ts_type, 1)
# delete the TS and check the metric is 0
delete_ts(kube_apis.custom_objects, ts_resource, test_namespace)
wait_before_test()
assert_ts_total_metric(ingress_controller_endpoint, ts_type, 0)
def transport_server_setup(request, kube_apis,
test_namespace) -> TransportServerSetup:
"""
Prepare Transport Server Example.
:param request: internal pytest fixture to parametrize this method
:param kube_apis: client apis
:param test_namespace:
:return: TransportServerSetup
"""
print(
"------------------------- Deploy Transport Server Example -----------------------------------"
)
# deploy global config
global_config_file = (
f"{TEST_DATA}/{request.param['example']}/standard/global-configuration.yaml"
)
gc_resource = create_gc_from_yaml(kube_apis.custom_objects,
global_config_file, "nginx-ingress")
# deploy dns
dns_file = f"{TEST_DATA}/{request.param['example']}/standard/dns.yaml"
create_items_from_yaml(kube_apis, dns_file, test_namespace)
# deploy transport server
transport_server_file = f"{TEST_DATA}/{request.param['example']}/standard/transport-server.yaml"
ts_resource = create_ts_from_yaml(kube_apis.custom_objects,
transport_server_file, test_namespace)
wait_until_all_pods_are_ready(kube_apis.v1, test_namespace)
def fin():
print("Clean up TransportServer Example:")
delete_ts(kube_apis.custom_objects, ts_resource, test_namespace)
delete_items_from_yaml(kube_apis, dns_file, test_namespace)
delete_gc(kube_apis.custom_objects, gc_resource, "nginx-ingress")
request.addfinalizer(fin)
return TransportServerSetup(ts_resource["metadata"]["name"],
test_namespace)
def test_tls_passthrough_host_collision_ts(
self,
kube_apis,
crd_ingress_controller,
transport_server_tls_passthrough_setup,
test_namespace,
):
"""
Test host collision handling in TransportServer with another TransportServer.
"""
print("Step 1: Create second TS with same host")
ts_src_same_host = (
f"{TEST_DATA}/transport-server-tls-passthrough/transport-server-same-host.yaml"
)
ts_same_host = create_ts_from_yaml(kube_apis.custom_objects,
ts_src_same_host, test_namespace)
wait_before_test()
response = read_ts(kube_apis.custom_objects, test_namespace,
ts_same_host["metadata"]["name"])
assert (response["status"]["reason"] == "Rejected"
and response["status"]["message"]
== "Host is taken by another resource")
print("Step 2: Delete TS taking up the host")
delete_ts(
kube_apis.custom_objects,
transport_server_tls_passthrough_setup.ts_resource,
test_namespace,
)
wait_before_test(1)
response = read_ts(kube_apis.custom_objects, test_namespace,
ts_same_host["metadata"]["name"])
assert (response["status"]["reason"] == "AddedOrUpdated"
and response["status"]["state"] == "Valid")
print("Step 3: Delete second TS and re-create standard one")
delete_ts(kube_apis.custom_objects, ts_same_host, test_namespace)
self.restore_ts(kube_apis, transport_server_tls_passthrough_setup)
response = read_ts(kube_apis.custom_objects, test_namespace,
transport_server_tls_passthrough_setup.name)
assert (response["status"]["reason"] == "AddedOrUpdated"
and response["status"]["state"] == "Valid")
def transport_server_tls_passthrough_setup(
request, kube_apis, test_namespace,
ingress_controller_endpoint) -> TransportServerTlsSetup:
"""
Prepare Transport Server Example.
:param request: internal pytest fixture to parametrize this method
:param kube_apis: client apis
:param test_namespace: namespace for test resources
:param ingress_controller_endpoint: ip and port information
:return TransportServerTlsSetup:
"""
print(
"------------------------- Deploy Transport Server with tls passthrough -----------------------------------"
)
# deploy secure_app
secure_app_file = f"{TEST_DATA}/{request.param['example']}/standard/secure-app.yaml"
create_items_from_yaml(kube_apis, secure_app_file, test_namespace)
# deploy transport server
transport_server_std_src = f"{TEST_DATA}/{request.param['example']}/standard/transport-server.yaml"
ts_resource = create_ts_from_yaml(kube_apis.custom_objects,
transport_server_std_src, test_namespace)
ts_host = get_first_host_from_yaml(transport_server_std_src)
wait_until_all_pods_are_ready(kube_apis.v1, test_namespace)
def fin():
print("Clean up TransportServer and app:")
delete_ts(kube_apis.custom_objects, ts_resource, test_namespace)
delete_items_from_yaml(kube_apis, secure_app_file, test_namespace)
request.addfinalizer(fin)
return TransportServerTlsSetup(
ingress_controller_endpoint,
ts_resource,
ts_resource["metadata"]["name"],
test_namespace,
ts_host,
)
def test_tcp_request_load_balanced_multiple(self, kube_apis,
crd_ingress_controller,
transport_server_setup):
"""
Requests to the load balanced TCP service should result in responses from 3 different endpoints.
"""
port = transport_server_setup.public_endpoint.tcp_server_port
host = transport_server_setup.public_endpoint.public_ip
# Step 1, confirm load balancing is working.
print(f"sending tcp requests to: {host}:{port}")
host = host.strip("[]")
client = socket.create_connection((host, port))
client.sendall(b'connect')
response = client.recv(4096)
endpoint = response.decode()
print(f'response: {endpoint}')
client.close()
assert endpoint is not ""
# Step 2, add a second TransportServer with the same port and confirm the collision
transport_server_file = f"{TEST_DATA}/transport-server-tcp-load-balance/second-transport-server.yaml"
ts_resource = create_ts_from_yaml(kube_apis.custom_objects,
transport_server_file,
transport_server_setup.namespace)
wait_before_test()
second_ts_name = ts_resource['metadata']['name']
response = read_ts(
kube_apis.custom_objects,
transport_server_setup.namespace,
second_ts_name,
)
assert (response["status"]
and response["status"]["reason"] == "Rejected"
and response["status"]["state"] == "Warning"
and response["status"]["message"]
== "Listener tcp-server is taken by another resource")
# Step 3, remove the default TransportServer with the same port
delete_ts(kube_apis.custom_objects, transport_server_setup.resource,
transport_server_setup.namespace)
wait_before_test()
response = read_ts(
kube_apis.custom_objects,
transport_server_setup.namespace,
second_ts_name,
)
assert (response["status"]
and response["status"]["reason"] == "AddedOrUpdated"
and response["status"]["state"] == "Valid")
# Step 4, confirm load balancing is still working.
print(f"sending tcp requests to: {host}:{port}")
host = host.strip("[]")
client = socket.create_connection((host, port))
client.sendall(b'connect')
response = client.recv(4096)
endpoint = response.decode()
print(f'response: {endpoint}')
client.close()
assert endpoint is not ""
# cleanup
delete_ts(kube_apis.custom_objects, ts_resource,
transport_server_setup.namespace)
transport_server_file = f"{TEST_DATA}/transport-server-tcp-load-balance/standard/transport-server.yaml"
create_ts_from_yaml(kube_apis.custom_objects, transport_server_file,
transport_server_setup.namespace)
wait_before_test()
