244 lines
10 KiB
Python
244 lines
10 KiB
Python
import io
|
|
import re
|
|
import json
|
|
import yaml
|
|
import random
|
|
import mistune
|
|
import resvg_py
|
|
from html import escape
|
|
from pathlib import Path
|
|
from bs4 import BeautifulSoup
|
|
from markitdown import MarkItDown
|
|
from datetime import datetime, timezone
|
|
from zoneinfo import ZoneInfo
|
|
from fastapi import FastAPI, Request, Response
|
|
from fastapi.templating import Jinja2Templates
|
|
from fastapi.responses import PlainTextResponse, JSONResponse, FileResponse, RedirectResponse
|
|
from jinja2.exceptions import TemplateNotFound
|
|
from .error import error_page
|
|
from .database import AccessCounter
|
|
from .middleware import Middleware, server_version, onion_hostname
|
|
|
|
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
|
app.add_middleware(Middleware)
|
|
templates = Jinja2Templates(directory=Path.cwd().joinpath("public"))
|
|
markitdown = MarkItDown()
|
|
accesscounter = AccessCounter()
|
|
templates.env.globals["get_access_count"] = accesscounter.get
|
|
templates.env.globals["server_version"] = server_version
|
|
templates.env.globals["onion_site_url"] = f"http://{onion_hostname}/"
|
|
templates.env.filters["re_sub"] = lambda s, pattern, repl: re.sub(pattern, repl, s)
|
|
|
|
class CustomHTMLRenderer(mistune.HTMLRenderer):
|
|
def block_code(self, code, **attrs):
|
|
return f'<pre>{mistune.escape(code)}</pre>\n'
|
|
htmlitdown = mistune.create_markdown(renderer=CustomHTMLRenderer(escape=False))
|
|
|
|
@property
|
|
def this_year() -> int:
|
|
return datetime.now(ZoneInfo("Asia/Tokyo")).year
|
|
templates.env.globals["this_year"] = this_year
|
|
|
|
@property
|
|
def this_year_in_heisei() -> int: # heysay is not ended.
|
|
return datetime.now(ZoneInfo("Asia/Tokyo")).year - 1989
|
|
templates.env.globals["this_year_in_heisei"] = this_year_in_heisei
|
|
|
|
def get_daily_quote() -> str:
|
|
seed = str(datetime.now(timezone.utc).date())
|
|
with Path.cwd().joinpath("public", "quotes.txt").open("r") as f:
|
|
quotes = f.read().strip().split("\n")
|
|
return random.Random(seed).choice(quotes)
|
|
templates.env.globals["get_daily_quote"] = get_daily_quote
|
|
|
|
def resolve_static_file(full_path: str) -> Path | None:
|
|
base_dir = Path.cwd().joinpath("public")
|
|
target_path = (base_dir / full_path.lstrip('/')).resolve()
|
|
if not str(target_path).startswith(str(base_dir.resolve())):
|
|
raise PermissionError()
|
|
return target_path if target_path.is_file() else None
|
|
|
|
def resolve_shorturl(shorturls: dict, full_path: str) -> str | None:
|
|
current_id = full_path.strip().rstrip("/")
|
|
visited = set()
|
|
for _ in range(10):
|
|
if current_id in visited or current_id not in shorturls:
|
|
return None
|
|
visited.add(current_id)
|
|
entry = shorturls[current_id]
|
|
if entry["type"] in ["redirect", "alias"]:
|
|
if entry["type"] == "redirect":
|
|
return entry["content"]
|
|
current_id = entry["content"]
|
|
return None
|
|
|
|
@app.api_route("/ping", methods=["GET"])
|
|
async def ping(request: Request):
|
|
return PlainTextResponse("pong!", status_code=200)
|
|
|
|
@app.api_route("/echo", methods=["GET"])
|
|
async def echo(request: Request):
|
|
return JSONResponse(request.scope["log"], status_code=200)
|
|
|
|
@app.api_route("/status", methods=["GET"])
|
|
async def status(request: Request):
|
|
return JSONResponse(
|
|
{
|
|
"status": "ok",
|
|
"version": server_version,
|
|
"daily_quote": get_daily_quote(),
|
|
"access_count": accesscounter.get()
|
|
},
|
|
status_code=200
|
|
)
|
|
|
|
@app.api_route("/welcome", methods=["GET"])
|
|
async def ping(request: Request):
|
|
return PlainTextResponse(
|
|
f"""
|
|
■ ■ ■■■■■ ■■■■ ■■■■ ■■■ ■ ■ ■■■■■
|
|
■■ ■ ■ ■ ■ ■ ■ ■ ■■ ■ ■
|
|
■■ ■ ■ ■ ■ ■ ■ ■ ■■ ■ ■
|
|
■ ■ ■ ■■■■ ■■■■ ■ ■ ■ ■ ■ ■ ■■■■
|
|
■ ■■ ■ ■ ■ ■ ■ ■ ■ ■■ ■
|
|
■ ■■ ■ ■ ■ ■ ■ ■ ■ ■■ ■
|
|
■ ■ ■■■■■ ■ ■ ■■■■ ■■■ ■ ■ ■■■■■
|
|
|
|
nercone.dev ({server_version})
|
|
welcome to nercone.dev!
|
|
""".strip() + "\n",
|
|
status_code=200
|
|
)
|
|
|
|
@app.api_route("/error/{code}", methods=["GET", "POST", "HEAD"])
|
|
async def fake_error_page(request: Request, code: str):
|
|
return error_page(templates=templates, request=request, status_code=int(code))
|
|
|
|
@app.api_route("/assets/images/thumbnails/{path:path}", methods=["GET"])
|
|
async def thumbnail(request: Request, path: str) -> Response:
|
|
title = request.query_params.get("title", "Untitled Page")
|
|
description = request.query_params.get("description", "No description.")
|
|
template_type = request.query_params.get("template", "normal")
|
|
|
|
parts = [p for p in path.strip("/").split("/") if p]
|
|
path_display = "nercone.dev / " + " / ".join(parts) if parts else "nercone.dev"
|
|
|
|
svg_filename = "error.svg" if template_type == "error" else "normal.svg"
|
|
fonts_dir = Path.cwd().joinpath("public", "assets", "fonts")
|
|
|
|
svg_path = Path.cwd().joinpath("public", "assets", "images", "thumbnails", svg_filename)
|
|
svg = svg_path.read_text(encoding="utf-8")
|
|
svg = svg.replace("__PATH__", escape(path_display))
|
|
svg = svg.replace("__TITLE__", escape(title))
|
|
svg = svg.replace("__DESCRIPTION__", escape(description))
|
|
|
|
font_files = [
|
|
str(fonts_dir / "MesloBIZUD-Regular.ttf"),
|
|
str(fonts_dir / "InterBIZUD-Regular.ttf"),
|
|
str(fonts_dir / "InterBIZUD-Bold.ttf"),
|
|
]
|
|
png = resvg_py.svg_to_bytes(svg, font_files=font_files, width=1200, height=630)
|
|
return Response(content=png, media_type="image/png")
|
|
|
|
@app.api_route("/{full_path:path}", methods=["GET", "POST", "HEAD"])
|
|
async def default_response(request: Request, full_path: str) -> Response:
|
|
if not full_path.endswith(".html") and not full_path.endswith(".md"):
|
|
try:
|
|
if static := resolve_static_file(full_path):
|
|
return FileResponse(static)
|
|
except PermissionError:
|
|
return error_page(templates, request, 403, "何をしてるんです？脆弱性報告のためならいいのですが、データ盗んで悪用するためなら今すぐにやめてくださいね？", "ディレクトリトラバーサルね、知ってる。公開してないところ覗きたいの？えっt")
|
|
|
|
original_path = full_path
|
|
markdown_mode = False
|
|
markdown_ua = ["curl", "claude-user", "chatgpt-user", "google-extended", "perplexity-user"]
|
|
|
|
if "text/markdown" in request.headers.get("accept", "").lower():
|
|
markdown_mode = True
|
|
elif any([ua in request.headers.get("user-agent", "").lower() for ua in markdown_ua]):
|
|
markdown_mode = True
|
|
|
|
if full_path.endswith(".md"):
|
|
markdown_mode = True
|
|
full_path = full_path[:-3] + ".html"
|
|
|
|
if full_path in ["", "/"]:
|
|
template_candidates = ["index.html"]
|
|
elif full_path.endswith(".html"):
|
|
template_candidates = [full_path.lstrip('/')]
|
|
else:
|
|
template_candidates = [f"{full_path.strip('/')}.html", f"{full_path.strip('/')}/index.html"]
|
|
|
|
for name in template_candidates:
|
|
try:
|
|
if markdown_mode:
|
|
content = templates.env.get_template(name).render(request=request)
|
|
soup = BeautifulSoup(content, "html.parser")
|
|
main = str(soup.find("main")) if soup.find("main") else content
|
|
markdown = markitdown.convert_stream(io.BytesIO(main.encode("utf-8")), file_extension=".html")
|
|
response = PlainTextResponse(markdown.text_content, status_code=200, media_type="text/markdown")
|
|
else:
|
|
response = templates.TemplateResponse(status_code=200, request=request, name=name)
|
|
|
|
accesscounter.increase()
|
|
return response
|
|
except TemplateNotFound:
|
|
continue
|
|
|
|
if original_path in ["", "/"]:
|
|
markdown_candidates = ["index.md"]
|
|
elif original_path.endswith(".md"):
|
|
markdown_candidates = [original_path.lstrip('/')]
|
|
else:
|
|
markdown_candidates = [f"{original_path.strip('/')}.md", f"{original_path.strip('/')}/index.md"]
|
|
|
|
for name in markdown_candidates:
|
|
try:
|
|
markdown_path = Path.cwd().joinpath("public", name)
|
|
if not markdown_path.is_relative_to(Path.cwd().joinpath("public")):
|
|
continue
|
|
with markdown_path.open("r") as f:
|
|
markdown = f.read()
|
|
|
|
if markdown_mode:
|
|
response = PlainTextResponse(markdown, status_code=200, media_type="text/markdown")
|
|
else:
|
|
if not markdown.startswith("---"):
|
|
front = {}
|
|
body = markdown
|
|
else:
|
|
end = markdown.find("\n---", 3)
|
|
if end == -1:
|
|
front = {}
|
|
body = markdown
|
|
else:
|
|
front = yaml.safe_load(markdown[3:end]) or {}
|
|
body = markdown[end+4:].lstrip("\n")
|
|
|
|
html = htmlitdown(body)
|
|
source = f"{{% extends \"/base.html\" %}}\n"
|
|
for block in front:
|
|
source += f"{{% block {block} %}}{front[block]}{{% endblock %}}\n"
|
|
source += f"{{% block content %}}\n{html}\n{{% endblock %}}\n"
|
|
|
|
content = templates.env.from_string(source).render(request=request)
|
|
response = Response(content=content, status_code=200, media_type="text/html")
|
|
|
|
accesscounter.increase()
|
|
return response
|
|
except FileNotFoundError:
|
|
continue
|
|
|
|
try:
|
|
path = Path.cwd().joinpath("public", "shorturls.json")
|
|
if not path.exists():
|
|
return error_page(templates, request, 500, "短縮URLの処理のためのJSONファイルがありません。", "設定ファイルぐらい用意しておけよ！")
|
|
shorturls = json.load(path.open("r", encoding="utf-8"))
|
|
except Exception:
|
|
return error_page(templates, request, 500, "短縮URLの処理のためのJSONファイルを正常に読み込めませんでした。", "なにこの設定ファイル読めないじゃない！")
|
|
|
|
if result := resolve_shorturl(shorturls, full_path):
|
|
return RedirectResponse(url=result)
|
|
|
|
return error_page(templates, request, 404, "リクエストしたページは現在ご利用になれません。削除/移動されたか、URLが間違っている可能性があります。", "そんなページ知らないっ！")
|