fix(854-1): 내 기계 저장 잠금 · 판 대조 · 번호 겹침 막음 — 묶음 ①

- 번호 발급 + 쓰기를 한 잠금 안에서(`M02_MyMachine.add`) · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음)
- 화면 만들기 · 단가산출 [저장] 초안(`M02_MyMachine_Draft._new`) · 불러오기 자동 생성(`create` 꼴 그대로) 모두 이 한 길
- 고치기 = 화면이 연 판을 보냄 · 다르면 409 {stale, 판} → 화면 「그 사이 다른 곳에서 바뀜」 · 서버 길(판 없음) = 대조 없음
- 답에 `판` · 지우기도 잠금 안
- 시험 test_854_1 — 동시 만들기 8 번 번호 겹침 0(옛 코드 = 8 번 중 3 번호) · 옛 판 409 · 뒤처진 `_다음` 이 있는 파일을 안 덮음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 15:59:02 +09:00
co-authored by Claude Opus 5.5
parent 9c67cdac64
commit cce681df12
7 changed files with 157 additions and 33 deletions
+55 -20
View File
@@ -23,6 +23,8 @@ from __future__ import annotations
import json
import os
import re
import threading
from collections.abc import Callable
from contextvars import ContextVar
from datetime import datetime
from decimal import Decimal
@@ -53,6 +55,11 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199"
FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b)
#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게)
# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로
_LOCK = threading.RLock()
#: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음
DRAFT: ContextVar[tuple] = ContextVar("내기계초안", default=())
@@ -106,6 +113,26 @@ def _put(row: dict) -> None:
atomic_write_json(_dir() / f"{row['키']}.json", row)
def version(key: str) -> str:
"""내 기계 한 대 판(파일 바이트 지문 · 없으면 빈 글)."""
path = _dir() / f"{key}.json"
return store.version_of(path.read_bytes()) if path.is_file() else ""
def add(build: Callable[[str], dict]) -> dict:
"""새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) ·
`build(키)` = 저장 줄."""
with _LOCK:
_move()
user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1)
while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists():
n += 1
row = build(f"{PREFIX}{user}-{n:04d}")
atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
_put(row)
return row
def _read(folder: Path | None = None) -> dict[str, Any]:
_move(folder)
base = _dir(folder)
@@ -420,9 +447,9 @@ def create_own(raw: Any = None, base: str | None = None) -> dict[str, Any]:
return create(raw, base)
def update_own(key: str, raw: Any) -> dict[str, Any]:
def update_own(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
not_m01(raw, key)
return update(key, raw)
return update(key, raw, ver)
def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
@@ -430,37 +457,44 @@ def create(raw: Any = None, base: str | None = None) -> dict[str, Any]:
seed = _seed(base) if base else {}
raw = raw if isinstance(raw, dict) else {}
body = clean({**seed, **raw, "값": {**seed.get("값", {}), **(raw.get("값") or {})}})
data = _read()
key = f"{PREFIX}{_user()}-{data['다음']:04d}"
when = _now()
row = {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인", "상세구분": body["이름"],
**body, "넣은날": when, "고친날": when, **({"본뜬": base} if base else {})} # fmt: skip
atomic_write_json(_dir() / NEXT, {"다음": data["다음"] + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
_put(row)
row = add(lambda key: {"키": key, "원문번호": f"{NO}{key}", "원문": "개인", "구분": "개인",
"상세구분": body["이름"], **body, "넣은날": when, "고친날": when,
**({"본뜬": base} if base else {})}) # fmt: skip
return answer(row)
def update(key: str, raw: Any) -> dict[str, Any]:
_user()
data = _read()
old = next((r for r in data["줄"] if r["키"] == key), None)
def _old(key: str) -> dict:
old = next((r for r in rows() if r["키"] == key), None)
if old is None:
raise _bad(f"없는 내 기계 「{key}」", 404)
return old
def update(key: str, raw: Any, ver: str | None = None) -> dict[str, Any]:
"""고침 — `ver`(화면이 연 판)가 지금 판과 다르면 409 {stale, 판} · None = 대조 없음(초안 저장 등 서버 길)."""
_user()
_old(key)
body = clean(raw)
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
_put(row)
return answer(row)
with _LOCK:
old = _old(key)
if ver is not None and (have := version(key)) != ver:
raise store.StoreError(409, {"stale": [key], "판": have})
keep = {k: old[k] for k in ("키", "원문번호", "원문", "구분", "넣은날", "본뜬") if k in old}
row = {**keep, "상세구분": body["이름"], **body, "고친날": _now()}
_put(row)
now = version(key) # 잠금 안 판 — 뒤 고침이 끼어도 화면이 그 고침을 덮지 않게
return {**answer(row), "판": now}
def delete(key: str) -> dict[str, Any]:
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
_user()
data = _read()
if not any(r["키"] == key for r in data["줄"]):
raise _bad(f"없는 내 기계 「{key}」", 404)
_old(key)
used = uses().get(key, [])
(_dir() / f"{key}.json").unlink(missing_ok=True)
with _LOCK:
_old(key)
(_dir() / f"{key}.json").unlink(missing_ok=True)
return {"지움": key, "쓰는곳": used}
@@ -509,6 +543,7 @@ def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
def answer(row: dict, used: list | None = None) -> dict[str, Any]:
out = {
"줄": row,
"판": version(row["키"]),
"시간당": hourly(engine(row), whole()),
"같은이름": same(row["이름"], row["규격"], row["키"]),
}
+4 -1
View File
@@ -48,6 +48,8 @@ export interface Use {
export interface MyMachineOne {
줄: MyMachine;
/** 연 판(854-1) — 고치기 때 보냄 · 다르면 409(`StaleError`) */
판?: string;
시간당: MyHourly;
같은이름: { 키: string; 이름: string; 규격: string; 출처: string }[];
쓰는곳?: Use[];
@@ -116,8 +118,9 @@ export const updateMyMachine = (
owner: string | null,
k: string,
body: MyMachineBody,
ver?: string,
): Promise<MyMachineOne> =>
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) });
call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body, 판: ver ?? null }) });
/** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */
export interface MyMachineImpact {
+10 -6
View File
@@ -140,15 +140,19 @@ def renew(copy: Any) -> Any:
def _new(row: dict) -> str:
"""새 내 기계 파일(`mym.create` 와 같은 꼴 · 값은 초안 그대로 — 본뜬 값을 다시 섞지 않음)."""
data = mym._read()
key = f"{mym.PREFIX}{mym._user()}-{data['다음']:04d}"
when = mym._now()
head = {"키": key, "원문번호": f"{mym.NO}{key}", "원문": "개인", "구분": "개인"}
body = {k: row[k] for k in ("상세구분", *BODY, "단위", "출처") if k in row}
tail = {"넣은날": when, "고친날": when, **({"본뜬": row["본뜬"]} if row.get("본뜬") else {})}
mym.atomic_write_json(mym._dir() / mym.NEXT, {"다음": data["다음"] + 1}) # 번호 먼저
mym._put({**head, **body, **tail})
return key
return mym.add( # 번호 발급 + 쓰기 한 잠금(854-1)
lambda key: {
"키": key,
"원문번호": f"{mym.NO}{key}",
"원문": "개인",
"구분": "개인",
**body,
**tail,
} # fmt: skip
)["키"]
def saving(body: dict, inner: Callable[[dict], Any]) -> Any:
+6 -4
View File
@@ -33,6 +33,7 @@ import {
type MyMachineOne,
type SimilarRow,
} from "./M02_MyMachine_Api";
import { StaleError } from "./M02_MasterTemplete_Api_Fetch";
import { confirmMyMachineImpact } from "./M02_MyMachine_Impact";
import { mt } from "./M02_MyMachine_Text";
import "./M02_MyMachine.css";
@@ -97,6 +98,7 @@ export async function mountMyMachineForm(
opt.key ? readMyMachine(opt.owner, opt.key) : Promise.resolve(null),
]);
const row = one?.줄;
let ver = one?.판; // 연 판(854-1) — 고치기 때 보냄 · 저장마다 새 판
let base: string | undefined; // 서버 `본뜬`
const notice = el("div", { className: "m02-mymach__notice" });
const server = el("div", { className: "m02-mymach__server" });
@@ -173,16 +175,16 @@ export async function mountMyMachineForm(
// 정본 고침 = 영향 보고 저장(848-5)
if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return;
const got = opt.key
? await updateMyMachine(opt.owner, opt.key, body)
? await updateMyMachine(opt.owner, opt.key, body, ver)
: await createMyMachine(opt.owner, body, base);
ver = got.판;
saved = true;
opt.onDirty?.(false);
showToast(mt("Saved"), "success");
opt.onSaved(got);
} catch (error) {
notice.replaceChildren(
createText(error instanceof Error ? error.message : mt("Failed"), "error"),
);
const why = error instanceof StaleError ? mt("Stale") : error instanceof Error ? error.message : mt("Failed"); // prettier-ignore
notice.replaceChildren(createText(why, "error"));
} finally {
saveBtn.disabled = m01Same;
}
+4 -2
View File
@@ -2,7 +2,8 @@
GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) ·
POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) ·
PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}.
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
⚠ 등록은 `main.py`(로그인만).
@@ -30,6 +31,7 @@ class MachineBody(BaseModel):
본뜬: str | None = None
키: str | None = None # 초안 확인(827-1) — 고칠 내 기계
표지: str | None = None # 초안 확인(827-1) — 화면이 정한 표지(셈 기록 열쇠)
판: str | None = None # 고치기 — 화면이 연 판(854-1 · 다르면 409)
def _folder(session: Session, layer: str, owner: str | None, write: bool = False):
@@ -78,7 +80,7 @@ def my_machine_update(
owner: str | None = None,
session: Session = Depends(verify_session),
):
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄)
return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄, body.판)
@router.post(PATH + "/{key}/impact")
+1
View File
@@ -28,6 +28,7 @@ const TEXT = {
Back: "목록",
Close: "닫기",
Failed: "못 함",
Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침",
Name_Needed: "이름 · 비어 있음",
Same: "같은 이름 · 규격 있음 — {value}",
Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]",
@@ -0,0 +1,77 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침).
① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨
③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음.
"""
from __future__ import annotations
import json
import time
from concurrent.futures import ThreadPoolExecutor
import pytest
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
N = 8
def _at(folder, fn, *args):
with store.at(folder):
return fn(*args)
def _easy(name="sub4임시기계", **vals):
base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"}
return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals}
def test_parallel_create_no_clash(world, monkeypatch):
"""① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림)."""
me = world["personal"]
write = mym.atomic_write_json
def slow(path, value):
time.sleep(0.02)
write(path, value)
monkeypatch.setattr(mym, "atomic_write_json", slow)
with ThreadPoolExecutor(N) as pool:
got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N)))
keys = [r["키"] for r in got]
assert len(set(keys)) == N
files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json"))
assert len(files) == N
names = {json.loads(p.read_bytes())["이름"] for p in files}
assert names == {f"sub4임시{i}" for i in range(N)}
assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1
def test_stale_version_409(world):
"""② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음."""
me = world["personal"]
made = _at(me, mym.create, _easy())
key, old = made["줄"]["키"], made["판"]
assert old
fresh = _at(me, mym.update, key, _easy(가격=3000), old)
assert fresh["판"] and fresh["판"] != old
with pytest.raises(store.StoreError) as e:
_at(me, mym.update, key, _easy(가격=4000), old)
assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]}
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘
_at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000
def test_counter_behind_skips_file(world):
"""③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
me = world["personal"]
first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"]
(me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8")
second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"]
assert second != first
assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음"