def get_ovdc_k8s_provider_metadata(org_name=None,
ovdc_name=None,
ovdc_id=None,
include_credentials=False,
include_nsxt_info=False):
"""Get k8s provider metadata for an org VDC.
:param str org_name:
:param str ovdc_name:
:param str ovdc_id:
:param bool include_credentials:
:param bool include_nsxt_info:
:return: Dictionary with k8s provider metadata
:rtype: Dict
"""
client = None
try:
client = vcd_utils.get_sys_admin_client()
ovdc = vcd_utils.get_vdc(client=client,
vdc_name=ovdc_name,
vdc_id=ovdc_id,
org_name=org_name,
is_admin_operation=True)
all_metadata = pyvcd_utils.metadata_to_dict(ovdc.get_all_metadata())
k8s_provider = all_metadata.get(K8S_PROVIDER_KEY, K8sProvider.NONE)
result = {K8S_PROVIDER_KEY: k8s_provider}
if k8s_provider == K8sProvider.PKS:
result.update(
{k: all_metadata[k]
for k in PksCache.get_pks_keys()}) # noqa: E501
result[PKS_PLANS_KEY] = result[PKS_PLANS_KEY].split(',')
# Get the credentials from PksCache
if include_credentials or include_nsxt_info:
pks_cache = utils.get_pks_cache()
pvdc_info = \
pks_cache.get_pvdc_info(vcd_utils.get_pvdc_id(ovdc))
if include_credentials:
# noqa: E501 TODO in case only ovdc_id is provided, we need a way to get org_name
pks_info = \
pks_cache.get_pks_account_info(org_name, pvdc_info.vc)
result.update(pks_info.credentials._asdict())
if include_nsxt_info:
nsxt_info = pks_cache.get_nsxt_info(pvdc_info.vc)
result['nsxt'] = nsxt_info
return result
finally:
if client is not None:
client.logout()
def construct_ctr_prov_ctx_from_pks_cache(ovdc_id, org_name, pks_plans,
pks_cluster_domain,
container_provider):
client = None
try:
ctr_prov_context = {}
ctr_prov_context[K8S_PROVIDER_KEY] = container_provider
if container_provider == K8sProviders.PKS:
if not is_pks_enabled():
raise CseServerError('CSE is not configured to work with PKS.')
client = get_sys_admin_client()
ovdc = get_vdc(client=client, vdc_id=ovdc_id,
is_admin_operation=True)
pks_cache = get_pks_cache()
pvdc_id = get_pvdc_id(ovdc)
pvdc_info = pks_cache.get_pvdc_info(pvdc_id)
if not pvdc_info:
LOGGER.debug(f"pvdc '{pvdc_id}' is not backed "
f"by PKS-managed-vSphere resources")
raise CseServerError(f"VDC '{ovdc.get_resource().get('name')}'"
" is not eligible to provide resources"
" for PKS clusters.")
pks_account_info = pks_cache.get_pks_account_info(
org_name, pvdc_info.vc)
nsxt_info = pks_cache.get_nsxt_info(pvdc_info.vc)
pks_compute_profile_name = \
_construct_pks_compute_profile_name(ovdc_id)
ctr_prov_context = construct_pks_context(
pks_account_info=pks_account_info,
pvdc_info=pvdc_info,
nsxt_info=nsxt_info,
pks_compute_profile_name=pks_compute_profile_name,
pks_plans=pks_plans,
pks_cluster_domain=pks_cluster_domain,
credentials_required=True)
return ctr_prov_context
finally:
if client:
client.logout()
def construct_k8s_metadata_from_pks_cache(sysadmin_client: vcd_client.Client,
ovdc_id, org_name, pks_plans,
pks_cluster_domain, k8s_provider):
vcd_utils.raise_error_if_not_sysadmin(sysadmin_client)
ctr_prov_context = {
K8S_PROVIDER_KEY: k8s_provider,
}
if k8s_provider == K8sProvider.PKS:
if not utils.is_pks_enabled():
raise e.CseServerError('CSE is not configured to work with PKS.')
ovdc = vcd_utils.get_vdc(client=sysadmin_client,
vdc_id=ovdc_id,
is_admin_operation=True)
pks_cache = utils.get_pks_cache()
pvdc_id = vcd_utils.get_pvdc_id(sysadmin_client, ovdc)
pvdc_info = pks_cache.get_pvdc_info(pvdc_id)
if not pvdc_info:
LOGGER.debug(f"pvdc '{pvdc_id}' is not backed "
f"by PKS-managed-vSphere resources")
raise e.CseServerError(f"VDC '{ovdc.get_resource().get('name')}'"
" is not eligible to provide resources"
" for PKS clusters.")
pks_account_info = pks_cache.get_pks_account_info(
org_name, pvdc_info.vc)
nsxt_info = pks_cache.get_nsxt_info(pvdc_info.vc)
pks_compute_profile_name = _construct_pks_compute_profile_name(
sysadmin_client, ovdc_id)
ctr_prov_context = construct_pks_context(
pks_account_info=pks_account_info,
pvdc_info=pvdc_info,
nsxt_info=nsxt_info,
pks_compute_profile_name=pks_compute_profile_name,
pks_plans=pks_plans,
pks_cluster_domain=pks_cluster_domain,
credentials_required=True)
return ctr_prov_context
def get_ovdc_container_provider_metadata(self, ovdc_name=None,
ovdc_id=None, org_name=None,
credentials_required=False,
nsxt_info_required=False):
"""Get metadata of given ovdc, pertaining to the container provider.
:param str ovdc_name: name of the ovdc
:param str ovdc_id: UUID of ovdc
:param str org_name: specific org to use if @org is not given.
If None, uses currently logged-in org from @client.
:param bool credentials_required: Decides if output metadata
should include credentials or not.
:return: metadata of the ovdc
:rtype: dict
:raises EntityNotFoundException: if the ovdc could not be found.
"""
# Get pvdc and pks information from oVdc metadata
client = None
try:
client = get_sys_admin_client()
ovdc = get_vdc(client=client, vdc_name=ovdc_name,
vdc_id=ovdc_id, org_name=org_name,
is_admin_operation=True)
all_metadata = metadata_to_dict(ovdc.get_all_metadata())
if K8S_PROVIDER_KEY not in all_metadata:
container_provider = K8sProviders.NONE
else:
container_provider = all_metadata[K8S_PROVIDER_KEY]
ctr_prov_details = {}
if container_provider == K8sProviders.PKS:
# Filter out container provider metadata into a dict
ctr_prov_details = {
metadata_key:
all_metadata[metadata_key]
for metadata_key in PksCache.get_pks_keys()
}
# Get the credentials from PksCache
pvdc_id = get_pvdc_id(ovdc)
pks_cache = get_pks_cache()
pvdc_info = pks_cache.get_pvdc_info(pvdc_id)
ctr_prov_details[PKS_PLANS_KEY] = \
ctr_prov_details[PKS_PLANS_KEY].split(',')
if credentials_required:
pks_info = pks_cache.get_pks_account_info(
org_name, pvdc_info.vc)
ctr_prov_details.update(pks_info.credentials._asdict())
if nsxt_info_required:
nsxt_info = pks_cache.get_nsxt_info(pvdc_info.vc)
ctr_prov_details['nsxt'] = nsxt_info
ctr_prov_details[K8S_PROVIDER_KEY] = container_provider
return ctr_prov_details
finally:
if client:
client.logout()