diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index bb5e0ef15..7778fc825 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -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["키"]), } diff --git a/M02_MasterTemplete/M02_MyMachine_Api.ts b/M02_MasterTemplete/M02_MyMachine_Api.ts index bd686defe..a7f10a983 100644 --- a/M02_MasterTemplete/M02_MyMachine_Api.ts +++ b/M02_MasterTemplete/M02_MyMachine_Api.ts @@ -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 => - 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 { diff --git a/M02_MasterTemplete/M02_MyMachine_Draft.py b/M02_MasterTemplete/M02_MyMachine_Draft.py index cfb51347b..f289820e1 100644 --- a/M02_MasterTemplete/M02_MyMachine_Draft.py +++ b/M02_MasterTemplete/M02_MyMachine_Draft.py @@ -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: diff --git a/M02_MasterTemplete/M02_MyMachine_Form.ts b/M02_MasterTemplete/M02_MyMachine_Form.ts index ac7b6d766..bdb9f5941 100644 --- a/M02_MasterTemplete/M02_MyMachine_Form.ts +++ b/M02_MasterTemplete/M02_MyMachine_Form.ts @@ -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; } diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 31ee23219..75bc55a6a 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -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") diff --git a/M02_MasterTemplete/M02_MyMachine_Text.ts b/M02_MasterTemplete/M02_MyMachine_Text.ts index df7e114e1..d79a93497 100644 --- a/M02_MasterTemplete/M02_MyMachine_Text.ts +++ b/M02_MasterTemplete/M02_MyMachine_Text.ts @@ -28,6 +28,7 @@ const TEXT = { Back: "목록", Close: "닫기", Failed: "못 함", + Stale: "그 사이 다른 곳에서 바뀜 — 목록에서 다시 열어 고침", Name_Needed: "이름 · 비어 있음", Same: "같은 이름 · 규격 있음 — {value}", Copied: "「{value}」 값을 복사 — 고친 뒤 [저장]", diff --git a/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py new file mode 100644 index 000000000..001cf95e4 --- /dev/null +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -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임시처음"