mirror of
https://github.com/pacnpal/Pac-cogs.git
synced 2025-12-20 10:51:05 -05:00
396 lines
13 KiB
Python
396 lines
13 KiB
Python
"""Base module containing core VideoArchiver class"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from typing import Dict, Any, Optional, TypedDict, ClassVar, List, Set, Union
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
import discord
|
|
from redbot.core.bot import Red
|
|
from redbot.core.commands import GroupCog, Context
|
|
|
|
from .settings import Settings
|
|
from .lifecycle import LifecycleManager, LifecycleState
|
|
from .component_manager import ComponentManager, ComponentState
|
|
from .error_handler import error_manager, handle_command_error
|
|
from .response_handler import response_manager
|
|
from .commands.archiver_commands import setup_archiver_commands
|
|
from .commands.database_commands import setup_database_commands
|
|
from .commands.settings_commands import setup_settings_commands
|
|
from .events import setup_events, EventManager
|
|
|
|
from .processor.core import Processor
|
|
from .queue.manager import QueueManager
|
|
from .ffmpeg.ffmpeg_manager import FFmpegManager
|
|
from .database.video_archive_db import VideoArchiveDB
|
|
from .config_manager import ConfigManager
|
|
from .utils.exceptions import (
|
|
CogError,
|
|
ErrorContext,
|
|
ErrorSeverity
|
|
)
|
|
|
|
logger = logging.getLogger("VideoArchiver")
|
|
|
|
class CogHealthCheck(TypedDict):
|
|
"""Type definition for health check status"""
|
|
name: str
|
|
status: bool
|
|
last_check: str
|
|
details: Optional[Dict[str, Any]]
|
|
|
|
class CogStatus(TypedDict):
|
|
"""Type definition for cog status"""
|
|
uptime: float
|
|
last_error: Optional[str]
|
|
error_count: int
|
|
command_count: int
|
|
last_command: Optional[str]
|
|
health_checks: Dict[str, CogHealthCheck]
|
|
state: str
|
|
ready: bool
|
|
|
|
class StatusTracker:
|
|
"""Tracks cog status and health"""
|
|
|
|
HEALTH_CHECK_INTERVAL: ClassVar[int] = 30 # Seconds between health checks
|
|
ERROR_THRESHOLD: ClassVar[int] = 100 # Maximum errors before health warning
|
|
|
|
def __init__(self) -> None:
|
|
self.start_time = datetime.utcnow()
|
|
self.last_error: Optional[str] = None
|
|
self.error_count = 0
|
|
self.command_count = 0
|
|
self.last_command_time: Optional[datetime] = None
|
|
self.health_checks: Dict[str, CogHealthCheck] = {}
|
|
|
|
def record_error(self, error: str) -> None:
|
|
"""Record an error occurrence"""
|
|
self.last_error = error
|
|
self.error_count += 1
|
|
|
|
def record_command(self) -> None:
|
|
"""Record a command execution"""
|
|
self.command_count += 1
|
|
self.last_command_time = datetime.utcnow()
|
|
|
|
def update_health_check(
|
|
self,
|
|
name: str,
|
|
status: bool,
|
|
details: Optional[Dict[str, Any]] = None
|
|
) -> None:
|
|
"""Update health check status"""
|
|
self.health_checks[name] = CogHealthCheck(
|
|
name=name,
|
|
status=status,
|
|
last_check=datetime.utcnow().isoformat(),
|
|
details=details
|
|
)
|
|
|
|
def get_status(self) -> CogStatus:
|
|
"""Get current status"""
|
|
return CogStatus(
|
|
uptime=(datetime.utcnow() - self.start_time).total_seconds(),
|
|
last_error=self.last_error,
|
|
error_count=self.error_count,
|
|
command_count=self.command_count,
|
|
last_command=self.last_command_time.isoformat() if self.last_command_time else None,
|
|
health_checks=self.health_checks.copy(),
|
|
state="healthy" if self.is_healthy() else "unhealthy",
|
|
ready=True
|
|
)
|
|
|
|
def is_healthy(self) -> bool:
|
|
"""Check if cog is healthy"""
|
|
if self.error_count > self.ERROR_THRESHOLD:
|
|
return False
|
|
return all(check["status"] for check in self.health_checks.values())
|
|
|
|
class ComponentAccessor:
|
|
"""Provides safe access to components"""
|
|
|
|
def __init__(self, component_manager: ComponentManager) -> None:
|
|
self._component_manager = component_manager
|
|
|
|
def get_component(self, name: str) -> Optional[Any]:
|
|
"""
|
|
Get a component with state validation.
|
|
|
|
Args:
|
|
name: Component name
|
|
|
|
Returns:
|
|
Component instance if ready, None otherwise
|
|
"""
|
|
component = self._component_manager.get(name)
|
|
if component and component.state == ComponentState.READY:
|
|
return component
|
|
return None
|
|
|
|
def get_component_status(self, name: str) -> Dict[str, Any]:
|
|
"""
|
|
Get component status.
|
|
|
|
Args:
|
|
name: Component name
|
|
|
|
Returns:
|
|
Component status dictionary
|
|
"""
|
|
return self._component_manager.get_component_status().get(name, {})
|
|
|
|
class VideoArchiver(GroupCog, Settings):
|
|
"""Archive videos from Discord channels"""
|
|
|
|
def __init__(self, bot: Red) -> None:
|
|
"""Initialize the cog with minimal setup"""
|
|
super().__init__()
|
|
self.bot = bot
|
|
self.ready = asyncio.Event()
|
|
|
|
# Initialize managers
|
|
self.lifecycle_manager = LifecycleManager(self)
|
|
self.component_manager = ComponentManager(self)
|
|
self.component_accessor = ComponentAccessor(self.component_manager)
|
|
self.status_tracker = StatusTracker()
|
|
self.event_manager: Optional[EventManager] = None
|
|
|
|
# Initialize task trackers
|
|
self._init_task: Optional[asyncio.Task] = None
|
|
self._cleanup_task: Optional[asyncio.Task] = None
|
|
self._queue_task: Optional[asyncio.Task] = None
|
|
self._health_tasks: Set[asyncio.Task] = set()
|
|
|
|
# Initialize component storage
|
|
self.components: Dict[int, Dict[str, Any]] = {}
|
|
self.update_checker = None
|
|
self._db = None
|
|
|
|
# Set up commands
|
|
setup_archiver_commands(self)
|
|
setup_database_commands(self)
|
|
setup_settings_commands(self)
|
|
|
|
# Set up events
|
|
self.event_manager = setup_events(self)
|
|
|
|
# Register cleanup handlers
|
|
self.lifecycle_manager.register_cleanup_handler(self._cleanup_handler)
|
|
|
|
async def cog_load(self) -> None:
|
|
"""
|
|
Handle cog loading.
|
|
|
|
Raises:
|
|
CogError: If loading fails
|
|
"""
|
|
try:
|
|
await self.lifecycle_manager.handle_load()
|
|
await self._start_health_monitoring()
|
|
except Exception as e:
|
|
error = f"Failed to load cog: {str(e)}"
|
|
self.status_tracker.record_error(error)
|
|
logger.error(error, exc_info=True)
|
|
raise CogError(
|
|
error,
|
|
context=ErrorContext(
|
|
"VideoArchiver",
|
|
"cog_load",
|
|
None,
|
|
ErrorSeverity.CRITICAL
|
|
)
|
|
)
|
|
|
|
async def cog_unload(self) -> None:
|
|
"""
|
|
Handle cog unloading.
|
|
|
|
Raises:
|
|
CogError: If unloading fails
|
|
"""
|
|
try:
|
|
# Cancel health monitoring
|
|
for task in self._health_tasks:
|
|
task.cancel()
|
|
self._health_tasks.clear()
|
|
|
|
await self.lifecycle_manager.handle_unload()
|
|
except Exception as e:
|
|
error = f"Failed to unload cog: {str(e)}"
|
|
self.status_tracker.record_error(error)
|
|
logger.error(error, exc_info=True)
|
|
raise CogError(
|
|
error,
|
|
context=ErrorContext(
|
|
"VideoArchiver",
|
|
"cog_unload",
|
|
None,
|
|
ErrorSeverity.CRITICAL
|
|
)
|
|
)
|
|
|
|
async def cog_command_error(
|
|
self,
|
|
ctx: Context,
|
|
error: Exception
|
|
) -> None:
|
|
"""Handle command errors"""
|
|
self.status_tracker.record_error(str(error))
|
|
await handle_command_error(ctx, error)
|
|
|
|
async def cog_before_invoke(self, ctx: Context) -> bool:
|
|
"""Pre-command hook"""
|
|
self.status_tracker.record_command()
|
|
return True
|
|
|
|
async def _start_health_monitoring(self) -> None:
|
|
"""Start health monitoring tasks"""
|
|
self._health_tasks.add(
|
|
asyncio.create_task(self._monitor_component_health())
|
|
)
|
|
self._health_tasks.add(
|
|
asyncio.create_task(self._monitor_system_health())
|
|
)
|
|
|
|
async def _monitor_component_health(self) -> None:
|
|
"""Monitor component health"""
|
|
while True:
|
|
try:
|
|
component_status = self.component_manager.get_component_status()
|
|
for name, status in component_status.items():
|
|
self.status_tracker.update_health_check(
|
|
f"component_{name}",
|
|
status["state"] == ComponentState.READY.name,
|
|
status
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Error monitoring component health: {e}", exc_info=True)
|
|
await asyncio.sleep(self.status_tracker.HEALTH_CHECK_INTERVAL)
|
|
|
|
async def _monitor_system_health(self) -> None:
|
|
"""Monitor system health metrics"""
|
|
while True:
|
|
try:
|
|
# Check queue health
|
|
if queue_manager := self.queue_manager:
|
|
queue_status = await queue_manager.get_queue_status()
|
|
self.status_tracker.update_health_check(
|
|
"queue_health",
|
|
queue_status["active"] and not queue_status["stalled"],
|
|
queue_status
|
|
)
|
|
|
|
# Check processor health
|
|
if processor := self.processor:
|
|
processor_status = await processor.get_status()
|
|
self.status_tracker.update_health_check(
|
|
"processor_health",
|
|
processor_status["active"],
|
|
processor_status
|
|
)
|
|
|
|
# Check database health
|
|
if db := self.db:
|
|
db_status = await db.get_status()
|
|
self.status_tracker.update_health_check(
|
|
"database_health",
|
|
db_status["connected"],
|
|
db_status
|
|
)
|
|
|
|
# Check event system health
|
|
if self.event_manager:
|
|
event_stats = self.event_manager.get_stats()
|
|
self.status_tracker.update_health_check(
|
|
"event_health",
|
|
event_stats["health"],
|
|
event_stats
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error monitoring system health: {e}", exc_info=True)
|
|
await asyncio.sleep(self.status_tracker.HEALTH_CHECK_INTERVAL)
|
|
|
|
async def _cleanup_handler(self) -> None:
|
|
"""Custom cleanup handler"""
|
|
try:
|
|
# Cancel health monitoring tasks
|
|
for task in self._health_tasks:
|
|
if not task.done():
|
|
task.cancel()
|
|
try:
|
|
await task
|
|
except asyncio.CancelledError:
|
|
pass
|
|
self._health_tasks.clear()
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in cleanup handler: {e}", exc_info=True)
|
|
|
|
def get_status(self) -> Dict[str, Any]:
|
|
"""
|
|
Get comprehensive cog status.
|
|
|
|
Returns:
|
|
Dictionary containing cog status information
|
|
"""
|
|
return {
|
|
"cog": self.status_tracker.get_status(),
|
|
"lifecycle": self.lifecycle_manager.get_status(),
|
|
"components": self.component_manager.get_component_status(),
|
|
"errors": error_manager.tracker.get_error_stats(),
|
|
"events": self.event_manager.get_stats() if self.event_manager else None
|
|
}
|
|
|
|
# Component property accessors
|
|
@property
|
|
def processor(self) -> Optional[Processor]:
|
|
"""Get the processor component"""
|
|
return self.component_accessor.get_component("processor")
|
|
|
|
@property
|
|
def queue_manager(self) -> Optional[QueueManager]:
|
|
"""Get the queue manager component"""
|
|
return self.component_accessor.get_component("queue_manager")
|
|
|
|
@property
|
|
def config_manager(self) -> Optional[ConfigManager]:
|
|
"""Get the config manager component"""
|
|
return self.component_accessor.get_component("config_manager")
|
|
|
|
@property
|
|
def ffmpeg_mgr(self) -> Optional[FFmpegManager]:
|
|
"""Get the FFmpeg manager component"""
|
|
return self.component_accessor.get_component("ffmpeg_mgr")
|
|
|
|
@property
|
|
def db(self) -> Optional[VideoArchiveDB]:
|
|
"""Get the database component"""
|
|
return self._db
|
|
|
|
@db.setter
|
|
def db(self, value: VideoArchiveDB) -> None:
|
|
"""Set the database component"""
|
|
self._db = value
|
|
|
|
@property
|
|
def data_path(self) -> Optional[Path]:
|
|
"""Get the data path"""
|
|
return self.component_accessor.get_component("data_path")
|
|
|
|
@property
|
|
def download_path(self) -> Optional[Path]:
|
|
"""Get the download path"""
|
|
return self.component_accessor.get_component("download_path")
|
|
|
|
@property
|
|
def queue_handler(self):
|
|
"""Get the queue handler from processor"""
|
|
if processor := self.processor:
|
|
return processor.queue_handler
|
|
return None
|