func main() { var srv http.Server flag.BoolVar(&http2.VerboseLogs, "verbose", false, "Verbose HTTP/2 debugging.") flag.Parse() srv.Addr = *addr registerHandlers() if *prod { *httpAddr = "http2.golang.org" log.Fatal(serveProd()) } url := "https://" + *addr + "/" log.Printf("Listening on " + url) http2.ConfigureServer(&srv, &http2.Server{}) if *httpAddr != "" { go func() { log.Fatal(http.ListenAndServe(*httpAddr, nil)) }() } go func() { log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key")) }() if *openFirefox && runtime.GOOS == "darwin" { time.Sleep(250 * time.Millisecond) exec.Command("open", "-b", "org.mozilla.nightly", "https://localhost:4430/").Run() } select {} }
func (e *endpoint) Serve() error { // TODO: Currently only support single server per endpoint if len(e.OriginServers) > 1 { return errors.New("Currently only 1 origin server per endpoint is supported.") } // Create http2 server var srv http.Server // Set Port srv.Addr = e.Address // Mux setup router := http.NewServeMux() // Set mux srv.Handler = router // Set handlers setHandlers(router, e) err := http2.ConfigureServer(&srv, &http2.Server{}) if err != nil { return err } log.Printf("Listening on %s", srv.Addr) srv.ListenAndServeTLS(e.Certs.CertFile, e.Certs.KeyFile) return nil }
// Run starts an http server using the provided config struct. // // This method configures the process to listen for termination signals (SIGINT // and SIGTERM) to trigger a graceful shutdown by way of the graceful package // (https://github.com/tylerb/graceful). func Run(conf Config) { srv := setup(conf) http2.ConfigureServer(srv.Server, nil) if conf.OnStarting != nil { conf.OnStarting() } var err error if conf.TLSCert != "" { err = srv.ListenAndServeTLS(conf.TLSCert, conf.TLSKey) } else { err = srv.ListenAndServe() } if err != nil { log.Error(errors.Wrap(err, "failed to start server")) os.Exit(1) } if conf.OnStopped != nil { conf.OnStopped() } os.Exit(0) }
func listenAndServeProtoHTTP(listener net.Listener, tlsConfig *tls.Config) error { srv := http.Server{ TLSConfig: tlsConfig, Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { reqBody, err := ioutil.ReadAll(r.Body) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } if err := r.Body.Close(); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } args := EchoRequest{} if err := proto.Unmarshal(reqBody, &args); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } reply := EchoResponse{Msg: args.Msg} respBody, err := proto.Marshal(&reply) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set(contentType, xProtobuf) w.Write(respBody) }), } http2.ConfigureServer(&srv, nil) return srv.Serve(listener) }
func main() { var srv http.Server flag.BoolVar(&http2.VerboseLogs, "verbose", false, "Verbose HTTP/2 debugging.") flag.Parse() srv.Addr = *httpsAddr srv.ConnState = idleTimeoutHook() registerHandlers() if *prod { *hostHTTP = "http2.golang.org" *hostHTTPS = "http2.golang.org" log.Fatal(serveProd()) } url := "https://" + httpsHost() + "/" log.Printf("Listening on " + url) http2.ConfigureServer(&srv, &http2.Server{}) if *httpAddr != "" { go func() { log.Printf("Listening on http://" + httpHost() + "/ (for unencrypted HTTP/1)") log.Fatal(http.ListenAndServe(*httpAddr, nil)) }() } go func() { log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key")) }() select {} }
func startTLS() { srv := &http.Server{Addr: *tlsListeningAddr} http2.ConfigureServer(srv, nil) log.Printf("TLS HTTP2 server listening on %q", *tlsListeningAddr) log.Fatal(srv.ListenAndServeTLS(*tlsCertFile, *tlsKeyFile)) }
func (s *Server) newH2Server(tlsConfig *tls.Config, laddr string) (*http.Server, func(error)) { var mu sync.Mutex var h2sleep time.Duration = 1 h2Server := &http.Server{ Addr: laddr, Handler: http.HandlerFunc(s.serveH2), TLSConfig: tlsConfig, ConnState: func(c net.Conn, s http.ConnState) { if s == http.StateNew { mu.Lock() h2sleep = 1 mu.Unlock() } }, } http2.ConfigureServer(h2Server, &http2.Server{ MaxReadFrameSize: s.H2BufSize, }) afterServeError := func(err error) { Log.Error("h2 server failed", zap.Error(err)) mu.Lock() if h2sleep < s.H2RetryMaxSecond { h2sleep++ } sec := h2sleep mu.Unlock() time.Sleep(time.Second * sec) } return h2Server, afterServeError }
func main() { var httpServer http.Server var httpsServer http.Server http2.VerboseLogs = true http2.ConfigureServer(&httpsServer, nil) http.HandleFunc("/auth", authHandler) http.HandleFunc("/", handler) http.HandleFunc("/js", jsHandler) var wg sync.WaitGroup wg.Add(2) go func() { log.Println("start http listening :18888") httpServer.Addr = ":18888" log.Println(httpServer.ListenAndServe()) wg.Done() }() go func() { log.Println("start https listening :18889") httpsServer.Addr = ":18889" log.Println(httpsServer.ListenAndServeTLS("server.crt", "server.key")) wg.Done() }() wg.Wait() }
func main() { router := lib.NewRouter() srvTLS := &http.Server{Addr: ":4000", Handler: router} log.Println("Listening...") http2.ConfigureServer(srvTLS, &http2.Server{}) srvTLS.ListenAndServeTLS("openssl/server.crt", "openssl/server.key") }
// Server returns the internal *http.Server. func (e *Echo) Server(addr string) *http.Server { s := &http.Server{Addr: addr} s.Handler = e if e.http2 { http2.ConfigureServer(s, nil) } return s }
// Server returns the internal *http.Server. func (e *Echo) Server(addr string) *http.Server { s := &http.Server{Addr: addr, Handler: e} // TODO: Remove in Go 1.6+ if e.http2 { http2.ConfigureServer(s, nil) } return s }
func NewServer(port string, handler http.Handler) ListenAndServer { addr := fmt.Sprintf(":%s", port) server := &http.Server{ Addr: addr, Handler: handler, } http2.ConfigureServer(server, nil) return server }
func startWebServer() { key := "/" + *accessKey + "/" mux := http.NewServeMux() mux.HandleFunc(key+"upload", upload) mux.Handle(key, http.StripPrefix(key, http.FileServer(assetFS()))) mux.Handle(key+"f/", http.StripPrefix(key+"f/", http.FileServer(http.Dir(*rootDir)))) if *h1Port != "" { log.Println("http://localhost" + *h1Port + key) s := &http.Server{ Addr: *h1Port, Handler: mux, } http2.ConfigureServer(s, nil) go func() { err := s.ListenAndServe() if err != nil { log.Fatal("HTTP server error:", err) } }() } if *h2Port != "" { log.Println("https://localhost" + *h2Port + key) s := &http.Server{ Addr: *h2Port, Handler: mux, TLSConfig: CreateTLS(), } http2.ConfigureServer(s, nil) go func() { err := s.ListenAndServeTLS("", "") if err != nil { log.Fatal("HTTPS/2 server error:", err) } }() } }
func main() { var srv http.Server srv.Addr = ":8000" http2.ConfigureServer(&srv, nil) http.HandleFunc("/", HelloWorld) http.HandleFunc("/favicon.ico", Error404) log.Fatal(srv.ListenAndServeTLS("localhost.crt", "localhost.key")) }
func main() { var srv http.Server srv.Addr = ":12345" authenticator := auth.NewDigestAuthenticator("063.jp", secret) http.HandleFunc("/", authenticator.Wrap(func(res http.ResponseWriter, req *auth.AuthenticatedRequest) { http.FileServer(http.Dir("/var/www/html/SS/")).ServeHTTP(res, &req.Request) })) http2.ConfigureServer(&srv, &http2.Server{}) srv.ListenAndServeTLS("../key/server.crt", "../key/server.key") }
// startClusterListener starts cluster request listeners during postunseal. It // is assumed that the state lock is held while this is run. func (c *Core) startClusterListener() error { if c.clusterListenerShutdownCh != nil { c.logger.Printf("[ERR] core/startClusterListener: attempt to set up cluster listeners when already set up") return fmt.Errorf("cluster listeners already setup") } if c.clusterListenerSetupFunc == nil { c.logger.Printf("[ERR] core/startClusterListener: cluster listener setup function has not been set") return fmt.Errorf("cluster listener setup function has not been set") } if c.clusterAddr == "" { c.logger.Printf("[TRACE] core/startClusterListener: clustering disabled, starting listeners") return nil } c.logger.Printf("[TRACE] core/startClusterListener: starting listeners") lns, handler, err := c.clusterListenerSetupFunc() if err != nil { return err } tlsConfig, err := c.ClusterTLSConfig() if err != nil { c.logger.Printf("[ERR] core/startClusterListener: failed to get tls configuration: %v", err) return err } tlsLns := make([]net.Listener, 0, len(lns)) for _, ln := range lns { tlsLn := tls.NewListener(ln, tlsConfig) tlsLns = append(tlsLns, tlsLn) server := &http.Server{ Handler: handler, } http2.ConfigureServer(server, nil) c.logger.Printf("[TRACE] core/startClusterListener: serving cluster requests on %s", tlsLn.Addr()) go server.Serve(tlsLn) } c.clusterListenerShutdownCh = make(chan struct{}) c.clusterListenerShutdownSuccessCh = make(chan struct{}) go func() { <-c.clusterListenerShutdownCh c.logger.Printf("[TRACE] core/startClusterListener: shutting down listeners") for _, tlsLn := range tlsLns { tlsLn.Close() } close(c.clusterListenerShutdownSuccessCh) }() return nil }
func main() { var httpServer http.Server http2.VerboseLogs = true httpServer.Addr = ":8080" http2.ConfigureServer(&httpServer, nil) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Welcome to test HTTP2 page %q\n", html.EscapeString(r.URL.Path)) ShowRequestInfoHandler(w, r) }) log.Fatal(httpServer.ListenAndServeTLS("localhost.cert", "localhost.key")) }
func main() { var srv http.Server //http2.VerboseLogs = true srv.Addr = ":8443" http2.ConfigureServer(&srv, nil) http.HandleFunc("/", get) err := srv.ListenAndServeTLS("cert.pem", "key.pem") if err != nil { log.Fatal(err) } }
func main() { var srv core.Server srv.Addr = ":8080" http2.ConfigureServer(&srv.Server, nil) http.HandleFunc("/", handlers.NewDirList().Reply) srv.Init() srv.Run() srv.Quit() }
func (s *Http2Server) ListenAndServeTLS(config *tls.Config) error { srv := http.Server{ Addr: s.Base.Node.Addr, Handler: s.Handler, TLSConfig: config, } if srv.Handler == nil { srv.Handler = http.HandlerFunc(s.HandleRequest) } http2.ConfigureServer(&srv, nil) return srv.ListenAndServeTLS("", "") }
func main() { //TODO os.Getenv("DOMAIN") configureSocial() // Load all configuration appCfg = &AppConfig{} rdisCfg := &RedisConfig{} natsCfg := &NatsConfig{} loadConfiguration(appCfg, rdisCfg, natsCfg) //Mongo configuration log.Infoln("Loading configuration of Redis") rdisStorage := storage.NewRedisStorage() rdisStorage.URL = rdisCfg.URI rdisStorage.Password = rdisCfg.Password rdisStorage.Database = rdisCfg.DB tokenStorage = rdisStorage err := tokenStorage.OpenSession() defer tokenStorage.CloseSession() if err != nil { log.Panic(err) } log.Infoln("Initializing NATS proxy") proxyConn, _ := nats.Connect(natsCfg.Endpoint) multiProxy, err := natsproxy.NewNatsProxy(proxyConn) multiProxy.AddHook("/login.*", loginHook) defer proxyConn.Close() if err != nil { log.Panic("Cannot initialize NATS proxy") } log.Infoln("Registering handlers") //Handle login and register mux := http.NewServeMux() log.Infoln("Start listening on " + appCfg.Port) mux.HandleFunc("/", func(rw http.ResponseWriter, req *http.Request) { log.Println("Handling") transformToken(req) log.Println(req.Header) multiProxy.ServeHTTP(rw, req) }) //Init HTTP2 server srv := &http.Server{ Addr: ":" + appCfg.Port, Handler: mux, } http2.ConfigureServer(srv, nil) serveErr := srv.ListenAndServe() if serveErr != nil { log.Errorln(serveErr) } }
// ListenAndServe creates a listener and serves handler on it, closing // the listener when signalled by the stopper. func ListenAndServe(stopper *stop.Stopper, handler http.Handler, addr net.Addr, tlsConfig *tls.Config) (net.Listener, error) { ln, err := Listen(addr, tlsConfig) if err != nil { return nil, err } var mu sync.Mutex activeConns := make(map[net.Conn]struct{}) httpServer := http.Server{ TLSConfig: tlsConfig, Handler: handler, ConnState: func(conn net.Conn, state http.ConnState) { mu.Lock() switch state { case http.StateNew: activeConns[conn] = struct{}{} case http.StateClosed: delete(activeConns, conn) } mu.Unlock() }, } if err := http2.ConfigureServer(&httpServer, nil); err != nil { return nil, err } stopper.RunWorker(func() { if err := httpServer.Serve(ln); err != nil && !IsClosedConnection(err) { log.Fatal(err) } <-stopper.ShouldStop() mu.Lock() for conn := range activeConns { conn.Close() } mu.Unlock() }) stopper.RunWorker(func() { <-stopper.ShouldDrain() // Some unit tests manually close `ln`, so it may already be closed // when we get here. if err := ln.Close(); err != nil && !IsClosedConnection(err) { log.Fatal(err) } }) return ln, nil }
func main() { cwd, err := os.Getwd() if err != nil { log.Fatal(err) } srv := &http.Server{ Addr: ":8000", // Normally ":443" Handler: http.FileServer(http.Dir(cwd)), } http2.ConfigureServer(srv, &http2.Server{}) log.Fatal(srv.ListenAndServe()) }
func main() { var src http.Server http2.VerboseLogs = true src.Addr = ":8080" http2.ConfigureServer(&src, nil) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hi testerer %q \n", html.EscapeString(r.URL.Path)) ShowRequestInfoHandler(w, r) }) log.Fatal(src.ListenAndServeTLS("server.crt", "server.key")) }
// Serve starts the server. It blocks until the server quits. func (s *Server) Serve() error { server := &http.Server{ Addr: s.address, Handler: s, } if s.HTTP2 { // TODO: This call may not be necessary after HTTP/2 is merged into std lib http2.ConfigureServer(server, nil) } for _, vh := range s.vhosts { // Execute startup functions now for _, start := range vh.config.Startup { err := start() if err != nil { return err } } // Execute shutdown commands on exit if len(vh.config.Shutdown) > 0 { go func(vh virtualHost) { // Wait for signal interrupt := make(chan os.Signal, 1) signal.Notify(interrupt, os.Interrupt, os.Kill) <-interrupt // Run callbacks exitCode := 0 for _, shutdownFunc := range vh.config.Shutdown { err := shutdownFunc() if err != nil { exitCode = 1 log.Println(err) } } os.Exit(exitCode) // BUG: Other shutdown goroutines might be running; use sync.WaitGroup }(vh) } } if s.tls { var tlsConfigs []TLSConfig for _, vh := range s.vhosts { tlsConfigs = append(tlsConfigs, vh.config.TLS) } return ListenAndServeTLSWithSNI(server, tlsConfigs) } return server.ListenAndServe() }
func (e *Echo) run(s *http.Server, files ...string) { s.Handler = e // TODO: Remove in Go 1.6+ if e.http2 { http2.ConfigureServer(s, nil) } if len(files) == 0 { e.logger.Fatal(s.ListenAndServe()) } else if len(files) == 2 { e.logger.Fatal(s.ListenAndServeTLS(files[0], files[1])) } else { e.logger.Fatal("invalid TLS configuration") } }
// Init initializes the server func (srv *Server) Init() error { // Settings srv.Addr = ":8080" http2.VerboseLogs = true http2.ConfigureServer(&srv.Server, nil) // Gorilla's mux router srv.mux = mux.NewRouter() // Handlers /// http.HandleFunc("/", testResponse) return nil }
func main() { var s http.Server http2.VerboseLogs = true s.Addr = ":8080" http2.ConfigureServer(&s, nil) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain") fmt.Fprintf(w, "Hello World") }) log.Fatal(s.ListenAndServeTLS("key/server.crt", "key/server.key")) }
func main() { var server http.Server http2.VerboseLogs = false //set true for verbose console output server.Addr = ":8080" log.Println("Starting server on localhost port 8080...") http2.ConfigureServer(&server, nil) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "URL: %q\n", html.EscapeString(r.URL.Path)) ShowRequestInfoHandler(w, r) }) log.Fatal(server.ListenAndServeTLS("localhost.cert", "localhost.key")) }
func main() { router := httprouter.New() router.GET("/", api.Index) router.POST("/bench", api.Bench) srv := http.Server{ Addr: ":8080", Handler: router, } http2.ConfigureServer(&srv, &http2.Server{}) log.Printf("%s\n", HEADER) log.Printf("Starting server on %s\n", srv.Addr) log.Fatal(srv.ListenAndServe()) }