cmd/pkgserver: add status endpoint

cmd/pkgserver/main.go

@@ -0,0 +1,229 @@
+package main
+
+import (
+	"bytes"
+	"cmp"
+	"context"
+	"embed"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"path"
+	"slices"
+	"strings"
+	"syscall"
+
+	"hakurei.app/command"
+	"hakurei.app/container/check"
+	"hakurei.app/internal/pkg"
+	"hakurei.app/internal/rosa"
+	"hakurei.app/message"
+)
+
+//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) {
+	fmt.Printf("serveWebUI: %s\n", r.URL.Path)
+	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) {
+	fmt.Printf("serveStaticContent: %s\n", r.URL.Path)
+	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 serveAPI(index *PackageIndex) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {}
+}
+
+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 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"`
+	Website     string `json:"website"`
+	Version     string `json:"version"`
+	status      []byte
+}
+
+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
+		if n < 1 {
+			status = nil
+		} else {
+			status = st
+		}
+		log.Printf("Processing package %s...\n", m.Name)
+		entry := PackageIndexEntry{
+			Name:        m.Name,
+			Description: m.Description,
+			Website:     m.Website,
+			Version:     v,
+			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
+}
+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
+		}
+		log.Println("baseDir:", baseDir)
+		cache, err := pkg.Open(ctx, msg, 0, baseDir)
+		if err != nil {
+			return err
+		}
+		report, err := rosa.OpenReport(reportPath)
+		if err != nil {
+			return err
+		}
+		log.Println("reportPath:", reportPath)
+		log.Println("indexing packages...")
+		index, err := createPackageIndex(cache, report)
+		if err != nil {
+			return err
+		}
+		log.Println("created package index")
+		http.HandleFunc("GET /{$}", serveWebUI)
+		http.HandleFunc("GET /favicon.ico", serveStaticContent)
+		http.HandleFunc("GET /static/", serveStaticContent)
+		http.HandleFunc("GET /api/", serveAPI(index))
+		http.HandleFunc("GET /api/status/", serveStatus(index))
+		log.Println("listening on", flagPort)
+		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/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;
+}

internal/azalea/azalea.go

@@ -0,0 +1,69 @@
+//go:generate gocc -a azalea.bnf
+package azalea
+
+import (
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"hakurei.app/container/check"
+)
+
+type Parser struct {
+	Generator
+}
+
+func NewParser(gen Generator) *Parser {
+	return &Parser{
+		Generator: gen,
+	}
+}
+func (p Parser) Initialise() {
+
+}
+
+func (p Parser) Consume(ns string, file io.Reader) error {
+	return nil
+}
+
+// ConsumeDir walks a directory and consumes all Azalea source files within it and all its subdirectories, as long as they end with the .az extension.
+func (p Parser) ConsumeDir(dir *check.Absolute) error {
+	ds := dir.String()
+	return filepath.WalkDir(ds, func(path string, d fs.DirEntry, err error) (e error) {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() || !strings.HasSuffix(d.Name(), ".az") {
+			return
+		}
+		rel, e := filepath.Rel(ds, path)
+		ns := strings.TrimSuffix(rel, ".az")
+		f, e := os.Open(path)
+		return p.Consume(ns, f)
+	})
+}
+
+// ConsumeAll consumes all provided readers as Azalea source code, each given the namespace `r%d` where `%d` is the index of the reader in the provided arguments.
+func (p Parser) ConsumeAll(in ...io.Reader) error {
+	for i, r := range in {
+		err := p.Consume("r"+strconv.FormatInt(int64(i), 10), r)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ConsumeStrings consumes all provided strings as Azalea source code, each given the namespace `s%d` where `%d` is the index of the string in the provided arugments.
+func (p Parser) ConsumeStrings(in ...string) error {
+	for i, s := range in {
+		err := p.Consume("s"+strconv.FormatInt(int64(i), 10), strings.NewReader(s))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/azalea/generator.go

@@ -0,0 +1,36 @@
+package azalea
+
+import (
+	"io"
+)
+
+type Generator interface {
+	Finalise() (error, io.Writer)
+}
+
+type JsonGenerator struct {
+	t any
+}
+
+func NewJsonGenerator[T any]() JsonGenerator {
+	t := new(T)
+
+	return JsonGenerator{
+		t,
+	}
+}
+
+func (j *JsonGenerator) Finalise() (error, io.Writer) {
+
+}
+
+type PkgIRGenerator struct {
+}
+
+func NewPkgIRGenerator() PkgIRGenerator {
+	return PkgIRGenerator{}
+}
+
+func (p *PkgIRGenerator) Finalise() (error, io.Writer) {
+
+}