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 serveHTTPS(ctx context.Context, httpServer *http.Server) error { log.Printf("Starting TLS server on %s", *httpsAddr) httpsServer := new(http.Server) *httpsServer = *httpServer httpsServer.Addr = *httpsAddr if !inProd { if *tlsCertFile == "" { return errors.New("unspecified --tlscert flag") } if *tlsKeyFile == "" { return errors.New("unspecified --tlskey flag") } return httpsServer.ListenAndServeTLS(*tlsCertFile, *tlsKeyFile) } cert, err := tlsCertFromGCS(ctx) if err != nil { return fmt.Errorf("error loading TLS certs from GCS: %v", err) } httpsServer.TLSConfig = &tls.Config{ Certificates: []tls.Certificate{*cert}, } log.Printf("Listening for HTTPS on %v", *httpsAddr) ln, err := net.Listen("tcp", *httpsAddr) if err != nil { return err } return httpsServer.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, httpsServer.TLSConfig)) }
func main() { port := 8080 var srv http.Server router := mux.NewRouter() router.HandleFunc("/hello", hello) router.HandleFunc("/welcome", welcome) router.PathPrefix("/").Handler(http.FileServer(http.Dir("."))) srv.Addr = Sprintf(":%d", port) /* set the http handler */ srv.Handler = &gpp.Handler{EnableProxy: true, Handler: router} /* initial http2 support */ http2.ConfigureServer(&srv, nil) log.Print("Listen on: ", Sprintf("https://0.0.0.0:%d", port)) srv.ListenAndServeTLS("server.crt", "server.key") if err != nil { log.Fatal(err) } }
func serveHTTPS(ctx context.Context, httpServer *http.Server) error { log.Printf("Starting TLS server on %s", *httpsAddr) httpsServer := new(http.Server) *httpsServer = *httpServer httpsServer.Addr = *httpsAddr cacheFile := "letsencrypt.cache" if !inProd { if *tlsCertFile != "" && *tlsKeyFile != "" { return httpsServer.ListenAndServeTLS(*tlsCertFile, *tlsKeyFile) } // Otherwise use Let's Encrypt, i.e. same use case as in prod } else { cacheFile = prodLECache if err := os.MkdirAll(filepath.Dir(cacheFile), 0755); err != nil { return err } } var m letsencrypt.Manager if err := m.CacheFile(cacheFile); err != nil { return err } httpsServer.TLSConfig = &tls.Config{ GetCertificate: m.GetCertificate, } log.Printf("Listening for HTTPS on %v", *httpsAddr) ln, err := net.Listen("tcp", *httpsAddr) if err != nil { return err } return httpsServer.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, httpsServer.TLSConfig)) }
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 }
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 {} }
// ListenAndServe is same as http.ListenAndServe except it returns // the address that will be listened on (which is useful when using // arbitrary ports). // See https://github.com/golang/go/blob/master/src/net/http/server.go func ListenAndServe(svr *http.Server) (*RestServiceInfo, error) { log.Infof("Entering ListenAndServe(%p)", svr) if svr.Addr == "" { svr.Addr = ":0" } ln, err := net.Listen("tcp", svr.Addr) if err != nil { return nil, err } realAddr := ln.Addr().String() channel := make(chan ServiceMessage) l := svr.ErrorLog if l == nil { l = clog.New(os.Stderr, "[negroni] ", 0) } go func() { channel <- Starting l.Printf("ListenAndServe(%p): listening on %s (asked for %s) with configuration %v, handler %v\n", svr, realAddr, svr.Addr, svr, svr.Handler) err := svr.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)}) if err != nil { log.Criticalf("RestService: Fatal error %v", err) os.Exit(255) } }() return &RestServiceInfo{Address: realAddr, Channel: channel}, nil }
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 main() { if _, err := fs.Mount(); err != nil { log.Printf("fs-mounting %v\n", err) os.Exit(-1) } var server http.Server server.Addr = envGetOrAlternatives(EnvCachyServerAddress, ":8080") log.Printf("cachy server running on %q\n", server.Addr) http.HandleFunc("/", Cache) http.HandleFunc("/cache", Cache) certFilepath := envGetOrAlternatives(EnvCachyCertFile, "cachy.cert") keyFilepath := envGetOrAlternatives(EnvCachyKeyFile, "cachy.key") if envGetOrAlternatives("http1") != "" { if err := server.ListenAndServe(); err != nil { log.Printf("serving http: %v\n", err) } } else { if err := server.ListenAndServeTLS(certFilepath, keyFilepath); err != nil { log.Printf("servingTLS: %v\n", err) } } }
func (c *conn) serveSmart() { defer func() { if err := recover(); err != nil { const size = 4096 buf := make([]byte, size) buf = buf[:runtime.Stack(buf, false)] log.Printf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf) } if !c.hijacked() { c.close() } }() if tlsConn, ok := c.rwc.(*tls.Conn); ok { if d := c.server.ReadTimeout; d != 0 { c.rwc.SetReadDeadline(time.Now().Add(d)) } if d := c.server.WriteTimeout; d != 0 { c.rwc.SetWriteDeadline(time.Now().Add(d)) } if err := tlsConn.Handshake(); err != nil { return } c.tlsState = new(tls.ConnectionState) *c.tlsState = tlsConn.ConnectionState() if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) { if fn := c.server.TLSNextProto[proto]; fn != nil { h := initNPNRequest{tlsConn, serverHandler{c.server}} fn(c.server, tlsConn, h) } return } } initial_bytes := make([]byte, start_bytes) // add smart detection n, err := c.rwc.Read(initial_bytes) if err != nil || n != start_bytes { return } if checkspdy(initial_bytes) { s := c.server z := new(http.Server) z.Addr = s.Addr z.Handler = s.inner_h z.ReadTimeout = s.ReadTimeout z.WriteTimeout = s.WriteTimeout z.MaxHeaderBytes = s.MaxHeaderBytes server_session := spdy.NewServerSession(NewSmartConn(c.rwc, initial_bytes), z) server_session.Serve() return } c2, err := c.server.newConn(NewSmartConn(c.rwc, initial_bytes)) if err != nil { return } c2.serve() }
// BackgroundRunHttps runs an https server in a goroutine. // Returns a send-only channel to watch for errors. func BackgroundRunHttps(server *http.Server, conf *BaseConfiguration) chan error { https := make(chan error) go func() { server.Addr = fmt.Sprintf("%s:%d", conf.BindAddress, int(conf.BindHttpsPort)) https <- server.ListenAndServeTLS(conf.CertFile, conf.KeyFile) }() return https }
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") }
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) } }
/* NewServer returns an intialized endlessServer Object. Calling Serve on it will actually "start" the server. */ func NewServer(addr string, handler http.Handler) *endlessServer { var srv http.Server srv.Addr = addr srv.ReadTimeout = DefaultReadTimeOut srv.WriteTimeout = DefaultWriteTimeOut srv.MaxHeaderBytes = DefaultMaxHeaderBytes srv.Handler = handler return New(srv) }
func (context *Context) ListenAndServeTLS(port string, certFile string, keyFile string) { var httpServer http.Server httpServer.Addr = ":" + port httpServer.Handler = http.HandlerFunc(serverHandler) go func() { err := httpServer.ListenAndServeTLS(certFile, keyFile) if err != nil { log.Printf("Listen error: %s", err) } }() }
func run(cfg *config) error { apiKey := cfg.YTDataAPIKey log.Printf("Using YouTube Data API key ending %s", apiKey[len(apiKey)-5:]) var cleanc chan *cleaningWhitelist if *dataClean { cleanc = make(chan *cleaningWhitelist) } for i := range cfg.Podcasts { ytAPI, err := youtube.New(&http.Client{ Transport: &transport.APIKey{Key: apiKey}, }) if err != nil { return err } wat, err := newWatcher(ytAPI, cfg, &cfg.Podcasts[i], cleanc) if err != nil { log.Fatal(err) } go wat.watch() } if *dataClean { n, err := clean(len(cfg.Podcasts), cleanc) if err != nil { return err } log.Printf("Clean removed %d files", n) } // Run a webserver to serve the episode and metadata files. mux := http.NewServeMux() files := newHitLoggingFsys(http.Dir("."), hitLoggingPeriod) mux.Handle("/", http.FileServer(files)) mux.HandleFunc(httpHealthPrefix, healthHandler) websrv := http.Server{ Addr: fmt.Sprint(cfg.ServeHost, ":", cfg.ServePort), Handler: mux, // Conserve # open FDs by pruning persistent (keep-alive) HTTP conns. ReadTimeout: websrvClientReadTimout, } err := websrv.ListenAndServe() if err != nil { samePortAllInterfaces := fmt.Sprint(":", cfg.ServePort) log.Printf("Web server could not listen on %v, trying %v instead", websrv.Addr, samePortAllInterfaces) websrv.Addr = samePortAllInterfaces err = websrv.ListenAndServe() } return err }
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")) }
func nextproto3(s *Server, c *tls.Conn, h Handler) { z := new(http.Server) z.Addr = s.Addr z.Handler = s.inner_h z.ReadTimeout = s.ReadTimeout z.WriteTimeout = s.WriteTimeout z.MaxHeaderBytes = s.MaxHeaderBytes if z.Handler == nil { z.Handler = http.DefaultServeMux } server_session := spdy.NewServerSession(c, z) server_session.Serve() }
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 (c *conn) handleConnection(outchan chan *Session) { hserve := new(http.Server) if c.srv.Handler == nil { hserve.Handler = http.DefaultServeMux } else { hserve.Handler = c.srv.Handler } hserve.Addr = c.srv.Addr c.ss = NewServerSession(c.cn, hserve) if outchan != nil { outchan <- c.ss } c.ss.Serve() }
// NewHTTPEntry returns a new HTTPEntry server func NewHTTPEntry(host string, port int, messageQueue queue.MessageQueue) (*HTTPEntry, error) { h := new(HTTPEntry) addr := utils.Addrcat(host, port) server := new(http.Server) server.Addr = addr server.Handler = h h.host = host h.port = port h.server = server h.messageQueue = messageQueue return h, nil }
// GODEBUG="http2debug=1" or 2 // DEBUG_HTTP2_GOROUTINES=1 func main() { DOTFILES := os.Getenv("DOTFILES") cert := DOTFILES + "/keys/cert.pem" key := DOTFILES + "/keys/key.pem" var s http.Server s.Addr = ":8080" 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(cert, key)) }
// ListenAndServe can listen on both TCP and UNIX sockets. func ListenAndServe(srv http.Server) error { var proto string if srv.Addr == "" { srv.Addr = ":http" } if strings.Contains(srv.Addr, "/") { proto = "unix" } else { proto = "tcp" } l, e := net.Listen(proto, srv.Addr) if e != nil { return e } return srv.Serve(l) }
func makeWebInterface(relatedNode *node) *http.Server { newServer := new(http.Server) mux := http.NewServeMux() mux.HandleFunc("/storage/", relatedNode.webstorage) mux.HandleFunc("/exit/", relatedNode.exit) mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { if req.URL.Path != "/" { http.NotFound(w, req) return } fmt.Fprintf(w, "") }) newServer.Addr = relatedNode.Address().IP.String() + ":" + strconv.Itoa(relatedNode.Address().Port+80) newServer.Handler = mux return newServer }
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() { flag.Parse() docroot, err := filepath.Abs("./html") HandleErr(err) hServe := new(http.Server) mux := http.NewServeMux() mux.HandleFunc("/mapi/", proxy) mux.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir(docroot)))) hServe.Handler = mux hServe.Addr = ":" + strconv.Itoa(*port) //":"+strconv.Itoa(*port),http.FileServer(http.Dir(docroot)) ) log.Notice("server running at %s:%d. CTRL + C to shutdown\n", "http://localhost", *port) err = hServe.ListenAndServe() HandleErr(err) }
func main() { err := database.Connect() if err != nil { log.Fatal(err) } addr := os.Getenv("LISTEN") if addr == "" { addr = "0.0.0.0:8443" } if os.Getenv("DEBUG") == "true" { log.SetLevel(log.DebugLevel) } var cert tls.Certificate if certName == "" { log.Info("Generating self-signed certificate") cert, err = GenCert() } else { log.Info("Using certificate from vault") cert, err = GetNutcrackerCert() } if err != nil { log.Fatal(err) } sock, err := Socket(addr, cert) if err != nil { log.Fatal(err) } r := mux.NewRouter() addRoutes(r) server := new(http.Server) server.ErrorLog = new(stdLog.Logger) server.ErrorLog.SetOutput(ioutil.Discard) server.Addr = addr server.Handler = context.ClearHandler(r) log.Infof("HTTPS server listening on: %s", addr) server.Serve(sock) }
func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello world") }) var srv http.Server log.Printf("Listening on https://localhost:4430/") srv.Addr = "localhost:4430" http2.ConfigureServer(&srv, &http2.Server{}) closeFirefox() go func() { log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key")) }() time.Sleep(500 * time.Millisecond) exec.Command("open", "-b", "org.mozilla.nightly", "https://localhost:4430/").Run() select {} }