""" AutoFlow Platform Backend - Flask Application Unified automation testing platform combining: - D-Cloud E2E testing (data-loop-automation) - Robogo full-chain inspection (test project) Start: python -m backend.app Access: http://127.0.0.1:5001 """ import os import sys import json import uuid import time import hashlib import queue import threading import subprocess import signal from datetime import datetime, timedelta from pathlib import Path from flask import Flask, request, jsonify, Response, send_from_directory from flask_cors import CORS # Ensure project root is on path PROJECT_ROOT = Path(__file__).parent.parent sys.path.insert(0, str(PROJECT_ROOT)) app = Flask( __name__, static_folder=str(PROJECT_ROOT / "frontend" / "dist"), static_url_path="/static" ) CORS(app) # ── Constants ────────────────────────────────────────────────────────────────── DB_FILE = str(PROJECT_ROOT / "platform_db.json") REPORTS_DIR = str(PROJECT_ROOT / "platform_reports") SCREENSHOTS_DIR = str(PROJECT_ROOT / "platform_artifacts" / "screenshots") PYTHON_BIN = sys.executable os.makedirs(REPORTS_DIR, exist_ok=True) os.makedirs(SCREENSHOTS_DIR, exist_ok=True) # ── Products & Test Modules Config ───────────────────────────────────────────── PRODUCTS = { "robogo": { "name": "Robogo", "desc": "Robogo 全链路 UI 巡检", "icon": "🤖", "entry": str(PROJECT_ROOT / "framework" / "scripts" / "run_all.py"), "type": "scenario" }, "data_loop": { "name": "数据闭环", "desc": "数据闭环平台端到端业务流水线验证", "icon": "🔄", "entry": str(PROJECT_ROOT / "framework" / "scripts" / "run_data_loop.py"), "type": "scenario" } } DCLOUD_MODULES = { "e2e": {"name": "E2E 全量", "icon": "Zap", "marker": "e2e"}, "workbench": {"name": "工作台", "icon": "Box", "marker": "workbench"}, "data_space": {"name": "数据空间", "icon": "Database", "marker": "data_space or dataspace"}, "data_set": {"name": "数据集", "icon": "Layers", "marker": "dataset"}, "data_generation": {"name": "数据生成", "icon": "Wand2", "marker": "data_generation"}, "model_workshop": {"name": "模型工作台", "icon": "Cpu", "marker": "model_workshop"}, "model_square": {"name": "模型广场", "icon": "ShoppingBag", "marker": "model_square"}, "monitor": {"name": "监控看板", "icon": "BarChart3", "marker": "monitor"}, "image_manage": {"name": "图像管理", "icon": "Image", "marker": "image_manage"}, "mirror_center": {"name": "镜像中心", "icon": "HardDrive", "marker": "mirror_center"}, "cloud_desktop": {"name": "云端桌面", "icon": "Monitor", "marker": "cloud_desktop"}, "dev_machine": {"name": "开发机", "icon": "Code2", "marker": "dev_machine"}, "device_manage": {"name": "设备管理", "icon": "Smartphone", "marker": "device_manage"}, "material_library": {"name": "素材库", "icon": "Library", "marker": "material_library"}, "prompt_library": {"name": "提示词库", "icon": "MessageSquare", "marker": "prompt_library"}, "lora_finetune": {"name": "LoRA微调", "icon": "GitBranch", "marker": "lora_finetune"}, } # ── In-memory State ──────────────────────────────────────────────────────────── tasks_db: dict = {} reports_db: dict = {} log_queues: dict = {} process_pids: dict = {} db_lock = threading.Lock() # ── Database Persistence ─────────────────────────────────────────────────────── def _load_db(): global tasks_db, reports_db if os.path.exists(DB_FILE): try: with open(DB_FILE, 'r', encoding='utf-8') as f: data = json.load(f) tasks_db = data.get("tasks", {}) reports_db = data.get("reports", {}) except Exception as e: print(f"⚠️ Database load failed: {e}") def _save_db(): with db_lock: try: active_once_tasks = [ t for t in tasks_db.values() if t.get("schedule_type", "once") == "once" and not t.get("is_deleted") ] if len(active_once_tasks) > 100: sorted_tasks = sorted(active_once_tasks, key=lambda t: t.get("created_at", "")) for t in sorted_tasks[:50]: tid = t.get("id") if tid: _cleanup_assets(tid) t["is_deleted"] = True safe_data = json.loads(json.dumps({"tasks": tasks_db, "reports": reports_db})) for t in safe_data.get("tasks", {}).values(): pw = t.get("password") if pw and not pw.startswith("sha256:"): t["password"] = "sha256:" + hashlib.sha256(pw.encode()).hexdigest() with open(DB_FILE, 'w', encoding='utf-8') as f: json.dump(safe_data, f, ensure_ascii=False) except Exception: pass def _cleanup_assets(tid): try: if os.path.exists(SCREENSHOTS_DIR): for s in os.listdir(SCREENSHOTS_DIR): if s.startswith(tid): try: os.remove(os.path.join(SCREENSHOTS_DIR, s)) except Exception: pass except Exception as e: print(f"⚠️ Cleanup failed: {e}") _load_db() # ── Feishu Alerting ──────────────────────────────────────────────────────────── def send_alerts(report): task_id = report.get("task_id") task = tasks_db.get(task_id, {}) channels = task.get("alert_channels", []) webhook_url = os.getenv("LARK_WEBHOOK_URL", "") if "lark" in channels and webhook_url: import requests as req rule = task.get("alert_rule", "always") if rule == "only_on_fail" and report["result"] == "PASS": return try: status_color = "green" if report["result"] == "PASS" else "red" status_text = "成功" if report["result"] == "PASS" else "失败" card = { "config": {"wide_screen_mode": True}, "header": { "title": {"tag": "plain_text", "content": f"🔔 AutoFlow 报告: {report['task_name']}"}, "template": status_color }, "elements": [ { "tag": "div", "fields": [ {"is_short": True, "text": {"tag": "lark_md", "content": f"**状态:** {status_text}"}}, {"is_short": True, "text": {"tag": "lark_md", "content": f"**产品:** {report['product']}"}}, {"is_short": True, "text": {"tag": "lark_md", "content": f"**环境:** {task.get('env', 'PROD')}"}}, {"is_short": True, "text": {"tag": "lark_md", "content": f"**通过/总计:** {report['pass']}/{report['total_runs']}"}} ] } ] } req.post(webhook_url, json={"msg_type": "interactive", "card": card}, timeout=5) except Exception as e: print(f"❌ Feishu alert failed: {e}") # ── Task Execution ───────────────────────────────────────────────────────────── def run_task_process(task): task_id = task["id"] task["status"] = "running" task["started_at"] = datetime.now().isoformat() _save_db() q = log_queues.get(task_id) logs_all = [] def push(msg, level="INFO"): entry = {"ts": datetime.now().strftime("%H:%M:%S"), "level": level, "msg": msg} logs_all.append(entry) if q: q.put(json.dumps(entry)) run_limit = int(task.get("run_count", 1)) retry_count = int(task.get("retry_count", 1)) if task.get("retry_on_fail") else 0 retry_delay = int(task.get("retry_delay", 5)) env = os.environ.copy() env["ROBOGO_SCREENSHOTS_DIR"] = os.path.abspath(SCREENSHOTS_DIR) env["ROBOGO_REPORTS_DIR"] = os.path.abspath(REPORTS_DIR) env["ROBOGO_TASK_ID"] = task_id env["ROBOGO_ENV"] = task.get("env", "PROD") env["ROBOGO_SCOPE"] = task.get("scope", "all") env["AUTH_ACCOUNT"] = task.get("account") or "" env["AUTH_PASSWORD"] = task.get("password") or "" env["ROBOGO_USER"] = task.get("account") or "" env["ROBOGO_PWD"] = task.get("password") or "" env["PYTEST_RUNNING"] = "1" env["HEADLESS"] = task.get("headless", os.environ.get("HEADLESS", "true")) task_type = task.get("task_type", "scenario") dcloud_module = task.get("dcloud_module", "") total_pass, total_fail = 0, 0 current_run = 0 planned_runs = run_limit last_run_success = None is_retry_run = False push(f"🎬 Task started — env: {env.get('ROBOGO_ENV', 'N/A')} | scope: {env.get('ROBOGO_SCOPE', 'N/A')}", "INFO") # Build command based on task type junit_report = str(PROJECT_ROOT / "reports" / f"{task_id}.xml") if task_type == "dcloud_module" and dcloud_module: test_path = task.get("test", "") if dcloud_module == "e2e": if test_path: cmd = [PYTHON_BIN, "-m", "pytest", test_path, "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push(f"🧪 Running E2E test: {test_path}", "INFO") else: cmd = [PYTHON_BIN, "-m", "pytest", "tests/", "-m", "e2e", "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push("🧪 Running ALL E2E tests across all modules", "INFO") elif test_path: cmd = [PYTHON_BIN, "-m", "pytest", test_path, "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push(f"🧪 Running test: {test_path}", "INFO") else: cmd = [PYTHON_BIN, "-m", "pytest", f"tests/{dcloud_module}/", "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push(f"🧪 Running D-Cloud module tests: {dcloud_module}", "INFO") elif task_type == "dcloud_e2e": cmd = [PYTHON_BIN, "-m", "pytest", "tests/", "-m", "e2e", "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push("🧪 Running ALL E2E tests across all modules", "INFO") elif task_type == "dcloud_all": cmd = [PYTHON_BIN, "-m", "pytest", "tests/", "-v", "--tb=short", "--color=no", "-s", f"--junitxml={junit_report}"] push("🧪 Running ALL D-Cloud tests", "INFO") elif task_type == "scenario": cmd = [PYTHON_BIN, task["entry"]] push(f"🚀 Running scenario: {task.get('product', 'unknown')}", "INFO") else: cmd = [PYTHON_BIN, task["entry"]] push(f"🚀 Running: {task.get('product', 'unknown')}", "INFO") while current_run < run_limit: current_run += 1 push(f"▶️ Run {current_run}/{planned_runs}", "INFO") try: proc = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, env=env, preexec_fn=os.setsid if os.name != 'nt' else None, cwd=str(PROJECT_ROOT) ) process_pids[task_id] = proc.pid for line in proc.stdout: push(line.rstrip(), "INFO") proc.wait() process_pids.pop(task_id, None) if proc.returncode == 0: last_run_success = True if is_retry_run: total_fail = max(0, total_fail - 1) total_pass += 1 push(f"✅ Retry #{current_run} succeeded (overrode previous failure)", "SUCCESS") else: total_pass += 1 push(f"✅ Run #{current_run} passed", "SUCCESS") is_retry_run = False else: last_run_success = False total_fail += 1 push(f"❌ Run #{current_run} failed", "ERROR") if retry_count > 0: push(f"🔁 Retrying ({retry_count} left), waiting {retry_delay}s...", "WARN") time.sleep(retry_delay) retry_count -= 1 run_limit += 1 is_retry_run = True else: is_retry_run = False except Exception as e: push(f"💥 System error: {e}", "ERROR") last_run_success = False total_fail += 1 is_retry_run = False finished_at = datetime.now().isoformat() final_result = "PASS" if last_run_success else "FAIL" report = { "task_id": task_id, "task_name": task["name"], "product": task.get("product", "dcloud"), "module": task.get("dcloud_module", "") or task.get("product", ""), "total_runs": planned_runs, "pass": total_pass, "fail": total_fail, "started_at": task["started_at"], "finished_at": finished_at, "result": final_result } log_file = os.path.join(REPORTS_DIR, f"{task_id}.json") try: with open(log_file, 'w', encoding='utf-8') as f: json.dump({"logs": logs_all}, f, ensure_ascii=False) except Exception: pass # Generate HTML dashboard report for D-Cloud tasks if task_type.startswith("dcloud"): try: html_report = os.path.join(REPORTS_DIR, f"{task_id}.html") subprocess.run( [PYTHON_BIN, str(PROJECT_ROOT / "scripts" / "generate_report.py"), "--output", html_report, "--no-history"], capture_output=True, timeout=30, cwd=str(PROJECT_ROOT) ) report["html_report"] = html_report except Exception: pass reports_db[task_id] = report task["status"] = "pass" if final_result == "PASS" else "fail" task["finished_at"] = finished_at task["report_id"] = task_id _save_db() send_alerts(report) push("__DONE__", "DONE") # ── API Routes ───────────────────────────────────────────────────────────────── @app.route("/api/products") def get_products(): return jsonify(PRODUCTS) @app.route("/api/dcloud-modules") def get_dcloud_modules(): return jsonify(DCLOUD_MODULES) @app.route("/api/dcloud-modules//tests") def get_module_tests(module): if module not in DCLOUD_MODULES: return jsonify({"error": "Unknown module"}), 404 test_dir = PROJECT_ROOT / "tests" / module / "tests" if not test_dir.exists(): return jsonify([]) tests = [] for f in sorted(test_dir.glob("test_*.py")): test_type = "" if "_e2e_" in f.name: test_type = "e2e" elif "_api_boundary" in f.name or "_api_comprehensive" in f.name: test_type = "api" elif "_api" in f.name: test_type = "api" elif "_ui_exceptions" in f.name: test_type = "exception" elif "_ui" in f.name: test_type = "ui" elif "_flow" in f.name: test_type = "flow" elif "_e2e" in f.name: test_type = "e2e" elif "full_pipeline" in f.name: test_type = "e2e" # Extract test functions from file funcs = [] try: content = f.read_text() for line in content.split("\n"): line = line.strip() if line.startswith("def test_"): func_name = line.split("(")[0].replace("def ", "") funcs.append(func_name) except Exception: pass tests.append({ "file": f.name, "path": f"tests/{module}/tests/{f.name}", "type": test_type, "functions": funcs, "count": len(funcs), }) return jsonify(tests) @app.route("/api/tasks", methods=["GET"]) def list_tasks(): product = request.args.get("product", "") t_list = [t for t in tasks_db.values() if not t.get("is_deleted")] if product: t_list = [t for t in t_list if t.get("product") == product] return jsonify(t_list) @app.route("/api/tasks", methods=["POST"]) def create_task(): body = request.json tid = str(uuid.uuid4())[:8] task_type = body.get("task_type", "scenario") p_key = body.get("product", "robogo") dcloud_module = body.get("dcloud_module", "") if task_type in ("dcloud_module", "dcloud_all"): entry = "" display_product = "dcloud" else: p = PRODUCTS.get(p_key, {}) entry = p.get("entry", "") display_product = p_key task = { "id": tid, "name": body.get("name", f"Task_{tid}"), "product": display_product, "status": "pending", "created_at": datetime.now().isoformat(), "account": body.get("account"), "password": body.get("password"), "run_count": int(body.get("run_count", 1)), "retry_on_fail": body.get("retry_on_fail", False), "retry_count": int(body.get("retry_count", 1)), "retry_delay": int(body.get("retry_delay", 5)), "env": body.get("env", "PROD"), "scope": body.get("scope", "all"), "scheduled_at": body.get("scheduled_at"), "schedule_type": body.get("schedule_type", "once"), "schedule_window": body.get("schedule_window", "00:00-23:59"), "alert_channels": body.get("alert_channels", ["lark"]), "alert_rule": body.get("alert_rule", "always"), "entry": entry, "task_type": task_type, "dcloud_module": dcloud_module, "test": body.get("test", ""), "headless": body.get("headless", "true"), } if task_type in ("dcloud_module", "dcloud_all"): task["entry"] = "pytest" tasks_db[tid] = task log_queues[tid] = queue.Queue() _save_db() if not task["scheduled_at"] and task["schedule_type"] == "once": threading.Thread(target=run_task_process, args=(task,), daemon=True).start() return jsonify(task), 201 @app.route("/api/tasks/", methods=["DELETE"]) def delete_task(tid): _cleanup_assets(tid) tasks_db.pop(tid, None) reports_db.pop(tid, None) _save_db() return jsonify({"success": True}) @app.route("/api/tasks//stop", methods=["POST"]) def stop_task(tid): pid = process_pids.get(tid) task = tasks_db.get(tid) if task: if task.get("schedule_type") == "continuous": task["schedule_type"] = "once" task["status"] = "fail" task["finished_at"] = datetime.now().isoformat() if pid: try: os.killpg(os.getpgid(pid), signal.SIGKILL) except Exception: try: os.kill(pid, signal.SIGKILL) except Exception: pass process_pids.pop(tid, None) _save_db() return jsonify({"success": True}) @app.route("/api/tasks//logs") def stream_logs(task_id): q = log_queues.get(task_id) if not q: return jsonify({"error": "No stream"}), 404 def event_stream(): while True: try: msg = q.get(timeout=30) yield f"data: {msg}\n\n" if json.loads(msg).get("level") == "DONE": break except queue.Empty: yield f"data: {json.dumps({'level': 'PING', 'msg': ''})}\n\n" return Response(event_stream(), content_type="text/event-stream") @app.route("/api/dashboard/stats") def get_stats(): try: product_filter = request.args.get("product", "") reports = list(reports_db.values()) tasks = list(tasks_db.values()) if product_filter: reports = [r for r in reports if r.get("product") == product_filter] total = len(reports) passed = sum(1 for r in reports if r.get('result') == 'PASS') fail_count = total - passed pass_rate = round(passed / total * 100, 1) if total > 0 else 0 trends = {} today = datetime.now() for i in range(6, -1, -1): day = (today - timedelta(days=i)).strftime("%m-%d") trends[day] = {"pass": 0, "fail": 0} for r in reports: f_at = r.get("finished_at") if not f_at: continue try: dt = datetime.fromisoformat(f_at).strftime("%m-%d") if dt in trends: if r.get("result") == "PASS": trends[dt]["pass"] += 1 else: trends[dt]["fail"] += 1 except Exception: continue health = {} if product_filter == "dcloud" or not product_filter: for mod_key, mod_val in DCLOUD_MODULES.items(): mod_reports = [r for r in reports if r.get("module") == mod_key] passed_mod = sum(1 for r in mod_reports if r.get("result") == "PASS") health[mod_val["name"]] = { "rate": round(passed_mod / len(mod_reports) * 100) if mod_reports else 0, "total": len(mod_reports), } if product_filter == "robogo" or not product_filter: for p_key, p_val in PRODUCTS.items(): p_reports = [r for r in reports if r.get("product") == p_key] total_p = sum(1 for r in p_reports if r.get("result") == "PASS") health[p_val["name"]] = { "rate": round(total_p / len(p_reports) * 100) if p_reports else 0, "total": len(p_reports), } failure_map = {"元素定位/超时": 0, "业务逻辑报错": 0, "接口/网络异常": 0, "其他": 0} failed_reports = [r for r in reports if r.get("result") == "FAIL"][-20:] for r in failed_reports: tid = r.get("task_id") if not tid: continue log_file = os.path.join(REPORTS_DIR, f"{tid}.json") if os.path.exists(log_file): try: with open(log_file, 'r') as f: content = f.read() if "Timeout" in content or "not found" in content: failure_map["元素定位/超时"] += 1 elif "Exception" in content: failure_map["业务逻辑报错"] += 1 else: failure_map["其他"] += 1 except Exception: pass return jsonify({ "summary": { "total_reports": total, "pass_rate": pass_rate, "fail_count": fail_count, "closure_rate": round(passed / total * 100, 1) if total > 0 else 0 }, "trends": trends, "health": health, "failure_analysis": failure_map, "ts": datetime.now().strftime("%H:%M:%S") }) except Exception as e: return jsonify({"error": f"Stats error: {str(e)}"}), 500 @app.route("/api/reports") def list_reports(): product = request.args.get("product", "") r_list = [] for tid, r in reports_db.items(): if tid in tasks_db and not tasks_db[tid].get("is_deleted"): if product and tasks_db[tid].get("product") != product: continue item = r.copy() item["thumbnail"] = None if os.path.exists(SCREENSHOTS_DIR): try: for f in os.listdir(SCREENSHOTS_DIR): if f.startswith(tid): item["thumbnail"] = f break except Exception: pass r_list.append(item) return jsonify(r_list) @app.route("/api/reports/") def get_report(tid): r = reports_db.get(tid) if not r: return jsonify({"error": "Not Found"}), 404 res = r.copy() res["results"] = [] res["logs"] = [] res["screenshots"] = [] log_path = os.path.join(REPORTS_DIR, f"{tid}.json") if os.path.exists(log_path): try: with open(log_path, 'r', encoding='utf-8') as f: res["logs"] = json.load(f).get("logs", []) except Exception: pass results_path = os.path.join(REPORTS_DIR, f"{tid}_results.json") if os.path.exists(results_path): try: with open(results_path, 'r', encoding='utf-8') as f: res["results"] = json.load(f) except Exception: pass if os.path.exists(SCREENSHOTS_DIR): try: res["screenshots"] = [s for s in os.listdir(SCREENSHOTS_DIR) if s.startswith(tid)] except Exception: pass html_path = os.path.join(REPORTS_DIR, f"{tid}.html") if os.path.exists(html_path): res["html_report"] = f"/api/reports/{tid}/html" return jsonify(res) @app.route("/artifacts/screenshots/") def serve_screenshot(filename): return send_from_directory(SCREENSHOTS_DIR, filename) @app.route("/api/reports//html") def serve_report_html(tid): html_path = os.path.join(REPORTS_DIR, f"{tid}.html") if os.path.exists(html_path): return send_from_directory(REPORTS_DIR, f"{tid}.html") return jsonify({"error": "Not Found"}), 404 # ── Serve React SPA (production) ─────────────────────────────────────────────── @app.route("/assets/") def serve_assets(filename): return send_from_directory(str(PROJECT_ROOT / "frontend" / "dist" / "assets"), filename) @app.route("/") @app.route("/") def serve_spa(path=""): dist_dir = str(PROJECT_ROOT / "frontend" / "dist") if os.path.isdir(dist_dir) and os.path.isfile(os.path.join(dist_dir, "index.html")): return send_from_directory(dist_dir, "index.html") return jsonify({"message": "AutoFlow API server running. Frontend not built. Run: cd frontend && pnpm build"}), 200 # ── E2E Step Runner ──────────────────────────────────────────────────────────── @app.route("/api/run-e2e-step") def run_e2e_step(): name = request.args.get("name", "") step = request.args.get("step", "1") if not name: return jsonify({"error": "Missing name parameter"}), 400 script = str(PROJECT_ROOT / "scripts" / "run_e2e_split.py") def event_stream(): import re start = time.time() try: p = subprocess.Popen( [PYTHON_BIN, script, "--name", name, "--step", step], cwd=str(PROJECT_ROOT), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, ) except Exception as e: yield f"data: {json.dumps({'type': 'log', 'msg': f'Failed: {e}', 'cls': 'text-red-400'})}\n\n" yield f"data: {json.dumps({'type': 'result', 'passed': False, 'duration': 0, 'summary': str(e)})}\n\n" return try: for line in iter(p.stdout.readline, ""): if not line: break line = line.rstrip("\n") if not line: continue if "ERROR" in line or "error" in line.lower(): yield f"data: {json.dumps({'type': 'log', 'msg': line, 'cls': 'text-red-400'})}\n\n" elif "完成" in line or "成功" in line or "ok" in line.lower(): yield f"data: {json.dumps({'type': 'log', 'msg': line, 'cls': 'text-green-400'})}\n\n" elif "创建" in line or "验证" in line or "清理" in line: yield f"data: {json.dumps({'type': 'log', 'msg': line, 'cls': 'text-cyan-400'})}\n\n" else: yield f"data: {json.dumps({'type': 'log', 'msg': line, 'cls': ''})}\n\n" p.wait() except (BrokenPipeError, ConnectionResetError): p.kill() return duration = round(time.time() - start, 1) passed = p.returncode == 0 status = "passed" if passed else "failed" yield f"data: {json.dumps({'type': 'result', 'passed': passed, 'duration': duration, 'summary': f'Step {step} {status}'})}\n\n" return Response( event_stream(), content_type="text/event-stream", headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*"}, ) # ── Health Check ─────────────────────────────────────────────────────────────── @app.route("/api/health") def health(): return jsonify({ "status": "ok", "version": "2.0.0", "uptime": datetime.now().isoformat(), "tasks_count": len(tasks_db), "reports_count": len(reports_db), }) # ── Scheduler ────────────────────────────────────────────────────────────────── class Scheduler: def _is_in_window(self, now, window_str): if not window_str or window_str == "all": return True current_time = now.strftime("%H:%M") try: for part in window_str.split(","): if "-" not in part: continue start, end = part.strip().split("-") if start <= current_time <= end: return True except Exception: pass return False def start(self): threading.Thread(target=self._loop, daemon=True).start() def _loop(self): while True: try: now = datetime.now() for tid, task in list(tasks_db.items()): if task["status"] == "running": continue stype = task.get("schedule_type", "once") last_run = task.get("last_scheduled_run") should_run = False if stype == "once" and task.get("scheduled_at") and task["status"] == "pending": if now >= datetime.fromisoformat(task["scheduled_at"]): should_run = True elif stype == "continuous": window = task.get("schedule_window", "00:00-23:59") if self._is_in_window(now, window): if last_run: delta = (now - datetime.fromisoformat(last_run)).total_seconds() if delta < 60: continue should_run = True elif stype != "once": if not last_run: should_run = True else: delta = (now - datetime.fromisoformat(last_run)).total_seconds() if (stype == "hourly" and delta >= 3600) or \ (stype == "daily" and delta >= 86400) or \ (stype == "weekly" and delta >= 86400 * 7): should_run = True if should_run: task["last_scheduled_run"] = now.isoformat() if stype == "once": task["status"] = "running" print(f"⏰ Triggered: {task['name']} (type: {stype})") threading.Thread(target=run_task_process, args=(task,), daemon=True).start() except Exception as e: print(f"❌ Scheduler error: {e}") time.sleep(30) # ── Startup ──────────────────────────────────────────────────────────────────── def create_app(): return app if __name__ == "__main__": port = int(os.getenv("PLATFORM_PORT", "5001")) print(f"🚀 AutoFlow Platform starting... http://127.0.0.1:{port}") Scheduler().start() app.run(host="0.0.0.0", port=port)