Update with last fixes

This commit is contained in:
Alexey Dudin
2026-11-11 18:43:40 +03:00
parent 53980a5558
commit 58cc8090a9
24 changed files with 832 additions and 50 deletions
+12
View File
@@ -0,0 +1,12 @@
# секреты и мусор не должны попадать в контекст сборки образа
.env
.env.*
!.env.example
/build/
/dist/
*.egg-info/
__pycache__/
.engine/
.pytest_cache/
/tests/
/docs/
+18
View File
@@ -0,0 +1,18 @@
# Формат: одна переменная на строку, БЕЗ кавычек и БЕЗ комментариев в конце строки.
# `docker run --env-file` не снимает кавычки и не вырезает «# …» после значения: они станут частью значения.
# Знаки `$` в хеше пароля экранировать не нужно.
#
# Хеш пароля: docker run --rm -it site-engine site-engine hash-password
# Ключ сессий: docker run --rm site-engine site-engine gen-secret (не короче 32 символов)
SITE_ADMIN_LOGIN=admin
SITE_ADMIN_PASSWORD_HASH=
SITE_SECRET_KEY=
# Cookie с флагом Secure браузер примет только по https и на http://localhost.
# Если открываете админку по http с другого адреса (http://192.168.1.10:8181), поставьте 0.
SITE_COOKIE_SECURE=1
SITE_SESSION_HOURS=8
# Пути НЕ задавайте при запуске в Docker: в образе они уже указывают внутрь тома /data
# (SITE_ROOT=/data/site, SITE_DIST=/data/dist, SITE_STATE_DIR=/data/state).
# Для запуска без Docker: SITE_ROOT=examples/studio-site SITE_DIST=dist
+3 -2
View File
@@ -1,8 +1,9 @@
__pycache__/ __pycache__/
*.pyc *.pyc
.env
.venv/ .venv/
dist/ /dist/
build/ /build/
*.egg-info/ *.egg-info/
.engine/ .engine/
*.sqlite3 *.sqlite3
+5 -4
View File
@@ -1,10 +1,11 @@
# M2+: образ для админки, форм и MCP. Статику в production отдаёт nginx из тома dist/. # Один том /data: data/site (контент), data/dist (опубликованное), data/state (вход и аудит).
# Статику в production лучше отдавать nginx из data/dist/current.
FROM python:3.12-slim FROM python:3.12-slim
WORKDIR /app WORKDIR /app
COPY pyproject.toml README.md ./ COPY pyproject.toml README.md ./
COPY src ./src COPY src ./src
RUN pip install --no-cache-dir ".[server,mcp]" RUN pip install --no-cache-dir ".[server,mcp]" && mkdir -p /data/site /data/dist /data/state
ENV SITE_ROOT=/data/site SITE_DIST=/data/dist SITE_DB=/data/db/engine.sqlite3 ENV SITE_ROOT=/data/site SITE_DIST=/data/dist SITE_STATE_DIR=/data/state
VOLUME ["/data/site", "/data/dist", "/data/db"] VOLUME ["/data"]
EXPOSE 8000 EXPOSE 8000
CMD ["uvicorn", "site_engine.web.app:create_app", "--factory", "--host", "0.0.0.0", "--port", "8000"] CMD ["uvicorn", "site_engine.web.app:create_app", "--factory", "--host", "0.0.0.0", "--port", "8000"]
+49 -2
View File
@@ -26,7 +26,7 @@ site-engine/
├── docs/ # ТЗ, ревью, журнал решений ├── docs/ # ТЗ, ревью, журнал решений
├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект) ├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект)
├── .env.example # переменные окружения для админки ├── .env.example # переменные окружения для админки
├── tests/ # 178 тестов: ядро, сборка, безопасность, запись, вход и редактор ├── tests/ # 206 тестов: ядро, сборка, безопасность, запись, вход и редактор
└── src/site_engine/ └── src/site_engine/
├── cli.py # validate · build · preview · fragments ├── cli.py # validate · build · preview · fragments
├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка ├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка
@@ -50,6 +50,53 @@ site-engine/
└── mcp/ # перечень инструментов MVP (M3) └── mcp/ # перечень инструментов MVP (M3)
``` ```
## Запуск в Docker
Один том `/data`, в нём три каталога. Всё, что важно сохранить, лежит на хосте в `./data`.
| На хосте | В контейнере | Что это |
|---|---|---|
| `data/site` | `/data/site` | Ваш сайт: `site.yaml`, `pages/`, `content/`, фрагменты. Его правит редактор |
| `data/dist` | `/data/dist` | Опубликованные релизы и симлинк `current` |
| `data/state` | `/data/state` | Состояние входа и журнал `audit.jsonl` |
```bash
docker build -t site-engine .
docker run --rm -it site-engine site-engine hash-password # спросит пароль, напечатает хеш
docker run --rm site-engine site-engine gen-secret # ключ подписи сессий
cp .env.example .env # впишите хеш и ключ
mkdir -p data && cp -r examples/studio-site data/site # или положите свой сайт в data/site
docker run -d --name site-engine -p 8181:8000 --env-file .env -v "$PWD/data:/data" site-engine
```
Админка: `http://localhost:8181/admin/` (на обзоре сверху показаны абсолютные пути, которыми пользуется приложение), опубликованный сайт: `http://localhost:8181/`. Проверка того, что видит контейнер:
```bash
docker logs site-engine # строка «site-engine: site=/data/site, dist=/data/dist, state=/data/state, admin=on»
docker exec site-engine env | grep '^SITE_' # SITE_ROOT, SITE_DIST, SITE_STATE_DIR должны начинаться с /data/
```
Если вместо `/data/...` там относительные пути (`examples/studio-site`, `dist`), эти строки остались в вашем `.env` от старой версии: удалите `SITE_ROOT`, `SITE_DIST`, `SITE_STATE_DIR` из `.env`, так как значения из `--env-file` перекрывают значения из образа. При старте приложение само пишет об этом предупреждение.
Правила для `.env` при `docker run --env-file`:
- **Без кавычек.** Docker не снимает их, они станут частью значения.
- **Без комментариев в конце строки.** `KEY=value # текст` даёт значение «value # текст».
- **Знак `$` в хеше экранировать не нужно.** (Для `docker compose` и его `.env` его нужно удваивать: `$$`.)
Приложение проверяет эти значения строго: хеш, ключ, логин, флаг Secure и host с лишними символами не принимаются молча, `/admin/` не включается, а в `docker logs` пишется причина.
| Симптом | Причина |
|---|---|
| `/admin/` даёт 404 | Не заданы `SITE_ADMIN_PASSWORD_HASH` и `SITE_SECRET_KEY`, ключ короче 32 символов или в значении кавычки или комментарий; причина в `docker logs`: «админка отключена: …» |
| «Сайт не загружен» на обзоре | В `data/site` нет `site.yaml` или том не смонтирован; на обзоре виден абсолютный путь, который проверял движок |
| Опубликованного сайта нет на хосте | Том не смонтирован (`-v "$PWD/data:/data"`): релизы лежат внутри контейнера и пропадут вместе с ним |
| После ввода пароля снова страница входа | Cookie с флагом Secure не принимается по `http://` с адреса не `localhost`: поставьте `SITE_COOKIE_SECURE=0` |
| Ответ 422 с `"loc": ["query","request"]` | Образ собран из версии до исправления: пересоберите `docker build` |
Контейнер работает от root, поэтому файлы в `data/` на Linux будут принадлежать root. Чтобы этого избежать, добавьте `--user "$(id -u):$(id -g)"`.
## Вход в админку ## Вход в админку
Самый простой вариант: **один администратор, без ролей**, логин и хеш пароля задаются переменными окружения, БД для входа не нужна. Самый простой вариант: **один администратор, без ролей**, логин и хеш пароля задаются переменными окружения, БД для входа не нужна.
@@ -120,7 +167,7 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file
## Что проверено, а что нет ## Что проверено, а что нет
Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 178 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp). Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 206 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp).
## Соответствие журналу решений ## Соответствие журналу решений
+1 -1
View File
@@ -36,7 +36,7 @@ site-engine = "site_engine.cli:main"
where = ["src"] where = ["src"]
[tool.setuptools.package-data] [tool.setuptools.package-data]
site_engine = ["builtin/**/*"] site_engine = ["builtin/**/*", "web/admin/templates/*", "web/admin/static/*"]
[tool.pytest.ini_options] [tool.pytest.ini_options]
testpaths = ["tests"] testpaths = ["tests"]
-11
View File
@@ -1,11 +0,0 @@
# Каталоги
SITE_ROOT=examples/studio-site
SITE_DIST=dist
# Вход в админку (без этих переменных /admin/ отключена)
SITE_ADMIN_LOGIN=admin
SITE_ADMIN_PASSWORD_HASH= # site-engine hash-password
SITE_SECRET_KEY= # site-engine gen-secret (не короче 32 символов)
SITE_COOKIE_SECURE=1 # 0 только для локальной разработки по http
SITE_SESSION_HOURS=8
# SITE_PUBLIC_HOST=admin.example.com # если Host подменяется прокси
+1
View File
@@ -0,0 +1 @@
"""Сборка: реестр → проверка → рендер → релиз `dist/<build_id>` → атомарный `current`."""
+252
View File
@@ -0,0 +1,252 @@
"""Конвейер сборки (ТЗ 6.1, ADR-003): сборка — чистая функция от каталога сайта.
Порядок: load → validate → render → postprocess → publish. Неудачная сборка не трогает
`dist/current`; релиз пишется в staging и переименовывается целиком.
"""
from __future__ import annotations
import datetime as dt
import hashlib
import json
import os
import re
import shutil
from dataclasses import dataclass
from pathlib import Path
from markupsafe import escape
from ..core.models import Block, Page
from ..core.registry import BUILTIN_DIR, Registry, load_site
from ..core.render import ASSETS_BODY, ASSETS_HEAD, PageView, Renderer
from ..core.routes import RouteRef, build_route_table, route_to_output
from ..core.validate import validate_release, validate_workspace
from ..errors import EngineError, Report
BUILD_ID_RE = re.compile(r"^\d{8}T\d{6}-[0-9a-f]{8}$")
_TOKEN_VALUE_RE = re.compile(r"^[A-Za-z0-9#%.,()\s'\"/_+-]+$")
_SKIP_DIRS = {"dist", ".engine", ".git", "__pycache__", "node_modules"}
@dataclass
class BuildResult:
build_id: str
output_dir: Path
pages: int
source_hash: str
report: Report
def hash_tree(root: Path) -> str:
"""Хеш всех исходных файлов сайта: основа build_id и проверки детерминизма."""
digest = hashlib.sha256()
for path in sorted(p for p in root.rglob("*") if p.is_file()):
rel = path.relative_to(root)
if _SKIP_DIRS & set(rel.parts):
continue
digest.update(rel.as_posix().encode("utf-8"))
digest.update(b"\0")
digest.update(path.read_bytes())
digest.update(b"\0")
return digest.hexdigest()
def merge_regions(base: dict[str, list[Block]], extra: dict[str, list[Block]], mode: str) -> dict[str, list[Block]]:
out = {name: list(blocks) for name, blocks in base.items()}
for name, blocks in extra.items():
if mode == "replace" or name not in out:
out[name] = list(blocks)
elif mode == "prepend":
out[name] = list(blocks) + out[name]
else:
out[name] = out[name] + list(blocks)
return out
def make_views(reg: Registry, table: dict[str, RouteRef], report: Report, published_only: bool = True) -> list[PageView]:
views: list[PageView] = []
for ref in table.values():
if published_only and not ref.published:
continue
if ref.kind == "page" and ref.page is not None:
page: Page = ref.page
layout_id = reg.effective_layout(page)
if not layout_id:
report.add("E_LAYOUT_MISSING", "у страницы нет layout (ни своего, ни из раздела, ни из site.yaml)", page.file)
continue
views.append(PageView(
id=page.id, title=page.title, route=ref.route, layout_id=layout_id, seo=page.seo,
regions=page.regions, body=page.body, source=page.file,
))
elif ref.kind == "entry" and ref.entry is not None and ref.collection is not None:
entry, coll = ref.entry, ref.collection
display = reg.displays.get(coll.display or coll.id)
if display is None or not display.layout:
report.add("E_DISPLAY_MISSING", f"нет display для коллекции «{coll.id}»", entry.file)
continue
views.append(PageView(
id=f"{coll.id}/{entry.slug}", title=str(entry.data.get("title", entry.slug)), route=ref.route,
layout_id=display.layout, seo=display.seo,
regions=merge_regions(display.regions, entry.regions, entry.regions_mode),
body=entry.body, entry=entry, collection=coll, source=entry.file,
))
views.sort(key=lambda v: v.route)
return views
def _token_css(tokens: dict, report: Report) -> str:
lines = []
for key, value in tokens.items():
name = "--" + str(key).replace(".", "-")
if not re.match(r"^--[a-z0-9-]+$", name) or not _TOKEN_VALUE_RE.match(str(value)):
report.add("E_THEME_TOKEN", f"недопустимый токен темы «{key}: {value}»", "site.yaml:theme.tokens")
continue
lines.append(f" {name}: {value};")
return ":root {\n" + "\n".join(lines) + "\n}\n" if lines else ""
def _bundle(reg: Registry, used: set[str], report: Report) -> tuple[str, str]:
base_css = (BUILTIN_DIR / "base.css").read_text(encoding="utf-8")
css = [_token_css(reg.site.theme_tokens, report), base_css]
js: list[str] = []
for fid in sorted(used):
fragment = reg.fragments[fid]
if fragment.style:
css.append(f"/* fragment: {fid} */\n{fragment.style}")
if fragment.script:
js.append(f"/* fragment: {fid} */\n{fragment.script}")
return "\n".join(css), "\n".join(js)
def _redirect_html(target: str) -> str:
t = escape(target)
return (f"<!doctype html><meta charset='utf-8'><title>Перенаправление</title>"
f"<link rel='canonical' href='{t}'><meta http-equiv='refresh' content='0; url={t}'>"
f"<p><a href='{t}'>Перейти</a></p>\n")
def _sitemap(reg: Registry, routes: list[str]) -> str:
base = reg.site.base_url
items = "".join(f" <url><loc>{escape(base + r)}</loc></url>\n" for r in routes)
return ("<?xml version='1.0' encoding='UTF-8'?>\n"
"<urlset xmlns='http://www.sitemaps.org/schemas/sitemap/0.9'>\n" + items + "</urlset>\n")
def switch_current(dist: Path, build_id: str) -> None:
"""Атомарное переключение: новый симлинк рядом, затем rename поверх `current`."""
tmp = dist / f".current-{os.getpid()}"
if tmp.is_symlink() or tmp.exists():
tmp.unlink()
os.symlink(build_id, tmp)
os.replace(tmp, dist / "current")
def prune_releases(dist: Path, keep: int) -> list[str]:
current = (dist / "current").resolve().name if (dist / "current").exists() else None
builds = sorted((p.name for p in dist.iterdir() if p.is_dir() and BUILD_ID_RE.match(p.name)), reverse=True)
removed = []
for name in builds[keep:]:
if name != current:
shutil.rmtree(dist / name)
removed.append(name)
return removed
def build_site(root: Path, out: Path, *, keep: int = 5, now: dt.datetime | None = None) -> BuildResult:
root, out = Path(root), Path(out)
now = now or dt.datetime.now(dt.timezone.utc)
reg = load_site(root)
report = Report()
table_report = Report()
table = build_route_table(reg, table_report)
report.extend(validate_workspace(reg, table))
report.extend(table_report)
report.extend(validate_release(reg, table))
source_hash = hash_tree(root)
build_id = f"{now.strftime('%Y%m%dT%H%M%S')}-{source_hash[:8]}"
views = make_views(reg, table, report)
renderer = Renderer(reg, table, report, strict=True, now=now, build_id=build_id)
rendered: dict[str, str] = {}
used: set[str] = set()
for view in views:
html, fragments = renderer.render(view)
rendered[view.route] = html
used |= fragments
css, js = _bundle(reg, used, report)
if report.errors:
raise EngineError(f"сборка остановлена: ошибок {len(report.errors)}", report)
css_name = f"site.{hashlib.sha256(css.encode()).hexdigest()[:8]}.css"
head = f"<link rel='stylesheet' href='/assets/{css_name}'>"
body = ""
js_name = None
if js:
js_name = f"site.{hashlib.sha256(js.encode()).hexdigest()[:8]}.js"
body = f"<script src='/assets/{js_name}' defer></script>"
out.mkdir(parents=True, exist_ok=True)
staging = out / f".staging-{build_id}"
if staging.exists():
shutil.rmtree(staging)
try:
staging.mkdir()
for route, html in rendered.items():
target = staging / route_to_output(route)
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(html.replace(ASSETS_HEAD, head).replace(ASSETS_BODY, body), encoding="utf-8")
assets = staging / "assets"
assets.mkdir(exist_ok=True)
if (root / "assets").is_dir():
shutil.copytree(root / "assets", assets, dirs_exist_ok=True)
(assets / css_name).write_text(css, encoding="utf-8")
if js_name:
(assets / js_name).write_text(js, encoding="utf-8")
forms_dir = staging / "_forms"
forms_dir.mkdir()
for form in reg.forms.values():
(forms_dir / f"{form.id}@{form.version}.json").write_text(
json.dumps(form.raw, ensure_ascii=False, sort_keys=True, indent=2, default=str), encoding="utf-8")
for ref in table.values():
if ref.kind == "redirect" and ref.target:
dest = ref.target if ref.target.startswith("http") else reg.site.base_url + ref.target
target = staging / route_to_output(ref.route)
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(_redirect_html(dest), encoding="utf-8")
(staging / "redirects.map").write_text(
"".join(f"{r.route} {r.target};\n" for r in table.values() if r.kind == "redirect" and r.target),
encoding="utf-8")
public = [r for r in rendered if r != "/404.html"]
(staging / "sitemap.xml").write_text(_sitemap(reg, public), encoding="utf-8")
(staging / "robots.txt").write_text(f"User-agent: *\nAllow: /\nSitemap: {reg.site.base_url}/sitemap.xml\n", encoding="utf-8")
(staging / "manifest.json").write_text(json.dumps({
"build_id": build_id, "source_hash": source_hash, "built_at": now.isoformat(),
"routes": sorted(rendered), "fragments": sorted(used),
}, ensure_ascii=False, indent=2), encoding="utf-8")
final = out / build_id
if final.exists():
shutil.rmtree(final)
os.rename(staging, final)
except BaseException:
shutil.rmtree(staging, ignore_errors=True)
raise
switch_current(out, build_id)
prune_releases(out, keep)
return BuildResult(build_id, out / build_id, len(rendered), source_hash, report)
def preview_page(root: Path, page_id: str, *, now: dt.datetime | None = None) -> tuple[str, Report]:
"""Рендер одной страницы из рабочего каталога, включая черновики (нестрогий режим)."""
reg = load_site(root)
report = Report()
table = build_route_table(reg, report)
views = [v for v in make_views(reg, table, report, published_only=False) if v.id == page_id]
if not views:
raise EngineError(f"нет страницы «{page_id}»", report)
renderer = Renderer(reg, table, report, strict=False, now=now, build_id="preview")
html, used = renderer.render(views[0])
css, _ = _bundle(reg, used, report)
html = html.replace(ASSETS_HEAD, f"<style>{css}</style>").replace(ASSETS_BODY, "")
return html, report
+1 -1
View File
@@ -94,7 +94,7 @@ def load_site(root: Path, builtin_dir: Path | None = BUILTIN_DIR) -> Registry:
report = Report() report = Report()
site_file = root / "site.yaml" site_file = root / "site.yaml"
if not site_file.is_file(): if not site_file.is_file():
raise EngineError(f"нет site.yaml в {root}") raise EngineError(f"нет site.yaml в {root.resolve()}")
raw_site = _read_yaml(site_file, "site.yaml", report) raw_site = _read_yaml(site_file, "site.yaml", report)
site = parse_site(raw_site, "site.yaml", report) if raw_site is not None else None site = parse_site(raw_site, "site.yaml", report) if raw_site is not None else None
if site is None: if site is None:
+29 -10
View File
@@ -17,6 +17,7 @@ import hashlib
import hmac import hmac
import json import json
import os import os
import re
import secrets import secrets
import time import time
from collections import defaultdict, deque from collections import defaultdict, deque
@@ -84,6 +85,15 @@ def verify_password(password: str, stored: str) -> bool:
# ── конфигурация ────────────────────────────────────────────────────────────── # ── конфигурация ──────────────────────────────────────────────────────────────
_HASH_RE = re.compile(r"^scrypt\$\d+\$\d+\$\d+\$[A-Za-z0-9_-]+\$[A-Za-z0-9_-]+$")
_SECRET_RE = re.compile(r"^[^\s#'\"]+$")
_LOGIN_RE = re.compile(r"^[A-Za-z0-9._@-]{1,64}$")
_HOST_RE = re.compile(r"^[A-Za-z0-9.-]+(:\d+)?$")
_TRUE, _FALSE = ("1", "true", "yes", "on"), ("0", "false", "no", "off")
_ENV_HINT = ("похоже на кавычки или комментарий в строке .env: для `docker run --env-file` значения пишутся "
"без кавычек и без «# …» после значения")
@dataclass(frozen=True) @dataclass(frozen=True)
class AuthConfig: class AuthConfig:
login: str login: str
@@ -102,21 +112,30 @@ class AuthConfig:
login = env.get("SITE_ADMIN_LOGIN", "admin").strip() login = env.get("SITE_ADMIN_LOGIN", "admin").strip()
password_hash = env.get("SITE_ADMIN_PASSWORD_HASH", "").strip() password_hash = env.get("SITE_ADMIN_PASSWORD_HASH", "").strip()
secret = env.get("SITE_SECRET_KEY", "") secret = env.get("SITE_SECRET_KEY", "")
if not login: if not _LOGIN_RE.match(login):
raise ConfigError("SITE_ADMIN_LOGIN пуст") raise ConfigError(f"SITE_ADMIN_LOGIN «{login}»: допустимы латиница, цифры, . _ @ - ({_ENV_HINT})")
if not password_hash.startswith("scrypt$"): if not password_hash:
raise ConfigError("SITE_ADMIN_PASSWORD_HASH не задан или не в формате scrypt (site-engine hash-password)") raise ConfigError("SITE_ADMIN_PASSWORD_HASH не задан (site-engine hash-password)")
if not _HASH_RE.match(password_hash):
raise ConfigError(f"SITE_ADMIN_PASSWORD_HASH: неверный формат, {_ENV_HINT}")
if len(secret) < MIN_SECRET_LENGTH: if len(secret) < MIN_SECRET_LENGTH:
raise ConfigError(f"SITE_SECRET_KEY короче {MIN_SECRET_LENGTH} символов (site-engine gen-secret)") raise ConfigError(f"SITE_SECRET_KEY не задан или короче {MIN_SECRET_LENGTH} символов (site-engine gen-secret)")
if not _SECRET_RE.match(secret):
raise ConfigError(f"SITE_SECRET_KEY содержит пробелы, # или кавычки: {_ENV_HINT}")
try: try:
hours = float(env.get("SITE_SESSION_HOURS", "8")) hours = float(env.get("SITE_SESSION_HOURS", "8").strip())
except ValueError as exc: except ValueError as exc:
raise ConfigError("SITE_SESSION_HOURS: ожидается число") from exc raise ConfigError(f"SITE_SESSION_HOURS: ожидается число ({_ENV_HINT})") from exc
if not 0 < hours <= 24 * 30: if not 0 < hours <= 24 * 30:
raise ConfigError("SITE_SESSION_HOURS: от 0 до 720") raise ConfigError("SITE_SESSION_HOURS: от 0 до 720")
secure = env.get("SITE_COOKIE_SECURE", "1").strip().lower() not in ("0", "false", "no", "off") flag = env.get("SITE_COOKIE_SECURE", "1").strip().lower()
return cls(login, password_hash, secret.encode("utf-8"), hours, secure, if flag not in _TRUE + _FALSE:
env.get("SITE_PUBLIC_HOST") or None) raise ConfigError(f"SITE_COOKIE_SECURE «{flag}»: ожидается 0 или 1 ({_ENV_HINT})")
secure = flag in _TRUE
public_host = (env.get("SITE_PUBLIC_HOST") or "").strip() or None
if public_host and not _HOST_RE.match(public_host):
raise ConfigError(f"SITE_PUBLIC_HOST «{public_host}»: ожидается host или host:port ({_ENV_HINT})")
return cls(login, password_hash, secret.encode("utf-8"), hours, secure, public_host)
# ── ограничение попыток и аудит ─────────────────────────────────────────────── # ── ограничение попыток и аудит ───────────────────────────────────────────────
+6 -2
View File
@@ -62,9 +62,10 @@ def htmx_available() -> bool:
class AdminHandlers: class AdminHandlers:
def __init__(self, auth: AuthService, site_root: Path): def __init__(self, auth: AuthService, site_root: Path, dist: Path | None = None):
self.auth = auth self.auth = auth
self.site_root = Path(site_root) self.site_root = Path(site_root)
self.dist = Path(dist) if dist is not None else None
def _clear_cookie(self) -> str: def _clear_cookie(self) -> str:
return build_set_cookie("", max_age=0, secure=self.auth.cfg.cookie_secure) return build_set_cookie("", max_age=0, secure=self.auth.cfg.cookie_secure)
@@ -110,7 +111,10 @@ class AdminHandlers:
ctx: dict = {"login": principal.login, "csrf": self.auth.csrf_token(principal), ctx: dict = {"login": principal.login, "csrf": self.auth.csrf_token(principal),
"section": "dashboard", "flash": "", "htmx": htmx_available(), "section": "dashboard", "flash": "", "htmx": htmx_available(),
"site_error": "", "site_name": "", "pages": [], "collections": [], "site_error": "", "site_name": "", "pages": [], "collections": [],
"errors": 0, "warnings": 0} "errors": 0, "warnings": 0,
"paths": {"site": str(self.site_root.resolve()),
"dist": str(self.dist.resolve()) if self.dist else "не задан",
"state": str(self.auth.state_dir.resolve())}}
try: try:
reg = load_site(self.site_root) reg = load_site(self.site_root)
report = Report() report = Report()
+8 -5
View File
@@ -1,12 +1,15 @@
"""FastAPI-адаптер для `AdminHandlers`. Не запускался в песочнице без сети: только компиляция. """FastAPI-адаптер для `AdminHandlers` и `EditorHandlers`.
ВАЖНО: в этом модуле нельзя ставить `from __future__ import annotations`. `Request` и `Form` импортируются
внутри `create_admin_router`, поэтому FastAPI не сможет разрешить аннотации-строки: параметр `request` станет
query-параметром, и любой запрос упадёт с 422 `loc: ["query", "request"]`. Это ловит тест
`test_annotations_are_real_types`.
Обработчики синхронные (`def`): хеш scrypt считается около 100 мс, и FastAPI вынесет их в пул потоков. Обработчики синхронные (`def`): хеш scrypt считается около 100 мс, и FastAPI вынесет их в пул потоков.
За обратным прокси `request.client.host` — адрес прокси, тогда ограничение попыток по IP За обратным прокси `request.client.host` — адрес прокси, тогда ограничение попыток по IP работает как
работает как общее; доверие к X-Forwarded-For нужно включать явно (задача M2). общее; доверие к X-Forwarded-For нужно включать явно (задача M2).
""" """
from __future__ import annotations
from ...services.auth import COOKIE_NAME from ...services.auth import COOKIE_NAME
from .editor import EditorHandlers from .editor import EditorHandlers
from .forms import FormData from .forms import FormData
@@ -1,6 +1,7 @@
{% extends 'shell.html.j2' %} {% extends 'shell.html.j2' %}
{% block title %}Обзор — админка{% endblock %} {% block title %}Обзор — админка{% endblock %}
{% block content %} {% block content %}
<p class='muted paths'>Каталог сайта: <code>{{ paths.site }}</code> · публикация: <code>{{ paths.dist }}</code> · состояние: <code>{{ paths.state }}</code></p>
{% if site_error %} {% if site_error %}
<p class='error' role='alert'>Сайт не загружен: {{ site_error }}</p> <p class='error' role='alert'>Сайт не загружен: {{ site_error }}</p>
{% else %} {% else %}
+33 -11
View File
@@ -1,13 +1,12 @@
"""Фабрика приложения. Админка подключается, только если задана конфигурация входа. """Фабрика приложения. Админка подключается, только если задана конфигурация входа.
Переменные окружения: SITE_ROOT, SITE_DIST, SITE_STATE_DIR (по умолчанию SITE_ROOT/.engine), Сайт раздаётся из `SITE_DIST/current` (удобно для разработки; в production лучше nginx).
Переменные окружения: SITE_ROOT, SITE_DIST, SITE_STATE_DIR (по умолчанию SITE_ROOT/.engine; в образе /data/state),
SITE_ADMIN_LOGIN, SITE_ADMIN_PASSWORD_HASH, SITE_SECRET_KEY, SITE_COOKIE_SECURE, SITE_SESSION_HOURS, SITE_ADMIN_LOGIN, SITE_ADMIN_PASSWORD_HASH, SITE_SECRET_KEY, SITE_COOKIE_SECURE, SITE_SESSION_HOURS,
SITE_PUBLIC_HOST. Без них `/admin/` отдаёт 404, и это сознательно: нет пароля — нет входа. SITE_PUBLIC_HOST. Без них `/admin/` отдаёт 404, и это сознательно: нет пароля — нет входа.
Не запускалось в песочнице без сети (нужен `pip install site-engine[server]`). Не запускалось в песочнице без сети (нужен `pip install site-engine[server]`).
""" """
from __future__ import annotations
import logging import logging
import os import os
from pathlib import Path from pathlib import Path
@@ -20,13 +19,15 @@ def create_app():
from fastapi.staticfiles import StaticFiles from fastapi.staticfiles import StaticFiles
from ..services.auth import AuthConfig, AuthService, ConfigError from ..services.auth import AuthConfig, AuthService, ConfigError
from .config import SitePaths
from .admin.editor import EditorHandlers from .admin.editor import EditorHandlers
from .admin.handlers import AdminHandlers from .admin.handlers import AdminHandlers
from .admin.routes import create_admin_router from .admin.routes import create_admin_router
app = FastAPI(title="Site Engine", docs_url=None, redoc_url=None, openapi_url=None) app = FastAPI(title="Site Engine", docs_url=None, redoc_url=None, openapi_url=None)
root = Path(os.environ.get("SITE_ROOT", "site")) paths = SitePaths.from_env()
dist = Path(os.environ.get("SITE_DIST", "dist")) root, dist = paths.root, paths.dist
uvicorn_log = logging.getLogger("uvicorn.error") # его уровень и вывод настраивает uvicorn
@app.get("/healthz") @app.get("/healthz")
def healthz() -> dict: def healthz() -> dict:
@@ -36,15 +37,36 @@ def create_app():
def submit_form(form_id: str) -> None: def submit_form(form_id: str) -> None:
raise HTTPException(status_code=501, detail="приём заявок появится в M2 (ADR-003)") raise HTTPException(status_code=501, detail="приём заявок появится в M2 (ADR-003)")
admin = "off"
try: try:
cfg = AuthConfig.from_env() cfg = AuthConfig.from_env()
except ConfigError as exc: except ConfigError as exc:
log.warning("админка отключена: %s", exc) uvicorn_log.warning("админка отключена: %s", exc)
else: else:
state_dir = Path(os.environ.get("SITE_STATE_DIR", root / ".engine")) auth = AuthService(cfg, paths.state)
auth = AuthService(cfg, state_dir) app.include_router(create_admin_router(AdminHandlers(auth, root, dist), EditorHandlers(auth, root, dist)))
app.include_router(create_admin_router(AdminHandlers(auth, root), EditorHandlers(auth, root, dist))) admin = "on"
uvicorn_log.info("site-engine: %s, admin=%s", paths.describe(), admin)
for problem in paths.problems():
uvicorn_log.warning("site-engine: %s", problem)
# Раздача сайта: путь к `dist/current` разрешается на каждый запрос, поэтому публикация и откат
# из админки видны сразу, без перезапуска. Маршрут объявлен последним: админка и /healthz важнее.
from fastapi.responses import FileResponse, PlainTextResponse, RedirectResponse
from .static_site import resolve_site_file
@app.get("/{path:path}", include_in_schema=False)
def serve_site(path: str):
kind, target = resolve_site_file(dist, "/" + path)
if kind == "file":
return FileResponse(target)
if kind == "redirect":
return RedirectResponse(target, status_code=308)
if kind == "unpublished":
return PlainTextResponse("Сайт ещё не опубликован. Войдите в /admin/ и откройте «Публикация».", status_code=404)
if target is not None:
return FileResponse(target, status_code=404)
return PlainTextResponse("Не найдено", status_code=404)
if (dist / "current").exists(): # маршруты выше имеют приоритет над раздачей статики
app.mount("/", StaticFiles(directory=dist / "current", html=True), name="site")
return app return app
+59
View File
@@ -0,0 +1,59 @@
"""Пути сайта из окружения и понятная диагностика при старте.
Три каталога: `SITE_ROOT` (контент и код сайта), `SITE_DIST` (опубликованные релизы),
`SITE_STATE_DIR` (состояние входа и аудит; по умолчанию `SITE_ROOT/.engine`). В Docker-образе все три
заданы внутри единственного тома `/data`. Относительные пути разрешаются от рабочего каталога процесса
(в образе это `/app`), и при старте о них пишется предупреждение: чаще всего это строки из старого `.env`.
"""
from __future__ import annotations
import os
from collections.abc import Mapping
from dataclasses import dataclass
from pathlib import Path
def _abs(value: str, base: Path) -> Path:
path = Path(value)
return Path(os.path.abspath(path if path.is_absolute() else base / path))
@dataclass(frozen=True)
class SitePaths:
root: Path
dist: Path
state: Path
relative: tuple[str, ...] = () # имена переменных, заданных относительным путём
@classmethod
def from_env(cls, env: Mapping[str, str] | None = None, cwd: Path | None = None) -> "SitePaths":
env = os.environ if env is None else env
base = Path(cwd) if cwd else Path.cwd()
values = {"SITE_ROOT": env.get("SITE_ROOT", "site"), "SITE_DIST": env.get("SITE_DIST", "dist")}
explicit_state = env.get("SITE_STATE_DIR", "").strip()
root = _abs(values["SITE_ROOT"], base)
state = _abs(explicit_state, base) if explicit_state else root / ".engine"
relative = tuple(k for k, v in {**values, **({"SITE_STATE_DIR": explicit_state} if explicit_state else {})}.items()
if v and not Path(v).is_absolute() and k in env)
return cls(root=root, dist=_abs(values["SITE_DIST"], base), state=state, relative=relative)
def describe(self) -> str:
return f"site={self.root}, dist={self.dist}, state={self.state}"
def problems(self, env: Mapping[str, str] | None = None) -> list[str]:
env = os.environ if env is None else env
found = []
if not self.root.is_dir():
found.append(f"каталога сайта нет: {self.root}. Смонтируйте его (docker run -v \"$PWD/data:/data\" ..., "
"сайт в data/site) или поправьте SITE_ROOT")
elif not (self.root / "site.yaml").is_file():
found.append(f"в каталоге сайта нет site.yaml: {self.root}")
for name in self.relative:
found.append(f"{name}={env.get(name)} задан относительным путём и разрешён как "
f"{ {'SITE_ROOT': self.root, 'SITE_DIST': self.dist, 'SITE_STATE_DIR': self.state}[name] }: "
"в контейнере это путь внутри образа, а не примонтированный том. Удалите строку из .env: "
"в образе пути уже заданы (/data/site, /data/dist, /data/state)")
if self.dist == self.root or self.root in self.dist.parents:
found.append(f"SITE_DIST находится внутри SITE_ROOT ({self.dist}): релизы попадут в исходники сайта")
return found
+45
View File
@@ -0,0 +1,45 @@
"""Раздача собранного сайта из `dist/current` для разработки и небольших установок.
Каталог `current` — симлинк, который переключается при публикации и откате, поэтому путь
разрешается на каждый запрос (StaticFiles при старте зафиксировал бы каталог навсегда).
В production статику лучше отдавать nginx. Служебные файлы релиза наружу не отдаются.
"""
from __future__ import annotations
from pathlib import Path
from ..errors import UnsafePathError
from ..storage.fs import safe_join
_PRIVATE_NAMES = {"manifest.json", "redirects.map"}
_PRIVATE_DIRS = {"_forms"}
def resolve_site_file(dist: Path, url_path: str) -> tuple[str, Path | str | None]:
"""(`file`, путь) | (`redirect`, url) | (`not_found`, путь к 404.html или None) | (`unpublished`, None)."""
current = Path(dist) / "current"
if not current.exists():
return "unpublished", None
rel = url_path.lstrip("/")
parts = [p for p in rel.split("/") if p]
if (parts and parts[0] in _PRIVATE_DIRS) or (parts and parts[-1] in _PRIVATE_NAMES and len(parts) == 1):
return "not_found", _page_404(current)
try:
target = safe_join(current, rel) if rel else current.resolve()
except UnsafePathError:
return "not_found", _page_404(current)
if target.is_dir():
if rel and not url_path.endswith("/"):
return "redirect", "/" + rel + "/"
index = target / "index.html"
if index.is_file():
return "file", index
elif target.is_file():
return "file", target
return "not_found", _page_404(current)
def _page_404(current: Path) -> Path | None:
page = current.resolve() / "404.html"
return page if page.is_file() else None
+10 -1
View File
@@ -16,7 +16,7 @@ class AdminHandlersTest(SiteTestCase):
super().setUp() super().setUp()
self.clock = Clock() self.clock = Clock()
self.auth = AuthService(make_cfg(), self.tmp / "state", clock=self.clock) self.auth = AuthService(make_cfg(), self.tmp / "state", clock=self.clock)
self.h = AdminHandlers(self.auth, self.site) self.h = AdminHandlers(self.auth, self.site, self.tmp / "dist")
def cookie_value(self, result): def cookie_value(self, result):
header = result.cookies[0] header = result.cookies[0]
@@ -91,6 +91,15 @@ class AdminHandlersTest(SiteTestCase):
self.assertIn("name='csrf'", result.body) self.assertIn("name='csrf'", result.body)
self.assertIn("no-store", result.headers["Cache-Control"]) self.assertIn("no-store", result.headers["Cache-Control"])
def test_dashboard_shows_the_absolute_paths_in_use(self):
body = self.h.dashboard(self.login()).body
for path in (self.site.resolve(), (self.tmp / "dist").resolve(), (self.tmp / "state").resolve()):
self.assertIn(str(path), body)
def test_missing_site_error_names_the_absolute_path(self):
(self.site / "site.yaml").unlink()
self.assertIn(str(self.site.resolve()), self.h.dashboard(self.login()).body)
def test_dashboard_shows_broken_site_instead_of_crashing(self): def test_dashboard_shows_broken_site_instead_of_crashing(self):
(self.site / "site.yaml").unlink() (self.site / "site.yaml").unlink()
result = self.h.dashboard(self.login()) result = self.h.dashboard(self.login())
+17
View File
@@ -134,6 +134,23 @@ class RoutesWiringTest(SiteTestCase):
self.assertEqual((out.status_code, out.headers["Location"]), (303, "/admin/login")) self.assertEqual((out.status_code, out.headers["Location"]), (303, "/admin/login"))
self.assertIn("Max-Age=0", out.headers.appended[0][1]) self.assertIn("Max-Age=0", out.headers.appended[0][1])
def test_annotations_are_real_types(self):
"""Регрессия: с `from __future__ import annotations` и локальным импортом Request FastAPI не разрешает
аннотацию, считает `request` query-параметром и отвечает 422 {"loc": ["query", "request"]}."""
import typing
from pathlib import Path
source = (Path(__file__).resolve().parent.parent / "src/site_engine/web/admin/routes.py").read_text(encoding="utf-8")
import re
self.assertIsNone(re.search(r"^from __future__ import annotations", source, re.M))
for key, fn in self.router.routes.items():
hints = typing.get_type_hints(fn) # как это делает FastAPI: имена берутся из globals модуля
if "request" in hints:
self.assertIs(hints["request"], FakeRequest, key)
self.assertFalse(any(isinstance(v, str) for v in fn.__annotations__.values()), key)
def test_static_and_login_page_routes(self): def test_static_and_login_page_routes(self):
css = self.route("GET", "/admin/static/{name}")("admin.css") css = self.route("GET", "/admin/static/{name}")("admin.css")
self.assertTrue(css.media_type.startswith("text/css")) self.assertTrue(css.media_type.startswith("text/css"))
+16
View File
@@ -64,6 +64,22 @@ class ConfigTest(unittest.TestCase):
with self.assertRaises(ConfigError, msg=str(patch)): with self.assertRaises(ConfigError, msg=str(patch)):
AuthConfig.from_env({**self.ENV, **patch}) AuthConfig.from_env({**self.ENV, **patch})
def test_trailing_comment_or_quotes_in_env_are_rejected_not_silently_accepted(self):
h, s = self.ENV["SITE_ADMIN_PASSWORD_HASH"], self.ENV["SITE_SECRET_KEY"]
for patch in ({"SITE_ADMIN_PASSWORD_HASH": h + " # site-engine hash-password"},
{"SITE_ADMIN_PASSWORD_HASH": f'"{h}"'}, {"SITE_ADMIN_PASSWORD_HASH": f"'{h}'"},
{"SITE_SECRET_KEY": s + " # gen-secret"}, {"SITE_SECRET_KEY": f'"{s}"'},
{"SITE_COOKIE_SECURE": "1 # только http"}, {"SITE_COOKIE_SECURE": "maybe"},
{"SITE_SESSION_HOURS": "8 # часов"}, {"SITE_ADMIN_LOGIN": "admin # мой"},
{"SITE_PUBLIC_HOST": "admin.example.com # прокси"}):
with self.assertRaises(ConfigError, msg=str(patch)) as ctx:
AuthConfig.from_env({**self.ENV, **patch})
self.assertIn("кавычки или комментарий", str(ctx.exception))
def test_valid_host_and_flags(self):
cfg = AuthConfig.from_env({**self.ENV, "SITE_PUBLIC_HOST": "admin.example.com:8443", "SITE_COOKIE_SECURE": "false"})
self.assertEqual((cfg.public_host, cfg.cookie_secure), ("admin.example.com:8443", False))
def test_cookie_secure_can_be_disabled_for_local_dev(self): def test_cookie_secure_can_be_disabled_for_local_dev(self):
self.assertFalse(AuthConfig.from_env({**self.ENV, "SITE_COOKIE_SECURE": "0"}).cookie_secure) self.assertFalse(AuthConfig.from_env({**self.ENV, "SITE_COOKIE_SECURE": "0"}).cookie_secure)
+50
View File
@@ -0,0 +1,50 @@
import tempfile
import unittest
from pathlib import Path
from site_engine.web.config import SitePaths
DOCKER_ENV = {"SITE_ROOT": "/data/site", "SITE_DIST": "/data/dist", "SITE_STATE_DIR": "/data/state"}
OLD_ENV_EXAMPLE = {"SITE_ROOT": "examples/studio-site", "SITE_DIST": "dist"} # строки, которые когда-то были включены в .env.example
class SitePathsTest(unittest.TestCase):
def test_docker_defaults_resolve_inside_the_data_volume(self):
p = SitePaths.from_env(DOCKER_ENV, cwd=Path("/app"))
self.assertEqual((p.root, p.dist, p.state), (Path("/data/site"), Path("/data/dist"), Path("/data/state")))
self.assertEqual(p.relative, ())
def test_leftover_relative_paths_from_old_env_are_called_out(self):
env = {**DOCKER_ENV, **OLD_ENV_EXAMPLE}
p = SitePaths.from_env(env, cwd=Path("/app"))
self.assertEqual((p.root, p.dist), (Path("/app/examples/studio-site"), Path("/app/dist")))
text = "\n".join(p.problems(env))
for needle in ("SITE_ROOT=examples/studio-site", "/app/examples/studio-site", "SITE_DIST=dist", "/app/dist",
"Удалите строку из .env", "каталога сайта нет"):
self.assertIn(needle, text)
def test_state_defaults_to_dot_engine_inside_site(self):
p = SitePaths.from_env({"SITE_ROOT": "/srv/site", "SITE_DIST": "/srv/dist"}, cwd=Path("/app"))
self.assertEqual(p.state, Path("/srv/site/.engine"))
def test_no_problems_for_a_healthy_layout(self):
with tempfile.TemporaryDirectory() as tmp:
(Path(tmp) / "site").mkdir()
(Path(tmp) / "site" / "site.yaml").write_text("name: x\n", encoding="utf-8")
env = {"SITE_ROOT": f"{tmp}/site", "SITE_DIST": f"{tmp}/dist", "SITE_STATE_DIR": f"{tmp}/state"}
self.assertEqual(SitePaths.from_env(env).problems(env), [])
def test_missing_site_yaml_and_dist_inside_root(self):
with tempfile.TemporaryDirectory() as tmp:
env = {"SITE_ROOT": tmp, "SITE_DIST": f"{tmp}/dist"}
text = "\n".join(SitePaths.from_env(env).problems(env))
self.assertIn("нет site.yaml", text)
self.assertIn("внутри SITE_ROOT", text)
def test_relative_paths_resolve_against_cwd_for_local_runs(self):
p = SitePaths.from_env({"SITE_ROOT": "examples/studio-site", "SITE_DIST": "dist"}, cwd=Path("/work/project"))
self.assertEqual((p.root, p.dist), (Path("/work/project/examples/studio-site"), Path("/work/project/dist")))
if __name__ == "__main__":
unittest.main()
+54
View File
@@ -0,0 +1,54 @@
"""Регрессия: в установленный пакет (Docker-образ, wheel) должны попасть шаблоны и статика админки,
встроенные фрагменты и стили. Раньше package-data включал только builtin/."""
import fnmatch
import glob
import shutil
import subprocess
import sys
import tempfile
import tomllib
import unittest
import zipfile
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
PKG = ROOT / "src" / "site_engine"
class PackagingTest(unittest.TestCase):
def test_package_data_patterns_cover_every_runtime_file(self):
patterns = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["tool"]["setuptools"]["package-data"]["site_engine"]
runtime = [p for sub in ("builtin", "web/admin/templates", "web/admin/static") for p in (PKG / sub).rglob("*")
if p.is_file() and p.suffix != ".pyc" and "__pycache__" not in p.parts]
self.assertGreater(len(runtime), 50)
uncovered = [str(p.relative_to(PKG)) for p in runtime
if not any(fnmatch.fnmatch(p.relative_to(PKG).as_posix(), pat.replace("**/*", "*")) for pat in patterns)]
self.assertEqual(uncovered, [])
def test_built_wheel_contains_templates_static_and_fragments(self):
try:
import setuptools # noqa: F401
except ImportError:
self.skipTest("нет setuptools")
before = {name: (ROOT / name).exists() for name in ("build", "src/site_engine.egg-info")}
with tempfile.TemporaryDirectory() as tmp:
project = Path(tmp) / "project"
shutil.copytree(ROOT, project, ignore=shutil.ignore_patterns(
"build", "*.egg-info", "__pycache__", ".git", "tests", "docs", "examples", "dist", ".engine"))
result = subprocess.run([sys.executable, "-m", "pip", "wheel", str(project), "--no-deps", "--no-build-isolation",
"-q", "-w", str(Path(tmp) / "out")], capture_output=True, text=True, timeout=180)
wheels = glob.glob(f"{tmp}/out/*.whl")
if result.returncode != 0 or not wheels:
self.skipTest(f"wheel не собрался в этом окружении: {result.stderr[-200:]}")
names = zipfile.ZipFile(wheels[0]).namelist()
after = {name: (ROOT / name).exists() for name in before}
self.assertEqual(after, before, "сборка wheel не должна оставлять мусор в рабочем каталоге")
for needed in ("site_engine/web/admin/templates/login.html.j2", "site_engine/web/admin/templates/page_edit.html.j2",
"site_engine/web/admin/static/admin.css", "site_engine/builtin/base.css",
"site_engine/builtin/fragments/hero/template.html.j2"):
self.assertIn(needed, names)
if __name__ == "__main__":
unittest.main()
+113
View File
@@ -0,0 +1,113 @@
"""Страховка от ошибок упаковки, из-за которых пользователь получал неверные пути в Docker."""
import re
import shutil
import subprocess
import tempfile
import unittest
from pathlib import Path
from site_engine.services.auth import AuthConfig, ConfigError
from site_engine.web.config import SitePaths
ROOT = Path(__file__).resolve().parent.parent
GOOD_HASH = "scrypt$32768$8$1$aGVsbG8$d29ybGQ"
OLD_ENV_EXAMPLE = """# Каталоги
SITE_ROOT=examples/studio-site
SITE_DIST=dist
SITE_ADMIN_LOGIN=admin
SITE_ADMIN_PASSWORD_HASH= # site-engine hash-password
SITE_SECRET_KEY= # site-engine gen-secret (не короче 32 символов)
SITE_COOKIE_SECURE=1 # 0 только для локальной разработки по http
"""
def parse_docker_env_file(text: str) -> dict[str, str]:
"""Как `docker run --env-file`: строки с # в начале пропускаются, значение — всё после первого «=»,
кавычки и комментарии в конце строки не обрабатываются."""
env = {}
for line in text.splitlines():
if line.strip() and not line.lstrip().startswith("#") and "=" in line:
key, value = line.split("=", 1)
env[key] = value
return env
class EnvExampleTest(unittest.TestCase):
def test_env_example_lives_in_the_project_root_only(self):
self.assertTrue((ROOT / ".env.example").is_file())
self.assertFalse((ROOT / "src" / ".env.example").exists())
def test_env_example_has_no_path_overrides(self):
env = parse_docker_env_file((ROOT / ".env.example").read_text(encoding="utf-8"))
for name in ("SITE_ROOT", "SITE_DIST", "SITE_STATE_DIR", "SITE_DB"):
self.assertNotIn(name, env)
def test_filled_env_example_works_exactly_as_docker_reads_it(self):
text = (ROOT / ".env.example").read_text(encoding="utf-8")
text = text.replace("SITE_ADMIN_PASSWORD_HASH=", f"SITE_ADMIN_PASSWORD_HASH={GOOD_HASH}")
text = text.replace("SITE_SECRET_KEY=", "SITE_SECRET_KEY=" + "k" * 43)
env = parse_docker_env_file(text)
cfg = AuthConfig.from_env(env)
self.assertEqual((cfg.login, cfg.cookie_secure, cfg.session_hours), ("admin", True, 8.0))
self.assertEqual(SitePaths.from_env({**{"SITE_ROOT": "/data/site", "SITE_DIST": "/data/dist"}, **env}).relative, ())
def test_old_env_example_would_have_failed_loudly_instead_of_silently(self):
text = OLD_ENV_EXAMPLE.replace("SITE_ADMIN_PASSWORD_HASH= #", f"SITE_ADMIN_PASSWORD_HASH={GOOD_HASH} #")
text = text.replace("SITE_SECRET_KEY= #", "SITE_SECRET_KEY=" + "k" * 43 + " #")
with self.assertRaises(ConfigError):
AuthConfig.from_env(parse_docker_env_file(text))
class IgnoreRulesTest(unittest.TestCase):
"""Пакет `site_engine.build` (конвейер сборки) раньше мог попасть под правило `build/` без привязки к корню."""
PACKAGE_FILES = ("src/site_engine/build/pipeline.py", "src/site_engine/build/__init__.py",
"src/site_engine/web/admin/templates/login.html.j2", "src/site_engine/builtin/base.css")
def test_source_package_exists(self):
for rel in self.PACKAGE_FILES:
self.assertTrue((ROOT / rel).is_file(), rel)
def test_gitignore_patterns_for_build_and_dist_are_anchored_to_the_root(self):
lines = [l.strip() for l in (ROOT / ".gitignore").read_text(encoding="utf-8").splitlines()]
for bad in ("build/", "dist/", "build", "dist"):
self.assertNotIn(bad, lines)
for good in ("/build/", "/dist/"):
self.assertIn(good, lines)
@unittest.skipUnless(shutil.which("git"), "git недоступен")
def test_git_does_not_ignore_the_source_package(self):
with tempfile.TemporaryDirectory() as tmp:
subprocess.run(["git", "init", "-q", tmp], check=True)
shutil.copy(ROOT / ".gitignore", Path(tmp) / ".gitignore")
for rel in self.PACKAGE_FILES:
result = subprocess.run(["git", "-C", tmp, "check-ignore", "-q", rel])
self.assertEqual(result.returncode, 1, f"{rel} игнорируется git")
for rel in ("build/lib/x.py", "dist/current/index.html"):
self.assertEqual(subprocess.run(["git", "-C", tmp, "check-ignore", "-q", rel]).returncode, 0, rel)
class DockerfileTest(unittest.TestCase):
def setUp(self):
self.text = (ROOT / "Dockerfile").read_text(encoding="utf-8")
def test_all_paths_point_inside_one_data_volume(self):
for pair in ("SITE_ROOT=/data/site", "SITE_DIST=/data/dist", "SITE_STATE_DIR=/data/state"):
self.assertIn(pair, self.text)
self.assertEqual(re.findall(r"^VOLUME .*$", self.text, re.M), ['VOLUME ["/data"]'])
def test_env_file_is_never_copied_into_the_image(self):
self.assertIn(".env", (ROOT / ".dockerignore").read_text(encoding="utf-8").splitlines())
self.assertNotRegex(self.text, r"COPY\s+.*\.env")
class ReadmeTest(unittest.TestCase):
def test_readme_docker_command_matches_the_dockerfile(self):
readme = (ROOT / "README.md").read_text(encoding="utf-8")
self.assertIn('-v "$PWD/data:/data"', readme)
self.assertNotIn("/data/dist\" site-engine", readme) # прежняя схема с двумя томами
if __name__ == "__main__":
unittest.main()
+49
View File
@@ -0,0 +1,49 @@
import unittest
from helpers import NOW, SiteTestCase
from site_engine.build.pipeline import build_site
from site_engine.services.publish import rollback
from site_engine.web.static_site import resolve_site_file
class StaticSiteTest(SiteTestCase):
def test_unpublished(self):
self.assertEqual(resolve_site_file(self.out, "/"), ("unpublished", None))
def test_pages_assets_redirects_and_404(self):
build_site(self.site, self.out, now=NOW)
cur = (self.out / "current").resolve()
self.assertEqual(resolve_site_file(self.out, "/"), ("file", cur / "index.html"))
self.assertEqual(resolve_site_file(self.out, "/services/"), ("file", cur / "services" / "index.html"))
self.assertEqual(resolve_site_file(self.out, "/services"), ("redirect", "/services/"))
self.assertEqual(resolve_site_file(self.out, "/assets/hero.svg")[0], "file")
self.assertEqual(resolve_site_file(self.out, "/nope/"), ("not_found", None))
self.assertEqual(resolve_site_file(self.out, "/drafts/next/"), ("not_found", None))
def test_custom_404_page_is_used(self):
self.write("pages/404.md", "---\ntitle: Не найдено\nstatus: published\nregions:\n main:\n - {id: b_h, fragment: page_header, props: {title: Нет такой страницы}}\n---\n")
build_site(self.site, self.out, now=NOW)
kind, target = resolve_site_file(self.out, "/missing/")
self.assertEqual((kind, target.name), ("not_found", "404.html"))
def test_traversal_and_service_files_are_not_served(self):
build_site(self.site, self.out, now=NOW)
for path in ("/../../etc/passwd", "/..%2f..%2fetc/passwd", "/assets/../../x", "/_forms/consultation@d409cada0967.json",
"/_forms/", "/manifest.json", "/redirects.map", "//etc/passwd", "/\x00"):
self.assertEqual(resolve_site_file(self.out, path)[0], "not_found", path)
def test_publish_and_rollback_are_visible_without_restart(self):
first = build_site(self.site, self.out, now=NOW)
self.edit("pages/privacy.md", "Текст политики", "Версия два")
second = build_site(self.site, self.out, now=NOW.replace(minute=30))
page = lambda: resolve_site_file(self.out, "/privacy/")[1].read_text(encoding="utf-8")
self.assertIn("Версия два", page())
rollback(self.out, first.build_id)
self.assertNotIn("Версия два", page())
rollback(self.out, second.build_id)
self.assertIn("Версия два", page())
if __name__ == "__main__":
unittest.main()