def cluster_update(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
Validate data before actual resize is delegated to cluster service.
:return: Defined entity of the native cluster
:rtype: container_service_extension.def_.models.DefEntity
"""
# TODO Reject request if rde_in_use is less than 2.0.0
# TODO find out the RDE version from the request spec
# TODO Insert RDE converters and validators
cluster_id = data[RequestKey.CLUSTER_ID]
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
NativeEntityClass = rde_factory.get_rde_model(rde_in_use)
cluster_entity_spec: AbstractNativeEntity = \
NativeEntityClass(**data[RequestKey.INPUT_SPEC]) # noqa: E501
curr_entity = svc.entity_svc.get_entity(cluster_id)
is_upgrade_operation = \
request_utils.validate_cluster_update_request_and_check_cluster_upgrade( # noqa: E501
asdict(cluster_entity_spec.spec), asdict(curr_entity.entity.spec))
if is_upgrade_operation:
return asdict(svc.upgrade_cluster(cluster_id, cluster_entity_spec))
return asdict(svc.resize_cluster(cluster_id, cluster_entity_spec))
def cluster_resize(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
Validate data before actual resize is delegated to cluster service.
:return: Defined entity of the native cluster
:rtype: container_service_extension.def_.models.DefEntity
"""
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]
# TODO find out the RDE version from the request spec
# TODO Insert RDE converters and validators
NativeEntityClass = rde_factory.get_rde_model(rde_in_use)
cluster_entity_spec: AbstractNativeEntity = \
NativeEntityClass(**data[RequestKey.INPUT_SPEC]) # noqa: E501
curr_entity = svc.entity_svc.get_entity(cluster_id)
request_utils.validate_request_payload(
asdict(cluster_entity_spec.spec),
asdict(curr_entity.entity.spec),
exclude_fields=[
FlattenedClusterSpecKey.WORKERS_COUNT.value,
FlattenedClusterSpecKey.NFS_COUNT.value
])
return asdict(svc.resize_cluster(cluster_id, cluster_entity_spec))
def cluster_upgrade(data, op_ctx: ctx.OperationContext):
"""Request handler for cluster upgrade operation.
Validate data before actual upgrade is delegated to cluster service.
: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)
# TODO find out the RDE version from the request spec
# TODO Insert RDE converters and validators
NativeEntityClass = rde_factory.get_rde_model(rde_in_use)
cluster_entity_spec: AbstractNativeEntity = \
NativeEntityClass(**data[RequestKey.INPUT_SPEC])
cluster_id = data[RequestKey.CLUSTER_ID]
curr_entity = svc.entity_svc.get_entity(cluster_id)
request_utils.validate_request_payload(
asdict(cluster_entity_spec.spec),
asdict(curr_entity.entity.spec),
exclude_fields=[
FlattenedClusterSpecKey.TEMPLATE_NAME.value,
FlattenedClusterSpecKey.TEMPLATE_REVISION.value
])
return asdict(svc.upgrade_cluster(cluster_id, cluster_entity_spec))
def cluster_update(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster update 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]
# Validate the input
# ToDo: Should the validation be done using a v36 client?
rde_validator_factory.get_validator(
rde_version=rde_constants.RDEVersion.RDE_2_0_0). \
validate(cloudapi_client=op_ctx.cloudapi_client, entity_id=cluster_id,
entity=input_entity,
operation=BehaviorOperation.UPDATE_CLUSTER)
# TODO Insert RDE converter if needed.
# Call the backend to initiate the cluster update operation.
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
NativeEntityClass: Type[AbstractNativeEntity] = rde_factory.get_rde_model(
rde_in_use) # noqa: E501
cluster_entity: AbstractNativeEntity = \
NativeEntityClass.from_dict(input_entity)
return svc.update_cluster(cluster_id, cluster_entity).to_dict()
def get_cluster_service(self,
rde_version_in_use=None,
skip_tkgm_check=False): # noqa: E501
"""Get the right instance of backend cluster service.
Factory method to return the ClusterService based on the RDE version in use.
:param rde_version_in_use (str)
:param bool skip_tkgm_check: flag specifying not to use TKGm cluster service
:rtype cluster_service (container_service_extension.server.abstract_broker.AbstractBroker) # noqa: E501
"""
if rde_version_in_use is None:
rde_version_in_use = server_utils.get_rde_version_in_use()
rde_version: semantic_version.Version = semantic_version.Version(
rde_version_in_use) # noqa: E501
if rde_version.major == 1:
return ClusterService1X(op_ctx=self.req_ctx)
elif rde_version.major == 2:
entity = self.req_ctx.entity
if not skip_tkgm_check and entity is None:
def_entity_svc = entity_service.DefEntityService(
self.req_ctx.op_ctx.cloudapi_client) # noqa: E501
def_entity = def_entity_svc.get_entity(
self.req_ctx.op_ctx.entity_id) # noqa: E501
entity = def_entity.entity.to_dict()
if not skip_tkgm_check and entity.get(
'kind') == ClusterEntityKind.TKG_M.value: # noqa: E501
return ClusterService2XTKGm(self.req_ctx)
else:
return ClusterService2X(self.req_ctx)
def native_cluster_list(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
:return: List
"""
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
filters = data.get(RequestKey.QUERY_PARAMS, {})
page_number = int(filters.get(PaginationKey.PAGE_NUMBER,
CSE_PAGINATION_FIRST_PAGE_NUMBER))
page_size = int(filters.get(PaginationKey.PAGE_SIZE,
CSE_PAGINATION_DEFAULT_PAGE_SIZE))
# remove page number and page size from the filters as it is treated
# differently from other filters
if PaginationKey.PAGE_NUMBER in filters:
del filters[PaginationKey.PAGE_NUMBER]
if PaginationKey.PAGE_SIZE in filters:
del filters[PaginationKey.PAGE_SIZE]
# response needs to paginated
result = svc.get_clusters_by_page(filters=filters)
clusters = [def_entity.to_dict() for def_entity in result[PaginationKey.VALUES]] # noqa: E501
uri = data['url']
return server_utils.create_links_and_construct_paginated_result(
uri,
clusters,
result_total=result[PaginationKey.RESULT_TOTAL],
page_number=page_number,
page_size=page_size,
query_params=filters)
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_acl_info(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster acl list operation."""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
return cluster_handler.cluster_acl_info(data=data, op_ctx=op_ctx)
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
cluster_id = data[RequestKey.CLUSTER_ID]
query = data.get(RequestKey.QUERY_PARAMS, {})
page = int(
query.get(PaginationKey.PAGE_NUMBER,
CSE_PAGINATION_FIRST_PAGE_NUMBER)) # noqa: E501
page_size = int(
query.get(PaginationKey.PAGE_SIZE,
CSE_PAGINATION_DEFAULT_PAGE_SIZE)) # noqa: E501
result: dict = svc.get_cluster_acl_info(cluster_id, page, page_size)
uri = f"{op_ctx.client.get_api_uri().strip('/api')}{data['url']}"
return server_utils.create_links_and_construct_paginated_result(
base_uri=uri,
values=result.get(PaginationKey.VALUES, []),
result_total=result.get(PaginationKey.RESULT_TOTAL, 0),
page_number=page,
page_size=page_size)
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
"""
rde_in_use = server_utils.get_rde_version_in_use()
input_entity: dict = data[RequestKey.INPUT_SPEC]
payload_version = input_entity.get(
rde_constants.PayloadKey.PAYLOAD_VERSION_RDE_1_0.value) # noqa: E501
# Reject request >= 2.0
_raise_error_if_unsupported_payload_version(payload_version)
# Convert the input entity to runtime rde format
converted_native_entity: AbstractNativeEntity = rde_utils.convert_input_rde_to_runtime_rde_format(
input_entity) # noqa: E501
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
rde_data: dict = cluster_handler.cluster_create(
data={RequestKey.INPUT_SPEC: converted_native_entity.to_dict()},
op_ctx=op_ctx)
new_rde = common_models.DefEntity(**rde_data)
else:
# Based on the runtime rde, call the appropriate backend method.
svc = cluster_service_factory.ClusterServiceFactory(
op_ctx).get_cluster_service() # noqa: E501
new_rde: common_models.DefEntity = svc.create_cluster(
converted_native_entity) # noqa: E501
# convert the created rde back to input rde version
return _convert_rde_to_1_0_format(new_rde.to_dict())
def cluster_acl_update(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster acl update operation."""
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]
update_acl_entries = data.get(RequestKey.INPUT_SPEC, {}).get(ClusterAclKey.ACCESS_SETTING) # noqa: E501
svc.update_cluster_acl(cluster_id, update_acl_entries)
def raise_error_if_unsupported_payload_version(payload_version: str):
input_rde_version = def_constants.MAP_INPUT_PAYLOAD_VERSION_TO_RDE_VERSION.get(
payload_version, def_constants.PayloadKey.UNKNOWN) # noqa: E501
runtime_rde_version = server_utils.get_rde_version_in_use()
if input_rde_version == def_constants.PayloadKey.UNKNOWN or semantic_version.Version(
input_rde_version) > semantic_version.Version(
runtime_rde_version): # noqa: E501
raise exceptions.BadRequestError(
f"Unsupported payload version: {payload_version}") # noqa: E501
def cluster_upgrade_plan(data, op_ctx: ctx.OperationContext):
"""Request handler for cluster upgrade-plan operation.
:return: List[Tuple(str, str)]
"""
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
return svc.get_cluster_upgrade_plan(data[RequestKey.CLUSTER_ID])
def cluster_list(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
:return: List
"""
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
# response should not be paginated
return [def_entity.to_dict() for def_entity in
svc.list_clusters(data.get(RequestKey.QUERY_PARAMS, {}))]
def cluster_config(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster config operation.
Required data: cluster_id
: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]
return svc.get_cluster_config(cluster_id)
def native_cluster_list(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
:return: List
"""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
response_data: dict = cluster_handler.native_cluster_list(
data=data, op_ctx=op_ctx) # noqa: E501
rde_list: list[dict] = response_data[PaginationKey.VALUES]
formatted_rde_list = [
_convert_rde_to_1_0_format(rde_data) for rde_data in rde_list
] # noqa: E501
response_data[PaginationKey.VALUES] = formatted_rde_list
return response_data
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
filters = data.get(RequestKey.QUERY_PARAMS, {})
page_number = int(
filters.get(PaginationKey.PAGE_NUMBER,
CSE_PAGINATION_FIRST_PAGE_NUMBER))
page_size = int(
filters.get(PaginationKey.PAGE_SIZE, CSE_PAGINATION_DEFAULT_PAGE_SIZE))
# remove page number and page size from the filters as it is treated
# differently from other filters
if PaginationKey.PAGE_NUMBER in filters:
del filters[PaginationKey.PAGE_NUMBER]
if PaginationKey.PAGE_SIZE in filters:
del filters[PaginationKey.PAGE_SIZE]
# response needs to paginated
result = svc.get_clusters_by_page(filters=filters)
clusters = [
def_entity.to_dict() for def_entity in result[PaginationKey.VALUES]
] # noqa: E501
# remove duplicate /api path while forming the endpoint url
uri = f"{op_ctx.client.get_api_uri().strip('/api')}{data['url']}"
return server_utils.create_links_and_construct_paginated_result(
uri,
clusters,
result_total=result[PaginationKey.RESULT_TOTAL],
page_number=page_number,
page_size=page_size,
query_params=filters)
def cluster_upgrade_plan(data, op_ctx: ctx.OperationContext):
"""Request handler for cluster upgrade-plan operation.
:return: List[Tuple(str, str)]
"""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
return cluster_handler.cluster_upgrade_plan(data=data, op_ctx=op_ctx)
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
return svc.get_cluster_upgrade_plan(data[RequestKey.CLUSTER_ID])
def cluster_acl_update(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster acl update operation."""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
return cluster_handler.cluster_acl_update(data=data, op_ctx=op_ctx)
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
cluster_id = data[RequestKey.CLUSTER_ID]
update_acl_entries = data.get(RequestKey.INPUT_SPEC, {}).get(
ClusterAclKey.ACCESS_SETTING) # noqa: E501
svc.update_cluster_acl(cluster_id, update_acl_entries)
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
"""
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]
return svc.delete_cluster(cluster_id).to_dict()
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
"""
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
# TODO find out the RDE version from the request spec
# TODO Insert RDE converters and validators
NativeEntityClass = rde_factory.get_rde_model(rde_in_use)
cluster_entity_spec: AbstractNativeEntity = \
NativeEntityClass(**data[RequestKey.INPUT_SPEC])
return asdict(svc.create_cluster(cluster_entity_spec))
def get_cluster_service(self, rde_version_in_use=None):
"""Get the right instance of backend cluster service.
Factory method to return the ClusterService based on the RDE version in use.
:param rde_version_in_use (str)
:param op_ctx Union[OperationContext, BehaviorRequestContext]
:rtype cluster_service (container_service_extension.server.abstract_broker.AbstractBroker) # noqa: E501
"""
if rde_version_in_use is None:
rde_version_in_use = server_utils.get_rde_version_in_use()
rde_version: semantic_version.Version = semantic_version.Version(rde_version_in_use) # noqa: E501
if rde_version.major == 1:
return ClusterService1X(op_ctx=self.req_ctx)
elif rde_version.major == 2:
return ClusterService2X(self.req_ctx)
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_config(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster config operation.
Required data: cluster_id
:return: Dict
"""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
return cluster_handler.cluster_config(data=data, op_ctx=op_ctx)
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
cluster_id = data[RequestKey.CLUSTER_ID]
return svc.get_cluster_config(cluster_id)
def cluster_acl_info(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster acl list operation."""
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]
query = data.get(RequestKey.QUERY_PARAMS, {})
page = int(query.get(PaginationKey.PAGE_NUMBER, CSE_PAGINATION_FIRST_PAGE_NUMBER)) # noqa: E501
page_size = int(query.get(PaginationKey.PAGE_SIZE, CSE_PAGINATION_DEFAULT_PAGE_SIZE)) # noqa: E501
result: dict = svc.get_cluster_acl_info(cluster_id, page, page_size)
uri = data['url']
return server_utils.create_links_and_construct_paginated_result(
base_uri=uri,
values=result.get(PaginationKey.VALUES, []),
result_total=result.get(PaginationKey.RESULT_TOTAL, 0),
page_number=page,
page_size=page_size)
def cluster_resize(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster resize operation.
Validate data before actual resize is delegated to cluster service.
:return: Defined entity of the native cluster
:rtype: container_service_extension.def_.models.DefEntity
"""
rde_in_use = server_utils.get_rde_version_in_use()
input_entity: dict = data[RequestKey.INPUT_SPEC]
payload_version = input_entity.get(
rde_constants.PayloadKey.PAYLOAD_VERSION_RDE_1_0.value) # noqa: E501
# Reject request >= 2.0
_raise_error_if_unsupported_payload_version(payload_version)
# Convert the input entity to runtime rde format
converted_native_entity: AbstractNativeEntity = rde_utils.convert_input_rde_to_runtime_rde_format(
input_entity) # noqa: E501
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
data[RequestKey.INPUT_SPEC] = converted_native_entity.to_dict()
rde_data: dict = cluster_handler.cluster_update(
data=data, op_ctx=op_ctx) # noqa: E501
new_rde = common_models.DefEntity(**rde_data)
else:
# Based on the runtime rde, call the appropriate backend method.
svc = cluster_service_factory.ClusterServiceFactory(
op_ctx).get_cluster_service() # noqa: E501
cluster_id = data[RequestKey.CLUSTER_ID]
curr_entity = svc.entity_svc.get_entity(cluster_id)
request_utils.validate_request_payload(
converted_native_entity.spec.to_dict(),
curr_entity.entity.spec.to_dict(), # noqa: E501
exclude_fields=[
FlattenedClusterSpecKey1X.WORKERS_COUNT.value,
FlattenedClusterSpecKey1X.NFS_COUNT.value,
FlattenedClusterSpecKey1X.EXPOSE.value
])
new_rde: common_models.DefEntity = svc.resize_cluster(
cluster_id, converted_native_entity) # noqa: E501
# convert the resized rde back to input rde version
return _convert_rde_to_1_0_format(new_rde.to_dict())
def convert_input_rde_to_runtime_rde_format(input_entity: dict):
"""Convert input entity to runtime rde format.
:param AbstractNativeEntity input_entity: entity to be converted
:return: Entity in runtime rde format
:rtype: AbstractNativeEntity
"""
payload_version = input_entity.get(
def_constants.PayloadKey.PAYLOAD_VERSION) # noqa: E501
runtime_rde_version = server_utils.get_rde_version_in_use()
RuntimeNativeEntityClass: Type[
AbstractNativeEntity] = rde_factory.get_rde_model(
runtime_rde_version) # noqa: E501
InputNativeEntityClass: Type[
AbstractNativeEntity] = rde_factory.get_rde_model( # noqa: E501
def_constants.MAP_INPUT_PAYLOAD_VERSION_TO_RDE_VERSION[
payload_version]) # noqa: E501
input_rde: AbstractNativeEntity = InputNativeEntityClass(
**input_entity) # noqa: E501
return RuntimeNativeEntityClass.from_native_entity(input_rde)
def cluster_list(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster list operation.
:return: List
"""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
rde_list: list[dict] = cluster_handler.cluster_list(
data=data, op_ctx=op_ctx) # noqa: E501
return [_convert_rde_to_1_0_format(rde_data) for rde_data in rde_list]
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
# response should not be paginated
return [
def_entity.to_dict() for def_entity in svc.list_clusters(
data.get(RequestKey.QUERY_PARAMS, {}))
]
def cluster_acl_info(data: dict, op_ctx: ctx.OperationContext):
"""Request handler for cluster acl list operation."""
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]
query = data.get(RequestKey.V35_QUERY, {})
page = int(
query.get(PaginationKey.PAGE_NUMBER,
CSE_PAGINATION_FIRST_PAGE_NUMBER)) # noqa: E501
page_size = int(
query.get(PaginationKey.PAGE_SIZE,
CSE_PAGINATION_DEFAULT_PAGE_SIZE)) # noqa: E501
result: dict = svc.get_cluster_acl_info(cluster_id, page, page_size)
api_path = CseServerOperationInfo.V35_CLUSTER_ACL_LIST.api_path_format % cluster_id # noqa: E501
uri = f"{op_ctx.client.get_api_uri().strip('/')}{api_path}"
return server_utils.create_links_and_construct_paginated_result(
base_uri=uri,
values=result.get(PaginationKey.VALUES, []),
result_total=result.get(PaginationKey.RESULT_TOTAL, 0),
page_number=page,
page_size=page_size)
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]
# Validate the input
rde_validator_factory.get_validator(
rde_version=rde_constants.RDEVersion.RDE_2_0_0). \
validate(cloudapi_client=op_ctx.cloudapi_client, entity=input_entity)
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(op_ctx). \
get_cluster_service(rde_in_use)
# TODO Insert RDE converter if needed.
NativeEntityClass: Type[AbstractNativeEntity] = rde_factory.get_rde_model(
rde_in_use) # noqa: E501
cluster_entity_spec: AbstractNativeEntity = \
NativeEntityClass(**input_entity)
return asdict(svc.create_cluster(cluster_entity_spec))
def create_cluster(behavior_ctx: BehaviorRequestContext):
entity_id: str = behavior_ctx.entity_id
entity: dict = behavior_ctx.entity
cloudapi_client: CloudApiClient = behavior_ctx.op_ctx.cloudapi_client
api_version: float = behavior_ctx.api_version
# Validate the input
rde_version_introduced_at_api_version = rde_utils.get_rde_version_introduced_at_api_version(
api_version) # noqa: E501
rde_validator_factory.get_validator(
rde_version=rde_version_introduced_at_api_version). \
validate(cloudapi_client=cloudapi_client, entity=entity)
# TODO Based on the rde_in_use, convert the entity if necessary.
# Call the backend to initiate the cluster creation.
rde_in_use = server_utils.get_rde_version_in_use()
svc = cluster_service_factory.ClusterServiceFactory(
behavior_ctx).get_cluster_service(rde_in_use) # noqa: E501
NativeEntityClass: AbstractNativeEntity = rde_factory.get_rde_model(
rde_in_use) # noqa: E501
input_entity: AbstractNativeEntity = NativeEntityClass(**entity)
return svc.create_cluster(entity_id=entity_id,
input_native_entity=input_entity) # noqa: E501
def cluster_info(data: dict, 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
"""
rde_in_use = server_utils.get_rde_version_in_use()
# Redirect to generic handler if the backend supports RDE-2.0
if semantic_version.Version(rde_in_use) >= semantic_version.Version(
rde_constants.RDEVersion.RDE_2_0_0.value): # noqa: E501
rde_data: dict = cluster_handler.cluster_info(data=data, op_ctx=op_ctx)
new_rde = common_models.DefEntity(**rde_data)
else:
svc = cluster_service_factory.ClusterServiceFactory(
op_ctx).get_cluster_service(rde_in_use) # noqa: E501
cluster_id = data[RequestKey.CLUSTER_ID]
new_rde = svc.get_cluster_info(cluster_id)
return _convert_rde_to_1_0_format(new_rde.to_dict())
