1
0
Fork 0
httpserver/http.go

255 Zeilen
7.2 KiB
Go

2021-01-09 20:39:05 +00:00
package httpserver
import (
"context"
2021-01-09 20:39:05 +00:00
"crypto/tls"
"net"
2021-01-09 20:39:05 +00:00
"net/http"
"sync"
2021-01-09 20:39:05 +00:00
"github.com/flosch/pongo2/v4"
2021-01-09 20:39:05 +00:00
"github.com/gin-gonic/gin"
"github.com/phuslu/log"
"go.sebtobie.de/httpserver/auth"
"go.sebtobie.de/httpserver/funcs"
"go.sebtobie.de/httpserver/menus"
"go.sebtobie.de/httpserver/templates"
2021-01-09 20:39:05 +00:00
)
func init() {
gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
log.Debug().Msgf("%-4s(%02d): %-20s %s", httpMethod, nuHandlers, absolutePath, handlerName)
}
gin.SetMode(gin.DebugMode)
}
2021-01-09 20:39:05 +00:00
// Config that is used to map the toml config to the settings that are used.
type Config struct {
Addr []string
TLSAddr []string
TLSconfig *tls.Config `toml:"-"`
2021-01-09 20:39:05 +00:00
Certfile string
Keyfile string
Sites map[string]SiteConfig
2021-01-09 20:39:05 +00:00
}
/**
// MarshalObject adds the information over the object to the *log.Entry
func (c *Config) MarshalObject(e *log.Entry) {
e.Strs("Address", c.Addr).Bool("TLS", c.TLSconfig != nil)
if c.TLSconfig != nil {
e.Str("Certfile", c.Certfile)
e.Str("Keyfile", c.Keyfile)
}
e.Int("sites", len(c.Sites))
2021-01-09 20:39:05 +00:00
}
var _ log.ObjectMarshaler = &Config{}
/**/
2021-01-09 20:39:05 +00:00
// Server is an wrapper for the *http.Server and *gin.Engine
type Server struct {
2021-11-06 19:59:56 +00:00
http *http.Server
Conf *Config
mrouter map[string]*gin.Engine
sites map[string]Site
menu []menus.Menu
template *pongo2.TemplateSet
NotFoundHandler http.Handler
routines sync.WaitGroup
2021-11-06 19:59:56 +00:00
setup bool
authh auth.AuthenticationHandler
middleware gin.HandlersChain
}
// CreateServer creates an server that can be run in a coroutine.
func CreateServer() *Server {
log.Info().Msg("Redirect logging output to phuslu/log")
gin.DefaultErrorWriter = log.DefaultLogger.Std(log.ErrorLevel, log.Context{}, "GIN", 0).Writer()
gin.DefaultWriter = log.DefaultLogger.Std(log.DebugLevel, log.Context{}, "GIN", 0).Writer()
log.Info().Msg("Creating HTTP-Server")
var server = &Server{
Conf: &Config{
TLSconfig: &tls.Config{},
Sites: map[string]SiteConfig{},
},
2021-11-06 19:59:56 +00:00
mrouter: map[string]*gin.Engine{},
authh: &auth.AnonAccountHandler{},
menu: []menus.Menu{},
NotFoundHandler: http.NotFoundHandler(),
sites: map[string]Site{},
middleware: gin.HandlersChain{},
template: pongo2.NewSet("templates", &templates.EmptyLoader{}),
}
server.http = &http.Server{
ErrorLog: log.DefaultLogger.Std(log.ErrorLevel, log.Context{}, "", 0),
Handler: http.HandlerFunc(server.DomainRouter),
}
return server
2021-01-09 20:39:05 +00:00
}
// runPort runs a listener on the port. his enables th server to serve more than a address.
func (s *Server) runPort(address string, tls bool) {
defer s.routines.Done()
var socket net.Listener
var err error
var unix string
if funcs.IsTCP(address) {
socket, err = net.Listen("tcp", address)
}
if funcs.IsUnix(address) {
unix = "Unix-"
socket, err = net.Listen("unix", address)
}
if err != nil {
log.Error().Err(err).Msgf("failed to open socket on %s", address)
return
}
if socket == nil {
log.Error().Msg("Failed to identify the sockettype")
return
}
if tls {
log.Info().Msgf("starting listen on secure %ssocket %s", unix, address)
err = s.http.ServeTLS(socket, s.Conf.Certfile, s.Conf.Keyfile)
} else {
log.Info().Msgf("starting listen on %ssocket %s", unix, address)
err = s.http.Serve(socket)
}
if err != http.ErrServerClosed {
log.Error().Err(err).Msg("Socket unexpected exited")
}
}
2021-11-06 19:59:56 +00:00
// SetAuthentication sets the handler that is responsible for authentication
func (s *Server) SetAuthentication(a auth.AuthenticationHandler) {
s.authh = a
}
2021-01-09 20:39:05 +00:00
// StartServer starts the server as configured and sends the errormessage to the log.
// it blocks until all ports are closed.
2021-01-09 20:39:05 +00:00
func (s *Server) StartServer() {
2021-11-06 19:59:56 +00:00
if !s.setup {
log.Error().Msg("Server not set up")
return
}
2021-01-09 20:39:05 +00:00
log.Info().Msg("Starting server")
s.http.TLSConfig = s.Conf.TLSconfig
if s.Conf.Certfile != "" && s.Conf.Keyfile != "" {
for _, addr := range s.Conf.TLSAddr {
s.routines.Add(1)
go s.runPort(addr, true)
}
}
for _, addr := range s.Conf.Addr {
s.routines.Add(1)
go s.runPort(addr, false)
2021-01-09 20:39:05 +00:00
}
s.routines.Wait()
2021-01-09 20:39:05 +00:00
}
2021-01-23 10:14:33 +00:00
// DomainRouter redirects the requests to the routers of the domains
func (s *Server) DomainRouter(w http.ResponseWriter, r *http.Request) {
var domain string
if r.URL.Host != "" {
domain = r.URL.Host
} else if r.Host != "" {
domain = r.Host
} else if r.Header.Get("X-Original-Host") != "" {
domain = r.Header.Get("X-Original-Host")
}
r.Host = domain
r.URL.Host = domain
for header, value := range map[string][]string(r.Header) {
log.Trace().Strs(header, value).Msg("Headers")
}
2021-01-23 10:14:33 +00:00
if router, found := s.mrouter[domain]; found {
router.NoMethod(gin.WrapH(s.NotFoundHandler))
router.NoRoute(gin.WrapH(s.NotFoundHandler))
router.ServeHTTP(w, r)
2021-01-23 10:14:33 +00:00
return
}
log.Error().Msgf("Failed to find domain for %s", domain)
var entrys []string
for d := range s.mrouter {
entrys = append(entrys, d)
}
log.Trace().Strs("registred domains", entrys).Msg("domain not found")
s.NotFoundHandler.ServeHTTP(w, r)
2021-01-23 10:14:33 +00:00
}
2021-01-09 20:39:05 +00:00
// Use installs the middleware into the router.
// The Middleware must be able to detect multiple calls byy itself. Deduplication is not performed.
func (s *Server) Use(m ...gin.HandlerFunc) {
s.middleware = append(s.middleware, m...)
for _, site := range s.mrouter {
site.Use(m...)
}
2021-01-09 20:39:05 +00:00
}
// Stop Shuts the Server down
func (s *Server) Stop(ctx context.Context) {
2021-01-12 18:29:25 +00:00
log.Info().Err(s.http.Shutdown(ctx)).Msg("Server Shut down.")
for _, s := range s.sites {
2021-11-06 19:59:56 +00:00
s.Teardown()
}
}
func (s *Server) menus() []menus.Menu {
return s.menu
}
// Setup sets the server up. It loads the sites and prepare the server for startup.
2021-11-06 19:59:56 +00:00
// The sites get their config in this step.
func (s *Server) Setup() {
log.Info().Msg("Perparing server for start")
2021-01-23 10:14:33 +00:00
var router *gin.Engine
var found bool
2021-11-06 19:59:56 +00:00
for cfg, site := range s.sites {
config := s.Conf.Sites[cfg]
if router, found = s.mrouter[config["domain"].(string)]; !found {
log.Info().Msgf("Setting up router for %s", config["domain"].(string))
2021-11-06 19:59:56 +00:00
router = gin.New()
router.Use(func(c *gin.Context) {
c.Set(Domain, config["domain"])
c.Set(Menus, s.menus)
c.Set(Accounts, s.authh.Account(c))
})
router.Use(s.middleware...)
router.HTMLRender = templates.NewPongo2Renderer(s.template)
s.mrouter[config["domain"].(string)] = router
}
group := router.Group(config["path"].(string))
site.Init(group)
2021-11-06 19:59:56 +00:00
if ms, ok := site.(menus.MenuSite); ok {
menus := ms.Menu(config["domain"].(string))
2021-11-06 19:59:56 +00:00
log.Debug().Msgf("%d menus are added", len(menus))
s.menu = append(s.menu, menus...)
}
2021-11-06 19:59:56 +00:00
if ts, ok := site.(templates.TemplateSite); ok {
templates := ts.Templates()
if templates == nil {
log.Error().Msgf("Site %s had an empty templateloader", cfg)
}
s.template.AddLoader(templates)
2021-11-06 19:59:56 +00:00
}
site.Setup(config)
2021-11-06 19:59:56 +00:00
}
s.setup = true
}
// RegisterSite adds an site to the engine as its own grouo
// it registers the defaults so that the application can load/dump it from/into an configfile or commandline options
func (s *Server) RegisterSite(cfg string, site Site) {
var config = site.Defaults()
if _, found := config["domain"]; !found {
config["domain"] = ""
}
if _, found := config["path"]; !found {
config["path"] = ""
}
2021-11-06 19:59:56 +00:00
s.Conf.Sites[cfg] = config
s.sites[cfg] = site
2021-01-09 20:39:05 +00:00
}