diff --git a/context.go b/context.go index 60ab4df..e9c2fd6 100644 --- a/context.go +++ b/context.go @@ -1,8 +1,12 @@ package router import ( + "bytes" "encoding/json" + "io" + "net" "net/http" + "strings" "github.com/julienschmidt/httprouter" ) @@ -16,11 +20,29 @@ type Context struct { store map[string]interface{} } -func newContext(router *Router, res http.ResponseWriter, req *http.Request, param httprouter.Params) *Context { +// NewContext creates a new context, this function is only exported for use in tests +func NewContext(router *Router, res http.ResponseWriter, req *http.Request, param httprouter.Params) *Context { return &Context{router, req, res, param.ByName, make(map[string]interface{})} } -// String returns the given status code and writes the bytes to the body +// QueryParam returns the specified parameter from the query string. +// Returns an empty string if it doesn't exist. Returns the first parameter if multiple instances exist +func (c *Context) QueryParam(param string) string { + params := c.Request.URL.Query()[param] + if params == nil { + return `` + } + + return params[0] +} + +// Redirect sends a redirect to the client +func (c *Context) Redirect(code int, url string) error { + http.Redirect(c.Response, c.Request, url, code) + return nil +} + +// Bytes returns the given status code and writes the bytes to the body func (c *Context) Bytes(code int, b []byte) error { c.Response.WriteHeader(code) _, err := c.Response.Write(b) @@ -53,14 +75,22 @@ func (c *Context) JSON(code int, data interface{}) error { return json.NewEncoder(c.Response).Encode(data) // TODO: Encode to buffer first to prevent partial responses on error } +// Render renders a templating using the Renderer set in router func (c *Context) Render(code int, template string, data interface{}) error { if c.router.Renderer == nil { panic(`Cannot call render without a renderer set`) } + var b bytes.Buffer + err := c.router.Renderer.Render(&b, template, data, c) + if err != nil { + return err + } + c.Response.Header().Set(`Content-Type`, `text/html`) c.Response.WriteHeader(code) - return c.router.Renderer.Render(c.Response, template, data, c) + _, _ = io.Copy(c.Response, &b) + return nil } // Set sets a value in the context. Set is not safe to be used concurrently @@ -72,3 +102,20 @@ func (c *Context) Set(key string, value interface{}) { func (c *Context) Get(key string) interface{} { return c.store[key] } + +// RealIP uses proxy headers for the real ip, if none exist the IP of the current connection is returned +func (c *Context) RealIP() string { + reqIP := c.Request.RemoteAddr + + if ip := c.Request.Header.Get(`X-Forwarded-For`); ip != `` { + reqIP = strings.Split(ip, `, `)[0] + } else if ip := c.Request.Header.Get(`X-Real-IP`); ip != `` { + reqIP = ip + } + + ra, _, _ := net.SplitHostPort(reqIP) + if ra != `` { + reqIP = ra + } + return reqIP +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..dc9d16a --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module git.fuyu.moe/Fuyu/router + +go 1.13 + +require github.com/julienschmidt/httprouter v1.3.0 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..096c54e --- /dev/null +++ b/go.sum @@ -0,0 +1,2 @@ +github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U= +github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= diff --git a/router.go b/router.go index 04980c1..754ab42 100644 --- a/router.go +++ b/router.go @@ -1,8 +1,12 @@ package router import ( + "context" + "crypto/tls" + "net" "net/http" "reflect" + "time" "github.com/julienschmidt/httprouter" ) @@ -23,7 +27,7 @@ type ErrorHandle func(*Context, interface{}) // Middleware is a function that runs before your route, it gets the next handler as a parameter type Middleware func(Handle) Handle -// Binder reads input to dst, returns true is successful +// Reader reads input to dst, returns true if successful type Reader func(c *Context, dst interface{}) (bool, error) // Router is the router itself @@ -35,6 +39,8 @@ type Router struct { NotFoundHandler Handle MethodNotAllowedHandler Handle ErrorHandler ErrorHandle + TrimTrailingSlashes bool + server *http.Server } // New returns a new Router @@ -90,14 +96,48 @@ func (r *Router) OPTIONS(path string, handle Handle, middleware ...Middleware) { r.routes = append(r.routes, route{`OPTIONS`, path, handle, middleware}) } +// Serve accepts incoming HTTP connections on the listener +func (r *Router) Serve(l net.Listener) error { + httpr := r.getHttpr() + + r.server = &http.Server{Handler: httpr} + return r.server.Serve(l) +} + // Start starts the web server and binds to the given address func (r *Router) Start(addr string) error { httpr := r.getHttpr() - return http.ListenAndServe(addr, httpr) + r.server = &http.Server{Addr: addr, Handler: httpr} + return r.server.ListenAndServe() } -func (r *Router) getHttpr() *httprouter.Router { +// StartTLS starts a TLS web server using the given key, cert and config and binds to the given address +func (r *Router) StartTLS(addr, certFile, keyFile string, conf *tls.Config) error { + httpr := r.getHttpr() + + r.server = &http.Server{Addr: addr, Handler: httpr, TLSConfig: conf} + return r.server.ListenAndServeTLS(certFile, keyFile) +} + +// Stop stops the web server +func (r *Router) Stop() error { + if r.server == nil { + return nil + } + + ctx, cancel := context.WithTimeout(context.Background(), time.Second*5) + defer cancel() + err := r.server.Shutdown(ctx) + if err == context.DeadlineExceeded { + err = r.server.Close() + } + r.server = nil + + return err +} + +func (r *Router) getHttpr() http.Handler { httpr := httprouter.New() for _, v := range r.routes { @@ -106,7 +146,11 @@ func (r *Router) getHttpr() *httprouter.Router { handle = handlePOST(r, v.Handle) } - httpr.Handle(v.Method, v.Path, handleReq(r, handle, append(r.middleware, v.Middleware...))) + middleware := make([]Middleware, len(r.middleware)+len(v.Middleware)) + copy(middleware, r.middleware) + copy(middleware[len(r.middleware):], v.Middleware) + + httpr.Handle(v.Method, v.Path, handleReq(r, handle, middleware)) } httpr.NotFound = http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) { @@ -118,18 +162,23 @@ func (r *Router) getHttpr() *httprouter.Router { }) httpr.PanicHandler = func(res http.ResponseWriter, req *http.Request, err interface{}) { - c := newContext(r, res, req, nil) + c := NewContext(r, res, req, nil) r.ErrorHandler(c, err) } - return httpr -} + if r.TrimTrailingSlashes { + httpr.RedirectTrailingSlash = false -func handleErr(errHandler ErrorHandle, err interface{}) Handle { - return func(c *Context) error { - errHandler(c, err) - return nil + return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + l := len(req.URL.Path) + if l > 1 && req.URL.Path[l-1] == '/' { + req.URL.Path = req.URL.Path[:l-1] + } + httpr.ServeHTTP(w, req) + }) } + + return httpr } func checkInterfaceHandle(f interface{}) { @@ -154,8 +203,6 @@ func checkInterfaceHandle(f interface{}) { if rt.In(0) != reflect.TypeOf(&Context{}) { panic(`handle should accept Context as first argument`) } - - return } func handlePOST(r *Router, f interface{}) Handle { @@ -166,7 +213,7 @@ func handlePOST(r *Router, f interface{}) Handle { if r.Reader != nil { ok, err := r.Reader(c, data.Interface()) - c.Request.Body.Close() + _ = c.Request.Body.Close() if err != nil { return err } @@ -186,10 +233,10 @@ func handlePOST(r *Router, f interface{}) Handle { func handleReq(r *Router, handle Handle, m []Middleware) httprouter.Handle { return func(res http.ResponseWriter, req *http.Request, param httprouter.Params) { - c := newContext(r, res, req, param) + c := NewContext(r, res, req, param) f := handle - for i := len(m) - 1; i >= 0; i-- { // TODO: 1,2,3 of 3,2,1 + for i := len(m) - 1; i >= 0; i-- { f = m[i](f) } diff --git a/type.go b/type.go index 2d5c6a5..bea7215 100644 --- a/type.go +++ b/type.go @@ -4,6 +4,7 @@ import ( "io" ) +// Renderer renders a template type Renderer interface { Render(w io.Writer, template string, data interface{}, c *Context) error }