Migrate to golang1.5 release with GO15VENDOREXPERIMENT=1 enabled

vendor/github.com/facebookgo/httpdown/httpdown.go

@@ -0,0 +1,380 @@
+// Package httpdown provides http.ConnState enabled graceful termination of
+// http.Server.
+package httpdown
+
+import (
+	"crypto/tls"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/facebookgo/clock"
+	"github.com/facebookgo/stats"
+)
+
+const (
+	defaultStopTimeout = time.Minute
+	defaultKillTimeout = time.Minute
+)
+
+// A Server allows encapsulates the process of accepting new connections and
+// serving them, and gracefully shutting down the listener without dropping
+// active connections.
+type Server interface {
+	// Wait waits for the serving loop to finish. This will happen when Stop is
+	// called, at which point it returns no error, or if there is an error in the
+	// serving loop. You must call Wait after calling Serve or ListenAndServe.
+	Wait() error
+
+	// Stop stops the listener. It will block until all connections have been
+	// closed.
+	Stop() error
+}
+
+// HTTP defines the configuration for serving a http.Server. Multiple calls to
+// Serve or ListenAndServe can be made on the same HTTP instance. The default
+// timeouts of 1 minute each result in a maximum of 2 minutes before a Stop()
+// returns.
+type HTTP struct {
+	// StopTimeout is the duration before we begin force closing connections.
+	// Defaults to 1 minute.
+	StopTimeout time.Duration
+
+	// KillTimeout is the duration before which we completely give up and abort
+	// even though we still have connected clients. This is useful when a large
+	// number of client connections exist and closing them can take a long time.
+	// Note, this is in addition to the StopTimeout. Defaults to 1 minute.
+	KillTimeout time.Duration
+
+	// Stats is optional. If provided, it will be used to record various metrics.
+	Stats stats.Client
+
+	// Clock allows for testing timing related functionality. Do not specify this
+	// in production code.
+	Clock clock.Clock
+}
+
+// Serve provides the low-level API which is useful if you're creating your own
+// net.Listener.
+func (h HTTP) Serve(s *http.Server, l net.Listener) Server {
+	stopTimeout := h.StopTimeout
+	if stopTimeout == 0 {
+		stopTimeout = defaultStopTimeout
+	}
+	killTimeout := h.KillTimeout
+	if killTimeout == 0 {
+		killTimeout = defaultKillTimeout
+	}
+	klock := h.Clock
+	if klock == nil {
+		klock = clock.New()
+	}
+
+	ss := &server{
+		stopTimeout:  stopTimeout,
+		killTimeout:  killTimeout,
+		stats:        h.Stats,
+		clock:        klock,
+		oldConnState: s.ConnState,
+		listener:     l,
+		server:       s,
+		serveDone:    make(chan struct{}),
+		serveErr:     make(chan error, 1),
+		new:          make(chan net.Conn),
+		active:       make(chan net.Conn),
+		idle:         make(chan net.Conn),
+		closed:       make(chan net.Conn),
+		stop:         make(chan chan struct{}),
+		kill:         make(chan chan struct{}),
+	}
+	s.ConnState = ss.connState
+	go ss.manage()
+	go ss.serve()
+	return ss
+}
+
+// ListenAndServe returns a Server for the given http.Server. It is equivalent
+// to ListenAndServe from the standard library, but returns immediately.
+// Requests will be accepted in a background goroutine. If the http.Server has
+// a non-nil TLSConfig, a TLS enabled listener will be setup.
+func (h HTTP) ListenAndServe(s *http.Server) (Server, error) {
+	addr := s.Addr
+	if addr == "" {
+		if s.TLSConfig == nil {
+			addr = ":http"
+		} else {
+			addr = ":https"
+		}
+	}
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		stats.BumpSum(h.Stats, "listen.error", 1)
+		return nil, err
+	}
+	if s.TLSConfig != nil {
+		l = tls.NewListener(l, s.TLSConfig)
+	}
+	return h.Serve(s, l), nil
+}
+
+// server manages the serving process and allows for gracefully stopping it.
+type server struct {
+	stopTimeout time.Duration
+	killTimeout time.Duration
+	stats       stats.Client
+	clock       clock.Clock
+
+	oldConnState func(net.Conn, http.ConnState)
+	server       *http.Server
+	serveDone    chan struct{}
+	serveErr     chan error
+	listener     net.Listener
+
+	new    chan net.Conn
+	active chan net.Conn
+	idle   chan net.Conn
+	closed chan net.Conn
+	stop   chan chan struct{}
+	kill   chan chan struct{}
+
+	stopOnce sync.Once
+	stopErr  error
+}
+
+func (s *server) connState(c net.Conn, cs http.ConnState) {
+	if s.oldConnState != nil {
+		s.oldConnState(c, cs)
+	}
+
+	switch cs {
+	case http.StateNew:
+		s.new <- c
+	case http.StateActive:
+		s.active <- c
+	case http.StateIdle:
+		s.idle <- c
+	case http.StateHijacked, http.StateClosed:
+		s.closed <- c
+	}
+}
+
+func (s *server) manage() {
+	defer func() {
+		close(s.new)
+		close(s.active)
+		close(s.idle)
+		close(s.closed)
+		close(s.stop)
+		close(s.kill)
+	}()
+
+	var stopDone chan struct{}
+
+	conns := map[net.Conn]http.ConnState{}
+	var countNew, countActive, countIdle float64
+
+	// decConn decrements the count associated with the current state of the
+	// given connection.
+	decConn := func(c net.Conn) {
+		switch conns[c] {
+		default:
+			panic(fmt.Errorf("unknown existing connection: %s", c))
+		case http.StateNew:
+			countNew--
+		case http.StateActive:
+			countActive--
+		case http.StateIdle:
+			countIdle--
+		}
+	}
+
+	// setup a ticker to report various values every minute. if we don't have a
+	// Stats implementation provided, we Stop it so it never ticks.
+	statsTicker := s.clock.Ticker(time.Minute)
+	if s.stats == nil {
+		statsTicker.Stop()
+	}
+
+	for {
+		select {
+		case <-statsTicker.C:
+			// we'll only get here when s.stats is not nil
+			s.stats.BumpAvg("http-state.new", countNew)
+			s.stats.BumpAvg("http-state.active", countActive)
+			s.stats.BumpAvg("http-state.idle", countIdle)
+			s.stats.BumpAvg("http-state.total", countNew+countActive+countIdle)
+		case c := <-s.new:
+			conns[c] = http.StateNew
+			countNew++
+		case c := <-s.active:
+			decConn(c)
+			countActive++
+
+			conns[c] = http.StateActive
+		case c := <-s.idle:
+			decConn(c)
+			countIdle++
+
+			conns[c] = http.StateIdle
+
+			// if we're already stopping, close it
+			if stopDone != nil {
+				c.Close()
+			}
+		case c := <-s.closed:
+			stats.BumpSum(s.stats, "conn.closed", 1)
+			decConn(c)
+			delete(conns, c)
+
+			// if we're waiting to stop and are all empty, we just closed the last
+			// connection and we're done.
+			if stopDone != nil && len(conns) == 0 {
+				close(stopDone)
+				return
+			}
+		case stopDone = <-s.stop:
+			// if we're already all empty, we're already done
+			if len(conns) == 0 {
+				close(stopDone)
+				return
+			}
+
+			// close current idle connections right away
+			for c, cs := range conns {
+				if cs == http.StateIdle {
+					c.Close()
+				}
+			}
+
+			// continue the loop and wait for all the ConnState updates which will
+			// eventually close(stopDone) and return from this goroutine.
+
+		case killDone := <-s.kill:
+			// force close all connections
+			stats.BumpSum(s.stats, "kill.conn.count", float64(len(conns)))
+			for c := range conns {
+				c.Close()
+			}
+
+			// don't block the kill.
+			close(killDone)
+
+			// continue the loop and we wait for all the ConnState updates and will
+			// return from this goroutine when we're all done. otherwise we'll try to
+			// send those ConnState updates on closed channels.
+
+		}
+	}
+}
+
+func (s *server) serve() {
+	stats.BumpSum(s.stats, "serve", 1)
+	s.serveErr <- s.server.Serve(s.listener)
+	close(s.serveDone)
+	close(s.serveErr)
+}
+
+func (s *server) Wait() error {
+	if err := <-s.serveErr; !isUseOfClosedError(err) {
+		return err
+	}
+	return nil
+}
+
+func (s *server) Stop() error {
+	s.stopOnce.Do(func() {
+		defer stats.BumpTime(s.stats, "stop.time").End()
+		stats.BumpSum(s.stats, "stop", 1)
+
+		// first disable keep-alive for new connections
+		s.server.SetKeepAlivesEnabled(false)
+
+		// then close the listener so new connections can't connect come thru
+		closeErr := s.listener.Close()
+		<-s.serveDone
+
+		// then trigger the background goroutine to stop and wait for it
+		stopDone := make(chan struct{})
+		s.stop <- stopDone
+
+		// wait for stop
+		select {
+		case <-stopDone:
+		case <-s.clock.After(s.stopTimeout):
+			defer stats.BumpTime(s.stats, "kill.time").End()
+			stats.BumpSum(s.stats, "kill", 1)
+
+			// stop timed out, wait for kill
+			killDone := make(chan struct{})
+			s.kill <- killDone
+			select {
+			case <-killDone:
+			case <-s.clock.After(s.killTimeout):
+				// kill timed out, give up
+				stats.BumpSum(s.stats, "kill.timeout", 1)
+			}
+		}
+
+		if closeErr != nil && !isUseOfClosedError(closeErr) {
+			stats.BumpSum(s.stats, "listener.close.error", 1)
+			s.stopErr = closeErr
+		}
+	})
+	return s.stopErr
+}
+
+func isUseOfClosedError(err error) bool {
+	if err == nil {
+		return false
+	}
+	if opErr, ok := err.(*net.OpError); ok {
+		err = opErr.Err
+	}
+	return err.Error() == "use of closed network connection"
+}
+
+// ListenAndServe is a convenience function to serve and wait for a SIGTERM
+// or SIGINT before shutting down.
+func ListenAndServe(s *http.Server, hd *HTTP) error {
+	if hd == nil {
+		hd = &HTTP{}
+	}
+	hs, err := hd.ListenAndServe(s)
+	if err != nil {
+		return err
+	}
+	log.Printf("serving on http://%s/ with pid %d\n", s.Addr, os.Getpid())
+
+	waiterr := make(chan error, 1)
+	go func() {
+		defer close(waiterr)
+		waiterr <- hs.Wait()
+	}()
+
+	signals := make(chan os.Signal, 10)
+	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)
+
+	select {
+	case err := <-waiterr:
+		if err != nil {
+			return err
+		}
+	case s := <-signals:
+		signal.Stop(signals)
+		log.Printf("signal received: %s\n", s)
+		if err := hs.Stop(); err != nil {
+			return err
+		}
+		if err := <-waiterr; err != nil {
+			return err
+		}
+	}
+	log.Println("exiting")
+	return nil
+}

vendor/github.com/facebookgo/httpdown/httpdown_test.go

@@ -0,0 +1,677 @@
+package httpdown_test
+
+import (
+	"bytes"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"regexp"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/facebookgo/clock"
+	"github.com/facebookgo/ensure"
+	"github.com/facebookgo/freeport"
+	"github.com/facebookgo/httpdown"
+	"github.com/facebookgo/stats"
+)
+
+type onCloseListener struct {
+	net.Listener
+	mutex   sync.Mutex
+	onClose chan struct{}
+}
+
+func (o *onCloseListener) Close() error {
+	// Listener is closed twice, once by Grace, and once by the http library, so
+	// we guard against a double close of the chan.
+	defer func() {
+		o.mutex.Lock()
+		defer o.mutex.Unlock()
+		if o.onClose != nil {
+			close(o.onClose)
+			o.onClose = nil
+		}
+	}()
+	return o.Listener.Close()
+}
+
+func NewOnCloseListener(l net.Listener) (net.Listener, chan struct{}) {
+	c := make(chan struct{})
+	return &onCloseListener{Listener: l, onClose: c}, c
+}
+
+type closeErrListener struct {
+	net.Listener
+	err error
+}
+
+func (c *closeErrListener) Close() error {
+	c.Listener.Close()
+	return c.err
+}
+
+type acceptErrListener struct {
+	net.Listener
+	err chan error
+}
+
+func (c *acceptErrListener) Accept() (net.Conn, error) {
+	return nil, <-c.err
+}
+
+type closeErrConn struct {
+	net.Conn
+	unblockClose chan chan struct{}
+}
+
+func (c *closeErrConn) Close() error {
+	ch := <-c.unblockClose
+
+	// Close gets called multiple times, but only the first one gets this ch
+	if ch != nil {
+		defer close(ch)
+	}
+
+	return c.Conn.Close()
+}
+
+type closeErrConnListener struct {
+	net.Listener
+	unblockClose chan chan struct{}
+}
+
+func (l *closeErrConnListener) Accept() (net.Conn, error) {
+	c, err := l.Listener.Accept()
+	if err != nil {
+		return c, err
+	}
+	return &closeErrConn{Conn: c, unblockClose: l.unblockClose}, nil
+}
+
+func TestHTTPStopWithNoRequest(t *testing.T) {
+	t.Parallel()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+
+	statsDone := make(chan struct{}, 2)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "serve" && val == 1 {
+				statsDone <- struct{}{}
+			}
+			if key == "stop" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	server := &http.Server{}
+	down := &httpdown.HTTP{Stats: hc}
+	s := down.Serve(server, listener)
+	ensure.Nil(t, s.Stop())
+	<-statsDone
+	<-statsDone
+}
+
+func TestHTTPStopWithFinishedRequest(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	fin := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(fin)
+		w.Write(hello)
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+
+	// At this point the request is finished, and the connection should be alive
+	// but idle (because we have keep alive enabled by default in our Transport).
+	ensure.Nil(t, s.Stop())
+	<-fin
+
+	ensure.Nil(t, s.Wait())
+}
+
+func TestHTTPStopWithActiveRequest(t *testing.T) {
+	t.Parallel()
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		for i := 0; i < count; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestNewRequestAfterStop(t *testing.T) {
+	t.Parallel()
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		const diff = 500
+		for i := 0; i < count-diff; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < diff; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	listener, onClose := NewOnCloseListener(listener)
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	// Wait until the listener is closed.
+	<-onClose
+
+	// Now the next request should not be able to connect as the listener is
+	// now closed.
+	_, err = client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+
+	// We should just get "connection refused" here, but sometimes, very rarely,
+	// we get a "connection reset" instead. Unclear why this happens.
+	ensure.Err(t, err, regexp.MustCompile("(connection refused|connection reset by peer)$"))
+
+	// Unblock the handler and ensure we finish writing the rest of the body
+	// successfully.
+	close(unblockOkHandler)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPListenerCloseError(t *testing.T) {
+	t.Parallel()
+	expectedError := errors.New("foo")
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	listener = &closeErrListener{Listener: listener, err: expectedError}
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	ensure.DeepEqual(t, s.Stop(), expectedError)
+}
+
+func TestHTTPServeError(t *testing.T) {
+	t.Parallel()
+	expectedError := errors.New("foo")
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	errChan := make(chan error)
+	listener = &acceptErrListener{Listener: listener, err: errChan}
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	errChan <- expectedError
+	ensure.DeepEqual(t, s.Wait(), expectedError)
+	ensure.Nil(t, s.Stop())
+}
+
+func TestHTTPWithinStopTimeout(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		w.Write(hello)
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{StopTimeout: time.Minute}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPStopTimeoutMissed(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	close(unblockOkHandler)
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPKillTimeout(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "kill" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		KillTimeout: time.Minute,
+		Stats:       hc,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	close(unblockOkHandler)
+	<-finOkHandler
+	<-finStop
+	<-statsDone
+}
+
+func TestHTTPKillTimeoutMissed(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "kill.timeout" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	unblockConnClose := make(chan chan struct{}, 1)
+	listener = &closeErrConnListener{
+		Listener:     listener,
+		unblockClose: unblockConnClose,
+	}
+
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		KillTimeout: time.Minute,
+		Stats:       hc,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	// Start the Stop process.
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)       // trigger stop timeout
+	klock.Wait(clock.Calls{After: 2}) // wait for Kill to call After
+	klock.Add(down.KillTimeout)       // trigger kill timeout
+
+	// We hit both the StopTimeout & the KillTimeout.
+	<-finStop
+
+	// Then we unblock the Close, so we get an unexpected EOF since we close
+	// before we finish writing the response.
+	connCloseDone := make(chan struct{})
+	unblockConnClose <- connCloseDone
+	<-connCloseDone
+	close(unblockConnClose)
+
+	// Then we unblock the handler which tries to write the rest of the data.
+	close(unblockOkHandler)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-statsDone
+}
+
+func TestDoubleStop(t *testing.T) {
+	t.Parallel()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	ensure.Nil(t, s.Stop())
+	ensure.Nil(t, s.Stop())
+}
+
+func TestExistingConnState(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	fin := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(fin)
+		w.Write(hello)
+	}
+
+	var called int32
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{
+		Handler: http.HandlerFunc(okHandler),
+		ConnState: func(c net.Conn, s http.ConnState) {
+			atomic.AddInt32(&called, 1)
+		},
+	}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+
+	ensure.Nil(t, s.Stop())
+	<-fin
+
+	ensure.True(t, atomic.LoadInt32(&called) > 0)
+}
+
+func TestHTTPDefaultListenError(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("cant run this test as root")
+	}
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "listen.error" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	t.Parallel()
+	down := &httpdown.HTTP{Stats: hc}
+	_, err := down.ListenAndServe(&http.Server{})
+	ensure.Err(t, err, regexp.MustCompile("listen tcp :80: bind: permission denied"))
+	<-statsDone
+}
+
+func TestHTTPSDefaultListenError(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("cant run this test as root")
+	}
+	t.Parallel()
+
+	cert, err := tls.X509KeyPair(localhostCert, localhostKey)
+	if err != nil {
+		t.Fatalf("error loading cert: %v", err)
+	}
+
+	down := &httpdown.HTTP{}
+	_, err = down.ListenAndServe(&http.Server{
+		TLSConfig: &tls.Config{
+			NextProtos:   []string{"http/1.1"},
+			Certificates: []tls.Certificate{cert},
+		},
+	})
+	ensure.Err(t, err, regexp.MustCompile("listen tcp :443: bind: permission denied"))
+}
+
+func TestTLS(t *testing.T) {
+	t.Parallel()
+	port, err := freeport.Get()
+	ensure.Nil(t, err)
+
+	cert, err := tls.X509KeyPair(localhostCert, localhostKey)
+	if err != nil {
+		t.Fatalf("error loading cert: %v", err)
+	}
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		for i := 0; i < count; i++ {
+			w.Write(hello)
+		}
+	}
+
+	server := &http.Server{
+		Addr:    fmt.Sprintf("0.0.0.0:%d", port),
+		Handler: http.HandlerFunc(okHandler),
+		TLSConfig: &tls.Config{
+			NextProtos:   []string{"http/1.1"},
+			Certificates: []tls.Certificate{cert},
+		},
+	}
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s, err := down.ListenAndServe(server)
+	ensure.Nil(t, err)
+	res, err := client.Get(fmt.Sprintf("https://%s/", server.Addr))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+// localhostCert is a PEM-encoded TLS cert with SAN IPs
+// "127.0.0.1" and "[::1]", expiring at the last second of 2049 (the end
+// of ASN.1 time).
+// generated from src/pkg/crypto/tls:
+// go run generate_cert.go  --rsa-bits 512 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h
+var localhostCert = []byte(`-----BEGIN CERTIFICATE-----
+MIIBdzCCASOgAwIBAgIBADALBgkqhkiG9w0BAQUwEjEQMA4GA1UEChMHQWNtZSBD
+bzAeFw03MDAxMDEwMDAwMDBaFw00OTEyMzEyMzU5NTlaMBIxEDAOBgNVBAoTB0Fj
+bWUgQ28wWjALBgkqhkiG9w0BAQEDSwAwSAJBALyCfqwwip8BvTKgVKGdmjZTU8DD
+ndR+WALmFPIRqn89bOU3s30olKiqYEju/SFoEvMyFRT/TWEhXHDaufThqaMCAwEA
+AaNoMGYwDgYDVR0PAQH/BAQDAgCkMBMGA1UdJQQMMAoGCCsGAQUFBwMBMA8GA1Ud
+EwEB/wQFMAMBAf8wLgYDVR0RBCcwJYILZXhhbXBsZS5jb22HBH8AAAGHEAAAAAAA
+AAAAAAAAAAAAAAEwCwYJKoZIhvcNAQEFA0EAr/09uy108p51rheIOSnz4zgduyTl
+M+4AmRo8/U1twEZLgfAGG/GZjREv2y4mCEUIM3HebCAqlA5jpRg76Rf8jw==
+-----END CERTIFICATE-----`)
+
+// localhostKey is the private key for localhostCert.
+var localhostKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
+MIIBOQIBAAJBALyCfqwwip8BvTKgVKGdmjZTU8DDndR+WALmFPIRqn89bOU3s30o
+lKiqYEju/SFoEvMyFRT/TWEhXHDaufThqaMCAwEAAQJAPXuWUxTV8XyAt8VhNQER
+LgzJcUKb9JVsoS1nwXgPksXnPDKnL9ax8VERrdNr+nZbj2Q9cDSXBUovfdtehcdP
+qQIhAO48ZsPylbTrmtjDEKiHT2Ik04rLotZYS2U873J6I7WlAiEAypDjYxXyafv/
+Yo1pm9onwcetQKMW8CS3AjuV9Axzj6cCIEx2Il19fEMG4zny0WPlmbrcKvD/DpJQ
+4FHrzsYlIVTpAiAas7S1uAvneqd0l02HlN9OxQKKlbUNXNme+rnOnOGS2wIgS0jW
+zl1jvrOSJeP1PpAHohWz6LOhEr8uvltWkN6x3vE=
+-----END RSA PRIVATE KEY-----`)

vendor/github.com/facebookgo/httpdown/license

@@ -0,0 +1,30 @@
+BSD License
+
+For httpdown software
+
+Copyright (c) 2015, Facebook, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name Facebook nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/facebookgo/httpdown/patents

@@ -0,0 +1,33 @@
+Additional Grant of Patent Rights Version 2
+
+"Software" means the httpdown software distributed by Facebook, Inc.
+
+Facebook, Inc. ("Facebook") hereby grants to each recipient of the Software
+("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
+(subject to the termination provision below) license under any Necessary
+Claims, to make, have made, use, sell, offer to sell, import, and otherwise
+transfer the Software. For avoidance of doubt, no license is granted under
+Facebook’s rights in any patent claims that are infringed by (i) modifications
+to the Software made by you or any third party or (ii) the Software in
+combination with any software or other technology.
+
+The license granted hereunder will terminate, automatically and without notice,
+if you (or any of your subsidiaries, corporate affiliates or agents) initiate
+directly or indirectly, or take a direct financial interest in, any Patent
+Assertion: (i) against Facebook or any of its subsidiaries or corporate
+affiliates, (ii) against any party if such Patent Assertion arises in whole or
+in part from any software, technology, product or service of Facebook or any of
+its subsidiaries or corporate affiliates, or (iii) against any party relating
+to the Software. Notwithstanding the foregoing, if Facebook or any of its
+subsidiaries or corporate affiliates files a lawsuit alleging patent
+infringement against you in the first instance, and you respond by filing a
+patent infringement counterclaim in that lawsuit against that party that is
+unrelated to the Software, the license granted hereunder will not terminate
+under section (i) of this paragraph due to such counterclaim.
+
+A "Necessary Claim" is a claim of a patent owned by Facebook that is
+necessarily infringed by the Software standing alone.
+
+A "Patent Assertion" is any lawsuit or other action alleging direct, indirect,
+or contributory infringement or inducement to infringe any patent, including a
+cross-claim or counterclaim.

vendor/github.com/facebookgo/httpdown/readme.md

@@ -0,0 +1,41 @@
+httpdown [![Build Status](https://secure.travis-ci.org/facebookgo/httpdown.png)](https://travis-ci.org/facebookgo/httpdown)
+========
+
+Documentation: https://godoc.org/github.com/facebookgo/httpdown
+
+Package httpdown provides a library that makes it easy to build a HTTP server
+that can be shutdown gracefully (that is, without dropping any connections).
+
+If you want graceful restart and not just graceful shutdown, look at the
+[grace](https://github.com/facebookgo/grace) package which uses this package
+underneath but also provides graceful restart.
+
+Usage
+-----
+
+Demo HTTP Server with graceful termination:
+https://github.com/facebookgo/httpdown/blob/master/httpdown_example/main.go
+
+1. Install the demo application
+
+        go get github.com/facebookgo/httpdown/httpdown_example
+
+1. Start it in the first terminal
+
+        httpdown_example
+
+   This will output something like:
+
+        2014/11/18 21:57:50 serving on http://127.0.0.1:8080/ with pid 17
+
+1. In a second terminal start a slow HTTP request
+
+        curl 'http://localhost:8080/?duration=20s'
+
+1. In a third terminal trigger a graceful shutdown (using the pid from your output):
+
+        kill -TERM 17
+
+This will demonstrate that the slow request was served before the server was
+shutdown. You could also have used `Ctrl-C` instead of `kill` as the example
+application triggers graceful shutdown on TERM or INT signals.