printbox 0.2.51__py3-none-any.whl

printbox/__init__.py

@@ -0,0 +1,5 @@
+"""PrintBox —— 把一台精简 Linux 主机变成无头打印服务器。
+
+以 pip 包形式分发，安装后由 printbox init 在本机配置打印/网络栈与 systemd 服务。
+"""
+__version__ = "0.2.51"

printbox/__main__.py

@@ -0,0 +1,4 @@
+from printbox.cli import main
+
+if __name__ == "__main__":
+    main()

printbox/about.py

@@ -0,0 +1,48 @@
+"""PrintBox 关于/发布页内容。
+
+优先读取 /var/lib/printbox/about.json（可由管理员就地编辑，无需重装），
+回退到打包的 data/about.json。WebUI 的“关于”页渲染此内容；
+用户后续新增的版本功能、改进内容、发布页面链接都放在这个 JSON 里即可。
+"""
+import json
+import os
+
+from . import config as C
+from . import __version__
+
+
+def _pkg_path():
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "data", "about.json")
+
+
+def load_about():
+    state_path = os.path.join(C.STATE_DIR, "about.json")
+    for p in (state_path, _pkg_path()):
+        if os.path.exists(p):
+            try:
+                with open(p, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                data.setdefault("version", __version__)
+                return data
+            except Exception:
+                continue
+    return {
+        "project": "PrintBox",
+        "tagline": "把一台精简 Linux 主机变成无头打印服务器",
+        "description": "",
+        "homepage": "",
+        "releases_url": "",
+        "features": [],
+        "changelog": [],
+        "version": __version__,
+    }
+
+
+def save_about(data):
+    """就地保存（管理员可在设备上改关于页内容）。"""
+    path = os.path.join(C.STATE_DIR, "about.json")
+    C.ensure_dirs()
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+    os.replace(tmp, path)

printbox/archive.py

@@ -0,0 +1,232 @@
+"""PrintBox 打印文件归档（自动配额 + 环型轮替）。
+
+- 每次打印的原始文件都保存下来，便于追溯。
+- 归档空间按磁盘容量自动计算（见 config.compute_archive_quota）。
+- 装满后自动删除最旧的文件（轮替），不会无限增长。
+
+依赖 CUPS 的 PreserveJobFiles（由 printers.enable_job_archive 开启）。
+"""
+import os
+import re
+import sys
+import time
+import json
+import shutil
+
+from . import config as C
+
+SPOOL = C.SPOOL
+POLL_INTERVAL = 15          # 秒
+EXT_MAP = {
+    "application/pdf": "pdf",
+    "application/postscript": "ps",
+    "application/vnd.cups-postscript": "ps",
+    "image/urf": "urf",
+    "image/pwg-raster": "pwg",
+    "text/plain": "txt",
+    "text/html": "html",
+    "application/octet-stream": "bin",
+}
+
+
+def ensure_preserve():
+    # PreserveJobFiles 保留原始文件；PreserveJobHistory 让已完成作业在 lpstat -W completed 中
+    # 保留更久，避免刚打印完、归档轮询还没跑到时作业就从历史里消失（表现为“历史只有旧记录”）。
+    # 0.2.48：改为直接写 cupsd.conf（幂等 no-op），不再调用 cupsctl 做 live reload——
+    # 对 PreserveJobFiles/PreserveJobHistory 的 live 重载会让 cupsd 立即崩溃重启、重跑作业。
+    from . import printers
+    try:
+        printers.enable_job_archive()
+    except Exception:
+        pass
+
+
+def list_completed_jobs():
+    """返回已完成作业列表 [{id, printer, user, name, format}]。"""
+    jobs = {}
+    rc, out, _ = C.run(["lpstat", "-W", "completed", "-o"])
+    for line in out.splitlines():
+        line = line.strip()
+        m = re.match(r"^(\S+?)-(\d+)\s+(\S+)\s+(\d+)\s+(.*)$", line)
+        if m:
+            prn, jid, user, _size, rest = m.groups()
+            jobs[int(jid)] = {
+                "id": int(jid), "printer": prn, "user": user,
+                "name": rest.strip(), "format": "",
+            }
+    rc, out2, _ = C.run(["lpstat", "-l", "-W", "completed", "-o"])
+    cur = None
+    for line in out2.splitlines():
+        if re.match(r"^\S+?-\d+\s", line):
+            mm = re.match(r"^(\S+?)-(\d+)", line)
+            cur = int(mm.group(2)) if mm else None
+        elif cur is not None and "document-format" in line:
+            parts = line.split(None, 1)
+            if len(parts) == 2:
+                jobs.get(cur, {})["format"] = parts[1].strip()
+    return list(jobs.values())
+
+
+def load_state(d):
+    sp = os.path.join(d, "state.json")
+    if os.path.exists(sp):
+        try:
+            with open(sp) as f:
+                return set(json.load(f).get("processed", []))
+        except Exception:
+            return set()
+    return set()
+
+
+def save_state(d, processed):
+    sp = os.path.join(d, "state.json")
+    tmp = sp + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump({"processed": sorted(processed)}, f)
+    os.replace(tmp, sp)
+
+
+def sanitize(s, maxlen=40):
+    s = re.sub(r"[^\w\-_. ]", "_", s or "job").strip() or "job"
+    return s[:maxlen]
+
+
+def ext_for(format_str):
+    return EXT_MAP.get((format_str or "").lower(), "bin")
+
+
+def archive_one(job, d, processed):
+    jid = job["id"]
+    # CUPS spool 数据文件名是 5 位零填充（如 d00012），不能用裸 d{jid} 匹配；
+    # 用 ^d0*{jid} 兼容任意前导零（d12 / d0012 / d00012 都能命中）。
+    pat = re.compile(rf"^d0*{jid}(?:-\d+)?$")
+    matches = sorted(p for p in os.listdir(SPOOL) if pat.match(p))
+    ts = time.strftime("%Y%m%d-%H%M%S")
+    user = sanitize(job["user"], 20)
+    name = sanitize(job["name"])
+    ext = ext_for(job.get("format"))
+    base = f"{ts}_{jid}_{user}_{name}"
+    saved = []
+    if matches:
+        for i, fn in enumerate(matches):
+            src = os.path.join(SPOOL, fn)
+            suffix = f".{i+1}" if len(matches) > 1 else ""
+            dst = os.path.join(d, f"{base}{suffix}.{ext}")
+            try:
+                shutil.copy2(src, dst)
+                saved.append(dst)
+            except Exception as e:
+                C.log("archive", "WARN", f"复制作业 {jid} 文件失败: {e}")
+    # 即便 spool 文件已不在（CUPS 清理/未开启保留），也写一条历史元数据包，
+    # 保证“最近打印”稳定出现在历史里（仅无原文件可下载）。
+    meta = {
+        "job_id": jid,
+        "printer": job.get("printer"),
+        "user": job.get("user"),
+        "job_name": job.get("name"),
+        "format": job.get("format"),
+        "archived_at": ts,
+        "files": [os.path.basename(x) for x in saved],
+        "no_file": len(saved) == 0,
+    }
+    with open(os.path.join(d, base + ".meta.json"), "w") as f:
+        json.dump(meta, f, indent=2, ensure_ascii=False)
+    if saved:
+        C.log("archive", "INFO", f"已归档作业 {jid} ({job.get('name')}) -> {len(saved)} 个文件")
+    else:
+        C.log("archive", "DEBUG",
+              f"作业 {jid} 无 spool 原文件（已记历史元数据；可能 PreserveJobFiles 未生效）")
+    processed.add(jid)
+    return True
+
+
+def enforce_quota(d, max_bytes):
+    if max_bytes <= 0:
+        return
+    files = []
+    total = 0
+    for name in os.listdir(d):
+        if name.endswith(".meta.json") or name == "state.json":
+            continue
+        fp = os.path.join(d, name)
+        try:
+            stt = os.stat(fp)
+        except OSError:
+            continue
+        files.append((stt.st_mtime, fp))
+        total += stt.st_size
+    if total <= max_bytes:
+        return
+    files.sort()
+    C.log("archive", "INFO",
+          f"归档超出配额 ({total/1024/1024:.1f}/{max_bytes/1024/1024:.1f} MB)，开始轮替删除最旧文件")
+    for mtime, fp in files:
+        if total <= max_bytes:
+            break
+        try:
+            sz = os.path.getsize(fp)
+            os.remove(fp)
+            total -= sz
+            meta = fp[:-4] + ".meta.json" if not fp.endswith(".meta.json") else fp
+            if os.path.exists(meta):
+                os.remove(meta)
+            C.log("archive", "INFO", f"轮替删除: {os.path.basename(fp)}")
+        except OSError:
+            pass
+
+
+def run_once(dry=False):
+    cfg = C.load_config()
+    a = cfg.get("archive", {})
+    if not a.get("enabled", True):
+        return
+    d = a.get("dir", C.ARCHIVE_DIR)
+    os.makedirs(d, exist_ok=True)
+    ensure_preserve()
+    max_mb = int(a.get("max_size_mb", 0) or 0)
+    if max_mb <= 0:
+        try:
+            st = os.statvfs("/")
+            total = st.f_frsize * st.f_blocks
+            max_mb = C.compute_archive_quota(total)
+            a["max_size_mb"] = max_mb
+            C.save_config(cfg)
+        except Exception:
+            max_mb = 2048
+    max_bytes = max_mb * 1024 * 1024
+
+    processed = load_state(d)
+    jobs = list_completed_jobs()
+    new_count = 0
+    for job in jobs:
+        if job["id"] in processed:
+            continue
+        if archive_one(job, d, processed):
+            new_count += 1
+        else:
+            C.log("archive", "DEBUG",
+                  f"已完成作业 {job['id']} 未在 spool 找到原始数据文件"
+                  f"（可能 PreserveJobFiles 关闭、或文件已被 CUPS 清理）")
+    if new_count:
+        save_state(d, processed)
+    if not dry:
+        enforce_quota(d, max_bytes)
+
+
+def main():
+    C.ensure_dirs()
+    if "--once" in sys.argv:
+        run_once()
+        return 0
+    C.log("archive", "INFO", "打印归档守护进程启动")
+    while True:
+        try:
+            run_once()
+        except Exception as e:
+            C.log("archive", "ERROR", f"归档循环异常: {e}")
+        time.sleep(POLL_INTERVAL)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

printbox/cli.py

@@ -0,0 +1,186 @@
+"""PrintBox 命令行入口（console_scripts: printbox）。
+
+子命令：
+  init      把本机配置为打印服务器（安装系统依赖 + 写入并启用 systemd 服务）；可加 --no-apt 跳过安装
+  repair    修复模式：不装依赖，仅重启服务并重新发布打印机到局域网（适合 init 中断后补救）
+  start     启动全部服务（含开机自启已由 init 设置）
+  stop      停止全部服务
+  restart   重启全部服务
+  status    查看服务状态
+  detect    探测并添加打印机（自动安装驱动）
+  web       仅在前台运行 Web 管理界面（调试用）
+  archive   执行一次/守护归档扫描（--daemon 持续运行）
+  prune     删除设备已移除的幽灵打印机队列（如裸名 print）
+  version   显示版本
+"""
+import argparse
+import os
+import subprocess
+import sys
+
+from . import __version__
+from . import config as C
+
+SERVICES = ["printbox-web", "printbox-archive", "printbox-printer-hotplug"]
+
+
+def _need_root():
+    if os.geteuid() != 0:
+        sys.exit("错误：该命令需要 root 权限，请使用 sudo 运行（例如：sudo printbox init）。")
+
+
+def _systemctl(action, services=None):
+    cmd = ["systemctl", action]
+    if services:
+        cmd += services
+    r = subprocess.run(cmd, capture_output=True, text=True)
+    if r.stdout:
+        print(r.stdout.rstrip())
+    if r.stderr:
+        print(r.stderr.rstrip(), file=sys.stderr)
+    return r.returncode
+
+
+def cmd_init(args):
+    _need_root()
+    from . import init
+    init.provision(skip_apt=getattr(args, "no_apt", False))
+
+
+def cmd_repair(args):
+    _need_root()
+    from . import init
+    init.repair()
+
+
+def cmd_start(args):
+    _need_root()
+    _systemctl("start", SERVICES)
+    print("已启动 PrintBox 服务。")
+
+
+def cmd_stop(args):
+    _need_root()
+    _systemctl("stop", SERVICES)
+    print("已停止 PrintBox 服务。")
+
+
+def cmd_restart(args):
+    _need_root()
+    _systemctl("restart", SERVICES)
+    print("已重启 PrintBox 服务。")
+
+
+def cmd_status(args):
+    _need_root()
+    for s in SERVICES:
+        r = subprocess.run(["systemctl", "is-active", "--quiet", s])
+        state = "运行中" if r.returncode == 0 else "未运行"
+        print(f"  {s:28s} {state}")
+
+
+def cmd_detect(args):
+    _need_root()
+    from . import printers
+    printers.main()
+
+
+def cmd_web(args):
+    from . import webapp
+    webapp.main()
+
+
+def cmd_republish(args):
+    _need_root()
+    from . import printers
+    printers.republish_airprint()
+    print("已重新发布打印机到局域网（AirPrint/mDNS）。手机/电脑应能在数秒内发现。")
+
+
+def cmd_mdns_check(args):
+    _need_root()
+    from . import printers
+    msg = printers.self_heal_publish()
+    print(msg)
+
+
+def cmd_prune(args):
+    _need_root()
+    from . import printers
+    removed = printers.prune_phantom_printers()
+    if removed:
+        print(f"已删除幽灵打印机队列: {', '.join(removed)}")
+    else:
+        print("未发现需要清理的幽灵打印机队列。")
+
+
+def cmd_guard(args):
+    _need_root()
+    from . import printers
+    n = printers.guard_runaway_jobs()
+    if n:
+        print(f"已取消 {n} 个重复在途作业（打印洪流防护）。")
+    else:
+        print("未检测到重复在途作业。")
+
+
+def cmd_archive(args):
+    from . import archive
+    if args.daemon:
+        archive.main()
+    else:
+        archive.run_once()
+        print("归档扫描完成。")
+
+
+def cmd_version(args):
+    print(f"printbox {__version__}")
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="printbox", description="PrintBox 无头打印服务器")
+    sub = p.add_subparsers(dest="cmd")
+
+    p_init = sub.add_parser("init", help="配置本机为打印服务器（安装依赖 + 启用服务）")
+    p_init.add_argument("--no-apt", action="store_true",
+                        help="跳过 apt 安装，仅做配置/服务/发布（适合 install 中断后补救）")
+    sub.add_parser("repair", help="修复模式：不装依赖，仅重启服务并重新发布打印机到局域网")
+    sub.add_parser("start", help="启动全部服务")
+    sub.add_parser("stop", help="停止全部服务")
+    sub.add_parser("restart", help="重启全部服务")
+    sub.add_parser("status", help="查看服务状态")
+    sub.add_parser("detect", help="探测并添加打印机（自动安装驱动）")
+    sub.add_parser("web", help="前台运行 Web 管理界面（调试）")
+    sub.add_parser("republish", help="重新发布打印机到局域网（AirPrint/mDNS）")
+    sub.add_parser("mdns-check", help="自检 AirPrint 是否在局域网可见，不可见则自动重新发布（供定时器调用）")
+    sub.add_parser("prune", help="删除设备已移除的幽灵打印机队列（如裸名 print）并清理其服务文件")
+    sub.add_parser("guard", help="打印洪流防护：取消同文档重复提交的在途作业（由定时器定期调用）")
+    pa = sub.add_parser("archive", help="执行归档扫描")
+    pa.add_argument("--daemon", action="store_true", help="持续守护运行")
+    sub.add_parser("version", help="显示版本")
+
+    args = p.parse_args(argv)
+    if not args.cmd:
+        p.print_help()
+        return
+
+    {
+        "init": cmd_init,
+        "repair": cmd_repair,
+        "start": cmd_start,
+        "stop": cmd_stop,
+        "restart": cmd_restart,
+        "status": cmd_status,
+        "detect": cmd_detect,
+        "web": cmd_web,
+        "archive": cmd_archive,
+        "republish": cmd_republish,
+        "mdns-check": cmd_mdns_check,
+        "prune": cmd_prune,
+        "guard": cmd_guard,
+        "version": cmd_version,
+    }[args.cmd](args)
+
+
+if __name__ == "__main__":
+    main()