def nfs_node_delete(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
"""
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
cluster_id = data[RequestKey.CLUSTER_ID]
node_name = data[RequestKey.NODE_NAME]
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_NODE_DELETE,
cse_params={
telemetry_constants.PayloadKey.CLUSTER_ID:
cluster_id,
telemetry_constants.PayloadKey.NODE_NAME:
node_name,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
server_constants.ThreadLocalData.USER_AGENT) # noqa: E501
})
return svc.delete_nodes(cluster_id, [node_name]).to_dict()
def cluster_delete(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster delete operation.
Required data: cluster_name
Optional data and default values: org_name=None, ovdc_name=None
(data validation handled in broker)
:return: Dict
"""
cluster_id = data[RequestKey.CLUSTER_ID]
def_entity_service = entity_service.DefEntityService(
op_ctx.cloudapi_client) # noqa: E501
def_entity: common_models.DefEntity = def_entity_service.get_entity(
cluster_id) # noqa: E501
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_CLUSTER_DELETE,
cse_params={
server_constants.CLUSTER_ENTITY:
def_entity,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
_, task_href = def_entity_service.delete_entity(
cluster_id, invoke_hooks=True, is_request_async=True) # noqa: E501
def_entity.entity.status.task_href = task_href
return def_entity.to_dict()
def cluster_config(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster config operation.
Required data: cluster_id
:return: Dict
"""
cluster_id = data[RequestKey.CLUSTER_ID]
def_entity_service = entity_service.DefEntityService(
op_ctx.cloudapi_client) # noqa: E501
def_entity: common_models.DefEntity = def_entity_service.get_entity(
cluster_id) # noqa: E501
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_CLUSTER_CONFIG,
cse_params={
server_constants.CLUSTER_ENTITY:
def_entity,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
op_ctx.entity_id = cluster_id # hack for passing entity id
svc = cluster_service_factory.ClusterServiceFactory(
_get_request_context(op_ctx)).get_cluster_service() # noqa: E501
config_dict = svc.get_cluster_config(cluster_id)
config: str = config_dict.get(
server_constants.BEHAVIOR_TASK_RESPONSE_RESULT_MESSAGE_KEY, {}).get(
server_constants.BEHAVIOR_TASK_RESPONSE_RESULT_CONTENT_MESSAGE_KEY
) # noqa: E501
return_dict = {"message": config}
return return_dict
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()
cse_params = copy.deepcopy(request_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(request_data, op_ctx)
common_cluster_properties = [
'name', 'vdc', 'status', 'org_name', 'k8s_version', K8S_PROVIDER_KEY
]
result = []
for cluster_info in pks_clusters_info:
filtered_cluster_info = \
{k: cluster_info.get(k) for k in common_cluster_properties}
result.append(filtered_cluster_info)
return result
def nfs_node_delete(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
"""
cluster_id = data[RequestKey.CLUSTER_ID]
node_name = data[RequestKey.NODE_NAME]
behavior_svc = BehaviorService(cloudapi_client=op_ctx.cloudapi_client)
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_NODE_DELETE,
cse_params={
telemetry_constants.PayloadKey.CLUSTER_ID:
cluster_id,
telemetry_constants.PayloadKey.NODE_NAME:
node_name,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
server_constants.ThreadLocalData.USER_AGENT) # noqa: E501
})
delete_nfs_node_task = behavior_svc.invoke_behavior(
entity_id=cluster_id,
behavior_interface_id=DELETE_NFS_NODE_BEHAVIOR_ID,
arguments={RequestKey.NODE_NAME.value: node_name})
def_entity_service = entity_service.DefEntityService(
op_ctx.cloudapi_client) # noqa: E501
cluster_def_entity: common_models.DefEntity = def_entity_service.get_entity(
cluster_id) # noqa: E501
cluster_def_entity.entity.status.task_href = delete_nfs_node_task
return cluster_def_entity.to_dict()
def get_ovdc(operation_context: ctx.OperationContext, ovdc_id: str) -> dict:
"""Get ovdc info for a particular ovdc.
:param ctx.OperationContext operation_context: context for the request
:param str ovdc_id: ID of the ovdc
:return: dictionary containing the ovdc information
:rtype: dict
"""
# NOTE: For CSE 3.0, if `enable_tkg_plus` flag in config is set to false,
# Prevent showing information about TKG+ by skipping TKG+ from the result.
cse_params = {
RequestKey.OVDC_ID:
ovdc_id,
PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
}
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.OVDC_INFO, # noqa: E501
cse_params=cse_params)
config = server_utils.get_server_runtime_config()
log_wire = utils.str_to_bool(config.get('service', {}).get('log_wire'))
result = asdict(
get_ovdc_k8s_runtime_details(
operation_context.sysadmin_client, # noqa: E501
ovdc_id=ovdc_id,
log_wire=log_wire))
# TODO: Find a better way to avoid sending remove_cp_from_vms_on_disable
# flag
if ClusterEntityKind.TKG_PLUS.value in result['k8s_runtime'] \
and not server_utils.is_tkg_plus_enabled():
result['k8s_runtime'].remove(ClusterEntityKind.TKG_PLUS.value)
del result['remove_cp_from_vms_on_disable']
return result
def list_org_vdcs(operation_context: ctx.OperationContext,
page_number=CSE_PAGINATION_FIRST_PAGE_NUMBER,
page_size=CSE_PAGINATION_DEFAULT_PAGE_SIZE) -> dict:
"""Fetch org VDCs and their k8s runtimes.
:param ctx.OperationContext operation_context: context for the request
:param int page_number: page_number to fetch
:param int page_size: size of each page to return
:return: dictionary containing list of details about the ovdc
:rtype: dict
"""
# NOTE: The response sent out by this function needs to be
# paginated
# Record telemetry
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.OVDC_LIST,
cse_params={
PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
result = cloudapi_utils.get_vdcs_by_page(operation_context.cloudapi_client,
page_number=page_number,
page_size=page_size)
num_results = result[PaginationKey.RESULT_TOTAL]
ovdcs = _get_cse_ovdc_list(operation_context.sysadmin_client,
result[PaginationKey.VALUES])
return {
PaginationKey.RESULT_TOTAL: num_results,
PaginationKey.VALUES: ovdcs
}
def cluster_create(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster create operation.
:return: Defined entity of the native cluster
:rtype: container_service_extension.def_.models.DefEntity
"""
input_entity: dict = data[RequestKey.INPUT_SPEC]
payload_version = input_entity.get(
rde_constants.PayloadKey.PAYLOAD_VERSION) # noqa: E501
rde_utils.raise_error_if_unsupported_payload_version(payload_version)
# Validate the Input payload based on the (Operation, payload_version).
# Get the validator based on the payload_version
# ToDo : Don't use default cloudapi_client. Use the specific versioned one
rde_validator_factory.get_validator(
rde_version=rde_constants.
MAP_INPUT_PAYLOAD_VERSION_TO_RDE_VERSION[payload_version]).validate(
cloudapi_client=op_ctx.cloudapi_client,
sysadmin_client=op_ctx.sysadmin_client,
entity=input_entity)
def_entity_service = entity_service.DefEntityService(
op_ctx.cloudapi_client) # noqa: E501
entity_type = server_utils.get_registered_def_entity_type()
converted_entity: AbstractNativeEntity = rde_utils.convert_input_rde_to_runtime_rde_format(
input_entity) # noqa: E501
def_entity = common_models.DefEntity(
entity=converted_entity, entityType=entity_type.id) # noqa: E501
# No need to set org context for non sysadmin users
org_context = None
if op_ctx.client.is_sysadmin():
org_resource = pyvcloud_utils.get_org(
op_ctx.client,
org_name=converted_entity.metadata.org_name) # noqa: E501
org_context = org_resource.href.split('/')[-1]
_, task_href = def_entity_service.create_entity(
entity_type_id=entity_type.id,
entity=def_entity,
tenant_org_context=org_context,
is_request_async=True)
task_resource = op_ctx.sysadmin_client.get_resource(task_href)
entity_id = task_resource.Owner.get('id')
def_entity = def_entity_service.get_entity(entity_id)
def_entity.entity.status.task_href = task_href
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_CLUSTER_APPLY,
cse_params={
server_constants.CLUSTER_ENTITY:
def_entity,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
return def_entity.to_dict()
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_update(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
:return: Defined entity of the native cluster
:rtype: container_service_extension.def_.models.DefEntity
"""
cluster_id = data[RequestKey.CLUSTER_ID]
input_entity: dict = data[RequestKey.INPUT_SPEC]
payload_version = input_entity.get(
rde_constants.PayloadKey.PAYLOAD_VERSION) # noqa: E501
rde_utils.raise_error_if_unsupported_payload_version(payload_version)
# Validate the Input payload based on the (Operation, payload_version).
# Get the validator based on the payload_version
# ToDo : Don't use default cloudapi_client. Use the specific versioned one
kind = input_entity['kind']
is_tkgm_cluster = (kind == ClusterEntityKind.TKG_M.value)
sysadmin_client = op_ctx.sysadmin_client
rde_validator_factory.get_validator(
rde_version=rde_constants.MAP_INPUT_PAYLOAD_VERSION_TO_RDE_VERSION[
payload_version]). \
validate(cloudapi_client=op_ctx.cloudapi_client,
sysadmin_client=sysadmin_client, entity_id=cluster_id,
entity=input_entity,
operation=BehaviorOperation.UPDATE_CLUSTER,
is_tkgm_cluster=is_tkgm_cluster)
# Convert the input entity to runtime rde format.
# Based on the runtime rde, call the appropriate backend method.
def_entity_service = entity_service.DefEntityService(
op_ctx.cloudapi_client) # noqa: E501
converted_native_entity: AbstractNativeEntity = rde_utils.convert_input_rde_to_runtime_rde_format(
input_entity) # noqa: E501
changes = {'entity.spec': converted_native_entity.spec}
updated_def_entity, task_href = def_entity_service.update_entity(
entity_id=cluster_id,
invoke_hooks=True,
is_request_async=True,
changes=changes)
updated_def_entity.entity.status.task_href = task_href
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V36_CLUSTER_APPLY,
cse_params={
server_constants.CLUSTER_ENTITY:
updated_def_entity,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
# TODO: Response RDE must be compatible with the request RDE.
# Conversions may be needed especially if there is a major version
# difference in the input RDE and runtime RDE.
return updated_def_entity.to_dict()
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
# Record telemetry data
cse_params = copy.deepcopy(request_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 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 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()
cluster, _ = _get_cluster_info(request_data, op_ctx) # noqa: E501
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.PKS_CLUSTER_INFO,
cse_params=_get_telemetry_data(request_data, cluster))
return cluster
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 nfs_node_delete(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
"""
rde_in_use = server_utils.get_rde_version_in_use()
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
cluster_dict = cluster_handler.nfs_node_delete(
data=data, op_ctx=op_ctx) # noqa: E501
# NOTE: cluster_handler is always expected to return RDE version
# 2.0.0 or more. Hence a convertion to 1.0 is needed
rde_class = rde_factory.get_rde_model(rde_in_use)
cluster_entity: AbstractNativeEntity = rde_class.from_dict(
cluster_dict['entity']) # noqa: E501
new_native_entity: AbstractNativeEntity = rde_utils.convert_runtime_rde_to_input_rde_version_format( # noqa: E501
cluster_entity, rde_constants.RDEVersion.RDE_1_0_0)
cluster_dict['entity'] = new_native_entity.to_dict()
cluster_dict[
'entityType'] = common_models.EntityType.NATIVE_ENTITY_TYPE_1_0_0.value.id # noqa: E501
return cluster_dict
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
cluster_id = data[RequestKey.CLUSTER_ID]
node_name = data[RequestKey.NODE_NAME]
telemetry_handler.record_user_action_details(
cse_operation=telemetry_constants.CseOperation.V35_NODE_DELETE,
cse_params={
telemetry_constants.PayloadKey.CLUSTER_ID:
cluster_id,
telemetry_constants.PayloadKey.NODE_NAME:
node_name,
telemetry_constants.PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
return svc.delete_nodes(cluster_id, [node_name]).to_dict()
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()
cluster, broker = _get_cluster_info(request_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(request_data, cluster))
return broker.resize_cluster(data=request_data)
def ovdc_info(request_data, op_ctx: ctx.OperationContext):
"""Request handler for ovdc info operation.
Required data: org_name, ovdc_name
:return: Dictionary with org VDC k8s provider metadata.
"""
required = [RequestKey.OVDC_ID]
req_utils.validate_payload(request_data, required)
# Record telemetry data
cse_params = copy.deepcopy(request_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_INFO,
cse_params=cse_params)
return ovdc_utils.get_ovdc_k8s_provider_metadata(
op_ctx.sysadmin_client, ovdc_id=request_data[RequestKey.OVDC_ID])
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)
client_v33 = op_ctx.get_client(api_version=DEFAULT_API_VERSION)
sysadmin_client_v33 = \
op_ctx.get_sysadmin_client(api_version=DEFAULT_API_VERSION)
org_vdcs = vcd_utils.get_all_ovdcs(client_v33)
return _get_cse_ovdc_list(sysadmin_client_v33, org_vdcs)
def list_ovdc(operation_context: ctx.OperationContext) -> list:
"""List all ovdc and their k8s runtimes.
:param ctx.OperationContext operation_context: context for the request
:return: list of org vdcs
:rtype: list
"""
# NOTE: Response sent out by this function should not be
# paginated. The purpose of this handler is to maintain
# backward compatibility
# TODO: Deprecate handler once support for CSE 3.0 is removed
# Record telemetry
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.OVDC_LIST,
cse_params={
PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
})
# send un-paginated response
org_vdcs = vcd_utils.get_all_ovdcs(operation_context.client)
return _get_cse_ovdc_list(operation_context.sysadmin_client, org_vdcs)
def run(self, msg_update_callback=utils.NullPrinter()):
sysadmin_client = None
try:
sysadmin_client = vcd_utils.get_sys_admin_client(api_version=None)
verify_version_compatibility(
sysadmin_client,
should_cse_run_in_legacy_mode=self.config['service']
['legacy_mode'], # noqa: E501
is_mqtt_extension=server_utils.should_use_mqtt_protocol(
self.config)) # noqa: E501
except Exception as err:
logger.SERVER_LOGGER.info(err)
raise
finally:
if sysadmin_client:
sysadmin_client.logout()
if server_utils.should_use_mqtt_protocol(self.config):
# Store/setup MQTT extension, api filter, and token info
try:
sysadmin_client = \
vcd_utils.get_sys_admin_client(api_version=None)
mqtt_ext_manager = MQTTExtensionManager(sysadmin_client)
ext_info = mqtt_ext_manager.get_extension_info(
ext_name=server_constants.CSE_SERVICE_NAME,
ext_version=server_constants.MQTT_EXTENSION_VERSION,
ext_vendor=server_constants.MQTT_EXTENSION_VENDOR)
ext_urn_id = ext_info[server_constants.MQTTExtKey.EXT_URN_ID]
ext_uuid = mqtt_ext_manager.get_extension_uuid(ext_urn_id)
api_filters_status = mqtt_ext_manager.check_api_filters_setup(
ext_uuid, configure_cse.API_FILTER_PATTERNS)
if not api_filters_status:
msg = 'MQTT Api filter is not set up'
logger.SERVER_LOGGER.error(msg)
raise cse_exception.MQTTExtensionError(msg)
token_info = mqtt_ext_manager.setup_extension_token(
token_name=server_constants.MQTT_TOKEN_NAME,
ext_name=server_constants.CSE_SERVICE_NAME,
ext_version=server_constants.MQTT_EXTENSION_VERSION,
ext_vendor=server_constants.MQTT_EXTENSION_VENDOR,
ext_urn_id=ext_urn_id)
self.config['mqtt'].update(ext_info)
self.config['mqtt'].update(token_info)
self.config['mqtt'][server_constants.MQTTExtKey.EXT_UUID] = \
ext_uuid
except Exception as err:
msg = f'MQTT extension setup error: {err}'
logger.SERVER_LOGGER.error(msg)
raise err
finally:
if sysadmin_client:
sysadmin_client.logout()
populate_vsphere_list(self.config['vcs'])
# Load def entity-type and interface
self._load_def_schema(msg_update_callback=msg_update_callback)
# Read k8s catalog definition from catalog item metadata and append
# the same to to server run-time config
self._load_template_definition_from_catalog(
msg_update_callback=msg_update_callback)
self._load_placement_policy_details(
msg_update_callback=msg_update_callback)
if self.config['service']['legacy_mode']:
# Read templates rules from config and update template definition
# in server run-time config
self._process_template_rules(
msg_update_callback=msg_update_callback)
# Make sure that all vms in templates are compliant with the
# compute policy specified in template definition (can be affected
# by rules).
self._process_template_compute_policy_compliance(
msg_update_callback=msg_update_callback)
else:
msg = "Template rules are not supported by CSE for vCD api " \
"version 35.0 or above. Skipping template rule processing."
msg_update_callback.info(msg)
logger.SERVER_LOGGER.debug(msg)
if self.should_check_config:
configure_cse.check_cse_installation(
self.config, msg_update_callback=msg_update_callback)
if self.config.get('pks_config'):
pks_config = self.config.get('pks_config')
self.pks_cache = PksCache(
pks_servers=pks_config.get('pks_api_servers', []),
pks_accounts=pks_config.get('pks_accounts', []),
pvdcs=pks_config.get('pvdcs', []),
orgs=pks_config.get('orgs', []),
nsxt_servers=pks_config.get('nsxt_servers', []))
num_processors = self.config['service']['processors']
name = server_constants.MESSAGE_CONSUMER_THREAD
try:
self.consumer = MessageConsumer(self.config, num_processors)
consumer_thread = Thread(name=name,
target=consumer_thread_run,
args=(self.consumer, ))
consumer_thread.daemon = True
consumer_thread.start()
self.consumer_thread = consumer_thread
msg = f"Started thread '{name}' ({consumer_thread.ident})"
msg_update_callback.general(msg)
logger.SERVER_LOGGER.info(msg)
except KeyboardInterrupt:
if self.consumer:
self.consumer.stop()
interrupt_msg = f"\nKeyboard interrupt when starting thread " \
f"'{name}'"
logger.SERVER_LOGGER.debug(interrupt_msg)
raise Exception(interrupt_msg)
except Exception:
if self.consumer:
self.consumer.stop()
logger.SERVER_LOGGER.error(traceback.format_exc())
# Updating state to Running before starting watchdog because watchdog
# exits when server is not Running
self._state = ServerState.RUNNING
# Start consumer watchdog
name = server_constants.WATCHDOG_THREAD
consumer_watchdog = Thread(name=name,
target=watchdog_thread_run,
args=(self, num_processors))
consumer_watchdog.daemon = True
consumer_watchdog.start()
self._consumer_watchdog = consumer_watchdog
msg = f"Started thread '{name}' ({consumer_watchdog.ident})"
msg_update_callback.general(msg)
logger.SERVER_LOGGER.info(msg)
message = f"Container Service Extension for vCloud Director" \
f"\nServer running using config file: {self.config_file}" \
f"\nLog files: {logger.SERVER_INFO_LOG_FILEPATH}, " \
f"{logger.SERVER_DEBUG_LOG_FILEPATH}" \
f"\nwaiting for requests (ctrl+c to close)"
signal.signal(signal.SIGINT, signal_handler)
msg_update_callback.general_no_color(message)
logger.SERVER_LOGGER.info(message)
# Record telemetry on user action and details of operation.
cse_params = {
PayloadKey.WAS_DECRYPTION_SKIPPED:
bool(self.skip_config_decryption), # noqa: E501
PayloadKey.WAS_PKS_CONFIG_FILE_PROVIDED:
bool(self.pks_config_file), # noqa: E501
PayloadKey.WAS_INSTALLATION_CHECK_SKIPPED:
bool(self.should_check_config) # noqa: E501
}
record_user_action_details(cse_operation=CseOperation.SERVICE_RUN,
cse_params=cse_params)
record_user_action(cse_operation=CseOperation.SERVICE_RUN)
while True:
try:
time.sleep(1)
if self._state == ServerState.STOPPING and \
self.active_requests_count() == 0:
break
except KeyboardInterrupt:
break
except Exception:
msg_update_callback.general_no_color(traceback.format_exc())
logger.SERVER_LOGGER.error(traceback.format_exc())
sys.exit(1)
logger.SERVER_LOGGER.info("Stop detected")
logger.SERVER_LOGGER.info("Closing connections...")
self._state = ServerState.STOPPING
try:
self.consumer.stop()
except Exception:
logger.SERVER_LOGGER.error(traceback.format_exc())
self._state = ServerState.STOPPED
logger.SERVER_LOGGER.info("Done")
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
def _update_ovdc_using_placement_policy_async(
operation_context: ctx.OperationContext, # noqa: E501
task: vcd_task.Task,
task_href,
user_href,
policy_list,
ovdc_id,
vdc,
org_name,
remove_cp_from_vms_on_disable=False): # noqa: E501
"""Enable ovdc using placement policies.
:param ctx.OperationContext operation_context: operation context object
:param vcd_task.Task task: Task resource to track progress
:param str task_href: href of the task
:param str user_href:
:param List[str] policy_list: The new list of policies associated with
the ovdc
:param str ovdc_id:
:param pyvcloud.vcd.vdc.VDC vdc: VDC object
:param str org_name: name of the organization that vdc provides resource
:param bool remove_cp_from_vms_on_disable: Set to true if placement
policies need to be removed from the vms before removing from the VDC.
"""
operation_name = "Update OVDC with placement policies"
k8s_runtimes_added = ''
k8s_runtimes_deleted = ''
try:
config = server_utils.get_server_runtime_config()
log_wire = utils.str_to_bool(config.get('service', {}).get('log_wire'))
cpm = compute_policy_manager.ComputePolicyManager(
operation_context.sysadmin_client, log_wire=log_wire)
existing_policies = []
for cse_policy in \
compute_policy_manager.list_cse_placement_policies_on_vdc(cpm, ovdc_id): # noqa: E501
existing_policies.append(cse_policy['display_name'])
logger.SERVER_LOGGER.debug(policy_list)
logger.SERVER_LOGGER.debug(existing_policies)
policies_to_add = set(policy_list) - set(existing_policies)
policies_to_delete = set(existing_policies) - set(policy_list)
# Telemetry for 'vcd cse ovdc enable' command
# TODO: Update telemetry request to handle 'k8s_runtime' array
k8s_runtimes_added = ','.join(policies_to_add)
if k8s_runtimes_added:
cse_params = {
RequestKey.K8S_PROVIDER:
k8s_runtimes_added,
RequestKey.OVDC_ID:
ovdc_id,
RequestKey.ORG_NAME:
org_name,
PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
}
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.OVDC_ENABLE, # noqa: E501
cse_params=cse_params)
# Telemetry for 'vcd cse ovdc enable' command
# TODO: Update telemetry request to handle 'k8s_runtime' array
k8s_runtimes_deleted = '.'.join(policies_to_delete)
if k8s_runtimes_deleted:
cse_params = {
RequestKey.K8S_PROVIDER:
k8s_runtimes_deleted,
RequestKey.OVDC_ID:
ovdc_id,
RequestKey.ORG_NAME:
org_name,
RequestKey.REMOVE_COMPUTE_POLICY_FROM_VMS:
remove_cp_from_vms_on_disable, # noqa: E501
PayloadKey.SOURCE_DESCRIPTION:
thread_local_data.get_thread_local_data(
ThreadLocalData.USER_AGENT) # noqa: E501
}
telemetry_handler.record_user_action_details(
cse_operation=CseOperation.OVDC_DISABLE, # noqa: E501
cse_params=cse_params)
for cp_name in policies_to_add:
msg = f"Adding k8s provider {cp_name} to OVDC {vdc.name}"
logger.SERVER_LOGGER.debug(msg)
task.update(status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=msg,
operation_name=operation_name,
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=operation_context.user.name,
task_href=task_href,
org_href=operation_context.user.org_href)
policy = compute_policy_manager.get_cse_vdc_compute_policy(
cpm, cp_name, is_placement_policy=True)
cpm.add_compute_policy_to_vdc(vdc_id=ovdc_id,
compute_policy_href=policy['href'])
for cp_name in policies_to_delete:
msg = f"Removing k8s provider {RUNTIME_INTERNAL_NAME_TO_DISPLAY_NAME_MAP[cp_name]} from OVDC {ovdc_id}" # noqa: E501
logger.SERVER_LOGGER.debug(msg)
task_resource = \
task.update(status=vcd_client.TaskStatus.RUNNING.value,
namespace='vcloud.cse',
operation=msg,
operation_name=operation_name,
details='',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=operation_context.user.name,
task_href=task_href,
org_href=operation_context.user.org_href)
policy = compute_policy_manager.get_cse_vdc_compute_policy(
cpm, cp_name, is_placement_policy=True) # noqa: E501
cpm.remove_compute_policy_from_vdc_sync(
vdc=vdc,
compute_policy_href=policy['href'], # noqa: E501
force=remove_cp_from_vms_on_disable, # noqa: E501
is_placement_policy=True,
task_resource=task_resource) # noqa: E501
msg = f"Successfully updated OVDC: {vdc.name}"
logger.SERVER_LOGGER.debug(msg)
task.update(status=vcd_client.TaskStatus.SUCCESS.value,
namespace='vcloud.cse',
operation="Operation success",
operation_name=operation_name,
details=msg,
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=operation_context.user.name,
task_href=task_href,
org_href=operation_context.user.org_href)
# Record telemetry
if k8s_runtimes_added:
telemetry_handler.record_user_action(
CseOperation.OVDC_ENABLE,
status=OperationStatus.SUCCESS) # noqa: E501
if k8s_runtimes_deleted:
telemetry_handler.record_user_action(
CseOperation.OVDC_DISABLE,
status=OperationStatus.SUCCESS) # noqa: E501
except Exception as err:
# Record telemetry
if k8s_runtimes_added:
telemetry_handler.record_user_action(CseOperation.OVDC_ENABLE,
status=OperationStatus.FAILED)
if k8s_runtimes_deleted:
telemetry_handler.record_user_action(CseOperation.OVDC_DISABLE,
status=OperationStatus.FAILED)
logger.SERVER_LOGGER.error(err)
task.update(status=vcd_client.TaskStatus.ERROR.value,
namespace='vcloud.cse',
operation='Failed to update OVDC',
operation_name=operation_name,
details=f'Failed with error: {err}',
progress=None,
owner_href=vdc.href,
owner_name=vdc.name,
owner_type=vcd_client.EntityType.VDC.value,
user_href=user_href,
user_name=operation_context.user.name,
task_href=task_href,
org_href=operation_context.user.org_href,
error_message=f"{err}")
finally:
if operation_context.sysadmin_client:
operation_context.end()
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
