2019-03-26 16:45:51 -05:00
|
|
|
package caddy2
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"net"
|
2019-03-26 20:42:52 -05:00
|
|
|
"sync"
|
2019-03-26 16:45:51 -05:00
|
|
|
"sync/atomic"
|
2019-04-02 15:58:24 -05:00
|
|
|
"time"
|
2019-03-26 16:45:51 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
// Listen returns a listener suitable for use in a Caddy module.
|
2019-05-16 17:05:38 -05:00
|
|
|
// Always be sure to close listeners when you are done with them.
|
2019-03-31 21:41:29 -05:00
|
|
|
func Listen(network, addr string) (net.Listener, error) {
|
|
|
|
lnKey := network + "/" + addr
|
2019-03-26 20:42:52 -05:00
|
|
|
|
|
|
|
listenersMu.Lock()
|
|
|
|
defer listenersMu.Unlock()
|
|
|
|
|
2019-04-02 16:31:02 -05:00
|
|
|
// if listener already exists, increment usage counter, then return listener
|
2019-05-16 17:05:38 -05:00
|
|
|
if lnUsage, ok := listeners[lnKey]; ok {
|
|
|
|
atomic.AddInt32(&lnUsage.usage, 1)
|
|
|
|
return &fakeCloseListener{usage: &lnUsage.usage, key: lnKey, Listener: lnUsage.ln}, nil
|
2019-03-26 20:42:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// or, create new one and save it
|
2019-03-31 21:41:29 -05:00
|
|
|
ln, err := net.Listen(network, addr)
|
2019-03-26 16:45:51 -05:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-03-26 20:42:52 -05:00
|
|
|
|
2019-04-02 16:31:02 -05:00
|
|
|
// make sure to start its usage counter at 1
|
2019-05-16 17:05:38 -05:00
|
|
|
lnUsage := &listenerUsage{usage: 1, ln: ln}
|
|
|
|
listeners[lnKey] = lnUsage
|
2019-04-02 16:31:02 -05:00
|
|
|
|
2019-05-16 17:05:38 -05:00
|
|
|
return &fakeCloseListener{usage: &lnUsage.usage, key: lnKey, Listener: ln}, nil
|
2019-03-26 16:45:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// fakeCloseListener's Close() method is a no-op. This allows
|
|
|
|
// stopping servers that are using the listener without giving
|
|
|
|
// up the socket; thus, servers become hot-swappable while the
|
|
|
|
// listener remains running. Listeners should be re-wrapped in
|
|
|
|
// a new fakeCloseListener each time the listener is reused.
|
|
|
|
type fakeCloseListener struct {
|
2019-04-02 16:31:02 -05:00
|
|
|
closed int32 // accessed atomically
|
|
|
|
usage *int32 // accessed atomically
|
2019-05-16 17:05:38 -05:00
|
|
|
key string
|
2019-03-26 16:45:51 -05:00
|
|
|
net.Listener
|
|
|
|
}
|
|
|
|
|
|
|
|
// Accept accepts connections until Close() is called.
|
|
|
|
func (fcl *fakeCloseListener) Accept() (net.Conn, error) {
|
2019-04-02 15:58:24 -05:00
|
|
|
// if the listener is already "closed", return error
|
2019-03-26 16:45:51 -05:00
|
|
|
if atomic.LoadInt32(&fcl.closed) == 1 {
|
2019-04-02 15:58:24 -05:00
|
|
|
return nil, fcl.fakeClosedErr()
|
2019-03-26 16:45:51 -05:00
|
|
|
}
|
2019-04-02 15:58:24 -05:00
|
|
|
|
|
|
|
// wrap underlying accept
|
|
|
|
conn, err := fcl.Listener.Accept()
|
|
|
|
if err == nil {
|
|
|
|
return conn, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if atomic.LoadInt32(&fcl.closed) == 1 {
|
|
|
|
// clear the deadline
|
|
|
|
switch ln := fcl.Listener.(type) {
|
|
|
|
case *net.TCPListener:
|
|
|
|
ln.SetDeadline(time.Time{})
|
|
|
|
case *net.UnixListener:
|
|
|
|
ln.SetDeadline(time.Time{})
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we cancelled the Accept() by setting a deadline
|
|
|
|
// on the listener, we need to make sure any callers of
|
|
|
|
// Accept() think the listener was actually closed;
|
|
|
|
// if we return the timeout error instead, callers might
|
|
|
|
// simply retry, leaking goroutines for longer
|
|
|
|
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
|
|
|
return nil, fcl.fakeClosedErr()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, err
|
2019-03-26 16:45:51 -05:00
|
|
|
}
|
|
|
|
|
2019-05-16 17:05:38 -05:00
|
|
|
// Close stops accepting new connections without
|
|
|
|
// closing the underlying listener, unless no one
|
|
|
|
// else is using it.
|
2019-03-26 16:45:51 -05:00
|
|
|
func (fcl *fakeCloseListener) Close() error {
|
2019-04-02 15:58:24 -05:00
|
|
|
if atomic.CompareAndSwapInt32(&fcl.closed, 0, 1) {
|
|
|
|
// unfortunately, there is no way to cancel any
|
|
|
|
// currently-blocking calls to Accept() that are
|
|
|
|
// awaiting connections since we're not actually
|
|
|
|
// closing the listener; so we cheat by setting
|
|
|
|
// a deadline in the past, which forces it to
|
|
|
|
// time out; note that this only works for
|
|
|
|
// certain types of listeners...
|
|
|
|
switch ln := fcl.Listener.(type) {
|
|
|
|
case *net.TCPListener:
|
|
|
|
ln.SetDeadline(time.Now().Add(-1 * time.Minute))
|
|
|
|
case *net.UnixListener:
|
|
|
|
ln.SetDeadline(time.Now().Add(-1 * time.Minute))
|
|
|
|
}
|
2019-04-02 16:31:02 -05:00
|
|
|
|
|
|
|
// since we're no longer using this listener,
|
2019-05-16 17:05:38 -05:00
|
|
|
// decrement the usage counter and, if no one
|
|
|
|
// else is using it, close underlying listener
|
|
|
|
if atomic.AddInt32(fcl.usage, -1) == 0 {
|
|
|
|
listenersMu.Lock()
|
|
|
|
delete(listeners, fcl.key)
|
|
|
|
listenersMu.Unlock()
|
|
|
|
err := fcl.Listener.Close()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-02 15:58:24 -05:00
|
|
|
}
|
|
|
|
|
2019-03-26 16:45:51 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-04-02 15:58:24 -05:00
|
|
|
func (fcl *fakeCloseListener) fakeClosedErr() error {
|
|
|
|
return &net.OpError{
|
|
|
|
Op: "accept",
|
|
|
|
Net: fcl.Listener.Addr().Network(),
|
|
|
|
Addr: fcl.Listener.Addr(),
|
2019-04-25 14:54:48 -05:00
|
|
|
Err: errFakeClosed,
|
2019-04-02 15:58:24 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrFakeClosed is the underlying error value returned by
|
|
|
|
// fakeCloseListener.Accept() after Close() has been called,
|
|
|
|
// indicating that it is pretending to be closed so that the
|
|
|
|
// server using it can terminate, while the underlying
|
|
|
|
// socket is actually left open.
|
2019-04-25 14:54:48 -05:00
|
|
|
var errFakeClosed = fmt.Errorf("listener 'closed' 😉")
|
2019-03-26 20:42:52 -05:00
|
|
|
|
2019-04-02 16:31:02 -05:00
|
|
|
// listenerUsage pairs a net.Listener with a
|
|
|
|
// count of how many servers are using it.
|
|
|
|
type listenerUsage struct {
|
|
|
|
usage int32 // accessed atomically
|
|
|
|
ln net.Listener
|
|
|
|
}
|
|
|
|
|
2019-03-26 20:42:52 -05:00
|
|
|
var (
|
2019-04-02 16:31:02 -05:00
|
|
|
listeners = make(map[string]*listenerUsage)
|
2019-03-26 20:42:52 -05:00
|
|
|
listenersMu sync.Mutex
|
|
|
|
)
|