Add support for net.Listener

Co-authored-by: Elwin Tamminga <elwintamminga@gmail.com>
Co-committed-by: Elwin Tamminga <elwintamminga@gmail.com>

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
+}

default.go

@@ -17,12 +17,11 @@ func defaultErrorHandler(c *Context, err interface{}) {
 	_ = c.StatusText(http.StatusInternalServerError)
 }
 
-func defaultReader(c *Context, dst interface{}) bool {
+func defaultReader(c *Context, dst interface{}) (bool, error) {
 	err := json.NewDecoder(c.Request.Body).Decode(dst)
 	if err != nil {
-		c.NoContent(400)
-		return false
+		return false, c.StatusText(http.StatusBadRequest)
 	}
 
-	return true
+	return true, nil
 }

go.mod

@@ -0,0 +1,5 @@
+module git.fuyu.moe/Fuyu/router
+
+go 1.13
+
+require github.com/julienschmidt/httprouter v1.3.0

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=

router.go

@@ -1,8 +1,12 @@
 package router
 
 import (
+	"context"
+	"crypto/tls"
+	"net"
 	"net/http"
 	"reflect"
+	"time"
 
 	"github.com/julienschmidt/httprouter"
 )
@@ -23,8 +27,8 @@ 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
-type Reader func(c *Context, dst interface{}) bool
+// Reader reads input to dst, returns true if successful
+type Reader func(c *Context, dst interface{}) (bool, error)
 
 // Router is the router itself
 type Router struct {
@@ -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 {
@@ -164,11 +211,16 @@ func handlePOST(r *Router, f interface{}) Handle {
 	return func(c *Context) error {
 		data := reflect.New(inputRt)
 
-		if !r.Reader(c, data.Interface()) {
-			c.Request.Body.Close()
-			return nil
+		if r.Reader != nil {
+			ok, err := r.Reader(c, data.Interface())
+			_ = c.Request.Body.Close()
+			if err != nil {
+				return err
+			}
+			if !ok {
+				return nil
+			}
 		}
-		c.Request.Body.Close()
 
 		out := funcRv.Call([]reflect.Value{reflect.ValueOf(c), data.Elem()})
 
@@ -181,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)
 		}
 

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
 }