// RunServer runs the app func RunServer() error { cnf, db, err := initConfigDB(true, true) if err != nil { return err } defer db.Close() if err := initServices(cnf, db); err != nil { return err } // Start a classic negroni app app := negroni.New() app.Use(negroni.NewRecovery()) app.Use(negroni.NewLogger()) app.Use(gzip.Gzip(gzip.DefaultCompression)) app.Use(negroni.NewStatic(http.Dir("public"))) // Create a router instance router := mux.NewRouter() // Add routes healthService.RegisterRoutes(router, "/v1") oauthService.RegisterRoutes(router, "/v1/oauth") webService.RegisterRoutes(router, "/web") // Set the router app.UseHandler(router) // Run the server on port 8080, gracefully stop on SIGTERM signal graceful.Run(":8080", 5*time.Second, app) return nil }
func main() { // Load the configuration. err := envconfig.Process("elwinar", &configuration) if err != nil { log.Fatalln("unable to read the configuration from env:", err) } // Open the database connection. database, err = sqlx.Connect("sqlite3", configuration.Database) if err != nil { log.Fatalln("unable to open the database:", err) } // Initialize the router. router := httprouter.New() // Add the front-office handlers. router.GET("/", Index) router.GET("/read", List) router.GET("/article/:slug", View) router.GET("/fortune", Fortune) router.GET("/sitemap.xml", Sitemap) // Add the back-office handlers. router.GET("/login", Login) router.POST("/login", Authenticate) router.GET("/logout", Logout) router.GET("/write", Write) router.POST("/write", Create) router.GET("/article/:slug/edit", Edit) router.POST("/article/:slug/edit", Update) router.GET("/article/:slug/delete", Delete) router.GET("/article/:slug/publish", Publish) router.GET("/article/:slug/unpublish", Unpublish) // Initialize the server middleware stack. stack := negroni.New() stack.Use(gzip.Gzip(gzip.DefaultCompression)) stack.Use(negroni.NewRecovery()) stack.Use(negroni.NewStatic(http.Dir(configuration.Public))) stack.Use(sessions.Sessions("elwinar", cookiestore.New([]byte(configuration.Secret)))) stack.UseHandler(router) // Initialize the HTTP server. server := &graceful.Server{ Timeout: 1 * time.Second, Server: &http.Server{ Addr: fmt.Sprintf(":%d", configuration.Port), Handler: stack, }, } // Run the server. err = server.ListenAndServe() if err != nil { log.Fatalln("unable to run the server:", err) } }
// RunServer runs the app func RunServer() error { cnf, db, err := initConfigDB(true, true) if err != nil { return err } defer db.Close() // Initialise the health service healthService := health.NewService(db) // Initialise the oauth service oauthService := oauth.NewService(cnf, db) // Initialise the email service emailService := email.NewService(cnf) // Initialise the accounts service accountsService := accounts.NewService( cnf, db, oauthService, emailService, nil, // accounts.EmailFactory ) // Initialise the facebook service facebookService := facebook.NewService( cnf, db, accountsService, nil, // facebook.Adapter ) // Start a negroni app app := negroni.New() app.Use(negroni.NewRecovery()) app.Use(negroni.NewLogger()) app.Use(gzip.Gzip(gzip.DefaultCompression)) // Create a router instance router := mux.NewRouter() // Register routes healthService.RegisterRoutes(router, "/v1") oauthService.RegisterRoutes(router, "/v1/oauth") accountsService.RegisterRoutes(router, "/v1") facebookService.RegisterRoutes(router, "/v1/facebook") // Set the router app.UseHandler(router) // Run the server on port 8080, gracefully stop on SIGTERM signal graceful.Run(":8080", 5*time.Second, app) return nil }
func buildMiddlewareStack(conf *Conf) *negroni.Negroni { stack := negroni.New() // Recover from panics and send them up to Rollbar. stack.Use(middleware.NewRecovery()) // Gzip-compress responses if requested. stack.Use(gzip.Gzip(gzip.DefaultCompression)) return stack }
func main() { r := mux.NewRouter() r.HandleFunc("/"+config.Secret, WebhookHandler).Methods("POST") http.Handle("/", r) n := negroni.Classic() n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(r) n.Run(config.ListenAddress) }
func main() { router := mux.NewRouter() router.HandleFunc("/black-and-gray", ShowCars) n := negroni.New() n.Use(negroni.NewLogger()) // include the gzip middleware above any other middleware that alters response body n.Use(gzip.Gzip(gzip.DefaultCompression)) n.Use(negroni.NewRecovery()) n.Use(negroni.NewStatic(http.Dir("public"))) n.UseHandler(router) n.Run(":8888") }
// NewApp returns a pointer to an application instance. These // instances have reasonable defaults and include middleware to: // recover from panics in handlers, log information about the request, // and gzip compress all data. Users must specify a default version // for new methods. func NewApp() *APIApp { a := &APIApp{ StrictSlash: true, defaultVersion: -1, // this is the same as having no version prepended to the path. port: 3000, } a.AddMiddleware(negroni.NewRecovery()) a.AddMiddleware(NewAppLogger()) a.AddMiddleware(gzip.Gzip(gzip.DefaultCompression)) return a }
func main() { r := render.New(render.Options{ Layout: "layout", }) mux := httprouter.New() mux.GET("/", func(w http.ResponseWriter, req *http.Request, _ httprouter.Params) { r.HTML(w, http.StatusOK, "index", nil) }) n := negroni.Classic() n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(mux) graceful.Run(":"+os.Getenv("PORT"), 10*time.Second, n) }
func main() { router := mux.NewRouter() router.HandleFunc("/routes/{route}", api.Stops) router.HandleFunc("/routes", api.AllStops) router.HandleFunc("/vehicles/{route}", api.Vehicles) router.HandleFunc("/vehicles", api.AllVehicles) n := negroni.New() n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(cors.Default().Handler(router)) go jobs.RunFetch() go jobs.RunExpire() n.Run(":8048") }
func New() http.Handler { // set up handlers http.HandleFunc("/1/setpoint.json", makeHandler(setpointHandler)) http.HandleFunc("/1/sleep.json", makeHandler(sleepHandler)) http.HandleFunc("/1/smooth.json", makeHandler(smoothHandler)) http.HandleFunc("/1/setpid.json", makeHandler(setpidHandler)) http.Handle("/1/data.json", negroni.New( gzip.Gzip(gzip.DefaultCompression), negroni.Wrap(makeHandler(dataHandler)), )) // use negroni n := negroni.New(negroni.NewRecovery(), negroni.NewLogger()) n.UseHandler(http.DefaultServeMux) return http.Handler(n) }
// RunServer runs the app func RunServer() error { cnf, db, err := initConfigDB(true, true) defer db.Close() if err != nil { return err } // Initialise the health service healthService := health.NewService(db) // Initialise the oauth service oauthService := oauth.NewService(cnf, db) // Initialise the web service webService := web.NewService(cnf, oauthService) // Start a classic negroni app app := negroni.New() app.Use(negroni.NewRecovery()) app.Use(negroni.NewLogger()) app.Use(gzip.Gzip(gzip.DefaultCompression)) app.Use(negroni.NewStatic(http.Dir("public"))) // Create a router instance router := mux.NewRouter() // Add routes for the health service (healthcheck endpoint) health.RegisterRoutes(router, healthService) // Add routes for the oauth service (REST tokens endpoint) oauth.RegisterRoutes(router, oauthService) // Add routes for the web package (register, login authorize web pages) web.RegisterRoutes(router, webService) // Set the router app.UseHandler(router) // Run the server on port 8080 app.Run(":8080") return nil }
func configRoutes(dbh *db.Handle) *negroni.Negroni { r := mux.NewRouter().PathPrefix(webroot).Subrouter() r.HandleFunc("/api", capsHandler).Queries("t", "caps") r.HandleFunc("/api", searchHandler).Queries("t", "search") r.HandleFunc("/api", tvSearchHandler).Queries("t", "tvsearch") r.HandleFunc("/getnzb", nzbDownloadHandler) r.HandleFunc("/", homeHandler) n := negroni.Classic() n.Use(gzip.Gzip(gzip.DefaultCompression)) c := cors.New(cors.Options{ AllowedOrigins: []string{"*"}, }) n.Use(negronilogrus.NewCustomMiddleware(logrus.DebugLevel, &logrus.JSONFormatter{}, "web")) n.Use(c) n.Use(dbMiddleware(dbh)) n.UseHandler(r) return n }
func makeHandler() http.Handler { router := httprouter.New() GET(router, "/", HandleIndex) GET(router, "/auth/user", HandleAuthUser) POST(router, "/auth/login", HandleLogin) POST(router, "/auth/register", HandleRegister) POST(router, "/auth/logout", HandleLogout) POST(router, "/auth/stripe", Authed(HandleUpdateStripe)) POST(router, "/model/create", Authed(HandleCreateModel)) GET(router, "/user/username/:username", HandleUserByUsername) GET(router, "/models/username/:username", HandleModelsByUsername) GET(router, "/models/public/latest", HandleLatestPublicModels) GET(router, "/models/public/top/:period", HandleTopPublicModels) GET(router, "/model/username/:username/slug/:slug", HandleModelByUsernameAndSlug) POST(router, "/model/id/:id/readme", Authed(HandleUpdateModelReadme)) POST(router, "/model/id/:id/deleted", Authed(HandleDeleteModel)) POST(router, "/file/:username/:slug/:framework/:filename", Authed(HandleFileUpload)) GET(router, "/file/:username/:slug/:framework/:filename", HandleFile) GET(router, "/file-id/:id", HandleFileById) GET(router, "/file-versions/:username/:slug/:framework/:filename", HandleFileVersions) GET(router, "/model/username/:username/slug/:slug/latest-files", HandleLatestFilesByUsernameAndSlug) n := negroni.New(negroni.NewLogger()) // In production, redirect all traffic to https (except /, for LB health check) if utils.Conf.Production { n.UseHandlerFunc(func(rw http.ResponseWriter, r *http.Request) { if r.URL.Path != "/" && r.Header.Get("X-Forwarded-Proto") != "https" { http.RedirectHandler( "https://"+r.Host+r.URL.RequestURI(), http.StatusFound, ).ServeHTTP(rw, r) } }) } n.Use(gzip.Gzip(gzip.BestCompression)) n.Use(negronilogrus.NewMiddleware()) n.UseHandler(router) return n }
func (a *API) Serve(addr string) { router := mux.NewRouter() v1 := router.PathPrefix("/1").Subrouter() // tasks tasksHandler := TasksHandler{a.store.Tasks()} task := v1.PathPrefix("/tasks/{id}").Subrouter() task.Methods("GET").HandlerFunc(tasksHandler.Get) task.Methods("PUT").HandlerFunc(tasksHandler.Set) task.Methods("DELETE").HandlerFunc(tasksHandler.Delete) task.Methods("POST", "PATCH").HandlerFunc(MethodNotAllowed) tasks := v1.PathPrefix("/tasks").Subrouter() tasks.Methods("GET").HandlerFunc(tasksHandler.List) tasks.Methods("POST").HandlerFunc(tasksHandler.Set) tasks.Methods("PUT", "DELETE", "PATCH").HandlerFunc(MethodNotAllowed) // events eventsHandler := EventsHandler{a.store.Events(), a.Events} event := v1.PathPrefix("/events/{id}").Subrouter() event.Methods("GET").HandlerFunc(eventsHandler.Get) event.Methods("PUT", "POST", "DELETE", "PATCH").HandlerFunc(MethodNotAllowed) events := v1.PathPrefix("/events").Subrouter() events.Methods("GET").HandlerFunc(eventsHandler.List) events.Methods("POST").HandlerFunc(eventsHandler.Create) events.Methods("PUT", "DELETE", "PATCH").HandlerFunc(MethodNotAllowed) // set up event handlers n := negroni.New() n.Use(negroni.NewRecovery()) n.Use(negronilogrus.NewMiddleware()) n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(router) logrus.WithField("addr", addr).Info("listening") graceful.Run(addr, 10*time.Second, n) }
func main() { // Parse flags parseFlags() // New logger l := log.New(os.Stdout, "[actions-store] ", 0) // If database url is empty its a fatal error if database == "" { l.Fatal("Database url can not be empty. Use `-database` flag or `MONGO_URL` environment variable.") } // Set database url err := models.SetDatabase(database) if err != nil { l.Fatal(err) } // Todo: authentication n := negroni.Classic() n.Use(negroni.HandlerFunc(corsMiddleware)) n.Use(gzip.Gzip(gzip.DefaultCompression)) // Bind actions REST api n.UseHandler(routes.Router) // Start JSON-RPC server go func() { l.Printf("rpc listening on %s", rpcaddress) err := rpc.Listen(rpcaddress) if err != nil { panic(err) } }() // Start HTTP server l.Printf("listening on %s", address) l.Fatal(http.ListenAndServe(address, n)) }
func main() { var httpPort = flag.Int("port", 8080, "port to listen on for HTTP") var dbHost = flag.String("dbhost", "localhost:27017", "host/port to connect to DB server") flag.Parse() session, err := mgo.Dial(*dbHost) if err != nil { fmt.Println(err) return } lk := logkeeper.New(session, logkeeper.Options{ DB: "buildlogs", URL: fmt.Sprintf("http://localhost:%v", *httpPort), }) router := lk.NewRouter() n := negroni.Classic() n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(router) graceful.Run(fmt.Sprintf(":%v", *httpPort), 10*time.Second, n) }
func main() { // Load configuration // TODO: How to share this config with the handlers? configuration, err := config.Load("./config.json") if err != nil { log.Fatal(err) } // Setup middleware middle := negroni.Classic() middle.Use(gzip.Gzip(gzip.DefaultCompression)) store := cookiestore.New([]byte("keyboard cat")) middle.Use(sessions.Sessions("tvtio", store)) // Setup router router := httprouter.New() router.GET("/", routes.Index) router.GET("/search", routes.Search) router.GET("/movie/:id", routes.Movie) router.GET("/tv/:id", routes.TV) router.GET("/person/:id", routes.Person) router.GET("/about", routes.About) router.GET("/login", routes.Login) router.GET("/logout", routes.Logout) router.GET("/auth/twitter", routes.AuthTwitter) router.GET("/auth/facebook", routes.AuthFacebook) router.GET("/auth/facebook/callback", routes.AuthFacebookCallback) router.ServeFiles("/css/*filepath", http.Dir(configuration.Templates+"/css")) router.ServeFiles("/js/*filepath", http.Dir(configuration.Templates+"/js")) router.ServeFiles("/img/*filepath", http.Dir(configuration.Templates+"/img")) middle.UseHandler(router) // Start server fmt.Println("Listening at " + configuration.ServerURL()) log.Fatal(http.ListenAndServe(configuration.ServerAddress(), middle)) }
func main() { // render ren := render.New(render.Options{ Layout: "shared/layout", IndentJSON: true, IsDevelopment: false, }) //init db db, err := sqlx.Connect("mysql", "root:slurp@tcp(127.0.0.1:3306)/sfs") if err != nil { log.Print(err) log.Print("Error initializing database...") } defer db.Close() // setup context c := ctx{db, ren} // setup negroni n := negroni.New() // setup router router := mux.NewRouter() // routes router.HandleFunc("/", c.NewSupporter).Methods("GET") router.HandleFunc("/", c.NewSupporterPost).Methods("POST") router.HandleFunc("/love", c.ShowSupporters).Methods("GET") //n.Use(NewRecovery(false)) n.Use(gzip.Gzip(gzip.DefaultCompression)) n.Use(negroni.NewStatic(http.Dir("public"))) n.UseHandler(router) n.Run(fmt.Sprint(":", os.Getenv("PORT"))) }
func main() { common.Initvars() common.Setupdb() // common.Setupspellchecker() // TODO: Setup shutdown when server is given a signal - see common.SetupShutdown defer common.Shutdown() // fmt.Println(common.Spk.SuggestSpelling("artointestinal")) // fmt.Println(common.Spk.CheckText("Myocariel Infraction")) n := negroni.Classic() n.Use(gzip.Gzip(gzip.DefaultCompression)) n.Use(negroni.NewRecovery()) n.Use(negroni.NewLogger()) mux := http.NewServeMux() mux.Handle("/", http.FileServer(http.Dir(common.Siteroot))) mux.HandleFunc("/snomed/searchterm", handlers.Snomedsearchterm) mux.HandleFunc("/loinc/searchterm", handlers.Loincsearchterm) n.UseHandler(mux) fmt.Println("Ontoserver Started") n.Run(":80") }
func main() { mainServer := negroni.New() // Token auth middleware tokenVerification := handlers.NewTokenVerificationMiddleware() tokenVerification.Initialize() mainServer.Use(negroni.NewRecovery()) mainServer.Use(negroni.NewLogger()) mainServer.Use(negroni.HandlerFunc(tokenVerification.Run)) mainServer.Use(gzip.Gzip(gzip.DefaultCompression)) // Create external service connections s := session.New() dynamoDBConnection := createDynamoDBConnection(s) geoLookup := geo.NewGoogleGeoLookup(os.Getenv("GOOGLE_API_KEY")) geoLookup.Initialize() deviceDatabase := db.NewDeviceDatabase(dynamoDBConnection, geoLookup) measurementsDatabase, err := createMeasurementsDatabaseConnection(deviceDatabase) if err != nil { fmt.Printf("Error connecting to InfluxDB: %s\n", err.Error()) return } // Initialize HTTP service handlers router := mux.NewRouter() handlers.InitializeRouterForSensorsDataRetrieval(router, deviceDatabase, measurementsDatabase) handlers.InitializeRouterForSensorHandler(router, deviceDatabase) mainServer.UseHandler(router) go mainServer.Run(":3000") // Run healthcheck service healthCheckServer := negroni.New() healthCheckRouter := mux.NewRouter() handlers.InitializeRouterForHealthCheckHandler(healthCheckRouter, dynamoDBConnection) healthCheckServer.UseHandler(healthCheckRouter) healthCheckServer.Run(":3100") }
func Gzip() Middleware { return gzip.Gzip(gzip.DefaultCompression) }
// WebApp creates the web application and YAML api for Tetra. func WebApp() { mux := routes.New() r := render.New(render.Options{}) mux.Get("/", func(res http.ResponseWriter, req *http.Request) { fmt.Fprintf(res, "error: No method chosen.") }) mux.Get("/info.json", func(w http.ResponseWriter, req *http.Request) { r.JSON(w, http.StatusOK, struct { Usercount int `json:"usercount"` Channelcount int `json:"channelcount"` }{ Usercount: len(Clients.ByNick), Channelcount: len(Channels), }) }) mux.Get("/channels.json", func(w http.ResponseWriter, req *http.Request) { var channels []channel for _, in := range Channels { if in.Modes&modes.PROP_SECRET != modes.PROP_SECRET { channels = append(channels, convertChannel(in)) } } r.JSON(w, http.StatusOK, channels) }) mux.Get("/clients.json", func(res http.ResponseWriter, req *http.Request) { var clients []client for _, in := range Clients.ByUID { myclient := convertClient(in) if len(myclient.Joins) == 0 { continue } clients = append(clients, myclient) } r.JSON(res, http.StatusOK, clients) }) mux.Get("/yo/:id", func(res http.ResponseWriter, req *http.Request) { params := req.URL.Query() id := params.Get(":id") username := req.URL.Query()["username"][0] RunHook("YO", username, id) RunHook("YO_"+id, username) fmt.Fprintf(res, "OK") }) port := os.Getenv("PORT") if port == "" { port = "3000" } Log.Printf("listening on %v...\n", port) go func() { n := negroni.New(negroni.NewRecovery(), negroni.NewStatic(http.Dir("public")), web.NewLogger()) n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(mux) err := http.ListenAndServe(":"+port, n) if err != nil { Services["tetra"].ServicesLog("Web app died") Services["tetra"].ServicesLog(err.Error()) Log.Fatal(err) } }() }
// apiRouter sets up the instance of negroni func apiRouter(apiKillChan chan struct{}) { log.Println("api: starting...") // Initialize negroni n := negroni.New() // Set up render r := render.New(render.Options{ // Output human-readable JSON/XML. GZIP will essentially negate the size increase, and this // makes the API much more developer-friendly IndentJSON: true, IndentXML: true, }) // GZIP all responses n.Use(gzip.Gzip(gzip.DefaultCompression)) // Initial API setup n.Use(negroni.HandlerFunc(func(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) { // Send a Server header with all responses res.Header().Set("Server", fmt.Sprintf("%s/%s (%s_%s)", App, Version, runtime.GOOS, runtime.GOARCH)) // Store render in context for all API calls context.Set(req, api.CtxRender, r) // Wrap HTTP request and response with metrics instrumentation req.Body = httpRMetricsLogger{req.Body} metricsRes := httpWMetricsLogger{res} // On debug, log everything if env.IsDebug() { log.Println(req.Header) log.Println(req.URL) // Wrap response in debug logging next(httpWDebugLogger{metricsRes}, req) return } // Delegate to next middleware next(metricsRes, req) return })) // Authenticate all API calls n.Use(negroni.HandlerFunc(func(res http.ResponseWriter, req *http.Request, next http.HandlerFunc) { // Use factory to determine and invoke the proper authentication method for this path user, session, clientErr, serverErr := auth.Factory(req.URL.Path).Authenticate(req) // Check for client error if clientErr != nil { // Check for a Subsonic error, since these are rendered as XML if subErr, ok := clientErr.(*subsonic.Container); ok { r.XML(res, 200, subErr) return } // If debug mode, and no username or password, send a WWW-Authenticate header to prompt request // This allows for manual exploration of the API if needed if env.IsDebug() && (clientErr == auth.ErrNoUsername || clientErr == auth.ErrNoPassword) { res.Header().Set("WWW-Authenticate", "Basic") } r.JSON(res, 401, api.ErrorResponse{ Error: &api.Error{ Code: 401, Message: "authentication failed: " + clientErr.Error(), }, }) return } // Check for server error if serverErr != nil { log.Println(serverErr) // Check for a Subsonic error, since these are rendered as XML if subErr, ok := serverErr.(*subsonic.Container); ok { r.XML(res, 200, subErr) return } r.JSON(res, 500, api.ErrorResponse{ Error: &api.Error{ Code: 500, Message: "server error", }, }) return } // Successful login, map session user and session to gorilla context for this request context.Set(req, api.CtxUser, user) context.Set(req, api.CtxSession, session) // Print information about this API call log.Printf("api: [%s] %s %s?%s", req.RemoteAddr, req.Method, req.URL.Path, req.URL.Query().Encode()) // Perform API call next(res, req) })) // Wait for graceful to signal termination gracefulChan := make(chan struct{}, 0) // Use gorilla mux with negroni, start server n.UseHandler(newRouter()) go func() { // Load config conf, err := config.C.Load() if err != nil { log.Println(err) return } // Check for empty host if conf.Host == "" { log.Fatalf("api: no host specified in configuration") } // Start server, allowing up to 10 seconds after shutdown for clients to complete log.Println("api: binding to host", conf.Host) if err := graceful.ListenAndServe(&http.Server{Addr: conf.Host, Handler: n}, 10*time.Second); err != nil { // Check if address in use if strings.Contains(err.Error(), "address already in use") { log.Fatalf("api: cannot bind to %s, is wavepipe already running?", conf.Host) } // Ignore error on closing if !strings.Contains(err.Error(), "use of closed network connection") { // Log other errors log.Println(err) } } // Shutdown complete close(gracefulChan) }() // Trigger events via channel for { select { // Stop API case <-apiKillChan: // If testing, don't wait for graceful shutdown if !env.IsTest() { // Block and wait for graceful shutdown log.Println("api: waiting for remaining connections to close...") <-gracefulChan } // Inform manager that shutdown is complete log.Println("api: stopped!") apiKillChan <- struct{}{} return } } }
func (l *Gzip) ServeHTTP(c context.Context, w http.ResponseWriter, r *http.Request) context.Context { return negroni.Middleware(negroniGzip.Gzip(l.compressionLevel)).ServeHTTP(c, w, r) }
func mindHTTP() { r := mux.NewRouter() r.HandleFunc("/v1.json", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/json") statsLock.Lock() defer statsLock.Unlock() enc := json.NewEncoder(w) enc.Encode(stats) }) r.HandleFunc("/v1/gt/{gamertag}.json", func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) enc := json.NewEncoder(w) statsLock.Lock() defer statsLock.Unlock() if v, ok := stats[vars["gamertag"]]; ok { w.Header().Set("Content-Type", "text/json") enc.Encode(v) } else { w.WriteHeader(http.StatusNotFound) } }) r.HandleFunc("/v1/slackid/{slackuid}.json", func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) enc := json.NewEncoder(w) statsLock.Lock() defer statsLock.Unlock() for _, v := range stats { if v.User.ID == vars["slackuid"] { w.Header().Set("Content-Type", "text/json") enc.Encode(v) return } } w.WriteHeader(http.StatusNotFound) }) r.HandleFunc("/v1/username/{slackusername}.json", func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) enc := json.NewEncoder(w) statsLock.Lock() defer statsLock.Unlock() for _, v := range stats { if v.User.UserName == vars["slackusername"] { w.Header().Set("Content-Type", "text/json") enc.Encode(v) return } } w.WriteHeader(http.StatusNotFound) }) r.HandleFunc("/v1/compact.json", func(w http.ResponseWriter, r *http.Request) { enc := json.NewEncoder(w) var out = struct { Index map[string]interface{} Stats []struct { User singleUser Stats map[string]string } }{ Stats: []struct { User singleUser Stats map[string]string }{}, } statsLock.Lock() for _, v := range stats { var entry = struct { User singleUser Stats map[string]string }{ User: v.User, Stats: map[string]string{}, } if out.Index == nil { out.Index = map[string]interface{}{} for _, s := range v.Stats { out.Index[s.Name] = s } } for _, s := range v.Stats { entry.Stats[s.Name] = s.Value.String() } out.Stats = append(out.Stats, entry) } statsLock.Unlock() w.Header().Set("Content-Type", "text/json") enc.Encode(out) }) n := negroni.New() n.Use(cors.New(cors.Options{AllowedOrigins: []string{"*"}})) n.Use(negroni.NewRecovery()) n.Use(negroni.NewLogger()) n.Use(gzip.Gzip(gzip.DefaultCompression)) n.UseHandler(r) n.Run(config.Listen) }
func NegroniGzip(compression int) func(http.Handler) http.Handler { return adaptors.FromNegroni(gzip.Gzip(compression)) }
// httpServer returns an http server func (s *Server) httpServer(log *logrus.Entry) *http.Server { addr := fmt.Sprintf("%s:%d", s.config.HTTPServer.Host, s.config.HTTPServer.Port) log.Debugf("http server will listen on: %s", addr) mux := mux.NewRouter() for _, route := range []struct { // name of the route name string // path of the route path string // allowed methods for this route methods string // handler is the http handler to run if the route matches handler func(http.ResponseWriter, *http.Request) // excluded tells if the route should be added to the router, // it's in the negative form so that the default behaviour is to add // the route to the router excluded bool }{ { name: "GetMovies", path: "/movies", methods: "GET", handler: s.movieIds, }, { name: "GetMovie", path: "/movies/{id}", methods: "GET", handler: s.getMovieDetails, }, { name: "DeleteMovie", path: "/movies/{id}", methods: "DELETE", handler: s.deleteMovie, }, { name: "DownloadMovie", path: "/movies/{id}/download", methods: "GET", handler: s.serveMovie, excluded: !s.config.HTTPServer.ServeFiles, }, { name: "GetShows", path: "/shows", methods: "GET", handler: s.showIds, }, { name: "GetShow", path: "/shows/{id}", methods: "GET", handler: s.getShowDetails, }, { name: "GetSeason", path: "/shows/{id}/seasons/{season:[0-9]+}", methods: "GET", handler: s.getSeasonDetails, }, { name: "GetEpisode", path: "/shows/{id}/seasons/{season:[0-9]+}/episodes/{episode:[0-9]+}", methods: "GET", handler: s.getShowEpisodeIDDetails, }, { name: "DeleteEpisode", path: "/shows/{id}/seasons/{season:[0-9]+}/episodes/{episode:[0-9]+}", methods: "DELETE", handler: s.deleteEpisode, }, { name: "DownloadEpisode", path: "/shows/{id}/seasons/{season:[0-9]+}/episodes/{episode:[0-9]+}/download", methods: "GET", handler: s.serveShow, excluded: !s.config.HTTPServer.ServeFiles, }, { name: "Wishlist", path: "/wishlist", methods: "GET", handler: s.wishlist, }, { name: "AddTorrent", path: "/torrents", methods: "POST", handler: s.addTorrent, }, } { if route.excluded { continue } // Register the route mux.HandleFunc(route.path, route.handler).Name(route.name).Methods(route.methods) } n := negroni.New() // Panic recovery n.Use(negroni.NewRecovery()) // Use logrus as logger n.Use(negronilogrus.NewMiddlewareFromLogger(s.log.Logger, "httpServer")) // gzip compression n.Use(gzip.Gzip(gzip.DefaultCompression)) // Add basic auth if configured if s.config.HTTPServer.BasicAuth { log.Info("server will require basic authentication") n.Use(NewBasicAuthMiddleware(s.config.HTTPServer.BasicAuthUser, s.config.HTTPServer.BasicAuthPassword)) } // Add token auth middleware if token configuration file specified if s.tokenManager != nil { n.Use(token.NewMiddleware(s.tokenManager, mux)) mux.HandleFunc("/tokens/allowed", s.tokenGetAllowed).Name("TokenGetAllowed") } // Wrap the router n.UseHandler(mux) return &http.Server{Addr: addr, Handler: n} }