Merge pull request #11 from go-rs/develop

Develop

Author: roshangade

README.md

@@ -3,7 +3,7 @@ REST API framework for go lang
 
 # Framework is under development
 ## Status: 
-Released alpha version
+Released beta version
 <br>
 See examples 
   - Request Interceptors/Middleware
@@ -27,9 +27,9 @@ api.Use(func(ctx *rest.Context) {
 // ctx.PreSend(func() error) OR ctx.PostSend(func() error)
 api.Use(func(ctx *rest.Context) {
   s := time.Now().UnixNano()
-  ctx.PreSend(func() error {
+  ctx.PreSend(func() {
     x := time.Now().UnixNano() - s
-    ctx.SetHeader("x-runtime", strconv.FormatInt(x/int64(time.Millisecond), 10))
+    ctx.SetHeader("X-Runtime", strconv.FormatInt(x/int64(time.Millisecond), 10))
     return nil
   })
 })
@@ -41,7 +41,7 @@ api.Get("/", func(ctx *rest.Context) {
 })
 
 api.Get("/foo", func(ctx *rest.Context) {
-  ctx.Status(401).Throw(errors.New("UNAUTHORIZED"))
+  ctx.Status(401).Throw("UNAUTHORIZED")
 })
 
 api.Get("/:bar", func(ctx *rest.Context) {

api.go

@@ -5,8 +5,7 @@
 package rest
 
 import (
-	"errors"
-	"log"
+	"fmt"
 	"net/http"
 	"regexp"
 	"strings"
@@ -48,8 +47,8 @@ type interceptor struct {
 
 // user exceptions, which is a common way to handle an error thrown by user
 type exception struct {
-	message string
-	handle  Handler
+	code   string
+	handle Handler
 }
 
 // Initialize an API with prefix value and return the API pointer
@@ -127,10 +126,10 @@ func (api *API) Patch(pattern string, handle Handler) {
 }
 
 // OnError method is used to handle a custom errors thrown by users
-func (api *API) OnError(err string, handle Handler) {
+func (api *API) OnError(code string, handle Handler) {
 	exp := exception{
-		message: err,
-		handle:  handle,
+		code:   code,
+		handle: handle,
 	}
 	api.exceptions = append(api.exceptions, exp)
 }
@@ -142,16 +141,16 @@ func (api *API) UnhandledException(handle Handler) {
 
 // error variables to handle expected errors
 var (
-	errNotFound          = errors.New("URL_NOT_FOUND")
-	errUncaughtException = errors.New("UNCAUGHT_EXCEPTION")
+	codeNotFound          = "URL_NOT_FOUND"
+	codeUncaughtException = "UNCAUGHT_EXCEPTION"
 )
 
 // It's required handle for http module.
 // Every request travels from this method.
 func (api *API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 
 	// STEP 1: initialize context
-	ctx := Context{
+	ctx := &Context{
 		Request:  req,
 		Response: res,
 		Query:    req.URL.Query(),
@@ -163,10 +162,9 @@ func (api *API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	defer func() {
 		err := recover()
 		if err != nil {
-			//TODO: log only with debugger mode
-			log.Println("uncaught exception - ", err)
-			if ctx.end == false {
-				ctx.err = errUncaughtException
+			if !ctx.end {
+				ctx.code = codeUncaughtException
+				ctx.err = fmt.Errorf("%v", err)
 				ctx.unhandledException()
 			}
 			return
@@ -179,7 +177,7 @@ func (api *API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 			break
 		}
 
-		task.handle(&ctx)
+		task.handle(ctx)
 	}
 
 	// STEP 3: check routes
@@ -192,29 +190,29 @@ func (api *API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 		if (route.method == "" || strings.EqualFold(route.method, req.Method)) && route.regex.Match(urlPath) {
 			ctx.found = route.method != "" //?
 			ctx.Params = utils.Exec(route.regex, route.params, urlPath)
-			route.handle(&ctx)
+			route.handle(ctx)
 		}
 	}
 
 	// STEP 4: check handled exceptions
 	for _, exp := range api.exceptions {
-		if ctx.end || ctx.err == nil {
+		if ctx.end || ctx.code == "" {
 			break
 		}
 
-		if exp.message == ctx.err.Error() {
-			exp.handle(&ctx)
+		if exp.code == ctx.code {
+			exp.handle(ctx)
 		}
 	}
 
 	// STEP 5: unhandled exceptions
 	if !ctx.end {
-		if ctx.err == nil && !ctx.found {
-			ctx.err = errNotFound
+		if ctx.code == "" && !ctx.found {
+			ctx.Throw(codeNotFound)
 		}
 
 		if api.unhandled != nil {
-			api.unhandled(&ctx)
+			api.unhandled(ctx)
 		}
 	}
 

api_test.go

@@ -95,7 +95,7 @@ func TestAPI_Exception(t *testing.T) {
 
 	flag := true
 	for _, route := range a.exceptions {
-		if route.message == "UID_NOT_FOUND" {
+		if route.code == "UID_NOT_FOUND" {
 			flag = false
 			break
 		}

context.go

@@ -29,6 +29,7 @@ type Context struct {
 	// for internal use
 	headers         map[string]string
 	data            map[string]interface{}
+	code            string
 	err             error
 	status          int
 	found           bool
@@ -58,6 +59,7 @@ func (ctx *Context) destroy() {
 	ctx.Params = nil
 	ctx.headers = nil
 	ctx.data = nil
+	ctx.code = ""
 	ctx.err = nil
 	ctx.status = 0
 	ctx.found = false
@@ -81,7 +83,7 @@ func (ctx *Context) Get(key string) (val interface{}, exists bool) {
 }
 
 // Delete data
-func (ctx *Context) Delete(key string, val interface{}) {
+func (ctx *Context) Delete(key string) {
 	delete(ctx.data, key)
 }
 
@@ -98,7 +100,13 @@ func (ctx *Context) SetHeader(key string, val string) *Context {
 }
 
 // Caught error in context on throw
-func (ctx *Context) Throw(err error) {
+func (ctx *Context) Throw(code string) {
+	ctx.code = code
+}
+
+// Throw an error with error
+func (ctx *Context) ThrowWithError(code string, err error) {
+	ctx.code = code
 	ctx.err = err
 }
 
@@ -149,11 +157,13 @@ func (ctx *Context) PostSend(task Task) {
 // Send data, which uses bytes or error if any
 // Also, it calls pre-send and post-send registered hooks
 func (ctx *Context) send(data []byte, err error) {
+
 	if ctx.end {
 		return
 	}
 
 	if err != nil {
+		ctx.code = "INVALID_RESPONSE"
 		ctx.err = err
 		ctx.unhandledException()
 		return
@@ -198,28 +208,39 @@ func (ctx *Context) send(data []byte, err error) {
 
 // Unhandled Exception
 func (ctx *Context) unhandledException() {
-	defer func() {
-		err := recover()
-		if err != nil {
-			//TODO: debugger mode
-			log.Println("Unhandled Error: ", err)
-			if !ctx.requestSent {
-				ctx.Response.WriteHeader(http.StatusInternalServerError)
-				ctx.Response.Header().Set("Content-Type", "text/plain;charset=UTF-8")
-				_, _ = ctx.Response.Write([]byte("Internal Server Error"))
-			}
-		}
-	}()
+	defer ctx.recover()
 
-	err := ctx.GetError()
+	if ctx.end {
+		return
+	}
 
-	if err != nil {
-		msg := err.Error()
-		ctx.Status(http.StatusInternalServerError)
-		ctx.SetHeader("Content-Type", "text/plain;charset=UTF-8")
-		if msg == "URL_NOT_FOUND" {
-			ctx.Status(http.StatusNotFound)
+	// NOT FOUND handler
+	if ctx.code == codeNotFound {
+		http.NotFound(ctx.Response, ctx.Request)
+		return
+	}
+
+	if ctx.code != "" || ctx.err != nil {
+		msg := ctx.code
+		if ctx.err != nil {
+			msg = ctx.err.Error()
 		}
+		ctx.SetHeader("Content-Type", "text/plain;charset=UTF-8")
+		ctx.Status(http.StatusInternalServerError)
 		ctx.Write([]byte(msg))
 	}
 }
+
+// recover
+func (ctx *Context) recover() {
+	err := recover()
+	if err != nil {
+		//TODO: debugger mode
+		log.Println("Unhandled Error: ", err)
+		if !ctx.requestSent {
+			ctx.Response.WriteHeader(http.StatusInternalServerError)
+			ctx.Response.Header().Set("Content-Type", "text/plain;charset=UTF-8")
+			_, _ = ctx.Response.Write([]byte("Internal Server Error"))
+		}
+	}
+}

context_test.go

@@ -53,7 +53,7 @@ func TestContext_Status(t *testing.T) {
 
 func TestContext_Throw(t *testing.T) {
 	err := errors.New("test error")
-	ctx.Throw(err)
+	ctx.ThrowWithError("TEST_ERROR", err)
 
 	if ctx.err != err {
 		t.Error("Throw is not working")
@@ -64,7 +64,7 @@ func TestContext_Throw(t *testing.T) {
 
 func TestContext_GetError(t *testing.T) {
 	err := errors.New("test error")
-	ctx.Throw(err)
+	ctx.ThrowWithError("TEST_ERROR", err)
 
 	if ctx.GetError() != err {
 		t.Error("GetError is not working")

examples/server.go

@@ -1,9 +1,10 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"net/http"
+	"strconv"
+	"time"
 
 	"github.com/go-rs/rest-api-framework"
 	"github.com/go-rs/rest-api-framework/examples/user"
@@ -19,16 +20,29 @@ func main() {
 	// body-parser : json, raw, form-data, etc
 	// security
 	api.Use(func(ctx *rest.Context) {
+		// way to reproduce uncaught exception
+		//zero, _ := strconv.ParseInt(ctx.Query.Get("zero"), 10, 32)
+		//x := 10/zero
+		//ctx.Set("x", x)
 		ctx.Set("authtoken", "roshangade")
 	})
 
+	// calculate runtime
+	api.Use(func(ctx *rest.Context) {
+		s := time.Now().UnixNano()
+		ctx.PreSend(func() {
+			x := time.Now().UnixNano() - s
+			ctx.SetHeader("X-Runtime", strconv.FormatInt(x/int64(time.Millisecond), 10))
+		})
+	})
+
 	// routes
 	api.Get("/", func(ctx *rest.Context) {
 		ctx.JSON(`{"message": "Hello World!"}`)
 	})
 
 	api.Get("/foo", func(ctx *rest.Context) {
-		ctx.Throw(errors.New("UNAUTHORIZED"))
+		ctx.Throw("UNAUTHORIZED")
 	})
 
 	// error handler
@@ -38,5 +52,7 @@ func main() {
 
 	fmt.Println("Starting server.")
 
-	http.ListenAndServe(":8080", api)
+	err := http.ListenAndServe(":8080", api)
+
+	fmt.Println(err)
 }

namespace.go

@@ -66,10 +66,10 @@ func (n *Namespace) Patch(pattern string, handle Handler) {
 }
 
 // OnError method is an exactly same with API.OnError
-func (n *Namespace) OnError(err string, handle Handler) {
+func (n *Namespace) OnError(code string, handle Handler) {
 	exp := exception{
-		message: err,
-		handle:  handle,
+		code:   code,
+		handle: handle,
 	}
 	n.api.exceptions = append(n.api.exceptions, exp)
 }

namespace_test.go

@@ -93,7 +93,7 @@ func TestNamespace_Exception(t *testing.T) {
 
 	flag := true
 	for _, route := range api.exceptions {
-		if route.message == "UID_NOT_FOUND" {
+		if route.code == "UID_NOT_FOUND" {
 			flag = false
 			break
 		}