def cluster_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: List
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
vcd_clusters_info = vcd_broker.list_clusters(data=data)
properties_to_retain = [
'name',
'vdc',
'status',
'org_name',
'k8s_version',
K8S_PROVIDER_KEY
]
return _retain_cluster_list_common_properties(vcd_clusters_info,
properties_to_retain)
def org_vdc_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for orgvdc list operation.
This handler returns a paginated response.
:return: Dictionary containing list of org VDC K8s provider metadata
:rtype: dict
"""
# NOTE: Response sent out by this function should be paginated
data = req_utils.flatten_request_data(request_data,
[RequestKey.QUERY_PARAMS])
defaults = {
PaginationKey.PAGE_NUMBER: CSE_PAGINATION_FIRST_PAGE_NUMBER,
PaginationKey.PAGE_SIZE: CSE_PAGINATION_DEFAULT_PAGE_SIZE
}
validated_data = {**defaults, **data}
page_number = int(validated_data[PaginationKey.PAGE_NUMBER])
page_size = int(validated_data[PaginationKey.PAGE_SIZE])
# Record telemetry data
# TODO: enhance telemetry to record the page number and page size data.
cse_params = copy.deepcopy(validated_data)
cse_params[PayloadKey.
SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
record_user_action_details(cse_operation=CseOperation.OVDC_LIST,
cse_params=cse_params)
client_v33 = op_ctx.get_client(api_version=DEFAULT_API_VERSION)
result = vcd_utils.get_ovdcs_by_page(client_v33,
page=page_number,
page_size=page_size)
org_vdcs = result[PaginationKey.VALUES]
result_total = result[PaginationKey.RESULT_TOTAL]
next_page_uri = result.get(PaginationKey.NEXT_PAGE_URI)
prev_page_uri = result.get(PaginationKey.PREV_PAGE_URI)
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
ovdcs = _get_cse_ovdc_list(sysadmin_client_v33, org_vdcs)
api_path = CseServerOperationInfo.ORG_VDC_LIST.api_path_format
next_page_uri = vcd_utils.create_cse_page_uri(client_v33,
api_path,
vcd_uri=next_page_uri)
prev_page_uri = vcd_utils.create_cse_page_uri(client_v33,
api_path,
vcd_uri=prev_page_uri)
return server_utils.construct_paginated_response(
values=ovdcs,
result_total=result_total,
page_number=page_number,
page_size=page_size,
next_page_uri=next_page_uri,
prev_page_uri=prev_page_uri)
def cluster_upgrade(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster upgrade operation.
data validation handled in broker
:return: Dict
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
return vcd_broker.upgrade_cluster(data=data)
def cluster_upgrade_plan(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster upgrade-plan operation.
data validation handled in broker
:return: List[Tuple(str, str)]
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
return vcd_broker.get_cluster_upgrade_plan(data=data)
def cluster_config(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster config operation.
Required data: cluster_name
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: Dict
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
return vcd_broker.get_cluster_config(data=data)
def ovdc_update(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc enable, disable operations.
Required data: org_name, ovdc_name, k8s_provider
Conditional data:
if k8s_provider is 'ent-pks': pks_plan_name, pks_cluster_domain
:return: Dictionary with org VDC update task href.
"""
# TODO the data flow here should be better understood.
# org_name and ovdc_name seem redundant if we already have ovdc_id
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC, RequestKey.QUERY_PARAMS])
required = [
RequestKey.ORG_NAME, RequestKey.OVDC_NAME, RequestKey.K8S_PROVIDER,
RequestKey.OVDC_ID
]
validated_data = data
req_utils.validate_payload(validated_data, required)
k8s_provider = validated_data[RequestKey.K8S_PROVIDER]
k8s_provider_info = {K8S_PROVIDER_KEY: k8s_provider}
# Record the telemetry data
cse_params = copy.deepcopy(validated_data)
cse_params[PayloadKey.
SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
cse_operation = CseOperation.OVDC_DISABLE if k8s_provider == K8sProvider.NONE else CseOperation.OVDC_ENABLE # noqa: E501
record_user_action_details(cse_operation=cse_operation,
cse_params=cse_params) # noqa: E501
try:
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
task = ovdc_utils.update_ovdc_k8s_provider_metadata(
sysadmin_client_v33,
validated_data[RequestKey.OVDC_ID],
k8s_provider_data=k8s_provider_info,
k8s_provider=k8s_provider)
# Telemetry - Record successful enabling/disabling of ovdc
record_user_action(cse_operation, status=OperationStatus.SUCCESS)
return {'task_href': task.get('href')}
except Exception as err:
# Telemetry - Record failed enabling/disabling of ovdc
record_user_action(cse_operation, status=OperationStatus.FAILED)
raise err
def node_delete(request_data, op_ctx: ctx.OperationContext):
"""Request handler for node delete operation.
Required data: cluster_name, node_names_list
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: Dict
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
return vcd_broker.delete_nodes(data=data)
def cluster_resize(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
Required data: cluster_name, num_nodes
Optional data and default values: org_name=None, ovdc_name=None
Conditional data and default values:
network_name, rollback=True
(data validation handled in broker)
:return: Dict
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
return vcd_broker.resize_cluster(data=data)
def node_create(request_data, op_ctx: ctx.OperationContext):
"""Request handler for node create operation.
Required data: cluster_name, network_name
Optional data and default values: org_name=None, ovdc_name=None,
num_nodes=1, num_cpu=None, mb_memory=None, storage_profile_name=None,
template_name=default, template_revision=default,
ssh_key=None, rollback=True, enable_nfs=False,
(data validation handled in broker)
:return: Dict
"""
vcd_broker = VcdBroker(op_ctx)
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
return vcd_broker.create_nodes(data=data)
def cluster_create(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster create operation.
Required data: org_name, ovdc_name, cluster_name
(data validation handled in broker)
:return: Dict
"""
_raise_error_if_pks_not_enabled()
data = req_utils.flatten_request_data(request_data,
[RequestKey.INPUT_SPEC])
required = [RequestKey.CLUSTER_NAME]
req_utils.validate_payload(data, required)
cluster_name = data[RequestKey.CLUSTER_NAME]
data['is_org_admin_search'] = True
try:
_get_cluster_and_broker(data, op_ctx, telemetry=False)
raise ClusterAlreadyExistsError(f"Cluster {cluster_name} "
f"already exists.")
except ClusterNotFoundError:
pass
sysadmin_client_v33 = op_ctx.get_sysadmin_client(
api_version=DEFAULT_API_VERSION)
k8s_metadata = \
ovdc_utils.get_ovdc_k8s_provider_metadata(
sysadmin_client_v33,
org_name=data[RequestKey.ORG_NAME],
ovdc_name=data[RequestKey.OVDC_NAME],
include_credentials=True,
include_nsxt_info=True)
broker = _get_broker_from_k8s_metadata(k8s_metadata, op_ctx)
data[RequestKey.PKS_PLAN_NAME] = k8s_metadata[PKS_PLANS_KEY][0]
data[RequestKey.PKS_EXT_HOST] = \
f"{cluster_name}.{k8s_metadata[PKS_CLUSTER_DOMAIN_KEY]}"
cluster = broker.create_cluster(data=data)
# Record telemetry data
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.PKS_CLUSTER_CREATE,
cse_params=_get_telemetry_data(data, cluster))
return cluster
def native_cluster_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: List
"""
vcd_broker = VcdBroker(op_ctx)
query_params = request_data.get(RequestKey.QUERY_PARAMS, {})
page_number = int(query_params.get(PaginationKey.PAGE_NUMBER, CSE_PAGINATION_FIRST_PAGE_NUMBER)) # noqa: E501
page_size = int(query_params.get(PaginationKey.PAGE_SIZE, CSE_PAGINATION_DEFAULT_PAGE_SIZE)) # noqa: E501 =
query_params_others = {}
for k, v in query_params.items():
if k not in [PaginationKey.PAGE_NUMBER, PaginationKey.PAGE_SIZE]:
query_params_others[k] = v
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
vcd_clusters_info = vcd_broker.get_clusters_by_page(
data=data, page_number=page_number, page_size=page_size)
properties_to_retain = [
'name',
'vdc',
'status',
'org_name',
'k8s_version',
K8S_PROVIDER_KEY
]
clusters = vcd_clusters_info[PaginationKey.VALUES]
result = _retain_cluster_list_common_properties(clusters,
properties_to_retain)
# remove duplicate /api path while forming the endpoint url
base_url = f"{op_ctx.client.get_api_uri().strip('/api')}" \
f"{request_data['url']}"
return server_utils.create_links_and_construct_paginated_result(
base_url,
result,
vcd_clusters_info[PaginationKey.RESULT_TOTAL],
page_number=page_number,
page_size=page_size,
query_params=query_params_others)
def ovdc_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc list operation.
:return: List of dictionaries with org VDC k8s provider metadata.
"""
# NOTE: Response sent out by this function should not be
# paginated
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
# Record telemetry data
cse_params = copy.deepcopy(data)
record_user_action_details(cse_operation=CseOperation.OVDC_LIST,
cse_params=cse_params)
org_vdcs = vcd_utils.get_all_ovdcs(op_ctx.client)
return _get_cse_ovdc_list(op_ctx.sysadmin_client, org_vdcs)
def cluster_info(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster info operation.
Required data: cluster_name
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: Dict
"""
_raise_error_if_pks_not_enabled()
data = req_utils.flatten_request_data(request_data,
[RequestKey.QUERY_PARAMS])
cluster, _ = _get_cluster_info(data, op_ctx) # noqa: E501
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.PKS_CLUSTER_INFO,
cse_params=_get_telemetry_data(data, cluster))
return cluster
def cluster_resize(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
Required data: cluster_name, num_nodes
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: Dict
"""
_raise_error_if_pks_not_enabled()
data = req_utils.flatten_request_data(request_data,
[RequestKey.INPUT_SPEC])
cluster, broker = _get_cluster_info(data, op_ctx,
telemetry=False) # noqa: E501
# Record telemetry data
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.PKS_CLUSTER_RESIZE,
cse_params=_get_telemetry_data(data, cluster))
return broker.resize_cluster(data=data)
def system_update(request_data, op_ctx: ctx.OperationContext):
"""Request handler for system update operation.
:return: Dictionary with system update status.
"""
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
required = [
RequestKey.SERVER_ACTION
]
req_utils.validate_payload(data, required)
# Telemetry data preparation
server_action = data.get(RequestKey.SERVER_ACTION)
cse_operation = server_action or 'invalid server action'
if server_action == 'enable':
cse_operation = CseOperation.SYSTEM_ENABLE
elif server_action == 'disable':
cse_operation = CseOperation.SYSTEM_DISABLE
elif server_action == 'stop':
cse_operation = CseOperation.SYSTEM_STOP
status = OperationStatus.FAILED
if op_ctx.client.is_sysadmin:
# circular dependency between request_processor.py and service.py
import container_service_extension.server.service as service
try:
result = service.Service().update_status(
data.get(RequestKey.SERVER_ACTION))
status = OperationStatus.SUCCESS
return result
finally:
record_user_action(cse_operation=cse_operation, status=status)
record_user_action(cse_operation=cse_operation, status=status)
raise e.UnauthorizedRequestError(
error_message='Unauthorized to update CSE')
def cluster_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
All brokers in the org do 'list cluster' operation.
Post-process the result returned by the broker.
Aggregate all the results into a list.
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: List
"""
_raise_error_if_pks_not_enabled()
data = req_utils.flatten_request_data(request_data,
[RequestKey.QUERY_PARAMS])
cse_params = copy.deepcopy(data)
cse_params[PayloadKey.
SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.PKS_CLUSTER_LIST, cse_params=cse_params)
pks_clusters_info = pks_broker_manager.list_clusters(data, op_ctx)
common_cluster_properties = [
'name', 'vdc', 'status', 'org_name', 'k8s_version', K8S_PROVIDER_KEY
]
result = []
for info in pks_clusters_info:
filtered_cluster_info = \
{k: info.get(k) for k in common_cluster_properties}
result.append(filtered_cluster_info)
return result
def ovdc_compute_policy_update(
request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc compute-policy update operation.
Required data: ovdc_id, compute_policy_action, compute_policy_names
:return: Dictionary with task href.
"""
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
required = [
RequestKey.OVDC_ID,
RequestKey.COMPUTE_POLICY_ACTION,
RequestKey.COMPUTE_POLICY_NAME
]
defaults = {
RequestKey.REMOVE_COMPUTE_POLICY_FROM_VMS: False,
}
validated_data = {**defaults, **data}
req_utils.validate_payload(validated_data, required)
action = validated_data[RequestKey.COMPUTE_POLICY_ACTION]
cp_name = validated_data[RequestKey.COMPUTE_POLICY_NAME]
ovdc_id = validated_data[RequestKey.OVDC_ID]
remove_compute_policy_from_vms = validated_data[RequestKey.REMOVE_COMPUTE_POLICY_FROM_VMS] # noqa: E501
try:
config = server_utils.get_server_runtime_config()
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
cpm = compute_policy_manager.ComputePolicyManager(
sysadmin_client_v33,
log_wire=utils.str_to_bool(config.get_value_at('service.log_wire'))) # noqa: E501
cp_href = None
cp_id = None
if cp_name == SYSTEM_DEFAULT_COMPUTE_POLICY_NAME:
for _cp in cpm.list_compute_policies_on_vdc(ovdc_id):
if _cp['name'] == cp_name:
cp_href = _cp['href']
cp_id = _cp['id']
else:
try:
_cp = compute_policy_manager.get_cse_vdc_compute_policy(cpm, cp_name) # noqa: E501
cp_href = _cp['href']
cp_id = _cp['id']
except vcd_e.EntityNotFoundException:
pass
if cp_href is None:
raise e.BadRequestError(f"Compute policy '{cp_name}' not found.")
if action == ComputePolicyAction.ADD:
cpm.add_compute_policy_to_vdc(ovdc_id, cp_href)
# Record telemetry data
record_user_action(CseOperation.OVDC_COMPUTE_POLICY_ADD)
return f"Added compute policy '{cp_name}' ({cp_id}) to ovdc " \
f"({ovdc_id})"
if action == ComputePolicyAction.REMOVE:
# TODO: fix remove_compute_policy by implementing a proper way
# for calling async methods without having to pass op_ctx
# outside handlers.
op_ctx.is_async = True
response = cpm.remove_vdc_compute_policy_from_vdc(
ovdc_id,
cp_href,
force=remove_compute_policy_from_vms)
# Follow task_href to completion in a different thread and end
# operation context
_follow_task(op_ctx, response['task_href'], ovdc_id)
# Record telemetry data
record_user_action(CseOperation.OVDC_COMPUTE_POLICY_REMOVE)
return response
raise e.BadRequestError("Unsupported compute policy action")
except Exception as err:
# Record telemetry data failure`
if action == ComputePolicyAction.ADD:
record_user_action(CseOperation.OVDC_COMPUTE_POLICY_ADD,
status=OperationStatus.FAILED)
elif action == ComputePolicyAction.REMOVE:
record_user_action(CseOperation.OVDC_COMPUTE_POLICY_REMOVE,
status=OperationStatus.FAILED)
raise err
def ovdc_update(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc enable, disable operations.
Required data: org_name, ovdc_name, k8s_provider
Conditional data:
if k8s_provider is 'ent-pks': pks_plan_name, pks_cluster_domain
:return: Dictionary with org VDC update task href.
"""
# TODO the data flow here should be better understood.
# org_name and ovdc_name seem redundant if we already have ovdc_id
data = req_utils.flatten_request_data(
request_data, [RequestKey.INPUT_SPEC])
required = [
RequestKey.ORG_NAME,
RequestKey.OVDC_NAME,
RequestKey.K8S_PROVIDER,
RequestKey.OVDC_ID
]
validated_data = data
req_utils.validate_payload(validated_data, required)
k8s_provider = validated_data[RequestKey.K8S_PROVIDER]
k8s_provider_info = {K8S_PROVIDER_KEY: k8s_provider}
# Record the telemetry data
cse_params = copy.deepcopy(validated_data)
cse_params[PayloadKey.SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(ThreadLocalData.USER_AGENT) # noqa: E501
cse_operation = CseOperation.OVDC_DISABLE if k8s_provider == K8sProvider.NONE else CseOperation.OVDC_ENABLE # noqa: E501
record_user_action_details(cse_operation=cse_operation, cse_params=cse_params) # noqa: E501
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
try:
if k8s_provider == K8sProvider.PKS:
if not server_utils.is_pks_enabled():
raise e.CseServerError('CSE server is not '
'configured to work with PKS.')
required = [
RequestKey.PKS_PLAN_NAME,
RequestKey.PKS_CLUSTER_DOMAIN
]
req_utils.validate_payload(validated_data, required)
# Check if target ovdc is not already enabled for other non PKS k8 providers # noqa: E501
ovdc_metadata = ovdc_utils.get_ovdc_k8s_provider_metadata(
sysadmin_client_v33,
ovdc_id=validated_data[RequestKey.OVDC_ID])
ovdc_k8_provider = ovdc_metadata.get(K8S_PROVIDER_KEY)
if ovdc_k8_provider != K8sProvider.NONE and \
ovdc_k8_provider != k8s_provider:
raise e.CseServerError("Ovdc already enabled for different K8 provider") # noqa: E501
k8s_provider_info = ovdc_utils.construct_k8s_metadata_from_pks_cache( # noqa: E501
sysadmin_client_v33,
ovdc_id=validated_data[RequestKey.OVDC_ID],
org_name=validated_data[RequestKey.ORG_NAME],
pks_plans=validated_data[RequestKey.PKS_PLAN_NAME],
pks_cluster_domain=validated_data[RequestKey.PKS_CLUSTER_DOMAIN], # noqa: E501
k8s_provider=k8s_provider)
ovdc_utils.create_pks_compute_profile(validated_data,
op_ctx,
k8s_provider_info)
task = ovdc_utils.update_ovdc_k8s_provider_metadata(
sysadmin_client_v33,
validated_data[RequestKey.OVDC_ID],
k8s_provider_data=k8s_provider_info,
k8s_provider=k8s_provider)
# Telemetry - Record successful enabling/disabling of ovdc
record_user_action(cse_operation, status=OperationStatus.SUCCESS)
return {'task_href': task.get('href')}
except Exception as err:
logger.SERVER_LOGGER.error(f"Error while updating OVDC: {str(err)}")
# Telemetry - Record failed enabling/disabling of ovdc
record_user_action(cse_operation, status=OperationStatus.FAILED)
raise err
def ovdc_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc list operation.
:return: List of dictionaries with org VDC k8s provider metadata.
:rtype: list
"""
# NOTE: response sent out by this handler should not be paginated
data = req_utils.flatten_request_data(
request_data, [RequestKey.QUERY_PARAMS])
defaults = {
RequestKey.LIST_PKS_PLANS: False,
}
validated_data = {**defaults, **data}
list_pks_plans = utils.str_to_bool(validated_data[RequestKey.LIST_PKS_PLANS]) # noqa: E501
# Record telemetry data
cse_params = copy.deepcopy(validated_data)
cse_params[RequestKey.LIST_PKS_PLANS] = list_pks_plans
cse_params[PayloadKey.SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(ThreadLocalData.USER_AGENT) # noqa: E501
record_user_action_details(cse_operation=CseOperation.OVDC_LIST,
cse_params=cse_params)
client_v33 = op_ctx.get_client(api_version=DEFAULT_API_VERSION)
if list_pks_plans and not client_v33.is_sysadmin():
raise e.UnauthorizedRequestError(
'Operation denied. Enterprise PKS plans visible only '
'to System Administrators.')
ovdcs = []
org_vdcs = vcd_utils.get_all_ovdcs(client_v33)
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
for ovdc in org_vdcs:
ovdc_name = ovdc.get('name')
org_name = ovdc.get('orgName')
ovdc_id = vcd_utils.extract_id(ovdc.get('id'))
k8s_metadata = ovdc_utils.get_ovdc_k8s_provider_metadata(
sysadmin_client_v33,
ovdc_id=ovdc_id,
ovdc_name=ovdc_name,
org_name=org_name)
k8s_provider = k8s_metadata[K8S_PROVIDER_KEY]
ovdc_dict = {
OvdcInfoKey.OVDC_NAME: ovdc_name,
OvdcInfoKey.ORG_NAME: org_name,
OvdcInfoKey.K8S_PROVIDER: k8s_provider
}
if list_pks_plans:
pks_plans = ''
pks_server = ''
if k8s_provider == K8sProvider.PKS:
# vc name for vdc can only be found using typed query
qfilter = f"name=={urllib.parse.quote(ovdc_name)};" \
f"orgName=={urllib.parse.quote(org_name)}"
q = client_v33.get_typed_query(
vcd_client.ResourceType.ADMIN_ORG_VDC.value,
query_result_format=vcd_client.QueryResultFormat.RECORDS, # noqa: E501
qfilter=qfilter)
# should only ever be one element in the generator
ovdc_records = list(q.execute())
if len(ovdc_records) == 0:
raise vcd_e.EntityNotFoundException(
f"Org VDC {ovdc_name} not found in org {org_name}")
ovdc_record = None
for record in ovdc_records:
ovdc_record = pyvcd_utils.to_dict(
record, resource_type=vcd_client.ResourceType.ADMIN_ORG_VDC.value) # noqa: E501
break
vc_to_pks_plans_map = {}
pks_contexts = pksbroker_manager.create_pks_context_for_all_accounts_in_org(op_ctx) # noqa: E501
for pks_context in pks_contexts:
if pks_context['vc'] in vc_to_pks_plans_map:
continue
pks_broker = pksbroker.PksBroker(pks_context, op_ctx)
plans = pks_broker.list_plans()
plan_names = [plan.get('name') for plan in plans]
vc_to_pks_plans_map[pks_context['vc']] = \
[plan_names, pks_context['host']]
pks_plan_and_server_info = vc_to_pks_plans_map.get(
ovdc_record['vcName'], [])
if len(pks_plan_and_server_info) > 0:
pks_plans = pks_plan_and_server_info[0]
pks_server = pks_plan_and_server_info[1]
ovdc_dict[PKSOvdcInfoKey.PKS_API_SERVER] = pks_server
ovdc_dict[PKSOvdcInfoKey.AVAILABLE_PKS_PLANS] = pks_plans
ovdcs.append(ovdc_dict)
return ovdcs
def org_vdc_list(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc list operation.
:return: dictionary containing list of Org VDCs
:rtype: dict
"""
# NOTE: Response sent out by this handler should be paginated
data = req_utils.flatten_request_data(request_data,
[RequestKey.QUERY_PARAMS])
defaults = {
RequestKey.LIST_PKS_PLANS: False,
PaginationKey.PAGE_NUMBER: CSE_PAGINATION_FIRST_PAGE_NUMBER,
PaginationKey.PAGE_SIZE: CSE_PAGINATION_DEFAULT_PAGE_SIZE
}
validated_data = {**defaults, **data}
page_number = int(validated_data[PaginationKey.PAGE_NUMBER])
page_size = int(validated_data[PaginationKey.PAGE_SIZE])
list_pks_plans = utils.str_to_bool(
validated_data[RequestKey.LIST_PKS_PLANS]) # noqa: E501
# Record telemetry data
# TODO: enhance telemetry to record the page number and page size data.
cse_params = copy.deepcopy(validated_data)
cse_params[RequestKey.LIST_PKS_PLANS] = list_pks_plans
cse_params[PayloadKey.
SOURCE_DESCRIPTION] = thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
record_user_action_details(cse_operation=CseOperation.OVDC_LIST,
cse_params=cse_params)
if list_pks_plans and not op_ctx.client.is_sysadmin():
raise e.UnauthorizedRequestError(
'Operation denied. Enterprise PKS plans visible only '
'to System Administrators.')
ovdcs = []
result = \
vcd_utils.get_ovdcs_by_page(op_ctx.client,
page=page_number,
page_size=page_size)
org_vdcs = result[PaginationKey.VALUES]
result_total = result[PaginationKey.RESULT_TOTAL]
next_page_uri = result.get(PaginationKey.NEXT_PAGE_URI)
prev_page_uri = result.get(PaginationKey.PREV_PAGE_URI)
for ovdc in org_vdcs:
ovdc_name = ovdc.get('name')
org_name = ovdc.get('orgName')
ovdc_id = vcd_utils.extract_id(ovdc.get('id'))
k8s_metadata = ovdc_utils.get_ovdc_k8s_provider_metadata(
op_ctx.sysadmin_client,
ovdc_id=ovdc_id,
ovdc_name=ovdc_name,
org_name=org_name)
k8s_provider = k8s_metadata[K8S_PROVIDER_KEY]
ovdc_dict = {
OvdcInfoKey.OVDC_NAME: ovdc_name,
OvdcInfoKey.ORG_NAME: org_name,
OvdcInfoKey.K8S_PROVIDER: k8s_provider
}
if list_pks_plans:
pks_plans = ''
pks_server = ''
if k8s_provider == K8sProvider.PKS:
# vc name for vdc can only be found using typed query
qfilter = f"name=={urllib.parse.quote(ovdc_name)};" \
f"orgName=={urllib.parse.quote(org_name)}"
q = op_ctx.client.get_typed_query(
vcd_client.ResourceType.ADMIN_ORG_VDC.value,
query_result_format=vcd_client.QueryResultFormat.
RECORDS, # noqa: E501
qfilter=qfilter)
# should only ever be one element in the generator
ovdc_records = list(q.execute())
if len(ovdc_records) == 0:
raise vcd_e.EntityNotFoundException(
f"Org VDC {ovdc_name} not found in org {org_name}")
ovdc_record = None
for record in ovdc_records:
ovdc_record = pyvcd_utils.to_dict(
record,
resource_type=vcd_client.ResourceType.ADMIN_ORG_VDC.
value) # noqa: E501
break
vc_to_pks_plans_map = {}
pks_contexts = pksbroker_manager.create_pks_context_for_all_accounts_in_org(
op_ctx) # noqa: E501
for pks_context in pks_contexts:
if pks_context['vc'] in vc_to_pks_plans_map:
continue
pks_broker = pksbroker.PksBroker(pks_context, op_ctx)
plans = pks_broker.list_plans()
plan_names = [plan.get('name') for plan in plans]
vc_to_pks_plans_map[pks_context['vc']] = \
[plan_names, pks_context['host']]
pks_plan_and_server_info = vc_to_pks_plans_map.get(
ovdc_record['vcName'], [])
if len(pks_plan_and_server_info) > 0:
pks_plans = pks_plan_and_server_info[0]
pks_server = pks_plan_and_server_info[1]
ovdc_dict[PKSOvdcInfoKey.PKS_API_SERVER] = pks_server
ovdc_dict[PKSOvdcInfoKey.AVAILABLE_PKS_PLANS] = pks_plans
ovdcs.append(ovdc_dict)
api_path = CseServerOperationInfo.PKS_ORG_VDC_LIST.api_path_format
next_page_uri = vcd_utils.create_cse_page_uri(op_ctx.client,
api_path,
vcd_uri=next_page_uri)
prev_page_uri = vcd_utils.create_cse_page_uri(op_ctx.client,
api_path,
vcd_uri=prev_page_uri)
return server_utils.construct_paginated_response(
values=ovdcs,
result_total=result_total,
page_number=page_number,
page_size=page_size,
next_page_uri=next_page_uri, # noqa: E501
prev_page_uri=prev_page_uri) # noqa: E501
