Since Go 1.6.0 and the concurrent acces detector, my app crashes under heavy load:

fatal error: concurrent map read and map write

at github.com/go-zoo/bone/route.go:98

Does anybody else is experiencing the same issue ?

I got panic running example code:

% go run 001/example.go -race

2015/10/03 20:58:39 http: panic serving [::1]:45814: runtime error: invalid memory address or nil pointer dereference
goroutine 182 [running]:
net/http.(*conn).serve.func1(0xc8201786e0, 0x7f33df087650, 0xc820080398)
        /usr/lib/go/src/net/http/server.go:1287 +0xb5
github.com/go-zoo/bone.(*Route).Match(0xc8200b0c80, 0xc820171880, 0xc820083a00)
        /tmp/b/src/github.com/go-zoo/bone/route.go:101 +0x28f
github.com/go-zoo/bone.(*Mux).parse(0xc820076cf0, 0x7f33df0877d0, 0xc820178790, 0xc820171880, 0x0)
        /tmp/b/src/github.com/go-zoo/bone/helper.go:29 +0x31d
github.com/go-zoo/bone.(*Mux).ServeHTTP(0xc820076cf0, 0x7f33df0877d0, 0xc820178790, 0xc820171880)
        /tmp/b/src/github.com/go-zoo/bone/bone.go:49 +0x43
net/http.serverHandler.ServeHTTP(0xc8200700c0, 0x7f33df0877d0, 0xc820178790, 0xc820171880)
        /usr/lib/go/src/net/http/server.go:1862 +0x19e
net/http.(*conn).serve(0xc8201786e0)
        /usr/lib/go/src/net/http/server.go:1361 +0xbee
created by net/http.(*Server).Serve
        /usr/lib/go/src/net/http/server.go:1910 +0x3f6

tested with curl:

% (repeat 100 {curl localhost:8080/home/foo & })

mux := bone.New()
mux.Get("/test/", http.HandlerFunc(myHandler))

If I make requests to /test/ endpoint with POST method then I get 404 Not Found error instead of 405 Method Not Allowed.

Probable reason: map[string][]*Route the key in this map is method name (e.g., GET, POST, etc..) and the requested endpoint is searched in the slice of the requested method, and if the endpoint is not found then 404 is returned.

Proposed Solution:

1. Search all Method's slices. (too costly operation) OR
2. Register routes with the different way.

Your benchmarks are comparing the fetching of a single url - This is a misleading benchmark which is heavily biased towards bone because of its simple algorithm.

Please add some benchmarks where the number of routes is medium and large with varying degrees of shared prefixes.

Is there any support for using case insensitive urls?

Say I have a page at http://test.com/promo/ and the user types http://test.com/Promo/ I would like it to still match.

Sorry if there is a feature I am missing that allows for this.

     mux := bone.New()

    sub := bone.New()

    sub.GetFunc("/test/example", func(rw http.ResponseWriter, req *http.Request) {
        rw.Write([]byte("From Sub router !"))
    })

    mux.Get("/api", sub)

This is example from Readme, and it doesn't work. But example 003 in examples folder, works. Only difference is the path of the subrouter. If subrouter has more than 1 hardcoded pathsegments, it doesn't work. Example - "/test/example" Doesn't work. Whereas this - "/user/:id" works.

Just a quick thought.

Example:

runtime.GOMAXPROCS(2)
mux.Get("/home/:id", Handler)

And as http.ListenAndServe() emits each client in the separate goroutine, it might happen that two clients access /home/1 and /home/2 at the same time.

According to the variant of the GetValue() as a global var , it I'm not sure that both clients will get the correct bone.GetValue("id").

Refactor value storage to use net.Context. This allows users of bone to use http.Request.WithContext without bone breaking.

I also expect this to have performance benefits since the map of requests has been completely eliminated (and locking is no longer required, since we don't allow mutations of the request values).

Using getRequestRoute for sub routes isn't working properly. Let's assume I have the following setup:

func Main() {
    mux := bone.New()
    mux.SubRoute("/v0", apiMux)
    http.ListenAndServe("127.0.0.1:3000", mux)
}

apiMux have the following endpoints registered:

apiMux.Post("/users", usersHandler)
apiMux.Post("/posts", postsHandler)

Doing a request to /users will generate a http.Request with an URL equal to /v0/users. Calling getRequestRoute(req) returns /v0. I'd assume it returns /v0/users or /users.

Is this a bug? If so, how do we want to fix it? I'd be happy to help in any way possible.

I have a sub route like:

subRouter.GetFunc("*/users", ...)
mainRouter.Get("/app/*", subRouter)

This matches /app/users, but I can't figure out how to match the same path with an added query string. e.g. /app/users?active=true or /app/users?foo=1&bar=3

I just get 404s. When I use a query string in the main router it works, but somehow a sub router fails. Any clues?

Like for instance the following:

subRouter := bone.New()
subRouter.GetFunc("/getNames", GetUserNamesControllerFunc)
subRouter.GetFunc("/getEmail", GetUserEmailControllerFunc)

router.Handle("/user", subRouter)

I would like this code to handle the /user/getNames and /user/getEmail urls but it does not work. Is this functionality supported?

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/go-zoo/bone"
)

var (
	mux = bone.New(Serve, Wrap)
)

func Wrap(mux *bone.Mux) *bone.Mux {
	return mux.Prefix("/api")
}

func Serve(mux *bone.Mux) *bone.Mux {
	mux.Serve = func(rw http.ResponseWriter, req *http.Request) {
		tr := time.Now()
		mux.DefaultServe(rw, req)
		fmt.Println("Serve request from", req.RemoteAddr, "in", time.Since(tr))
	}
	return mux
}

func main() {
	// Custom 404
	mux.NotFoundFunc(Handler404)
	// Handle with any http method, Handle takes http.Handler as argument.
	mux.Handle("/index", http.HandlerFunc(homeHandler))
	mux.Handle("/index/:var/info/:test", http.HandlerFunc(varHandler))
	// Get, Post etc... takes http.HandlerFunc as argument.
	mux.Post("/home", http.HandlerFunc(homeHandler))
	mux.Get("/home/:var", http.HandlerFunc(varHandler))

	mux.GetFunc("/test/*", func(rw http.ResponseWriter, req *http.Request) {
		rw.Write([]byte(req.RequestURI))
	})

	// Start Listening
	log.Fatal(mux.ListenAndServe(":8080"))
}

func homeHandler(rw http.ResponseWriter, req *http.Request) {
	rw.Write([]byte("WELCOME HOME"))
}

func varHandler(rw http.ResponseWriter, req *http.Request) {
	varr := bone.GetValue(req, "var")
	test := bone.GetValue(req, "test")

	var args = struct {
		First  string
		Second string
	}{varr, test}

	if err := json.NewEncoder(rw).Encode(&args); err != nil {
		panic(err)
	}
}

func Handler404(rw http.ResponseWriter, req *http.Request) {
	rw.Write([]byte("These are not the droids you're looking for ..."))
}

visist http://localhost:8080/api/home/xxx
{"First":"xxx","Second":""} visit http://localhost:8080/api/home/ {"First":"","Second":""}

When bone returns a 405 Method Not Allowed response, it would be good if it could include an Allow header detailing which methods are permitted.

I think it could perhaps be done by amending the otherMethods helper. Something like:

func (m *Mux) otherMethods(rw http.ResponseWriter, req *http.Request) bool {
	allowed := []string{}
	for _, met := range method {
		if met != req.Method {
			for _, r := range m.Routes[met] {
				ok := r.exists(rw, req)
				if ok {
					allowed = append(allowed, r.Method)
				}
			}
		}
	}
	if len(allowed) > 0 {
		rw.Header()["Allow"] = allowed
		rw.WriteHeader(http.StatusMethodNotAllowed)
		return true
	}
	return false
}

Also, what are your thoughts on including a plain text "Method Not Allowed" message in the response body, similar to the "404 page not allowed" body for 404s?