func (g *gorai) Run() { if isConsole() { consoleHandler() return } cer, err := tls.LoadX509KeyPair(g.config.Framework.WebServerSSL.CtrFile, g.config.Framework.WebServerSSL.KeyFile) if err != nil { panic(err) } config := &tls.Config{Certificates: []tls.Certificate{cer}} server := &http.Server{ Addr: g.config.Framework.WebServer.Host + ":" + g.config.Framework.WebServer.Port, Handler: webReWriteHandler(), ReadTimeout: g.config.Framework.WebServer.ReadTimeout * time.Second, WriteTimeout: g.config.Framework.WebServer.WriteTimeout * time.Second, } serverSSL := &http.Server{ Addr: g.config.Framework.WebServerSSL.Host + ":" + g.config.Framework.WebServerSSL.Port, Handler: webHandler(), ReadTimeout: g.config.Framework.WebServerSSL.ReadTimeout * time.Second, WriteTimeout: g.config.Framework.WebServerSSL.WriteTimeout * time.Second, TLSConfig: config, } gracehttp.Serve(server, serverSSL) }
/* Run ... */ func (srv *Server) Run() { conf := config.GetConfig() port := int(conf.Port) logger.Info.Println("Server up and running on port: " + strconv.Itoa(port)) err := gracehttp.Serve(&http.Server{Addr: ":" + strconv.Itoa(port), Handler: srv}) utils.PanicOnError(err) }
func main() { var err error sentry, err = raven.NewClient(*sentryDSN, nil) if err != nil { log.Println("No sentry:", err) } restrict.ReadCryptoKey(*crypto) models.Init( *dbUser, *dbPass, *dbService, *dbPort, *dbName, ) go tunnel.NewRPCServer(messages, *rpcAddr, *rpcPort) go messageLoop() r := setupRouting() pool = setupZombies() log.Println(gracehttp.Serve( &http.Server{ Addr: *httpAddr + ":" + *httpPort, Handler: r, }, )) }
func ServeApi() { ApiServers := make([]*http.Server, len(utils.Cfg.ServerSettings.Ports)) for i, port := range utils.Cfg.ServerSettings.Ports { ApiServers[i] = newApiServer(port) } gracehttp.Serve(ApiServers...) }
func main() { wg := &sync.WaitGroup{} notificationBackend := backend.GetBackend(applicationConfig.BackendName) err := notificationBackend.Initialize(applicationConfig.BackendOpenString) if err != nil { logger.WithField("error", err).Panic("cannot initialize backend") } notificationBackend.Start(wg) defer func() { notificationBackend.Shutdown() wg.Wait() }() notificationBackend.BlockUntilReady() receiverApp := webreceiver.NewApp(notificationBackend, applicationConfig.Receiver) receiverServer := &http.Server{ Addr: fmt.Sprintf("%s:%d", applicationConfig.Receiver.ListenHost, applicationConfig.Receiver.ListenPort), Handler: receiverApp, } gracehttp.Serve(receiverServer) }
func main() { //runtime.GOMAXPROCS(runtime.NumCPU()) e := echo.New() e.Use(mw.Logger()) e.Use(mw.Recover()) e.Use(mw.Gzip()) e.Get("/", welcome) e.Get("/ping", ping) //// Start server //e.Run(":1323") // Get the http.Server s := e.Server(":8000") // HTTP2 is currently enabled by default in echo.New(). To override TLS handshake errors // you will need to override the TLSConfig for the server so it does not attempt to validate // the connection using TLS as required by HTTP2 s.TLSConfig = nil // Serve it like a boss log.Fatal(gracehttp.Serve(s)) }
func do() error { server, err := createServer() if err != nil { return err } glog.V(2).Infof("start server") return gracehttp.Serve(server) }
func do(writer io.Writer, address string, documentRoot string, dbPath string) error { dbPath, err := io_util.NormalizePath(dbPath) if err != nil { return err } gracehttp.Serve(createServer(address, documentRoot, dbPath)) return nil }
func main() { flag.Parse() gracehttp.Serve( &http.Server{Addr: *address0, Handler: newHandler("Zero ")}, &http.Server{Addr: *address1, Handler: newHandler("First ")}, &http.Server{Addr: *address2, Handler: newHandler("Second")}, ) }
func main() { e := echo.New() e.GET("/", func(c echo.Context) error { return c.String(http.StatusOK, "Six sick bricks tick") }) std := standard.New(":1323") std.SetHandler(e) gracehttp.Serve(std.Server) }
func mainImpl() error { port := flag.Int("port", 8010, "port number") notLocal := flag.Bool("all", false, "listen on all IPs, not just localhost") cwd, _ := os.Getwd() root := flag.String("root", filepath.Join(cwd, "repos"), "checkout root dir") flag.Parse() log.SetFlags(log.Ldate | log.Lmicroseconds | log.LUTC) if err := os.MkdirAll(*root, 0700); err != nil { return err } footer := "" if c := loadConfig(); c != nil { b := &bytes.Buffer{} if err := footerTmpl.Execute(b, c); err != nil { return err } footer = b.String() } repos := &repositories{ root: *root, delay: 60 * time.Second, repos: map[string]*git{}, footer: footer, } // TODO(maruel): This is a race condition with the parent process. if err := repos.init(); err != nil { return err } var addr string if *notLocal { addr = fmt.Sprintf(":%d", *port) } else { addr = fmt.Sprintf("localhost:%d", *port) } mux := http.NewServeMux() mux.Handle("/favicon.ico", restrictFunc(func(w http.ResponseWriter, r *http.Request) { // TODO(maruel): Eh. http.Redirect(w, r, "https://git-scm.com/images/logos/downloads/Git-Icon-1788C.png", http.StatusFound) }, "GET")) mux.Handle("/", repos) s := &http.Server{ Addr: addr, Handler: exitOnPanic{&loggingHandler{mux, nil}}, } // TODO(maruel): Handle Ctrl-C to quick shutdown but wait for git operations. err := gracehttp.Serve(s) interrupt.Set() repos.wg.Wait() return err }
func main() { // Setup e := echo.New() e.Get("/", func(c *echo.Context) error { return c.String(http.StatusOK, "Six sick bricks tick") }) gracehttp.Serve(e.Server(":1323")) }
func main() { http.HandleFunc("/", findFile) log.Println("[server]:start :", conf.Port) log.Println(conf) err := gracehttp.Serve(&http.Server{Addr: ":" + conf.Port, Handler: nil}) // err := http.ListenAndServe(":"+conf.Port, nil) if err != nil { log.Fatal(err) } }
func main() { flag.Parse() go checkForUpdates() gracehttp.Serve( &http.Server{Addr: ":8111", Handler: newHandler("handler1")}, &http.Server{Addr: ":8112", Handler: newHandler("handler2")}, &http.Server{Addr: ":8113", Handler: newHandler("handler3")}, ) }
func main() { options := Options{ Port: 8080, } config.MustResolve(&options) port := options.Port s := &http.Server{ Addr: fmt.Sprintf(":%v", port), Handler: newHandler(), } gracehttp.Serve(s) }
func startServer(app *app.App) error { addr := fmt.Sprintf(":%d", config.Port) server := &http.Server{ Addr: addr, Handler: app, ReadTimeout: time.Second * 10, WriteTimeout: time.Second * 10, } server.SetKeepAlivesEnabled(false) logger.Infof("listen on: %s", addr) return gracehttp.Serve(server) }
func main() { port = flag.String("port", ":8080", "port for this HTTP server to listen on") target = flag.String("target", "https://www.marksandspencer.com", "target URL for reverse proxy") flag.Parse() u, err := url.Parse(*target) if err != nil { log.Fatal(err) } proxy := newReverseProxy(u) log.Fatal(gracehttp.Serve( &http.Server{Addr: *port, Handler: proxy}, )) }
func main() { // Echo instance e := echo.New() applicationConfig := foundation.NewApplicationConfig() handler := foundation.ApplicationLogFile() foundation.RegisterFileLogger(e, handler) // register global middleware middleware.GlobalMiddleware(e) // register application routes foundation.ApplicationRoutes(e) defer handler.FileHandler.Close() // boot application server standard := standard.New(fmt.Sprintf("%s:%s", *applicationConfig.Host, *applicationConfig.Port)) standard.SetHandler(e) gracehttp.Serve(standard.Server) }
func Run(path string) error { runtime.GOMAXPROCS(runtime.NumCPU()) app, err := NewFromConfigPath(path) if err != nil { return err } n := app.InitRouter() server := &http.Server{Addr: fmt.Sprintf(":%s", strconv.Itoa(app.Port())), Handler: n} gracehttp.Serve(server) return nil }
func main() { // fetch config from environment awsRegion := os.Getenv("AWS_REGION") awsBucketName := os.Getenv("AWS_BUCKET") awsBucketPrefix := os.Getenv("AWS_BUCKET_PREFIX") // create the s3 client client := s3.New(nil) // create middleware n := negroni.Classic() // create mux mux := http.NewServeMux() resizePath := fmt.Sprintf("/%s/", awsBucketPrefix) ro := resizeOpts{ bucket: awsBucketName, prefix: awsBucketPrefix, path: resizePath, region: awsRegion, client: client, } resizeHandler := newResizeHandler(ro) log.Println("Serving images from", resizePath) mux.HandleFunc(resizePath, resizeHandler) mux.HandleFunc("/robots.txt", robotsHandler) // add mux to middleware stack n.UseHandler(mux) server := &http.Server{ Addr: fmt.Sprintf("0.0.0.0:%s", os.Getenv("PORT")), Handler: n, } log.Printf("Starting server on 0.0.0.0:%s\n", os.Getenv("PORT")) // run using gracehttp gracehttp.Serve(server) }
func main() { r := gin.Default() r.Use(cors.CORS()) // verified the csrf token from the request r.Use(csrf.Verify()) r.GET("/status", status.StatusController) r.NoRoute(c.ErrorController) // requires mod perms admin := r.Group("/") admin.Use(validate.ValidateParams()) admin.Use(user.Auth(true)) admin.Use(user.Protect()) admin.GET("/statistics/:ib", c.StatisticsController) admin.GET("/log/board/:ib/:page", c.BoardLogController) admin.GET("/log/mod/:ib/:page", c.ModLogController) admin.DELETE("/tag/:ib/:id", c.DeleteTagController) admin.DELETE("/imagetag/:ib/:image/:tag", c.DeleteImageTagController) admin.DELETE("/thread/:ib/:id", c.DeleteThreadController) admin.DELETE("/post/:ib/:thread/:id", c.DeletePostController) admin.POST("/tag/:ib", c.UpdateTagController) admin.POST("/sticky/:ib/:thread", c.StickyThreadController) admin.POST("/close/:ib/:thread", c.CloseThreadController) admin.POST("/ban/ip/:ib/:thread/:post", c.BanIPController) admin.POST("/ban/file/:ib/:thread/:post", c.BanFileController) admin.POST("/user/resetpassword/:ib", c.ResetPasswordController) //admin.DELETE("/thread/:id", c.PurgeThreadController) //admin.DELETE("/post/:thread/:id", c.PurgePostController) //admin.DELETE("/flushcache", c.DeleteCacheController) s := &http.Server{ Addr: fmt.Sprintf("%s:%d", local.Settings.Admin.Host, local.Settings.Admin.Port), Handler: r, } gracehttp.Serve(s) }
func main() { // Setup e := echo.New() e.Get("/", func(c *echo.Context) error { return c.String(http.StatusOK, "Six sick bricks tick") }) // Get the http.Server s := e.Server(":1323") // HTTP2 is currently enabled by default in echo.New(). To override TLS handshake errors // you will need to override the TLSConfig for the server so it does not attempt to valudate // the connection using TLS as required by HTTP2 s.TLSConfig = nil // Serve it like a boss gracehttp.Serve(s) }
func main() { flagSet := flag.CommandLine flags := parseFlags(flagSet) log.Printf("Flags: %+v", flags) oinker := &Oinker{} if *flags.cassandraAddr != "" { oinker.CQLHosts = []string{*flags.cassandraAddr} } else if *flags.cassandraSRV != "" && *flags.cassandraDNS == "" || *flags.cassandraSRV == "" && *flags.cassandraDNS != "" { log.Fatalf("Invalid input: cassandra-srv and cassandra-dns must both be specified to enable cassandra usage") } else if *flags.cassandraSRV != "" && *flags.cassandraDNS != "" { hosts, err := lookupCassandraHosts(*flags.cassandraSRV, *flags.cassandraDNS) if err != nil { log.Fatalf("Error looking up Cassandra SRV records: %s", err) } oinker.CQLHosts = hosts } graph := oinker.NewGraph() var oinkRepo model.OinkRepo inject.ExtractAssignable(graph, &oinkRepo) err := oinkRepo.Init() if err != nil { log.Fatalf("Error Initializing Repo: %s", err) } var mux controller.MuxServer inject.ExtractAssignable(graph, &mux) var controllers []controller.Controller inject.FindAssignable(graph, &controllers) for _, c := range controllers { log.Println("Registering controller:", c.Name()) c.RegisterHandlers(mux) } // serve and listen for shutdown signals gracehttp.Serve( &http.Server{Addr: *flags.address, Handler: mux}, ) }
func main() { var httpAddr, httpsAddr string flag.StringVar(&httpAddr, "http", ":48560", "http address to bind to") flag.StringVar(&httpsAddr, "https", ":48561", "https address to bind to") flag.Parse() // we have self signed certs http.DefaultTransport = &http.Transport{ DisableKeepAlives: true, TLSClientConfig: &tls.Config{ InsecureSkipVerify: true, }, } err := flag.Set("gracehttp.log", "false") if err != nil { log.Fatalf("Error setting gracehttp.log: %s", err) } // print json to stderr once we can successfully connect to all three // addresses. the ensures we only print the line once we're ready to serve. go func() { var wg sync.WaitGroup wg.Add(2) go wait(&wg, fmt.Sprintf("http://%s/sleep/?duration=1ms", httpAddr)) go wait(&wg, fmt.Sprintf("https://%s/sleep/?duration=1ms", httpsAddr)) wg.Wait() err = json.NewEncoder(os.Stderr).Encode(&response{Pid: os.Getpid()}) if err != nil { log.Fatalf("Error writing startup json: %s", err) } }() err = gracehttp.Serve( &http.Server{Addr: httpAddr, Handler: newHandler()}, httpsServer(httpsAddr), ) if err != nil { log.Fatalf("Error in gracehttp.Serve: %s", err) } }
func main() { if serviceConfigPath == "" { serviceConfigPath = DEFAULT_CONFIG_PATH } if serverPort == ":" { serverPort = "localhost:9990" } sc, err := ParseServiceConfig(&serviceConfigPath) if err != nil { panic(err) } handler := RegisterServices(sc) fmt.Printf("Starting server on %s...\n", serverPort) gracehttp.Serve( &http.Server{Addr: serverPort, Handler: handler}, ) }
func main() { flagSet := flag.CommandLine flags := parseFlags(flagSet) log.Infof("Flags: %+v", flags) oinker := &Oinker{} if *flags.cassandraAddr != "" { oinker.CQLHosts = []string{*flags.cassandraAddr} oinker.CQLReplicationFactor = *flags.cassandraRepl } graph := oinker.NewGraph() defer graph.Finalize() // initialize cassandra (connection, keyspace, tables) var oinkRepo service.OinkRepo inject.ExtractAssignable(graph, &oinkRepo) svc, ok := oinkRepo.(inject.Initializable) if ok { svc.Initialize() } var mux controller.MuxServer inject.ExtractAssignable(graph, &mux) var controllers []controller.Controller inject.FindAssignable(graph, &controllers) for _, c := range controllers { log.Infof("Registering controller:", c.Name()) c.RegisterHandlers(mux) } // serve and listen for shutdown signals gracehttp.Serve( &http.Server{Addr: *flags.address, Handler: mux}, ) }
func main() { fmt.Println("Starting web server") // Set routes router := httprouter.New() router.HandleMethodNotAllowed = false router.POST("/upload", upload) router.NotFound = emptypage s := &http.Server{ Addr: bind, Handler: router, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1024 * 6, // 4k cookie + 2k http request } s.SetKeepAlivesEnabled(true) if err := gracehttp.Serve(s); err != nil { panic(err) } }
func main() { bind := flag.String("bind", "0.0.0.0:5241", "Bind to this IP:port combination") flag.Parse() // Set routes router := httprouter.New() router.HandleMethodNotAllowed = false router.POST("/upload", upload) router.NotFound = notFound{} s := &http.Server{ Addr: *bind, Handler: router, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1024 * 6, // 4k cookie + 2k http request } s.SetKeepAlivesEnabled(true) if err := gracehttp.Serve(s); err != nil { panic(err) } }
// start will initialize the gin server func start(name, address string, port int) { // init store u.Initialize(name) // create pid file pidfile.SetPidfilePath(fmt.Sprintf("/run/fluorescences/%s.pid", name)) err := pidfile.Write() if err != nil { panic("Could not write pid file") } // load the site templates t := template.Must(template.New("public").Funcs(u.TemplateFuncs).ParseGlob("templates/*.tmpl")) r := gin.Default() // load template into gin r.SetHTMLTemplate(t) // serve our static files r.Static("/css", "./css") r.Static("/images", "./images") r.StaticFile("/logo.png", "./logo.png") // if nothing matches r.NoRoute(c.ErrorController) // routing group for public handlers public := r.Group("/") public.GET("/", blog.ViewController) public.GET("/blog/:page", blog.ViewController) public.GET("/categories", category.IndexController) public.GET("/comics/:id/:page", gallery.IndexController) public.GET("/comic/:id/:page", m.Private(), gallery.ViewController) public.GET("/image/:id/:page", m.Private(), image.ViewController) public.GET("/gallery/key/:id", keys.InputController) public.GET("/commission", com.ViewController) // routing group for admin handlers authed := r.Group("/admin") // add a CSRF cookie and session token to requests authed.Use(csrf.Cookie()) authed.GET("/login", admin.LoginController) authed.POST("/login", admin.AuthController) authed.GET("/logout", admin.LogoutController) // ensure the user is authenticated authed.Use(m.Auth()) authed.GET("/panel", admin.PanelController) authed.GET("/blog", blog.NewController) authed.GET("/blog/edit/:id", blog.EditController) authed.GET("/link/edit/:id", link.EditController) authed.GET("/category", category.NewController) authed.GET("/category/edit/:id", category.EditController) authed.GET("/gallery", gallery.NewController) authed.GET("/gallery/edit/:id", gallery.EditController) authed.GET("/image/edit/:gallery/:image", image.EditController) // authenticates the CSRF session token authed.Use(csrf.Verify()) authed.POST("/settings/update", admin.UpdateController) authed.POST("/blog/new", blog.PostController) authed.POST("/blog/delete", blog.DeleteController) authed.POST("/blog/update", blog.UpdateController) authed.POST("/link/new", link.NewController) authed.POST("/link/delete", link.DeleteController) authed.POST("/link/update", link.UpdateController) authed.POST("/category/new", category.PostController) authed.POST("/category/delete", category.DeleteController) authed.POST("/category/update", category.UpdateController) authed.POST("/gallery/new", gallery.PostController) authed.POST("/gallery/delete", gallery.DeleteController) authed.POST("/gallery/update", gallery.UpdateController) authed.POST("/gallery/private", gallery.PrivateController) authed.POST("/gallery/image/new", image.NewController) authed.POST("/gallery/image/delete", image.DeleteController) authed.POST("/gallery/image/update", image.UpdateController) authed.POST("/gallery/key/new", keys.NewController) authed.POST("/gallery/key/delete", keys.DeleteController) authed.POST("/commission/update", com.UpdateController) authed.POST("/password/update", admin.PasswordController) s := &http.Server{ Addr: fmt.Sprintf("%s:%d", address, port), Handler: r, } gracehttp.Serve(s) }
// Uses our own listener to make our server stoppable. Similar to // net.http.Server.ListenAndServer only this version saves a reference to the listener func (a *Application) listenAndServe() error { // Serve accepts incoming connections on the Listener lsn, creating a // new service goroutine for each. The service goroutines read requests and // then call the handler (i.e. ServeHTTP() ) to reply to them. return gracehttp.Serve(a.httpSrv) }