fix(854-2): M01 수식 문서 쓰기 안전 길 — 잠금 · 임시 파일 → 교체 · 문서별 판 대조 409 — 묶음 ①

- Doc.put 한 곳으로 씀(save · drop · Machine._register_docs) · Doc._LOCK 안 · 임시 파일 → os.replace
- 판 = 문서 한 장 저장 글 지문 · 읽기가 「판」 을 줌 · /logic/doc/save 가 받은 판과 다르면 409(화면 Save_Stale 과 같은 글) · 판 없음 = 대조 안 함(옛 부름 · 시험)
- M01 줄 쌓기 [저장]이 판을 보냄(M02 사본 길은 그대로) — 기계 목록 등록이 바꾼 문서를 옛 화면이 덮지 않음
- 수식 문서 폴더가 AISLO_MASTER_DIR 사본을 따름(마스터 사본 · 문서 정본이 갈리던 것) · 마스터만 사본인 시험은 정본 문서를 안 씀
- 시험 test_854_2_m01_doc_write — 옛 판 409 · 동시 두 저장 = 하나 ok 하나 409 · 기계 등록 뒤 옛 판 409 · 정본 안 씀

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:43:09 +09:00
co-authored by Claude Opus 5.5
parent ba6f25b971
commit fe9920851c
6 changed files with 221 additions and 40 deletions
+4 -1
View File
@@ -533,7 +533,10 @@ export function createStackScreen(opt: StackScreenOptions) {
const save = async (job?: Record<string, unknown>, done = ft("Saved")): Promise<boolean> => {
await loading; // 새 로직 저장 뒤 여는 중이면 다 읽고(캐시 이어 받음)
if (!doc || (!job && !dirty())) return true;
const send = job ?? (cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc });
// M01 = 읽을 때 받은 판도(그 사이 다른 곳에서 바뀌면 409 · 덮지 않음)
const send =
job ??
(cp ? { 문서: doc, 끊음: cut, 판: version, ...pending() } : { 문서: doc, 판: version });
const was = saved;
showLoadingOverlay();
try {
+52 -23
View File
@@ -16,6 +16,8 @@
from __future__ import annotations
import json
import os
import threading
from decimal import Decimal
from pathlib import Path
@@ -30,12 +32,33 @@ import master_equation_link as link # noqa: E402
OWN_FILE = "수식_자체.json"
_memo: dict = {}
# 수식 문서 쓰기 한 번에 하나 — 저장 · 지움 · 기계 고르기 목록 등록(`Machine._register_docs`)
# ponytail: 프로세스 안 잠금(`Store._LOCK` 과 같은 한계) · 서버를 여럿 띄우면 파일 잠금으로
_LOCK = threading.Lock()
_HOME = Path(ml.__file__).resolve().parents[1] # 저장소 정본 마스터 폴더
STALE = "그 사이 파일이 바뀜 — 고친 것을 버리고 다시 여세요: {v}" # 화면 `Save_Stale` 과 같은 글
def folder() -> Path:
return ml.FOLDER
def version_of(doc: dict | None) -> str:
"""문서 한 장의 판(저장 글 기준) — 저장본 없음 = 빈 글."""
return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8"))
def put(path: Path, data: dict) -> None:
"""수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름.
마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀."""
if path.resolve().parent.parent == _HOME and Path(store.FOLDER).resolve() != _HOME:
return
tmp = path.with_name(f".{path.name}.tmp")
tmp.write_text(ml.dump(data), encoding="utf-8", newline="\n")
os.replace(tmp, path)
_memo.clear()
def _stamp() -> tuple:
return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json")))
@@ -95,7 +118,8 @@ def read(key: str) -> dict:
out = _run(found)
up = None if fresh else built(key)
more = {"층바탕": {"위": up}} if up is not None else {}
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, **more}
판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more}
def preview(doc: dict, given: dict | None = None) -> dict:
@@ -150,22 +174,27 @@ def layered(doc: dict, key: str) -> dict:
return out
def save(doc: dict) -> dict:
def save(doc: dict, 판: str | None = None) -> dict:
"""`판` = 읽을 때 받은 판(없음 = 대조 안 함 · 빈 글 = 저장본 없던 문서) · 다르면 409."""
doc = _check(doc)
key = str(doc["키"]).strip()
doc = layered(doc, key)
name = _file_for(key)
path = folder() / name
data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
rows = data.setdefault("줄", [])
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
if at is None:
rows.append(doc)
else:
rows[at] = doc
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
_memo.clear()
return {"문서": doc, **_run(doc), "파일": name}
with _LOCK:
doc = layered(doc, key)
name = _file_for(key)
path = folder() / name
data = (
ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
)
rows = data.setdefault("줄", [])
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
if 판 is not None and version_of(None if at is None else rows[at]) != 판:
raise store.StoreError(409, STALE.format(v=f"{name} {key}"))
if at is None:
rows.append(doc)
else:
rows[at] = doc
put(path, data)
return {"문서": doc, **_run(doc), "파일": name, "판": version_of(doc)}
def candidates(ask: dict) -> dict:
@@ -222,14 +251,14 @@ def users(key: str) -> list[str]:
def drop(key: str) -> None:
"""수식 문서 줄 하나 지움(없으면 그냥)."""
name = _where(key)
if not name:
return
path = folder() / name
data = ml.load_file(path)
data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key]
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
_memo.clear()
with _LOCK:
name = _where(key)
if not name:
return
path = folder() / name
data = ml.load_file(path)
data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key]
put(path, data)
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
+18 -14
View File
@@ -182,22 +182,26 @@ def register(batch: list[dict]) -> Callable[[], None]:
def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None:
"""수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀."""
"""수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀
(수식 문서 쓰기 길 `Doc.put` · 잠금 안 — 화면 저장과 겹쳐도 한쪽이 덮지 않음)."""
import master_doc_link as ml # noqa: E402
for path in sorted(ml.FOLDER.glob("수식_*.json")):
data, hit = ml.load_file(path), False
for doc in data.get("줄") or []:
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") != "선택" or v.get("이름") != "기계":
continue
codes = [c for c in link.get("목록") or [] if str(c) not in drop]
codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes]
if codes != link.get("목록"):
link["목록"], hit = codes, True
if hit:
path.write_text(ml.dump(data), encoding="utf-8", newline="\n")
from M01_MasterData import M01_MasterData_Doc as docs
with docs._LOCK:
for path in sorted(docs.folder().glob("수식_*.json")):
data, hit = ml.load_file(path), False
for doc in data.get("줄") or []:
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") != "선택" or v.get("이름") != "기계":
continue
codes = [c for c in link.get("목록") or [] if str(c) not in drop]
codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes]
if codes != link.get("목록"):
link["목록"], hit = codes, True
if hit:
docs.put(path, data)
# ── 쓰는 곳 = `M01_MasterData_Machine_Uses`(수식 문서 기준 · 848-5) ──────────────
+2 -1
View File
@@ -318,6 +318,7 @@ def post_logic_formula_preview(body: FormulaPreview) -> dict:
class DocBody(BaseModel):
문서: dict[str, Any]
입력: dict[str, Any] = {}
판: str | None = None # 저장 — 읽을 때 받은 판(다르면 409 · 없으면 대조 안 함)
@router.get("/logic/doc")
@@ -335,7 +336,7 @@ def post_logic_doc_preview(body: DocBody) -> dict:
@router.post("/logic/doc/save")
def post_logic_doc_save(body: DocBody) -> dict:
"""저장 — 서버가 정본으로 다시 셈 · 문서 파일에 씀 → {문서, 셈, 연결, 파일}."""
return _call(doc_screen.save, body.문서)
return _call(doc_screen.save, body.문서, body.판)
class RemoveBody(BaseModel):
@@ -14,6 +14,7 @@
from __future__ import annotations
import json
import os
from decimal import Decimal
from pathlib import Path
@@ -24,7 +25,9 @@ import master_machine_crew as mcrew
import master_material as mm
import master_pick as mp
FOLDER = Path(__file__).resolve().parents[1] / "수식문서"
# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본
_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1]
FOLDER = Path(_HOME).resolve() / "수식문서"
_ARITH_OK = ("num", "bin", "neg")
@@ -0,0 +1,141 @@
"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체.
마스터 · 수식 문서 사본 폴더에서만 씀.
"""
from __future__ import annotations
import shutil
from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Store as store
REAL = store.FOLDER
@pytest.fixture
def master(tmp_path: Path, monkeypatch) -> Path:
for path in REAL.glob("*.json"):
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
shutil.copy(path, tmp_path / path.name)
shutil.copytree(REAL / "기계", tmp_path / "기계")
monkeypatch.setattr(store, "FOLDER", tmp_path)
return tmp_path
DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력)
@pytest.fixture
def docs(master: Path, monkeypatch) -> Path:
from M01_MasterData import M01_MasterData_Doc as doc_screen
folder = master / "수식문서"
shutil.copytree(REAL / "수식문서", folder)
monkeypatch.setattr(doc_screen.ml, "FOLDER", folder)
doc_screen._memo.clear()
return folder
def _client():
from fastapi import FastAPI
from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
app = FastAPI()
app.include_router(router_module.router)
return TestClient(app)
def _renamed(doc: dict, tail: str) -> dict:
return {**doc, "이름": f"{doc['이름']} {tail}"}
def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None:
client = _client()
got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
assert got["판"] and not got["새"]
first = client.post(
"/api/m01/logic/doc/save",
json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]},
)
assert first.status_code == 200, first.text
again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판
late = client.post(
"/api/m01/logic/doc/save",
json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]},
)
assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"]
assert again["문서"]["이름"].endswith("sub5임시A")
now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음
assert not list(docs.glob(".*.tmp"))
def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None:
import threading
import time
from M01_MasterData import M01_MasterData_Doc as doc_screen
got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON)
real = doc_screen.layered
def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘
time.sleep(0.3)
return real(doc, key)
monkeypatch.setattr(doc_screen, "layered", slow)
plain = got["문서"]
out: list[str] = []
def one(tail: str) -> None:
try:
doc_screen.save(_renamed(plain, tail), got["판"])
out.append("ok")
except doc_screen.store.StoreError as e:
out.append(str(e.status))
runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")]
for t in runs:
t.start()
for t in runs:
t.join()
assert sorted(out) == ["409", "ok"]
def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None:
from M01_MasterData import M01_MasterData_Doc as doc_screen
from M01_MasterData import M01_MasterData_Machine as machine
key = next(
k
for k, d in doc_screen.docs().items()
if any(
v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택"
for v in d.get("변수") or []
)
)
got = _client().get("/api/m01/logic/doc", params={"key": key}).json()
machine._register_docs({key: ["sub5임시EQ"]}, set())
after = doc_screen.read(key)
assert after["판"] != got["판"]
plain = got["문서"]
with pytest.raises(doc_screen.store.StoreError) as e:
doc_screen.save(_renamed(plain, "sub5임시"), got["판"])
assert e.value.status == 409
picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계")
assert "sub5임시EQ" in picks["연결"]["목록"]
def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None:
from M01_MasterData import M01_MasterData_Doc as doc_screen
path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈)
raw = path.read_bytes()
doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []})
assert path.read_bytes() == raw