async def deep_check():
template = random.choice(
list(XDS_TEMPLATES['default'].keys())
)
await discovery.response(
mock_discovery_request(),
xds_type=template
)
node = mock_discovery_request().node
match_node(node_value=extract_node_key(node))
return PlainTextResponse(f'Rendered {template} OK')
async def display_config(
xds_type: DiscoveryTypes = Query(...,
title='xDS type',
description='The type of request',
example='clusters'),
service_cluster: str = Query(
'*',
title='The clients service cluster to emulate in this XDS request'
),
resource_names: str = Query('',
title='Envoy Resource names to request'),
region: str = Query(
None, title='The clients region to emulate in this XDS request'),
version: str = Query(
'1.11.1',
title='The clients envoy version to emulate in this XDS request')):
ret = defaultdict(list)
mock_request = mock_discovery_request(service_cluster=service_cluster,
resource_names=resource_names,
version=version,
region=region)
response = await discovery.response(request=mock_request,
xds_type=xds_type.value)
ret['resources'] += response.get('resources', [])
safe_response = jsonable_encoder(ret)
return json_response_class(content=safe_response)
async def debug_template(
xds_type: DiscoveryTypes = Query(...,
title="xDS type",
description="The type of request",
example="clusters"),
service_cluster: str = Query(
"*",
title="The clients service cluster to emulate in this XDS request"),
resource_names: str = Query("", title="Envoy Resource names to request"),
region: str = Query(
None, title="The clients region to emulate in this XDS request"),
version: str = Query(
"1.11.1",
title="The clients envoy version to emulate in this XDS request"),
) -> JSONResponse:
mock_request = mock_discovery_request(
service_cluster=service_cluster,
resource_names=resource_names.split(","),
version=version,
region=region,
)
template = select_template(mock_request, xds_type.value)
context = template_context.get_context(mock_request, template)
context = dict(
discovery_request=mock_request,
host_header="debug",
resource_names=mock_request.resources,
**context,
)
raw_template_content = await template(**context)
safe_response = jsonable_encoder(raw_template_content)
return JSONResponse(content=safe_response)
async def display_config(
xds_type: DiscoveryTypes = Query(...,
title="xDS type",
description="The type of request",
example="clusters"),
service_cluster: str = Query(
"*",
title="The clients service cluster to emulate in this XDS request"),
resource_names: str = Query("", title="Envoy Resource names to request"),
region: str = Query(
None, title="The clients region to emulate in this XDS request"),
version: str = Query(
"1.11.1",
title="The clients envoy version to emulate in this XDS request"),
) -> JSONResponse:
ret: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
mock_request = mock_discovery_request(
service_cluster=service_cluster,
resource_names=resource_names.split(","),
version=version,
region=region,
)
response = await discovery.response(request=mock_request,
xds_type=xds_type)
ret["resources"] += response.resources
safe_response = jsonable_encoder(ret)
return JSONResponse(content=safe_response)
async def resource(
xds_type: DiscoveryTypes = Path("clusters",
title="xDS type",
description="The type of request"),
resource_name: str = Path(..., title="Name of the resource to view"),
region: str = Query(
None, title="The clients region to emulate in this XDS request"),
api_version: str = Query("v2", title="The desired Envoy API version"),
service_cluster: str = Cookie(
"*",
title="The clients service cluster to emulate in this XDS request"),
envoy_version: str = Cookie(
"__any__",
title="The clients envoy version to emulate in this XDS request"),
) -> Response:
response = await perform_discovery(
req=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[resource_name],
version=envoy_version,
region=region,
),
api_version=api_version,
xds=xds_type,
skip_auth=True,
)
return Response(response.rendered, media_type="application/json")
async def virtual_hosts(
route_configuration: str = Path(
..., title='Name of the route configuration'),
virtual_host: str = Path(..., title='Name of the resource to view'),
region: str = Query(
None, title='The clients region to emulate in this XDS request'),
service_cluster: str = Cookie(
'*',
title='The clients service cluster to emulate in this XDS request'
),
envoy_version: str = Cookie(
'__any__',
title='The clients envoy version to emulate in this XDS request')):
response = await discovery.response(request=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[route_configuration],
version=envoy_version,
region=region),
xds_type='routes')
if isinstance(response, dict):
route_configs = [
resource_ for resource_ in response.get('resources', [])
if resource_['name'] == route_configuration
]
for route_config in route_configs:
for vhost in route_config['virtual_hosts']:
if vhost['name'] == virtual_host:
safe_response = jsonable_encoder(vhost)
try:
return json_response_class(content=safe_response)
except TypeError:
return JSONResponse(content=safe_response)
break
async def resource(
xds_type: DiscoveryTypes = Path('clusters',
title='xDS type',
description='The type of request'),
resource_name: str = Path(..., title='Name of the resource to view'),
region: str = Query(
None, title='The clients region to emulate in this XDS request'),
service_cluster: str = Cookie(
'*',
title='The clients service cluster to emulate in this XDS request'
),
envoy_version: str = Cookie(
'__any__',
title='The clients envoy version to emulate in this XDS request')):
response = await discovery.response(request=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[resource_name],
version=envoy_version,
region=region),
xds_type=xds_type.value)
safe_response = jsonable_encoder(response)
try:
return json_response_class(content=safe_response)
except TypeError:
return JSONResponse(content=safe_response)
async def deep_check(response: Response) -> List[str]:
response.status_code = 200
ret = list()
for template in list(XDS_TEMPLATES["default"].keys()):
try:
req = mock_discovery_request(service_cluster="*")
await discovery.response(req,
xds_type=getattr(discovery.DiscoveryTypes,
template, template))
# pylint: disable=broad-except
except Exception as e:
ret.append(f"Failed {template}: {str(e)}")
else:
ret.append(f"Rendered {template} OK")
return ret
async def resources(
request: Request,
xds_type: DiscoveryTypes = Path('clusters',
title='xDS type',
description='The type of request'),
region: str = Query(
None, title='The clients region to emulate in this XDS request'),
service_cluster: str = Cookie(
'*',
title='The clients service cluster to emulate in this XDS request'),
envoy_version: str = Cookie(
'__any__',
title='The clients envoy version to emulate in this XDS request')):
ret = defaultdict(list)
try:
response = await discovery.response(request=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[],
version=envoy_version,
region=region),
xds_type=xds_type.value)
except KeyError:
ret['resources'] = []
else:
if isinstance(response, dict):
ret['resources'] += response.get('resources') or []
return html_templates.TemplateResponse(name='resources.html',
media_type='text/html',
context={
'resources':
ret['resources'],
'request':
request,
'resource_type':
xds_type.value,
'all_types':
all_types,
'version':
envoy_version,
'available_versions':
list(XDS_TEMPLATES.keys()),
'service_cluster':
service_cluster,
'available_service_clusters':
available_service_clusters(),
'last_update':
str(source_metadata),
})
async def resources(
request: Request,
xds_type: DiscoveryTypes = Path("clusters",
title="xDS type",
description="The type of request"),
region: str = Query(
None, title="The clients region to emulate in this XDS request"),
api_version: str = Query("v2", title="The desired Envoy API version"),
service_cluster: str = Cookie(
"*",
title="The clients service cluster to emulate in this XDS request"),
envoy_version: str = Cookie(
"__any__",
title="The clients envoy version to emulate in this XDS request"),
) -> Response:
ret: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
try:
response = await perform_discovery(
req=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[],
version=envoy_version,
region=region,
),
api_version=api_version,
xds=xds_type,
skip_auth=True,
)
except KeyError:
ret["resources"] = []
else:
ret["resources"] += response.deserialize_resources()
return html_templates.TemplateResponse(
name="resources.html",
media_type="text/html",
context={
"resources": ret["resources"],
"request": request,
"resource_type": xds_type.value,
"all_types": all_types,
"version": envoy_version,
"available_versions": list(XDS_TEMPLATES.keys()),
"service_cluster": service_cluster,
"available_service_clusters": poller.match_keys,
"last_update": str(poller.last_updated),
},
)
def instances(
service_cluster: str = Query(
"*",
title="The clients service cluster to emulate in this XDS request"),
modified: str = Query(
"yes",
title=
"Whether the sources should run Modifiers/Global Modifiers prior to being returned",
),
) -> JSONResponse:
node = mock_discovery_request(service_cluster=service_cluster).node
args = {
"modify": yaml.safe_load(modified),
"node_value": poller.extract_node_key(node),
}
ret = poller.match_node(**args)
safe_response = jsonable_encoder(ret)
return JSONResponse(content=safe_response)
def instances(
service_cluster: str = Query(
'*',
title='The clients service cluster to emulate in this XDS request'
),
modified:
str = Query(
'yes',
title=
'Whether the sources should run Modifiers/Global Modifiers prior to being returned'
)):
node = mock_discovery_request(service_cluster=service_cluster).node
args = {
'modify': yaml.safe_load(modified),
'node_value': extract_node_key(node)
}
ret = match_node(**args)
safe_response = jsonable_encoder(ret)
return json_response_class(content=safe_response)
async def virtual_hosts(
route_configuration: str = Path(...,
title="Name of the route configuration"),
virtual_host: str = Path(..., title="Name of the resource to view"),
region: str = Query(
None, title="The clients region to emulate in this XDS request"),
api_version: str = Query("v2", title="The desired Envoy API version"),
service_cluster: str = Cookie(
"*",
title="The clients service cluster to emulate in this XDS request"),
envoy_version: str = Cookie(
"__any__",
title="The clients envoy version to emulate in this XDS request"),
) -> Response:
response = await perform_discovery(
req=mock_discovery_request(
service_cluster=service_cluster,
resource_names=[route_configuration],
version=envoy_version,
region=region,
),
api_version=api_version,
xds=getattr(DiscoveryTypes, "routes", "routes"),
skip_auth=True,
)
route_configs = [
resource_ for resource_ in response.deserialize_resources()
if resource_["name"] == route_configuration
]
for route_config in route_configs:
for vhost in route_config["virtual_hosts"]:
if vhost["name"] == virtual_host:
safe_response = jsonable_encoder(vhost)
try:
return json_response_class(content=safe_response)
except TypeError:
return JSONResponse(content=safe_response)
break
return JSONResponse(content={})
def discovery_request_with_auth():
"""Envoy XDS Discovery request with the test auth defined in global"""
return mock_discovery_request(service_cluster="T1",
metadata={"auth": test_auth})
def discovery_request():
"""Envoy XDS Discovery request without authentication"""
return mock_discovery_request(service_cluster="T1")
