management server listener (#17)

Reviewed-on: #17 Co-authored-by: David Ashby <delta.mu.alpha@gmail.com> Co-committed-by: David Ashby <delta.mu.alpha@gmail.com>
2024-01-06 21:38:13 +00:00
parent dc7218131d
commit 315fb4e9d2
19 changed files with 1112 additions and 224 deletions
--- a/cmd/manage/events.go
+++ b/cmd/manage/events.go
--- a/cmd/manage/main.go
+++ b/cmd/manage/main.go
--- a/cmd/serve/api.go
+++ b/cmd/serve/api.go
@@ -0,0 +1,179 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"net/http"
+
+	"git.yetaga.in/alazyreader/library/media"
+	"tailscale.com/client/tailscale"
+)
+
+type Router struct {
+	static  fs.FS
+	lib     Library
+	rcol    RecordCollection
+	query   Query
+	ts      *tailscale.LocalClient
+	isAdmin bool
+}
+
+type path map[string]func()
+
+func (h path) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if f, ok := h[r.Method]; ok {
+		f()
+		return
+	}
+	writeJSONerror(w, "method not supported", http.StatusMethodNotAllowed)
+}
+
+func writeJSONerror(w http.ResponseWriter, err string, status int) {
+	log.Println(err)
+	writeJSON(w, struct{ Status, Reason string }{Status: "error", Reason: err}, status)
+}
+
+func writeJSON(w http.ResponseWriter, b any, status int) {
+	bytes, err := json.Marshal(b)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	w.Write(bytes)
+	w.Write([]byte("\n"))
+}
+
+func (router *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	switch r.URL.Path {
+	case "/api/mode":
+		path{
+			http.MethodGet: func() {
+				writeJSON(w, struct{ Admin bool }{Admin: router.isAdmin}, http.StatusOK)
+			},
+		}.ServeHTTP(w, r)
+	case "/api/whoami":
+		if !router.isAdmin {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+		path{
+			http.MethodGet: func() { getWhoAmI(router.ts, w, r) },
+		}.ServeHTTP(w, r)
+	case "/api/records":
+		path{
+			http.MethodGet: func() { getRecords(router.rcol, w, r) },
+		}.ServeHTTP(w, r)
+	case "/api/books":
+		p := path{
+			http.MethodGet: func() { getBooks(router.lib, w, r) },
+		}
+		if router.isAdmin {
+			p[http.MethodPost] = func() { addBook(router.lib, w, r) }
+			p[http.MethodDelete] = func() { deleteBook(router.lib, w, r) }
+		}
+		p.ServeHTTP(w, r)
+	case "/api/query":
+		if !router.isAdmin {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+		path{
+			http.MethodPost: func() { lookupBook(router.query, w, r) },
+		}.ServeHTTP(w, r)
+	default:
+		static(router.static).ServeHTTP(w, r)
+	}
+}
+
+func getBooks(l Library, w http.ResponseWriter, r *http.Request) {
+	books, err := l.GetAllBooks(r.Context())
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, books, http.StatusOK)
+}
+
+func addBook(l Library, w http.ResponseWriter, r *http.Request) {
+	book, err := ReadBody[media.Book](r.Body)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err = l.AddBook(r.Context(), book); err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusAccepted)
+}
+
+func deleteBook(l Library, w http.ResponseWriter, r *http.Request) {
+	book, err := ReadBody[media.Book](r.Body)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err = l.DeleteBook(r.Context(), book); err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusAccepted)
+}
+
+func getRecords(l RecordCollection, w http.ResponseWriter, r *http.Request) {
+	records, err := l.GetAllRecords(r.Context())
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, records, http.StatusOK)
+}
+
+func getWhoAmI(ts *tailscale.LocalClient, w http.ResponseWriter, r *http.Request) {
+	whois, err := ts.WhoIs(r.Context(), r.RemoteAddr)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, whois.UserProfile, http.StatusOK)
+}
+
+func lookupBook(query Query, w http.ResponseWriter, r *http.Request) {
+	req, err := ReadBody[media.Book](r.Body)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	book, err := query.GetByISBN(req.ISBN13)
+	if err != nil {
+		writeJSONerror(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, book, http.StatusOK)
+}
+
+func static(f fs.FS) http.Handler {
+	return http.FileServer(http.FS(f))
+}
+
+func ReadBody[T any](r io.ReadCloser) (*T, error) {
+	t := new(T)
+	if r == nil {
+		return t, fmt.Errorf("no body provided")
+	}
+	defer r.Close()
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return t, fmt.Errorf("error reading body: %w", err)
+	}
+	err = json.Unmarshal(b, t)
+	if err != nil {
+		return t, fmt.Errorf("error reading body: %w", err)
+	}
+	return t, nil
+}
--- a/cmd/serve/main.go
+++ b/cmd/serve/main.go
@@ -2,10 +2,12 @@ package main

 import (
 	"context"
-	"encoding/json"
-	"io/fs"
+	"fmt"
 	"log"
+	"net"
 	"net/http"
+	"os"
+	"os/signal"
 	"strings"
 	"time"

@@ -13,100 +15,78 @@ import (
 	"git.yetaga.in/alazyreader/library/database"
 	"git.yetaga.in/alazyreader/library/frontend"
 	"git.yetaga.in/alazyreader/library/media"
+	"git.yetaga.in/alazyreader/library/query"
 	"github.com/kelseyhightower/envconfig"
+	"golang.org/x/sync/errgroup"
+	"tailscale.com/tsnet"
+	"tailscale.com/util/must"
 )

-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
 func obscureStr(in string, l int) string {
 	return in[0:max(l, len(in))] + strings.Repeat("*", max(0, len(in)-l))
 }

 type Library interface {
 	GetAllBooks(context.Context) ([]media.Book, error)
+	AddBook(context.Context, *media.Book) error
+	DeleteBook(context.Context, *media.Book) error
 }

 type RecordCollection interface {
 	GetAllRecords(context.Context) ([]media.Record, error)
 }

-type Router struct {
-	static fs.FS
-	lib    Library
-	rcol   RecordCollection
-}
-
-func writeJSON(w http.ResponseWriter, b []byte, status int) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	w.WriteHeader(status)
-	w.Write(b)
-	w.Write([]byte("\n"))
-}
-
-func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	if req.URL.Path == "/api/records" {
-		RecordsAPIHandler(r.rcol).ServeHTTP(w, req)
-		return
-	}
-	if req.URL.Path == "/api/books" {
-		BooksAPIHandler(r.lib).ServeHTTP(w, req)
-		return
-	}
-	StaticHandler(r.static).ServeHTTP(w, req)
-}
-
-func BooksAPIHandler(l Library) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		books, err := l.GetAllBooks(r.Context())
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		b, err := json.Marshal(books)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-
-		}
-		writeJSON(w, b, http.StatusOK)
-	})
-}
-
-func RecordsAPIHandler(l RecordCollection) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		books, err := l.GetAllRecords(r.Context())
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		b, err := json.Marshal(books)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		writeJSON(w, b, http.StatusOK)
-	})
-}
-
-func StaticHandler(f fs.FS) http.Handler {
-	return http.FileServer(http.FS(f))
+type Query interface {
+	GetByISBN(string) (*media.Book, error)
 }

 func main() {
 	var c config.Config
-	err := envconfig.Process("library", &c)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	f, err := frontend.Root()
-	if err != nil {
-		log.Fatalln(err)
+	must.Do(envconfig.Process("library", &c))
+
+	var lib Library
+	if c.DBType == "memory" {
+		lib = &database.Memory{}
+	} else if c.DBType == "sql" {
+		sqllib, latest, run, err := setupSQL(c)
+		if err != nil {
+			log.Fatalf("sql connection err: %v", err)
+		}
+		log.Printf("latest migration: %d; migrations run: %d", latest, run)
+		lib = sqllib
 	}
+	discogsCache := must.Get(database.NewDiscogsCache(
+		c.DiscogsToken, time.Hour*24, c.DiscogsUser, c.DiscogsPersist, c.DiscogsCacheFile,
+	))
+	queryProvider := &query.GoogleBooks{}
+	staticRoot := must.Get(frontend.Root())
+
+	servers := make(chan (*http.Server), 3)
+	errGroup := errgroup.Group{}
+	errGroup.Go(func() error {
+		return start(servers)(publicServer(8080, &Router{
+			static:  staticRoot,
+			lib:     lib,
+			rcol:    discogsCache,
+			isAdmin: false,
+		}))
+	})
+	errGroup.Go(func() error {
+		return start(servers)(tailscaleListener("library-admin", &Router{
+			static:  staticRoot,
+			lib:     lib,
+			rcol:    discogsCache,
+			query:   queryProvider,
+			isAdmin: true,
+		}))
+	})
+	errGroup.Go(func() error {
+		return shutdown(servers)
+	})
+	log.Println(errGroup.Wait())
+}
+
+func setupSQL(c config.Config) (Library, int, int, error) {
 	if c.DBUser == "" || c.DBPass == "" || c.DBHost == "" || c.DBPort == "" || c.DBName == "" {
 		if c.DBPass != "" {
 			c.DBPass = obscureStr(c.DBPass, 3)
@@ -114,30 +94,77 @@ func main() {
 		if c.DiscogsToken != "" {
 			c.DiscogsToken = obscureStr(c.DiscogsToken, 3)
 		}
-		log.Fatalf("vars: %+v", c)
+		return nil, 0, 0, fmt.Errorf("invalid config; vars provided: %+v", c)
 	}
-	lib, err := database.NewMySQLConnection(c.DBUser, c.DBPass, c.DBHost, c.DBPort, c.DBName)
+	sql, err := database.NewMySQLConnection(c.DBUser, c.DBPass, c.DBHost, c.DBPort, c.DBName)
 	if err != nil {
-		log.Fatalln(err)
+		return nil, 0, 0, err
 	}
-	err = lib.PrepareDatabase(context.Background())
+	err = sql.PrepareDatabase(context.Background())
 	if err != nil {
-		log.Fatalln(err)
+		return nil, 0, 0, err
 	}
-	latest, run, err := lib.RunMigrations(context.Background())
+	latest, run, err := sql.RunMigrations(context.Background())
 	if err != nil {
-		log.Fatalln(err)
+		return nil, 0, 0, err
 	}
-	log.Printf("latest migration: %d; migrations run: %d", latest, run)
-	discogsCache, err := database.NewDiscogsCache(c.DiscogsToken, time.Hour*24, c.DiscogsUser, c.DiscogsPersist, c.DiscogsCacheFile)
-	if err != nil {
-		log.Fatalln(err)
-	}
-	r := &Router{
-		static: f,
-		lib:    lib,
-		rcol:   discogsCache,
-	}
-	log.Println("Listening on http://0.0.0.0:8080/")
-	log.Fatalln(http.ListenAndServe(":8080", r))
+	return sql, latest, run, nil
+}
+
+func start(servers chan (*http.Server)) func(*http.Server, net.Listener, error) error {
+	return func(s *http.Server, l net.Listener, err error) error {
+		if err != nil {
+			return err
+		}
+		servers <- s
+		return s.Serve(l)
+	}
+}
+
+func shutdown(servers chan (*http.Server)) error {
+	sigint := make(chan os.Signal, 1)
+	signal.Notify(sigint, os.Interrupt)
+	<-sigint
+	close(servers)
+	var err error
+	for server := range servers {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+		if shutdownerr := server.Shutdown(ctx); shutdownerr != nil {
+			err = shutdownerr
+		}
+		cancel()
+	}
+	return err
+}
+
+func publicServer(port int, handler http.Handler) (*http.Server, net.Listener, error) {
+	server := &http.Server{Handler: handler}
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	if err != nil {
+		return nil, nil, err
+	}
+	log.Printf("public server: http://0.0.0.0:%d/", port)
+	return server, ln, nil
+}
+
+func tailscaleListener(hostname string, handler *Router) (*http.Server, net.Listener, error) {
+	s := &tsnet.Server{
+		Dir:      ".config/" + hostname,
+		Hostname: hostname,
+		Logf: func(s string, a ...any) { // silence most tsnet logs
+			if strings.HasPrefix(s, "To start this tsnet server") {
+				log.Printf(s, a...)
+			}
+		},
+	}
+	ln, err := s.Listen("tcp", ":80")
+	if err != nil {
+		return nil, nil, err
+	}
+	handler.ts, err = s.LocalClient()
+	if err != nil {
+		return nil, nil, err
+	}
+	log.Printf("management server: http://%s/", hostname)
+	return &http.Server{Handler: handler}, ln, nil
 }