Now supports socket activation

multilistener/listener.go

@@ -0,0 +1,125 @@
+package multilistener
+
+import (
+	"fmt"
+	"net"
+)
+
+// Listener implements a net.Listener interface but multiplexes connections
+// from multiple listeners.
+type Listener struct {
+	listeners []net.Listener
+	closing   chan struct{}
+	conns     chan acceptResults
+}
+
+type acceptResults struct {
+	conn net.Conn
+	err  error
+}
+
+var _ net.Listener = &Listener{}
+
+// New creates an instance of a Listener using the given listeners. You must
+// pass at least one listener. The new listener object listens for new connection
+// on all the given listeners.
+func New(listeners ...net.Listener) (*Listener, error) {
+
+	if len(listeners) == 0 {
+		return nil, fmt.Errorf("multilistener requires at least 1 listener")
+	}
+
+	n := &Listener{
+		listeners: listeners,
+		closing:   make(chan struct{}),
+		conns:     make(chan acceptResults),
+	}
+	for i := range n.listeners {
+		go n.loop(n.listeners[i])
+	}
+	return n, nil
+
+}
+
+// Addr returns the address of the first listener the multi-listener is using.
+// The address of other listeners are not available.
+func (l *Listener) Addr() net.Addr {
+	return l.listeners[0].Addr()
+}
+
+// Close will close the multi-listener by iterating over its listeners and calling
+// Close() on each one. If an error is encountered, it is returned. If multiple
+// errors are encountered they are returned in a MutiError. Close will also shut down
+// the background goroutines that are calling Accept() on the underlying listeners.
+//
+// Calling Close() more than once will cause it to panic.
+func (l *Listener) Close() error {
+	close(l.closing)
+	var errors []error
+	for i := range l.listeners {
+		err := l.listeners[i].Close()
+		if err != nil {
+			errors = append(errors, err)
+		}
+	}
+	switch len(errors) {
+	case 0:
+		return nil
+	case 1:
+		return errors[0]
+	}
+	return &MultiError{Errors: errors}
+}
+
+// MultiError is a wrapper around a slice of errors that implements the error interface.
+type MultiError struct {
+	Errors []error
+}
+
+// Error concats the Error() messages of the underlying errors
+func (m *MultiError) Error() string {
+	if len(m.Errors) == 0 {
+		return ""
+	}
+	s := "errors: "
+	for _, e := range m.Errors {
+		s += e.Error() + ", "
+	}
+	return s
+}
+
+// loop continually accepts connections from the given listener. It forwards the result
+// of the .Accept() method to a channel on the listener. When a user of the Listener object
+// calls Accept(), it receives a value from that channel. Closing the listener will cause
+// this loop to exit.
+func (l *Listener) loop(listener net.Listener) {
+	for {
+		conn, err := listener.Accept()
+		r := acceptResults{
+			conn: conn,
+			err:  err,
+		}
+		select {
+		case l.conns <- r:
+		case <-l.closing:
+			if r.err == nil {
+				r.conn.Close()
+			}
+			return
+		}
+	}
+}
+
+// Accept will wait for a result from calling Accept from the underlying listeners.
+// It will return an error if the multi-listener is closed.
+func (l *Listener) Accept() (net.Conn, error) {
+	select {
+	case acceptResult, ok := <-l.conns:
+		if ok {
+			return acceptResult.conn, acceptResult.err
+		}
+		return nil, fmt.Errorf("closed conn channel")
+	case <-l.closing:
+		return nil, fmt.Errorf("listener is closed")
+	}
+}