Using a trivially modified example that sleeps in the middle of an output:

func (c *Context) SayHello(rw web.ResponseWriter, req *web.Request) {
    Fprint(rw, strings.Repeat("Hello ", c.HelloCount), "World!")

    rw.Flush()
    time.Sleep(2 * time.Second)

    Fprint(rw, strings.Repeat("Hello ", c.HelloCount), "World!")
}

Running curl 127.0.0.1:3000 won't print anything until the entire output is finished. Adding a newline to the printed strings will make this example behave as expected.

Is this an issue with gocraft/web, or is the problem at another layer? Do you forsee any issues with leaving requests open like this?

I'm assuming that each request is inside its own gofunc, and so could be used to trivially implement server-sent events, an alternative to websockets that uses "plain" HTTP.

Currently, there is no way to set the path prefix of the root router. It should be allowed as the application may not listen at the root of a server. An example is a REST API that may want to prefix all routes with /api or /v1 etc.

First off, thanks for building a flexible, yet simple router & middleware system.

I was wondering, though -- Do you have any thoughts on how I might go about implementing "Outerware" (often called output filters)? Essentially, middleware that will get executed after the route handler gets processed? You could imagine that for ever web request you serve, you want to have a standard way of recording stats for that request without having to put the code in each handler. For instance:

type YourContext struct {
  startTime time.Time
}

func (c *YourContext) StartRequest(rw web.ResponseWriter, req *web.Request, next web.NextMiddlewareFunc) {
  c.startTime = time.Now()
  next(rw, req)
}

func (c *YourContext) EndRequest(rw web.ResponseWriter, req *web.Request, next web.NextOuterwareFunc) {
  fmt.Fprint(rw, "request_time=", time.Since(c.startTime), " request_url=", req.URL.Path)
  next(rw, req)
}

router := web.New(YourContext{})
router.Middleware((*YourContext).StartRequest)

router.Get("/users", (*YourContext).UsersList)
router.Post("/users", (*YourContext).UsersCreate)
router.Put("/users/:id", (*YourContext).UsersUpdate)
router.Delete("/users/:id", (*YourContext).UsersDelete)
router.Patch("/users/:id", (*YourContext).UsersUpdate)
router.Get("/", (*YourContext).Root)

router.Outerware((*YourContext).EndRequest)

You could also imagine this process would be useful for having the handlers prep the context with the output data, and a common outerware takes that data and generates the JSON response. I think the alternative would be to call a common function at the end of every handler. That solution just is not as flexible in terms of attaching different outerware to different routers and subrouters (not demonstrated in the above example).

Thanks!

In the process of playing around with gocraft/web I've attempted to bring across a custom handler type that I use to save me some repetition when needing to return errors.

type appHandler func(w http.ResponseWriter, r *http.Request) *appError

type appError struct {
    code int
    err error
}

// Ensures appHandler satisfies the http.Handler interface
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     if e := fn(w, r); e != nil {
          // Handle error cases
     }
}

The problem I'm having is integrating this into gocraft/web - which provides it's own wrappers (web.ResponseWriter and *web.Request).

type appHandler func(w web.ResponseWriter, r *web.Request) *appError

// Ensures appHandler satisfies the http.Handler interface
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // We can't pass in w, r here as they aren't web.ResponseWriter or web.Request
     if e := fn(w, r); e != nil {
          // Handle error cases
     }
}

Is there a way to achieve this? Looking at the docs, the GenericHandler type has a signature of func(web.ResponseWriter, *web.Request) but I'm not sure on how to reconcile this with wanting a ServeHTTP method for my handler types.

This pull request modifies context creation: Instead of creating a new context on each request, a shallow copy of the context passed to New or Subrouter is created. This makes it possible to pass data into requests from the outside.

One use case for this is dependency injection. For example, the context could look like this:

type Context struct {
    UserService UserService // the dependency I'd like to inject

    UserName  string      // request-specific data
    SessionId string
}

I would initialize it like this:

router := web.New(Context { UserService: myUserService }).
    Middleware((*Context).VerifyUser)

And since the context of every request would be a shallow clone of my original context struct, I could access the user service from the middleware handler:

func (ctx *Context) VerifyUser(w web.ResponseWriter, r *web.Request) {
    if !ctx.UserService.IsValidUser(ctx.UserName, ctx.SessionId) {
        // error handling...
    }

As far as I can tell, the only way to access services from inside middleware right now is to use a global variable. This is a bit messy and not very composable. So unless I'm missing something and there already is a nice solution to this problem, I'd appreciate it if you would merge this.

Here is a snippet of a continuation of the nested routers and use of pointers with Context example from the docs: https://gist.github.com/bundah/d29cfc5fed6a6cb8428c

Removing the struct pointer for User and following same pattern in web.New yields less crash but still incorrect behaviour:

adminRouter := rootRouter.Subrouter(AdminContext{CurrentAdmin: User{Name: "Bill"}}, "/admin") // and also change the struct

And finally, if we change these bits to:

type AdminContext struct {
    *Context
    CurrentAdmin User
}

actx := AdminContext{CurrentAdmin: User{Name: "Bill"}}
adminRouter := rootRouter.Subrouter(actx, "/admin")
    adminRouter.Get("/reports", (actx).Reports) //(*AdminContext).Reports)

and curl that one, the name prints... Except that all requests now share actx instance and changing anywere at runtime via middleware etc crosses the request boundary (and can poison other requests).

Please advise...

The HTTP package in go has a Filesystem interface so that you don't have to back your server with a real fileserver.

In static_middleware.go, the string param type means that you can't use anything other than a real OS file; a call-path that accepted any http.Filesystem would let me use (e.g.) github.com/jteeuwen/go-bindata

Responses by the ShowErrorsMiddleware returned response code 200, which confused my JavaScript code. The attached commit sets a 500 response code, making sure the error can be correctly handled on the client-side.

package main

import (
	"fmt"
	"github.com/gocraft/web"
	"net/http"
)

type Context struct {
	HelloCount int
}

func (c *Context) Test(rw web.ResponseWriter, req *web.Request) {
	fmt.Println(c)

	fmt.Fprint(rw, req.PathParams["uid"])
}

func main() {
	router := web.New(Context{}).
		Get("/test/:uid", (*Context).Test)
	http.ListenAndServe("localhost:3000", router)
}

curl http://localhost:3000/test/web curl http://localhost:3000/test/web/ all return 200

int standart net/http

package main
import (
    "fmt"
    "net/http"
)
func main() {
    http.HandleFunc("/test/web", func (w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Welcome to my website!")
    })
   http.ListenAndServe(":8080", nil)
}

curl http://localhost:3000/test/web return 200 curl http://localhost:3000/test/web/ return 404

In some scenarios, it's handy to get the full path of an endpoint like this: curPath := "/path/to/resource" subRouter.Get(curPath, fn) fullPath := subRouter.PathPrefix() + curPath

Without public accessor, I have to pass sub-routers prefixes everywhere.

Hi folks,

I have a wrapper library around gocraft/web that is used for all of our micro services. I want all of these services to have a /_health endpoint. So I set up one by default when the object is instantiated.

I wanted to also have the ability for a service to pass in their own handler for this endpoint, when that happens, I want to remove the default created automatically, and replace it with the new one.

Is there a way in your code to remove a route and replace it with a new one? If not, any suggestions?

Thanks,

Hi Folks,

I've wrapped your package in a library for a set of web services that always return JSON data (except for one case, this one, when downloading a file). I set the Content-Type with a piece of middleware:

rRouter := &Router{}
rRouter.mDispatch = web.New(Context{})
rRouter.mDispatch.Middleware(func(rw web.ResponseWriter, r *web.Request, next web.NextMiddlewareFunc) {
	rw.Header().Set("Content-Type", "application/json; charset=utf-8")
	next(rw, r)
})

In one of my handlers, I want to override this for a file download:

rw.WriteHeader(201)
bytes := getContent(filename)
rw.Header().Set("Content-Type","application/pdf")
rw.Header().Set("Content-Disposition", "Attachment; filename="filename")
rw.Write(bytes)

When the endpoint is called, the content type comes down as application/json and not application/pdf as expected. I also have verified that the content type is set properly in the rw.Header map:

log.Printf("%+v", rw.Header())
    2018/06/13 21:08:03 map[Content-Type:[application/pdf]]

If I remove the middleware, this works fine. Any suggestions or insight as to what may be happening? Am I working with a copy of the rw var?

Thanks in advance.