mirror of
https://github.com/pacnpal/Pac-cogs.git
synced 2025-12-20 02:41:06 -05:00
fixed
This commit is contained in:
pacnpal
@@ -4,31 +4,68 @@ from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import Dict, Any, Optional
|
||||
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
|
||||
from redbot.core.commands import GroupCog, Context
|
||||
|
||||
from .settings import Settings
|
||||
from .lifecycle import LifecycleManager
|
||||
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 import setup_archiver_commands, setup_database_commands, setup_settings_commands
|
||||
from .events import setup_events
|
||||
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 CogStatus:
|
||||
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"""
|
||||
|
||||
def __init__(self):
|
||||
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, bool] = {}
|
||||
self.health_checks: Dict[str, CogHealthCheck] = {}
|
||||
|
||||
def record_error(self, error: str) -> None:
|
||||
"""Record an error occurrence"""
|
||||
@@ -40,36 +77,70 @@ class CogStatus:
|
||||
self.command_count += 1
|
||||
self.last_command_time = datetime.utcnow()
|
||||
|
||||
def update_health_check(self, check: str, status: bool) -> None:
|
||||
def update_health_check(
|
||||
self,
|
||||
name: str,
|
||||
status: bool,
|
||||
details: Optional[Dict[str, Any]] = None
|
||||
) -> None:
|
||||
"""Update health check status"""
|
||||
self.health_checks[check] = status
|
||||
self.health_checks[name] = CogHealthCheck(
|
||||
name=name,
|
||||
status=status,
|
||||
last_check=datetime.utcnow().isoformat(),
|
||||
details=details
|
||||
)
|
||||
|
||||
def get_status(self) -> Dict[str, Any]:
|
||||
def get_status(self) -> CogStatus:
|
||||
"""Get current status"""
|
||||
return {
|
||||
"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()
|
||||
}
|
||||
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):
|
||||
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"""
|
||||
"""
|
||||
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"""
|
||||
"""
|
||||
Get component status.
|
||||
|
||||
Args:
|
||||
name: Component name
|
||||
|
||||
Returns:
|
||||
Component status dictionary
|
||||
"""
|
||||
return self._component_manager.get_component_status().get(name, {})
|
||||
|
||||
class VideoArchiver(GroupCog, Settings):
|
||||
@@ -85,7 +156,19 @@ class VideoArchiver(GroupCog, Settings):
|
||||
self.lifecycle_manager = LifecycleManager(self)
|
||||
self.component_manager = ComponentManager(self)
|
||||
self.component_accessor = ComponentAccessor(self.component_manager)
|
||||
self.status = CogStatus()
|
||||
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)
|
||||
@@ -93,42 +176,85 @@ class VideoArchiver(GroupCog, Settings):
|
||||
setup_settings_commands(self)
|
||||
|
||||
# Set up events
|
||||
setup_events(self)
|
||||
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"""
|
||||
"""
|
||||
Handle cog loading.
|
||||
|
||||
Raises:
|
||||
CogError: If loading fails
|
||||
"""
|
||||
try:
|
||||
await self.lifecycle_manager.handle_load()
|
||||
await self._start_health_monitoring()
|
||||
except Exception as e:
|
||||
self.status.record_error(str(e))
|
||||
raise
|
||||
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"""
|
||||
"""
|
||||
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:
|
||||
self.status.record_error(str(e))
|
||||
raise
|
||||
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, error):
|
||||
async def cog_command_error(
|
||||
self,
|
||||
ctx: Context,
|
||||
error: Exception
|
||||
) -> None:
|
||||
"""Handle command errors"""
|
||||
self.status.record_error(str(error))
|
||||
self.status_tracker.record_error(str(error))
|
||||
await handle_command_error(ctx, error)
|
||||
|
||||
async def cog_before_invoke(self, ctx) -> bool:
|
||||
async def cog_before_invoke(self, ctx: Context) -> bool:
|
||||
"""Pre-command hook"""
|
||||
self.status.record_command()
|
||||
self.status_tracker.record_command()
|
||||
return True
|
||||
|
||||
async def _start_health_monitoring(self) -> None:
|
||||
"""Start health monitoring tasks"""
|
||||
asyncio.create_task(self._monitor_component_health())
|
||||
asyncio.create_task(self._monitor_system_health())
|
||||
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"""
|
||||
@@ -136,98 +262,134 @@ class VideoArchiver(GroupCog, Settings):
|
||||
try:
|
||||
component_status = self.component_manager.get_component_status()
|
||||
for name, status in component_status.items():
|
||||
self.status.update_health_check(
|
||||
self.status_tracker.update_health_check(
|
||||
f"component_{name}",
|
||||
status["state"] == ComponentState.READY.value
|
||||
status["state"] == ComponentState.READY.name,
|
||||
status
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Error monitoring component health: {e}")
|
||||
await asyncio.sleep(60) # Check every minute
|
||||
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
|
||||
queue_manager = self.queue_manager
|
||||
if queue_manager:
|
||||
if queue_manager := self.queue_manager:
|
||||
queue_status = await queue_manager.get_queue_status()
|
||||
self.status.update_health_check(
|
||||
self.status_tracker.update_health_check(
|
||||
"queue_health",
|
||||
queue_status["active"] and not queue_status["stalled"]
|
||||
queue_status["active"] and not queue_status["stalled"],
|
||||
queue_status
|
||||
)
|
||||
|
||||
# Check processor health
|
||||
processor = self.processor
|
||||
if processor:
|
||||
if processor := self.processor:
|
||||
processor_status = await processor.get_status()
|
||||
self.status.update_health_check(
|
||||
self.status_tracker.update_health_check(
|
||||
"processor_health",
|
||||
processor_status["active"]
|
||||
processor_status["active"],
|
||||
processor_status
|
||||
)
|
||||
|
||||
# Check database health
|
||||
db = self.db
|
||||
if db:
|
||||
if db := self.db:
|
||||
db_status = await db.get_status()
|
||||
self.status.update_health_check(
|
||||
self.status_tracker.update_health_check(
|
||||
"database_health",
|
||||
db_status["connected"]
|
||||
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}")
|
||||
await asyncio.sleep(30) # Check every 30 seconds
|
||||
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:
|
||||
# Perform any custom cleanup
|
||||
pass
|
||||
# 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}")
|
||||
logger.error(f"Error in cleanup handler: {e}", exc_info=True)
|
||||
|
||||
def get_status(self) -> Dict[str, Any]:
|
||||
"""Get comprehensive cog status"""
|
||||
"""
|
||||
Get comprehensive cog status.
|
||||
|
||||
Returns:
|
||||
Dictionary containing cog status information
|
||||
"""
|
||||
return {
|
||||
"cog": self.status.get_status(),
|
||||
"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()
|
||||
"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):
|
||||
def processor(self) -> Optional[Processor]:
|
||||
"""Get the processor component"""
|
||||
return self.component_accessor.get_component("processor")
|
||||
|
||||
@property
|
||||
def queue_manager(self):
|
||||
def queue_manager(self) -> Optional[QueueManager]:
|
||||
"""Get the queue manager component"""
|
||||
return self.component_accessor.get_component("queue_manager")
|
||||
|
||||
@property
|
||||
def config_manager(self):
|
||||
def config_manager(self) -> Optional[ConfigManager]:
|
||||
"""Get the config manager component"""
|
||||
return self.component_accessor.get_component("config_manager")
|
||||
|
||||
@property
|
||||
def ffmpeg_mgr(self):
|
||||
def ffmpeg_mgr(self) -> Optional[FFmpegManager]:
|
||||
"""Get the FFmpeg manager component"""
|
||||
return self.component_accessor.get_component("ffmpeg_mgr")
|
||||
|
||||
@property
|
||||
def db(self):
|
||||
def db(self) -> Optional[VideoArchiveDB]:
|
||||
"""Get the database component"""
|
||||
return self.component_accessor.get_component("db")
|
||||
return self._db
|
||||
|
||||
@db.setter
|
||||
def db(self, value: VideoArchiveDB) -> None:
|
||||
"""Set the database component"""
|
||||
self._db = value
|
||||
|
||||
@property
|
||||
def data_path(self):
|
||||
def data_path(self) -> Optional[Path]:
|
||||
"""Get the data path"""
|
||||
return self.component_accessor.get_component("data_path")
|
||||
|
||||
@property
|
||||
def download_path(self):
|
||||
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
|
||||
|
||||
Reference in New Issue
Block a user