def delete_comparison(self, project_id: str, comparison_id: str): """ Delete a comparison in our database. Parameters ---------- project_id : str comparison_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When comparison_id does not exist. """ comparison = self.session.query(models.Comparison).get(comparison_id) if comparison is None: raise NOT_FOUND self.session.delete(comparison) self.session.commit() return schemas.Message(message="Comparison deleted")
def delete_template(self, template_id: str): """ Delete a template in our database. Parameters ---------- template_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When template_id does not exist. """ template = self.session.query(models.Template).get(template_id) if template is None: raise NOT_FOUND self.session.delete(template) return schemas.Message(message="Template deleted")
def delete_project(self, project_id): """ Delete a project in our database and in the object storage. Parameters ---------- project_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When project_id does not exist. """ project = (self.session.query(models.Project).filter_by( uuid=project_id).filter_by(tenant=self.kubeflow_userid).first()) if project is None: raise NOT_FOUND self.session.delete(project) self.session.commit() return schemas.Message(message="Project deleted")
def delete_multiple_projects(self, project_ids): """ Delete multiple projects. Parameters ---------- project_ids : str The list of project ids. Returns ------- projects.schemas.message.Message Raises ------ BadRequest When any project_id does not exist. """ total_elements = len(project_ids) if total_elements < 1: raise BadRequest(code="MissingRequiredProjectId", message="inform at least one project") projects = (self.session.query(models.Project).filter( models.Project.uuid.in_(project_ids)).filter_by( tenant=self.kubeflow_userid).all()) for project in projects: self.session.delete(project) self.session.commit() return schemas.Message(message="Successfully removed projects")
def delete_template(self, template_id: str): """ Delete a template in our database. Parameters ---------- template_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When template_id does not exist. """ template = (self.session.query(models.Template).filter_by( uuid=template_id).filter_by(tenant=self.kubeflow_userid).first()) if template is None: raise NOT_FOUND self.session.delete(template) self.session.commit() return schemas.Message(message="Template deleted")
def delete_multiple_templates(self, template_ids): """ Delete multiple templates. Parameters ---------- template_ids : str The list of template ids. Returns ------- projects.schemas.message.Message Raises ------ BadRequest When any template_id does not exist. """ total_elements = len(template_ids) if total_elements < 1: raise BadRequest(code="MissingRequiredTemplateId", message="inform at least one template") templates = (self.session.query(models.Template).filter( models.Template.uuid.in_(template_ids)).filter_by( tenant=self.kubeflow_userid).all()) for template in templates: self.session.delete(template) self.session.commit() return schemas.Message(message="Successfully removed templates")
def delete_deployment(self, project_id: str, deployment_id: str): """ Delete a deployment in our database and in the object storage. Parameters ---------- project_id: str deployment_id : str Raises ------ NotFound When deployment_id does not exist. Returns ------- projects.schemas.message.Message """ deployment = self.session.query(models.Deployment).get(deployment_id) if deployment is None: raise NOT_FOUND self.session.delete(deployment) self.fix_positions(project_id=project_id) self.session.commit() return schemas.Message(message="Deployment deleted")
def delete_task(self, task_id: str): """ Delete a task in our database. Parameters ---------- task_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When task_id does not exist. """ task = self.session.query(models.Task).get(task_id) if task is None: raise NOT_FOUND # remove the volume for the task in the notebook server self.background_tasks.add_task( remove_persistent_volume_claim, name=f"vol-task-{task_id}", mount_path=f"/home/jovyan/tasks/{task.name}", ) self.session.delete(task) self.session.commit() return schemas.Message(message="Task deleted")
def delete_project(self, project_id): """ Delete a project in our database and in the object storage. Parameters ---------- project_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When project_id does not exist. """ project = self.session.query(models.Project).get(project_id) if project is None: raise NOT_FOUND self.session.delete(project) self.session.commit() prefix = join("experiments", project_id) remove_objects(prefix=prefix) return schemas.Message(message="Project deleted")
def delete_operator( self, project_id: str, operator_id: str, experiment_id: Optional[str] = None, deployment_id: Optional[str] = None, ): """ Delete an operator in our database. Parameters ---------- project_id : str experiment_id : str or None deployment_id : str or None operator_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When operator_id does not exist. """ operator = self.session.query(models.Operator).get(operator_id) if operator is None: raise NOT_FOUND # check if other operators contains the operator being deleted # in dependencies and remove this operator from dependencies operators = (self.session.query( models.Operator).filter_by(experiment_id=experiment_id).filter_by( deployment_id=deployment_id).filter( models.Operator.uuid != operator_id).all()) for op in operators: if operator_id in op.dependencies: dependencies = op.dependencies.remove(operator_id) if dependencies is None: dependencies = [] op_update = schemas.OperatorUpdate(dependencies=dependencies, ) self.update_operator( project_id=project_id, experiment_id=experiment_id, deployment_id=deployment_id, operator_id=op.uuid, operator=op_update, ) self.session.delete(operator) self.session.commit() return schemas.Message(message="Operator deleted")
def delete_deployment(self, project_id: str, deployment_id: str): """ Delete a deployment in our database and in the object storage. Parameters ---------- project_id: str deployment_id : str Raises ------ NotFound When deployment_id does not exist. Returns ------- projects.schemas.message.Message """ deployment = self.session.query(models.Deployment).get(deployment_id) if deployment is None: raise NOT_FOUND # remove responses self.session.query(models.Response).filter( models.Response.deployment_id == deployment_id).delete() # remove operators self.session.query(models.Operator).filter( models.Operator.deployment_id == deployment_id).delete() # remove monitorings monitorings = self.session.query(models.Monitoring).filter( models.Monitoring.deployment_id == deployment_id) # Undeploy monitorings if monitorings: for monitoring in monitorings: self.background_tasks.add_task(undeploy_monitoring, monitoring_id=monitoring.uuid) # delete monitorings on database monitorings.delete() self.session.delete(deployment) self.fix_positions(project_id=project_id) self.session.commit() # Temporary: also delete run deployment (while web-ui isn't ready) self.run_controller = self.run_controller.terminate_run( project_id=project_id, deployment_id=deployment_id, run_id="latest") return schemas.Message(message="Deployment deleted")
def terminate_run(self, deployment_id): """ Terminates a run in Kubeflow Pipelines. Parameters ---------- deployment_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When deployment run does not exist. """ load_kube_config() api = client.CustomObjectsApi() custom_objects = api.list_namespaced_custom_object( "machinelearning.seldon.io", "v1", KF_PIPELINES_NAMESPACE, "seldondeployments", ) deployments_objects = custom_objects["items"] if deployments_objects: for deployment in deployments_objects: if deployment["metadata"]["name"] == deployment_id: undeploy_pipeline( name=deployment["metadata"]["name"], kind=deployment["kind"], namespace=deployment["metadata"]["namespace"], ) deployment_run = get_deployment_runs(deployment_id) if not deployment_run: raise NotFound(code="RunNotFound", message="The specified run does not exist.") kfp_client().runs.delete_run(deployment_run["runId"]) return schemas.Message(message="Deployment deleted")
def delete_experiment(self, project_id, experiment_id): """ Delete an experiment in our database and in the object storage. Parameters ---------- project_id : str experiment_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When experiment_id does not exist. """ experiment = self.session.query(models.Experiment).get(experiment_id) if experiment is None: raise NOT_FOUND # remove comparisons self.session.query(models.Comparison) \ .filter(models.Comparison.experiment_id == experiment_id) \ .delete() # remove experiment operators self.session.query(models.Operator) \ .filter(models.Operator.experiment_id == experiment_id) \ .delete() # update deployments experiment id to None self.session.query(models.Deployment) \ .filter(models.Deployment.experiment_id == experiment_id) \ .update({"experiment_id": None}) self.session.delete(experiment) self.session.flush() self.fix_positions(project_id=project_id) self.session.commit() return schemas.Message(message="Experiment deleted")
def delete_multiple_projects(self, project_ids): """ Delete multiple projects. Parameters ---------- project_ids : str The list of project ids. Returns ------- projects.schemas.message.Message Raises ------ BadRequest When any project_id does not exist. """ total_elements = len(project_ids) if total_elements < 1: raise BadRequest("inform at least one project") experiments = self.session.query(models.Experiment) \ .filter(models.Experiment.project_id.in_(project_ids)) \ .all() projects = self.session.query(models.Project) \ .filter(models.Project.uuid.in_(project_ids)) \ .all() for project in projects: self.session.delete(project) self.session.commit() for experiment in experiments: prefix = join("experiments", experiment.uuid) try: remove_objects(prefix=prefix) except Exception: pass return schemas.Message(message="Successfully removed projects")
def delete_task(self, task_id: str): """ Delete a task in our database. Parameters ---------- task_id : str Returns ------- projects.schemas.message.Message Raises ------ NotFound When task_id does not exist. """ task = self.session.query(models.Task).get(task_id) if task is None: raise NOT_FOUND if task.operator: raise Forbidden(code="TaskProtectedFromDeletion", message="Task related to an operator") # remove the volume for the task in the notebook server self.session.delete(task) self.session.commit() all_tasks = self.session.query(models.Task).all() try: make_task_deletion_job( task=task, all_tasks=all_tasks, namespace=KF_PIPELINES_NAMESPACE, ) except Exception as e: raise InternalServerError( code="DeletionJobError", message= f"Error while trying to make deletion container job: {e}", ) return schemas.Message(message="Task deleted")
def delete_monitoring(self, uuid): """ Delete a monitoring in our database. Parameters ---------- uuid : str Returns ------- projects.schemas.message.Message """ monitoring = self.session.query(models.Monitoring).get(uuid) if monitoring is None: raise NOT_FOUND self.session.delete(monitoring) self.session.commit() return schemas.Message(message="Monitoring deleted")