Add source
This commit is contained in:
694
bot/modules/task_scheduler/executor.py
Normal file
694
bot/modules/task_scheduler/executor.py
Normal file
@@ -0,0 +1,694 @@
|
||||
"""
|
||||
Task executor
|
||||
"""
|
||||
import asyncio
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from bot.modules.task_scheduler.queue import task_queue, Task, TaskStatus
|
||||
from bot.modules.media_loader.ytdlp import download_media
|
||||
from bot.modules.media_loader.sender import send_file_to_user, delete_file
|
||||
from bot.modules.message_handler.filters import is_youtube_url, is_instagram_url
|
||||
from pyrogram import Client
|
||||
from typing import Optional
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Global client for sending messages
|
||||
# Protected by threading.Lock for thread-safe access from different threads
|
||||
_app_client: Optional[Client] = None
|
||||
_app_client_lock = threading.Lock()
|
||||
|
||||
# Dictionary to store message_id for tasks to update messages
|
||||
# Format: {task_id: message_id}
|
||||
# Use size limit to prevent memory leaks
|
||||
_task_messages: dict[int, int] = {}
|
||||
_task_messages_lock = threading.Lock()
|
||||
_MAX_TASK_MESSAGES = 10000 # Maximum number of records
|
||||
|
||||
|
||||
def set_app_client(client: Client) -> None:
|
||||
"""
|
||||
Set client for sending messages (thread-safe)
|
||||
|
||||
Args:
|
||||
client: Pyrogram client for sending messages
|
||||
"""
|
||||
global _app_client
|
||||
with _app_client_lock:
|
||||
_app_client = client
|
||||
|
||||
|
||||
def get_app_client() -> Optional[Client]:
|
||||
"""Get client for sending messages (thread-safe)"""
|
||||
global _app_client
|
||||
with _app_client_lock:
|
||||
return _app_client
|
||||
|
||||
|
||||
def set_task_message(task_id: int, message_id: int) -> None:
|
||||
"""
|
||||
Save message_id for task (thread-safe)
|
||||
|
||||
Args:
|
||||
task_id: Task ID
|
||||
message_id: Telegram message ID
|
||||
"""
|
||||
global _task_messages
|
||||
with _task_messages_lock:
|
||||
# Clear old records if limit reached
|
||||
if len(_task_messages) >= _MAX_TASK_MESSAGES:
|
||||
# Remove 10% of oldest records (FIFO)
|
||||
keys_to_remove = list(_task_messages.keys())[:_MAX_TASK_MESSAGES // 10]
|
||||
for key in keys_to_remove:
|
||||
_task_messages.pop(key, None)
|
||||
logger.debug(f"Cleared {len(keys_to_remove)} old records from _task_messages")
|
||||
_task_messages[task_id] = message_id
|
||||
|
||||
|
||||
def get_task_message(task_id: int) -> Optional[int]:
|
||||
"""Get message_id for task (thread-safe)"""
|
||||
global _task_messages
|
||||
with _task_messages_lock:
|
||||
return _task_messages.get(task_id)
|
||||
|
||||
|
||||
def clear_task_message(task_id: int) -> None:
|
||||
"""
|
||||
Remove message_id for task (thread-safe)
|
||||
|
||||
Args:
|
||||
task_id: Task ID
|
||||
"""
|
||||
global _task_messages
|
||||
with _task_messages_lock:
|
||||
_task_messages.pop(task_id, None)
|
||||
|
||||
|
||||
async def cleanup_completed_task_messages():
|
||||
"""
|
||||
Periodic cleanup of message_id for completed tasks
|
||||
Runs in background every 30 minutes
|
||||
"""
|
||||
while True:
|
||||
try:
|
||||
await asyncio.sleep(30 * 60) # 30 minutes
|
||||
from bot.modules.task_scheduler.queue import task_queue, TaskStatus
|
||||
|
||||
# Get all completed tasks
|
||||
all_tasks = await task_queue.get_all_tasks()
|
||||
completed_task_ids = [
|
||||
task.id for task in all_tasks
|
||||
if task.status in [TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED]
|
||||
]
|
||||
|
||||
# Remove message_id for completed tasks
|
||||
with _task_messages_lock:
|
||||
removed_count = 0
|
||||
for task_id in completed_task_ids:
|
||||
if task_id in _task_messages:
|
||||
del _task_messages[task_id]
|
||||
removed_count += 1
|
||||
|
||||
if removed_count > 0:
|
||||
logger.debug(f"Cleared {removed_count} message_id for completed tasks")
|
||||
except asyncio.CancelledError:
|
||||
logger.info("Message ID cleanup task stopped")
|
||||
break
|
||||
except Exception as e:
|
||||
logger.error(f"Error cleaning up message_id: {e}", exc_info=True)
|
||||
|
||||
|
||||
class TaskExecutor:
|
||||
"""Task executor"""
|
||||
|
||||
def __init__(self):
|
||||
self._running = False
|
||||
self._workers: list[asyncio.Task] = []
|
||||
self._running_lock = asyncio.Lock() # Protection for _running flag
|
||||
|
||||
async def start(self, num_workers: int = 2):
|
||||
"""
|
||||
Start task executor
|
||||
|
||||
Args:
|
||||
num_workers: Number of workers (default 2 for parallel processing)
|
||||
"""
|
||||
async with self._running_lock:
|
||||
if self._running:
|
||||
logger.warning("Task executor already running")
|
||||
return
|
||||
|
||||
self._running = True
|
||||
logger.info(f"Starting task executor with {num_workers} workers")
|
||||
|
||||
# Create workers (each works independently)
|
||||
for i in range(num_workers):
|
||||
worker = asyncio.create_task(self._worker(f"worker-{i+1}"))
|
||||
self._workers.append(worker)
|
||||
# Small delay between worker starts for even load distribution
|
||||
await asyncio.sleep(0.1)
|
||||
|
||||
# Start background task for cleaning message_id for completed tasks
|
||||
cleanup_task = asyncio.create_task(cleanup_completed_task_messages())
|
||||
self._workers.append(cleanup_task)
|
||||
logger.info("Started background task for cleaning message_id for completed tasks")
|
||||
|
||||
async def stop(self):
|
||||
"""Stop task executor"""
|
||||
async with self._running_lock:
|
||||
if not self._running:
|
||||
return
|
||||
|
||||
self._running = False
|
||||
logger.info("Stopping task executor...")
|
||||
|
||||
# Cancel all active tasks
|
||||
# Get all tasks and cancel active ones
|
||||
all_tasks = await task_queue.get_all_tasks()
|
||||
for task in all_tasks:
|
||||
if task.status == TaskStatus.PROCESSING:
|
||||
logger.info(f"Cancelling active task {task.id} on shutdown")
|
||||
await task_queue.update_task_status(task.id, TaskStatus.CANCELLED, error="Bot shutdown")
|
||||
cancel_event = task_queue.get_cancel_event(task.id)
|
||||
cancel_event.set()
|
||||
|
||||
# Wait for all workers to complete
|
||||
await asyncio.gather(*self._workers, return_exceptions=True)
|
||||
self._workers.clear()
|
||||
logger.info("Task executor stopped")
|
||||
|
||||
async def _worker(self, name: str):
|
||||
"""Worker for processing tasks (runs in parallel with other workers)"""
|
||||
logger.info(f"Worker {name} started")
|
||||
|
||||
while True:
|
||||
# Check state with lock protection
|
||||
async with self._running_lock:
|
||||
if not self._running:
|
||||
break
|
||||
try:
|
||||
# Get task from queue (non-blocking)
|
||||
task = await task_queue.get_task()
|
||||
|
||||
if not task:
|
||||
# No tasks, small delay
|
||||
await asyncio.sleep(0.5)
|
||||
continue
|
||||
|
||||
# Check for cancellation before starting processing
|
||||
current_task = await task_queue.get_task_by_id(task.id)
|
||||
if current_task and current_task.status == TaskStatus.CANCELLED:
|
||||
logger.info(f"Task {task.id} was cancelled, skipping")
|
||||
continue
|
||||
|
||||
# Update status
|
||||
await task_queue.update_task_status(task.id, TaskStatus.PROCESSING)
|
||||
|
||||
logger.info(f"Worker {name} processing task {task.id}")
|
||||
|
||||
# Execute task (doesn't block other workers and message processing)
|
||||
# Each task executes independently
|
||||
await self._execute_task(task)
|
||||
|
||||
except asyncio.CancelledError:
|
||||
logger.info(f"Worker {name} stopped")
|
||||
break
|
||||
except Exception as e:
|
||||
logger.error(f"Error in worker {name}: {e}", exc_info=True)
|
||||
await asyncio.sleep(1)
|
||||
|
||||
logger.info(f"Worker {name} finished")
|
||||
|
||||
async def _execute_task(self, task: Task):
|
||||
"""
|
||||
Execute task
|
||||
|
||||
Args:
|
||||
task: Task to execute
|
||||
"""
|
||||
try:
|
||||
if task.task_type == "download" and task.url:
|
||||
# Determine download type
|
||||
if is_youtube_url(task.url) or is_instagram_url(task.url) or any(
|
||||
domain in task.url.lower()
|
||||
for domain in ['youtube.com', 'youtu.be', 'instagram.com', 'tiktok.com', 'twitter.com', 'x.com']
|
||||
):
|
||||
# Download via yt-dlp
|
||||
await self._download_with_ytdlp(task)
|
||||
else:
|
||||
# Direct download (to be implemented later)
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error="Direct download not supported yet"
|
||||
)
|
||||
else:
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error="Unknown task type or missing URL"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error executing task {task.id}: {e}", exc_info=True)
|
||||
|
||||
# Form user-friendly error message
|
||||
error_message = str(e)
|
||||
if "login required" in error_message.lower() or "cookies" in error_message.lower():
|
||||
error_message = (
|
||||
"❌ Authentication required to download this content.\n\n"
|
||||
"💡 Solution: configure cookies in bot configuration.\n"
|
||||
"See instructions in README.md"
|
||||
)
|
||||
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=error_message
|
||||
)
|
||||
|
||||
# Send message to user
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Download error:\n{error_message}"
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send error message to user {task.user_id}: {e}", exc_info=True)
|
||||
|
||||
async def _download_with_ytdlp(self, task: Task):
|
||||
"""Download via yt-dlp"""
|
||||
# Get cancellation event for this task
|
||||
cancel_event = task_queue.get_cancel_event(task.id)
|
||||
|
||||
try:
|
||||
# Check for cancellation
|
||||
current_task = await task_queue.get_task_by_id(task.id)
|
||||
if current_task and current_task.status == TaskStatus.CANCELLED:
|
||||
logger.info(f"Task {task.id} cancelled, stopping download")
|
||||
task_queue.clear_cancel_event(task.id)
|
||||
return
|
||||
|
||||
# Get media information to check limits
|
||||
from bot.modules.media_loader.ytdlp import get_media_info
|
||||
from shared.config import settings
|
||||
|
||||
media_info = await get_media_info(task.url, cookies_file=settings.COOKIES_FILE)
|
||||
if media_info:
|
||||
# Check duration
|
||||
max_duration = settings.max_duration_minutes_int
|
||||
if max_duration and media_info.get('duration'):
|
||||
duration_minutes = media_info['duration'] / 60
|
||||
if duration_minutes > max_duration:
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=f"Maximum duration exceeded ({max_duration} min)"
|
||||
)
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ File too long ({duration_minutes:.1f} min). "
|
||||
f"Maximum: {max_duration} min."
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send duration exceeded message to user {task.user_id}: {e}", exc_info=True)
|
||||
return
|
||||
|
||||
# Function for updating progress with cancellation check
|
||||
# This function is called from another thread (yt-dlp), so we use run_coroutine_threadsafe
|
||||
async def update_progress(percent: int):
|
||||
# Check cancellation when updating progress
|
||||
if cancel_event.is_set():
|
||||
raise asyncio.CancelledError("Task cancelled by user")
|
||||
current_task = await task_queue.get_task_by_id(task.id)
|
||||
if current_task and current_task.status == TaskStatus.CANCELLED:
|
||||
raise asyncio.CancelledError("Task cancelled by user")
|
||||
await task_queue.update_task_status(task.id, TaskStatus.PROCESSING, progress=percent)
|
||||
|
||||
# Update progress message
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
try:
|
||||
from pyrogram.errors import MessageNotModified
|
||||
status_text = (
|
||||
f"📥 **Downloading file**\n\n"
|
||||
f"🔗 {task.url[:50]}...\n"
|
||||
f"📊 Progress: **{percent}%**\n"
|
||||
f"⏳ Please wait..."
|
||||
)
|
||||
try:
|
||||
await app_client.edit_message_text(
|
||||
chat_id=task.user_id,
|
||||
message_id=message_id,
|
||||
text=status_text
|
||||
)
|
||||
except MessageNotModified:
|
||||
pass # Ignore if text didn't change
|
||||
except Exception as e:
|
||||
logger.debug(f"Failed to update message: {e}")
|
||||
|
||||
# Save reference to event loop for use in progress hook
|
||||
progress_loop = asyncio.get_event_loop()
|
||||
|
||||
# Send one message about download start (will be updated)
|
||||
app_client = get_app_client()
|
||||
status_message = None
|
||||
if app_client:
|
||||
try:
|
||||
status_text = (
|
||||
f"📥 **Downloading file**\n\n"
|
||||
f"🔗 {task.url[:50]}...\n"
|
||||
f"📊 Progress: **0%**\n"
|
||||
f"⏳ Please wait..."
|
||||
)
|
||||
status_message = await app_client.send_message(
|
||||
task.user_id,
|
||||
status_text
|
||||
)
|
||||
# Save message_id for updates
|
||||
set_task_message(task.id, status_message.id)
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to send notification: {e}")
|
||||
|
||||
# Download media
|
||||
try:
|
||||
logger.info(f"Starting download for task {task.id}, URL: {task.url}")
|
||||
result = await download_media(
|
||||
url=task.url,
|
||||
output_dir="downloads",
|
||||
quality="best",
|
||||
progress_callback=update_progress,
|
||||
cookies_file=settings.COOKIES_FILE,
|
||||
cancel_event=cancel_event,
|
||||
task_id=task.id
|
||||
)
|
||||
|
||||
logger.info(f"Download completed for task {task.id}. Result: {result is not None}, file_path: {result.get('file_path') if result else None}")
|
||||
|
||||
# Save file path to database
|
||||
if result and result.get('file_path'):
|
||||
await task_queue.update_task_file_path(task.id, result['file_path'])
|
||||
logger.info(f"File path saved to DB: {result['file_path']}")
|
||||
|
||||
# Check file size after download
|
||||
max_file_size = settings.max_file_size_bytes
|
||||
if result and max_file_size:
|
||||
file_size = result.get('size', 0)
|
||||
if file_size > max_file_size:
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=f"Maximum file size exceeded ({max_file_size / (1024*1024):.1f} MB)"
|
||||
)
|
||||
# Delete file
|
||||
if result.get('file_path'):
|
||||
await delete_file(result['file_path'])
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ File too large ({file_size / (1024*1024):.1f} MB). "
|
||||
f"Maximum: {max_file_size / (1024*1024):.1f} MB."
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send file size exceeded message to user {task.user_id}: {e}", exc_info=True)
|
||||
clear_task_message(task.id)
|
||||
return
|
||||
except (asyncio.CancelledError, KeyboardInterrupt) as e:
|
||||
logger.info(f"Task {task.id} cancelled during download: {e}")
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.CANCELLED,
|
||||
error="Cancelled by user"
|
||||
)
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
# Update cancellation message
|
||||
try:
|
||||
await app_client.edit_message_text(
|
||||
chat_id=task.user_id,
|
||||
message_id=message_id,
|
||||
text=f"🚫 **Task cancelled**\n\nTask #{task.id} was cancelled."
|
||||
)
|
||||
except Exception as edit_error:
|
||||
# If update failed, send new message
|
||||
logger.debug(f"Failed to update cancellation message, sending new: {edit_error}")
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"🚫 Task #{task.id} cancelled"
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send cancellation message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
else:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"🚫 Task #{task.id} cancelled"
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send cancellation message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
except Exception as e:
|
||||
logger.error(f"Error sending cancellation notification for task {task.id}: {e}", exc_info=True)
|
||||
clear_task_message(task.id)
|
||||
task_queue.clear_cancel_event(task.id)
|
||||
return
|
||||
|
||||
# Check for cancellation after download
|
||||
current_task = await task_queue.get_task_by_id(task.id)
|
||||
if current_task and current_task.status == TaskStatus.CANCELLED:
|
||||
logger.info(f"Task {task.id} cancelled after download")
|
||||
# Delete downloaded file if exists
|
||||
if result and result.get('file_path'):
|
||||
await delete_file(result['file_path'])
|
||||
task_queue.clear_cancel_event(task.id)
|
||||
return
|
||||
|
||||
if not result:
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error="Failed to download file"
|
||||
)
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
try:
|
||||
await app_client.edit_message_text(
|
||||
chat_id=task.user_id,
|
||||
message_id=message_id,
|
||||
text="❌ **Download error**\n\nFailed to download file. Check the link and try again."
|
||||
)
|
||||
except Exception as edit_error:
|
||||
logger.debug(f"Failed to update error message, sending new: {edit_error}")
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Error downloading file. Check the link and try again."
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send error message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
else:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Error downloading file. Check the link and try again."
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send error message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
except Exception as e:
|
||||
logger.error(f"Error sending download error notification for task {task.id}: {e}", exc_info=True)
|
||||
clear_task_message(task.id)
|
||||
return
|
||||
|
||||
# Send file to user
|
||||
await task_queue.update_task_status(task.id, TaskStatus.PROCESSING, progress=90)
|
||||
|
||||
# Check that file exists before sending
|
||||
file_path_obj = Path(result['file_path'])
|
||||
if not file_path_obj.exists():
|
||||
logger.error(f"File doesn't exist before sending: {result['file_path']}")
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=f"File not found: {result['file_path']}"
|
||||
)
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Error: file not found after download"
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send error message: {e}")
|
||||
clear_task_message(task.id)
|
||||
return
|
||||
|
||||
logger.info(f"Sending file to user {task.user_id}: {result['file_path']}")
|
||||
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
# Form caption
|
||||
caption = f"📥 **{result.get('title', 'File')}**"
|
||||
if result.get('duration'):
|
||||
from bot.utils.helpers import format_duration
|
||||
caption += f"\n⏱ Duration: {format_duration(result['duration'])}"
|
||||
|
||||
# Send file
|
||||
logger.info(f"Calling send_file_to_user for file: {result['file_path']}")
|
||||
success = await send_file_to_user(
|
||||
client=app_client,
|
||||
chat_id=task.user_id,
|
||||
file_path=result['file_path'],
|
||||
caption=caption,
|
||||
thumbnail=result.get('thumbnail')
|
||||
)
|
||||
|
||||
logger.info(f"File sending result: success={success}")
|
||||
|
||||
if success:
|
||||
# Delete file after successful sending
|
||||
await delete_file(result['file_path'])
|
||||
await task_queue.update_task_status(task.id, TaskStatus.COMPLETED, progress=100)
|
||||
task_queue.clear_cancel_event(task.id)
|
||||
|
||||
# Delete download message (file already sent)
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
try:
|
||||
await app_client.delete_messages(
|
||||
chat_id=task.user_id,
|
||||
message_ids=message_id
|
||||
)
|
||||
except Exception as e:
|
||||
logger.debug(f"Failed to delete download message for task {task.id}: {e}")
|
||||
clear_task_message(task.id)
|
||||
else:
|
||||
error_msg = "Failed to send file"
|
||||
logger.error(f"File sending error for task {task.id}: {error_msg}")
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=error_msg
|
||||
)
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Error sending file. File downloaded but failed to send."
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send file sending error message: {e}")
|
||||
except Exception as send_error:
|
||||
error_msg = f"Error sending file: {str(send_error)}"
|
||||
logger.error(f"Exception sending file for task {task.id}: {send_error}", exc_info=True)
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=error_msg
|
||||
)
|
||||
try:
|
||||
if app_client:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ Error sending file: {str(send_error)}"
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send error message: {e}")
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
try:
|
||||
await app_client.edit_message_text(
|
||||
chat_id=task.user_id,
|
||||
message_id=message_id,
|
||||
text="❌ **Send error**\n\nFailed to send file. Try again later."
|
||||
)
|
||||
except Exception as edit_error:
|
||||
logger.debug(f"Failed to update send error message, sending new: {edit_error}")
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
"❌ Error sending file. Try again later."
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send send error message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
else:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
"❌ Error sending file. Try again later."
|
||||
)
|
||||
clear_task_message(task.id)
|
||||
except Exception as e:
|
||||
logger.error(f"Error sending file: {e}", exc_info=True)
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=f"Send error: {str(e)}"
|
||||
)
|
||||
else:
|
||||
logger.warning("Client not set, file not sent")
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error="Client not available"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error downloading via yt-dlp: {e}", exc_info=True)
|
||||
await task_queue.update_task_status(
|
||||
task.id,
|
||||
TaskStatus.FAILED,
|
||||
error=str(e)
|
||||
)
|
||||
task_queue.clear_cancel_event(task.id)
|
||||
clear_task_message(task.id)
|
||||
app_client = get_app_client()
|
||||
if app_client:
|
||||
try:
|
||||
message_id = get_task_message(task.id)
|
||||
if message_id:
|
||||
try:
|
||||
await app_client.edit_message_text(
|
||||
chat_id=task.user_id,
|
||||
message_id=message_id,
|
||||
text=f"❌ **Error**\n\nAn error occurred: {str(e)}"
|
||||
)
|
||||
except Exception as edit_error:
|
||||
logger.debug(f"Failed to update error message, sending new: {edit_error}")
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ An error occurred: {str(e)}"
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send error message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
else:
|
||||
try:
|
||||
await app_client.send_message(
|
||||
task.user_id,
|
||||
f"❌ An error occurred: {str(e)}"
|
||||
)
|
||||
except Exception as send_error:
|
||||
logger.error(f"Failed to send error message to user {task.user_id}: {send_error}", exc_info=True)
|
||||
except Exception as notify_error:
|
||||
logger.error(f"Error sending error notification for task {task.id}: {notify_error}", exc_info=True)
|
||||
|
||||
|
||||
# Global task executor
|
||||
task_executor = TaskExecutor()
|
||||
|
||||
Reference in New Issue
Block a user