package httpserver import ( "context" "crypto/tls" "net/http" "github.com/gin-gonic/gin" "github.com/pelletier/go-toml" "github.com/phuslu/log" "go.sebtobie.de/httpserver/auth" "go.sebtobie.de/httpserver/menus" ) // Config that is used to map the toml config to the settings that are used. type Config struct { Addr string TLSconfig *tls.Config Certfile string Keyfile string } // MarshalObject adds the information over the object to the *log.Entry func (c *Config) MarshalObject(e *log.Entry) { e.Str("Address", c.Addr).Bool("TLS", c.TLSconfig != nil).Strs("Cert", []string{c.Certfile, c.Keyfile}) } var _ log.ObjectMarshaler = &Config{} // Server is an wrapper for the *http.Server and *gin.Engine type Server struct { http *http.Server conf *Config mrouter map[string]*gin.Engine config *toml.Tree sites []Site menu []menus.Menu NotFoundHandler http.Handler } func init() { gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) { log.Trace().Msgf("%-4s(%02d): %-20s %s", httpMethod, nuHandlers, absolutePath, handlerName) } } // StartServer starts the server as configured and sends the errormessage to the log. func (s *Server) StartServer() { log.Info().Msg("Starting server") var err error if s.conf.Certfile != "" && s.conf.Keyfile != "" { err = s.http.ListenAndServeTLS(s.conf.Certfile, s.conf.Keyfile) } else { err = s.http.ListenAndServe() } if err != http.ErrServerClosed { log.Error().Err(err).Msg("Server unexpected exited") } } // 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") } if router, found := s.mrouter[domain]; found { router.NoMethod(gin.WrapH(s.NotFoundHandler)) router.NoRoute(gin.WrapH(s.NotFoundHandler)) router.ServeHTTP(w, r) return } var entrys []string for d := range s.mrouter { entrys = append(entrys, d) } log.Trace().Strs("reqistred domains", entrys).Msg("domain not found") s.NotFoundHandler.ServeHTTP(w, r) } // CreateServer creates an server that can be run in a coroutine. func CreateServer(config *toml.Tree) *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{ Addr: "127.0.0.1:8080", }, mrouter: map[string]*gin.Engine{}, } if err := config.Unmarshal(server.conf); err != nil { log.Error().Msg("Problem mapping config to Configstruct") } log.Debug().EmbedObject(server.conf).Msg("Config") server.http = &http.Server{ Addr: server.conf.Addr, ErrorLog: log.DefaultLogger.Std(log.ErrorLevel, log.Context{}, "", 0), Handler: http.HandlerFunc(server.DomainRouter), TLSConfig: server.conf.TLSconfig, } server.NotFoundHandler = http.NotFoundHandler() server.menu = []menus.Menu{} return server } // 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) { for _, router := range s.mrouter { router.Use(m...) } } // Stop Shuts the Server down func (s *Server) Stop(ctx context.Context) { log.Info().Err(s.http.Shutdown(ctx)).Msg("Server Shut down.") for _, site := range s.sites { site.Teardown() } } // Site is an Interface to abstract the modularized group of pages. // The Middleware must be able to detect multiple calls byy itself. Deduplication is not performed. type Site interface { Init(*gin.RouterGroup) Teardown() } func (s *Server) menus() []menus.Menu { return s.menu } // RegisterSite adds an site to the engine as its own grouo func (s *Server) RegisterSite(domain, path string, site Site) { var router *gin.Engine var found bool if router, found = s.mrouter[domain]; !found { var authhf auth.AuthenticationHandler router = gin.New() mw := []gin.HandlerFunc{ func(c *gin.Context) { c.Set(Menus, s.menus) c.Set(Domain, domain) }, } if authhf, found = site.(auth.AuthenticationHandler); !found { authhf = &auth.AnonAccountHandler{} } mw = append(mw, func(c *gin.Context) { authhf.Account(c) }) router.Use(mw...) s.mrouter[domain] = router } site.Init(router.Group(path)) s.sites = append(s.sites, site) if ms, ok := site.(menus.MenuSite); ok { menus := ms.Menu(domain) log.Debug().Msgf("%d menus are added", len(menus)) s.menu = append(s.menu, menus...) } return }