Marvin Steadfast
949d97b49c
All checks were successful
continuous-integration/drone/push Build is passing
126 lines
3.3 KiB
Go
126 lines
3.3 KiB
Go
package web
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"html/template"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
"github.com/rs/zerolog/log"
|
|
"github.com/spf13/cobra"
|
|
"go.xsfx.dev/logginghandler"
|
|
assets "go.xsfx.dev/schnutibox/assets/web"
|
|
"go.xsfx.dev/schnutibox/internal/config"
|
|
api "go.xsfx.dev/schnutibox/pkg/api/v1"
|
|
"go.xsfx.dev/schnutibox/pkg/sselog"
|
|
"golang.org/x/net/http2"
|
|
"golang.org/x/net/http2/h2c"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/reflection"
|
|
)
|
|
|
|
func root(w http.ResponseWriter, r *http.Request) {
|
|
logger := logginghandler.Logger(r)
|
|
|
|
t, err := template.ParseFS(assets.Templates, "templates/index.html.tmpl")
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("could not parse template")
|
|
http.Error(w, "could not parse template", http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
if err := t.Execute(w, struct{}{}); err != nil {
|
|
logger.Error().Err(err).Msg("could not execute template")
|
|
http.Error(w, "could not execute template", http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
// grpcHandlerFunc reads header and returns a grpc handler or a http one.
|
|
// nolint:interfacer
|
|
func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
|
|
return h2c.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
|
|
grpcServer.ServeHTTP(w, r)
|
|
} else {
|
|
otherHandler.ServeHTTP(w, r)
|
|
}
|
|
}), &http2.Server{})
|
|
}
|
|
|
|
type server struct{}
|
|
|
|
// Identify searches in tracks config for entries and returns them.
|
|
// nolint:goerr113
|
|
func (s server) Identify(ctx context.Context, in *api.IdentifyRequest) (*api.IdentifyResponse, error) {
|
|
r := &api.IdentifyResponse{}
|
|
|
|
if in.Id == "" {
|
|
return r, fmt.Errorf("no id in request specified")
|
|
}
|
|
|
|
t, ok := config.Cfg.Tracks[in.Id]
|
|
if !ok {
|
|
return r, fmt.Errorf("could not find track for id: %s", in.Id)
|
|
}
|
|
|
|
r.Name = t.Name
|
|
r.Uris = t.Uris
|
|
|
|
return r, nil
|
|
}
|
|
|
|
func gw(s *grpc.Server, conn string) *runtime.ServeMux {
|
|
ctx := context.Background()
|
|
gopts := []grpc.DialOption{grpc.WithInsecure()}
|
|
|
|
api.RegisterIdentifierServiceServer(s, server{})
|
|
reflection.Register(s)
|
|
|
|
gwmux := runtime.NewServeMux()
|
|
if err := api.RegisterIdentifierServiceHandlerFromEndpoint(ctx, gwmux, conn, gopts); err != nil {
|
|
log.Fatal().Err(err).Msg("could not register grpc endpoint")
|
|
}
|
|
|
|
return gwmux
|
|
}
|
|
|
|
func Run(command *cobra.Command, args []string) {
|
|
// Create host string for serving web.
|
|
lh := fmt.Sprintf("%s:%d", config.Cfg.Box.Hostname, config.Cfg.Box.Port)
|
|
|
|
// Create grpc server.
|
|
grpcServer := grpc.NewServer()
|
|
|
|
// Define http handlers.
|
|
mux := http.NewServeMux()
|
|
mux.Handle("/", logginghandler.Handler(http.HandlerFunc(root)))
|
|
mux.Handle("/log", logginghandler.Handler(http.HandlerFunc(sselog.LogHandler)))
|
|
mux.Handle(
|
|
"/static/",
|
|
logginghandler.Handler(
|
|
http.StripPrefix("/static/", http.FileServer(http.FS(assets.Files))),
|
|
),
|
|
)
|
|
mux.Handle("/metrics", promhttp.Handler())
|
|
mux.Handle("/api/", http.StripPrefix("/api", gw(grpcServer, lh)))
|
|
|
|
// Serving http.
|
|
log.Info().Msgf("serving HTTP on %s...", lh)
|
|
|
|
log.Fatal().Err(
|
|
http.ListenAndServe(
|
|
lh,
|
|
grpcHandlerFunc(
|
|
grpcServer,
|
|
logginghandler.Handler(mux),
|
|
),
|
|
),
|
|
).Msg("goodbye")
|
|
}
|