Add Inner Ring code

pkg/innerring/processors/netmap/processor.go

@@ -0,0 +1,131 @@
+package netmap
+
+import (
+	"github.com/nspcc-dev/neo-go/pkg/util"
+	"github.com/nspcc-dev/neofs-node/pkg/innerring/timers"
+	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
+	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
+	netmapEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
+	"github.com/panjf2000/ants/v2"
+	"github.com/pkg/errors"
+	"go.uber.org/zap"
+)
+
+type (
+	// EpochTimerReseter is a callback interface for tickers component.
+	EpochTimerReseter interface {
+		ResetEpochTimer()
+	}
+
+	// EpochState is a callback interface for inner ring global state.
+	EpochState interface {
+		SetEpochCounter(uint64)
+		EpochCounter() uint64
+	}
+
+	// ActiveState is a callback interface for inner ring global state.
+	ActiveState interface {
+		IsActive() bool
+	}
+
+	// Processor of events produced by network map contract
+	// and new epoch ticker, because it is related to contract.
+	Processor struct {
+		log            *zap.Logger
+		pool           *ants.Pool
+		netmapContract util.Uint160
+		epochTimer     EpochTimerReseter
+		epochState     EpochState
+		activeState    ActiveState
+		morphClient    *client.Client
+	}
+
+	// Params of the processor constructor.
+	Params struct {
+		Log            *zap.Logger
+		PoolSize       int
+		NetmapContract util.Uint160
+		EpochTimer     EpochTimerReseter
+		MorphClient    *client.Client
+		EpochState     EpochState
+		ActiveState    ActiveState
+	}
+)
+
+const (
+	newEpochNotification = "NewEpoch"
+)
+
+// New creates network map contract processor instance.
+func New(p *Params) (*Processor, error) {
+	switch {
+	case p.Log == nil:
+		return nil, errors.New("ir/netmap: logger is not set")
+	case p.MorphClient == nil:
+		return nil, errors.New("ir/netmap: morph client is not set")
+	case p.EpochTimer == nil:
+		return nil, errors.New("ir/netmap: epoch itmer is not set")
+	case p.EpochState == nil:
+		return nil, errors.New("ir/netmap: global state is not set")
+	case p.ActiveState == nil:
+		return nil, errors.New("ir/netmap: global state is not set")
+	}
+
+	p.Log.Debug("netmap worker pool", zap.Int("size", p.PoolSize))
+
+	pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
+	if err != nil {
+		return nil, errors.Wrap(err, "ir/netmap: can't create worker pool")
+	}
+
+	return &Processor{
+		log:            p.Log,
+		pool:           pool,
+		netmapContract: p.NetmapContract,
+		epochTimer:     p.EpochTimer,
+		epochState:     p.EpochState,
+		activeState:    p.ActiveState,
+		morphClient:    p.MorphClient,
+	}, nil
+}
+
+// ListenerParsers for the 'event.Listener' event producer.
+func (np *Processor) ListenerParsers() []event.ParserInfo {
+	var parsers []event.ParserInfo
+
+	// new epoch event
+	newEpoch := event.ParserInfo{}
+	newEpoch.SetType(newEpochNotification)
+	newEpoch.SetScriptHash(np.netmapContract)
+	newEpoch.SetParser(netmapEvent.ParseNewEpoch)
+	parsers = append(parsers, newEpoch)
+
+	return parsers
+}
+
+// ListenerHandlers for the 'event.Listener' event producer.
+func (np *Processor) ListenerHandlers() []event.HandlerInfo {
+	var handlers []event.HandlerInfo
+
+	// new epoch handler
+	newEpoch := event.HandlerInfo{}
+	newEpoch.SetType(newEpochNotification)
+	newEpoch.SetScriptHash(np.netmapContract)
+	newEpoch.SetHandler(np.handleNewEpoch)
+	handlers = append(handlers, newEpoch)
+
+	return handlers
+}
+
+// TimersHandlers for the 'Timers' event producer.
+func (np *Processor) TimersHandlers() []event.HandlerInfo {
+	var handlers []event.HandlerInfo
+
+	// new epoch handler
+	newEpoch := event.HandlerInfo{}
+	newEpoch.SetType(timers.EpochTimer)
+	newEpoch.SetHandler(np.handleNewEpochTick)
+	handlers = append(handlers, newEpoch)
+
+	return handlers
+}