Ejemplo n.º 1
0
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))
}
Ejemplo n.º 2
0
func main() {
	flag.Parse()

	ln, err := net.Listen("tcp", ":"+PORT)
	if err != nil {
		glog.Fatalf("Listen(%s) error: %s", PORT, err)
	}

	cert, err := getCertificate(nil)
	if err != nil {
		glog.Fatalf("getCertificate error: %s", err)
	}

	tlsConfig := &tls.Config{
		Certificates: []tls.Certificate{*cert},
		// GetCertificate: getCertificate,
	}

	s := &http.Server{
		Handler:   http.HandlerFunc(handler),
		TLSConfig: tlsConfig,
	}

	http2.ConfigureServer(s, &http2.Server{})
	glog.Infof("ListenAndServe on %s\n", ln.Addr().String())
	s.Serve(tls.NewListener(ln, tlsConfig))
}
Ejemplo n.º 3
0
func main() {
	flag.Parse()

	addr := fmt.Sprintf("%s:%s", os.Getenv("HOST"), os.Getenv("PORT"))
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		glog.Fatalf("Listen(%s) error: %s", addr, err)
	}

	cert, err := getCertificate(nil)
	if err != nil {
		glog.Fatalf("getCertificate error: %s", err)
	}

	tlsConfig := &tls.Config{
		Certificates: []tls.Certificate{*cert},
		// GetCertificate: getCertificate,
	}

	s := &http.Server{
		Handler:   http.HandlerFunc(handler),
		TLSConfig: tlsConfig,
	}

	// http2.VerboseLogs = true
	http2.ConfigureServer(s, &http2.Server{})
	glog.Infof("ListenAndServe on %s\n", ln.Addr().String())
	s.Serve(tls.NewListener(ln, tlsConfig))
}
Ejemplo n.º 4
0
func ListenAndServeSecure(addr string, certFile string, keyFile string, numOfServers int, handler http.Handler) error {
	port, err := parsePort(addr)
	if err != nil {
		return err
	}

	if handler == nil {
		handler = http.DefaultServeMux
	}

	go func() {
		httpServer := &http.Server{Addr: addr, Handler: altProtoMiddleware(handler, port)}
		http2.ConfigureServer(httpServer, nil)
		err := httpServer.ListenAndServeTLS(certFile, keyFile)
		if err != nil {
			panic(err)
		}
	}()
	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
	if err != nil {
		return err
	}

	server := &QuicSpdyServer{Addr: addr, Handler: handler, numOfServers: numOfServers, Certificate: cert, isSecure: true}
	return server.ListenAndServe()
}
Ejemplo n.º 5
0
func (this *Server) Start() error {
	logger.Debug("serverConfig is %#v", this.config)
	this.router.matcher.sort()
	conf := this.config
	server := &http.Server{Handler: http.HandlerFunc(this.serverHttpHandler), MaxHeaderBytes: conf.MaxHeaderBytes, TLSConfig: conf.TLSConfig}
	if conf.ReadTimeout > 0 {
		server.ReadTimeout = conf.ReadTimeout
	}
	if conf.WriteTimeout > 0 {
		server.WriteTimeout = conf.WriteTimeout
	}
	http2.ConfigureServer(server, &http2.Server{})
	var err error
	this.listener, err = net.Listen("tcp", conf.serverAddr)
	if err != nil {
		return errors.New(logger.Error("listen [%s] fail:%s", conf.serverAddr, err))
	}
	logger.Info("start HttpServer :%s", conf.serverAddr)
	keepAliveListrener := tcpKeepAliveListener{this.listener.(*net.TCPListener)}
	if conf.TLSConfig != nil {
		conf.TLSConfig.NextProtos = append(conf.TLSConfig.NextProtos, "http/1.1")
		go server.Serve(tls.NewListener(keepAliveListrener, conf.TLSConfig))
	} else {
		go server.Serve(keepAliveListrener)
	}
	return nil
}
Ejemplo n.º 6
0
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 {}
}
Ejemplo n.º 7
0
func listenHttp() {
	log.Printf("Listening on port :%s\n", *httpport)

	port := fmt.Sprintf(":%s", *httpport)

	if secure {
		log.Println("Serving via TLS")
		server := &http.Server{Addr: port, Handler: nil}

		if os.Getenv("DISABLE_HTTP2") == "" {
			http2.ConfigureServer(server, nil)
			log.Println("HTTP/2 support is enabled.")
		} else {
			log.Println("HTTP/2 support is disabled.")
		}

		if err := server.ListenAndServeTLS(CertFilePath, KeyFilePath); err != nil {
			log.Fatalf("Error starting server: %s\n", err.Error())
		}
	} else {
		if err := http.ListenAndServe(port, nil); err != nil {
			log.Fatalf("Error starting server: %s\n", err.Error())
		}
	}
}
Ejemplo n.º 8
0
// Create a new graceful server configuration
func newGracefulServer(mux *http.ServeMux, http2support bool, addr string, shutdownTimeout time.Duration) *graceful.Server {
	// Server configuration
	s := &http.Server{
		Addr:    addr,
		Handler: mux,

		// The timeout values is also the maximum time it can take
		// for a complete page of Server-Sent Events (SSE).
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,

		MaxHeaderBytes: 1 << 20,
	}
	if http2support {
		// Enable HTTP/2 support
		http2.ConfigureServer(s, nil)
	}
	gracefulServer := &graceful.Server{
		Server:  s,
		Timeout: shutdownTimeout,
	}
	// Handle ctrl-c
	gracefulServer.ShutdownInitiated = runShutdown
	return gracefulServer
}
Ejemplo n.º 9
0
// 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
}
Ejemplo n.º 10
0
// 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
}
Ejemplo n.º 11
0
func newServer(addr string, h http.Handler, HTTP2 bool) *http.Server {
	srv := &http.Server{
		Addr:         addr,
		Handler:      h,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
	if HTTP2 {
		http2.ConfigureServer(srv, &http2.Server{})
	}
	return srv
}
Ejemplo n.º 12
0
func (e *Echo) run(s *http.Server, files ...string) {
	s.Handler = e
	if e.http2 {
		http2.ConfigureServer(s, nil)
	}
	if len(files) == 0 {
		log.Fatal(s.ListenAndServe())
	} else if len(files) == 2 {
		log.Fatal(s.ListenAndServeTLS(files[0], files[1]))
	} else {
		log.Fatal("echo => invalid TLS configuration")
	}
}
Ejemplo n.º 13
0
// 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()
}
Ejemplo n.º 14
0
func (s *Server) Serve() error {
	server := &http.Server{
		Addr:    s.address,
		Handler: s,
	}

	if s.HTTP2 {

		http2.ConfigureServer(server, nil)
	}

	for _, vh := range s.vhosts {

		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)
			}(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()
}
Ejemplo n.º 15
0
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")
	}
}
Ejemplo n.º 16
0
func main() {
	r := httprouter.New()
	r.GET("/", index)
	r.ServeFiles("/webapp/*filepath", http.Dir("webapp"))
	r.GET("/api/fs/*filepath", fsRead)
	r.PUT("/api/fs/*filepath", fsWrite)
	r.DELETE("/api/fs/*filepath", fsDelete)
	r.POST("/api/fs/*filepath", fsSpecial)

	s := &http.Server{}
	s.Addr = ":8080"
	s.Handler = r
	http2.ConfigureServer(s, nil)

	log.Fatalln(s.ListenAndServeTLS("cert.pem", "key.pem"))
}
Ejemplo n.º 17
0
func ListenAndServe(addr string, numOfServers int, handler http.Handler) error {
	port, err := parsePort(addr)
	if err != nil {
		return err
	}

	if handler == nil {
		handler = http.DefaultServeMux
	}

	httpServer := &http.Server{Addr: addr, Handler: altProtoMiddleware(handler, port)}
	http2.ConfigureServer(httpServer, nil)
	go httpServer.ListenAndServe()
	server := &QuicSpdyServer{Addr: addr, Handler: handler, numOfServers: numOfServers, isSecure: false}
	return server.ListenAndServe()
}
Ejemplo n.º 18
0
// 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() {
				interrupt := make(chan os.Signal, 1)
				signal.Notify(interrupt, os.Interrupt, os.Kill) // TODO: syscall.SIGQUIT? (Ctrl+\, Unix-only)
				<-interrupt
				for _, shutdownFunc := range vh.config.Shutdown {
					err := shutdownFunc()
					if err != nil {
						log.Fatal(err)
					}
				}
				os.Exit(0)
			}()
		}
	}

	if s.tls {
		var tlsConfigs []TLSConfig
		for _, vh := range s.vhosts {
			tlsConfigs = append(tlsConfigs, vh.config.TLS)
		}
		return ListenAndServeTLSWithSNI(server, tlsConfigs)
	}
	return server.ListenAndServe()
}
Ejemplo n.º 19
0
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 {}
}
Ejemplo n.º 20
0
func standUpServer() error {
	srv := &http.Server{Addr: hostport}

	reg, router, cxt := cookoo.Cookoo()

	buildRegistry(reg, router, cxt)

	// Our main datasource is the Medium, which manages channels.
	m := pubsub.NewMedium()
	cxt.AddDatasource(pubsub.MediumDS, m)
	cxt.Put("routes", reg.Routes())

	http2.ConfigureServer(srv, &http2.Server{})

	srv.Handler = web.NewCookooHandler(reg, router, cxt)

	srv.ListenAndServeTLS("../server/server.crt", "../server/server.key")
	return nil
}
Ejemplo n.º 21
0
func ListenAndServeRaw(addr string, certFile string, keyFile string, numOfServers int, quicHandler http.Handler, nonQuicHandler http.Handler) error {
	port, err := parsePort(addr)
	if err != nil {
		return err
	}

	if quicHandler == nil {
		return errors.New("quic handler should be provided")
	}

	if nonQuicHandler != nil {
		go func() {
			httpServer := &http.Server{Addr: addr, Handler: AltProtoMiddleware(nonQuicHandler, port)}
			http2.ConfigureServer(httpServer, nil)

			if certFile != "" && keyFile != "" {
				if err := httpServer.ListenAndServeTLS(certFile, keyFile); err != nil {
					panic(err)
				}
			} else {
				if err := httpServer.ListenAndServe(); err != nil {
					panic(err)
				}
			}
		}()
	}

	server := &QuicSpdyServer{Addr: addr, Handler: quicHandler, numOfServers: numOfServers}
	if certFile != "" && keyFile != "" {
		cert, err := tls.LoadX509KeyPair(certFile, keyFile)
		if err != nil {
			panic(err)
		}

		server.isSecure = true
		server.Certificate = cert
	} else {
		server.isSecure = false
	}

	return server.ListenAndServe()
}
Ejemplo n.º 22
0
func main() {
	srv := &http.Server{
		Addr: ":5500",
	}

	reg, router, cxt := cookoo.Cookoo()

	buildRegistry(reg, router, cxt)

	// Our main datasource is the Medium, which manages channels.
	m := pubsub.NewMedium()
	cxt.AddDatasource(pubsub.MediumDS, m)
	cxt.Put("routes", reg.Routes())

	http2.ConfigureServer(srv, &http2.Server{})

	srv.Handler = web.NewCookooHandler(reg, router, cxt)

	srv.ListenAndServeTLS("server.crt", "server.key")
}
Ejemplo n.º 23
0
func serveProdTLS() error {
	c, err := googlestorage.NewServiceClient()
	if err != nil {
		return err
	}
	slurp := func(key string) ([]byte, error) {
		const bucket = "http2-demo-server-tls"
		rc, _, err := c.GetObject(&googlestorage.Object{
			Bucket: bucket,
			Key:    key,
		})
		if err != nil {
			return nil, fmt.Errorf("Error fetching GCS object %q in bucket %q: %v", key, bucket, err)
		}
		defer rc.Close()
		return ioutil.ReadAll(rc)
	}
	certPem, err := slurp("http2.golang.org.chained.pem")
	if err != nil {
		return err
	}
	keyPem, err := slurp("http2.golang.org.key")
	if err != nil {
		return err
	}
	cert, err := tls.X509KeyPair(certPem, keyPem)
	if err != nil {
		return err
	}
	srv := &http.Server{
		TLSConfig: &tls.Config{
			Certificates: []tls.Certificate{cert},
		},
	}
	http2.ConfigureServer(srv, &http2.Server{})
	ln, err := net.Listen("tcp", ":443")
	if err != nil {
		return err
	}
	return srv.Serve(tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, srv.TLSConfig))
}
Ejemplo n.º 24
0
// NewApp creates a new App
func NewApp(port int) *App {
	a := &App{}

	certRoot := "/etc/ssl/zqz/zqzca"
	a.certPath = fmt.Sprintf("%s.crt", certRoot)
	a.keyPath = fmt.Sprintf("%s.key", certRoot)
	a.port = fmt.Sprintf(":%d", port)

	a.Router = mux.NewRouter().StrictSlash(true)

	chain := alice.New().Then(a.Router)

	a.Server = &http.Server{
		Addr:    a.port,
		Handler: chain,
	}

	http2.ConfigureServer(a.Server, nil)

	return a
}
Ejemplo n.º 25
0
func (s *Server) Serve() {
	if err := s.Listen(""); err != nil {
		s.fatalf("Listen error: %v", err)
	}
	go runTestHarnessIntegration(s.listener)

	srv := &http.Server{
		Handler: s,
	}
	// TODO: allow configuring src.ErrorLog (and plumb through to
	// Google Cloud Logging when run on GCE, eventually)

	// Setup the NPN NextProto map for HTTP/2 support:
	http2.ConfigureServer(srv, &s.H2Server)

	err := srv.Serve(s.throttleListener())
	if err != nil {
		s.printf("Error in http server: %v\n", err)
		os.Exit(1)
	}
}
Ejemplo n.º 26
0
func main() {

	// Initialize server and parse flags.
	var s http.Server
	flag.BoolVar(&http2.VerboseLogs, "verbose", false, "verbose HTTP/2 debugging")
	flag.Parse()
	s.Addr = *addr

	// Open database and retrieve posts.
	p, err := database.GetPosts()
	if err != nil {
		log.Fatal(err)
	}

	// Registers handlers and logs URL
	// and port, configured for HTTP/2.
	registerHandlers(p)
	url := "https://" + *addr + "/"
	log.Printf("Listening on " + url)
	http2.ConfigureServer(&s, &http2.Server{})

	// Starts listening over regular HTTP
	// if the "-http" flag is non-empty.
	if *httpAddr != "" {
		go func() { log.Fatal(http.ListenAndServe(*httpAddr, nil)) }()
	}

	// Concurrently begins listening at URL for
	// tls encrypted HTTP/2 communications.
	go func() {
		log.Fatal(s.ListenAndServeTLS("out/dev.crt", "out/dev.key"))
	}()

	// Blocks forever.
	select {}
}
Ejemplo n.º 27
0
func main() {
	fmt.Printf("Starting nano server...\nServing directory: %s\n", dir)
	if crtFile != "" && keyFile != "" {
		fmt.Printf("Using certificate: %s\nUsing private key: %s\n", crtFile, keyFile)
	} else {
		fmt.Println("No certificate and/or key provided!")
	}
	srv := &http.Server{
		Addr:    port,
		Handler: &requestLogger{http.FileServer(http.Dir(dir))},
	}
	http2.ConfigureServer(srv, nil)
	if crtFile != "" && keyFile != "" {
		fmt.Printf("Starting HTTPS server on port %s... Kill with [Ctrl]-[C]!\n", port)
		if err := srv.ListenAndServeTLS(crtFile, keyFile); err != nil {
			fmt.Printf("Error: %s\n", err)
		}
	} else {
		fmt.Printf("Starting HTTP server on port %s... Kill with [Ctrl]-[C]!\n", port)
		if err := srv.ListenAndServe(); err != nil {
			fmt.Printf("Error: %s\n", err)
		}
	}
}
Ejemplo n.º 28
0
func main() {
	initFlags()

	if len(options.Configs) > 0 {
		for _, configDef := range options.Configs {
			log.Printf("Creating config file:  %v => %v\n", configDef.template, configDef.output)
			createConfig(configDef.template, configDef.output)
		}
		log.Println()
	}

	if len(options.Services) > 0 {
		tlsConfig := &tls.Config{
			RootCAs:            x509.NewCertPool(),
			InsecureSkipVerify: options.SkipCertValidation,
		}
		transport := &http.Transport{TLSClientConfig: tlsConfig}
		if len(options.CACerts) > 0 {
			for _, caFile := range options.CACerts {
				// Load our trusted certificate path
				pemData, err := ioutil.ReadFile(caFile)
				if err != nil {
					log.Fatal("Couldn't read CA file, ", caFile, ": ", err)
				}
				if ok := tlsConfig.RootCAs.AppendCertsFromPEM(pemData); !ok {
					log.Fatal("Couldn't load PEM data from CA file, ", caFile)
				}
			}
		}
		for _, serviceDef := range options.Services {
			actualHost, port, err := validateServiceHost(serviceDef.url.Host)
			if err != nil {
				if options.FailOnUnknownServices {
					log.Fatalf("Unknown service host: %s", serviceDef.url.Host)
				} else {
					log.Printf("Unknown service host: %s", serviceDef.url.Host)
				}
			} else {
				if len(port) > 0 {
					actualHost += ":" + port
				}
				serviceDef.url.Host = actualHost
			}
			log.Printf("Creating service proxy: %v => %v\n", serviceDef.prefix, serviceDef.url.String())
			rp := httputil.NewSingleHostReverseProxy(serviceDef.url)
			rp.Transport = transport
			http.Handle(serviceDef.prefix, http.StripPrefix(serviceDef.prefix, rp))
		}
		log.Println()
	}

	if options.ServeWww {
		httpDir := http.Dir(options.StaticDir)
		staticHandler := http.FileServer(httpDir)
		if options.StaticCacheMaxAge > 0 {
			staticHandler = maxAgeHandler(options.StaticCacheMaxAge.Seconds(), staticHandler)
		}

		if len(options.DefaultPage) > 0 {
			staticHandler = defaultPageHandler(options.DefaultPage, httpDir, staticHandler)
		}
		if options.CompressHandler {
			staticHandler = handlers.CompressHandler(staticHandler)
		}
		http.Handle(options.StaticPrefix, staticHandler)
	}

	log.Printf("Listening on :%d\n", options.Port)
	log.Println()

	registerMimeTypes()

	srv := &http.Server{
		Addr: fmt.Sprintf(":%d", options.Port),
	}
	http2.ConfigureServer(srv, &http2.Server{})

	var handler http.Handler = http.DefaultServeMux

	if options.AccessLogging {
		handler = handlers.CombinedLoggingHandler(os.Stdout, handler)
	}

	srv.Handler = handler

	if len(options.TlsCertFile) > 0 && len(options.TlsKeyFile) > 0 {
		log.Fatal(srv.ListenAndServeTLS(options.TlsCertFile, options.TlsKeyFile))
	} else {
		log.Fatal(srv.ListenAndServe())
	}
}