frostfs-node/pkg/innerring/processors/netmap/processor.go

package netmap

import (
	"errors"
	"fmt"

	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/innerring/metrics"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/innerring/processors/netmap/nodevalidation/state"
	cntClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/container"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/event"
	netmapEvent "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/event/netmap"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
	"github.com/nspcc-dev/neo-go/pkg/core/mempoolevent"
	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/panjf2000/ants/v2"
	"go.uber.org/zap"
)

type (
	// EpochTimerReseter is a callback interface for tickers component.
	EpochTimerReseter interface {
		ResetEpochTimer(uint32) error
	}

	// EpochState is a callback interface for inner ring global state.
	EpochState interface {
		SetEpochCounter(uint64)
		EpochCounter() uint64
		SetEpochDuration(uint64)
		EpochDuration() uint64
	}

	// AlphabetState is a callback interface for inner ring global state.
	AlphabetState interface {
		IsAlphabet() bool
	}

	// NodeValidator wraps basic method of checking the correctness
	// of information about the node and its finalization for adding
	// to the network map.
	NodeValidator interface {
		// VerifyAndUpdate must verify and optionally update NodeInfo structure.
		//
		// Must return an error if NodeInfo input is invalid.
		// Must return an error if it is not possible to correctly
		// change the structure for sending to the network map.
		//
		// If no error occurs, the parameter must point to the
		// ready-made NodeInfo structure.
		VerifyAndUpdate(*netmap.NodeInfo) error
	}

	Client interface {
		MorphNotaryInvoke(contract util.Uint160, fee fixedn.Fixed8, nonce uint32, vub *uint32, method string, args ...any) error
		ContractAddress() util.Uint160
		EpochDuration() (uint64, error)
		MorphTxHeight(h util.Uint256) (res uint32, err error)
		NetMap() (*netmap.NetMap, error)
		NewEpoch(epoch uint64) error
		MorphIsValidScript(script []byte, signers []transaction.Signer) (valid bool, err error)
		MorphNotarySignAndInvokeTX(mainTx *transaction.Transaction) error
	}

	ContainerClient interface {
		StartEstimation(p cntClient.StartEstimationPrm) error
	}

	// Processor of events produced by network map contract
	// and new epoch ticker, because it is related to contract.
	Processor struct {
		log           *logger.Logger
		metrics       metrics.Register
		pool          *ants.Pool
		epochTimer    EpochTimerReseter
		epochState    EpochState
		alphabetState AlphabetState

		netmapClient Client
		containerWrp ContainerClient

		netmapSnapshot cleanupTable

		handleAlphabetSync  event.Handler
		handleNotaryDeposit event.Handler

		nodeValidator NodeValidator

		nodeStateSettings state.NetworkSettings
	}

	// Params of the processor constructor.
	Params struct {
		Log              *logger.Logger
		Metrics          metrics.Register
		PoolSize         int
		NetmapClient     Client
		EpochTimer       EpochTimerReseter
		EpochState       EpochState
		AlphabetState    AlphabetState
		CleanupEnabled   bool
		CleanupThreshold uint64 // in epochs
		ContainerWrapper ContainerClient

		AlphabetSyncHandler  event.Handler
		NotaryDepositHandler event.Handler

		NodeValidator NodeValidator

		NodeStateSettings state.NetworkSettings
	}
)

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.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.AlphabetState == nil:
		return nil, errors.New("ir/netmap: global state is not set")
	case p.AlphabetSyncHandler == nil:
		return nil, errors.New("ir/netmap: alphabet sync handler is not set")
	case p.NotaryDepositHandler == nil:
		return nil, errors.New("ir/netmap: notary deposit handler is not set")
	case p.ContainerWrapper == nil:
		return nil, errors.New("ir/netmap: container contract wrapper is not set")
	case p.NodeValidator == nil:
		return nil, errors.New("ir/netmap: node validator is not set")
	case p.NodeStateSettings == nil:
		return nil, errors.New("ir/netmap: node state settings is not set")
	}

	p.Log.Debug(logs.NetmapNetmapWorkerPool, zap.Int("size", p.PoolSize))

	pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
	if err != nil {
		return nil, fmt.Errorf("ir/netmap: can't create worker pool: %w", err)
	}

	metricsRegister := p.Metrics
	if metricsRegister == nil {
		metricsRegister = metrics.DefaultRegister{}
	}

	return &Processor{
		log:            p.Log,
		metrics:        metricsRegister,
		pool:           pool,
		epochTimer:     p.EpochTimer,
		epochState:     p.EpochState,
		alphabetState:  p.AlphabetState,
		netmapClient:   p.NetmapClient,
		containerWrp:   p.ContainerWrapper,
		netmapSnapshot: newCleanupTable(p.CleanupEnabled, p.CleanupThreshold),

		handleAlphabetSync: p.AlphabetSyncHandler,

		handleNotaryDeposit: p.NotaryDepositHandler,

		nodeValidator: p.NodeValidator,

		nodeStateSettings: p.NodeStateSettings,
	}, nil
}

// ListenerNotificationParsers for the 'event.Listener' event producer.
func (np *Processor) ListenerNotificationParsers() []event.NotificationParserInfo {
	parsers := make([]event.NotificationParserInfo, 0, 3)

	var p event.NotificationParserInfo

	p.SetScriptHash(np.netmapClient.ContractAddress())

	// new epoch event
	p.SetType(newEpochNotification)
	p.SetParser(netmapEvent.ParseNewEpoch)
	parsers = append(parsers, p)

	return parsers
}

// ListenerNotificationHandlers for the 'event.Listener' event producer.
func (np *Processor) ListenerNotificationHandlers() []event.NotificationHandlerInfo {
	handlers := make([]event.NotificationHandlerInfo, 0, 3)

	var i event.NotificationHandlerInfo

	i.SetScriptHash(np.netmapClient.ContractAddress())

	// new epoch handler
	i.SetType(newEpochNotification)
	i.SetHandler(np.handleNewEpoch)
	handlers = append(handlers, i)

	return handlers
}

// ListenerNotaryParsers for the 'event.Listener' event producer.
func (np *Processor) ListenerNotaryParsers() []event.NotaryParserInfo {
	var (
		p event.NotaryParserInfo

		pp = make([]event.NotaryParserInfo, 0, 2)
	)

	p.SetMempoolType(mempoolevent.TransactionAdded)
	p.SetScriptHash(np.netmapClient.ContractAddress())

	// new peer
	p.SetRequestType(netmapEvent.AddPeerNotaryEvent)
	p.SetParser(netmapEvent.ParseAddPeerNotary)
	pp = append(pp, p)

	// update state
	p.SetRequestType(netmapEvent.UpdateStateNotaryEvent)
	p.SetParser(netmapEvent.ParseUpdatePeerNotary)
	pp = append(pp, p)

	return pp
}

// ListenerNotaryHandlers for the 'event.Listener' event producer.
func (np *Processor) ListenerNotaryHandlers() []event.NotaryHandlerInfo {
	var (
		h event.NotaryHandlerInfo

		hh = make([]event.NotaryHandlerInfo, 0, 2)
	)

	h.SetMempoolType(mempoolevent.TransactionAdded)
	h.SetScriptHash(np.netmapClient.ContractAddress())

	// new peer
	h.SetRequestType(netmapEvent.AddPeerNotaryEvent)
	h.SetHandler(np.handleAddPeer)
	hh = append(hh, h)

	// update state
	h.SetRequestType(netmapEvent.UpdateStateNotaryEvent)
	h.SetHandler(np.handleUpdateState)
	hh = append(hh, h)

	return hh
}