154 lines
6.7 KiB
Python
154 lines
6.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Serve the project site and the small plain-text RouterOS update feed."""
|
|
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
|
|
import json
|
|
from pathlib import Path
|
|
import re
|
|
import sys
|
|
from urllib.error import URLError
|
|
from urllib.request import Request, urlopen
|
|
from urllib.parse import urlsplit
|
|
|
|
|
|
HERE = Path(__file__).resolve().parent
|
|
SITE = HERE / "site"
|
|
if not SITE.is_dir(): # Running from the source tree: service/server.py.
|
|
SITE = HERE.parent / "site"
|
|
FEED = json.loads((SITE / "feed" / "channels.json").read_text())
|
|
RELEASES_URL = (
|
|
"https://code.brunner.ninja/api/v1/repos/feedc0de/mikrotik-olsr/releases?limit=50"
|
|
)
|
|
PACKAGE_RE = re.compile(r"(routeros|option|olsr|wifi-qcom-ac|wifi-qcom)-"
|
|
r"(7\.\d+(?:\.\d+)?)-(arm|arm64)\.npk\Z")
|
|
VERSION_RE = re.compile(r"7\.\d+(?:\.\d+)?\Z")
|
|
|
|
|
|
def release_assets(version, releases):
|
|
"""Select the newest published revision for each architecture."""
|
|
selected = {}
|
|
for release in releases:
|
|
tag = release.get("tag_name", "")
|
|
match = re.fullmatch(rf"ros-{re.escape(version)}(?:-(arm|arm64))?-r(\d+)", tag)
|
|
if not match or release.get("draft"):
|
|
continue
|
|
tag_arch, revision = match.group(1), int(match.group(2))
|
|
for asset in release.get("assets", []):
|
|
name = asset.get("name", "")
|
|
package = PACKAGE_RE.fullmatch(name)
|
|
if not package or package.group(2) != version:
|
|
continue
|
|
arch = package.group(3)
|
|
if tag_arch and tag_arch != arch:
|
|
continue
|
|
url = asset.get("browser_download_url", "")
|
|
parsed = urlsplit(url)
|
|
if parsed.scheme != "https" or parsed.hostname != "code.brunner.ninja":
|
|
continue
|
|
if not parsed.path.startswith(
|
|
f"/feedc0de/mikrotik-olsr/releases/download/{tag}/"
|
|
) or not parsed.path.endswith("/" + name):
|
|
continue
|
|
key = (arch, package.group(1))
|
|
if key not in selected or revision > selected[key][0]:
|
|
selected[key] = (revision, asset)
|
|
return {key: value[1] for key, value in selected.items()}
|
|
|
|
|
|
def fetch_releases():
|
|
req = Request(RELEASES_URL, headers={"User-Agent": "mikrotik-olsr-site"})
|
|
with urlopen(req, timeout=8) as response:
|
|
return json.load(response)
|
|
|
|
|
|
class Handler(SimpleHTTPRequestHandler):
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, directory=str(SITE), **kwargs)
|
|
|
|
def send_bytes(self, status, body, content_type):
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", content_type)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.send_header("Cache-Control", "public, max-age=300")
|
|
self.end_headers()
|
|
if self.command != "HEAD":
|
|
self.wfile.write(body)
|
|
|
|
def do_HEAD(self):
|
|
self.do_GET()
|
|
|
|
def do_GET(self):
|
|
path = urlsplit(self.path).path
|
|
if path == "/healthz":
|
|
return self.send_bytes(200, b"ok\n", "text/plain; charset=utf-8")
|
|
if path == "/api/releases":
|
|
try:
|
|
body = json.dumps(fetch_releases()).encode()
|
|
return self.send_bytes(200, body, "application/json; charset=utf-8")
|
|
except (URLError, TimeoutError, ValueError) as exc:
|
|
return self.send_bytes(502, (str(exc) + "\n").encode(), "text/plain; charset=utf-8")
|
|
|
|
package_path = re.fullmatch(r"/routeros/(7\.\d+(?:\.\d+)?)/([^/]+)", path)
|
|
if package_path:
|
|
version, filename = package_path.groups()
|
|
if filename == "packages.csv":
|
|
try:
|
|
assets = release_assets(version, fetch_releases())
|
|
except (URLError, TimeoutError, ValueError) as exc:
|
|
return self.send_bytes(502, (str(exc) + "\n").encode(), "text/plain")
|
|
rows = ["arch,name,size"]
|
|
rows += [f"{arch},{name},{asset['size']}" for (arch, name), asset
|
|
in sorted(assets.items())]
|
|
return self.send_bytes(200, ("\n".join(rows) + "\n").encode(), "text/csv")
|
|
package = PACKAGE_RE.fullmatch(filename)
|
|
if package and package.group(2) == version:
|
|
try:
|
|
asset = release_assets(version, fetch_releases()).get(
|
|
(package.group(3), package.group(1)))
|
|
if asset is None:
|
|
return self.send_bytes(404, b"Package not published\n", "text/plain")
|
|
req = Request(asset["browser_download_url"],
|
|
headers={"User-Agent": "mikrotik-olsr-site"})
|
|
with urlopen(req, timeout=30) as response:
|
|
length = int(response.headers.get("Content-Length", "0"))
|
|
if length != asset["size"]:
|
|
raise ValueError("Release asset size mismatch")
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/octet-stream")
|
|
self.send_header("Content-Length", str(length))
|
|
self.end_headers()
|
|
if self.command != "HEAD":
|
|
while block := response.read(65536):
|
|
self.wfile.write(block)
|
|
return
|
|
except (URLError, TimeoutError, ValueError) as exc:
|
|
return self.send_bytes(502, (str(exc) + "\n").encode(), "text/plain")
|
|
|
|
prefix = "/routeros/NEWESTa7."
|
|
if path.startswith(prefix):
|
|
channel = path[len(prefix):]
|
|
item = FEED.get(channel)
|
|
if item is None:
|
|
return self.send_bytes(200, b"No version available in this channel\n", "text/plain; charset=utf-8")
|
|
body = f"{item['version']} {item['epoch']}\n".encode("ascii")
|
|
return self.send_bytes(200, body, "text/plain; charset=utf-8")
|
|
|
|
marker = "/CHANGELOG"
|
|
if path.startswith("/routeros/") and path.endswith(marker):
|
|
version = path[len("/routeros/"):-len(marker)].strip("/")
|
|
if VERSION_RE.fullmatch(version):
|
|
changelog = SITE / "feed" / "changelogs" / f"{version}.txt"
|
|
if changelog.is_file():
|
|
return self.send_bytes(200, changelog.read_bytes(), "text/plain; charset=utf-8")
|
|
return self.send_bytes(404, b"Unknown RouterOS changelog\n", "text/plain; charset=utf-8")
|
|
|
|
return super().do_GET()
|
|
|
|
|
|
def main():
|
|
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8080
|
|
ThreadingHTTPServer(("0.0.0.0", port), Handler).serve_forever()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|