func main() { mw := interpose.New() // Turn on output buffering. It's added first because it encapsulates all other output. // This enables headers to be written after data is sent, because they're all stored // in a buffer, so the user's browser will see everything in the order it expects. mw.Use(middleware.Buffer()) // Tell the browser our output will be JSON. Note that because this is added // before the router, we will write JSON headers AFTER the router starts // writing output to the browser! Usually this would mean that the header would // not get set correctly. However, because we are buffering (see below), // nothing will get sent to the browser until all output is finished rendering. // This means that the header will get set correctly. mw.Use(func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { w.Header().Set("Content-Type", "application/json") next.ServeHTTP(w, req) }) }) // Apply the router. router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) mw.UseHandler(router) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, mw) }
func main() { middle := interpose.New() // Tell the browser which server this came from. // This modifies headers, so we want this to be called before // any middleware which might modify the body (in HTTP, the headers cannot be // modified after the body is modified) middle.Use(func(next http.Handler) http.Handler { return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { rw.Header().Set("X-Server-Name", "Interpose Test Server") next.ServeHTTP(rw, req) }) }) // Apply the router. By adding it last, all of our other middleware will be // executed before the router, allowing us to modify headers before any // output has been generated. router := mux.NewRouter() middle.UseHandler(router) router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, middle) }
func main() { mw := interpose.New() // Set a random integer everytime someone loads the page mw.Use(context.ClearHandler) mw.Use(func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { c := rand.Int() fmt.Println("Setting ctx count to:", c) context.Set(req, CountKey, c) next.ServeHTTP(w, req) }) }) // Apply the router. router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { c, ok := context.GetOk(req, CountKey) if !ok { fmt.Println("Get not ok") } fmt.Fprintf(w, "Welcome to the home page, %s!\nCount:%d", mux.Vars(req)["user"], c) }) mw.UseHandler(router) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, mw) }
func main() { mw := interpose.New() // Use unrolled's secure framework // If you inspect the headers, you will see X-Frame-Options set to DENY // Must be called before the router because it modifies HTTP headers secureMiddleware := secure.New(secure.Options{ FrameDeny: true, }) mw.Use(secureMiddleware.Handler) // Apply the router. By adding it first, all of our other middleware will be // executed before the router, allowing us to modify headers before any // output has been generated. router := mux.NewRouter() mw.UseHandler(router) router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, mw) }
func main() { middle := interpose.New() // First apply any middleware that will not write output to http body // but which may (or may not) modify headers middle.Use(middleware.GorillaLog()) // Now apply any middleware that might modify the http body. This permits the // preceding middleware to alter headers router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) middle.UseHandler(router) http.ListenAndServe(":3001", middle) }
func main() { router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) middle := interpose.New() // Use Martini-Auth, a Martini library for basic HTTP authentication middle.Use(adaptors.FromMartini(auth.Basic("user", "basic"))) // Finally, add the router middle.UseHandler(router) // Now visit http://localhost:3001/guest and enter username "user" // and password "basic" http.ListenAndServe(":3001", middle) }
func main() { middle := interpose.New() // First apply any middleware that will not write output to http body // Log to stdout. Taken from Gorilla middle.Use(middleware.GorillaLog()) // Gzip output that follows. Taken from Negroni middle.Use(middleware.NegroniGzip(gzip.DefaultCompression)) // Now apply any middleware that modify the http body. router := mux.NewRouter() middle.UseHandler(router) router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) http.ListenAndServe(":3001", middle) }
func main() { router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) mw := interpose.New() // Use logrus x := negroni.Handler(negronilogrus.NewMiddleware()) mw.Use(adaptors.FromNegroni(x)) // Apply the router. By adding it last, all of our other middleware will be // executed before the router, allowing us to modify headers before any // output has been generated. mw.UseHandler(router) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, mw) }
func main() { mw := interpose.New() // Tell the browser our output will be JSON mw.Use(func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { w.Header().Set("Content-Type", "application/json") next.ServeHTTP(w, req) }) }) // Apply the router. Because HTTP requires that headers be modified before // the body, the JSON header function must be added to the middleware stack // before the router. router := mux.NewRouter() router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"]) }) mw.UseHandler(router) // Launch and permit graceful shutdown, allowing up to 10 seconds for existing // connections to end graceful.Run(":3001", 10*time.Second, mw) }
func welcomeHandler(rw http.ResponseWriter, req *http.Request) { fmt.Fprintf(rw, "Welcome to the home page, %s", mux.Vars(req)["name"]) }
func main() { middle := interpose.New() // Create a middleware that yields a global counter that increments until // the server is shut down. Note that this would actually require a mutex // or a channel to be safe for concurrent use. Therefore, this example is // unsafe. middle.Use(context.ClearHandler) middle.Use(func() func(http.Handler) http.Handler { c := 0 return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { c++ context.Set(req, CountKey, c) next.ServeHTTP(w, req) }) } }()) // Apply the router. router := mux.NewRouter() router.HandleFunc("/test/{user}", func(w http.ResponseWriter, req *http.Request) { c, ok := context.GetOk(req, CountKey) if !ok { fmt.Println("Context not ok") } fmt.Fprintf(w, "Hi %s, this is visit #%d to the site since the server was last rebooted.", mux.Vars(req)["user"], c) }) middle.UseHandler(router) http.ListenAndServe(":3001", middle) }