import json import os import logging from abc import ABC, abstractmethod from typing import Dict, Any, Optional from opentelemetry.trace import Status, StatusCode from util.exceptions import TemplateError, TemplateNotFoundError, TemplateValidationError from util import api, oss from config.settings import get_storage_config from telemetry import get_tracer logger = logging.getLogger(__name__) class TemplateService(ABC): """模板服务抽象接口""" @abstractmethod def get_template(self, template_id: str) -> Optional[Dict[str, Any]]: """ 获取模板信息 Args: template_id: 模板ID Returns: Dict[str, Any]: 模板信息，如果不存在则返回None """ pass @abstractmethod def load_local_templates(self): """加载本地模板""" pass @abstractmethod def download_template(self, template_id: str) -> bool: """ 下载模板 Args: template_id: 模板ID Returns: bool: 下载是否成功 """ pass @abstractmethod def validate_template(self, template_info: Dict[str, Any]) -> bool: """ 验证模板 Args: template_info: 模板信息 Returns: bool: 验证是否通过 """ pass class DefaultTemplateService(TemplateService): """默认模板服务实现""" def __init__(self): self.templates: Dict[str, Dict[str, Any]] = {} self.storage_config = get_storage_config() def get_template(self, template_id: str) -> Optional[Dict[str, Any]]: """获取模板信息""" if template_id not in self.templates: # 尝试下载模板 if not self.download_template(template_id): return None return self.templates.get(template_id) def load_local_templates(self): """加载本地模板""" template_dir = self.storage_config.template_dir if not os.path.exists(template_dir): logger.warning("Template directory does not exist: %s", template_dir) return for template_name in os.listdir(template_dir): if template_name.startswith("_") or template_name.startswith("."): continue target_path = os.path.join(template_dir, template_name) if os.path.isdir(target_path): try: self._load_template(template_name, target_path) except Exception as e: logger.error("Failed to load template %s: %s", template_name, e) def download_template(self, template_id: str) -> bool: """下载模板""" tracer = get_tracer(__name__) with tracer.start_as_current_span("download_template") as span: try: span.set_attribute("template.id", template_id) # 获取远程模板信息 template_info = api.get_template_info(template_id) if template_info is None: logger.warning("Failed to get template info: %s", template_id) return False local_path = template_info.get('local_path') if not local_path: local_path = os.path.join(self.storage_config.template_dir, str(template_id)) template_info['local_path'] = local_path # 创建本地目录 if not os.path.isdir(local_path): os.makedirs(local_path) # 下载模板资源 overall_template = template_info.get('overall_template', {}) video_parts = template_info.get('video_parts', []) self._download_template_assets(overall_template, template_info) for video_part in video_parts: self._download_template_assets(video_part, template_info) # 保存模板定义文件 template_file = os.path.join(local_path, 'template.json') with open(template_file, 'w', encoding='utf-8') as f: json.dump(template_info, f, ensure_ascii=False, indent=2) # 加载到内存 self._load_template(template_id, local_path) span.set_status(Status(StatusCode.OK)) logger.info("Template downloaded successfully: %s", template_id) return True except Exception as e: span.set_status(Status(StatusCode.ERROR)) logger.error("Failed to download template %s: %s", template_id, e) return False def validate_template(self, template_info: Dict[str, Any]) -> bool: """验证模板""" try: local_path = template_info.get("local_path") if not local_path: raise TemplateValidationError("Template missing local_path") # 验证视频部分 for video_part in template_info.get("video_parts", []): self._validate_template_part(video_part, local_path) # 验证整体模板 overall_template = template_info.get("overall_template", {}) if overall_template: self._validate_template_part(overall_template, local_path) return True except TemplateValidationError: raise except Exception as e: raise TemplateValidationError(f"Template validation failed: {e}") def _load_template(self, template_name: str, local_path: str): """加载单个模板""" logger.info("Loading template: %s (%s)", template_name, local_path) template_def_file = os.path.join(local_path, "template.json") if not os.path.exists(template_def_file): raise TemplateNotFoundError(f"Template definition file not found: {template_def_file}") try: with open(template_def_file, 'r', encoding='utf-8') as f: template_info = json.load(f) except json.JSONDecodeError as e: raise TemplateError(f"Invalid template JSON: {e}") template_info["local_path"] = local_path try: self.validate_template(template_info) self.templates[template_name] = template_info logger.info("Template loaded successfully: %s", template_name) except TemplateValidationError as e: logger.error("Template validation failed for %s: %s. Attempting to re-download.", template_name, e) # 模板验证失败，尝试重新下载 if self.download_template(template_name): logger.info("Template re-downloaded successfully: %s", template_name) else: logger.error("Failed to re-download template: %s", template_name) raise def _download_template_assets(self, template_part: Dict[str, Any], template_info: Dict[str, Any]): """下载模板资源""" local_path = template_info['local_path'] # 下载源文件 if 'source' in template_part: source = template_part['source'] if isinstance(source, str) and source.startswith("http"): _, filename = os.path.split(source) new_file_path = os.path.join(local_path, filename) oss.download_from_oss(source, new_file_path) if filename.endswith(".mp4"): from util.ffmpeg import re_encode_and_annexb new_file_path = re_encode_and_annexb(new_file_path) template_part['source'] = os.path.relpath(new_file_path, local_path) # 下载覆盖层 if 'overlays' in template_part: for i, overlay in enumerate(template_part['overlays']): if isinstance(overlay, str) and overlay.startswith("http"): _, filename = os.path.split(overlay) oss.download_from_oss(overlay, os.path.join(local_path, filename)) template_part['overlays'][i] = filename # 下载LUT if 'luts' in template_part: for i, lut in enumerate(template_part['luts']): if isinstance(lut, str) and lut.startswith("http"): _, filename = os.path.split(lut) oss.download_from_oss(lut, os.path.join(local_path, filename)) template_part['luts'][i] = filename # 下载音频 if 'audios' in template_part: for i, audio in enumerate(template_part['audios']): if isinstance(audio, str) and audio.startswith("http"): _, filename = os.path.split(audio) oss.download_from_oss(audio, os.path.join(local_path, filename)) template_part['audios'][i] = filename def _validate_template_part(self, template_part: Dict[str, Any], base_dir: str): """验证模板部分""" # 验证源文件 source_file = template_part.get("source", "") if source_file and not source_file.startswith("http") and not source_file.startswith("PLACEHOLDER_"): if not os.path.isabs(source_file): source_file = os.path.join(base_dir, source_file) if not os.path.exists(source_file): raise TemplateValidationError(f"Source file not found: {source_file}") # 验证音频文件 for audio in template_part.get("audios", []): if not os.path.isabs(audio): audio = os.path.join(base_dir, audio) if not os.path.exists(audio): raise TemplateValidationError(f"Audio file not found: {audio}") # 验证LUT文件 for lut in template_part.get("luts", []): if not os.path.isabs(lut): lut = os.path.join(base_dir, lut) if not os.path.exists(lut): raise TemplateValidationError(f"LUT file not found: {lut}") # 验证覆盖层文件 for overlay in template_part.get("overlays", []): if not os.path.isabs(overlay): overlay = os.path.join(base_dir, overlay) if not os.path.exists(overlay): raise TemplateValidationError(f"Overlay file not found: {overlay}")