crouter

README

crouter

A common router for all need routing data.

copy from httprouter, but not for http. It can be used in any place that needs routing data. Like mqtt, kafka, custom protocol, etc.

usage

1. define a context interface

   import (
       "context"
       "time"
   
       "github.com/bytectlgo/crouter"
   )
   
   type Context interface {
       context.Context
       crouter.RouterInfo
   }
   

2. implement the context interface

   note: the context interface must be a combination of context.Context and crouter.RouterInfo. crouter.RouterInfo is a interface, router info is the data you need from the router

   var _ Context = (*wrapper)(nil)
   
   type wrapper struct {
       ctx context.Context
       req *TestRouterReq
   }
   
   func (c *wrapper) GetPath() string {
       return c.req.path
   }
   
   func (c *wrapper) Method() string {
       return c.req.method
   }
   
   func (c *wrapper) Deadline() (time.Time, bool) {
       if c.ctx == nil {
       return time.Time{}, false
       }
       return c.ctx.Deadline()
   }
   
   func (c *wrapper) Done() <-chan struct{} {
       if c.ctx == nil {
       return nil
       }
       return c.ctx.Done()
   }
   
   func (c *wrapper) Err() error {
       if c.ctx == nil {
       return context.Canceled
       }
       return c.ctx.Err()
   }
   
   func (c *wrapper) Value(key interface{}) interface{} {
       if c.ctx == nil {
       return nil
       }
       return c.ctx.Value(key)
   }
   

3. define a request struct

   type TestRouterReq struct {
       method string
       path   string
   }
   
   func NewTestRouterReq(method, path string) *TestRouterReq {
       return &TestRouterReq{method, path}
   }
   

4. use the router and test

   router := crouter.New()
   router.Handle("METHOD", "/test/:id", func(ctx context.Context, ps crouter.Params) {
       rctx, ok := ctx.(Context)
       if !ok {
           t.Fatal("ctx is not a Context")
       }
       fmt.Println(rctx.GetPath())
       fmt.Println(rctx.Method())
       fmt.Println(ps)
   })
   // create test context
   wp := &wrapper{
       context.Background(),
       &TestRouterReq{
           method: "METHOD",
           path:   "/test/1234",
       },
   }
   router.Serve(wp)
   

LICENSE

The code copy from httprouter and modified.

• httprouter

Documentation

Overview

Package httprouter is a trie based high performance HTTP request router.

A trivial example is:

package main

import (
    "fmt"
    "github.com/julienschmidt/httprouter"
    "net/http"
    "log"
)

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, "Welcome!\n")
}

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func main() {
    router := httprouter.New()
    router.GET("/", Index)
    router.GET("/hello/:name", Hello)

    log.Fatal(http.ListenAndServe(":8080", router))
}

The router matches incoming requests by the request method and the path. If a handle is registered for this path and method, the router delegates the request to that function. For the methods GET, POST, PUT, PATCH, DELETE and OPTIONS shortcut functions exist to register handles, for all other methods router.Handle can be used.

The registered path, against which the router matches incoming requests, can contain two types of parameters:

Syntax    Type
:name     named parameter
*name     catch-all parameter

Named parameters are dynamic path segments. They match anything until the next '/' or the path end:

Path: /blog/:category/:post

Requests:
 /blog/go/request-routers            match: category="go", post="request-routers"
 /blog/go/request-routers/           no match, but the router would redirect
 /blog/go/                           no match
 /blog/go/request-routers/comments   no match

Catch-all parameters match anything until the path end, including the directory index (the '/' before the catch-all). Since they match anything until the end, catch-all parameters must always be the final path element.

Path: /files/*filepath

Requests:
 /files/                             match: filepath="/"
 /files/LICENSE                      match: filepath="/LICENSE"
 /files/templates/article.html       match: filepath="/templates/article.html"
 /files                              no match, but the router would redirect

The value of parameters is saved as a slice of the Param struct, consisting each of a key and a value. The slice is passed to the Handle func as a third parameter. There are two ways to retrieve the value of a parameter:

// by the name of the parameter
user := ps.ByName("user") // defined by :user or *user

// by the index of the parameter. This way you can also get the name (key)
thirdKey   := ps[2].Key   // the name of the 3rd parameter
thirdValue := ps[2].Value // the value of the 3rd parameter

Index

• Variables
• func CleanPath(p string) string
• type Handle
• type Handler
• type HandlerFunc
  • func (f HandlerFunc) Serve(ctx context.Context)
• type Param
• type Params
  • func ParamsFromContext(ctx context.Context) Params
  • func (ps Params) ByName(name string) string
  • func (ps Params) MatchedRoutePath() string
• type Router
  • func New() *Router
  • func (r *Router) Handle(method, path string, handle Handle)
  • func (r *Router) Handler(method, path string, handler Handler)
  • func (r *Router) HandlerFunc(method, path string, handler Handler)
  • func (r *Router) Lookup(method, path string) (Handle, Params, bool)
  • func (r *Router) Serve(ctx context.Context)
• type RouterInfo

Variables

var MatchedRoutePathParam = "$matchedRoutePath"

MatchedRoutePathParam is the Param name under which the path of the matched route is stored, if Router.SaveMatchedRoutePath is set.

var ParamsKey = paramsKey{}

ParamsKey is the request context key under which URL params are stored.

Functions

func CleanPath

func CleanPath(p string) string

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

Types

type Handle

type Handle func(context.Context, Params)

Handle is a function that can be registered to a route to handle HTTP requests. Like http.HandlerFunc, but has a third parameter for the values of wildcards (path variables).

type Handler

type Handler interface {
	Serve(context.Context)
}

type HandlerFunc

type HandlerFunc func(context.Context)

func (HandlerFunc) Serve

func (f HandlerFunc) Serve(ctx context.Context)

Serve calls f(ctx).

type Param

type Param struct {
	Key   string
	Value string
}

Param is a single URL parameter, consisting of a key and a value.

type Params

type Params []Param

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.

func ParamsFromContext

func ParamsFromContext(ctx context.Context) Params

ParamsFromContext pulls the URL parameters from a request context, or returns nil if none are present.

func (Params) ByName

func (ps Params) ByName(name string) string

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 (Params) MatchedRoutePath

func (ps Params) MatchedRoutePath() string

MatchedRoutePath retrieves the path of the matched route. Router.SaveMatchedRoutePath must have been enabled when the respective handler was added, otherwise this function always returns an empty string.

type Router

type Router struct {

	// Configurable http.Handler which is called when no matching route is
	// found. If it is not set, http.NotFound is used.
	NotFound Handler

	// Function to handle panics recovered from http handlers.
	// It should be used to generate a error page and return the http error code
	// 500 (Internal Server Error).
	// The handler can be used to keep your server from crashing because of
	// unrecovered panics.
	PanicHandler func(ctx context.Context, rcv interface{})

	SaveMatchedRoutePath bool
	// contains filtered or unexported fields
}

Router is a http.Handler which can be used to dispatch requests to different handler functions via configurable routes

func New

func New() *Router

New returns a new initialized Router. Path auto-correction, including trailing slashes, is enabled by default.

func (*Router) Handle

func (r *Router) Handle(method, path string, handle Handle)

Handle registers a new request handle with the given path and method.

For GET, POST, PUT, PATCH and DELETE requests the respective shortcut functions can be used.

This function is intended for bulk loading and to allow the usage of less frequently used, non-standardized or custom methods (e.g. for internal communication with a proxy).

func (*Router) Handler

func (r *Router) Handler(method, path string, handler Handler)

Handler is an adapter which allows the usage of an http.Handler as a request handle. The Params are available in the request context under ParamsKey.

func (*Router) HandlerFunc

func (r *Router) HandlerFunc(method, path string, handler Handler)

HandlerFunc is an adapter which allows the usage of an http.HandlerFunc as a request handle.

func (*Router) Lookup

func (r *Router) Lookup(method, path string) (Handle, Params, bool)

Lookup allows the manual lookup of a method + path combo. This is e.g. useful to build a framework around this router. If the path was found, it returns the handle function and the path parameter values. Otherwise the third return value indicates whether a redirection to the same path with an extra / without the trailing slash should be performed.

func (*Router) Serve

func (r *Router) Serve(ctx context.Context)

Serve makes the router implement the Handler interface.

type RouterInfo

type RouterInfo interface {
	// Method 获取路由方法
	Method() string
	// 获取路由路径
	GetPath() string
}