package echo import ( "net/http" ) type ( // Router is the registry of all registered routes for an `Echo` instance for // request matching and URL path parameter parsing. Router struct { tree *node routes map[string]*Route echo *Echo } node struct { kind kind label byte prefix string parent *node staticChildren children ppath string pnames []string methodHandler *methodHandler paramChild *node anyChild *node } kind uint8 children []*node methodHandler struct { connect HandlerFunc delete HandlerFunc get HandlerFunc head HandlerFunc options HandlerFunc patch HandlerFunc post HandlerFunc propfind HandlerFunc put HandlerFunc trace HandlerFunc report HandlerFunc } ) const ( staticKind kind = iota paramKind anyKind paramLabel = byte(':') anyLabel = byte('*') ) // NewRouter returns a new Router instance. func NewRouter(e *Echo) *Router { return &Router{ tree: &node{ methodHandler: new(methodHandler), }, routes: map[string]*Route{}, echo: e, } } // Add registers a new route for method and path with matching handler. func (r *Router) Add(method, path string, h HandlerFunc) { // Validate path if path == "" { path = "/" } if path[0] != '/' { path = "/" + path } pnames := []string{} // Param names ppath := path // Pristine path for i, lcpIndex := 0, len(path); i < lcpIndex; i++ { if path[i] == ':' { j := i + 1 r.insert(method, path[:i], nil, staticKind, "", nil) for ; i < lcpIndex && path[i] != '/'; i++ { } pnames = append(pnames, path[j:i]) path = path[:j] + path[i:] i, lcpIndex = j, len(path) if i == lcpIndex { r.insert(method, path[:i], h, paramKind, ppath, pnames) } else { r.insert(method, path[:i], nil, paramKind, "", nil) } } else if path[i] == '*' { r.insert(method, path[:i], nil, staticKind, "", nil) pnames = append(pnames, "*") r.insert(method, path[:i+1], h, anyKind, ppath, pnames) } } r.insert(method, path, h, staticKind, ppath, pnames) } func (r *Router) insert(method, path string, h HandlerFunc, t kind, ppath string, pnames []string) { // Adjust max param paramLen := len(pnames) if *r.echo.maxParam < paramLen { *r.echo.maxParam = paramLen } currentNode := r.tree // Current node as root if currentNode == nil { panic("echo: invalid method") } search := path for { searchLen := len(search) prefixLen := len(currentNode.prefix) lcpLen := 0 // LCP - Longest Common Prefix (https://en.wikipedia.org/wiki/LCP_array) max := prefixLen if searchLen < max { max = searchLen } for ; lcpLen < max && search[lcpLen] == currentNode.prefix[lcpLen]; lcpLen++ { } if lcpLen == 0 { // At root node currentNode.label = search[0] currentNode.prefix = search if h != nil { currentNode.kind = t currentNode.addHandler(method, h) currentNode.ppath = ppath currentNode.pnames = pnames } } else if lcpLen < prefixLen { // Split node n := newNode( currentNode.kind, currentNode.prefix[lcpLen:], currentNode, currentNode.staticChildren, currentNode.methodHandler, currentNode.ppath, currentNode.pnames, currentNode.paramChild, currentNode.anyChild, ) // Update parent path for all children to new node for _, child := range currentNode.staticChildren { child.parent = n } if currentNode.paramChild != nil { currentNode.paramChild.parent = n } if currentNode.anyChild != nil { currentNode.anyChild.parent = n } // Reset parent node currentNode.kind = staticKind currentNode.label = currentNode.prefix[0] currentNode.prefix = currentNode.prefix[:lcpLen] currentNode.staticChildren = nil currentNode.methodHandler = new(methodHandler) currentNode.ppath = "" currentNode.pnames = nil currentNode.paramChild = nil currentNode.anyChild = nil // Only Static children could reach here currentNode.addStaticChild(n) if lcpLen == searchLen { // At parent node currentNode.kind = t currentNode.addHandler(method, h) currentNode.ppath = ppath currentNode.pnames = pnames } else { // Create child node n = newNode(t, search[lcpLen:], currentNode, nil, new(methodHandler), ppath, pnames, nil, nil) n.addHandler(method, h) // Only Static children could reach here currentNode.addStaticChild(n) } } else if lcpLen < searchLen { search = search[lcpLen:] c := currentNode.findChildWithLabel(search[0]) if c != nil { // Go deeper currentNode = c continue } // Create child node n := newNode(t, search, currentNode, nil, new(methodHandler), ppath, pnames, nil, nil) n.addHandler(method, h) switch t { case staticKind: currentNode.addStaticChild(n) case paramKind: currentNode.paramChild = n case anyKind: currentNode.anyChild = n } } else { // Node already exists if h != nil { currentNode.addHandler(method, h) currentNode.ppath = ppath if len(currentNode.pnames) == 0 { // Issue #729 currentNode.pnames = pnames } } } return } } func newNode(t kind, pre string, p *node, sc children, mh *methodHandler, ppath string, pnames []string, paramChildren, anyChildren *node) *node { return &node{ kind: t, label: pre[0], prefix: pre, parent: p, staticChildren: sc, ppath: ppath, pnames: pnames, methodHandler: mh, paramChild: paramChildren, anyChild: anyChildren, } } func (n *node) addStaticChild(c *node) { n.staticChildren = append(n.staticChildren, c) } func (n *node) findStaticChild(l byte) *node { for _, c := range n.staticChildren { if c.label == l { return c } } return nil } func (n *node) findChildWithLabel(l byte) *node { for _, c := range n.staticChildren { if c.label == l { return c } } if l == paramLabel { return n.paramChild } if l == anyLabel { return n.anyChild } return nil } func (n *node) addHandler(method string, h HandlerFunc) { switch method { case http.MethodConnect: n.methodHandler.connect = h case http.MethodDelete: n.methodHandler.delete = h case http.MethodGet: n.methodHandler.get = h case http.MethodHead: n.methodHandler.head = h case http.MethodOptions: n.methodHandler.options = h case http.MethodPatch: n.methodHandler.patch = h case http.MethodPost: n.methodHandler.post = h case PROPFIND: n.methodHandler.propfind = h case http.MethodPut: n.methodHandler.put = h case http.MethodTrace: n.methodHandler.trace = h case REPORT: n.methodHandler.report = h } } func (n *node) findHandler(method string) HandlerFunc { switch method { case http.MethodConnect: return n.methodHandler.connect case http.MethodDelete: return n.methodHandler.delete case http.MethodGet: return n.methodHandler.get case http.MethodHead: return n.methodHandler.head case http.MethodOptions: return n.methodHandler.options case http.MethodPatch: return n.methodHandler.patch case http.MethodPost: return n.methodHandler.post case PROPFIND: return n.methodHandler.propfind case http.MethodPut: return n.methodHandler.put case http.MethodTrace: return n.methodHandler.trace case REPORT: return n.methodHandler.report default: return nil } } func (n *node) checkMethodNotAllowed() HandlerFunc { for _, m := range methods { if h := n.findHandler(m); h != nil { return MethodNotAllowedHandler } } return NotFoundHandler } // Find lookup a handler registered for method and path. It also parses URL for path // parameters and load them into context. // // For performance: // // - Get context from `Echo#AcquireContext()` // - Reset it `Context#Reset()` // - Return it `Echo#ReleaseContext()`. func (r *Router) Find(method, path string, c Context) { ctx := c.(*context) ctx.path = path currentNode := r.tree // Current node as root var ( // search stores the remaining path to check for match. By each iteration we move from start of path to end of the path // and search value gets shorter and shorter. search = path searchIndex = 0 paramIndex int // Param counter paramValues = ctx.pvalues // Use the internal slice so the interface can keep the illusion of a dynamic slice ) // Backtracking is needed when a dead end (leaf node) is reached in the router tree. // To backtrack the current node will be changed to the parent node and the next kind for the // router logic will be returned based on fromKind or kind of the dead end node (static > param > any). // For example if there is no static node match we should check parent next sibling by kind (param). // Backtracking itself does not check if there is a next sibling, this is done by the router logic. backtrackToNextNodeKind := func(fromKind kind) (nextNodeKind kind, valid bool) { previous := currentNode currentNode = previous.parent valid = currentNode != nil // Next node type by priority // NOTE: With the current implementation we never backtrack from an `any` route, so `previous.kind` is // always `static` or `any` // If this is changed then for any route next kind would be `static` and this statement should be changed nextNodeKind = previous.kind + 1 if fromKind == staticKind { // when backtracking is done from static kind block we did not change search so nothing to restore return } // restore search to value it was before we move to current node we are backtracking from. if previous.kind == staticKind { searchIndex -= len(previous.prefix) } else { paramIndex-- // for param/any node.prefix value is always `:` so we can not deduce searchIndex from that and must use pValue // for that index as it would also contain part of path we cut off before moving into node we are backtracking from searchIndex -= len(paramValues[paramIndex]) } search = path[searchIndex:] return } // Router tree is implemented by longest common prefix array (LCP array) https://en.wikipedia.org/wiki/LCP_array // Tree search is implemented as for loop where one loop iteration is divided into 3 separate blocks // Each of these blocks checks specific kind of node (static/param/any). Order of blocks reflex their priority in routing. // Search order/priority is: static > param > any. // // Note: backtracking in tree is implemented by replacing/switching currentNode to previous node // and hoping to (goto statement) next block by priority to check if it is the match. for { prefixLen := 0 // Prefix length lcpLen := 0 // LCP (longest common prefix) length if currentNode.kind == staticKind { searchLen := len(search) prefixLen = len(currentNode.prefix) // LCP - Longest Common Prefix (https://en.wikipedia.org/wiki/LCP_array) max := prefixLen if searchLen < max { max = searchLen } for ; lcpLen < max && search[lcpLen] == currentNode.prefix[lcpLen]; lcpLen++ { } } if lcpLen != prefixLen { // No matching prefix, let's backtrack to the first possible alternative node of the decision path nk, ok := backtrackToNextNodeKind(staticKind) if !ok { return // No other possibilities on the decision path } else if nk == paramKind { goto Param // NOTE: this case (backtracking from static node to previous any node) can not happen by current any matching logic. Any node is end of search currently //} else if nk == anyKind { // goto Any } else { // Not found (this should never be possible for static node we are looking currently) return } } // The full prefix has matched, remove the prefix from the remaining search search = search[lcpLen:] searchIndex = searchIndex + lcpLen // Finish routing if no remaining search and we are on an leaf node if search == "" && currentNode.ppath != "" { break } // Static node if search != "" { if child := currentNode.findStaticChild(search[0]); child != nil { currentNode = child continue } } Param: // Param node if child := currentNode.paramChild; search != "" && child != nil { currentNode = child // FIXME: when param node does not have any children then param node should act similarly to any node - consider all remaining search as match i, l := 0, len(search) for ; i < l && search[i] != '/'; i++ { } paramValues[paramIndex] = search[:i] paramIndex++ search = search[i:] searchIndex = searchIndex + i continue } Any: // Any node if child := currentNode.anyChild; child != nil { // If any node is found, use remaining path for paramValues currentNode = child paramValues[len(currentNode.pnames)-1] = search break } // Let's backtrack to the first possible alternative node of the decision path nk, ok := backtrackToNextNodeKind(anyKind) if !ok { return // No other possibilities on the decision path } else if nk == paramKind { goto Param } else if nk == anyKind { goto Any } else { // Not found return } } ctx.handler = currentNode.findHandler(method) ctx.path = currentNode.ppath ctx.pnames = currentNode.pnames if ctx.handler == nil { ctx.handler = currentNode.checkMethodNotAllowed() } return }