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")