You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
mir/handler.go

322 lines
8.2 KiB
Go

package main
import (
"context"
"embed"
"encoding/json"
"errors"
"fmt"
"io/fs"
"net"
"net/http"
"os"
"path/filepath"
"regexp"
"strings"
"time"
"golang.org/x/mod/semver"
)
//go:embed meta
var content embed.FS
// this is pretty janky, but I didn't want to import a routing library
var (
latestP = regexp.MustCompile(`^/dl/(.+)/@latest$`)
listP = regexp.MustCompile(`^/dl/(.+)/@v/list$`)
infoP = regexp.MustCompile(`^/dl/(.+)/@v/(.+)\.info$`)
modP = regexp.MustCompile(`^/dl/(.+)/@v/(.+)\.mod$`)
zipP = regexp.MustCompile(`^/dl/(.+)/@v/(.+)\.zip$`)
)
type handler struct {
httpAddr string
socketPath string
root string
hostname string
}
func (h handler) run() error {
if h.hostname == "" {
return fmt.Errorf("hostname missing but hostname is required")
}
l, err := h.listen()
if err != nil {
return err
}
server := http.Server{
Handler: h,
}
onShutdown(func() error {
log_info.Print("shutting down http server")
return server.Shutdown(context.TODO())
})
// ??
start := time.Now()
err = server.Serve(l)
if err != nil {
// I dunno how to check for the right error, offhand
if time.Since(start) < time.Second {
return fmt.Errorf("unable to start server: %v", err)
}
}
log_info.Printf("http serve result: %v", err)
return nil
}
func (h handler) listen() (net.Listener, error) {
if h.httpAddr == "" && h.socketPath == "" {
return nil, fmt.Errorf("must supply one of -http or -unix")
}
if h.httpAddr != "" {
if h.socketPath != "" {
return nil, fmt.Errorf("must supply (only) one of -http or -unix: supplied both")
}
lis, err := net.Listen("tcp", h.httpAddr)
if err != nil {
return nil, fmt.Errorf("failed to start http listener: %w", err)
}
return lis, nil
}
lis, err := net.Listen("unix", h.socketPath)
if err != nil {
return nil, fmt.Errorf("failed to start unix socket listener: %w", err)
}
// TODO: what should this permission set be? hrm
// TODO: what about the error here?
os.Chmod(h.socketPath, 0777)
return lis, nil
}
func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
log_info.Printf("%s %s %s %s", r.Method, r.Host, r.URL.Host, r.URL.String())
// this is very stupid but I didn't want to add a routing library
// dependency for five endpoints
if matches := latestP.FindStringSubmatch(r.URL.Path); matches != nil {
modpath := matches[1]
h.latest(modpath, w, r)
return
}
if matches := listP.FindStringSubmatch(r.URL.Path); matches != nil {
modpath := matches[1]
h.list(modpath, w, r)
return
}
// if matches := infoP.FindStringSubmatch(r.URL.Path); matches != nil {
// modpath := matches[1]
// modversion := matches[2]
// h.info(modpath, modversion, w, r)
// return
// }
// if matches := modP.FindStringSubmatch(r.URL.Path); matches != nil {
// modpath := matches[1]
// modversion := matches[2]
// h.modfile(modpath, modversion, w, r)
// return
// }
// if matches := zipP.FindStringSubmatch(r.URL.Path); matches != nil {
// modpath := matches[1]
// modversion := matches[2]
// h.zipfile(modpath, modversion, w, r)
// return
// }
w.WriteHeader(http.StatusNotFound)
w.Write([]byte("not found"))
return
// switch r.URL.Path {
// case "/fart":
// // Step 1: a request comes in at orel.li. This page contains a meta tag
// // indicating where the package contents may be found, and which backend
// // is serving the package.
// serveFile(w, "meta/fart/root.html")
// case "/modules/orel.li/fart/@v/list":
// // Step 2: list all of the versions for the package. Versions may be
// // available but unlisted.
// serveFile(w, "meta/fart/version-list")
// case "/modules/orel.li/fart/@latest",
// "/modules/orel.li/fart/@v/v0.0.3.info":
// // Step 3: get info for the version, which is just a timestamp at the
// // moment.
// e := json.NewEncoder(w)
// e.Encode(versionInfo{
// Version: "v0.0.3",
// Time: time.Now(),
// })
// case "/modules/orel.li/fart/@v/v0.0.3.mod":
// // Step 4: retrieve the modfile for the package, informing go mod of
// // any transitive dependencies.
// serveFile(w, "meta/fart/modfile")
// case "/modules/orel.li/fart/@v/v0.0.3.zip":
// // Step 5: retrieve the source code contents for a package, as a
// // specially-formatted zip file.
// err := zip.CreateFromDir(w, module.Version{
// Path: "orel.li/fart",
// Version: "v0.0.3",
// }, "/home/jorelli/mir/modules/orel.li/fart")
// if err != nil {
// log_error.Printf("zip error: %v", err)
// }
// case "/":
// w.WriteHeader(http.StatusOK)
// default:
// w.WriteHeader(http.StatusNotFound)
// w.Write([]byte("not found"))
// }
}
// locate searches our module root for a given modpath
func (h handler) locate(modpath string) ([]os.DirEntry, error) {
localDir := filepath.Join(h.root, "modules", modpath)
return os.ReadDir(localDir)
}
// writeError writes a given error to an underlying http responsewriter
func writeError(w http.ResponseWriter, err error) {
// this sucks and is wrong
if os.IsNotExist(err) {
log_info.Printf("404 %v", err)
w.WriteHeader(http.StatusNotFound)
fmt.Fprintf(w, "not found")
return
}
var status apiError
if errors.As(err, &status) {
w.WriteHeader(int(status))
log_error.Printf("%d %v", status, err)
fmt.Fprintf(w, err.Error())
return
}
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, "internal server error")
log_error.Printf("500 %v", err)
return
}
// getVersions gets the list of versions available for a module
func (h handler) getVersions(modpath string) ([]string, error) {
dirpath, _ := filepath.Split(modpath)
localDir := filepath.Join(h.root, "modules", dirpath)
files, err := os.ReadDir(localDir)
if err != nil {
if errors.Is(err, fs.ErrNotExist) {
return nil, apiError(http.StatusNotFound)
}
if errors.Is(err, fs.ErrPermission) {
return nil, apiError(http.StatusForbidden)
}
return nil, joinErrors(err, apiError(http.StatusInternalServerError))
}
allVersions := make([]string, 0, len(files))
for _, f := range files {
name := f.Name()
if filepath.Ext(name) != ".zip" {
continue
}
parts := strings.Split(name[:len(name)-4], "@")
if len(parts) != 2 {
continue
}
if !semver.IsValid(parts[1]) {
continue
}
allVersions = append(allVersions, parts[1])
}
if len(allVersions) == 0 {
return nil, apiError(http.StatusNotFound)
}
semver.Sort(allVersions)
return allVersions, nil
}
func (h handler) stat(modpath, version string) (os.FileInfo, error) {
log_info.Printf("stat modpath: %s version: %s", modpath, version)
dirname, basename := filepath.Split(modpath)
absdir := filepath.Join(h.root, "modules", dirname)
fname := filepath.Join(absdir, fmt.Sprintf("%s@%s.zip", basename, version))
return os.Stat(fname)
}
// latest serves the @latest endpoint
func (h handler) latest(modpath string, w http.ResponseWriter, r *http.Request) {
versions, err := h.getVersions(modpath)
if err != nil {
writeError(w, err)
return
}
log_info.Printf("all versions: %v", versions)
type Info struct {
Version string
Time time.Time
}
last := versions[len(versions)-1]
fi, err := h.stat(modpath, last)
if err != nil {
writeError(w, err)
return
}
json.NewEncoder(w).Encode(Info{
Version: last,
Time: fi.ModTime(),
})
}
// list serves the $base/$module/@v/list endpoint
func (h handler) list(modpath string, w http.ResponseWriter, r *http.Request) {
versions, err := h.getVersions(modpath)
if err != nil {
writeError(w, err)
return
}
for _, version := range versions {
fmt.Fprint(w, version)
}
}
// info serves the $base/$module/@v/$version.info endpoint
func (h handler) info(modpath, modversion string, w http.ResponseWriter, r *http.Request) {
}
// modfile serves the $base/$module/@v/$version.mod endpoint
func (h handler) modfile(modpath, modversion string, w http.ResponseWriter, r *http.Request) {
}
// zipfile serves the $base/$module/@v/$version.zip endpoint
func (h handler) zipfile(modpath, modversion string, w http.ResponseWriter, r *http.Request) {
}
func serveFile(w http.ResponseWriter, path string) {
b, err := content.ReadFile(path)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, err.Error())
}
w.Write(b)
}
type versionInfo struct {
Version string // version string
Time time.Time // commit time
}