Add Inner Ring code

pkg/morph/client/netmap/client.go

@@ -0,0 +1,156 @@
+package netmap
+
+import (
+	"errors"
+
+	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
+)
+
+// Client is a wrapper over StaticClient
+// which makes calls with the names and arguments
+// of the NeoFS Netmap contract.
+//
+// Working client must be created via constructor New.
+// Using the Client that has been created with new(Client)
+// expression (or just declaring a Client variable) is unsafe
+// and can lead to panic.
+type Client struct {
+	client *client.StaticClient // static Netmap contract client
+
+	*cfg // contract method names
+}
+
+// ErrNilClient is returned by functions that expect
+// a non-nil Client pointer, but received nil.
+var ErrNilClient = errors.New("netmap contract client is nil")
+
+// Option is a client configuration change function.
+type Option func(*cfg)
+
+type cfg struct {
+	addPeerMethod, // add peer method name for invocation
+	newEpochMethod, // new epoch method name for invocation
+	netMapMethod, // get network map method name
+	updateStateMethod, // update state method name for invocation
+	innerRingListMethod string // IR list method name for invocation
+}
+
+const (
+	defaultAddPeerMethod       = "AddPeer"       // default add peer method name
+	defaultNewEpochMethod      = "NewEpoch"      // default new epoch method name
+	defaultNetMapMethod        = "Netmap"        // default get network map method name
+	defaultUpdateStateMethod   = "UpdateState"   // default update state method name
+	defaultInnerRIngListMethod = "InnerRingList" // default IR list method name
+)
+
+func defaultConfig() *cfg {
+	return &cfg{
+		addPeerMethod:       defaultAddPeerMethod,
+		newEpochMethod:      defaultNewEpochMethod,
+		netMapMethod:        defaultNetMapMethod,
+		updateStateMethod:   defaultUpdateStateMethod,
+		innerRingListMethod: defaultInnerRIngListMethod,
+	}
+}
+
+// New creates, initializes and returns the Client instance.
+//
+// If StaticClient is nil, client.ErrNilStaticClient is returned.
+//
+// Other values are set according to provided options, or by default:
+//  * add peer method name: AddPeer;
+//  * new epoch method name: NewEpoch;
+//  * get network map method name: Netmap;
+//  * update state method name: UpdateState;
+//  * inner ring list method name: InnerRingList.
+//
+// If desired option satisfies the default value, it can be omitted.
+// If multiple options of the same config value are supplied,
+// the option with the highest index in the arguments will be used.
+func New(c *client.StaticClient, opts ...Option) (*Client, error) {
+	if c == nil {
+		return nil, client.ErrNilStaticClient
+	}
+
+	res := &Client{
+		client: c,
+		cfg:    defaultConfig(), // build default configuration
+	}
+
+	// apply options
+	for _, opt := range opts {
+		opt(res.cfg)
+	}
+
+	return res, nil
+}
+
+// WithAddPeerMethod returns a client constructor option that
+// specifies the method name of adding peer operation.
+//
+// Ignores empty value.
+//
+// If option not provided, "AddPeer" is used.
+func WithAddPeerMethod(n string) Option {
+	return func(c *cfg) {
+		if n != "" {
+			c.addPeerMethod = n
+		}
+	}
+}
+
+// WithNewEpochMethod returns a client constructor option that
+// specifies the method name of new epoch operation.
+//
+// Ignores empty value.
+//
+// If option not provided, "NewEpoch" is used.
+func WithNewEpochMethod(n string) Option {
+	return func(c *cfg) {
+		if n != "" {
+			c.newEpochMethod = n
+		}
+	}
+}
+
+// WithNetMapMethod returns a client constructor option that
+// specifies the method name of network map receiving operation.
+//
+// Ignores empty value.
+//
+// If option not provided, "Netmap" is used.
+func WithNetMapMethod(n string) Option {
+	return func(c *cfg) {
+		if n != "" {
+			c.netMapMethod = n
+		}
+	}
+}
+
+// WithUpdateStateMethod returns a client constructor option that
+// specifies the method name of peer state updating operation.
+//
+// Ignores empty value.
+//
+// If option not provided, "UpdateState" is used.
+func WithUpdateStateMethod(n string) Option {
+	return func(c *cfg) {
+		if n != "" {
+			c.updateStateMethod = n
+		}
+	}
+}
+
+// WithInnerRingListMethod returns a client constructor option that
+// specifies the method name of inner ring listing operation.
+//
+// Ignores empty value.
+//
+// If option not provided, "InnerRingList" is used.
+func WithInnerRingListMethod(n string) Option {
+	return func(c *cfg) {
+		if n != "" {
+			c.innerRingListMethod = n
+		}
+	}
+}