mirror of
https://github.com/steveiliop56/tinyauth.git
synced 2025-11-04 08:05:42 +00:00
131 lines
3.4 KiB
Go
131 lines
3.4 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"io/fs"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
"tinyauth/internal/assets"
|
|
"tinyauth/internal/handlers"
|
|
"tinyauth/internal/types"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/rs/zerolog/log"
|
|
)
|
|
|
|
type Server struct {
|
|
Config types.ServerConfig
|
|
Handlers *handlers.Handlers
|
|
Router *gin.Engine
|
|
}
|
|
|
|
var (
|
|
loggerSkipPathsPrefix = []string{
|
|
"GET /api/healthcheck",
|
|
"HEAD /api/healthcheck",
|
|
"GET /favicon.ico",
|
|
}
|
|
)
|
|
|
|
func logPath(path string) bool {
|
|
for _, prefix := range loggerSkipPathsPrefix {
|
|
if strings.HasPrefix(path, prefix) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func NewServer(config types.ServerConfig, handlers *handlers.Handlers) (*Server, error) {
|
|
gin.SetMode(gin.ReleaseMode)
|
|
|
|
log.Debug().Msg("Setting up router")
|
|
router := gin.New()
|
|
router.Use(zerolog())
|
|
|
|
log.Debug().Msg("Setting up assets")
|
|
dist, err := fs.Sub(assets.Assets, "dist")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
log.Debug().Msg("Setting up file server")
|
|
fileServer := http.FileServer(http.FS(dist))
|
|
|
|
// UI middleware
|
|
router.Use(func(c *gin.Context) {
|
|
// If not an API request, serve the UI
|
|
if !strings.HasPrefix(c.Request.URL.Path, "/api") {
|
|
_, err := fs.Stat(dist, strings.TrimPrefix(c.Request.URL.Path, "/"))
|
|
if os.IsNotExist(err) {
|
|
c.Request.URL.Path = "/"
|
|
}
|
|
fileServer.ServeHTTP(c.Writer, c.Request)
|
|
c.Abort()
|
|
}
|
|
})
|
|
|
|
// Proxy routes
|
|
router.GET("/api/auth/:proxy", handlers.ProxyHandler)
|
|
|
|
// Auth routes
|
|
router.POST("/api/login", handlers.LoginHandler)
|
|
router.POST("/api/totp", handlers.TOTPHandler)
|
|
router.POST("/api/logout", handlers.LogoutHandler)
|
|
|
|
// Context routes
|
|
router.GET("/api/app", handlers.AppContextHandler)
|
|
router.GET("/api/user", handlers.UserContextHandler)
|
|
|
|
// OAuth routes
|
|
router.GET("/api/oauth/url/:provider", handlers.OAuthURLHandler)
|
|
router.GET("/api/oauth/callback/:provider", handlers.OAuthCallbackHandler)
|
|
|
|
// App routes
|
|
router.GET("/api/healthcheck", handlers.HealthcheckHandler)
|
|
router.HEAD("/api/healthcheck", handlers.HealthcheckHandler)
|
|
|
|
return &Server{
|
|
Config: config,
|
|
Handlers: handlers,
|
|
Router: router,
|
|
}, nil
|
|
}
|
|
|
|
func (s *Server) Start() error {
|
|
log.Info().Str("address", s.Config.Address).Int("port", s.Config.Port).Msg("Starting server")
|
|
return s.Router.Run(fmt.Sprintf("%s:%d", s.Config.Address, s.Config.Port))
|
|
}
|
|
|
|
// zerolog is a middleware for gin that logs requests using zerolog
|
|
func zerolog() gin.HandlerFunc {
|
|
return func(c *gin.Context) {
|
|
tStart := time.Now()
|
|
|
|
c.Next()
|
|
|
|
code := c.Writer.Status()
|
|
address := c.Request.RemoteAddr
|
|
method := c.Request.Method
|
|
path := c.Request.URL.Path
|
|
|
|
latency := time.Since(tStart).String()
|
|
|
|
// logPath check if the path should be logged normally or with debug
|
|
if logPath(method + " " + path) {
|
|
switch {
|
|
case code >= 200 && code < 300:
|
|
log.Info().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
|
|
case code >= 300 && code < 400:
|
|
log.Warn().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
|
|
case code >= 400:
|
|
log.Error().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
|
|
}
|
|
} else {
|
|
log.Debug().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
|
|
}
|
|
}
|
|
}
|