aboutsummaryrefslogtreecommitdiff
path: root/pkg/ext
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/ext')
-rw-r--r--pkg/ext/fileserver.go33
-rw-r--r--pkg/ext/middleware.go74
-rw-r--r--pkg/ext/responses.go30
-rw-r--r--pkg/ext/router.go45
4 files changed, 65 insertions, 117 deletions
diff --git a/pkg/ext/fileserver.go b/pkg/ext/fileserver.go
deleted file mode 100644
index 87c1ae8..0000000
--- a/pkg/ext/fileserver.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package ext
-
-import (
- "io/fs"
- "mime"
- "path/filepath"
-
- "github.com/valyala/fasthttp"
-)
-
-type FileSystem interface {
- Open(name string) (fs.File, error)
-}
-
-// This is a VERY simple file server. It does not take a lot into consideration
-// and it should only be used to return small predictable files, like in the
-// static folder.
-func FileServer(rootFS FileSystem) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
- path := ctx.UserValue("filepath").(string)
-
- f, err := rootFS.Open(path)
- if err != nil {
- InternalServerError(ctx, err)
- return
- }
- defer f.Close()
-
- m := mime.TypeByExtension(filepath.Ext(path))
- ctx.SetContentType(m)
- ctx.SetBodyStream(f, -1)
- }
-}
diff --git a/pkg/ext/middleware.go b/pkg/ext/middleware.go
index bcc6c5f..fe2d185 100644
--- a/pkg/ext/middleware.go
+++ b/pkg/ext/middleware.go
@@ -1,22 +1,22 @@
package ext
import (
+ "context"
"encoding/base64"
+ "errors"
+ "net/http"
"time"
"github.com/sirupsen/logrus"
- "github.com/valyala/fasthttp"
"git.sr.ht/~gabrielgio/img/pkg/database/repository"
"git.sr.ht/~gabrielgio/img/pkg/service"
)
-func HTML(next fasthttp.RequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
- if len(ctx.Request.Header.ContentType()) > 0 {
- ctx.Response.Header.SetContentType("text/html")
- }
- next(ctx)
+func HTML(next http.HandlerFunc) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/html")
+ next(w, r)
}
}
@@ -30,17 +30,15 @@ func NewLogMiddleare(log *logrus.Entry) *LogMiddleware {
}
}
-func (l *LogMiddleware) HTTP(next fasthttp.RequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
+func (l *LogMiddleware) HTTP(next http.HandlerFunc) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
- next(ctx)
+ next(w, r)
elapsed := time.Since(start)
l.entry.
WithField("time", elapsed).
- WithField("code", ctx.Response.StatusCode()).
- WithField("path", string(ctx.Path())).
- WithField("bytes", len(ctx.Response.Body())).
- Info(string(ctx.Request.Header.Method()))
+ WithField("path", r.URL.Path).
+ Info(r.Method)
}
}
@@ -56,23 +54,23 @@ func NewAuthMiddleware(key []byte, log *logrus.Entry) *AuthMiddleware {
}
}
-func (a *AuthMiddleware) LoggedIn(next fasthttp.RequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
- path := string(ctx.Path())
+func (a *AuthMiddleware) LoggedIn(next http.HandlerFunc) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ path := string(r.URL.Path)
if path == "/login" || path == "/initial" {
- next(ctx)
+ next(w, r)
return
}
redirectLogin := "/login?redirect=" + path
- authBase64 := ctx.Request.Header.Cookie("auth")
- if authBase64 == nil {
+ authBase64, err := r.Cookie("auth")
+ if errors.Is(err, http.ErrNoCookie) {
a.entry.Info("No auth provided")
- ctx.Redirect(redirectLogin, 307)
+ http.Redirect(w, r, redirectLogin, http.StatusTemporaryRedirect)
return
}
- auth, err := base64.StdEncoding.DecodeString(string(authBase64))
+ auth, err := base64.StdEncoding.DecodeString(authBase64.Value)
if err != nil {
a.entry.Error(err)
return
@@ -81,20 +79,20 @@ func (a *AuthMiddleware) LoggedIn(next fasthttp.RequestHandler) fasthttp.Request
token, err := service.ReadToken(auth, a.key)
if err != nil {
a.entry.Error(err)
- ctx.Redirect(redirectLogin, 307)
+ http.Redirect(w, r, redirectLogin, http.StatusTemporaryRedirect)
return
}
- ctx.SetUserValue("token", token)
+ r = r.WithContext(context.WithValue(r.Context(), "token", token))
a.entry.
WithField("userID", token.UserID).
WithField("username", token.Username).
Info("user recognized")
- next(ctx)
+ next(w, r)
}
}
-func GetTokenFromCtx(ctx *fasthttp.RequestCtx) *service.Token {
- tokenValue := ctx.UserValue("token")
+func GetTokenFromCtx(w http.ResponseWriter, r *http.Request) *service.Token {
+ tokenValue := r.Context().Value("token")
if token, ok := tokenValue.(*service.Token); ok {
return token
}
@@ -111,31 +109,31 @@ func NewInitialSetupMiddleware(userRepository repository.UserRepository) *Initia
}
}
-func (i *InitialSetupMiddleware) Check(next fasthttp.RequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
+func (i *InitialSetupMiddleware) Check(next http.HandlerFunc) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
// if user has been set to context it is logged in already
- _, ok := ctx.UserValue("token").(*service.Token)
- if ok {
- next(ctx)
+ token := GetTokenFromCtx(w, r)
+ if token == nil {
+ next(w, r)
return
}
- path := string(ctx.Path())
+ path := r.URL.Path
if path == "/initial" {
- next(ctx)
+ next(w, r)
return
}
- exists, err := i.userRepository.Any(ctx)
+ exists, err := i.userRepository.Any(r.Context())
if err != nil {
- InternalServerError(ctx, err)
+ InternalServerError(w, err)
return
}
if exists {
- next(ctx)
+ next(w, r)
return
}
- ctx.Redirect("/initial", 307)
+ http.Redirect(w, r, "/initial", http.StatusTemporaryRedirect)
}
}
diff --git a/pkg/ext/responses.go b/pkg/ext/responses.go
index dbad5b2..ba58dd5 100644
--- a/pkg/ext/responses.go
+++ b/pkg/ext/responses.go
@@ -1,39 +1,21 @@
package ext
import (
- "bytes"
"fmt"
-
- "github.com/valyala/fasthttp"
+ "net/http"
"git.sr.ht/~gabrielgio/img/templates"
)
-var (
- ContentTypeHTML = []byte("text/html")
-)
-
-func NotFoundHTML(ctx *fasthttp.RequestCtx) {
- templates.WritePageTemplate(ctx, &templates.ErrorPage{
+func NotFound(w http.ResponseWriter, r *http.Request) {
+ templates.WritePageTemplate(w, &templates.ErrorPage{
Err: "Not Found",
})
}
-func NotFound(ctx *fasthttp.RequestCtx) {
- ctx.Response.SetStatusCode(404)
- ct := ctx.Response.Header.ContentType()
- if bytes.Equal(ct, ContentTypeHTML) {
- NotFoundHTML(ctx)
- }
-}
-
-func InternalServerError(ctx *fasthttp.RequestCtx, err error) {
- ctx.Response.SetStatusCode(500)
- templates.WritePageTemplate(ctx, &templates.ErrorPage{
+func InternalServerError(w http.ResponseWriter, err error) {
+ w.WriteHeader(http.StatusInternalServerError)
+ templates.WritePageTemplate(w, &templates.ErrorPage{
Err: fmt.Sprintf("Internal Server Error:\n%s", err.Error()),
})
}
-
-func NoContent(ctx *fasthttp.RequestCtx) {
- ctx.Response.SetStatusCode(204)
-}
diff --git a/pkg/ext/router.go b/pkg/ext/router.go
index 74f0a95..8b9a310 100644
--- a/pkg/ext/router.go
+++ b/pkg/ext/router.go
@@ -1,51 +1,52 @@
package ext
import (
- "github.com/fasthttp/router"
- "github.com/valyala/fasthttp"
+ "net/http"
+
+ "github.com/gorilla/mux"
)
type (
Router struct {
middlewares []Middleware
- fastRouter *router.Router
+ router *mux.Router
}
- Middleware func(next fasthttp.RequestHandler) fasthttp.RequestHandler
- ErrorRequestHandler func(ctx *fasthttp.RequestCtx) error
+ Middleware func(next http.HandlerFunc) http.HandlerFunc
+ ErrorRequestHandler func(w http.ResponseWriter, r *http.Request) error
)
-func NewRouter(nestedRouter *router.Router) *Router {
+func NewRouter(nestedRouter *mux.Router) *Router {
return &Router{
- fastRouter: nestedRouter,
+ router: nestedRouter,
}
}
-func (self *Router) AddMiddleware(middleware Middleware) {
- self.middlewares = append(self.middlewares, middleware)
+func (r *Router) AddMiddleware(middleware Middleware) {
+ r.middlewares = append(r.middlewares, middleware)
}
-func wrapError(next ErrorRequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
- if err := next(ctx); err != nil {
- ctx.Response.SetStatusCode(500)
- InternalServerError(ctx, err)
+func wrapError(next ErrorRequestHandler) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if err := next(w, r); err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ InternalServerError(w, err)
}
}
}
-func (self *Router) run(next ErrorRequestHandler) fasthttp.RequestHandler {
- return func(ctx *fasthttp.RequestCtx) {
+func (r *Router) run(next ErrorRequestHandler) http.HandlerFunc {
+ return func(w http.ResponseWriter, re *http.Request) {
req := wrapError(next)
- for _, r := range self.middlewares {
+ for _, r := range r.middlewares {
req = r(req)
}
- req(ctx)
+ req(w, re)
}
}
-func (self *Router) GET(path string, handler ErrorRequestHandler) {
- self.fastRouter.GET(path, self.run(handler))
+func (r *Router) GET(path string, handler ErrorRequestHandler) {
+ r.router.HandleFunc(path, r.run(handler)).Methods("GET")
}
-func (self *Router) POST(path string, handler ErrorRequestHandler) {
- self.fastRouter.POST(path, self.run(handler))
+func (r *Router) POST(path string, handler ErrorRequestHandler) {
+ r.router.HandleFunc(path, r.run(handler)).Methods("POSt")
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-19 16:31:52 +0000