beego: update namespace

admin.go

@@ -218,9 +218,9 @@ func profIndex(rw http.ResponseWriter, r *http.Request) {
 func healthcheck(rw http.ResponseWriter, req *http.Request) {
 	for name, h := range toolbox.AdminCheckList {
 		if err := h.Check(); err != nil {
-			fmt.Fprintf(rw, "%s : ok\n", name)
-		} else {
 			fmt.Fprintf(rw, "%s : %s\n", name, err.Error())
+		} else {
+			fmt.Fprintf(rw, "%s : ok\n", name)
 		}
 	}
 }

context/input.go

@@ -161,7 +161,8 @@ func (input *BeegoInput) IsUpload() bool {
 func (input *BeegoInput) IP() string {
 	ips := input.Proxy()
 	if len(ips) > 0 && ips[0] != "" {
-		return ips[0]
+		rip := strings.Split(ips[0], ":")
+		return rip[0]
 	}
 	ip := strings.Split(input.Request.RemoteAddr, ":")
 	if len(ip) > 0 {

namespace.go

@@ -14,12 +14,14 @@ import (
 
 type namespaceCond func(*beecontext.Context) bool
 
+// Namespace is store all the info
 type Namespace struct {
 	prefix    string
 	condition namespaceCond
 	handlers  *ControllerRegistor
 }
 
+// get new Namespace
 func NewNamespace(prefix string) *Namespace {
 	cr := NewControllerRegistor()
 	return &Namespace{
@@ -28,11 +30,30 @@ func NewNamespace(prefix string) *Namespace {
 	}
 }
 
+// set condtion function
+// if cond return true can run this namespace, else can't
+// usage:
+// ns.Cond(func (ctx *context.Context) bool{
+//       if ctx.Input.Domain() == "api.beego.me" {
+//         return true
+//       }
+//       return false
+//   })
 func (n *Namespace) Cond(cond namespaceCond) *Namespace {
 	n.condition = cond
 	return n
 }
 
+// add filter in the Namespace
+// action has before & after
+// FilterFunc
+// usage:
+// Filter("before", func (ctx *context.Context){
+//       _, ok := ctx.Input.Session("uid").(int)
+//       if !ok && ctx.Request.RequestURI != "/login" {
+//          ctx.Redirect(302, "/login")
+//        }
+//   })
 func (n *Namespace) Filter(action string, filter FilterFunc) *Namespace {
 	if action == "before" {
 		action = "BeforeRouter"
@@ -43,71 +64,115 @@ func (n *Namespace) Filter(action string, filter FilterFunc) *Namespace {
 	return n
 }
 
+// same as beego.Rourer
+// refer: https://godoc.org/github.com/astaxie/beego#Router
 func (n *Namespace) Router(rootpath string, c ControllerInterface, mappingMethods ...string) *Namespace {
 	n.handlers.Add(rootpath, c, mappingMethods...)
 	return n
 }
 
+// same as beego.AutoRouter
+// refer: https://godoc.org/github.com/astaxie/beego#AutoRouter
 func (n *Namespace) AutoRouter(c ControllerInterface) *Namespace {
 	n.handlers.AddAuto(c)
 	return n
 }
 
+// same as beego.AutoPrefix
+// refer: https://godoc.org/github.com/astaxie/beego#AutoPrefix
 func (n *Namespace) AutoPrefix(prefix string, c ControllerInterface) *Namespace {
 	n.handlers.AddAutoPrefix(prefix, c)
 	return n
 }
 
+// same as beego.Get
+// refer: https://godoc.org/github.com/astaxie/beego#Get
 func (n *Namespace) Get(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Get(rootpath, f)
 	return n
 }
 
+// same as beego.Post
+// refer: https://godoc.org/github.com/astaxie/beego#Post
 func (n *Namespace) Post(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Post(rootpath, f)
 	return n
 }
 
+// same as beego.Delete
+// refer: https://godoc.org/github.com/astaxie/beego#Delete
 func (n *Namespace) Delete(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Delete(rootpath, f)
 	return n
 }
 
+// same as beego.Put
+// refer: https://godoc.org/github.com/astaxie/beego#Put
 func (n *Namespace) Put(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Put(rootpath, f)
 	return n
 }
 
+// same as beego.Head
+// refer: https://godoc.org/github.com/astaxie/beego#Head
 func (n *Namespace) Head(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Head(rootpath, f)
 	return n
 }
 
+// same as beego.Options
+// refer: https://godoc.org/github.com/astaxie/beego#Options
 func (n *Namespace) Options(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Options(rootpath, f)
 	return n
 }
 
+// same as beego.Patch
+// refer: https://godoc.org/github.com/astaxie/beego#Patch
 func (n *Namespace) Patch(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Patch(rootpath, f)
 	return n
 }
 
+// same as beego.Any
+// refer: https://godoc.org/github.com/astaxie/beego#Any
 func (n *Namespace) Any(rootpath string, f FilterFunc) *Namespace {
 	n.handlers.Any(rootpath, f)
 	return n
 }
 
+// same as beego.Handler
+// refer: https://godoc.org/github.com/astaxie/beego#Handler
 func (n *Namespace) Handler(rootpath string, h http.Handler) *Namespace {
 	n.handlers.Handler(rootpath, h)
 	return n
 }
 
-func (n *Namespace) Namespace(ns *Namespace) *Namespace {
-	n.handlers.Handler(ns.prefix, ns, true)
+// nest Namespace
+// usage:
+//ns := beego.NewNamespace(“/v1”).
+//Namespace(
+//    beego.NewNamespace("/shop").
+//        Get("/:id", func(ctx *context.Context) {
+//            ctx.Output.Body([]byte("shopinfo"))
+//    }),
+//    beego.NewNamespace("/order").
+//        Get("/:id", func(ctx *context.Context) {
+//            ctx.Output.Body([]byte("orderinfo"))
+//    }),
+//    beego.NewNamespace("/crm").
+//        Get("/:id", func(ctx *context.Context) {
+//            ctx.Output.Body([]byte("crminfo"))
+//    }),
+//)
+func (n *Namespace) Namespace(ns ...*Namespace) *Namespace {
+	for _, ni := range ns {
+		n.handlers.Handler(ni.prefix, ni, true)
+	}
 	return n
 }
 
+// Namespace implement the http.Handler
 func (n *Namespace) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	//trim the preifix from URL.Path
 	r.URL.Path = strings.TrimPrefix(r.URL.Path, n.prefix)
@@ -130,6 +195,8 @@ func (n *Namespace) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	n.handlers.ServeHTTP(rw, r)
 }
 
+// register Namespace into beego.Handler
+// support multi Namespace
 func AddNamespace(nl ...*Namespace) {
 	for _, n := range nl {
 		Handler(n.prefix, n, true)

router.go

@@ -480,6 +480,7 @@ func (p *ControllerRegistor) InsertFilter(pattern string, pos int, filter Filter
 	return nil
 }
 
+// build the Filter by pattern
 func (p *ControllerRegistor) buildFilter(pattern string, filter FilterFunc) (*FilterRouter, error) {
 	mr := new(FilterRouter)
 	mr.params = make(map[int]string)