diff --git a/.idea/kratos.iml b/.idea/kratos.iml
new file mode 100644
index 000000000..c956989b2
--- /dev/null
+++ b/.idea/kratos.iml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 000000000..28a804d89
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 000000000..c3d31912a
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 000000000..94a25f7f4
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pkg/net/http/blademaster/tree.go b/pkg/net/http/blademaster/tree.go
new file mode 100644
index 000000000..eaeec92bd
--- /dev/null
+++ b/pkg/net/http/blademaster/tree.go
@@ -0,0 +1,627 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE
+
+package blademaster
+
+import (
+"net/url"
+"strings"
+"unicode"
+)
+
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+ Key string
+ Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// Get returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) Get(name string) (string, bool) {
+ for _, entry := range ps {
+ if entry.Key == name {
+ return entry.Value, true
+ }
+ }
+ return "", false
+}
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) ByName(name string) (va string) {
+ va, _ = ps.Get(name)
+ return
+}
+
+type methodTree struct {
+ method string
+ root *node
+}
+
+type methodTrees []methodTree
+
+func (trees methodTrees) get(method string) *node {
+ for _, tree := range trees {
+ if tree.method == method {
+ return tree.root
+ }
+ }
+ return nil
+}
+
+func min(a, b int) int {
+ if a <= b {
+ return a
+ }
+ return b
+}
+
+func countParams(path string) uint8 {
+ var n uint
+ for i := 0; i < len(path); i++ {
+ if path[i] != ':' && path[i] != '*' {
+ continue
+ }
+ n++
+ }
+ if n >= 255 {
+ return 255
+ }
+ return uint8(n)
+}
+
+type nodeType uint8
+
+const (
+ static nodeType = iota // default
+ root
+ param
+ catchAll
+)
+
+type node struct {
+ path string
+ indices string
+ children []*node
+ handlers []HandlerFunc
+ priority uint32
+ nType nodeType
+ maxParams uint8
+ wildChild bool
+}
+
+// increments priority of the given child and reorders if necessary.
+func (n *node) incrementChildPrio(pos int) int {
+ n.children[pos].priority++
+ prio := n.children[pos].priority
+
+ // adjust position (move to front)
+ newPos := pos
+ for newPos > 0 && n.children[newPos-1].priority < prio {
+ // swap node positions
+ n.children[newPos-1], n.children[newPos] = n.children[newPos], n.children[newPos-1]
+
+ newPos--
+ }
+
+ // build new index char string
+ if newPos != pos {
+ n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
+ n.indices[pos:pos+1] + // the index char we move
+ n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+ }
+
+ return newPos
+}
+
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handlers []HandlerFunc) {
+ fullPath := path
+ n.priority++
+ numParams := countParams(path)
+
+ // non-empty tree
+ if len(n.path) > 0 || len(n.children) > 0 {
+ walk:
+ for {
+ // Update maxParams of the current node
+ if numParams > n.maxParams {
+ n.maxParams = numParams
+ }
+
+ // Find the longest common prefix.
+ // This also implies that the common prefix contains no ':' or '*'
+ // since the existing key can't contain those chars.
+ i := 0
+ max := min(len(path), len(n.path))
+ for i < max && path[i] == n.path[i] {
+ i++
+ }
+
+ // Split edge
+ if i < len(n.path) {
+ child := node{
+ path: n.path[i:],
+ wildChild: n.wildChild,
+ indices: n.indices,
+ children: n.children,
+ handlers: n.handlers,
+ priority: n.priority - 1,
+ }
+
+ // Update maxParams (max of all children)
+ for i := range child.children {
+ if child.children[i].maxParams > child.maxParams {
+ child.maxParams = child.children[i].maxParams
+ }
+ }
+
+ n.children = []*node{&child}
+ // []byte for proper unicode char conversion, see #65
+ n.indices = string([]byte{n.path[i]})
+ n.path = path[:i]
+ n.handlers = nil
+ n.wildChild = false
+ }
+
+ // Make new node a child of this node
+ if i < len(path) {
+ path = path[i:]
+
+ if n.wildChild {
+ n = n.children[0]
+ n.priority++
+
+ // Update maxParams of the child node
+ if numParams > n.maxParams {
+ n.maxParams = numParams
+ }
+ numParams--
+
+ // Check if the wildcard matches
+ if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
+ // check for longer wildcard, e.g. :name and :names
+ if len(n.path) >= len(path) || path[len(n.path)] == '/' {
+ continue walk
+ }
+ }
+
+ pathSeg := path
+ if n.nType != catchAll {
+ pathSeg = strings.SplitN(path, "/", 2)[0]
+ }
+ prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
+ panic("'" + pathSeg +
+ "' in new path '" + fullPath +
+ "' conflicts with existing wildcard '" + n.path +
+ "' in existing prefix '" + prefix +
+ "'")
+ }
+
+ c := path[0]
+
+ // slash after param
+ if n.nType == param && c == '/' && len(n.children) == 1 {
+ n = n.children[0]
+ n.priority++
+ continue walk
+ }
+
+ // Check if a child with the next path byte exists
+ for i := 0; i < len(n.indices); i++ {
+ if c == n.indices[i] {
+ i = n.incrementChildPrio(i)
+ n = n.children[i]
+ continue walk
+ }
+ }
+
+ // Otherwise insert it
+ if c != ':' && c != '*' {
+ // []byte for proper unicode char conversion, see #65
+ n.indices += string([]byte{c})
+ child := &node{
+ maxParams: numParams,
+ }
+ n.children = append(n.children, child)
+ n.incrementChildPrio(len(n.indices) - 1)
+ n = child
+ }
+ n.insertChild(numParams, path, fullPath, handlers)
+ return
+
+ } else if i == len(path) { // Make node a (in-path) leaf
+ if n.handlers != nil {
+ panic("handlers are already registered for path '" + fullPath + "'")
+ }
+ n.handlers = handlers
+ }
+ return
+ }
+ } else { // Empty tree
+ n.insertChild(numParams, path, fullPath, handlers)
+ n.nType = root
+ }
+}
+
+func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers []HandlerFunc) {
+ var offset int // already handled bytes of the path
+
+ // find prefix until first wildcard (beginning with ':' or '*')
+ for i, max := 0, len(path); numParams > 0; i++ {
+ c := path[i]
+ if c != ':' && c != '*' {
+ continue
+ }
+
+ // find wildcard end (either '/' or path end)
+ end := i + 1
+ for end < max && path[end] != '/' {
+ switch path[end] {
+ // the wildcard name must not contain ':' and '*'
+ case ':', '*':
+ panic("only one wildcard per path segment is allowed, has: '" +
+ path[i:] + "' in path '" + fullPath + "'")
+ default:
+ end++
+ }
+ }
+
+ // check if this Node existing children which would be
+ // unreachable if we insert the wildcard here
+ if len(n.children) > 0 {
+ panic("wildcard route '" + path[i:end] +
+ "' conflicts with existing children in path '" + fullPath + "'")
+ }
+
+ // check if the wildcard has a name
+ if end-i < 2 {
+ panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+ }
+
+ if c == ':' { // param
+ // split path at the beginning of the wildcard
+ if i > 0 {
+ n.path = path[offset:i]
+ offset = i
+ }
+
+ child := &node{
+ nType: param,
+ maxParams: numParams,
+ }
+ n.children = []*node{child}
+ n.wildChild = true
+ n = child
+ n.priority++
+ numParams--
+
+ // if the path doesn't end with the wildcard, then there
+ // will be another non-wildcard subpath starting with '/'
+ if end < max {
+ n.path = path[offset:end]
+ offset = end
+
+ child := &node{
+ maxParams: numParams,
+ priority: 1,
+ }
+ n.children = []*node{child}
+ n = child
+ }
+
+ } else { // catchAll
+ if end != max || numParams > 1 {
+ panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+ }
+
+ if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+ panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+ }
+
+ // currently fixed width 1 for '/'
+ i--
+ if path[i] != '/' {
+ panic("no / before catch-all in path '" + fullPath + "'")
+ }
+
+ n.path = path[offset:i]
+
+ // first node: catchAll node with empty path
+ child := &node{
+ wildChild: true,
+ nType: catchAll,
+ maxParams: 1,
+ }
+ n.children = []*node{child}
+ n.indices = string(path[i])
+ n = child
+ n.priority++
+
+ // second node: node holding the variable
+ child = &node{
+ path: path[i:],
+ nType: catchAll,
+ maxParams: 1,
+ handlers: handlers,
+ priority: 1,
+ }
+ n.children = []*node{child}
+
+ return
+ }
+ }
+
+ // insert remaining path part and handle to the leaf
+ n.path = path[offset:]
+ n.handlers = handlers
+}
+
+// getValue returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string, po Params, unescape bool) (handlers []HandlerFunc, p Params, tsr bool) {
+ p = po
+walk: // Outer loop for walking the tree
+ for {
+ if len(path) > len(n.path) {
+ if path[:len(n.path)] == n.path {
+ path = path[len(n.path):]
+ // If this node does not have a wildcard (param or catchAll)
+ // child, we can just look up the next child node and continue
+ // to walk down the tree
+ if !n.wildChild {
+ c := path[0]
+ for i := 0; i < len(n.indices); i++ {
+ if c == n.indices[i] {
+ n = n.children[i]
+ continue walk
+ }
+ }
+
+ // Nothing found.
+ // We can recommend to redirect to the same URL without a
+ // trailing slash if a leaf exists for that path.
+ tsr = path == "/" && n.handlers != nil
+ return
+ }
+
+ // handle wildcard child
+ n = n.children[0]
+ switch n.nType {
+ case param:
+ // find param end (either '/' or path end)
+ end := 0
+ for end < len(path) && path[end] != '/' {
+ end++
+ }
+
+ // save param value
+ if cap(p) < int(n.maxParams) {
+ p = make(Params, 0, n.maxParams)
+ }
+ i := len(p)
+ p = p[:i+1] // expand slice within preallocated capacity
+ p[i].Key = n.path[1:]
+ val := path[:end]
+ if unescape {
+ var err error
+ if p[i].Value, err = url.QueryUnescape(val); err != nil {
+ p[i].Value = val // fallback, in case of error
+ }
+ } else {
+ p[i].Value = val
+ }
+
+ // we need to go deeper!
+ if end < len(path) {
+ if len(n.children) > 0 {
+ path = path[end:]
+ n = n.children[0]
+ continue walk
+ }
+
+ // ... but we can't
+ tsr = len(path) == end+1
+ return
+ }
+
+ if handlers = n.handlers; handlers != nil {
+ return
+ }
+ if len(n.children) == 1 {
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists for TSR recommendation
+ n = n.children[0]
+ tsr = n.path == "/" && n.handlers != nil
+ }
+
+ return
+
+ case catchAll:
+ // save param value
+ if cap(p) < int(n.maxParams) {
+ p = make(Params, 0, n.maxParams)
+ }
+ i := len(p)
+ p = p[:i+1] // expand slice within preallocated capacity
+ p[i].Key = n.path[2:]
+ if unescape {
+ var err error
+ if p[i].Value, err = url.QueryUnescape(path); err != nil {
+ p[i].Value = path // fallback, in case of error
+ }
+ } else {
+ p[i].Value = path
+ }
+
+ handlers = n.handlers
+ return
+
+ default:
+ panic("invalid node type")
+ }
+ }
+ } else if path == n.path {
+ // We should have reached the node containing the handle.
+ // Check if this node has a handle registered.
+ if handlers = n.handlers; handlers != nil {
+ return
+ }
+
+ if path == "/" && n.wildChild && n.nType != root {
+ tsr = true
+ return
+ }
+
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists for trailing slash recommendation
+ for i := 0; i < len(n.indices); i++ {
+ if n.indices[i] == '/' {
+ n = n.children[i]
+ tsr = (len(n.path) == 1 && n.handlers != nil) ||
+ (n.nType == catchAll && n.children[0].handlers != nil)
+ return
+ }
+ }
+
+ return
+ }
+
+ // Nothing found. We can recommend to redirect to the same URL with an
+ // extra trailing slash if a leaf exists for that path
+ tsr = (path == "/") ||
+ (len(n.path) == len(path)+1 && n.path[len(path)] == '/' &&
+ path == n.path[:len(n.path)-1] && n.handlers != nil)
+ return
+ }
+}
+
+// findCaseInsensitivePath makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
+ ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+
+ // Outer loop for walking the tree
+ for len(path) >= len(n.path) && strings.ToLower(path[:len(n.path)]) == strings.ToLower(n.path) {
+ path = path[len(n.path):]
+ ciPath = append(ciPath, n.path...)
+
+ if len(path) > 0 {
+ // If this node does not have a wildcard (param or catchAll) child,
+ // we can just look up the next child node and continue to walk down
+ // the tree
+ if !n.wildChild {
+ r := unicode.ToLower(rune(path[0]))
+ for i, index := range n.indices {
+ // must use recursive approach since both index and
+ // ToLower(index) could exist. We must check both.
+ if r == unicode.ToLower(index) {
+ out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
+ if found {
+ return append(ciPath, out...), true
+ }
+ }
+ }
+
+ // Nothing found. We can recommend to redirect to the same URL
+ // without a trailing slash if a leaf exists for that path
+ found = fixTrailingSlash && path == "/" && n.handlers != nil
+ return
+ }
+
+ n = n.children[0]
+ switch n.nType {
+ case param:
+ // find param end (either '/' or path end)
+ k := 0
+ for k < len(path) && path[k] != '/' {
+ k++
+ }
+
+ // add param value to case insensitive path
+ ciPath = append(ciPath, path[:k]...)
+
+ // we need to go deeper!
+ if k < len(path) {
+ if len(n.children) > 0 {
+ path = path[k:]
+ n = n.children[0]
+ continue
+ }
+
+ // ... but we can't
+ if fixTrailingSlash && len(path) == k+1 {
+ return ciPath, true
+ }
+ return
+ }
+
+ if n.handlers != nil {
+ return ciPath, true
+ } else if fixTrailingSlash && len(n.children) == 1 {
+ // No handle found. Check if a handle for this path + a
+ // trailing slash exists
+ n = n.children[0]
+ if n.path == "/" && n.handlers != nil {
+ return append(ciPath, '/'), true
+ }
+ }
+ return
+
+ case catchAll:
+ return append(ciPath, path...), true
+
+ default:
+ panic("invalid node type")
+ }
+ } else {
+ // We should have reached the node containing the handle.
+ // Check if this node has a handle registered.
+ if n.handlers != nil {
+ return ciPath, true
+ }
+
+ // No handle found.
+ // Try to fix the path by adding a trailing slash
+ if fixTrailingSlash {
+ for i := 0; i < len(n.indices); i++ {
+ if n.indices[i] == '/' {
+ n = n.children[i]
+ if (len(n.path) == 1 && n.handlers != nil) ||
+ (n.nType == catchAll && n.children[0].handlers != nil) {
+ return append(ciPath, '/'), true
+ }
+ return
+ }
+ }
+ }
+ return
+ }
+ }
+
+ // Nothing found.
+ // Try to fix the path by adding / removing a trailing slash
+ if fixTrailingSlash {
+ if path == "/" {
+ return ciPath, true
+ }
+ if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
+ strings.ToLower(path) == strings.ToLower(n.path[:len(path)]) &&
+ n.handlers != nil {
+ return append(ciPath, n.path...), true
+ }
+ }
+ return
+}
diff --git a/pkg/net/http/blademaster/tree_test.go b/pkg/net/http/blademaster/tree_test.go
new file mode 100644
index 000000000..991b5ce93
--- /dev/null
+++ b/pkg/net/http/blademaster/tree_test.go
@@ -0,0 +1,698 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE
+
+package blademaster
+
+import (
+"fmt"
+"reflect"
+"regexp"
+"strings"
+"testing"
+)
+
+// Used as a workaround since we can't compare functions or their addresses
+var fakeHandlerValue string
+
+func fakeHandler(val string) []HandlerFunc {
+ return []HandlerFunc{func(c *Context) {
+ fakeHandlerValue = val
+ }}
+}
+
+type testRequests []struct {
+ path string
+ nilHandler bool
+ route string
+ ps Params
+}
+
+func checkRequests(t *testing.T, tree *node, requests testRequests, unescapes ...bool) {
+ unescape := false
+ if len(unescapes) >= 1 {
+ unescape = unescapes[0]
+ }
+
+ for _, request := range requests {
+ handler, ps, _ := tree.getValue(request.path, nil, unescape)
+
+ if handler == nil {
+ if !request.nilHandler {
+ t.Errorf("handle mismatch for route '%s': Expected non-nil handle", request.path)
+ }
+ } else if request.nilHandler {
+ t.Errorf("handle mismatch for route '%s': Expected nil handle", request.path)
+ } else {
+ handler[0](nil)
+ if fakeHandlerValue != request.route {
+ t.Errorf("handle mismatch for route '%s': Wrong handle (%s != %s)", request.path, fakeHandlerValue, request.route)
+ }
+ }
+
+ if !reflect.DeepEqual(ps, request.ps) {
+ t.Errorf("Params mismatch for route '%s'", request.path)
+ }
+ }
+}
+
+func checkPriorities(t *testing.T, n *node) uint32 {
+ var prio uint32
+ for i := range n.children {
+ prio += checkPriorities(t, n.children[i])
+ }
+
+ if n.handlers != nil {
+ prio++
+ }
+
+ if n.priority != prio {
+ t.Errorf(
+ "priority mismatch for node '%s': is %d, should be %d",
+ n.path, n.priority, prio,
+ )
+ }
+
+ return prio
+}
+
+func checkMaxParams(t *testing.T, n *node) uint8 {
+ var maxParams uint8
+ for i := range n.children {
+ params := checkMaxParams(t, n.children[i])
+ if params > maxParams {
+ maxParams = params
+ }
+ }
+ if n.nType > root && !n.wildChild {
+ maxParams++
+ }
+
+ if n.maxParams != maxParams {
+ t.Errorf(
+ "maxParams mismatch for node '%s': is %d, should be %d",
+ n.path, n.maxParams, maxParams,
+ )
+ }
+
+ return maxParams
+}
+
+func TestCountParams(t *testing.T) {
+ if countParams("/path/:param1/static/*catch-all") != 2 {
+ t.Fail()
+ }
+ if countParams(strings.Repeat("/:param", 256)) != 255 {
+ t.Fail()
+ }
+}
+
+func TestTreeAddAndGet(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/contact",
+ "/co",
+ "/c",
+ "/a",
+ "/ab",
+ "/doc/",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/α",
+ "/β",
+ }
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ checkRequests(t, tree, testRequests{
+ {"/a", false, "/a", nil},
+ {"/", true, "", nil},
+ {"/hi", false, "/hi", nil},
+ {"/contact", false, "/contact", nil},
+ {"/co", false, "/co", nil},
+ {"/con", true, "", nil}, // key mismatch
+ {"/cona", true, "", nil}, // key mismatch
+ {"/no", true, "", nil}, // no matching child
+ {"/ab", false, "/ab", nil},
+ {"/α", false, "/α", nil},
+ {"/β", false, "/β", nil},
+ })
+
+ checkPriorities(t, tree)
+ checkMaxParams(t, tree)
+}
+
+func TestTreeWildcard(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/",
+ "/cmd/:tool/:sub",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/search/",
+ "/search/:query",
+ "/user_:name",
+ "/user_:name/about",
+ "/files/:dir/*filepath",
+ "/doc/",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/info/:user/public",
+ "/info/:user/project/:project",
+ }
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ checkRequests(t, tree, testRequests{
+ {"/", false, "/", nil},
+ {"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}},
+ {"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}},
+ {"/cmd/test/3", false, "/cmd/:tool/:sub", Params{Param{Key: "tool", Value: "test"}, Param{Key: "sub", Value: "3"}}},
+ {"/src/", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/"}}},
+ {"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
+ {"/search/", false, "/search/", nil},
+ {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+ {"/search/someth!ng+in+ünìcodé/", true, "", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+ {"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}},
+ {"/user_gopher/about", false, "/user_:name/about", Params{Param{Key: "name", Value: "gopher"}}},
+ {"/files/js/inc/framework.js", false, "/files/:dir/*filepath", Params{Param{Key: "dir", Value: "js"}, Param{Key: "filepath", Value: "/inc/framework.js"}}},
+ {"/info/gordon/public", false, "/info/:user/public", Params{Param{Key: "user", Value: "gordon"}}},
+ {"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}},
+ })
+
+ checkPriorities(t, tree)
+ checkMaxParams(t, tree)
+}
+
+func TestUnescapeParameters(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/",
+ "/cmd/:tool/:sub",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/search/:query",
+ "/files/:dir/*filepath",
+ "/info/:user/project/:project",
+ "/info/:user",
+ }
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ unescape := true
+ checkRequests(t, tree, testRequests{
+ {"/", false, "/", nil},
+ {"/cmd/test/", false, "/cmd/:tool/", Params{Param{Key: "tool", Value: "test"}}},
+ {"/cmd/test", true, "", Params{Param{Key: "tool", Value: "test"}}},
+ {"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
+ {"/src/some/file+test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file test.png"}}},
+ {"/src/some/file++++%%%%test.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file++++%%%%test.png"}}},
+ {"/src/some/file%2Ftest.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file/test.png"}}},
+ {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng in ünìcodé"}}},
+ {"/info/gordon/project/go", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "gordon"}, Param{Key: "project", Value: "go"}}},
+ {"/info/slash%2Fgordon", false, "/info/:user", Params{Param{Key: "user", Value: "slash/gordon"}}},
+ {"/info/slash%2Fgordon/project/Project%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash/gordon"}, Param{Key: "project", Value: "Project #1"}}},
+ {"/info/slash%%%%", false, "/info/:user", Params{Param{Key: "user", Value: "slash%%%%"}}},
+ {"/info/slash%%%%2Fgordon/project/Project%%%%20%231", false, "/info/:user/project/:project", Params{Param{Key: "user", Value: "slash%%%%2Fgordon"}, Param{Key: "project", Value: "Project%%%%20%231"}}},
+ }, unescape)
+
+ checkPriorities(t, tree)
+ checkMaxParams(t, tree)
+}
+
+func catchPanic(testFunc func()) (recv interface{}) {
+ defer func() {
+ recv = recover()
+ }()
+
+ testFunc()
+ return
+}
+
+type testRoute struct {
+ path string
+ conflict bool
+}
+
+func testRoutes(t *testing.T, routes []testRoute) {
+ tree := &node{}
+
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route.path, nil)
+ })
+
+ if route.conflict {
+ if recv == nil {
+ t.Errorf("no panic for conflicting route '%s'", route.path)
+ }
+ } else if recv != nil {
+ t.Errorf("unexpected panic for route '%s': %v", route.path, recv)
+ }
+ }
+}
+
+func TestTreeWildcardConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/cmd/:tool/:sub", false},
+ {"/cmd/vet", true},
+ {"/src/*filepath", false},
+ {"/src/*filepathx", true},
+ {"/src/", true},
+ {"/src1/", false},
+ {"/src1/*filepath", true},
+ {"/src2*filepath", true},
+ {"/search/:query", false},
+ {"/search/invalid", true},
+ {"/user_:name", false},
+ {"/user_x", true},
+ {"/user_:name", false},
+ {"/id:id", false},
+ {"/id/:id", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeChildConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/cmd/vet", false},
+ {"/cmd/:tool/:sub", true},
+ {"/src/AUTHORS", false},
+ {"/src/*filepath", true},
+ {"/user_x", false},
+ {"/user_:name", true},
+ {"/id/:id", false},
+ {"/id:id", true},
+ {"/:id", true},
+ {"/*filepath", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeDupliatePath(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/",
+ "/doc/",
+ "/src/*filepath",
+ "/search/:query",
+ "/user_:name",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+
+ // Add again
+ recv = catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+ if recv == nil {
+ t.Fatalf("no panic while inserting duplicate route '%s", route)
+ }
+ }
+
+ checkRequests(t, tree, testRequests{
+ {"/", false, "/", nil},
+ {"/doc/", false, "/doc/", nil},
+ {"/src/some/file.png", false, "/src/*filepath", Params{Param{Key: "filepath", Value: "/some/file.png"}}},
+ {"/search/someth!ng+in+ünìcodé", false, "/search/:query", Params{Param{Key: "query", Value: "someth!ng+in+ünìcodé"}}},
+ {"/user_gopher", false, "/user_:name", Params{Param{Key: "name", Value: "gopher"}}},
+ })
+}
+
+func TestEmptyWildcardName(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/user:",
+ "/user:/",
+ "/cmd/:/",
+ "/src/*",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+ if recv == nil {
+ t.Fatalf("no panic while inserting route with empty wildcard name '%s", route)
+ }
+ }
+}
+
+func TestTreeCatchAllConflict(t *testing.T) {
+ routes := []testRoute{
+ {"/src/*filepath/x", true},
+ {"/src2/", false},
+ {"/src2/*filepath/x", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeCatchAllConflictRoot(t *testing.T) {
+ routes := []testRoute{
+ {"/", false},
+ {"/*filepath", true},
+ }
+ testRoutes(t, routes)
+}
+
+func TestTreeDoubleWildcard(t *testing.T) {
+ const panicMsg = "only one wildcard per path segment is allowed"
+
+ routes := [...]string{
+ "/:foo:bar",
+ "/:foo:bar/",
+ "/:foo*bar",
+ }
+
+ for _, route := range routes {
+ tree := &node{}
+ recv := catchPanic(func() {
+ tree.addRoute(route, nil)
+ })
+
+ if rs, ok := recv.(string); !ok || !strings.HasPrefix(rs, panicMsg) {
+ t.Fatalf(`"Expected panic "%s" for route '%s', got "%v"`, panicMsg, route, recv)
+ }
+ }
+}
+
+/*func TestTreeDuplicateWildcard(t *testing.T) {
+ tree := &node{}
+ routes := [...]string{
+ "/:id/:name/:id",
+ }
+ for _, route := range routes {
+ ...
+ }
+}*/
+
+func TestTreeTrailingSlashRedirect(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/b/",
+ "/search/:query",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/x",
+ "/x/y",
+ "/y/",
+ "/y/z",
+ "/0/:id",
+ "/0/:id/1",
+ "/1/:id/",
+ "/1/:id/2",
+ "/aa",
+ "/a/",
+ "/admin",
+ "/admin/:category",
+ "/admin/:category/:page",
+ "/doc",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/no/a",
+ "/no/b",
+ "/api/hello/:name",
+ }
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+ }
+
+ tsrRoutes := [...]string{
+ "/hi/",
+ "/b",
+ "/search/gopher/",
+ "/cmd/vet",
+ "/src",
+ "/x/",
+ "/y",
+ "/0/go/",
+ "/1/go",
+ "/a",
+ "/admin/",
+ "/admin/config/",
+ "/admin/config/permissions/",
+ "/doc/",
+ }
+ for _, route := range tsrRoutes {
+ handler, _, tsr := tree.getValue(route, nil, false)
+ if handler != nil {
+ t.Fatalf("non-nil handler for TSR route '%s", route)
+ } else if !tsr {
+ t.Errorf("expected TSR recommendation for route '%s'", route)
+ }
+ }
+
+ noTsrRoutes := [...]string{
+ "/",
+ "/no",
+ "/no/",
+ "/_",
+ "/_/",
+ "/api/world/abc",
+ }
+ for _, route := range noTsrRoutes {
+ handler, _, tsr := tree.getValue(route, nil, false)
+ if handler != nil {
+ t.Fatalf("non-nil handler for No-TSR route '%s", route)
+ } else if tsr {
+ t.Errorf("expected no TSR recommendation for route '%s'", route)
+ }
+ }
+}
+
+func TestTreeRootTrailingSlashRedirect(t *testing.T) {
+ tree := &node{}
+
+ recv := catchPanic(func() {
+ tree.addRoute("/:test", fakeHandler("/:test"))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting test route: %v", recv)
+ }
+
+ handler, _, tsr := tree.getValue("/", nil, false)
+ if handler != nil {
+ t.Fatalf("non-nil handler")
+ } else if tsr {
+ t.Errorf("expected no TSR recommendation")
+ }
+}
+
+func TestTreeFindCaseInsensitivePath(t *testing.T) {
+ tree := &node{}
+
+ routes := [...]string{
+ "/hi",
+ "/b/",
+ "/ABC/",
+ "/search/:query",
+ "/cmd/:tool/",
+ "/src/*filepath",
+ "/x",
+ "/x/y",
+ "/y/",
+ "/y/z",
+ "/0/:id",
+ "/0/:id/1",
+ "/1/:id/",
+ "/1/:id/2",
+ "/aa",
+ "/a/",
+ "/doc",
+ "/doc/go_faq.html",
+ "/doc/go1.html",
+ "/doc/go/away",
+ "/no/a",
+ "/no/b",
+ }
+
+ for _, route := range routes {
+ recv := catchPanic(func() {
+ tree.addRoute(route, fakeHandler(route))
+ })
+ if recv != nil {
+ t.Fatalf("panic inserting route '%s': %v", route, recv)
+ }
+ }
+
+ // Check out == in for all registered routes
+ // With fixTrailingSlash = true
+ for _, route := range routes {
+ out, found := tree.findCaseInsensitivePath(route, true)
+ if !found {
+ t.Errorf("Route '%s' not found!", route)
+ } else if string(out) != route {
+ t.Errorf("Wrong result for route '%s': %s", route, string(out))
+ }
+ }
+ // With fixTrailingSlash = false
+ for _, route := range routes {
+ out, found := tree.findCaseInsensitivePath(route, false)
+ if !found {
+ t.Errorf("Route '%s' not found!", route)
+ } else if string(out) != route {
+ t.Errorf("Wrong result for route '%s': %s", route, string(out))
+ }
+ }
+
+ tests := []struct {
+ in string
+ out string
+ found bool
+ slash bool
+ }{
+ {"/HI", "/hi", true, false},
+ {"/HI/", "/hi", true, true},
+ {"/B", "/b/", true, true},
+ {"/B/", "/b/", true, false},
+ {"/abc", "/ABC/", true, true},
+ {"/abc/", "/ABC/", true, false},
+ {"/aBc", "/ABC/", true, true},
+ {"/aBc/", "/ABC/", true, false},
+ {"/abC", "/ABC/", true, true},
+ {"/abC/", "/ABC/", true, false},
+ {"/SEARCH/QUERY", "/search/QUERY", true, false},
+ {"/SEARCH/QUERY/", "/search/QUERY", true, true},
+ {"/CMD/TOOL/", "/cmd/TOOL/", true, false},
+ {"/CMD/TOOL", "/cmd/TOOL/", true, true},
+ {"/SRC/FILE/PATH", "/src/FILE/PATH", true, false},
+ {"/x/Y", "/x/y", true, false},
+ {"/x/Y/", "/x/y", true, true},
+ {"/X/y", "/x/y", true, false},
+ {"/X/y/", "/x/y", true, true},
+ {"/X/Y", "/x/y", true, false},
+ {"/X/Y/", "/x/y", true, true},
+ {"/Y/", "/y/", true, false},
+ {"/Y", "/y/", true, true},
+ {"/Y/z", "/y/z", true, false},
+ {"/Y/z/", "/y/z", true, true},
+ {"/Y/Z", "/y/z", true, false},
+ {"/Y/Z/", "/y/z", true, true},
+ {"/y/Z", "/y/z", true, false},
+ {"/y/Z/", "/y/z", true, true},
+ {"/Aa", "/aa", true, false},
+ {"/Aa/", "/aa", true, true},
+ {"/AA", "/aa", true, false},
+ {"/AA/", "/aa", true, true},
+ {"/aA", "/aa", true, false},
+ {"/aA/", "/aa", true, true},
+ {"/A/", "/a/", true, false},
+ {"/A", "/a/", true, true},
+ {"/DOC", "/doc", true, false},
+ {"/DOC/", "/doc", true, true},
+ {"/NO", "", false, true},
+ {"/DOC/GO", "", false, true},
+ }
+ // With fixTrailingSlash = true
+ for _, test := range tests {
+ out, found := tree.findCaseInsensitivePath(test.in, true)
+ if found != test.found || (found && (string(out) != test.out)) {
+ t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t",
+ test.in, string(out), found, test.out, test.found)
+ return
+ }
+ }
+ // With fixTrailingSlash = false
+ for _, test := range tests {
+ out, found := tree.findCaseInsensitivePath(test.in, false)
+ if test.slash {
+ if found { // test needs a trailingSlash fix. It must not be found!
+ t.Errorf("Found without fixTrailingSlash: %s; got %s", test.in, string(out))
+ }
+ } else {
+ if found != test.found || (found && (string(out) != test.out)) {
+ t.Errorf("Wrong result for '%s': got %s, %t; want %s, %t",
+ test.in, string(out), found, test.out, test.found)
+ return
+ }
+ }
+ }
+}
+
+func TestTreeInvalidNodeType(t *testing.T) {
+ const panicMsg = "invalid node type"
+
+ tree := &node{}
+ tree.addRoute("/", fakeHandler("/"))
+ tree.addRoute("/:page", fakeHandler("/:page"))
+
+ // set invalid node type
+ tree.children[0].nType = 42
+
+ // normal lookup
+ recv := catchPanic(func() {
+ tree.getValue("/test", nil, false)
+ })
+ if rs, ok := recv.(string); !ok || rs != panicMsg {
+ t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv)
+ }
+
+ // case-insensitive lookup
+ recv = catchPanic(func() {
+ tree.findCaseInsensitivePath("/test", true)
+ })
+ if rs, ok := recv.(string); !ok || rs != panicMsg {
+ t.Fatalf("Expected panic '"+panicMsg+"', got '%v'", recv)
+ }
+}
+
+func TestTreeWildcardConflictEx(t *testing.T) {
+ conflicts := [...]struct {
+ route string
+ segPath string
+ existPath string
+ existSegPath string
+ }{
+ {"/who/are/foo", "/foo", `/who/are/\*you`, `/\*you`},
+ {"/who/are/foo/", "/foo/", `/who/are/\*you`, `/\*you`},
+ {"/who/are/foo/bar", "/foo/bar", `/who/are/\*you`, `/\*you`},
+ {"/conxxx", "xxx", `/con:tact`, `:tact`},
+ {"/conooo/xxx", "ooo", `/con:tact`, `:tact`},
+ }
+
+ for _, conflict := range conflicts {
+ // I have to re-create a 'tree', because the 'tree' will be
+ // in an inconsistent state when the loop recovers from the
+ // panic which threw by 'addRoute' function.
+ tree := &node{}
+ routes := [...]string{
+ "/con:tact",
+ "/who/are/*you",
+ "/who/foo/hello",
+ }
+
+ for _, route := range routes {
+ tree.addRoute(route, fakeHandler(route))
+ }
+
+ recv := catchPanic(func() {
+ tree.addRoute(conflict.route, fakeHandler(conflict.route))
+ })
+
+ if !regexp.MustCompile(fmt.Sprintf("'%s' in new path .* conflicts with existing wildcard '%s' in existing prefix '%s'",
+ conflict.segPath, conflict.existSegPath, conflict.existPath)).MatchString(fmt.Sprint(recv)) {
+ t.Fatalf("invalid wildcard conflict error (%v)", recv)
+ }
+ }
+}
+
diff --git a/pkg/net/http/blademaster/utils.go b/pkg/net/http/blademaster/utils.go
index 99ee1fdf3..7bd86034f 100644
--- a/pkg/net/http/blademaster/utils.go
+++ b/pkg/net/http/blademaster/utils.go
@@ -29,8 +29,10 @@ func resolveAddress(addr []string) string {
switch len(addr) {
case 0:
if port := os.Getenv("PORT"); port != "" {
+ //debugPrint("Environment variable PORT=\"%s\"", port)
return ":" + port
}
+ //debugPrint("Environment variable PORT is undefined. Using port :8080 by default")
return ":8080"
case 1:
return addr[0]
@@ -38,3 +40,120 @@ func resolveAddress(addr []string) string {
panic("too much parameters")
}
}
+
+// cleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+// 1. Replace multiple slashes with a single slash.
+// 2. Eliminate each . path name element (the current directory).
+// 3. Eliminate each inner .. path name element (the parent directory)
+// along with the non-.. element that precedes it.
+// 4. Eliminate .. elements that begin a rooted path:
+// that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned.
+func cleanPath(p string) string {
+ // Turn empty string into "/"
+ if p == "" {
+ return "/"
+ }
+
+ n := len(p)
+ var buf []byte
+
+ // Invariants:
+ // reading from path; r is index of next byte to process.
+ // writing to buf; w is index of next byte to write.
+
+ // path must start with '/'
+ r := 1
+ w := 1
+
+ if p[0] != '/' {
+ r = 0
+ buf = make([]byte, n+1)
+ buf[0] = '/'
+ }
+
+ trailing := n > 1 && p[n-1] == '/'
+
+ // A bit more clunky without a 'lazybuf' like the path package, but the loop
+ // gets completely inlined (bufApp). So in contrast to the path package this
+ // loop has no expensive function calls (except 1x make)
+
+ for r < n {
+ switch {
+ case p[r] == '/':
+ // empty path element, trailing slash is added after the end
+ r++
+
+ case p[r] == '.' && r+1 == n:
+ trailing = true
+ r++
+
+ case p[r] == '.' && p[r+1] == '/':
+ // . element
+ r += 2
+
+ case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+ // .. element: remove to last /
+ r += 3
+
+ if w > 1 {
+ // can backtrack
+ w--
+
+ if buf == nil {
+ for w > 1 && p[w] != '/' {
+ w--
+ }
+ } else {
+ for w > 1 && buf[w] != '/' {
+ w--
+ }
+ }
+ }
+
+ default:
+ // real path element.
+ // add slash if needed
+ if w > 1 {
+ bufApp(&buf, p, w, '/')
+ w++
+ }
+
+ // copy element
+ for r < n && p[r] != '/' {
+ bufApp(&buf, p, w, p[r])
+ w++
+ r++
+ }
+ }
+ }
+
+ // re-append trailing slash
+ if trailing && w > 1 {
+ bufApp(&buf, p, w, '/')
+ w++
+ }
+
+ if buf == nil {
+ return p[:w]
+ }
+ return string(buf[:w])
+}
+
+// internal helper to lazily create a buffer if necessary.
+func bufApp(buf *[]byte, s string, w int, c byte) {
+ if *buf == nil {
+ if s[w] == c {
+ return
+ }
+
+ *buf = make([]byte, len(s))
+ copy(*buf, s[:w])
+ }
+ (*buf)[w] = c
+}