cmd/pkgserver: api versioning

cmd/pkgserver/api.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"path"
+	"strconv"
+	"strings"
+
+	"hakurei.app/internal/info"
+	"hakurei.app/internal/rosa"
+)
+
+type InfoPayload struct {
+	Count          int    `json:"count"`
+	HakureiVersion string `json:"hakurei_version"`
+}
+
+func NewInfoPayload(index *PackageIndex) InfoPayload {
+	count := len(index.sorts[0])
+	return InfoPayload{
+		Count:          count,
+		HakureiVersion: info.Version(),
+	}
+}
+
+func serveInfo(index *PackageIndex) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Header().Set("Content-Type", "text/json; charset=utf-8")
+		w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+		WritePayload(w, NewInfoPayload(index))
+	}
+}
+
+func serveStatus(index *PackageIndex) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if index == nil {
+			http.Error(w, "index is nil", http.StatusInternalServerError)
+			return
+		}
+		base := path.Base(r.URL.Path)
+		name := strings.TrimSuffix(base, ".log")
+		p, ok := rosa.ResolveName(name)
+		if !ok {
+			http.NotFound(w, r)
+			return
+		}
+		m := rosa.GetMetadata(p)
+		pk, ok := index.names[m.Name]
+		if !ok {
+			http.NotFound(w, r)
+			return
+		}
+		if len(pk.status) > 0 {
+			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+			w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+			w.WriteHeader(http.StatusOK)
+			_, err := io.Copy(w, bytes.NewReader(pk.status))
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+			}
+		} else {
+			http.NotFound(w, r)
+		}
+	}
+}
+
+type GetPayload struct {
+	Count  int                 `json:"count"`
+	Values []PackageIndexEntry `json:"values"`
+}
+
+func NewGetPayload(values []*PackageIndexEntry) GetPayload {
+	count := len(values)
+	v := make([]PackageIndexEntry, count)
+	for i, _ := range values {
+		v[i] = *values[i]
+	}
+	return GetPayload{
+		Count:  count,
+		Values: v,
+	}
+}
+
+func serveGet(index *PackageIndex) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		q := r.URL.Query()
+		limit, err := strconv.Atoi(q.Get("limit"))
+		if err != nil || limit > 100 || limit < 1 {
+			http.Error(w, fmt.Sprintf("limit must be an integer between 1 and 100"), http.StatusBadRequest)
+			return
+		}
+		i, err := strconv.Atoi(q.Get("index"))
+		if err != nil || i >= len(index.sorts[0]) || i < 0 {
+			http.Error(w, fmt.Sprintf("index must be an integer between 0 and %d", len(index.sorts[0])-1), http.StatusBadRequest)
+			return
+		}
+		sort, err := strconv.Atoi(q.Get("sort"))
+		if err != nil || sort >= len(index.sorts) || sort < 0 {
+			http.Error(w, fmt.Sprintf("sort must be an integer between 0 and %d", len(index.sorts)-1), http.StatusBadRequest)
+			return
+		}
+		values := index.sorts[sort][i:min(i+limit, len(index.sorts[sort]))]
+		WritePayload(w, NewGetPayload(values))
+	}
+}
+
+const ApiVersion = "v1"
+
+func apiRoutes(index *PackageIndex) {
+	http.HandleFunc(fmt.Sprintf("GET /api/%s/info", ApiVersion), serveInfo(index))
+	http.HandleFunc(fmt.Sprintf("GET /api/%s/get", ApiVersion), serveGet(index))
+	http.HandleFunc(fmt.Sprintf("GET /api/%s/status/", ApiVersion), serveStatus(index))
+}
+
+func WritePayload(w http.ResponseWriter, payload any) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+	w.WriteHeader(http.StatusOK)
+	err := json.NewEncoder(w).Encode(payload)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}

cmd/pkgserver/index.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"cmp"
+	"fmt"
+	"slices"
+
+	"hakurei.app/internal/pkg"
+	"hakurei.app/internal/rosa"
+)
+
+type SortOrders int
+
+const (
+	DeclarationAscending SortOrders = iota
+	DeclarationDescending
+	NameAscending
+	NameDescending
+	limitSortOrders
+)
+
+type PackageIndex struct {
+	sorts [limitSortOrders][rosa.PresetUnexportedStart]*PackageIndexEntry
+	names map[string]*PackageIndexEntry
+}
+
+type PackageIndexEntry struct {
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	Website     string `json:"website,omitempty"`
+	Version     string `json:"version"`
+	Status      string `json:"report,omitempty"`
+	status      []byte `json:"-"`
+}
+
+func createPackageIndex(cache *pkg.Cache, report *rosa.Report) (_ *PackageIndex, err error) {
+	index := new(PackageIndex)
+	index.names = make(map[string]*PackageIndexEntry, rosa.PresetUnexportedStart)
+	work := make([]PackageIndexEntry, rosa.PresetUnexportedStart)
+	defer report.HandleAccess(&err)()
+	for p := range rosa.PresetUnexportedStart {
+		m := rosa.GetMetadata(p)
+		v := rosa.Std.Version(p)
+		a := rosa.Std.Load(p)
+		id := cache.Ident(a)
+		st, n := report.ArtifactOf(id)
+		var status []byte
+		var statusUrl string
+		if n < 1 {
+			status = nil
+			statusUrl = ""
+		} else {
+			status = st
+			statusUrl = fmt.Sprintf("/api/%s/status/%s.log", ApiVersion, m.Name)
+		}
+		entry := PackageIndexEntry{
+			Name:        m.Name,
+			Description: m.Description,
+			Website:     m.Website,
+			Version:     v,
+			Status:      statusUrl,
+			status:      status,
+		}
+		work[p] = entry
+		index.names[m.Name] = &entry
+	}
+	for i, p := range work {
+		index.sorts[DeclarationAscending][i] = &p
+	}
+	slices.Reverse(work)
+	for i, p := range work {
+		index.sorts[DeclarationDescending][i] = &p
+	}
+	slices.SortFunc(work, func(a PackageIndexEntry, b PackageIndexEntry) int {
+		return cmp.Compare(a.Name, b.Name)
+	})
+	for i, p := range work {
+		index.sorts[NameAscending][i] = &p
+	}
+	slices.Reverse(work)
+	for i, p := range work {
+		index.sorts[NameDescending][i] = &p
+	}
+	return index, err
+}

cmd/pkgserver/main.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"hakurei.app/command"
+	"hakurei.app/container/check"
+	"hakurei.app/internal/pkg"
+	"hakurei.app/internal/rosa"
+	"hakurei.app/message"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("pkgserver: ")
+
+	var (
+		flagBaseDir string
+		flagPort    int
+	)
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
+	defer stop()
+	msg := message.New(log.Default())
+
+	c := command.New(os.Stderr, log.Printf, "pkgserver", func(args []string) error {
+		reportPath := args[0]
+		baseDir, err := check.NewAbs(flagBaseDir)
+		if err != nil {
+			return err
+		}
+		cache, err := pkg.Open(ctx, msg, 0, baseDir)
+		if err != nil {
+			return err
+		}
+		report, err := rosa.OpenReport(reportPath)
+		if err != nil {
+			return err
+		}
+		index, err := createPackageIndex(cache, report)
+		if err != nil {
+			return err
+		}
+		uiRoutes()
+		apiRoutes(index)
+		err = http.ListenAndServe(fmt.Sprintf(":%d", flagPort), nil)
+		if err != nil {
+			return err
+		}
+		return nil
+	}).Flag(
+		&flagBaseDir,
+		"b", command.StringFlag(""),
+		"base directory for cache",
+	).Flag(
+		&flagPort,
+		"p", command.IntFlag(8067),
+		"http listen port",
+	)
+	c.MustParse(os.Args[1:], func(e error) {
+		log.Fatal(e)
+	})
+
+}

cmd/pkgserver/ui.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"embed"
+	"net/http"
+)
+
+//go:generate sh -c "sass ui/static/dark.scss ui/static/dark.css && sass ui/static/light.scss ui/static/light.css && tsc ui/static/index.ts"
+//go:embed ui/*
+var content embed.FS
+
+func serveWebUI(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.Header().Set("X-XSS-Protection", "1")
+	w.Header().Set("X-Frame-Options", "DENY")
+
+	http.ServeFileFS(w, r, content, "ui/index.html")
+}
+func serveStaticContent(w http.ResponseWriter, r *http.Request) {
+	switch r.URL.Path {
+	case "/static/style.css":
+		darkTheme := r.CookiesNamed("dark_theme")
+		if len(darkTheme) > 0 && darkTheme[0].Value == "true" {
+			http.ServeFileFS(w, r, content, "ui/static/dark.css")
+		} else {
+			http.ServeFileFS(w, r, content, "ui/static/light.css")
+		}
+		break
+	case "/favicon.ico":
+		http.ServeFileFS(w, r, content, "ui/static/favicon.ico")
+		break
+	case "/static/index.js":
+		http.ServeFileFS(w, r, content, "ui/static/index.js")
+		break
+	default:
+		http.NotFound(w, r)
+
+	}
+}
+
+func uiRoutes() {
+	http.HandleFunc("GET /{$}", serveWebUI)
+	http.HandleFunc("GET /favicon.ico", serveStaticContent)
+	http.HandleFunc("GET /static/", serveStaticContent)
+}

cmd/pkgserver/ui/index.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <link rel="stylesheet" href="static/style.css">
+    <title>Hakurei PkgServer</title>
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+    <script src="static/index.js"></script>
+</head>
+<body>
+<h1>Hakurei PkgServer</h1>
+
+<table id="pkg-list">
+    <tr><th>Status</th><th>Name</th><th>Version</th></tr>
+</table>
+<p>Showing entries <span id="entry-counter"></span>.</p>
+<span class="bottom-nav"><a href="javascript:prevPage()">&laquo; Previous</a> <span id="page-number">1</span> <a href="javascript:nextPage()">Next &raquo;</a></span>
+<span><label for="count">Entries per page:</label><select name="count" id="count">
+    <option value="10">10</option>
+    <option value="25">25</option>
+    <option value="50">50</option>
+    <option value="100">100</option>
+</select></span>
+</body>
+<footer>&copy; <a href="https://hakurei.app/">Hakurei</a>. Licensed under the MIT license.</footer>
+</html>

cmd/pkgserver/ui/static/dark.css

@@ -0,0 +1,6 @@
+@use 'common';
+html {
+  background-color: #2c2c2c;
+  color: ghostwhite; }
+
+/*# sourceMappingURL=dark.css.map */

cmd/pkgserver/ui/static/dark.css.map

@@ -0,0 +1,7 @@
+{
+"version": 3,
+"mappings": "AAAA,aAAa;AAEb,IAAK;EACH,gBAAgB,EAAE,OAAO;EACzB,KAAK,EAAE,UAAU",
+"sources": ["dark.scss"],
+"names": [],
+"file": "dark.css"
+}

cmd/pkgserver/ui/static/dark.scss

@@ -0,0 +1,6 @@
+@use 'common';
+
+html {
+  background-color: #2c2c2c;
+  color: ghostwhite;
+}

cmd/pkgserver/ui/static/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var PackageEntry = /** @class */ (function () {
+    function PackageEntry() {
+    }
+    return PackageEntry;
+}());
+var State = /** @class */ (function () {
+    function State() {
+        this.entriesPerPage = 10;
+        this.currentPage = 1;
+        this.entryIndex = 0;
+        this.loadedEntries = [];
+    }
+    State.prototype.getEntriesPerPage = function () {
+        return this.entriesPerPage;
+    };
+    State.prototype.setEntriesPerPage = function (entriesPerPage) {
+        this.entriesPerPage = entriesPerPage;
+        this.updateRange();
+    };
+    State.prototype.getCurrentPage = function () {
+        return this.currentPage;
+    };
+    State.prototype.setCurrentPage = function (page) {
+        this.currentPage = page;
+        document.getElementById("page-number").innerText = String(this.currentPage);
+        this.updateRange();
+    };
+    State.prototype.getEntryIndex = function () {
+        return this.entryIndex;
+    };
+    State.prototype.setEntryIndex = function (entryIndex) {
+        this.entryIndex = entryIndex;
+        this.updateRange();
+    };
+    State.prototype.getLoadedEntries = function () {
+        return this.loadedEntries;
+    };
+    State.prototype.getMaxPage = function () {
+        return this.loadedEntries.length / this.entriesPerPage;
+    };
+    State.prototype.updateRange = function () {
+        var max = Math.min(this.entryIndex + this.entriesPerPage, this.loadedEntries.length);
+        document.getElementById("entry-counter").innerText = "".concat(this.entryIndex, "-").concat(max, " of ").concat(this.loadedEntries.length);
+    };
+    return State;
+}());
+var STATE;
+function prevPage() {
+    var current = STATE.getCurrentPage();
+    if (current > 1) {
+        STATE.setCurrentPage(STATE.getCurrentPage() - 1);
+    }
+}
+function nextPage() {
+    var current = STATE.getCurrentPage();
+    if (current < STATE.getMaxPage()) {
+        STATE.setCurrentPage(STATE.getCurrentPage() + 1);
+    }
+}
+document.addEventListener("DOMContentLoaded", function () {
+    STATE = new State();
+    STATE.updateRange();
+    document.getElementById("count").addEventListener("change", function (event) {
+        STATE.setEntriesPerPage(parseInt(event.target.value));
+    });
+});

cmd/pkgserver/ui/static/index.ts

@@ -0,0 +1,66 @@
+"use strict"
+
+class PackageEntry {
+
+}
+class State {
+    entriesPerPage: number = 10
+    currentPage: number = 1
+    entryIndex: number = 0
+    loadedEntries: PackageEntry[] = []
+    getEntriesPerPage(): number {
+        return this.entriesPerPage
+    }
+    setEntriesPerPage(entriesPerPage: number) {
+        this.entriesPerPage = entriesPerPage
+        this.updateRange()
+    }
+    getCurrentPage(): number {
+        return this.currentPage
+    }
+    setCurrentPage(page: number) {
+        this.currentPage = page
+        document.getElementById("page-number").innerText = String(this.currentPage)
+        this.updateRange()
+    }
+    getEntryIndex(): number {
+        return this.entryIndex
+    }
+    setEntryIndex(entryIndex: number) {
+        this.entryIndex = entryIndex
+        this.updateRange()
+    }
+    getLoadedEntries(): PackageEntry[] {
+        return this.loadedEntries
+    }
+    getMaxPage(): number {
+        return this.loadedEntries.length / this.entriesPerPage
+    }
+    updateRange() {
+        let max = Math.min(this.entryIndex + this.entriesPerPage, this.loadedEntries.length)
+        document.getElementById("entry-counter").innerText = `${this.entryIndex}-${max} of ${this.loadedEntries.length}`
+    }
+}
+
+let STATE: State
+
+function prevPage() {
+    let current = STATE.getCurrentPage()
+    if (current > 1) {
+        STATE.setCurrentPage(STATE.getCurrentPage() - 1)
+    }
+}
+function nextPage() {
+    let current = STATE.getCurrentPage()
+    if (current < STATE.getMaxPage()) {
+        STATE.setCurrentPage(STATE.getCurrentPage() + 1)
+    }
+}
+
+document.addEventListener("DOMContentLoaded", () => {
+    STATE = new State()
+    STATE.updateRange()
+    document.getElementById("count").addEventListener("change", (event) => {
+        STATE.setEntriesPerPage(parseInt((event.target as HTMLSelectElement).value))
+    })
+})

cmd/pkgserver/ui/static/light.css

@@ -0,0 +1,6 @@
+@use 'common';
+html {
+  background-color: #d3d3d3;
+  color: black; }
+
+/*# sourceMappingURL=light.css.map */

cmd/pkgserver/ui/static/light.css.map

@@ -0,0 +1,7 @@
+{
+"version": 3,
+"mappings": "AAAA,aAAa;AAEb,IAAK;EACH,gBAAgB,EAAE,OAAO;EACzB,KAAK,EAAE,KAAK",
+"sources": ["light.scss"],
+"names": [],
+"file": "light.css"
+}

cmd/pkgserver/ui/static/light.scss

@@ -0,0 +1,6 @@
+@use 'common';
+
+html {
+  background-color: #d3d3d3;
+  color: black;
+}