332 lines
9.6 KiB
Python
332 lines
9.6 KiB
Python
import asyncio
|
|
import json
|
|
import logging
|
|
import os
|
|
import time
|
|
from dataclasses import dataclass, field
|
|
from datetime import UTC, datetime
|
|
from typing import Any
|
|
|
|
import httpx
|
|
from aiohttp import web
|
|
|
|
from .config import Config
|
|
from .Emitter import Emitter
|
|
from .encoder import Encoder
|
|
from .EventsSubscriber import Event, Events, EventsSubscriber
|
|
from .Scheduler import Scheduler
|
|
from .Singleton import Singleton
|
|
|
|
LOG = logging.getLogger("tasks")
|
|
|
|
|
|
@dataclass(kw_only=True)
|
|
class Task:
|
|
id: str
|
|
name: str
|
|
url: str
|
|
folder: str = ""
|
|
preset: str = ""
|
|
timer: str = ""
|
|
template: str = ""
|
|
cookies: str = ""
|
|
config: dict[str, str] = field(default_factory=dict)
|
|
|
|
def serialize(self) -> dict:
|
|
return self.__dict__
|
|
|
|
def json(self) -> str:
|
|
return Encoder().encode(self.serialize())
|
|
|
|
def get(self, key: str, default: Any = None) -> Any:
|
|
return self.serialize().get(key, default)
|
|
|
|
|
|
class Tasks(metaclass=Singleton):
|
|
"""
|
|
This class is used to manage the tasks.
|
|
"""
|
|
|
|
_tasks: list[Task] = []
|
|
"""The tasks."""
|
|
|
|
_instance = None
|
|
"""The instance of the Tasks."""
|
|
|
|
def __init__(
|
|
self,
|
|
file: str | None = None,
|
|
emitter: Emitter | None = None,
|
|
loop: asyncio.AbstractEventLoop | None = None,
|
|
config: Config | None = None,
|
|
encoder: Encoder | None = None,
|
|
client: httpx.AsyncClient | None = None,
|
|
scheduler: Scheduler | None = None,
|
|
):
|
|
Tasks._instance = self
|
|
|
|
config = config or Config.get_instance()
|
|
|
|
self._debug = config.debug
|
|
self._default_preset = config.default_preset
|
|
self._file = file or os.path.join(config.config_path, "tasks.json")
|
|
self._client = client or httpx.AsyncClient()
|
|
self._encoder = encoder or Encoder()
|
|
self._loop = loop or asyncio.get_event_loop()
|
|
self._emitter = emitter or Emitter.get_instance()
|
|
self._scheduler = scheduler or Scheduler.get_instance()
|
|
|
|
if os.path.exists(self._file) and "600" != oct(os.stat(self._file).st_mode)[-3:]:
|
|
try:
|
|
os.chmod(self._file, 0o600)
|
|
except Exception:
|
|
pass
|
|
|
|
def handle_event(_, e: Event):
|
|
self.save(**e.data)
|
|
|
|
EventsSubscriber.get_instance().subscribe(Events.TASKS_ADD, f"{__class__}.save", handle_event)
|
|
|
|
@staticmethod
|
|
def get_instance() -> "Tasks":
|
|
"""
|
|
Get the instance of the class.
|
|
|
|
Returns:
|
|
Tasks: The instance of the class.
|
|
|
|
"""
|
|
if not Tasks._instance:
|
|
Tasks._instance = Tasks()
|
|
|
|
return Tasks._instance
|
|
|
|
async def on_shutdown(self, _: web.Application):
|
|
pass
|
|
|
|
def attach(self, _: web.Application):
|
|
"""
|
|
Attach the tasks to the aiohttp application.
|
|
|
|
Args:
|
|
_ (web.Application): The aiohttp application.
|
|
|
|
"""
|
|
self.load()
|
|
|
|
def get_all(self) -> list[Task]:
|
|
"""Return the tasks."""
|
|
return self._tasks
|
|
|
|
def load(self) -> "Tasks":
|
|
"""
|
|
Load the tasks.
|
|
|
|
Returns:
|
|
Tasks: The current instance.
|
|
|
|
"""
|
|
self.clear()
|
|
|
|
if not os.path.exists(self._file) or os.path.getsize(self._file) < 10:
|
|
return self
|
|
|
|
LOG.info(f"Loading tasks from '{self._file}'.")
|
|
try:
|
|
with open(self._file) as f:
|
|
tasks = json.load(f)
|
|
except Exception as e:
|
|
LOG.error(f"Failed to parse tasks from '{self._file}'. '{e}'.")
|
|
return self
|
|
|
|
if not tasks or len(tasks) < 1:
|
|
LOG.info(f"No tasks were defined in '{self._file}'.")
|
|
return self
|
|
|
|
for i, task in enumerate(tasks):
|
|
try:
|
|
task = Task(**task)
|
|
except Exception as e:
|
|
LOG.error(f"Failed to parse task at list position '{i}'. '{e!s}'.")
|
|
continue
|
|
|
|
try:
|
|
self._scheduler.add(timer=task.timer, func=self._runner, args=(task,), id=task.id)
|
|
self._tasks.append(task)
|
|
|
|
LOG.info(f"Task '{i}: {task.name}' queued to be executed every '{task.timer}'.")
|
|
except Exception as e:
|
|
LOG.exception(e)
|
|
LOG.error(f"Failed to queue task '{i}: {task.name}'. '{e!s}'.")
|
|
|
|
return self
|
|
|
|
def clear(self, shutdown: bool = False) -> "Tasks":
|
|
"""
|
|
Clear all tasks.
|
|
|
|
Returns:
|
|
Tasks: The current instance.
|
|
|
|
"""
|
|
if len(self._tasks) < 1:
|
|
return self
|
|
|
|
for task in self._tasks:
|
|
try:
|
|
LOG.info(f"Stopping task '{task.id}: {task.name}'.")
|
|
self._scheduler.remove(task.id)
|
|
except Exception as e:
|
|
if not shutdown:
|
|
LOG.exception(e)
|
|
LOG.error(f"Failed to stop task '{task.id}: {task.name}'. '{e!s}'.")
|
|
|
|
self._tasks.clear()
|
|
|
|
return self
|
|
|
|
def validate(self, task: Task | dict) -> bool:
|
|
"""
|
|
Validate the task.
|
|
|
|
Args:
|
|
task (Task|dict): The task to validate.
|
|
|
|
Returns:
|
|
bool: True if the task is valid, False otherwise.
|
|
|
|
"""
|
|
if not isinstance(task, dict):
|
|
if not isinstance(task, Task):
|
|
msg = "Invalid task type."
|
|
raise ValueError(msg) # noqa: TRY004
|
|
|
|
task = task.serialize()
|
|
|
|
if not task.get("name"):
|
|
msg = "No name found."
|
|
raise ValueError(msg)
|
|
|
|
if not task.get("timer"):
|
|
msg = "No timer found."
|
|
raise ValueError(msg)
|
|
|
|
if not task.get("url"):
|
|
msg = "No URL found."
|
|
raise ValueError(msg)
|
|
|
|
if not isinstance(task.get("cookies"), str):
|
|
msg = "Invalid cookies type."
|
|
raise ValueError(msg) # noqa: TRY004
|
|
|
|
if not isinstance(task.get("config"), dict):
|
|
msg = "Invalid config type."
|
|
raise ValueError(msg) # noqa: TRY004
|
|
|
|
if not isinstance(task.get("template"), str):
|
|
msg = "Invalid template type."
|
|
raise ValueError(msg) # noqa: TRY004
|
|
|
|
return True
|
|
|
|
def save(self, tasks: list[Task | dict]) -> "Tasks":
|
|
"""
|
|
Save the tasks.
|
|
|
|
Args:
|
|
tasks (list[Task]): The tasks to save.
|
|
|
|
Returns:
|
|
Tasks: The current instance.
|
|
|
|
"""
|
|
for i, task in enumerate(tasks):
|
|
try:
|
|
if not isinstance(task, Task):
|
|
task = Task(**task)
|
|
tasks[i] = task
|
|
except Exception as e:
|
|
LOG.error(f"Failed to save task '{i}' unable to parse task. '{e!s}'.")
|
|
continue
|
|
|
|
try:
|
|
self.validate(task)
|
|
except ValueError as e:
|
|
LOG.error(f"Failed to add task '{i}: {task.name}'. '{e}'.")
|
|
continue
|
|
|
|
try:
|
|
with open(self._file, "w") as f:
|
|
json.dump(obj=[task.serialize() for task in tasks], fp=f, indent=4)
|
|
|
|
LOG.info(f"Tasks saved to '{self._file}'.")
|
|
except Exception as e:
|
|
LOG.error(f"Failed to save tasks to '{self._file}'. '{e!s}'.")
|
|
|
|
return self
|
|
|
|
async def _runner(self, task: Task):
|
|
"""
|
|
Run the task.
|
|
|
|
Args:
|
|
task (Task): The task to run.
|
|
|
|
Returns:
|
|
None
|
|
|
|
"""
|
|
try:
|
|
timeNow = datetime.now(UTC).isoformat()
|
|
started = time.time()
|
|
if not task.url:
|
|
LOG.error(f"Failed to dispatch task '{task.id}: {task.name}'. No URL found.")
|
|
return
|
|
|
|
preset: str = str(task.preset or self._default_preset)
|
|
folder: str = task.folder if task.folder else ""
|
|
cookies: str = str(task.cookies) if task.cookies else ""
|
|
template: str = task.template if task.template else ""
|
|
|
|
config = task.config if task.config else {}
|
|
if isinstance(config, str) and config:
|
|
try:
|
|
config = json.loads(config)
|
|
except Exception as e:
|
|
LOG.error(f"Failed to parse json yt-dlp config for '{task.name}'. {e!s}")
|
|
return
|
|
|
|
LOG.info(f"Task '{task.id}: {task.name}' dispatched at '{timeNow}'.")
|
|
|
|
tasks = []
|
|
tasks.append(self._emitter.info(f"Task '{task.name}' dispatched at '{timeNow}'."))
|
|
tasks.append(
|
|
self._emitter.emit(
|
|
event=Events.ADD_URL,
|
|
data=Event(
|
|
id=task.id,
|
|
data={
|
|
"url": task.url,
|
|
"preset": preset,
|
|
"folder": folder,
|
|
"cookies": cookies,
|
|
"config": config,
|
|
"template": template,
|
|
},
|
|
),
|
|
local=True,
|
|
)
|
|
)
|
|
|
|
await asyncio.wait_for(asyncio.gather(*tasks), timeout=None)
|
|
|
|
timeNow = datetime.now(UTC).isoformat()
|
|
|
|
ended = time.time()
|
|
LOG.info(f"Task '{task.id}: {task.name}' completed at '{timeNow}' took '{ended - started:.2f}' seconds.")
|
|
|
|
await self._emitter.success(f"Task '{task.name}' completed in '{ended - started:.2f}' seconds.")
|
|
except Exception as e:
|
|
timeNow = datetime.now(UTC).isoformat()
|
|
LOG.error(f"Task '{task.id}: {task.name}' has failed to execute at '{timeNow}'. '{e!s}'.")
|
|
await self._emitter.error(f"Task '{task.name}' failed to execute at '{timeNow}'. '{e!s}'.")
|