Initial commit

Initial public review release v0.10.0

lib/muxer/muxer.go

@@ -0,0 +1,247 @@
+package muxer
+
+import (
+	"context"
+	"net"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/multiformats/go-multiaddr"
+	"github.com/nspcc-dev/neofs-node/lib/peers"
+	"github.com/soheilhy/cmux"
+	"github.com/valyala/fasthttp"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+)
+
+type (
+	// StoreParams groups the parameters of network connections muxer constructor.
+	Params struct {
+		Logger      *zap.Logger
+		API         *fasthttp.Server
+		Address     multiaddr.Multiaddr
+		ShutdownTTL time.Duration
+		P2P         *grpc.Server
+		Peers       peers.Interface
+	}
+
+	// Mux is an interface of network connections muxer.
+	Mux interface {
+		Start(ctx context.Context)
+		Stop()
+	}
+
+	muxer struct {
+		peers peers.Interface
+		maddr multiaddr.Multiaddr
+		run   *int32
+		lis   net.Listener
+		log   *zap.Logger
+		ttl   time.Duration
+
+		p2p *grpc.Server
+		api *fasthttp.Server
+
+		done chan struct{}
+	}
+)
+
+const (
+	// we close listener, that's why we ignore this errors
+	errClosedConnection = "use of closed network connection"
+	errMuxListenerClose = "mux: listener closed"
+	errHTTPServerClosed = "http: Server closed"
+)
+
+var (
+	ignoredErrors = []string{
+		errClosedConnection,
+		errMuxListenerClose,
+		errHTTPServerClosed,
+	}
+)
+
+// New constructs network connections muxer and returns Mux interface.
+func New(p Params) Mux {
+	return &muxer{
+		maddr: p.Address,
+		ttl:   p.ShutdownTTL,
+		run:   new(int32),
+		api:   p.API,
+		p2p:   p.P2P,
+		log:   p.Logger,
+		peers: p.Peers,
+		done:  make(chan struct{}),
+	}
+}
+
+func needCatch(err error) bool {
+	if err == nil || containsErr(err) {
+		return false
+	}
+
+	return true
+}
+
+func containsErr(err error) bool {
+	for _, msg := range ignoredErrors {
+		if strings.Contains(err.Error(), msg) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (m *muxer) Start(ctx context.Context) {
+	var err error
+
+	// if already started - ignore
+	if !atomic.CompareAndSwapInt32(m.run, 0, 1) {
+		m.log.Warn("already started")
+		return
+	} else if m.lis != nil {
+		m.log.Info("try close old listener")
+		if err = m.lis.Close(); err != nil {
+			m.log.Fatal("could not close old listener",
+				zap.Error(err))
+		}
+	}
+
+	lis, err := m.peers.Listen(m.maddr)
+	if err != nil {
+		m.log.Fatal("could not close old listener",
+			zap.Error(err))
+	}
+
+	m.lis = NetListener(lis)
+
+	m.log.Info("create mux-listener",
+		zap.String("bind-address", m.lis.Addr().String()))
+
+	mux := cmux.New(m.lis)
+	mux.HandleError(func(e error) bool {
+		if needCatch(e) {
+			m.log.Error("error-handler: something went wrong",
+				zap.Error(e))
+		}
+		return true
+	})
+
+	// trpcL := mux.Match(cmux.Any()) // Any means anything that is not yet matched.
+	hLis := mux.Match(cmux.HTTP1Fast())
+	gLis := mux.Match(cmux.HTTP2())
+	pLis := mux.Match(cmux.Any())
+
+	m.log.Debug("delay context worker")
+
+	go func() {
+		<-ctx.Done()
+		m.Stop()
+	}()
+
+	m.log.Debug("delay tcp")
+
+	go func() {
+		m.log.Debug("tcp: serve")
+	loop:
+		for {
+			select {
+			case <-ctx.Done():
+				break loop
+			default:
+			}
+
+			con, err := pLis.Accept()
+			if err != nil {
+				break loop
+			}
+
+			_ = con.Close()
+		}
+
+		m.log.Debug("tcp: stopped")
+	}()
+
+	m.log.Debug("delay p2p")
+
+	go func() {
+		if m.p2p == nil {
+			m.log.Info("p2p: service is empty")
+			return
+		}
+
+		m.log.Debug("p2p: serve")
+
+		if err := m.p2p.Serve(gLis); needCatch(err) {
+			m.log.Error("p2p: something went wrong",
+				zap.Error(err))
+		}
+
+		m.log.Debug("p2p: stopped")
+	}()
+
+	m.log.Debug("delay api")
+
+	go func() {
+		if m.api == nil {
+			m.log.Info("api: service is empty")
+			return
+		}
+
+		m.log.Debug("api: serve")
+
+		if err := m.api.Serve(hLis); needCatch(err) {
+			m.log.Error("rpc: something went wrong",
+				zap.Error(err))
+		}
+
+		m.log.Debug("rpc: stopped")
+	}()
+
+	m.log.Debug("delay serve")
+
+	go func() {
+		defer func() { close(m.done) }()
+
+		m.log.Debug("mux: serve")
+
+		if err := mux.Serve(); needCatch(err) {
+			m.log.Fatal("mux: something went wrong",
+				zap.Error(err))
+		}
+
+		m.log.Debug("mux: stopped")
+	}()
+}
+
+func (m *muxer) Stop() {
+	if !atomic.CompareAndSwapInt32(m.run, 1, 0) {
+		m.log.Warn("already stopped")
+		return
+	}
+
+	if err := m.lis.Close(); err != nil {
+		m.log.Error("could not close connection",
+			zap.Error(err))
+	}
+
+	m.log.Debug("lis: close ok")
+
+	<-m.done // muxer stopped
+
+	if m.api != nil {
+		if err := m.api.Shutdown(); needCatch(err) {
+			m.log.Error("api: could not shutdown",
+				zap.Error(err))
+		}
+
+		m.log.Debug("api: shutdown ok")
+	}
+
+	if m.p2p != nil {
+		m.p2p.GracefulStop()
+		m.log.Debug("p2p: shutdown ok")
+	}
+}