def create_schedule(
project: str,
schedule: schemas.ScheduleInput,
auth_verifier: deps.AuthVerifierDep = Depends(deps.AuthVerifierDep),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.singletons.project_member.get_project_member(
).ensure_project(db_session, project, auth_info=auth_verifier.auth_info)
mlrun.api.utils.clients.opa.Client().query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
schedule.name,
mlrun.api.schemas.AuthorizationAction.create,
auth_verifier.auth_info,
)
get_scheduler().create_schedule(
db_session,
auth_verifier.auth_info,
project,
schedule.name,
schedule.kind,
schedule.scheduled_object,
schedule.cron_trigger,
labels=schedule.labels,
concurrency_limit=schedule.concurrency_limit,
)
return Response(status_code=HTTPStatus.CREATED.value)
def create_schedule(
project: str,
schedule: schemas.ScheduleInput,
auth_info: mlrun.api.schemas.AuthInfo = Depends(
deps.authenticate_request),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.singletons.project_member.get_project_member(
).ensure_project(db_session, project, auth_info=auth_info)
mlrun.api.utils.auth.verifier.AuthVerifier(
).query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
schedule.name,
mlrun.api.schemas.AuthorizationAction.create,
auth_info,
)
if not auth_info.access_key:
auth_info.access_key = schedule.credentials.access_key
get_scheduler().create_schedule(
db_session,
auth_info,
project,
schedule.name,
schedule.kind,
schedule.scheduled_object,
schedule.cron_trigger,
schedule.labels,
schedule.concurrency_limit,
)
return Response(status_code=HTTPStatus.CREATED.value)
def update_schedule(
project: str,
name: str,
schedule: schemas.ScheduleUpdate,
auth_info: mlrun.api.schemas.AuthInfo = Depends(
deps.authenticate_request),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.auth.verifier.AuthVerifier(
).query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
name,
mlrun.api.schemas.AuthorizationAction.update,
auth_info,
)
if not auth_info.access_key:
auth_info.access_key = schedule.credentials.access_key
get_scheduler().update_schedule(
db_session,
auth_info,
project,
name,
schedule.scheduled_object,
schedule.cron_trigger,
labels=schedule.labels,
)
return Response(status_code=HTTPStatus.OK.value)
def delete_schedule(
project: str,
name: str,
db_session: Session = Depends(deps.get_db_session),
):
get_scheduler().delete_schedule(db_session, project, name)
return Response(status_code=HTTPStatus.NO_CONTENT.value)
def _submit_run(db_session: Session, auth_info: mlrun.api.schemas.AuthInfo,
data) -> typing.Tuple[str, str, str, typing.Dict]:
"""
:return: Tuple with:
1. str of the project of the run
2. str of the kind of the function of the run
3. str of the uid of the run that started execution (None when it was scheduled)
4. dict of the response info
"""
run_uid = None
project = None
try:
fn, task = _parse_submit_run_body(db_session, auth_info, data)
run_db = get_run_db_instance(db_session, auth_info.session)
fn.set_db_connection(run_db, True)
logger.info("Submitting run", function=fn.to_dict(), task=task)
# fn.spec.rundb = "http://mlrun-api:8080"
schedule = data.get("schedule")
if schedule:
cron_trigger = schedule
if isinstance(cron_trigger, dict):
cron_trigger = schemas.ScheduleCronTrigger(**cron_trigger)
schedule_labels = task["metadata"].get("labels")
get_scheduler().create_schedule(
db_session,
auth_info,
task["metadata"]["project"],
task["metadata"]["name"],
schemas.ScheduleKinds.job,
data,
cron_trigger,
schedule_labels,
)
project = task["metadata"]["project"]
response = {
"schedule": schedule,
"project": task["metadata"]["project"],
"name": task["metadata"]["name"],
}
else:
run = fn.run(task, watch=False)
run_uid = run.metadata.uid
project = run.metadata.project
if run:
response = run.to_dict()
except HTTPException:
logger.error(traceback.format_exc())
raise
except mlrun.errors.MLRunHTTPStatusError:
raise
except Exception as err:
logger.error(traceback.format_exc())
log_and_raise(HTTPStatus.BAD_REQUEST.value,
reason=f"runtime error: {err}")
logger.info("Run submission succeeded", response=response)
return project, fn.kind, run_uid, {"data": response}
def update_schedule(
project: str,
name: str,
schedule: schemas.ScheduleUpdate,
db_session: Session = Depends(deps.get_db_session),
):
get_scheduler().update_schedule(
db_session,
project,
name,
schedule.scheduled_object,
schedule.cron_trigger,
labels=schedule.labels,
)
return Response(status_code=HTTPStatus.OK.value)
def delete_schedule(
project: str,
name: str,
auth_verifier: deps.AuthVerifierDep = Depends(deps.AuthVerifierDep),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.clients.opa.Client().query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
name,
mlrun.api.schemas.AuthorizationAction.delete,
auth_verifier.auth_info,
)
get_scheduler().delete_schedule(db_session, project, name)
return Response(status_code=HTTPStatus.NO_CONTENT.value)
def create_schedule(
project: str,
schedule: schemas.ScheduleInput,
db_session: Session = Depends(deps.get_db_session),
):
get_scheduler().create_schedule(
db_session,
project,
schedule.name,
schedule.kind,
schedule.scheduled_object,
schedule.cron_trigger,
labels={label.name: label.value for label in schedule.labels},
)
return Response(status_code=HTTPStatus.CREATED.value)
def list_schedules(
project: str,
name: str = None,
labels: str = None,
kind: schemas.ScheduleKinds = None,
include_last_run: bool = False,
auth_verifier: deps.AuthVerifierDep = Depends(deps.AuthVerifierDep),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.clients.opa.Client().query_project_permissions(
project,
mlrun.api.schemas.AuthorizationAction.read,
auth_verifier.auth_info,
)
schedules = get_scheduler().list_schedules(
db_session,
project,
name,
kind,
labels,
include_last_run=include_last_run,
)
filtered_schedules = mlrun.api.utils.clients.opa.Client(
).filter_project_resources_by_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
schedules.schedules,
lambda schedule: (
schedule.project,
schedule.name,
),
auth_verifier.auth_info,
)
schedules.schedules = filtered_schedules
return schedules
def list_schedules(
project: str,
name: str = None,
labels: str = None,
kind: schemas.ScheduleKinds = None,
include_last_run: bool = False,
include_credentials: bool = fastapi.Query(False,
alias="include-credentials"),
auth_info: mlrun.api.schemas.AuthInfo = Depends(
deps.authenticate_request),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.auth.verifier.AuthVerifier().query_project_permissions(
project,
mlrun.api.schemas.AuthorizationAction.read,
auth_info,
)
schedules = get_scheduler().list_schedules(db_session, project, name, kind,
labels, include_last_run,
include_credentials)
filtered_schedules = mlrun.api.utils.auth.verifier.AuthVerifier(
).filter_project_resources_by_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
schedules.schedules,
lambda schedule: (
schedule.project,
schedule.name,
),
auth_info,
)
schedules.schedules = filtered_schedules
return schedules
def get_schedule(
project: str,
name: str,
include_last_run: bool = False,
db_session: Session = Depends(deps.get_db_session),
):
return get_scheduler().get_schedule(
db_session, project, name, include_last_run=include_last_run
)
def create_schedule(
project: str,
schedule: schemas.ScheduleInput,
auth_verifier: deps.AuthVerifier = Depends(deps.AuthVerifier),
db_session: Session = Depends(deps.get_db_session),
):
get_scheduler().create_schedule(
db_session,
auth_verifier.auth_info,
project,
schedule.name,
schedule.kind,
schedule.scheduled_object,
schedule.cron_trigger,
labels=schedule.labels,
concurrency_limit=schedule.concurrency_limit,
)
return Response(status_code=HTTPStatus.CREATED.value)
def list_schedules(
project: str,
name: str = None,
labels: str = None,
kind: schemas.ScheduleKinds = None,
include_last_run: bool = False,
db_session: Session = Depends(deps.get_db_session),
):
return get_scheduler().list_schedules(
db_session, project, name, labels, kind, include_last_run=include_last_run
)
def delete_schedules(
project: str,
auth_info: mlrun.api.schemas.AuthInfo = Depends(
deps.authenticate_request),
db_session: Session = Depends(deps.get_db_session),
):
schedules = get_scheduler().list_schedules(
db_session,
project,
)
mlrun.api.utils.auth.verifier.AuthVerifier(
).query_project_resources_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
schedules.schedules,
lambda schedule: (schedule.project, schedule.name),
mlrun.api.schemas.AuthorizationAction.delete,
auth_info,
)
get_scheduler().delete_schedules(db_session, project)
return Response(status_code=HTTPStatus.NO_CONTENT.value)
def update_schedule(
project: str,
name: str,
schedule: schemas.ScheduleUpdate,
auth_verifier: deps.AuthVerifierDep = Depends(deps.AuthVerifierDep),
db_session: Session = Depends(deps.get_db_session),
):
mlrun.api.utils.clients.opa.Client().query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
name,
mlrun.api.schemas.AuthorizationAction.update,
auth_verifier.auth_info,
)
get_scheduler().update_schedule(
db_session,
auth_verifier.auth_info,
project,
name,
schedule.scheduled_object,
schedule.cron_trigger,
labels=schedule.labels,
)
return Response(status_code=HTTPStatus.OK.value)
def get_schedule(
project: str,
name: str,
include_last_run: bool = False,
auth_verifier: deps.AuthVerifierDep = Depends(deps.AuthVerifierDep),
db_session: Session = Depends(deps.get_db_session),
):
schedule = get_scheduler().get_schedule(
db_session,
project,
name,
include_last_run=include_last_run,
)
mlrun.api.utils.clients.opa.Client().query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
name,
mlrun.api.schemas.AuthorizationAction.read,
auth_verifier.auth_info,
)
return schedule
def get_schedule(
project: str,
name: str,
include_last_run: bool = False,
include_credentials: bool = fastapi.Query(False,
alias="include-credentials"),
auth_info: mlrun.api.schemas.AuthInfo = Depends(
deps.authenticate_request),
db_session: Session = Depends(deps.get_db_session),
):
schedule = get_scheduler().get_schedule(db_session, project, name,
include_last_run,
include_credentials)
mlrun.api.utils.auth.verifier.AuthVerifier(
).query_project_resource_permissions(
mlrun.api.schemas.AuthorizationResourceTypes.schedule,
project,
name,
mlrun.api.schemas.AuthorizationAction.read,
auth_info,
)
return schedule
async def shutdown_event():
if get_project_member():
get_project_member().shutdown()
cancel_all_periodic_functions()
if get_scheduler():
await get_scheduler().stop()
