"""매출·광고비 자동 업데이트 — 웹 프로세스 안 데몬 스레드(프로젝트 마감 알림과 같은 방식). 일정(2026-10-26) — 실적 설정 "자동 업데이트" 카드에서 매출 실적·광고비를 **따로** 정한다(마이그레이션 011 perf_settings, key 'auto_sync'). 종류마다 {enabled, interval(분, 5분 단위, 기본 30), days(0=월 … 6=일), start "HH:MM", end "HH:MM"}. - 회차 = 고른 요일의 start, start+interval, … end 까지(end 와 딱 맞으면 end 도). 시각은 5분 단위, KST. - 저장한 일정은 1분 안에 반영(스레드가 1분마다 다시 읽는다). 저장 값이 없으면(011 미적용 포함) 기본 일정 = 매일 env PERFORMANCE_AUTO_SYNC_HOURS(기본 9-19)시 정각 ~ 마지막 시 정각, 30분마다. - 매출 = 진행 창 작업(jobs kind="sales") — 그동안 누가 [매출 업데이트] 를 누르면 새로 시작하지 않고 이 진행 상황을 본다. - 광고비 = 설정된 광고 API(구글·메타) — 광고비 진행 창 작업(jobs kind="ads"). 광고비 탭 [광고비 업데이트]도 같은 진행 상황. - 두 종류의 회차가 같은 시각이면 동시에 돈다(따로 스레드). 그 시각에 이미 같은 종류 업데이트가 돌고 있으면 그 종류는 그 회차를 건너뛴다. 한 회차가 간격을 넘기면 지나간 회차는 건너뛰고 다음 회차를 기다린다(밀린 회차를 몰아서 돌리지 않음). - 서버를 켠 시각의 회차는 돌리지 않고 다음 회차부터. 환경변수(.env) PERFORMANCE_AUTO_SYNC=false 끄기(기본 켜짐) — 끄면 설정 화면 일정과 상관없이 안 돈다 PERFORMANCE_AUTO_SYNC_DAYS=10 가져올 기간(오늘 포함 최근 N일, 1~90) PERFORMANCE_AUTO_SYNC_HOURS=9-19 설정 화면에서 일정을 저장하기 전 기본 시간대(시작시-마지막시) """ from __future__ import annotations import logging import os import re import threading import time from datetime import datetime, timedelta from typing import Any from app.timezone import now_kst logger = logging.getLogger("performance.auto_sync") AUTO_USER = "자동 업데이트" DEFAULT_DAYS = 10 DEFAULT_HOURS = (9, 19) DEFAULT_INTERVAL = 30 INTERVAL_STEP = 5 INTERVAL_MAX = 720 SETTING_KEY = "auto_sync" KINDS = ("sales", "ads") KIND_NAMES = {"sales": "매출 실적", "ads": "광고비"} WEEKDAYS = ("월", "화", "수", "목", "금", "토", "일") _started = False _start_lock = threading.Lock() def _env(name: str) -> str: return (os.getenv(name, "") or "").strip() def enabled() -> bool: return _env("PERFORMANCE_AUTO_SYNC").lower() not in ("0", "false", "no", "off") def sync_days() -> int: try: return max(1, min(90, int(_env("PERFORMANCE_AUTO_SYNC_DAYS") or DEFAULT_DAYS))) except ValueError: return DEFAULT_DAYS def hour_window() -> tuple[int, int]: m = re.fullmatch(r"(\d{1,2})\s*-\s*(\d{1,2})", _env("PERFORMANCE_AUTO_SYNC_HOURS")) if not m: return DEFAULT_HOURS first, last = int(m.group(1)), int(m.group(2)) if not (0 <= first <= last <= 23): return DEFAULT_HOURS return first, last # ════════════════════════════════════════════════════════════ # 일정 # ════════════════════════════════════════════════════════════ def default_schedule() -> dict[str, Any]: first, last = hour_window() return {"enabled": True, "interval": DEFAULT_INTERVAL, "days": list(range(7)), "start": f"{first:02d}:00", "end": f"{last:02d}:00"} def _minutes(hhmm: str) -> int: h, m = hhmm.split(":") return int(h) * 60 + int(m) def _time(raw: Any, label: str) -> str: m = re.fullmatch(r"(\d{1,2}):(\d{2})", str(raw or "").strip()) if not m or not (0 <= int(m.group(1)) <= 23 and 0 <= int(m.group(2)) <= 59): raise ValueError(f"{label}을 HH:MM 으로 넣어 주세요.") if int(m.group(2)) % INTERVAL_STEP: raise ValueError(f"{label}은 {INTERVAL_STEP}분 단위로 정할 수 있습니다.") return f"{int(m.group(1)):02d}:{m.group(2)}" def validate_schedule(raw: Any) -> dict[str, Any]: """설정 화면에서 받은 일정 하나 → 정리한 값. 잘못되면 ValueError(화면에 그대로 보여 줄 문구).""" if not isinstance(raw, dict): raise ValueError("일정 형식이 잘못되었습니다.") on = bool(raw.get("enabled")) try: interval = int(raw.get("interval")) except (TypeError, ValueError): raise ValueError("간격(분)을 숫자로 넣어 주세요.") from None if not (INTERVAL_STEP <= interval <= INTERVAL_MAX) or interval % INTERVAL_STEP: raise ValueError(f"간격은 {INTERVAL_STEP}분 ~ {INTERVAL_MAX}분, {INTERVAL_STEP}분 단위로 정할 수 있습니다.") days = raw.get("days") if not isinstance(days, list) or any(not isinstance(d, int) or isinstance(d, bool) or not 0 <= d <= 6 for d in days): raise ValueError("요일이 잘못되었습니다.") days = sorted(set(days)) if on and not days: raise ValueError("요일을 하나 이상 고르세요(자동 업데이트를 쓰지 않으려면 [사용]을 끄세요).") start, end = _time(raw.get("start"), "시작 시각"), _time(raw.get("end"), "끝 시각") if _minutes(end) < _minutes(start): raise ValueError("끝 시각은 시작 시각과 같거나 뒤여야 합니다(밤을 넘기는 시간대는 안 됩니다).") return {"enabled": on, "interval": interval, "days": days, "start": start, "end": end} def normalize(raw: Any) -> dict[str, dict[str, Any]]: """DB 에 저장된 값 → 종류마다 일정. 없거나 잘못된 종류는 기본 일정.""" out = {} for k in KINDS: try: out[k] = validate_schedule((raw or {}).get(k)) if isinstance(raw, dict) else default_schedule() except ValueError: out[k] = default_schedule() return out def load_schedules(store: Any) -> tuple[dict[str, dict[str, Any]], bool]: """(종류 → 일정, 011 적용 여부). DB 오류는 그대로 올린다(스레드는 직전 일정을 계속 쓴다).""" from .db import SettingsMigrationNeeded # noqa: WPS433 getter = getattr(store, "get_setting", None) if getter is None: # 테스트용 가짜 저장소 등 return normalize(None), True try: return normalize(getter(SETTING_KEY)), True except SettingsMigrationNeeded: return normalize(None), False def describe(sched: dict[str, Any]) -> str: """'매일 09:00~19:00 · 30분마다' / '평일 …' / '월·수·금 …' / '꺼짐'.""" if not sched.get("enabled") or not sched.get("days"): return "꺼짐" days = sched["days"] if days == list(range(7)): when = "매일" elif days == list(range(5)): when = "평일" elif days == [5, 6]: when = "주말" else: when = "·".join(WEEKDAYS[d] for d in days) span = sched["start"] if sched["start"] == sched["end"] else f"{sched['start']}~{sched['end']}" every = sched["interval"] every_txt = f"{every // 60}시간" + (f" {every % 60}분" if every % 60 else "") if every >= 60 else f"{every}분" return f"{when} {span}" + ("" if sched["start"] == sched["end"] else f" · {every_txt}마다") def is_slot(t: datetime, sched: dict[str, Any]) -> bool: """t(분 단위로 자른 KST 시각)가 회차인가.""" if not sched.get("enabled") or t.weekday() not in sched["days"]: return False m, start, end = t.hour * 60 + t.minute, _minutes(sched["start"]), _minutes(sched["end"]) return start <= m <= end and (m - start) % sched["interval"] == 0 def next_slot(after: datetime, sched: dict[str, Any]) -> datetime | None: """after 보다 뒤의 첫 회차 시각(KST). 꺼져 있거나 요일이 없으면 None.""" if not sched.get("enabled") or not sched.get("days"): return None start, end, step = _minutes(sched["start"]), _minutes(sched["end"]), sched["interval"] day0 = after.replace(hour=0, minute=0, second=0, microsecond=0) for d in range(8): base = day0 + timedelta(days=d) if base.weekday() not in sched["days"]: continue first = base + timedelta(minutes=start) k = 0 if first > after else int((after - first).total_seconds() // (step * 60)) + 1 m = start + k * step if m <= end: return base + timedelta(minutes=m) return None # ════════════════════════════════════════════════════════════ # 회차 실행 # ════════════════════════════════════════════════════════════ def run_once(store: Any, app_state: Any, *, today: Any, days: int, kinds: tuple[str, ...] = KINDS) -> dict[str, Any]: """한 회차 — 오늘 포함 최근 days 일. kinds 의 매출(진행 창 작업)·광고비(광고 진행 창 작업)를 동시에. 각각 이미 돌고 있으면 그 종류만 건너뜀.""" from . import common, jobs # noqa: WPS433 from .ad_sync import run_ad_job # noqa: WPS433 from .credentials import CredentialService # noqa: WPS433 from .sync import SyncService # noqa: WPS433 start, end = today - timedelta(days=days - 1), today ads: list[dict[str, Any]] = [] ad_thread = None ads_skipped = "ads" not in kinds or jobs.running_job("ads") is not None if not ads_skipped: ad_job = jobs.create_job(user=AUTO_USER, start=start, end=end, kind="ads") def _ads() -> None: ads.extend(run_ad_job(store, common.key_ring, ad_job, start, end, user=AUTO_USER)) ad_thread = threading.Thread(target=_ads, name=f"perf-auto-ads-{ad_job.id}", daemon=True) ad_thread.start() sales_skipped = "sales" not in kinds or jobs.running_job("sales") is not None error = "" results: list[dict[str, Any]] = [] if not sales_skipped: job = jobs.create_job(user=AUTO_USER, start=start, end=end) sync = SyncService(store, CredentialService(store, common.key_ring), app_state=app_state) try: results = sync.sync_all(start=start, end=end, trigger="schedule", user=AUTO_USER, job=job) except Exception as exc: # noqa: BLE001 — 스레드가 죽지 않게 logger.exception("auto sync failed") error = f"업데이트 중 오류: {type(exc).__name__}" last = None try: last = store.last_update_at() except Exception: # noqa: BLE001 pass job.finish(error=error, last_update_at=last) if ad_thread is not None: ad_thread.join() if sales_skipped and ads_skipped: return {"skipped": True, "reason": "다른 업데이트 진행 중"} ok = sum(1 for r in results if r.get("ok")) return {"skipped": False, "sales_skipped": sales_skipped, "ads_skipped": ads_skipped, "from": start.isoformat(), "to": end.isoformat(), "ok": ok, "failed": [r.get("code") for r in results if not r.get("ok") and not r.get("skipped")], "error": error, "ads": [{"code": a.get("code"), "ok": bool(a.get("ok"))} for a in ads]} class Scheduler: """종류마다 다음 회차(due)를 들고 있다가 시각이 되면 그 종류만 따로 스레드로 돌린다. tick(now) 이 1분마다 불리며 일정이 바뀐 종류는 지금부터 다시 계산(서버 시작·저장 직후 회차는 안 돌림).""" def __init__(self, fire: Any): self.fire = fire # fire(kind, due) self.schedules: dict[str, dict[str, Any]] = {} self.due: dict[str, datetime | None] = {} def update(self, schedules: dict[str, dict[str, Any]], now: datetime) -> None: for k in KINDS: s = schedules.get(k) or default_schedule() if self.schedules.get(k) != s: self.schedules[k] = s self.due[k] = next_slot(now, s) def tick(self, now: datetime) -> None: for k in KINDS: due = self.due.get(k) if due is not None and due <= now: self.fire(k, due) self.due[k] = next_slot(max(now, due), self.schedules[k]) def wait_seconds(self, now: datetime) -> float: dues = [d for d in self.due.values() if d is not None] if not dues: return 60.0 return max(0.0, min(60.0, min((d - now).total_seconds() for d in dues))) def start_auto_sync_thread(app_state: Any) -> bool: """웹 프로세스 시작 시 1번. 저장소가 없거나 꺼져 있거나 이미 돌고 있으면 False.""" global _started # noqa: PLW0603 store = getattr(app_state, "performance_store", None) if store is not None and not _started: try: # 지난 프로세스가 업데이트 도중 끝나 남은 '진행 중' 기록 정리(자동 업데이트를 꺼 둬도) n = store.abandon_running_runs() if n: logger.warning("매출 업데이트 '진행 중' 기록 %d건 정리(서버 재시작으로 중단)", n) except Exception: # noqa: BLE001 — DB 가 아직 안 붙었어도 앱은 뜬다 logger.exception("매출 업데이트 진행 기록 정리 실패") if store is None or not enabled(): return False with _start_lock: if _started: return False _started = True days = sync_days() def _fire(kind: str, due: datetime) -> None: def _run() -> None: try: res = run_once(store, app_state, today=due.date(), days=days, kinds=(kind,)) logger.info("%s 자동 업데이트 %s: %s", KIND_NAMES[kind], due.strftime("%H:%M"), res) except Exception: # noqa: BLE001 logger.exception("%s 자동 업데이트 실패 — 다음 회차에 다시", KIND_NAMES[kind]) threading.Thread(target=_run, name=f"performance-auto-{kind}", daemon=True).start() sched = Scheduler(_fire) def _reload(now: datetime) -> None: try: schedules, _ = load_schedules(store) except Exception: # noqa: BLE001 — DB 가 잠시 끊기면 직전 일정 그대로(처음이면 기본 일정) logger.warning("자동 업데이트 일정 읽기 실패 — 직전 일정 사용", exc_info=True) schedules = sched.schedules or normalize(None) sched.update(schedules, now) def _loop() -> None: _reload(now_kst()) logger.info("실적 자동 업데이트 시작 — 최근 %d일, %s", days, ", ".join( f"{KIND_NAMES[k]} {describe(sched.schedules[k])} 다음 " f"{sched.due[k].strftime('%m-%d %H:%M') if sched.due[k] else '없음'}" for k in KINDS)) while True: time.sleep(max(1.0, sched.wait_seconds(now_kst()))) # 시계 변경·절전·일정 저장에도 1분 안에 다시 확인 now = now_kst() _reload(now) sched.tick(now) threading.Thread(target=_loop, name="performance-auto-sync", daemon=True).start() return True