ddeutil-workflow 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

ddeutil/workflow/route.py

@@ -5,57 +5,89 @@
 # ------------------------------------------------------------------------------
 from __future__ import annotations
 
+import copy
+import os
+from datetime import datetime, timedelta
+from typing import Any
+from zoneinfo import ZoneInfo
+
 from fastapi import APIRouter, HTTPException, Request
 from fastapi import status as st
 from fastapi.responses import UJSONResponse
+from pydantic import BaseModel
 
+from . import Workflow
 from .__types import DictData
 from .log import get_logger
-from .pipeline import Pipeline
-from .repeat import repeat_every
-from .utils import Loader
+from .scheduler import Schedule
+from .utils import Loader, Result
 
 logger = get_logger("ddeutil.workflow")
 workflow = APIRouter(
-    prefix="/workflow",
+    prefix="/api/workflow",
     tags=["workflow"],
+    default_response_class=UJSONResponse,
 )
 schedule = APIRouter(
-    prefix="/schedule",
+    prefix="/api/schedule",
     tags=["schedule"],
+    default_response_class=UJSONResponse,
 )
 
+ListDate = list[datetime]
 
-@workflow.get(
-    "/",
-    response_class=UJSONResponse,
-    status_code=st.HTTP_200_OK,
-)
+
+@workflow.get("/")
 async def get_workflows():
-    """Return all pipeline workflows that exists in config path."""
-    pipelines: DictData = Loader.finds(Pipeline)
+    """Return all workflow workflows that exists in config path."""
+    workflows: DictData = Loader.finds(Workflow)
     return {
-        "message": f"getting all pipelines: {pipelines}",
+        "message": f"getting all workflows: {workflows}",
     }
 
 
-@workflow.get(
-    "/{name}",
-    response_class=UJSONResponse,
-    status_code=st.HTTP_200_OK,
-)
+@workflow.get("/{name}")
 async def get_workflow(name: str) -> DictData:
-    """Return model of pipeline that passing an input pipeline name."""
+    """Return model of workflow that passing an input workflow name."""
+    try:
+        wf: Workflow = Workflow.from_loader(name=name, externals={})
+    except ValueError as err:
+        logger.exception(err)
+        raise HTTPException(
+            status_code=st.HTTP_404_NOT_FOUND,
+            detail=(
+                f"Workflow workflow name: {name!r} does not found in /conf path"
+            ),
+        ) from None
+    return wf.model_dump(
+        by_alias=True,
+        exclude_none=True,
+        exclude_unset=True,
+        exclude_defaults=True,
+    )
+
+
+class ExecutePayload(BaseModel):
+    params: dict[str, Any]
+
+
+@workflow.post("/{name}/execute", status_code=st.HTTP_202_ACCEPTED)
+async def execute_workflow(name: str, payload: ExecutePayload) -> DictData:
+    """Return model of workflow that passing an input workflow name."""
     try:
-        pipeline: Pipeline = Pipeline.from_loader(name=name, externals={})
+        wf: Workflow = Workflow.from_loader(name=name, externals={})
     except ValueError:
         raise HTTPException(
             status_code=st.HTTP_404_NOT_FOUND,
             detail=(
-                f"Workflow pipeline name: {name!r} does not found in /conf path"
+                f"Workflow workflow name: {name!r} does not found in /conf path"
             ),
         ) from None
-    return pipeline.model_dump(
+
+    # NOTE: Start execute manually
+    rs: Result = wf.execute(params=payload.params)
+
+    return rs.model_dump(
         by_alias=True,
         exclude_none=True,
         exclude_unset=True,
@@ -65,28 +97,125 @@ async def get_workflow(name: str) -> DictData:
 
 @workflow.get("/{name}/logs")
 async def get_workflow_logs(name: str):
-    return {"message": f"getting pipeline {name} logs"}
+    return {"message": f"getting workflow {name!r} logs"}
 
 
 @workflow.get("/{name}/logs/{release}")
 async def get_workflow_release_log(name: str, release: str):
-    return {"message": f"getting pipeline {name} log in release {release}"}
+    return {"message": f"getting workflow {name!r} log in release {release}"}
 
 
-@workflow.delete(
-    "/{name}/logs/{release}",
-    status_code=st.HTTP_204_NO_CONTENT,
-)
+@workflow.delete("/{name}/logs/{release}", status_code=st.HTTP_204_NO_CONTENT)
 async def del_workflow_release_log(name: str, release: str):
-    return {"message": f"getting pipeline {name} log in release {release}"}
+    return {"message": f"deleted workflow {name!r} log in release {release}"}
+
+
+@schedule.get("/{name}")
+async def get_schedule(name: str):
+    try:
+        sch: Schedule = Schedule.from_loader(name=name, externals={})
+    except ValueError:
+        raise HTTPException(
+            status_code=st.HTTP_404_NOT_FOUND,
+            detail=f"Schedule name: {name!r} does not found in /conf path",
+        ) from None
+    return sch.model_dump(
+        by_alias=True,
+        exclude_none=True,
+        exclude_unset=True,
+        exclude_defaults=True,
+    )
+
+
+@schedule.get("/deploy")
+async def get_deploy_schedulers(request: Request):
+    snapshot = copy.deepcopy(request.state.scheduler)
+    return {"schedule": snapshot}
+
+
+@schedule.get("/deploy/{name}")
+async def get_deploy_scheduler(request: Request, name: str):
+    if name in request.state.scheduler:
+        sch = Schedule.from_loader(name)
+        getter: list[dict[str, dict[str, list[datetime]]]] = []
+        for wf in sch.workflows:
+            getter.append(
+                {
+                    wf.name: {
+                        "queue": copy.deepcopy(
+                            request.state.workflow_queue[wf.name]
+                        ),
+                        "running": copy.deepcopy(
+                            request.state.workflow_running[wf.name]
+                        ),
+                    }
+                }
+            )
+        return {
+            "message": f"getting {name!r} to schedule listener.",
+            "scheduler": getter,
+        }
+    raise HTTPException(
+        status_code=st.HTTP_404_NOT_FOUND,
+        detail=f"Does not found {name!r} in schedule listener",
+    )
+
+
+@schedule.post("/deploy/{name}")
+async def add_deploy_scheduler(request: Request, name: str):
+    """Adding schedule name to application state store."""
+    if name in request.state.scheduler:
+        raise HTTPException(
+            status_code=st.HTTP_302_FOUND,
+            detail="This schedule already exists in scheduler list.",
+        )
 
+    request.state.scheduler.append(name)
 
-@schedule.on_event("startup")
-@repeat_every(seconds=60)
-def schedule_broker_up():
-    logger.info("Start listening schedule from queue ...")
+    tz: ZoneInfo = ZoneInfo(os.getenv("WORKFLOW_CORE_TIMEZONE", "UTC"))
+    start_date: datetime = datetime.now(tz=tz)
+    start_date_waiting: datetime = (start_date + timedelta(minutes=1)).replace(
+        second=0, microsecond=0
+    )
 
+    # NOTE: Create pair of workflow and on from schedule model.
+    try:
+        sch = Schedule.from_loader(name)
+    except ValueError as e:
+        request.state.scheduler.remove(name)
+        logger.exception(e)
+        raise HTTPException(
+            status_code=st.HTTP_404_NOT_FOUND,
+            detail=str(e),
+        ) from None
+    request.state.workflow_tasks.extend(
+        sch.tasks(
+            start_date_waiting,
+            queue=request.state.workflow_queue,
+            running=request.state.workflow_running,
+        ),
+    )
+    return {"message": f"adding {name!r} to schedule listener."}
 
-@schedule.get("/", response_class=UJSONResponse)
-async def get_jobs(request: Request):
-    return {}
+
+@schedule.delete("/deploy/{name}")
+async def del_deploy_scheduler(request: Request, name: str):
+    if name in request.state.scheduler:
+        request.state.scheduler.remove(name)
+        sche = Schedule.from_loader(name)
+        for workflow_task in sche.tasks(datetime.now(), {}, {}):
+            request.state.workflow_tasks.remove(workflow_task)
+
+        for wf in sche.workflows:
+            if wf in request.state.workflow_queue:
+                request.state.workflow_queue.pop(wf, {})
+
+            if wf in request.state.workflow_running:
+                request.state.workflow_running.pop(wf, {})
+
+        return {"message": f"deleted {name!r} to schedule listener."}
+
+    raise HTTPException(
+        status_code=st.HTTP_404_NOT_FOUND,
+        detail=f"Does not found {name!r} in schedule listener",
+    )