def __init__(self, sysadmin_client: vcd_client.Client, log_wire=True):
vcd_utils.raise_error_if_user_not_from_system_org(sysadmin_client)
self._sysadmin_client: vcd_client.Client = sysadmin_client
self._cloudapi_client = None
self._session = self._sysadmin_client.get_vcloud_session()
self._is_operation_supported = True
try:
wire_logger = logger.NULL_LOGGER
if log_wire:
wire_logger = logger.SERVER_CLOUDAPI_WIRE_LOGGER
self._cloudapi_client = \
vcd_utils.get_cloudapi_client_from_vcd_client(self._sysadmin_client, # noqa: E501
logger.SERVER_LOGGER, # noqa: E501
wire_logger)
self._cloudapi_version = \
cloudapi_constants.CloudApiVersion.VERSION_2_0_0
if float(self._cloudapi_client.get_api_version()) < \
GLOBAL_PVDC_COMPUTE_POLICY_MIN_VERSION:
self._cloudapi_version = \
cloudapi_constants.CloudApiVersion.VERSION_1_0_0
# Since the /cloudapi endpoint was added before the compute policy
# endpoint. Mere presence of the /cloudapi uri is not enough, we
# need to make sure that this cloud api client will be of actual
# use to us.
self._cloudapi_client.do_request(
method=RequestMethod.GET,
cloudapi_version=self._cloudapi_version,
resource_url_relative_path=
f"{cloudapi_constants.CloudApiResource.VDC_COMPUTE_POLICIES}"
) # noqa: E501
except requests.exceptions.HTTPError as err:
logger.SERVER_LOGGER.error(err)
self._is_operation_supported = False
def _load_def_schema(self, msg_update_callback=utils.NullPrinter()):
"""Load cluster interface and cluster entity type to global context.
If defined entity framework is supported by vCD api version, load
defined entity interface and defined entity type registered during
server install
:param utils.ConsoleMessagePrinter msg_update_callback
"""
sysadmin_client = None
try:
sysadmin_client = vcd_utils.get_sys_admin_client()
logger_wire = logger.NULL_LOGGER
if utils.str_to_bool(
utils.str_to_bool(self.config['service'].get(
'log_wire', False))): # noqa: E501
logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER
cloudapi_client = \
vcd_utils.get_cloudapi_client_from_vcd_client(sysadmin_client,
logger.SERVER_LOGGER, # noqa: E501
logger_wire)
raise_error_if_def_not_supported(cloudapi_client)
schema_svc = def_schema_svc.DefSchemaService(cloudapi_client)
defKey = def_utils.DefKey
keys_map = def_utils.MAP_API_VERSION_TO_KEYS[float(
sysadmin_client.get_api_version())] # noqa: E501
interface_id = def_utils.generate_interface_id(
vendor=keys_map[defKey.VENDOR], # noqa: E501
nss=keys_map[defKey.INTERFACE_NSS], # noqa: E501
version=keys_map[defKey.INTERFACE_VERSION]) # noqa: E501
entity_type_id = def_utils.generate_entity_type_id(
vendor=keys_map[defKey.VENDOR], # noqa: E501
nss=keys_map[defKey.ENTITY_TYPE_NSS], # noqa: E501
version=keys_map[defKey.ENTITY_TYPE_VERSION]) # noqa: E501
self._nativeInterface = schema_svc.get_interface(interface_id)
self._nativeEntityType = schema_svc.get_entity_type(entity_type_id)
msg = "Successfully loaded defined entity schema to global context"
msg_update_callback.general(msg)
logger.SERVER_LOGGER.debug(msg)
except cse_exception.DefNotSupportedException:
msg = "Skipping initialization of defined entity type" \
" and defined entity interface"
msg_update_callback.info(msg)
logger.SERVER_LOGGER.debug(msg)
except cse_exception.DefSchemaServiceError as e:
msg = f"Error while loading defined entity schema: {e.minor_error_code}" # noqa: E501
msg_update_callback.error(msg)
logger.SERVER_LOGGER.debug(msg)
raise e
except Exception as e:
msg = f"Failed to load defined entity schema to global context: {str(e)}" # noqa: E501
msg_update_callback.error(e)
logger.SERVER_LOGGER.error(e)
raise (e)
finally:
if sysadmin_client:
sysadmin_client.logout()
def __init__(self, client):
logger_wire = logger.NULL_LOGGER
if os.getenv(cli_constants.ENV_CSE_CLIENT_WIRE_LOGGING):
logger_wire = logger.CLIENT_WIRE_LOGGER
self._cloudapi_client = \
vcd_utils.get_cloudapi_client_from_vcd_client(
client=client, logger_debug=logger.CLIENT_LOGGER,
logger_wire=logger_wire)
self._native_cluster_api = NativeClusterApi(client)
def __init__(self,
sysadmin_client: vcd_client.Client,
log_wire=False,
logger_debug=NULL_LOGGER):
vcd_utils.raise_error_if_not_sysadmin(sysadmin_client)
self.logger_wire = SERVER_CLOUDAPI_WIRE_LOGGER \
if log_wire else NULL_LOGGER
self.logger_debug = logger_debug
self.cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client(
sysadmin_client,
logger_debug=self.logger_debug,
logger_wire=self.logger_wire)
def cloudapi_client(self):
if self._cloudapi_client is None:
log_wire = utils.get_server_runtime_config() \
.get('service', {}).get('log_wire', False)
logger_wire = logger.NULL_LOGGER
if log_wire:
logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER
self._cloudapi_client = \
vcd_utils.get_cloudapi_client_from_vcd_client(self.client,
logger.SERVER_LOGGER, # noqa: E501
logger_wire)
return self._cloudapi_client
def __init__(self, sysadmin_client: vcd_client.Client,
debug_logger=logger.SERVER_LOGGER, log_wire=True):
# Ensure correct credentials and api version
vcd_utils.raise_error_if_not_sysadmin(sysadmin_client)
client_api_version = float(sysadmin_client.get_api_version())
if client_api_version < constants.MQTT_MIN_API_VERSION:
raise ValueError(f'API version {client_api_version} '
f'is less than required version '
f'{constants.MQTT_MIN_API_VERSION} to use MQTT')
self._sysadmin_client: vcd_client.Client = sysadmin_client
wire_logger = logger.NULL_LOGGER
if log_wire:
wire_logger = logger.SERVER_CLOUDAPI_WIRE_LOGGER
self._wire_logger = wire_logger
self._debug_logger = debug_logger
self._cloudapi_client = \
vcd_utils.get_cloudapi_client_from_vcd_client(
self._sysadmin_client, self._debug_logger, self._wire_logger)
def _register_def_schema(client: Client,
msg_update_callback=utils.NullPrinter(),
log_wire=False):
"""Register defined entity interface and defined entity type.
If vCD api version is >= 35, register the vCD api version based
defined entity interface and defined entity type. Read the schema present
in the location dictated by api version to register the
defined entity type.
:param pyvcloud.vcd.client.Client client:
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object.
:param bool log_wire: wire logging enabled
"""
msg = "Registering defined entity schema"
msg_update_callback.info(msg)
INSTALL_LOGGER.debug(msg)
logger_wire = SERVER_CLOUDAPI_WIRE_LOGGER if log_wire else NULL_LOGGER
cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client(
client=client, # noqa: E501
logger_debug=INSTALL_LOGGER, # noqa: E501
logger_wire=logger_wire) # noqa: E501
schema_file = None
try:
def_utils.raise_error_if_def_not_supported(cloudapi_client)
schema_svc = def_schema_svc.DefSchemaService(cloudapi_client)
keys_map = def_utils.MAP_API_VERSION_TO_KEYS[float(
client.get_api_version())] # noqa: E501
defKey = def_utils.DefKey
native_interface = def_models.\
DefInterface(name=keys_map[defKey.INTERFACE_NAME],
vendor=keys_map[defKey.VENDOR],
nss=keys_map[defKey.INTERFACE_NSS],
version=keys_map[defKey.INTERFACE_VERSION], # noqa: E501
readonly=False)
msg = ""
try:
schema_svc.get_interface(native_interface.get_id())
msg = "defined entity interface already exists." \
" Skipping defined entity interface creation"
except HTTPError:
# TODO handle this part only if the interface was not found
native_interface = schema_svc.create_interface(native_interface)
msg = "Successfully created defined entity interface"
msg_update_callback.general(msg)
INSTALL_LOGGER.debug(msg)
# TODO stop-gap fix - find efficient way to import schema
import importlib
import importlib.resources as pkg_resources
schema_module = importlib.import_module(
f'{def_utils.DEF_SCHEMA_DIRECTORY}.{keys_map[defKey.ENTITY_TYPE_SCHEMA_VERSION]}'
) # noqa: E501
schema_file = pkg_resources.open_text(
schema_module, def_utils.DEF_ENTITY_TYPE_SCHEMA_FILE) # noqa: E501
native_entity_type = def_models.\
DefEntityType(name=keys_map[defKey.ENTITY_TYPE_NAME],
description='',
vendor=keys_map[defKey.VENDOR],
nss=keys_map[defKey.ENTITY_TYPE_NSS],
version=keys_map[defKey.ENTITY_TYPE_VERSION],
schema=json.load(schema_file),
interfaces=[native_interface.get_id()],
readonly=False)
msg = ""
try:
schema_svc.get_entity_type(native_entity_type.get_id())
msg = "defined entity type already exists." \
" Skipping defined entity type creation"
except HTTPError:
# TODO handle this part only if the entity type was not found
native_entity_type = schema_svc.create_entity_type(
native_entity_type) # noqa: E501
msg = "Successfully registered defined entity type"
msg_update_callback.general(msg)
INSTALL_LOGGER.debug(msg)
except cse_exception.DefNotSupportedException:
msg = "Skipping defined entity type and defined entity interface" \
" registration"
msg_update_callback.general(msg)
INSTALL_LOGGER.debug(msg)
except Exception as e:
msg = f"Error occured while registering defined entity schema: {str(e)}" # noqa: E501
msg_update_callback.error(msg)
INSTALL_LOGGER.error(msg)
raise (e)
finally:
try:
schema_file.close()
except Exception:
pass
def __init__(self, client):
self.client = client
self.cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client(
client=client, logger_debug=CLIENT_LOGGER)