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 force_delete_cluster_by_cluster_id(self, cluster_id): uri = f'{self._uri}/cluster/{cluster_id}/action/force-delete' response = self.do_request(uri=uri, method=shared_constants.RequestMethod.POST, accept_type='application/json') return common_models.DefEntity(**self.process_response(response))
def delete_nfs_node_by_node_name(self, cluster_id: str, node_name: str): uri = f"{self._cluster_uri}/{cluster_id}/nfs/{node_name}" response = self.do_request( uri=uri, method=shared_constants.RequestMethod.DELETE, accept_type='application/json') return common_models.DefEntity(**self.process_response(response))
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 delete_nfs_node_by_node_name(self, cluster_id: str, node_name: str): uri = f"{self._cluster_uri}/{cluster_id}/nfs/{node_name}" response = self._client._do_request_prim( shared_constants.RequestMethod.DELETE, uri, self._client._session, media_type='application/json', accept_type='application/json') return common_models.DefEntity( **response_processor.process_response(response))
def upgrade_cluster_by_cluster_id( self, cluster_id: str, cluster_upgrade_definition: common_models.DefEntity): # noqa: E501 uri = f'{self._uri}/cluster/{cluster_id}/action/upgrade' entity_dict = asdict(cluster_upgrade_definition.entity) response = self.do_request(uri=uri, method=shared_constants.RequestMethod.POST, accept_type='application/json', media_type='application/json', payload=entity_dict) return common_models.DefEntity(**self.process_response(response))
def update_cluster_by_cluster_id( self, cluster_id, cluster_entity_definition: rde_1_0_0.NativeEntity): # noqa: E501 cluster_entity_dict = asdict(cluster_entity_definition) uri = f"{self._cluster_uri}/{cluster_id}" response = self.do_request(uri=uri, method=shared_constants.RequestMethod.PUT, accept_type='application/json', media_type='application/json', payload=cluster_entity_dict) return common_models.DefEntity(**self.process_response(response))
def _convert_rde_to_1_0_format(rde_data: dict) -> dict: """Convert defined entity to RDE 1.0. :param DefEntity rde_data: Defined entity dictionary :return: converted defined entity :rtype: dict """ new_rde = common_models.DefEntity(**rde_data) new_native_entity: AbstractNativeEntity = rde_utils.convert_runtime_rde_to_input_rde_version_format( # noqa: E501 new_rde.entity, rde_constants.RDEVersion.RDE_1_0_0) new_rde.entity = new_native_entity new_rde.entityType = common_models.EntityType.NATIVE_ENTITY_TYPE_1_0_0.value.get_id( ) # noqa: E501 return new_rde.to_dict()
def upgrade_cluster_by_cluster_id( self, cluster_id: str, cluster_upgrade_definition: common_models.DefEntity): # noqa: E501 uri = f'{self._uri}/cluster/{cluster_id}/action/upgrade' entity_dict = asdict(cluster_upgrade_definition.entity) response = self._client._do_request_prim( shared_constants.RequestMethod.POST, uri, self._client._session, contents=entity_dict, media_type='application/json', accept_type='application/json') return common_models.DefEntity( **response_processor.process_response(response))
def update_cluster_by_cluster_id( self, cluster_id, cluster_entity_definition: rde_1_0_0.NativeEntity): # noqa: E501 cluster_entity_dict = asdict(cluster_entity_definition) uri = f"{self._cluster_uri}/{cluster_id}" response = self._client._do_request_prim( shared_constants.RequestMethod.PUT, uri, self._client._session, contents=cluster_entity_dict, media_type='application/json', accept_type='application/json') return common_models.DefEntity( **response_processor.process_response(response))
def upgrade_cluster_by_cluster_id(self, cluster_id, cluster_def_entity, **kwargs): # noqa: E501 """Get the upgrade plan for give cluster id. :param str cluster_id: unique id of the cluster :param dict cluster_def_entity: defined entity :return: string containing upgrade cluster task href :rtype: str """ # TODO: check if we really need to decode-encode-decode-encode cluster_upgrade_definition = common_models.DefEntity(**cluster_def_entity) # noqa: E501 cluster_def_entity = \ self._native_cluster_api.upgrade_cluster_by_cluster_id( cluster_id, cluster_upgrade_definition) task_href = cluster_def_entity.entity.status.task_href return client_utils.construct_task_console_message(task_href)
def create_cluster(self, cluster_create_spec: dict): """Call create native cluster CSE server endpoint. :param dict cluster_create_spec: Cluster create specification :return: defined entity object representing the response :rtype: common_models.DefEntity """ uri = self._clusters_uri response = self.do_request(uri=uri, method=shared_constants.RequestMethod.POST, accept_type='application/json', media_type='application/json', payload=cluster_create_spec) return common_models.DefEntity(**self.process_response(response))
def update_cluster_by_cluster_id(self, cluster_id: str, cluster_update_spec: dict): # noqa: E501 """Call update native cluster CSE server endpoint. :param str cluster_id: ID of the cluster :param dict cluster_update_spec: Update cluster specification :return: defined entity object representing the response :rtype: common_models.DefEntity """ uri = f"{self._cluster_uri}/{cluster_id}" response = self.do_request(uri=uri, method=shared_constants.RequestMethod.PUT, accept_type='application/json', media_type='application/json', payload=cluster_update_spec) return common_models.DefEntity(**self.process_response(response))
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 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())