def v_s_route_setup(request, kube_apis, crd_ingress_controller,
ingress_controller_endpoint) -> VirtualServerRouteSetup:
"""
Prepare Virtual Server Route Example.
1st namespace with VS and 1st addressed VSR and 2nd namespace with second addressed VSR.
:param request: internal pytest fixture
:param kube_apis: client apis
:param crd_ingress_controller:
:param ingress_controller_endpoint:
:return: VirtualServerRouteSetup
"""
vs_routes_ns = get_route_namespace_from_vs_yaml(
f"{TEST_DATA}/virtual-server-route/standard/virtual-server.yaml")
ns_1 = create_namespace_with_name_from_yaml(kube_apis.v1, vs_routes_ns[0],
f"{TEST_DATA}/common/ns.yaml")
ns_2 = create_namespace_with_name_from_yaml(kube_apis.v1, vs_routes_ns[1],
f"{TEST_DATA}/common/ns.yaml")
print(
"------------------------- Deploy Virtual Server -----------------------------------"
)
vs_name = create_virtual_server_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/virtual-server-route/standard/virtual-server.yaml", ns_1)
vs_host = get_first_vs_host_from_yaml(
f"{TEST_DATA}/virtual-server-route/standard/virtual-server.yaml")
print(
"------------------------- Deploy Virtual Server Route -----------------------------------"
)
vsr_m_name = create_v_s_route_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/virtual-server-route/route-multiple.yaml", ns_1)
vsr_m_paths = get_paths_from_vsr_yaml(
f"{TEST_DATA}/virtual-server-route/route-multiple.yaml")
route_m = VirtualServerRoute(ns_1, vsr_m_name, vsr_m_paths)
vsr_s_name = create_v_s_route_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/virtual-server-route/route-single.yaml", ns_2)
vsr_s_paths = get_paths_from_vsr_yaml(
f"{TEST_DATA}/virtual-server-route/route-single.yaml")
route_s = VirtualServerRoute(ns_2, vsr_s_name, vsr_s_paths)
def fin():
print("Clean up the Virtual Server Route:")
delete_v_s_route(kube_apis.custom_objects, vsr_m_name, ns_1)
delete_v_s_route(kube_apis.custom_objects, vsr_s_name, ns_2)
print("Clean up Virtual Server:")
delete_virtual_server(kube_apis.custom_objects, vs_name, ns_1)
print("Delete test namespaces")
delete_namespace(kube_apis.v1, ns_1)
delete_namespace(kube_apis.v1, ns_2)
request.addfinalizer(fin)
return VirtualServerRouteSetup(ingress_controller_endpoint, ns_1, vs_host,
vs_name, route_m, route_s)
def vsr_externalname_setup(request, kube_apis,
ingress_controller_prerequisites,
ingress_controller_endpoint) -> ReducedVirtualServerRouteSetup:
"""
Prepare an example app for Virtual Server Route.
1st namespace with externalName svc and VS+VSR.
:param request: internal pytest fixture
:param kube_apis: client apis
:param ingress_controller_endpoint:
:param ingress_controller_prerequisites:
:return:
"""
vs_routes_ns = get_route_namespace_from_vs_yaml(
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
ns_1 = create_namespace_with_name_from_yaml(kube_apis.v1,
vs_routes_ns[0],
f"{TEST_DATA}/common/ns.yaml")
print("------------------------- Deploy External-Backend -----------------------------------")
external_ns = create_namespace_with_name_from_yaml(kube_apis.v1, "external-ns", f"{TEST_DATA}/common/ns.yaml")
external_svc_name = create_service_with_name(kube_apis.v1, external_ns, "external-backend-svc")
create_deployment_with_name(kube_apis.apps_v1_api, external_ns, "external-backend")
print("------------------------- Deploy Virtual Server -----------------------------------")
vs_name = create_virtual_server_from_yaml(kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml",
ns_1)
vs_host = get_first_vs_host_from_yaml(f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
print("------------------------- Deploy Virtual Server Route -----------------------------------")
vsr_name = create_v_s_route_from_yaml(kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/route-single.yaml",
ns_1)
vsr_paths = get_paths_from_vsr_yaml(f"{TEST_DATA}/{request.param['example']}/route-single.yaml")
route = VirtualServerRoute(ns_1, vsr_name, vsr_paths)
print("---------------------- Deploy ExternalName service and update ConfigMap ----------------------------")
config_map_name = ingress_controller_prerequisites.config_map["metadata"]["name"]
replace_configmap_from_yaml(kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
f"{TEST_DATA}/{request.param['example']}/nginx-config.yaml")
external_svc_host = f"{external_svc_name}.{external_ns}.svc.cluster.local"
svc_name = create_service_from_yaml(kube_apis.v1,
ns_1, f"{TEST_DATA}/{request.param['example']}/externalname-svc.yaml")
wait_before_test(2)
req_url = f"http://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.port}"
ensure_response_from_backend(f"{req_url}{route.paths[0]}", vs_host)
def fin():
print("Delete test namespaces")
delete_namespace(kube_apis.v1, external_ns)
delete_namespace(kube_apis.v1, ns_1)
request.addfinalizer(fin)
return ReducedVirtualServerRouteSetup(ingress_controller_endpoint,
ns_1, vs_host, vs_name, route, svc_name, external_svc_host)
def vs_externalname_setup(request,
kube_apis,
ingress_controller_prerequisites,
virtual_server_setup) -> ExternalNameSetup:
print("------------------------- Deploy External-Backend -----------------------------------")
external_ns = create_namespace_with_name_from_yaml(kube_apis.v1, "external-ns", f"{TEST_DATA}/common/ns.yaml")
external_svc_name = create_service_with_name(kube_apis.v1, external_ns, "external-backend-svc")
create_deployment_with_name(kube_apis.apps_v1_api, external_ns, "external-backend")
print("------------------------- Prepare ExternalName Setup -----------------------------------")
external_svc_src = f"{TEST_DATA}/virtual-server-externalname/externalname-svc.yaml"
external_svc_host = f"{external_svc_name}.{external_ns}.svc.cluster.local"
config_map_name = ingress_controller_prerequisites.config_map["metadata"]["name"]
replace_configmap_from_yaml(kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
f"{TEST_DATA}/virtual-server-externalname/nginx-config.yaml")
external_svc = create_service_from_yaml(kube_apis.v1, virtual_server_setup.namespace, external_svc_src)
wait_before_test(2)
ensure_connection_to_public_endpoint(virtual_server_setup.public_endpoint.public_ip,
virtual_server_setup.public_endpoint.port,
virtual_server_setup.public_endpoint.port_ssl)
ic_pod_name = get_first_pod_name(kube_apis.v1, ingress_controller_prerequisites.namespace)
ensure_response_from_backend(virtual_server_setup.backend_1_url, virtual_server_setup.vs_host)
def fin():
print("Clean up ExternalName Setup:")
delete_namespace(kube_apis.v1, external_ns)
replace_configmap(kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
ingress_controller_prerequisites.config_map)
request.addfinalizer(fin)
return ExternalNameSetup(ic_pod_name, external_svc, external_svc_host)
def vsr_adv_routing_setup(
request, kube_apis, ingress_controller_prerequisites,
ingress_controller_endpoint) -> VSRAdvancedRoutingSetup:
"""
Prepare an example app for advanced routing VSR.
Single namespace with VS+VSR and advanced-routing app.
:param request: internal pytest fixture
:param kube_apis: client apis
:param ingress_controller_endpoint:
:param ingress_controller_prerequisites:
:return:
"""
vs_routes_ns = get_route_namespace_from_vs_yaml(
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
ns_1 = create_namespace_with_name_from_yaml(kube_apis.v1, vs_routes_ns[0],
f"{TEST_DATA}/common/ns.yaml")
print(
"------------------------- Deploy Virtual Server -----------------------------------"
)
vs_name = create_virtual_server_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml",
ns_1)
vs_host = get_first_vs_host_from_yaml(
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
print(
"------------------------- Deploy Virtual Server Route -----------------------------------"
)
vsr_name = create_v_s_route_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/virtual-server-route-header.yaml",
ns_1)
vsr_paths = get_paths_from_vsr_yaml(
f"{TEST_DATA}/{request.param['example']}/virtual-server-route-header.yaml"
)
route = VirtualServerRoute(ns_1, vsr_name, vsr_paths)
backends_url = f"http://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.port}{vsr_paths[0]}"
print(
"---------------------- Deploy advanced-routing app ----------------------------"
)
create_example_app(kube_apis, "advanced-routing", ns_1)
wait_until_all_pods_are_ready(kube_apis.v1, ns_1)
def fin():
print("Delete test namespace")
delete_namespace(kube_apis.v1, ns_1)
request.addfinalizer(fin)
return VSRAdvancedRoutingSetup(ns_1, vs_host, vs_name, route, backends_url)
def test_namespace(kube_apis) -> str:
"""
Create a test namespace.
:param kube_apis: client apis
:return: str
"""
timestamp = round(time.time() * 1000)
print("------------------------- Create Test Namespace -----------------------------------")
namespace = create_namespace_with_name_from_yaml(kube_apis.v1,
f"test-namespace-{str(timestamp)}",
f"{TEST_DATA}/common/ns.yaml")
return namespace
def backend_setup(request, kube_apis,
ingress_controller_endpoint) -> BackendSetup:
"""
Create 2 namespaces and deploy simple applications in them.
:param request: pytest fixture
:param kube_apis: client apis
:param ingress_controller_endpoint: public endpoint
:return: BackendSetup
"""
watched_namespace = create_namespace_with_name_from_yaml(
kube_apis.v1, f"watched-ns", f"{TEST_DATA}/common/ns.yaml")
foreign_namespace = create_namespace_with_name_from_yaml(
kube_apis.v1, f"foreign-ns", f"{TEST_DATA}/common/ns.yaml")
ingress_hosts = {}
for ns in [watched_namespace, foreign_namespace]:
print(
f"------------------------- Deploy the backend in {ns} -----------------------------------"
)
create_example_app(kube_apis, "simple", ns)
src_ing_yaml = f"{TEST_DATA}/watch-namespace/{ns}-ingress.yaml"
create_items_from_yaml(kube_apis, src_ing_yaml, ns)
ingress_host = get_first_ingress_host_from_yaml(src_ing_yaml)
ingress_hosts[f"{ns}-ingress"] = ingress_host
req_url = f"http://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.port}/backend1"
wait_until_all_pods_are_ready(kube_apis.v1, ns)
ensure_connection_to_public_endpoint(
ingress_controller_endpoint.public_ip,
ingress_controller_endpoint.port,
ingress_controller_endpoint.port_ssl)
def fin():
print("Clean up:")
delete_namespace(kube_apis.v1, watched_namespace)
delete_namespace(kube_apis.v1, foreign_namespace)
request.addfinalizer(fin)
return BackendSetup(req_url, ingress_hosts)
def external_name_setup(request, kube_apis, ingress_controller_prerequisites,
ingress_controller_endpoint, ingress_controller,
test_namespace) -> ExternalNameSetup:
print(
"------------------------- Deploy External-Backend -----------------------------------"
)
external_ns = create_namespace_with_name_from_yaml(
kube_apis.v1, "external-ns", f"{TEST_DATA}/common/ns.yaml")
external_svc_name = create_service_with_name(kube_apis.v1, external_ns,
"external-backend-svc")
create_deployment_with_name(kube_apis.apps_v1_api, external_ns,
"external-backend")
print(
"------------------------- Deploy External-Name-Example -----------------------------------"
)
ingress_name = create_ingress_from_yaml(
kube_apis.extensions_v1_beta1, test_namespace,
f"{TEST_DATA}/externalname-services/externalname-ingress.yaml")
ingress_host = get_first_ingress_host_from_yaml(
f"{TEST_DATA}/externalname-services/externalname-ingress.yaml")
external_host = f"{external_svc_name}.{external_ns}.svc.cluster.local"
config_map_name = ingress_controller_prerequisites.config_map["metadata"][
"name"]
replace_configmap_from_yaml(
kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
f"{TEST_DATA}/externalname-services/nginx-config.yaml")
svc_name = create_service_from_yaml(
kube_apis.v1, test_namespace,
f"{TEST_DATA}/externalname-services/externalname-svc.yaml")
ensure_connection_to_public_endpoint(ingress_controller_endpoint.public_ip,
ingress_controller_endpoint.port,
ingress_controller_endpoint.port_ssl)
ic_pod_name = get_first_pod_name(
kube_apis.v1, ingress_controller_prerequisites.namespace)
def fin():
print("Clean up External-Name-Example:")
delete_namespace(kube_apis.v1, external_ns)
replace_configmap(kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
ingress_controller_prerequisites.config_map)
delete_ingress(kube_apis.extensions_v1_beta1, ingress_name,
test_namespace)
delete_service(kube_apis.v1, svc_name, test_namespace)
request.addfinalizer(fin)
return ExternalNameSetup(ingress_controller_endpoint, ingress_name,
ingress_host, ic_pod_name, svc_name,
external_host, test_namespace)
def test_namespace(kube_apis, request) -> str:
"""
Create a test namespace.
:param kube_apis: client apis
:param request: pytest fixture
:return: str
"""
timestamp = round(time.time() * 1000)
print("------------------------- Create Test Namespace -----------------------------------")
namespace = create_namespace_with_name_from_yaml(kube_apis.v1, f"test-namespace-{str(timestamp)}", f"{TEST_DATA}/common/ns.yaml")
def fin():
print("Delete test namespace")
delete_namespace(kube_apis.v1, namespace)
request.addfinalizer(fin)
return namespace
def test_namespace(kube_apis, request) -> str:
"""
Create a test namespace.
:param kube_apis: client apis
:param request: pytest fixture
:return: str
"""
timestamp = round(time.time() * 1000)
print("------------------------- Create Test Namespace -----------------------------------")
namespace = create_namespace_with_name_from_yaml(kube_apis.v1, f"test-namespace-{str(timestamp)}", f"{TEST_DATA}/common/ns.yaml")
def fin():
print("Delete test namespace")
delete_namespace(kube_apis.v1, namespace)
request.addfinalizer(fin)
return namespace
def ap_vsr_setup(kube_apis, test_namespace, policy_method) -> tuple:
print(
f"------------------------- Deploy namespace ---------------------------"
)
vs_routes_ns = "grpcs"
vsr_ns = create_namespace_with_name_from_yaml(
kube_apis.v1, vs_routes_ns, f"{TEST_DATA}/common/ns.yaml")
src_pol_name, vs_name = ap_generic_setup(kube_apis, vsr_ns, test_namespace,
policy_method, vsr_vs_yaml)
vs_host = get_first_host_from_yaml(vsr_vs_yaml)
print(
"------------------------- Deploy Virtual Server Route ----------------------------"
)
vsr_name = create_v_s_route_from_yaml(kube_apis.custom_objects,
waf_subroute_vsr_src, vsr_ns)
vsr_paths = get_paths_from_vsr_yaml(waf_subroute_vsr_src)
vsr = VirtualServerRoute(vsr_ns, vsr_name, vsr_paths)
return (src_pol_name, vsr_ns, vs_host, vs_name, vsr)
def vsr_externalname_setup(
request, kube_apis, ingress_controller_prerequisites,
ingress_controller_endpoint) -> ReducedVirtualServerRouteSetup:
"""
Prepare an example app for Virtual Server Route.
1st namespace with externalName svc and VS+VSR.
:param request: internal pytest fixture
:param kube_apis: client apis
:param ingress_controller_endpoint:
:param ingress_controller_prerequisites:
:return:
"""
vs_routes_ns = get_route_namespace_from_vs_yaml(
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
ns_1 = create_namespace_with_name_from_yaml(kube_apis.v1, vs_routes_ns[0],
f"{TEST_DATA}/common/ns.yaml")
print(
"------------------------- Deploy Virtual Server -----------------------------------"
)
vs_name = create_virtual_server_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml",
ns_1)
vs_host = get_first_vs_host_from_yaml(
f"{TEST_DATA}/{request.param['example']}/standard/virtual-server.yaml")
print(
"------------------------- Deploy Virtual Server Route -----------------------------------"
)
vsr_name = create_v_s_route_from_yaml(
kube_apis.custom_objects,
f"{TEST_DATA}/{request.param['example']}/route-single.yaml", ns_1)
vsr_paths = get_paths_from_vsr_yaml(
f"{TEST_DATA}/{request.param['example']}/route-single.yaml")
route = VirtualServerRoute(ns_1, vsr_name, vsr_paths)
print(
"---------------------- Deploy ExternalName service and update ConfigMap ----------------------------"
)
config_map_name = ingress_controller_prerequisites.config_map["metadata"][
"name"]
replace_configmap_from_yaml(
kube_apis.v1, config_map_name,
ingress_controller_prerequisites.namespace,
f"{TEST_DATA}/{request.param['example']}/nginx-config.yaml")
external_svc_src = f"{TEST_DATA}/{request.param['example']}/externalname-svc.yaml"
external_svc_name = create_service_from_yaml(kube_apis.v1, route.namespace,
external_svc_src)
external_svc_host = get_external_host_from_service_yaml(external_svc_src)
wait_before_test(2)
def fin():
print("Delete test namespace")
delete_namespace(kube_apis.v1, ns_1)
request.addfinalizer(fin)
return ReducedVirtualServerRouteSetup(ingress_controller_endpoint, ns_1,
vs_host, vs_name, route,
external_svc_name, external_svc_host)
def backend_setup(request, kube_apis, ingress_controller_endpoint) -> BackendSetup:
"""
Deploy a simple application and AppProtect manifests.
:param request: pytest fixture
:param kube_apis: client apis
:param ingress_controller_endpoint: public endpoint
:param test_namespace:
:return: BackendSetup
"""
policy = "file-block"
create_namespace_with_name_from_yaml(kube_apis.v1, test_namespace, f"{TEST_DATA}/common/ns.yaml")
print("------------------------- Deploy backend application -------------------------")
create_example_app(kube_apis, "simple", test_namespace)
req_url = f"https://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.port_ssl}/backend1"
req_url_2 = f"https://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.port_ssl}/backend2"
metrics_url = f"http://{ingress_controller_endpoint.public_ip}:{ingress_controller_endpoint.metrics_port}/metrics"
wait_until_all_pods_are_ready(kube_apis.v1, test_namespace)
ensure_connection_to_public_endpoint(
ingress_controller_endpoint.public_ip,
ingress_controller_endpoint.port,
ingress_controller_endpoint.port_ssl,
)
print("------------------------- Deploy Secret -----------------------------")
src_sec_yaml = f"{TEST_DATA}/appprotect/appprotect-secret.yaml"
create_items_from_yaml(kube_apis, src_sec_yaml, test_namespace)
print("------------------------- Deploy logconf -----------------------------")
src_log_yaml = f"{TEST_DATA}/appprotect/logconf.yaml"
log_name = create_ap_logconf_from_yaml(kube_apis.custom_objects, src_log_yaml, test_namespace)
print(f"------------------------- Deploy namespace: {policy_namespace} ---------------------------")
create_namespace_with_name_from_yaml(kube_apis.v1, policy_namespace, f"{TEST_DATA}/common/ns.yaml")
print(f"------------------------- Deploy appolicy: {policy} ---------------------------")
src_pol_yaml = f"{TEST_DATA}/appprotect/{policy}.yaml"
pol_name = create_ap_policy_from_yaml(kube_apis.custom_objects, src_pol_yaml, policy_namespace)
print("------------------------- Deploy ingress -----------------------------")
ingress_host = {}
src_ing_yaml = f"{TEST_DATA}/appprotect/appprotect-ingress.yaml"
create_ingress_with_ap_annotations(
kube_apis, src_ing_yaml, test_namespace, f"{policy_namespace}/{policy}", "True", "True", "127.0.0.1:514"
)
ingress_host = get_first_ingress_host_from_yaml(src_ing_yaml)
wait_before_test()
def fin():
print("Clean up:")
src_ing_yaml = f"{TEST_DATA}/appprotect/appprotect-ingress.yaml"
delete_items_from_yaml(kube_apis, src_ing_yaml, test_namespace)
delete_ap_policy(kube_apis.custom_objects, pol_name, policy_namespace)
delete_namespace(kube_apis.v1, policy_namespace)
delete_ap_logconf(kube_apis.custom_objects, log_name, test_namespace)
delete_common_app(kube_apis, "simple", test_namespace)
src_sec_yaml = f"{TEST_DATA}/appprotect/appprotect-secret.yaml"
delete_items_from_yaml(kube_apis, src_sec_yaml, test_namespace)
delete_namespace(kube_apis.v1, test_namespace)
request.addfinalizer(fin)
return BackendSetup(req_url, req_url_2, metrics_url, ingress_host)
