func main() { c, err := myrpc.Dial("tcp", checkEnv("VEIL_LISTENER")) check(err) h := handlers.New(&handlers.H{C: c}) r := mux.NewRouter() r.HandleFunc("/api/version", h.Version).Methods("GET") r.HandleFunc("/api/payloads", h.Payloads).Methods("GET") r.HandleFunc("/api/options", h.PayloadOptions).Methods("GET") r.HandleFunc("/api/generate", h.Generate).Methods("POST") n := negroni.New() n.Use(negroni.NewLogger()) n.Use(negroni.NewRecovery()) n.Use(negroni.NewStatic(http.Dir(checkEnv("VEIL_OUTPUT_DIR")))) n.Use(auth.Basic(checkEnv("ADMIN_USER"), checkEnv("ADMIN_PASS"))) n.Use(negroni.NewStatic(http.Dir("public"))) n.Use(negroni.HandlerFunc(func(w http.ResponseWriter, req *http.Request, next http.HandlerFunc) { if req.Method != "POST" { next(w, req) return } if !strings.Contains(req.Header.Get("content-type"), "application/json") { h.JSON400(w, errors.New("Content-Type must be application/json")) return } next(w, req) })) n.UseHandler(r) n.Run(checkEnv("SERVER_LISTENER")) }
func main() { router := mux.NewRouter() router.HandleFunc(xmlEndpoint+"/alerts", func(res http.ResponseWriter, req *http.Request) { res.Header().Set("Access-Control-Allow-Origin", "*") }).Methods("OPTIONS") //router.HandleFunc(xmlEndpoint+"/alerts", alertPost).Methods("POST") //router.HandleFunc(xmlEndpoint+"/alerts", alertsGet).Methods("GET") router.HandleFunc(xmlEndpoint+"/alerts/{id}", alertGet).Methods("GET") router.HandleFunc(jsonEndpoint+"/alerts", alertPostJson).Methods("POST") router.HandleFunc(jsonEndpoint+"/alerts", alertsGetJson).Methods("GET") router.HandleFunc(jsonEndpoint+"/alerts/{id}", alertGetJson).Methods("GET") // router.HandleFunc("/alerts/{id}", alertPost).Methods("POST") router.HandleFunc(xmlEndpoint+"/feed", getAtomFeed) //router.HandleFunc("/mdc", DrgHandler).Methods("GET") // router.HandleFunc("/", HomeHandler) n := negroni.New(negroni.NewRecovery(), NewLogger(), negroni.NewStatic(http.Dir("dist"))) n.UseHandler(router) n.Run(qcapListen) }
func newServer() *http.Server { n := negroni.New() // Middlewares if Settings["environments"].GetBool("log") { n.Use(negroni.NewLogger()) } n.UseFunc(recovery()) n.Use(negroni.NewStatic(http.Dir("./public"))) // Setup routes router := pat.New() router.Get("/api/v1/:env/driver/:ID", http.HandlerFunc(getDriverLocation)) //router.Post("/api/v1/<resource>", http.HandlerFunc(/*handle func*/)) // Add alive endpoint // router.Get("/alive", http.HandlerFunc(alive)) // Add the router action n.UseHandler(router) Server := &http.Server{ Addr: ":" + Settings["environments"].GetString("server.port"), Handler: n, ReadTimeout: 5 * time.Second, WriteTimeout: 5 * time.Second, MaxHeaderBytes: 1 << 20, } return Server }
// This function is called from main.go and from the tests // to create a new application. func NewApp(root string) *App { CheckEnv() // Use negroni for middleware ne := negroni.New() // Use gorilla/mux for routing ro := mux.NewRouter() // Use Render for template. Pass in path to templates folder // as well as asset helper functions. re := render.New(render.Options{ Directory: filepath.Join(root, "templates"), Layout: "layouts/layout", Extensions: []string{".html"}, Funcs: []template.FuncMap{AssetHelpers(root)}, }) // Establish connection to DB as specificed in database.go db := NewDB() // Add middleware to the stack ne.Use(negroni.NewRecovery()) ne.Use(negroni.NewLogger()) ne.Use(NewAssetHeaders()) ne.Use(negroni.NewStatic(http.Dir("public"))) ne.UseHandler(ro) // Return a new App struct with all these things. return &App{ne, ro, re, db} }
func serverRun(cmd *cobra.Command, args []string) { // MongoDB setup CreateUniqueIndexes() // Web Server Setup CreateStore() webRouter := CreateWebRouter() teamRouter := CreateTeamRouter() app := negroni.New() webRouter.PathPrefix("/").Handler(negroni.New( negroni.HandlerFunc(RequireLogin), negroni.Wrap(teamRouter), )) app.Use(negroni.NewLogger()) app.Use(negroni.NewStatic(http.Dir("static"))) app.Use(negroni.HandlerFunc(CheckSessionID)) app.UseHandler(webRouter) l := log.New(os.Stdout, "[negroni] ", 0) http_port := viper.GetString("server.http_port") https_port := viper.GetString("server.https_port") cert := viper.GetString("server.cert") key := viper.GetString("server.key") l.Printf("Server running at: https://%s:%s", viper.GetString("server.ip"), https_port) go http.ListenAndServe(":"+http_port, http.HandlerFunc(redir)) l.Fatal(http.ListenAndServeTLS(":"+https_port, cert, key, app)) }
func main() { cfg.MustLoad() listeningAddr := ":" + cfg.Server.Port router := mux.NewRouter().PathPrefix(cfg.Server.API.Prefix).Subrouter() db, err := pg.NewSession(cfg.DB.ConnectionURL()) if err != nil { log.Fatalf("Unable to connect to database: %s", err) } vars := map[string]interface{}{"db": db} err = ctx.Init(router, cfg.Server.API.PrivKey, cfg.Server.API.PubKey, vars) if err != nil { log.Fatalf("Unable to configure API: %s", err) } server := negroni.New( negroni.NewRecovery(), negroni.HandlerFunc(WebLogger), negroni.NewStatic(http.Dir(cfg.Server.Frontend.Path)), ) server.UseHandler(router) log.Infof("Listening on address: %s", listeningAddr) log.Fatal(http.ListenAndServe(listeningAddr, server)) }
func StartServer() { rest.P() // Log to file f, err := os.OpenFile("logs/arkeogis.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) if err != nil { log.Fatalf("Error opening log file: %v", err) } defer f.Close() log.SetOutput(f) // Configure Negroni and start server Negroni := negroni.New( negroni.NewRecovery(), negroni.HandlerFunc(crossDomainMiddleware), NewLogger(), negroni.NewStatic(http.Dir(config.WebPath)), ) Negroni.UseHandler(routes.MuxRouter) /* DEBUG SENDING MAIL fmt.Println("SENDING MAIL") errrr := mail.Send([]string{"*****@*****.**"}, "pouet", "poeut", "fr") if errrr != nil { log.Println(errors.ErrorStack(errrr)) } fmt.Println("starting web server...") */ Negroni.Run(":" + strconv.Itoa(config.Main.Server.Port)) }
func configureHttpAndListen(config *AppConfig, db gorm.DB) { // register routes r := render.New(render.Options{}) h := DBHandler{db: &db, r: r} router := mux.NewRouter() router.HandleFunc("/api/schedules", h.schedulesIndexHandler).Methods("GET") router.HandleFunc("/api/schedules", h.scheduleCreateHandler).Methods("POST") router.HandleFunc("/api/schedules/{id:[0-9]+}", h.scheduleShowHandler).Methods("GET") router.HandleFunc("/api/schedules/{id:[0-9]+}", h.scheduleUpdateHandler).Methods("PUT", "PATCH") router.HandleFunc("/api/schedules/{id:[0-9]+}", h.scheduleDeleteHandler).Methods("DELETE") router.HandleFunc("/api/cards", h.cardsIndexHandler).Methods("GET") router.HandleFunc("/api/cards", h.cardCreateHandler).Methods("POST") router.HandleFunc("/api/cards/{id:[0-9]+}", h.cardShowHandler).Methods("GET") router.HandleFunc("/api/cards/{id:[0-9]+}", h.cardUpdateHandler).Methods("PUT", "PATCH") router.HandleFunc("/api/cards/{id:[0-9]+}", h.cardDeleteHandler).Methods("DELETE") router.HandleFunc("/api/logs", h.logsIndexHandler).Methods("GET") n := negroni.New( negroni.NewRecovery(), negroni.NewStatic(http.Dir(config.AssetPath)), ) n.Use(auth.Basic(config.Authentication.Username, config.Authentication.Password)) n.UseHandler(router) n.Run(":" + config.Port) }
func NewApp() *App { db := newDB() // Use negroni for middleware ne := negroni.New( negroni.NewRecovery(), negroni.NewLogger(), negroni.NewStatic(http.Dir("public")), ) // Use gorilla/mux for routing ro := mux.NewRouter() // Set StrictSlash to allow /things/ to automatically redirect to /things ro.StrictSlash(true) // Use Render for template. Pass in path to templates folder // as well as asset helper functions. re := render.New(render.Options{ Layout: "layouts/layout", Extensions: []string{".html"}, }) ne.UseHandler(ro) return &App{ne, ro, re, db} }
func main() { conf.Parse() restrict.ReadCryptoKey("keys/app.rsa") router := mux.NewRouter() router.HandleFunc("/users", GetUserHandler).Methods("GET") router.HandleFunc("/users/login", LoginHandler).Methods("POST") router.HandleFunc("/users/register", RegisterHandler).Methods("POST") router.HandleFunc("/classes", restrict.R(CreateClassHandler)).Methods("POST") router.HandleFunc("/classes", restrict.R(GetClassesHandler)).Methods("GET") router.HandleFunc("/classes/{class_id}/workshops", restrict.R(CreateWorkshopHandler)).Methods("POST") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}/pages", restrict.R(CreateWorkshopPageHandler)).Methods("POST") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}/pages", restrict.R(GetWorkshopPagesHandler)).Methods("GET") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}/pages/{page_id}/edit", restrict.R(EditPageHandler)).Methods("POST") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}", restrict.R(GetWorkshopHandler)).Methods("GET") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}", restrict.R(EditWorkshopHandler)).Methods("PUT") router.HandleFunc("/classes/{class_id}/workshops/{workshop_id}", restrict.R(DeleteWorkshopHandler)).Methods("DELETE") router.HandleFunc("/classes/{class_id}/workshops", restrict.R(GetWorkshopsHandler)).Methods("GET") router.HandleFunc("/classes/{class_id}/students", restrict.R(GetStudentHandler)).Methods("GET") router.HandleFunc("/classes/{class_id}/image", restrict.R(SetClassImageHandler)).Methods("POST") router.HandleFunc("/classes/{class_id}/admin/students", restrict.R(AddUserToClassHandler)).Methods("POST") n := negroni.New() n.Use(negroni.NewStatic(http.Dir("static"))) n.Use(negroni.NewLogger()) n.UseHandler(router) models.InitDB(*dbFile) http.ListenAndServe("localhost:8080", n) }
func main() { settings := evergreen.GetSettingsOrExit() if settings.Ui.LogFile != "" { evergreen.SetLogger(settings.Ui.LogFile) } db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(settings)) home := evergreen.FindEvergreenHome() userManager, err := auth.LoadUserManager(settings.AuthConfig) if err != nil { fmt.Println("Failed to create user manager:", err) os.Exit(1) } cookieStore := sessions.NewCookieStore([]byte(settings.Ui.Secret)) uis := ui.UIServer{ nil, // render settings.Ui.Url, // RootURL userManager, // User Manager *settings, // mci settings cookieStore, // cookiestore nil, // plugin panel manager } router, err := uis.NewRouter() if err != nil { fmt.Println("Failed to create router:", err) os.Exit(1) } webHome := filepath.Join(home, "public") functionOptions := ui.FuncOptions{webHome, settings.Ui.HelpUrl, true, router} functions, err := ui.MakeTemplateFuncs(functionOptions, settings.SuperUsers) if err != nil { fmt.Println("Failed to create template function map:", err) os.Exit(1) } uis.Render = render.New(render.Options{ Directory: filepath.Join(home, ui.WebRootPath, ui.Templates), DisableCache: !settings.Ui.CacheTemplates, Funcs: functions, }) err = uis.InitPlugins() if err != nil { fmt.Println("WARNING: Error initializing plugins:", err) } n := negroni.New() n.Use(negroni.NewStatic(http.Dir(webHome))) n.Use(ui.NewLogger()) n.Use(negroni.HandlerFunc(ui.UserMiddleware(userManager))) n.UseHandler(router) graceful.Run(settings.Ui.HttpListenAddr, requestTimeout, n) evergreen.Logger.Logf(slogger.INFO, "UI server cleanly terminated") }
func main() { n := negroni.Classic() n.Use(negroni.NewStatic(http.Dir("."))) // listen on port n.Run(":8080") }
func StaticPathFallback(path string) http.Handler { return negroni.New( negroni.NewStatic(http.Dir(path)), negroni.Wrap(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { r.URL.Path = "/" http.FileServer(http.Dir(path)).ServeHTTP(w, r) }))) }
func (srv *Server) setupNegroni() { srv.log.Debug("setting up negroni") srv.n = negroni.New() srv.n.Use(negroni.NewRecovery()) srv.n.Use(negronilogrus.NewMiddleware()) srv.n.Use(negroni.NewStatic(http.Dir("public"))) srv.n.UseHandler(srv.Router) }
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) } }
func main() { n := negroni.New( negroni.NewRecovery(), negroni.HandlerFunc(MyMiddleware), negroni.NewLogger(), negroni.NewStatic(http.Dir("public")), ) n.Run(":8080") }
func (self *Server) Serve() error { self.mux = http.NewServeMux() self.router = httprouter.New() self.RoutePrefix = strings.TrimSuffix(self.RoutePrefix, `/`) // load route handlers if err := self.LoadRoutes(); err != nil { return err } staticHandler := negroni.NewStatic(self.MountProxy) if self.RoutePrefix != DEFAULT_ROUTE_PREFIX { staticHandler.Prefix = self.RoutePrefix } self.mux.HandleFunc(`/_bindings`, func(w http.ResponseWriter, req *http.Request) { if req.URL.Path == `/_bindings` { if data, err := json.Marshal(self.Config.Bindings); err == nil { w.Header().Set(`Content-Type`, `application/json`) if _, err := w.Write(data); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } } else { http.Error(w, err.Error(), http.StatusInternalServerError) return } } }) // add custom http.Handlers to the mux for i, handler := range self.Handlers { log.Debugf("Setting up custom handler %d for pattern '%s'", i, handler.Pattern) self.mux.Handle(handler.Pattern, handler.Handler) } // add custom http.HandleFuncs to the mux for i, handleFunc := range self.HandleFuncs { log.Debugf("Setting up custom handler function %d for pattern '%s'", i, handleFunc.Pattern) self.mux.HandleFunc(handleFunc.Pattern, handleFunc.HandleFunc) } // fallback to httprouter (these are the routes defined in the configuration) self.mux.Handle(`/`, self.router) self.server = negroni.New() self.server.Use(negroni.NewRecovery()) self.server.Use(staticHandler) self.server.Use(negroni.Wrap(self.mux)) self.server.Run(fmt.Sprintf("%s:%d", self.Address, self.Port)) return nil }
func main() { log.Println("Starting...") runtime.GOMAXPROCS(runtime.NumCPU()) r := mux.NewRouter() r.HandleFunc("/socket", func(w http.ResponseWriter, req *http.Request) { conn, err := upgrader.Upgrade(w, req, nil) if err != nil { log.Println(err) return } conns = append(conns, conn) }) r.Methods("POST").Path("/switch-mode").HandlerFunc(func(w http.ResponseWriter, req *http.Request) { var post PostBodySwitchMode dec := json.NewDecoder(req.Body) err := dec.Decode(&post) if err != nil { log.Println(err) http.Error(w, err.Error(), http.StatusInternalServerError) return } switchMode(post.Mode, post.Address) }) n := negroni.New( negroni.NewRecovery(), negroni.NewLogger(), negroni.NewStatic(rice.MustFindBox("public").HTTPBox()), ) n.UseHandler(r) listen := os.Getenv("LISTEN") if listen == "" { listen = ":3000" } lineCh = make(chan string, 32) go func() { for line := range lineCh { for _, conn := range conns { err := conn.WriteMessage(websocket.TextMessage, []byte(line)) if nil != err { log.Println(err) } } } }() n.Run(listen) }
func main() { dir, err := filepath.Abs(filepath.Dir(os.Args[0])) must(err) distBase := filepath.Join(dir, "..") port := flag.Uint("port", 8080, "port to listen on") templateDir := flag.String("templateDir", filepath.Join(distBase, "web", "templates"), "path to html templates") storeDir := flag.String("storeDir", filepath.Join(distBase, "db"), "directory for saving persistent data") buildsDir := flag.String("buildsDir", filepath.Join(distBase, "builds"), "directory for saving build output") assetsDir := flag.String("assetsDir", filepath.Join(distBase, "web", "assets"), "path to static web assets") gooseCmd := flag.String("gooseCmd", filepath.Join(distBase, "bin", "goose"), `path to "goose" database migration tool`) debugMode := flag.Bool("debugMode", false, "do not parse templates up front. Only for development use") flag.Parse() bootMsg := ` _ _ _ _ _____ _____ | | | | | | | / __ \_ _| | | | | ___ ___ __| | |__ ___ _ _ ___ ___ ______| / \/ | | | |/\| |/ _ \ / _ \ / _` + "`" + ` | '_ \ / _ \| | | / __|/ _ \______| | | | \ /\ / (_) | (_) | (_| | | | | (_) | |_| \__ \ __/ | \__/\_| |_ \/ \/ \___/ \___/ \__,_|_| |_|\___/ \__,_|___/\___| \____/\___/ ` fmt.Println(bootMsg) if *debugMode { log.Println("Starting in debug mode") } dbDir := filepath.Join(*storeDir, "sqlite") must(os.MkdirAll(dbDir, 0755)) migrateCmd := exec.Command(*gooseCmd, "up") migrateCmd.Dir = filepath.Join(*storeDir, "..") must(migrateCmd.Run()) jobRepo, err := db.NewJobRepository(filepath.Join(dbDir, "store.db")) must(err) // Only Interrupt handled, as this is available on all major platforms and is the most common way of stopping Woodhouse-CI exitChan := make(chan os.Signal) signal.Notify(exitChan, os.Interrupt) go func(c <-chan os.Signal) { log.Printf("Caught signal %s. Closing database connections. Goodbye!\n", <-c) must(jobRepo.Close()) os.Exit(0) }(exitChan) handler := web.New(&jobs.Service{ JobRepository: jobRepo, Runner: runner.NewDockerRunner(vcs.GitCloner{}), BuildRepository: builds.NewRepository(*buildsDir), }, *templateDir, !*debugMode) server := negroni.New(negroni.NewRecovery(), negroni.NewLogger(), negroni.NewStatic(http.Dir(*assetsDir))) server.UseHandler(handler) server.Run(fmt.Sprintf("0.0.0.0:%d", *port)) }
func main() { tb := thunderbird.New() ch := &RoomChannel{tb} tb.HandleChannel("room", ch) router := mux.NewRouter() router.HandleFunc("/", serveHome).Methods("GET") router.Handle("/ws", tb.HTTPHandler()) n := negroni.New( negroni.NewRecovery(), negroni.NewLogger(), negroni.NewStatic(http.Dir("../client/lib")), // serve thunderbird.js negroni.NewStatic(http.Dir("public")), // serve other assets ) n.UseHandler(router) n.Run(":" + os.Getenv("PORT")) }
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") }
func main() { n := negroni.New() n.Use(negronilogrus.NewMiddleware()) n.Use(negroni.NewStatic(http.Dir("public"))) render := render.New(render.Options{}) renderer := context.NewRender(render) n.Use(renderer) n.UseHandler(router.API()) go handlers.Hub.Run() n.Run(":3000") }
func main() { ren := render.New(render.Options{ Layout: "shared/layout", IsDevelopment: true, }) //sessions store := cookiestore.New([]byte("secret")) //db // db, err := sqlx.Connect("postgres", os.Getenv("CONNECTIONSTRING")) db, err := sqlx.Connect("postgres", "user=travisjones dbname=cm_app sslmode=disable") if err != nil { log.Println("Error initializing database...") log.Fatalln(err) } c := ctx{db, ren} n := negroni.New() nauth := negroni.New() //routers router := mux.NewRouter() authRouter := mux.NewRouter() //AUTHORIZED ROUTES authRouter.HandleFunc("/", c.Home) router.Handle("/", nauth).Methods("GET") //OPEN ROUTES router.HandleFunc("/account/login", c.Login).Methods("GET") router.HandleFunc("/account/login", c.LoginPost).Methods("POST") router.HandleFunc("/account/signup", c.Signup).Methods("GET") router.HandleFunc("/account/signup", c.SignupPost).Methods("POST") router.HandleFunc("/account/logout", c.Logout).Methods("GET") //Middleware nauth.Use(negroni.HandlerFunc(RequireAuth)) nauth.UseHandler(authRouter) //Sessions n.Use(sessions.Sessions("authex", store)) n.Use(negroni.NewStatic(http.Dir("public"))) n.UseHandler(router) n.Run( fmt.Sprint(":", os.Getenv("PORT")), ) }
// New returns a new Handler instance. func New(dir string) *Handler { if dir == "" { dir = DefaultDirectory } s := negroni.NewStatic(http.Dir(dir)) s.IndexFile = "" return &Handler{ Dir: dir, Index: DefaultIndex, static: s, } }
func main() { store := cookiestore.New([]byte("secretkey789")) router := LoadRoutes() n := negroni.Classic() static := negroni.NewStatic(http.Dir("static")) static.Prefix = "/static" n.Use(static) n.Use(negroni.HandlerFunc(MgoMiddleware)) n.Use(sessions.Sessions("global_session_store", store)) n.UseHandler(router) n.Run(":3000") }
func Start() { r := mux.NewRouter().StrictSlash(true) r.NotFoundHandler = http.HandlerFunc(errorHandler) /* * * ROUTES */ r.HandleFunc("/", mainPageHandler) r.HandleFunc("/upload", uploadHandler) r.HandleFunc("/apps", appsPageHandler) r.HandleFunc("/favicon.ico", favIcoHandler) r.HandleFunc("/img/{id}", imageHandler) r.HandleFunc("/{id}", imagePageHandler) r.HandleFunc("/api/upload", apiUploadHandler) r.HandleFunc("/error", errorHandler) n := negroni.New( negroni.NewRecovery(), negroni.HandlerFunc(MiddleWare), negroni.NewLogger(), negroni.NewStatic(http.Dir(os.Getenv("APP_LOCATION"))), negroni.NewStatic(http.Dir("public")), ) n.UseHandler(r) go func(n http.Handler) { cio.PrintMessage(0, "https: Running on port 8001...") err := http.ListenAndServeTLS(":8001", "http/ssl/cert.pem", "http/ssl/key.pem", n) if err != nil { log.Fatal(err) } }(n) cio.PrintMessage(0, "http: Running on port 8000...") http.ListenAndServe(":8000", n) }
func main() { settings := evergreen.GetSettingsOrExit() home := evergreen.FindEvergreenHome() uis, err := ui.New(settings, home) if err != nil { fmt.Println("Failed to create ui server: %v", err) os.Exit(1) } router, err := uis.NewRouter() if err != nil { fmt.Println("Failed to create router:", err) os.Exit(1) } webHome := filepath.Join(uis.Home, "public") functionOptions := ui.FuncOptions{webHome, uis.Settings.Ui.HelpUrl, true, router} functions, err := ui.MakeTemplateFuncs(functionOptions, uis.Settings.SuperUsers) htmlFunctions := htmlTemplate.FuncMap(functions) textFunctions := textTemplate.FuncMap(functions) if err != nil { fmt.Println("Failed to create template function map:", err) os.Exit(1) } uis.Render = render.New(render.Options{ Directory: filepath.Join(uis.Home, ui.WebRootPath, ui.Templates), DisableCache: !uis.Settings.Ui.CacheTemplates, HtmlFuncs: htmlFunctions, TextFuncs: textFunctions, }) err = uis.InitPlugins() if err != nil { fmt.Println("WARNING: Error initializing plugins:", err) } n := negroni.New() n.Use(negroni.NewStatic(http.Dir(webHome))) n.Use(ui.NewLogger()) n.Use(negroni.HandlerFunc(ui.UserMiddleware(uis.UserManager))) n.UseHandler(router) graceful.Run(uis.Settings.Ui.HttpListenAddr, requestTimeout, n) evergreen.Logger.Logf(slogger.INFO, "UI server cleanly terminated") }
func newServerStack(engine *engine.Engine) *negroni.Negroni { context := handlers.NewContext(engine) router := mux.NewRouter().StrictSlash(true) router.HandleFunc("/", context.IndexHandler).Methods("GET") router.HandleFunc("/execute", context.ExecuteHandler).Methods("POST") router.HandleFunc("/executews", context.ExecuteWSHandler).Methods("GET") router.HandleFunc("/info", context.InfoHandler).Methods("GET") server := negroni.New(xrequestid.New(16), context, negronilogrus.NewCustomMiddleware(logrus.InfoLevel, &logrus.JSONFormatter{}, "straitjacket"), cors.Default(), negroni.NewStatic(http.Dir("public"))) server.UseHandler(router) return server }
func main() { port := os.Getenv("PORT") if port == "" { port = "8080" } // Middleware stack n := negroni.New( negroni.NewRecovery(), negroni.HandlerFunc(LetMeGoogleThatForYou), negroni.HandlerFunc(MyMiddleware), negroni.NewLogger(), negroni.NewStatic(http.Dir("public")), ) n.Run(":" + port) }
func startServer(context Context) { mux := http.NewServeMux() mux.HandleFunc("/status", StatusHandler) server := negroni.New() server.Use(negroni.NewRecovery()) server.Use(logger.NewMiddlewareLogger(context.lg)) server.Use(negroni.NewStatic(http.Dir("staging"))) server.UseHandler(mux) p := fmt.Sprintf(":%d", context.port) context.lg.Info("starting server at port: %s", p) server.Run(p) }