Add Inner Ring code

cmd/neofs-node/modules/fix/catch.go

@@ -0,0 +1,59 @@
+package fix
+
+import (
+	"fmt"
+	"reflect"
+
+	"go.uber.org/zap"
+)
+
+func (a *app) Catch(err error) {
+	if err == nil {
+		return
+	}
+
+	if a.log == nil {
+		panic(err)
+	}
+
+	a.log.Fatal("Can't run app",
+		zap.Error(err))
+}
+
+// CatchTrace catch errors for debugging
+// use that function just for debug your application.
+func (a *app) CatchTrace(err error) {
+	if err == nil {
+		return
+	}
+
+	// digging into the root of the problem
+	for {
+		var (
+			ok bool
+			v  = reflect.ValueOf(err)
+			fn reflect.Value
+		)
+
+		if v.Type().Kind() != reflect.Struct {
+			break
+		}
+
+		if !v.FieldByName("Reason").IsValid() {
+			break
+		}
+
+		if v.FieldByName("Func").IsValid() {
+			fn = v.FieldByName("Func")
+		}
+
+		fmt.Printf("Place: %#v\nReason: %s\n\n", fn, err)
+
+		if err, ok = v.FieldByName("Reason").Interface().(error); !ok {
+			err = v.Interface().(error)
+			break
+		}
+	}
+
+	panic(err)
+}

cmd/neofs-node/modules/fix/config/config.go

@@ -0,0 +1,53 @@
+package config
+
+import (
+	"strings"
+
+	"github.com/spf13/viper"
+)
+
+// Params groups the parameters of configuration.
+type Params struct {
+	File    string
+	Type    string
+	Prefix  string
+	Name    string
+	Version string
+
+	AppDefaults func(v *viper.Viper)
+}
+
+// NewConfig is a configuration tool's constructor.
+func NewConfig(p Params) (v *viper.Viper, err error) {
+	v = viper.New()
+	v.SetEnvPrefix(p.Prefix)
+	v.AutomaticEnv()
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+
+	v.SetDefault("app.name", p.Name)
+	v.SetDefault("app.version", p.Version)
+
+	if p.AppDefaults != nil {
+		p.AppDefaults(v)
+	}
+
+	if p.fromFile() {
+		v.SetConfigFile(p.File)
+		v.SetConfigType(p.safeType())
+
+		err = v.ReadInConfig()
+	}
+
+	return v, err
+}
+
+func (p Params) fromFile() bool {
+	return p.File != ""
+}
+
+func (p Params) safeType() string {
+	if p.Type == "" {
+		p.Type = "yaml"
+	}
+	return strings.ToLower(p.Type)
+}

cmd/neofs-node/modules/fix/fix.go

@@ -0,0 +1,113 @@
+package fix
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/nspcc-dev/neofs-node/cmd/neofs-node/modules/fix/config"
+	"github.com/nspcc-dev/neofs-node/cmd/neofs-node/modules/fix/module"
+	"github.com/nspcc-dev/neofs-node/misc"
+	"github.com/nspcc-dev/neofs-node/pkg/util/grace"
+	"github.com/nspcc-dev/neofs-node/pkg/util/logger"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"go.uber.org/dig"
+	"go.uber.org/zap"
+)
+
+type (
+	// App is an interface of executable application.
+	App interface {
+		Run() error
+		RunAndCatch()
+	}
+
+	app struct {
+		err    error
+		log    *zap.Logger
+		di     *dig.Container
+		runner interface{}
+	}
+
+	// Settings groups the application parameters.
+	Settings struct {
+		File    string
+		Type    string
+		Name    string
+		Prefix  string
+		Build   string
+		Version string
+		Runner  interface{}
+
+		AppDefaults func(v *viper.Viper)
+	}
+)
+
+func (a *app) RunAndCatch() {
+	err := a.Run()
+
+	if errors.Is(err, context.Canceled) {
+		return
+	}
+
+	if ok, _ := strconv.ParseBool(misc.Debug); ok {
+		a.CatchTrace(err)
+	}
+
+	a.Catch(err)
+}
+
+func (a *app) Run() error {
+	if a.err != nil {
+		return a.err
+	}
+
+	// setup app logger:
+	if err := a.di.Invoke(func(l *zap.Logger) {
+		a.log = l
+	}); err != nil {
+		return err
+	}
+
+	return a.di.Invoke(a.runner)
+}
+
+// New is an application constructor.
+func New(s *Settings, mod module.Module) App {
+	var (
+		a   app
+		err error
+	)
+
+	a.di = dig.New(dig.DeferAcyclicVerification())
+	a.runner = s.Runner
+
+	if s.Prefix == "" {
+		s.Prefix = s.Name
+	}
+
+	mod = mod.Append(
+		module.Module{
+			{Constructor: logger.NewLogger},
+			{Constructor: grace.NewGracefulContext},
+			{Constructor: func() (*viper.Viper, error) {
+				return config.NewConfig(config.Params{
+					File:    s.File,
+					Type:    s.Type,
+					Prefix:  strings.ToUpper(s.Prefix),
+					Name:    s.Name,
+					Version: fmt.Sprintf("%s(%s)", s.Version, s.Build),
+
+					AppDefaults: s.AppDefaults,
+				})
+			}},
+		})
+
+	if err = module.Provide(a.di, mod); err != nil {
+		a.err = err
+	}
+
+	return &a
+}

cmd/neofs-node/modules/fix/module/module.go

@@ -0,0 +1,35 @@
+package module
+
+import (
+	"go.uber.org/dig"
+)
+
+type (
+	// Module type
+	Module []*Provider
+
+	// Provider struct
+	Provider struct {
+		Constructor interface{}
+		Options     []dig.ProvideOption
+	}
+)
+
+// Append module to target module and return new module
+func (m Module) Append(mods ...Module) Module {
+	var result = m
+	for _, mod := range mods {
+		result = append(result, mod...)
+	}
+	return result
+}
+
+// Provide set providers functions to DI container
+func Provide(dic *dig.Container, providers Module) error {
+	for _, p := range providers {
+		if err := dic.Provide(p.Constructor, p.Options...); err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/neofs-node/modules/fix/services.go

@@ -0,0 +1,46 @@
+package fix
+
+import (
+	"context"
+)
+
+type (
+	// Service interface
+	Service interface {
+		Start(context.Context)
+		Stop()
+	}
+
+	combiner []Service
+)
+
+var _ Service = (combiner)(nil)
+
+// NewServices creates single runner.
+func NewServices(items ...Service) Service {
+	var svc = make(combiner, 0, len(items))
+
+	for _, item := range items {
+		if item == nil {
+			continue
+		}
+
+		svc = append(svc, item)
+	}
+
+	return svc
+}
+
+// Start all services.
+func (c combiner) Start(ctx context.Context) {
+	for _, svc := range c {
+		svc.Start(ctx)
+	}
+}
+
+// Stop all services.
+func (c combiner) Stop() {
+	for _, svc := range c {
+		svc.Stop()
+	}
+}

cmd/neofs-node/modules/fix/worker/worker.go

@@ -0,0 +1,79 @@
+package worker
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+type (
+	// Workers is an interface of worker tool.
+	Workers interface {
+		Start(context.Context)
+		Stop()
+
+		Add(Job Handler)
+	}
+
+	workers struct {
+		cancel  context.CancelFunc
+		started *int32
+		wg      *sync.WaitGroup
+		jobs    []Handler
+	}
+
+	// Handler is a worker's handling function.
+	Handler func(ctx context.Context)
+
+	// Jobs is a map of worker names to handlers.
+	Jobs map[string]Handler
+
+	// Job groups the parameters of worker's job.
+	Job struct {
+		Disabled    bool
+		Immediately bool
+		Timer       time.Duration
+		Ticker      time.Duration
+		Handler     Handler
+	}
+)
+
+// New is a constructor of workers.
+func New() Workers {
+	return &workers{
+		started: new(int32),
+		wg:      new(sync.WaitGroup),
+	}
+}
+
+func (w *workers) Add(job Handler) {
+	w.jobs = append(w.jobs, job)
+}
+
+func (w *workers) Stop() {
+	if !atomic.CompareAndSwapInt32(w.started, 1, 0) {
+		// already stopped
+		return
+	}
+
+	w.cancel()
+	w.wg.Wait()
+}
+
+func (w *workers) Start(ctx context.Context) {
+	if !atomic.CompareAndSwapInt32(w.started, 0, 1) {
+		// already started
+		return
+	}
+
+	ctx, w.cancel = context.WithCancel(ctx)
+	for _, job := range w.jobs {
+		w.wg.Add(1)
+
+		go func(handler Handler) {
+			defer w.wg.Done()
+			handler(ctx)
+		}(job)
+	}
+}