initial app
This commit is contained in:
Arnie
@@ -0,0 +1,113 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
"go.uber.org/zap/zapcore"
|
||||
|
||||
"go.c3c.cz/cv/app/server/internal/version"
|
||||
)
|
||||
|
||||
type FrontendConfigDef struct {
|
||||
CommitTime string `json:"commitTime"`
|
||||
ContactEmail string `json:"contactEmail"`
|
||||
ContactPhone string `json:"contactPhone"`
|
||||
Position string `json:"position"`
|
||||
}
|
||||
|
||||
var (
|
||||
BindAddrPprof = confString("BIND_ADDR_PPROF", "localhost:6060", false)
|
||||
BindAddrHttp = confString("BIND_ADDR_HTTP", ":8080", false)
|
||||
|
||||
GraceTerminationDelay = confDuration("GRACE_TERMINATION_DELAY", 0)
|
||||
GraceTerminationLimit = confDuration("GRACE_TERMINATION_LIMIT", 10*time.Second)
|
||||
|
||||
LoggerConfig *zap.Config
|
||||
loggingLevel = confString("LOGGING_LEVEL", "info", false)
|
||||
|
||||
Frontend string
|
||||
)
|
||||
|
||||
func init() {
|
||||
b, err := json.Marshal(FrontendConfigDef{
|
||||
CommitTime: version.CommitTime.Format(time.RFC3339),
|
||||
ContactEmail: confString("CONTACT_EMAIL", "", true),
|
||||
ContactPhone: confString("CONTACT_PHONE", "", true),
|
||||
Position: confString("POSITION", "", true),
|
||||
})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
Frontend = string(b)
|
||||
|
||||
zapConfig := confString("LOGGER_CONFIG", "", false)
|
||||
|
||||
var l zapcore.Level
|
||||
if err := l.UnmarshalText([]byte(loggingLevel)); err != nil {
|
||||
log.Fatal(fmt.Errorf("could not create debug level from env: %w", err))
|
||||
}
|
||||
|
||||
if zapConfig != "" {
|
||||
if err := json.Unmarshal([]byte(zapConfig), &LoggerConfig); err != nil {
|
||||
log.Fatal(fmt.Errorf("could not create logging configuration from env: %w", err))
|
||||
}
|
||||
|
||||
// Warn if both logger config and logging level are specified
|
||||
_, loggingLevelPresent := os.LookupEnv("LOGGING_LEVEL")
|
||||
if loggingLevelPresent {
|
||||
log.Println("cannot have both LOGGING_CONFIG and LOGGING_LEVEL environment configuration values")
|
||||
LoggerConfig.Level = zap.NewAtomicLevelAt(l)
|
||||
}
|
||||
} else {
|
||||
loggerConfig := zap.NewProductionConfig()
|
||||
encoderConfig := zap.NewProductionEncoderConfig()
|
||||
encoderConfig.TimeKey = "t"
|
||||
encoderConfig.LevelKey = "l"
|
||||
encoderConfig.CallerKey = "c"
|
||||
encoderConfig.MessageKey = "m"
|
||||
encoderConfig.StacktraceKey = "s"
|
||||
encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
|
||||
encoderConfig.EncodeTime = zapcore.RFC3339NanoTimeEncoder
|
||||
encoderConfig.EncodeDuration = zapcore.MillisDurationEncoder
|
||||
encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
|
||||
|
||||
loggerConfig.EncoderConfig = encoderConfig
|
||||
loggerConfig.Level = zap.NewAtomicLevelAt(l)
|
||||
loggerConfig.Encoding = "json"
|
||||
|
||||
LoggerConfig = &loggerConfig
|
||||
}
|
||||
}
|
||||
|
||||
const requiredErrorF = `required variable "%s" not set`
|
||||
|
||||
func confString(name string, defaultValue string, required bool) string {
|
||||
val, present := os.LookupEnv(name)
|
||||
if !present {
|
||||
if required {
|
||||
log.Fatalf(requiredErrorF, name)
|
||||
}
|
||||
|
||||
val = defaultValue
|
||||
}
|
||||
return val
|
||||
}
|
||||
|
||||
func confDuration(name string, defaultValue time.Duration) (val time.Duration) {
|
||||
sVal, present := os.LookupEnv(name)
|
||||
if !present {
|
||||
val = defaultValue
|
||||
} else {
|
||||
var err error
|
||||
val, err = time.ParseDuration(sVal)
|
||||
if err != nil {
|
||||
log.Fatalf(`cannot parse duration variable "%s"`, name)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package files
|
||||
|
||||
import (
|
||||
"embed"
|
||||
)
|
||||
|
||||
//go:embed data/public/*
|
||||
var Public embed.FS
|
||||
@@ -0,0 +1,121 @@
|
||||
package httpserver
|
||||
|
||||
import (
|
||||
"compress/gzip"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"html/template"
|
||||
"io"
|
||||
"io/fs"
|
||||
"mime"
|
||||
"net/http"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
|
||||
"go.c3c.cz/cv/app/server/internal/files"
|
||||
"go.c3c.cz/cv/app/server/internal/version"
|
||||
)
|
||||
|
||||
type handler struct {
|
||||
indexTemplate *template.Template
|
||||
logger *zap.Logger
|
||||
frontendConfig string
|
||||
}
|
||||
|
||||
func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
f, err := files.Public.Open(path.Join("data", "public", r.URL.Path))
|
||||
if err != nil {
|
||||
h.serveIndex(w)
|
||||
return
|
||||
}
|
||||
|
||||
fi, err := f.Stat()
|
||||
if err != nil || fi.IsDir() {
|
||||
h.serveIndex(w)
|
||||
return
|
||||
}
|
||||
|
||||
h.serveFile(w, r, version.CommitTime, f)
|
||||
}
|
||||
|
||||
func (h *handler) serveFile(w http.ResponseWriter, r *http.Request, modtime time.Time, f fs.File) {
|
||||
if !modtime.IsZero() {
|
||||
ims := r.Header.Get("If-Modified-Since")
|
||||
modtime = modtime.Truncate(time.Second)
|
||||
if t, err := http.ParseTime(ims); err == nil && !modtime.After(t) {
|
||||
w.WriteHeader(http.StatusNotModified)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat))
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", mime.TypeByExtension(filepath.Ext(r.URL.Path)))
|
||||
|
||||
if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
|
||||
w.Header().Set("Content-Encoding", "gzip")
|
||||
gw, err := gzip.NewWriterLevel(w, gzip.DefaultCompression)
|
||||
if err != nil {
|
||||
h.logger.Warn("Could not create gzip writer", zap.Error(err))
|
||||
return
|
||||
}
|
||||
if n, _ := io.Copy(gw, f); n == 0 {
|
||||
w.Header().Del("Content-Encoding")
|
||||
gw.Reset(io.Discard)
|
||||
}
|
||||
err = gw.Close()
|
||||
|
||||
if err != nil {
|
||||
h.logger.Warn("Could not close gzip writer", zap.Error(err))
|
||||
return
|
||||
}
|
||||
} else {
|
||||
_, err := io.Copy(w, f)
|
||||
if err != nil {
|
||||
h.logger.Warn("Could not write file response", zap.Error(err))
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type indexData struct {
|
||||
Config string
|
||||
CspNonce string
|
||||
}
|
||||
|
||||
func (h *handler) serveIndex(w http.ResponseWriter) {
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
|
||||
if h.indexTemplate == nil {
|
||||
_, _ = w.Write([]byte("no index"))
|
||||
return
|
||||
}
|
||||
|
||||
token := make([]byte, 12)
|
||||
_, err := rand.Read(token)
|
||||
if err != nil {
|
||||
h.logger.Warn("Could not create random csp token", zap.Error(err))
|
||||
return
|
||||
}
|
||||
|
||||
data := indexData{
|
||||
Config: h.frontendConfig,
|
||||
CspNonce: base64.RawStdEncoding.EncodeToString(token),
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Security-Policy", "script-src 'self' 'nonce-"+data.CspNonce+"' 'unsafe-eval'")
|
||||
w.Header().Set("X-Frame-Options", "DENY")
|
||||
w.Header().Set("X-XSS-Protection", "1; mode=block")
|
||||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||||
w.Header().Set("Referrer-Policy", "same-origin")
|
||||
w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
|
||||
w.Header().Set("Permissions-Policy", "accelerometer=(), camera=(), geolocation=(), microphone=(), payment=(), usb=()")
|
||||
|
||||
err = h.indexTemplate.Execute(w, data)
|
||||
if err != nil {
|
||||
h.logger.Warn("Could not execute index template", zap.Error(err))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package httpserver
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"html/template"
|
||||
"io"
|
||||
"log"
|
||||
"mime"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
|
||||
"go.c3c.cz/cv/app/server/internal/files"
|
||||
)
|
||||
|
||||
func init() {
|
||||
err := mime.AddExtensionType(".ico", "image/x-icon")
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
err = mime.AddExtensionType(".json", "application/json; charset=utf-8")
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
type Options struct {
|
||||
Logger *zap.Logger
|
||||
BindAddr string
|
||||
FrontendConfig string
|
||||
RequireIndex bool
|
||||
}
|
||||
|
||||
type server struct{ http.Server }
|
||||
|
||||
func New(options *Options) (*server, error) {
|
||||
handler := &handler{
|
||||
frontendConfig: options.FrontendConfig,
|
||||
logger: options.Logger,
|
||||
}
|
||||
|
||||
httpSrv := &server{
|
||||
http.Server{
|
||||
Addr: options.BindAddr,
|
||||
Handler: handler,
|
||||
},
|
||||
}
|
||||
|
||||
index, err := files.Public.Open("data/public/index.html")
|
||||
if err != nil {
|
||||
if !options.RequireIndex {
|
||||
return httpSrv, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("could not open index.html: %w", err)
|
||||
}
|
||||
|
||||
fi, err := index.Stat()
|
||||
if err != nil || fi.IsDir() {
|
||||
if !options.RequireIndex {
|
||||
return httpSrv, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("invalid index.html: %w", err)
|
||||
}
|
||||
|
||||
tb, err := io.ReadAll(index)
|
||||
if err != nil {
|
||||
if !options.RequireIndex {
|
||||
return httpSrv, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("could not read index.html: %w", err)
|
||||
}
|
||||
|
||||
handler.indexTemplate, err = template.New("index").Parse(string(tb))
|
||||
if err != nil {
|
||||
if !options.RequireIndex {
|
||||
return httpSrv, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("could not parse index.html: index.html: %w", err)
|
||||
}
|
||||
|
||||
return httpSrv, nil
|
||||
}
|
||||
|
||||
func (s *server) ShutdownWithDelay(delay time.Duration, limit time.Duration) {
|
||||
h, ok := s.Handler.(*handler)
|
||||
|
||||
var logger *zap.Logger
|
||||
if ok {
|
||||
logger = h.logger
|
||||
} else {
|
||||
logger = zap.L()
|
||||
}
|
||||
|
||||
if delay > 0 {
|
||||
logger.Info(fmt.Sprintf("Waiting %s for incoming requests\n", delay))
|
||||
time.Sleep(delay)
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), limit)
|
||||
defer cancel()
|
||||
|
||||
logger.Info("Gracefully shutting down http server")
|
||||
if err := s.Shutdown(ctx); err != nil {
|
||||
logger.Error("Failed to shutdown http server", zap.Error(err))
|
||||
} else {
|
||||
logger.Info("Http server was stopped")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package pprofserver
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type Options struct {
|
||||
BindAddr string
|
||||
LogLevelHandler http.Handler
|
||||
Logger *zap.Logger
|
||||
}
|
||||
|
||||
type server struct {
|
||||
addr string
|
||||
logger *zap.Logger
|
||||
ready bool
|
||||
}
|
||||
|
||||
func New(options Options) *server {
|
||||
s := &server{
|
||||
addr: options.BindAddr,
|
||||
logger: options.Logger,
|
||||
}
|
||||
|
||||
http.Handle("/log/level", options.LogLevelHandler)
|
||||
http.HandleFunc("/readyz", s.handleReady)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *server) ListenAndServe() error {
|
||||
return http.ListenAndServe(s.addr, nil)
|
||||
}
|
||||
|
||||
func (s *server) handleReady(w http.ResponseWriter, _ *http.Request) {
|
||||
s.logger.Debug("Handling healthcheck request", zap.Bool("ready", s.ready))
|
||||
|
||||
if s.ready {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusServiceUnavailable)
|
||||
_, err := w.Write([]byte("shutting down"))
|
||||
if err != nil {
|
||||
s.logger.Error("Could not write ready response", zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
func (s *server) SetReady() {
|
||||
s.ready = true
|
||||
}
|
||||
|
||||
func (s *server) SetNotReady() {
|
||||
s.ready = false
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package version
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
JSON []byte
|
||||
|
||||
Commit string
|
||||
CommitTime time.Time
|
||||
Tag string
|
||||
|
||||
commitTime string
|
||||
repoUrl string
|
||||
)
|
||||
|
||||
func init() {
|
||||
t, _ := time.Parse(time.RFC3339, commitTime)
|
||||
CommitTime = t.In(time.UTC)
|
||||
|
||||
type v struct {
|
||||
Source string `json:"source,omitempty"`
|
||||
Version string `json:"version,omitempty"`
|
||||
Commit string `json:"commit,omitempty"`
|
||||
CommitTime time.Time `json:"commitTime,omitempty"`
|
||||
}
|
||||
|
||||
JSON, _ = json.Marshal(v{
|
||||
Source: repoUrl,
|
||||
Version: Tag,
|
||||
Commit: Commit,
|
||||
CommitTime: CommitTime,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
_ "net/http/pprof"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
|
||||
"go.uber.org/zap"
|
||||
|
||||
"go.c3c.cz/cv/app/server/internal/config"
|
||||
"go.c3c.cz/cv/app/server/internal/httpserver"
|
||||
"go.c3c.cz/cv/app/server/internal/pprofserver"
|
||||
"go.c3c.cz/cv/app/server/internal/version"
|
||||
)
|
||||
|
||||
func main() {
|
||||
defer handleExit()
|
||||
|
||||
notice := "Starting version "
|
||||
if version.Tag != "" {
|
||||
notice += version.Tag
|
||||
} else {
|
||||
notice += "latest"
|
||||
}
|
||||
if version.Commit != "" {
|
||||
notice = fmt.Sprintf("%s (%s)", notice, version.Commit)
|
||||
}
|
||||
|
||||
var logger *zap.Logger
|
||||
var err error
|
||||
|
||||
logger, err = config.LoggerConfig.Build()
|
||||
|
||||
if err != nil {
|
||||
fmt.Println(notice)
|
||||
fmt.Println(version.CommitTime.Format("Committed at 2006/01/02 15:04:05 MST"))
|
||||
|
||||
panic(Exit{fmt.Errorf("logger creation failed")})
|
||||
}
|
||||
|
||||
logger.Info(
|
||||
"App initializing",
|
||||
zap.String("version", version.Tag),
|
||||
zap.String("commit", version.Commit),
|
||||
zap.Time("commitTime", version.CommitTime),
|
||||
)
|
||||
|
||||
defer func() {
|
||||
_ = logger.Sync()
|
||||
}()
|
||||
|
||||
httpSrv, err := httpserver.New(&httpserver.Options{
|
||||
BindAddr: config.BindAddrHttp,
|
||||
FrontendConfig: config.Frontend,
|
||||
Logger: logger,
|
||||
})
|
||||
if err != nil {
|
||||
logger.Error("HTTP server creation failed", zap.Error(err))
|
||||
panic(Exit{err})
|
||||
}
|
||||
|
||||
quit := struct {
|
||||
os chan os.Signal
|
||||
pprof chan error
|
||||
http chan error
|
||||
}{
|
||||
os: make(chan os.Signal, 1),
|
||||
pprof: make(chan error, 1),
|
||||
http: make(chan error, 1),
|
||||
}
|
||||
|
||||
pprofSrv := pprofserver.New(pprofserver.Options{
|
||||
BindAddr: config.BindAddrPprof,
|
||||
Logger: logger,
|
||||
LogLevelHandler: config.LoggerConfig.Level,
|
||||
})
|
||||
|
||||
// Pprof server.
|
||||
go func() {
|
||||
logger.Info("debug server was started", zap.String("BindAddr", config.BindAddrPprof))
|
||||
quit.pprof <- pprofSrv.ListenAndServe()
|
||||
}()
|
||||
|
||||
go func() {
|
||||
logger.Info("http server was started", zap.String("BindAddr", config.BindAddrHttp))
|
||||
pprofSrv.SetReady()
|
||||
err := httpSrv.ListenAndServe()
|
||||
if err != http.ErrServerClosed {
|
||||
quit.http <- err
|
||||
}
|
||||
}()
|
||||
|
||||
logger.Info("application started")
|
||||
|
||||
signal.Notify(quit.os, os.Interrupt, syscall.SIGTERM)
|
||||
|
||||
select {
|
||||
case s := <-quit.os:
|
||||
sig, _ := s.(syscall.Signal)
|
||||
logger.Info("Signal received\n", zap.Int("signal", int(sig)))
|
||||
pprofSrv.SetNotReady()
|
||||
httpSrv.ShutdownWithDelay(config.GraceTerminationDelay, config.GraceTerminationLimit)
|
||||
case err := <-quit.pprof:
|
||||
logger.Error("app shutdown was triggered by a pprof server error", zap.Error(err))
|
||||
httpSrv.ShutdownWithDelay(config.GraceTerminationDelay, config.GraceTerminationLimit)
|
||||
case err := <-quit.http:
|
||||
logger.Error("app shutdown was triggered by an http server error", zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
type Exit struct {
|
||||
err error
|
||||
}
|
||||
|
||||
func handleExit() {
|
||||
if e := recover(); e != nil {
|
||||
if exit, ok := e.(Exit); ok {
|
||||
fmt.Println(exit.err)
|
||||
os.Exit(1)
|
||||
}
|
||||
panic(e)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user