From 0dab4b758135934d4544238456eaddb4664b7f68 Mon Sep 17 00:00:00 2001 From: Leonard Lyubich Date: Wed, 21 Oct 2020 12:24:02 +0300 Subject: [PATCH] [#108] services: Implement Policer service Implement Policer service that performs background work to check compliance with the placement policy for local objects in the container. In the initial implementation, the selection of the working queue of objects is simplified, and there is no transfer of the result to the replicator. Signed-off-by: Leonard Lyubich --- pkg/services/policer/check.go | 103 +++++++++++++++++++++++ pkg/services/policer/policer.go | 140 ++++++++++++++++++++++++++++++++ pkg/services/policer/process.go | 114 ++++++++++++++++++++++++++ pkg/services/policer/queue.go | 28 +++++++ 4 files changed, 385 insertions(+) create mode 100644 pkg/services/policer/check.go create mode 100644 pkg/services/policer/policer.go create mode 100644 pkg/services/policer/process.go create mode 100644 pkg/services/policer/queue.go diff --git a/pkg/services/policer/check.go b/pkg/services/policer/check.go new file mode 100644 index 000000000..85f2a6c41 --- /dev/null +++ b/pkg/services/policer/check.go @@ -0,0 +1,103 @@ +package policer + +import ( + "context" + "strings" + + "github.com/nspcc-dev/neofs-api-go/pkg/netmap" + "github.com/nspcc-dev/neofs-api-go/pkg/object" + "github.com/nspcc-dev/neofs-node/pkg/network" + headsvc "github.com/nspcc-dev/neofs-node/pkg/services/object/head" + "go.uber.org/zap" +) + +func (p *Policer) processObject(ctx context.Context, addr *object.Address) { + cnr, err := p.cnrSrc.Get(addr.GetContainerID()) + if err != nil { + p.log.Error("could not get container", + zap.String("error", err.Error()), + ) + + return + } + + policy := cnr.GetPlacementPolicy() + + nn, err := p.placementBuilder.BuildPlacement(addr, policy) + if err != nil { + p.log.Error("could not build placement vector for object", + zap.String("error", err.Error()), + ) + + return + } + + replicas := policy.GetReplicas() + + for i := range nn { + select { + case <-ctx.Done(): + return + default: + } + + p.processNodes(ctx, addr, nn[i], replicas[i].GetCount()) + } +} + +func (p *Policer) processNodes(ctx context.Context, addr *object.Address, nodes netmap.Nodes, shortage uint32) { + prm := new(headsvc.RemoteHeadPrm).WithObjectAddress(addr) + + for i := 0; shortage > 0 && i < len(nodes); i++ { + select { + case <-ctx.Done(): + return + default: + } + + netAddr := nodes[i].NetworkAddress() + + log := p.log.With(zap.String("node", netAddr)) + + node, err := network.AddressFromString(netAddr) + if err != nil { + log.Error("could not parse network address") + + continue + } + + if network.IsLocalAddress(p.localAddrSrc, node) { + shortage-- + } else { + callCtx, cancel := context.WithTimeout(ctx, p.headTimeout) + + _, err = p.remoteHeader.Head(callCtx, prm.WithNodeAddress(node)) + + cancel() + + if err != nil { + // FIXME: this is a temporary solution to resolve 404 response from remote node + // We need to distinguish problem nodes from nodes without an object. + if strings.Contains(err.Error(), headsvc.ErrNotFound.Error()) { + continue + } else { + log.Error("could not receive object header", + zap.String("error", err.Error()), + ) + } + } else { + shortage-- + } + } + + nodes = append(nodes[:i], nodes[i+1:]...) + i-- + } + + if shortage > 0 { + p.log.Info("shortage of object copies detected", + zap.Uint32("shortage", shortage), + ) + // TODO: send task to replicator + } +} diff --git a/pkg/services/policer/policer.go b/pkg/services/policer/policer.go new file mode 100644 index 000000000..8a0d5e57d --- /dev/null +++ b/pkg/services/policer/policer.go @@ -0,0 +1,140 @@ +package policer + +import ( + "sync" + "time" + + "github.com/nspcc-dev/neofs-node/pkg/core/container" + "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/localstore" + "github.com/nspcc-dev/neofs-node/pkg/network" + headsvc "github.com/nspcc-dev/neofs-node/pkg/services/object/head" + "github.com/nspcc-dev/neofs-node/pkg/services/object_manager/placement" + "github.com/nspcc-dev/neofs-node/pkg/util/logger" + "go.uber.org/zap" +) + +// Policer represents the utility that verifies +// compliance with the object storage policy. +type Policer struct { + *cfg + + prevTask prevTask +} + +// Option is an option for Policer constructor. +type Option func(*cfg) + +type cfg struct { + headTimeout time.Duration + + workScope workScope + + log *logger.Logger + + trigger <-chan *Task + + jobQueue jobQueue + + cnrSrc container.Source + + placementBuilder placement.Builder + + remoteHeader *headsvc.RemoteHeader + + localAddrSrc network.LocalAddressSource +} + +func defaultCfg() *cfg { + return &cfg{ + log: zap.L(), + } +} + +// New creates, initializes and returns Policer instance. +func New(opts ...Option) *Policer { + c := defaultCfg() + + for i := range opts { + opts[i](c) + } + + c.log = c.log.With(zap.String("component", "Object Policer")) + + return &Policer{ + cfg: c, + prevTask: prevTask{ + cancel: func() {}, + wait: new(sync.WaitGroup), + }, + } +} + +// WithHeadTimeout returns option to set Head timeout of Policer. +func WithHeadTimeout(v time.Duration) Option { + return func(c *cfg) { + c.headTimeout = v + } +} + +// WithWorkScope returns option to set job work scope value of Policer. +func WithWorkScope(v int) Option { + return func(c *cfg) { + c.workScope.val = v + } +} + +// WithExpansionRate returns option to set expansion rate of Policer's works scope (in %). +func WithExpansionRate(v int) Option { + return func(c *cfg) { + c.workScope.expRate = v + } +} + +// WithTrigger returns option to set triggering channel of Policer. +func WithTrigger(v <-chan *Task) Option { + return func(c *cfg) { + c.trigger = v + } +} + +// WithLogger returns option to set Logger of Policer. +func WithLogger(v *logger.Logger) Option { + return func(c *cfg) { + c.log = v + } +} + +// WithLocalStorage returns option to set local object storage of Policer. +func WithLocalStorage(v *localstore.Storage) Option { + return func(c *cfg) { + c.jobQueue.localStorage = v + } +} + +// WithContainerSource returns option to set container source of Policer. +func WithContainerSource(v container.Source) Option { + return func(c *cfg) { + c.cnrSrc = v + } +} + +// WithPlacementBuilder returns option to set object placement builder of Policer. +func WithPlacementBuilder(v placement.Builder) Option { + return func(c *cfg) { + c.placementBuilder = v + } +} + +// WithRemoteHeader returns option to set object header receiver of Policer. +func WithRemoteHeader(v *headsvc.RemoteHeader) Option { + return func(c *cfg) { + c.remoteHeader = v + } +} + +// WithLocalAddressSource returns option to set local address source of Policer. +func WithLocalAddressSource(v network.LocalAddressSource) Option { + return func(c *cfg) { + c.localAddrSrc = v + } +} diff --git a/pkg/services/policer/process.go b/pkg/services/policer/process.go new file mode 100644 index 000000000..eb9fbd6b5 --- /dev/null +++ b/pkg/services/policer/process.go @@ -0,0 +1,114 @@ +package policer + +import ( + "context" + "sync" + + "go.uber.org/zap" +) + +// Task represents group of Policer tact parameters. +type Task struct{} + +type prevTask struct { + undone int + + cancel context.CancelFunc + + wait *sync.WaitGroup +} + +type workScope struct { + val int + + expRate int // in % +} + +func (p *Policer) Run(ctx context.Context) { + defer func() { + p.log.Info("routine stopped") + }() + + p.log.Info("process routine", + zap.Int("work scope value", p.workScope.val), + zap.Int("expansion rate (%)", p.workScope.val), + zap.Duration("head timeout", p.headTimeout), + ) + + for { + select { + case <-ctx.Done(): + p.prevTask.cancel() + + p.log.Warn("context is done", + zap.String("error", ctx.Err().Error()), + ) + + return + case task, ok := <-p.trigger: + if !ok { + p.log.Warn("trigger channel is closed") + + return + } + + p.prevTask.cancel() + p.prevTask.wait.Wait() + + var taskCtx context.Context + + taskCtx, p.prevTask.cancel = context.WithCancel(ctx) + + go p.handleTask(taskCtx, task) + } + } +} + +func (p *Policer) handleTask(ctx context.Context, task *Task) { + p.prevTask.wait.Add(1) + + defer func() { + p.prevTask.wait.Done() + p.log.Info("finish work", + zap.Int("amount of unfinished objects", p.prevTask.undone), + ) + }() + + var delta int + + // undone - amount of objects we couldn't process in last epoch + if p.prevTask.undone > 0 { + // if there are unprocessed objects, then lower your estimation + delta = -p.prevTask.undone + } else { + // otherwise try to expand + delta = p.workScope.val * p.workScope.expRate / 100 + } + + addrs, err := p.jobQueue.Select(p.workScope.val + delta) + if err != nil { + p.log.Warn("could not select objects", + zap.String("error", err.Error()), + ) + } + + // if there are NOT enough objects to fill the pool, do not change it + // otherwise expand or shrink it with the delta value + if len(addrs) >= p.workScope.val+delta { + p.workScope.val += delta + } + + p.prevTask.undone = len(addrs) + + for i := range addrs { + select { + case <-ctx.Done(): + return + default: + } + + p.processObject(ctx, addrs[i]) + + p.prevTask.undone-- + } +} diff --git a/pkg/services/policer/queue.go b/pkg/services/policer/queue.go new file mode 100644 index 000000000..63348a0a0 --- /dev/null +++ b/pkg/services/policer/queue.go @@ -0,0 +1,28 @@ +package policer + +import ( + "github.com/nspcc-dev/neofs-api-go/pkg/object" + "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/localstore" +) + +type jobQueue struct { + localStorage *localstore.Storage +} + +func (q *jobQueue) Select(limit int) ([]*object.Address, error) { + // TODO: optimize the logic for selecting objects + // We can prioritize objects for migration, newly arrived objects, etc. + // It is recommended to make changes after updating the metabase + + res := make([]*object.Address, 0, limit) + + if err := q.localStorage.Iterate(nil, func(meta *localstore.ObjectMeta) bool { + res = append(res, meta.Head().Address()) + + return len(res) >= limit + }); err != nil { + return nil, err + } + + return res, nil +}