[#1445] shard/gc: Remove graves of new format separately

Signed-off-by: Aleksey Savchuk <a.savchuk@yadro.com>

.ci/Jenkinsfile

@@ -1,81 +0,0 @@
-def golang = ['1.23', '1.24']
-def golangDefault = "golang:${golang.last()}"
-
-async {
-
-    for (version in golang) {
-        def go = version
-
-        task("test/go${go}") {
-            container("golang:${go}") {
-                sh 'make test'
-            }
-        }
-
-        task("build/go${go}") {
-            container("golang:${go}") {
-                for (app in ['cli', 'node', 'ir', 'adm', 'lens']) {
-                    sh """
-                        make bin/frostfs-${app}
-                        bin/frostfs-${app} --version
-                    """
-                }
-            }
-        }
-    }
-
-    task('test/race') {
-        container(golangDefault) {
-            sh 'make test GOFLAGS="-count=1 -race"'
-        }
-    }
-
-    task('lint') {
-        container(golangDefault) {
-            sh 'make lint-install lint'
-        }
-    }
-
-    task('staticcheck') {
-        container(golangDefault) {
-            sh 'make staticcheck-install staticcheck-run'
-        }
-    }
-
-    task('gopls') {
-        container(golangDefault) {
-            sh 'make gopls-install gopls-run'
-        }
-    }
-
-    task('gofumpt') {
-        container(golangDefault) {
-            sh '''
-                make fumpt-install
-                make fumpt
-                git diff --exit-code --quiet
-            '''
-        }
-    }
-
-    task('vulncheck') {
-        container(golangDefault) {
-            sh '''
-                go install golang.org/x/vuln/cmd/govulncheck@latest
-                govulncheck ./...
-            '''
-        }
-    }
-
-    task('pre-commit') {
-        dockerfile("""
-            FROM ${golangDefault}
-            RUN apt update && \
-                apt install -y --no-install-recommends pre-commit
-        """) {
-            withEnv(['SKIP=make-lint,go-staticcheck-repo-mod,go-unit-tests,gofumpt']) {
-                sh 'pre-commit run --color=always --hook-stage=manual --all-files'
-            }
-        }
-    }
-}

.forgejo/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go_versions: [ '1.23', '1.24' ]
+        go_versions: [ '1.22', '1.23' ]
 
     steps:
       - uses: actions/checkout@v3

.forgejo/workflows/dco.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.22'
 
       - name: Run commit format checker
         uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3

.forgejo/workflows/pre-commit.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: 1.24
+          go-version: 1.23
       - name: Set up Python
         run: |
           apt update

.forgejo/workflows/tests.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.23'
           cache: true
 
       - name: Install linters
@@ -30,7 +30,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go_versions: [ '1.23', '1.24' ]
+        go_versions: [ '1.22', '1.23' ]
       fail-fast: false
     steps:
       - uses: actions/checkout@v3
@@ -53,7 +53,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.22'
           cache: true
 
       - name: Run tests
@@ -68,7 +68,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.23'
           cache: true
 
       - name: Install staticcheck
@@ -104,7 +104,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.23'
           cache: true
 
       - name: Install gofumpt

.forgejo/workflows/vulncheck.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.24'
+          go-version: '1.23'
           check-latest: true
 
       - name: Install govulncheck

.golangci.yml

@@ -1,103 +1,95 @@
-version: "2"
+# This file contains all available configuration options
+# with their default values.
+
+# options for analysis running
 run:
+  # timeout for analysis, e.g. 30s, 5m, default is 1m
+  timeout: 20m
+
+  # include test files or not, default is true
   tests: false
+
+# output configuration options
 output:
+  # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
   formats:
-    tab:
-      path: stdout
-      colors: false
+    - format: tab
+
+# all available settings of specific linters
+linters-settings:
+  exhaustive:
+    # indicates that switch statements are to be considered exhaustive if a
+    # 'default' case is present, even if all enum members aren't listed in the
+    # switch
+    default-signifies-exhaustive: true
+  govet:
+    # report about shadowed variables
+    check-shadowing: false
+  staticcheck:
+    checks: ["all", "-SA1019"] # TODO Enable SA1019 after deprecated warning are fixed.
+  funlen:
+    lines: 80 # default 60
+    statements: 60 # default 40
+  gocognit:
+    min-complexity: 40 # default 30
+  importas:
+    no-unaliased: true
+    no-extra-aliases: false
+    alias:
+      pkg: git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object
+      alias: objectSDK
+  unused:
+    field-writes-are-uses: false
+    exported-fields-are-used: false
+    local-variables-are-used: false
+  custom:
+    truecloudlab-linters:
+      path: bin/linters/external_linters.so
+      original-url: git.frostfs.info/TrueCloudLab/linters.git
+      settings:
+        noliteral:
+          target-methods : ["reportFlushError", "reportError"]
+          disable-packages: ["codes", "err", "res","exec"]
+          constants-package: "git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
+
 linters:
-  default: none
   enable:
-    - bidichk
-    - containedctx
-    - contextcheck
-    - copyloopvar
-    - durationcheck
-    - errcheck
-    - exhaustive
-    - funlen
-    - gocognit
-    - godot
-    - importas
-    - ineffassign
-    - intrange
-    - misspell
-    - perfsprint
-    - predeclared
-    - protogetter
-    - reassign
+    # mandatory linters
+    - govet
     - revive
+
+    # some default golangci-lint linters
+    - errcheck
+    - gosimple
+    - godot
+    - ineffassign
     - staticcheck
-    - testifylint
-    - truecloudlab-linters
-    - unconvert
-    - unparam
+    - typecheck
     - unused
-    - usetesting
-    - whitespace
-  settings:
-    exhaustive:
-      default-signifies-exhaustive: true
-    funlen:
-      lines: 80
-      statements: 60
-    gocognit:
-      min-complexity: 40
-    importas:
-      alias:
-        - pkg: git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object
-          alias: objectSDK
-      no-unaliased: true
-      no-extra-aliases: false
-    staticcheck:
-      checks:
-        - all
-        - -QF1002
-    unused:
-      field-writes-are-uses: false
-      exported-fields-are-used: false
-      local-variables-are-used: false
-    custom:
-      truecloudlab-linters:
-        path: bin/linters/external_linters.so
-        original-url: git.frostfs.info/TrueCloudLab/linters.git
-        settings:
-          noliteral:
-            constants-package: git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs
-            disable-packages:
-              - codes
-              - err
-              - res
-              - exec
-            target-methods:
-              - reportFlushError
-              - reportError
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
-formatters:
-  enable:
-    - gci
+
+    # extra linters
+    - bidichk
+    - durationcheck
+    - exhaustive
+    - copyloopvar
     - gofmt
     - goimports
-  settings:
-    gci:
-      sections:
-        - standard
-        - default
-      custom-order: true
-  exclusions:
-    generated: lax
-    paths:
-      - third_party$
-      - builtin$
-      - examples$
+    - misspell
+    - predeclared
+    - reassign
+    - whitespace
+    - containedctx
+    - funlen
+    - gocognit
+    - contextcheck
+    - importas
+    - truecloudlab-linters
+    - perfsprint
+    - testifylint
+    - protogetter
+    - intrange
+    - tenv
+    - unconvert
+    - unparam
+  disable-all: true
+  fast: false

Makefile

@@ -1,6 +1,5 @@
 #!/usr/bin/make -f
 SHELL = bash
-.SHELLFLAGS = -euo pipefail -c
 
 REPO ?= $(shell go list -m)
 VERSION ?= $(shell git describe --tags --dirty --match "v*" --always --abbrev=8 2>/dev/null || cat VERSION 2>/dev/null || echo "develop")
@@ -8,16 +7,16 @@ VERSION ?= $(shell git describe --tags --dirty --match "v*" --always --abbrev=8
 HUB_IMAGE ?= git.frostfs.info/truecloudlab/frostfs
 HUB_TAG ?= "$(shell echo ${VERSION} | sed 's/^v//')"
 
-GO_VERSION ?= 1.23
-LINT_VERSION ?= 2.0.2
-TRUECLOUDLAB_LINT_VERSION ?= 0.0.10
+GO_VERSION ?= 1.22
+LINT_VERSION ?= 1.62.2
+TRUECLOUDLAB_LINT_VERSION ?= 0.0.8
 PROTOC_VERSION ?= 25.0
 PROTOGEN_FROSTFS_VERSION ?= $(shell go list -f '{{.Version}}' -m git.frostfs.info/TrueCloudLab/frostfs-sdk-go)
 PROTOC_OS_VERSION=osx-x86_64
 ifeq ($(shell uname), Linux)
 	PROTOC_OS_VERSION=linux-x86_64
 endif
-STATICCHECK_VERSION ?= 2025.1.1
+STATICCHECK_VERSION ?= 2024.1.1
 ARCH = amd64
 
 BIN = bin
@@ -43,7 +42,7 @@ GOFUMPT_VERSION ?= v0.7.0
 GOFUMPT_DIR ?= $(abspath $(BIN))/gofumpt
 GOFUMPT_VERSION_DIR ?= $(GOFUMPT_DIR)/$(GOFUMPT_VERSION)
 
-GOPLS_VERSION ?= v0.17.1
+GOPLS_VERSION ?= v0.15.1
 GOPLS_DIR ?= $(abspath $(BIN))/gopls
 GOPLS_VERSION_DIR ?= $(GOPLS_DIR)/$(GOPLS_VERSION)
 GOPLS_TEMP_FILE := $(shell mktemp)
@@ -116,7 +115,7 @@ protoc:
 # Install protoc
 protoc-install:
 	@rm -rf $(PROTOBUF_DIR)
-	@mkdir -p $(PROTOBUF_DIR)
+	@mkdir $(PROTOBUF_DIR)
 	@echo "⇒ Installing protoc... "
 	@wget -q -O $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip 'https://github.com/protocolbuffers/protobuf/releases/download/v$(PROTOC_VERSION)/protoc-$(PROTOC_VERSION)-$(PROTOC_OS_VERSION).zip'
 	@unzip -q -o $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip -d $(PROTOC_DIR)
@@ -170,7 +169,7 @@ imports:
 # Install gofumpt
 fumpt-install:
 	@rm -rf $(GOFUMPT_DIR)
-	@mkdir -p $(GOFUMPT_DIR)
+	@mkdir $(GOFUMPT_DIR)
 	@GOBIN=$(GOFUMPT_VERSION_DIR) go install mvdan.cc/gofumpt@$(GOFUMPT_VERSION)
 
 # Run gofumpt
@@ -187,44 +186,21 @@ test:
 	@echo "⇒ Running go test"
 	@GOFLAGS="$(GOFLAGS)" go test ./...
 
-# Install Gerrit commit-msg hook
-review-install: GIT_HOOK_DIR := $(shell git rev-parse --git-dir)/hooks
-review-install:
-	@git config remote.review.url \
-		|| git remote add review ssh://review.frostfs.info:2222/TrueCloudLab/frostfs-node
-	@mkdir -p $(GIT_HOOK_DIR)/
-	@curl -Lo $(GIT_HOOK_DIR)/commit-msg https://review.frostfs.info/tools/hooks/commit-msg
-	@chmod +x $(GIT_HOOK_DIR)/commit-msg
-	@echo -e '#!/bin/sh\n"$$(git rev-parse --git-path hooks)"/commit-msg "$$1"' >$(GIT_HOOK_DIR)/prepare-commit-msg
-	@chmod +x $(GIT_HOOK_DIR)/prepare-commit-msg
-
-# Create a PR in Gerrit
-review: BRANCH ?= master
-review:
-	@git push review HEAD:refs/for/$(BRANCH) \
-		--push-option r=e.stratonikov@yadro.com \
-		--push-option r=d.stepanov@yadro.com \
-		--push-option r=an.nikiforov@yadro.com \
-		--push-option r=a.arifullin@yadro.com \
-		--push-option r=ekaterina.lebedeva@yadro.com \
-		--push-option r=a.savchuk@yadro.com \
-		--push-option r=a.chuprov@yadro.com
-
 # Run pre-commit
 pre-commit-run:
 	@pre-commit run -a --hook-stage manual
 
 # Install linters
-lint-install: $(BIN)
+lint-install:
 	@rm -rf $(OUTPUT_LINT_DIR)
-	@mkdir -p $(OUTPUT_LINT_DIR)
+	@mkdir $(OUTPUT_LINT_DIR)
 	@mkdir -p $(TMP_DIR)
 	@rm -rf $(TMP_DIR)/linters
 	@git -c advice.detachedHead=false clone --branch v$(TRUECLOUDLAB_LINT_VERSION) https://git.frostfs.info/TrueCloudLab/linters.git $(TMP_DIR)/linters
 	@@make -C $(TMP_DIR)/linters lib CGO_ENABLED=1 OUT_DIR=$(OUTPUT_LINT_DIR)
 	@rm -rf $(TMP_DIR)/linters
 	@rmdir $(TMP_DIR) 2>/dev/null || true
-	@CGO_ENABLED=1 GOBIN=$(LINT_DIR) go install -trimpath github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v$(LINT_VERSION)
+	@CGO_ENABLED=1 GOBIN=$(LINT_DIR) go install -trimpath github.com/golangci/golangci-lint/cmd/golangci-lint@v$(LINT_VERSION)
 
 # Run linters
 lint:
@@ -236,7 +212,7 @@ lint:
 # Install staticcheck
 staticcheck-install:
 	@rm -rf $(STATICCHECK_DIR)
-	@mkdir -p $(STATICCHECK_DIR)
+	@mkdir $(STATICCHECK_DIR)
 	@GOBIN=$(STATICCHECK_VERSION_DIR) go install honnef.co/go/tools/cmd/staticcheck@$(STATICCHECK_VERSION)
 
 # Run staticcheck
@@ -249,7 +225,7 @@ staticcheck-run:
 # Install gopls
 gopls-install:
 	@rm -rf $(GOPLS_DIR)
-	@mkdir -p $(GOPLS_DIR)
+	@mkdir $(GOPLS_DIR)
 	@GOBIN=$(GOPLS_VERSION_DIR) go install golang.org/x/tools/gopls@$(GOPLS_VERSION)
 
 # Run gopls

cmd/frostfs-adm/internal/modules/maintenance/root.go

@@ -1,15 +0,0 @@
-package maintenance
-
-import (
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/maintenance/zombie"
-	"github.com/spf13/cobra"
-)
-
-var RootCmd = &cobra.Command{
-	Use:   "maintenance",
-	Short: "Section for maintenance commands",
-}
-
-func init() {
-	RootCmd.AddCommand(zombie.Cmd)
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/key.go

@@ -1,70 +0,0 @@
-package zombie
-
-import (
-	"crypto/ecdsa"
-	"fmt"
-	"os"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	nodeconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/node"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	"github.com/nspcc-dev/neo-go/cli/flags"
-	"github.com/nspcc-dev/neo-go/cli/input"
-	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neo-go/pkg/util"
-	"github.com/nspcc-dev/neo-go/pkg/wallet"
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-)
-
-func getPrivateKey(cmd *cobra.Command, appCfg *config.Config) *ecdsa.PrivateKey {
-	keyDesc := viper.GetString(walletFlag)
-	if keyDesc == "" {
-		return &nodeconfig.Key(appCfg).PrivateKey
-	}
-	data, err := os.ReadFile(keyDesc)
-	commonCmd.ExitOnErr(cmd, "open wallet file: %w", err)
-
-	priv, err := keys.NewPrivateKeyFromBytes(data)
-	if err != nil {
-		w, err := wallet.NewWalletFromFile(keyDesc)
-		commonCmd.ExitOnErr(cmd, "provided key is incorrect, only wallet or binary key supported: %w", err)
-		return fromWallet(cmd, w, viper.GetString(addressFlag))
-	}
-	return &priv.PrivateKey
-}
-
-func fromWallet(cmd *cobra.Command, w *wallet.Wallet, addrStr string) *ecdsa.PrivateKey {
-	var (
-		addr util.Uint160
-		err  error
-	)
-
-	if addrStr == "" {
-		addr = w.GetChangeAddress()
-	} else {
-		addr, err = flags.ParseAddress(addrStr)
-		commonCmd.ExitOnErr(cmd, "--address option must be specified and valid: %w", err)
-	}
-
-	acc := w.GetAccount(addr)
-	if acc == nil {
-		commonCmd.ExitOnErr(cmd, "--address option must be specified and valid: %w", fmt.Errorf("can't find wallet account for %s", addrStr))
-	}
-
-	pass, err := getPassword()
-	commonCmd.ExitOnErr(cmd, "invalid password for the encrypted key: %w", err)
-
-	commonCmd.ExitOnErr(cmd, "can't decrypt account: %w", acc.Decrypt(pass, keys.NEP2ScryptParams()))
-
-	return &acc.PrivateKey().PrivateKey
-}
-
-func getPassword() (string, error) {
-	// this check allows empty passwords
-	if viper.IsSet("password") {
-		return viper.GetString("password"), nil
-	}
-
-	return input.ReadPassword("Enter password > ")
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/list.go

@@ -1,31 +0,0 @@
-package zombie
-
-import (
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/spf13/cobra"
-)
-
-func list(cmd *cobra.Command, _ []string) {
-	configFile, _ := cmd.Flags().GetString(commonflags.ConfigFlag)
-	configDir, _ := cmd.Flags().GetString(commonflags.ConfigDirFlag)
-	appCfg := config.New(configFile, configDir, config.EnvPrefix)
-	storageEngine := newEngine(cmd, appCfg)
-	q := createQuarantine(cmd, storageEngine.DumpInfo())
-	var containerID *cid.ID
-	if cidStr, _ := cmd.Flags().GetString(cidFlag); cidStr != "" {
-		containerID = &cid.ID{}
-		commonCmd.ExitOnErr(cmd, "decode container ID string: %w", containerID.DecodeString(cidStr))
-	}
-
-	commonCmd.ExitOnErr(cmd, "iterate over quarantine: %w", q.Iterate(cmd.Context(), func(a oid.Address) error {
-		if containerID != nil && a.Container() != *containerID {
-			return nil
-		}
-		cmd.Println(a.EncodeToString())
-		return nil
-	}))
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/morph.go

@@ -1,46 +0,0 @@
-package zombie
-
-import (
-	"errors"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	morphconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/morph"
-	nodeconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/node"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
-	cntClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/container"
-	netmapClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/netmap"
-	"github.com/spf13/cobra"
-)
-
-func createMorphClient(cmd *cobra.Command, appCfg *config.Config) *client.Client {
-	addresses := morphconfig.RPCEndpoint(appCfg)
-	if len(addresses) == 0 {
-		commonCmd.ExitOnErr(cmd, "create morph client: %w", errors.New("no morph endpoints found"))
-	}
-	key := nodeconfig.Key(appCfg)
-	cli, err := client.New(cmd.Context(),
-		key,
-		client.WithDialTimeout(morphconfig.DialTimeout(appCfg)),
-		client.WithEndpoints(addresses...),
-		client.WithSwitchInterval(morphconfig.SwitchInterval(appCfg)),
-	)
-	commonCmd.ExitOnErr(cmd, "create morph client: %w", err)
-	return cli
-}
-
-func createContainerClient(cmd *cobra.Command, morph *client.Client) *cntClient.Client {
-	hs, err := morph.NNSContractAddress(client.NNSContainerContractName)
-	commonCmd.ExitOnErr(cmd, "resolve container contract hash: %w", err)
-	cc, err := cntClient.NewFromMorph(morph, hs, 0)
-	commonCmd.ExitOnErr(cmd, "create morph container client: %w", err)
-	return cc
-}
-
-func createNetmapClient(cmd *cobra.Command, morph *client.Client) *netmapClient.Client {
-	hs, err := morph.NNSContractAddress(client.NNSNetmapContractName)
-	commonCmd.ExitOnErr(cmd, "resolve netmap contract hash: %w", err)
-	cli, err := netmapClient.NewFromMorph(morph, hs, 0)
-	commonCmd.ExitOnErr(cmd, "create morph netmap client: %w", err)
-	return cli
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/quarantine.go

@@ -1,154 +0,0 @@
-package zombie
-
-import (
-	"context"
-	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	objectcore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/object"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/common"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/fstree"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/engine"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
-	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
-	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/spf13/cobra"
-)
-
-type quarantine struct {
-	// mtx protects current field.
-	mtx     sync.Mutex
-	current int
-	trees   []*fstree.FSTree
-}
-
-func createQuarantine(cmd *cobra.Command, engineInfo engine.Info) *quarantine {
-	var paths []string
-	for _, sh := range engineInfo.Shards {
-		var storagePaths []string
-		for _, st := range sh.BlobStorInfo.SubStorages {
-			storagePaths = append(storagePaths, st.Path)
-		}
-		if len(storagePaths) == 0 {
-			continue
-		}
-		paths = append(paths, filepath.Join(commonPath(storagePaths), "quarantine"))
-	}
-	q, err := newQuarantine(paths)
-	commonCmd.ExitOnErr(cmd, "create quarantine: %w", err)
-	return q
-}
-
-func commonPath(paths []string) string {
-	if len(paths) == 0 {
-		return ""
-	}
-	if len(paths) == 1 {
-		return paths[0]
-	}
-	minLen := math.MaxInt
-	for _, p := range paths {
-		if len(p) < minLen {
-			minLen = len(p)
-		}
-	}
-
-	var sb strings.Builder
-	for i := range minLen {
-		for _, path := range paths[1:] {
-			if paths[0][i] != path[i] {
-				return sb.String()
-			}
-		}
-		sb.WriteByte(paths[0][i])
-	}
-	return sb.String()
-}
-
-func newQuarantine(paths []string) (*quarantine, error) {
-	var q quarantine
-	for i := range paths {
-		f := fstree.New(
-			fstree.WithDepth(1),
-			fstree.WithDirNameLen(1),
-			fstree.WithPath(paths[i]),
-			fstree.WithPerm(os.ModePerm),
-		)
-		if err := f.Open(mode.ComponentReadWrite); err != nil {
-			return nil, fmt.Errorf("open fstree %s: %w", paths[i], err)
-		}
-		if err := f.Init(); err != nil {
-			return nil, fmt.Errorf("init fstree %s: %w", paths[i], err)
-		}
-		q.trees = append(q.trees, f)
-	}
-	return &q, nil
-}
-
-func (q *quarantine) Get(ctx context.Context, a oid.Address) (*objectSDK.Object, error) {
-	for i := range q.trees {
-		res, err := q.trees[i].Get(ctx, common.GetPrm{Address: a})
-		if err != nil {
-			continue
-		}
-		return res.Object, nil
-	}
-	return nil, &apistatus.ObjectNotFound{}
-}
-
-func (q *quarantine) Delete(ctx context.Context, a oid.Address) error {
-	for i := range q.trees {
-		_, err := q.trees[i].Delete(ctx, common.DeletePrm{Address: a})
-		if err != nil {
-			continue
-		}
-		return nil
-	}
-	return &apistatus.ObjectNotFound{}
-}
-
-func (q *quarantine) Put(ctx context.Context, obj *objectSDK.Object) error {
-	data, err := obj.Marshal()
-	if err != nil {
-		return err
-	}
-
-	var prm common.PutPrm
-	prm.Address = objectcore.AddressOf(obj)
-	prm.Object = obj
-	prm.RawData = data
-
-	q.mtx.Lock()
-	current := q.current
-	q.current = (q.current + 1) % len(q.trees)
-	q.mtx.Unlock()
-
-	_, err = q.trees[current].Put(ctx, prm)
-	return err
-}
-
-func (q *quarantine) Iterate(ctx context.Context, f func(oid.Address) error) error {
-	var prm common.IteratePrm
-	prm.Handler = func(elem common.IterationElement) error {
-		return f(elem.Address)
-	}
-	for i := range q.trees {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-		}
-
-		_, err := q.trees[i].Iterate(ctx, prm)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/remove.go

@@ -1,55 +0,0 @@
-package zombie
-
-import (
-	"errors"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
-	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/spf13/cobra"
-)
-
-func remove(cmd *cobra.Command, _ []string) {
-	configFile, _ := cmd.Flags().GetString(commonflags.ConfigFlag)
-	configDir, _ := cmd.Flags().GetString(commonflags.ConfigDirFlag)
-	appCfg := config.New(configFile, configDir, config.EnvPrefix)
-	storageEngine := newEngine(cmd, appCfg)
-	q := createQuarantine(cmd, storageEngine.DumpInfo())
-
-	var containerID cid.ID
-	cidStr, _ := cmd.Flags().GetString(cidFlag)
-	commonCmd.ExitOnErr(cmd, "decode container ID string: %w", containerID.DecodeString(cidStr))
-
-	var objectID *oid.ID
-	oidStr, _ := cmd.Flags().GetString(oidFlag)
-	if oidStr != "" {
-		objectID = &oid.ID{}
-		commonCmd.ExitOnErr(cmd, "decode object ID string: %w", objectID.DecodeString(oidStr))
-	}
-
-	if objectID != nil {
-		var addr oid.Address
-		addr.SetContainer(containerID)
-		addr.SetObject(*objectID)
-		removeObject(cmd, q, addr)
-	} else {
-		commonCmd.ExitOnErr(cmd, "iterate over quarantine: %w", q.Iterate(cmd.Context(), func(addr oid.Address) error {
-			if addr.Container() != containerID {
-				return nil
-			}
-			removeObject(cmd, q, addr)
-			return nil
-		}))
-	}
-}
-
-func removeObject(cmd *cobra.Command, q *quarantine, addr oid.Address) {
-	err := q.Delete(cmd.Context(), addr)
-	if errors.Is(err, new(apistatus.ObjectNotFound)) {
-		return
-	}
-	commonCmd.ExitOnErr(cmd, "remove object from quarantine: %w", err)
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/restore.go

@@ -1,69 +0,0 @@
-package zombie
-
-import (
-	"crypto/sha256"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	containerCore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/container"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/engine"
-	cntClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/container"
-	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/spf13/cobra"
-)
-
-func restore(cmd *cobra.Command, _ []string) {
-	configFile, _ := cmd.Flags().GetString(commonflags.ConfigFlag)
-	configDir, _ := cmd.Flags().GetString(commonflags.ConfigDirFlag)
-	appCfg := config.New(configFile, configDir, config.EnvPrefix)
-	storageEngine := newEngine(cmd, appCfg)
-	q := createQuarantine(cmd, storageEngine.DumpInfo())
-	morphClient := createMorphClient(cmd, appCfg)
-	cnrCli := createContainerClient(cmd, morphClient)
-
-	var containerID cid.ID
-	cidStr, _ := cmd.Flags().GetString(cidFlag)
-	commonCmd.ExitOnErr(cmd, "decode container ID string: %w", containerID.DecodeString(cidStr))
-
-	var objectID *oid.ID
-	oidStr, _ := cmd.Flags().GetString(oidFlag)
-	if oidStr != "" {
-		objectID = &oid.ID{}
-		commonCmd.ExitOnErr(cmd, "decode object ID string: %w", objectID.DecodeString(oidStr))
-	}
-
-	if objectID != nil {
-		var addr oid.Address
-		addr.SetContainer(containerID)
-		addr.SetObject(*objectID)
-		restoreObject(cmd, storageEngine, q, addr, cnrCli)
-	} else {
-		commonCmd.ExitOnErr(cmd, "iterate over quarantine: %w", q.Iterate(cmd.Context(), func(addr oid.Address) error {
-			if addr.Container() != containerID {
-				return nil
-			}
-			restoreObject(cmd, storageEngine, q, addr, cnrCli)
-			return nil
-		}))
-	}
-}
-
-func restoreObject(cmd *cobra.Command, storageEngine *engine.StorageEngine, q *quarantine, addr oid.Address, cnrCli *cntClient.Client) {
-	obj, err := q.Get(cmd.Context(), addr)
-	commonCmd.ExitOnErr(cmd, "get object from quarantine: %w", err)
-	rawCID := make([]byte, sha256.Size)
-
-	cid := addr.Container()
-	cid.Encode(rawCID)
-	cnr, err := cnrCli.Get(cmd.Context(), rawCID)
-	commonCmd.ExitOnErr(cmd, "get container: %w", err)
-
-	putPrm := engine.PutPrm{
-		Object:             obj,
-		IsIndexedContainer: containerCore.IsIndexedContainer(cnr.Value),
-	}
-	commonCmd.ExitOnErr(cmd, "put object to storage engine: %w", storageEngine.Put(cmd.Context(), putPrm))
-	commonCmd.ExitOnErr(cmd, "remove object from quarantine: %w", q.Delete(cmd.Context(), addr))
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/root.go

@@ -1,123 +0,0 @@
-package zombie
-
-import (
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-)
-
-const (
-	flagBatchSize       = "batch-size"
-	flagBatchSizeUsage  = "Objects iteration batch size"
-	cidFlag             = "cid"
-	cidFlagUsage        = "Container ID"
-	oidFlag             = "oid"
-	oidFlagUsage        = "Object ID"
-	walletFlag          = "wallet"
-	walletFlagShorthand = "w"
-	walletFlagUsage     = "Path to the wallet or binary key"
-	addressFlag         = "address"
-	addressFlagUsage    = "Address of wallet account"
-	moveFlag            = "move"
-	moveFlagUsage       = "Move objects from storage engine to quarantine"
-)
-
-var (
-	Cmd = &cobra.Command{
-		Use:   "zombie",
-		Short: "Zombie objects related commands",
-	}
-	scanCmd = &cobra.Command{
-		Use:   "scan",
-		Short: "Scan storage engine for zombie objects and move them to quarantine",
-		Long:  "",
-		PreRun: func(cmd *cobra.Command, _ []string) {
-			_ = viper.BindPFlag(commonflags.ConfigFlag, cmd.Flags().Lookup(commonflags.ConfigFlag))
-			_ = viper.BindPFlag(commonflags.ConfigDirFlag, cmd.Flags().Lookup(commonflags.ConfigDirFlag))
-			_ = viper.BindPFlag(walletFlag, cmd.Flags().Lookup(walletFlag))
-			_ = viper.BindPFlag(addressFlag, cmd.Flags().Lookup(addressFlag))
-			_ = viper.BindPFlag(flagBatchSize, cmd.Flags().Lookup(flagBatchSize))
-			_ = viper.BindPFlag(moveFlag, cmd.Flags().Lookup(moveFlag))
-		},
-		Run: scan,
-	}
-	listCmd = &cobra.Command{
-		Use:   "list",
-		Short: "List zombie objects from quarantine",
-		Long:  "",
-		PreRun: func(cmd *cobra.Command, _ []string) {
-			_ = viper.BindPFlag(commonflags.ConfigFlag, cmd.Flags().Lookup(commonflags.ConfigFlag))
-			_ = viper.BindPFlag(commonflags.ConfigDirFlag, cmd.Flags().Lookup(commonflags.ConfigDirFlag))
-			_ = viper.BindPFlag(cidFlag, cmd.Flags().Lookup(cidFlag))
-		},
-		Run: list,
-	}
-	restoreCmd = &cobra.Command{
-		Use:   "restore",
-		Short: "Restore zombie objects from quarantine",
-		Long:  "",
-		PreRun: func(cmd *cobra.Command, _ []string) {
-			_ = viper.BindPFlag(commonflags.ConfigFlag, cmd.Flags().Lookup(commonflags.ConfigFlag))
-			_ = viper.BindPFlag(commonflags.ConfigDirFlag, cmd.Flags().Lookup(commonflags.ConfigDirFlag))
-			_ = viper.BindPFlag(cidFlag, cmd.Flags().Lookup(cidFlag))
-			_ = viper.BindPFlag(oidFlag, cmd.Flags().Lookup(oidFlag))
-		},
-		Run: restore,
-	}
-	removeCmd = &cobra.Command{
-		Use:   "remove",
-		Short: "Remove zombie objects from quarantine",
-		Long:  "",
-		PreRun: func(cmd *cobra.Command, _ []string) {
-			_ = viper.BindPFlag(commonflags.ConfigFlag, cmd.Flags().Lookup(commonflags.ConfigFlag))
-			_ = viper.BindPFlag(commonflags.ConfigDirFlag, cmd.Flags().Lookup(commonflags.ConfigDirFlag))
-			_ = viper.BindPFlag(cidFlag, cmd.Flags().Lookup(cidFlag))
-			_ = viper.BindPFlag(oidFlag, cmd.Flags().Lookup(oidFlag))
-		},
-		Run: remove,
-	}
-)
-
-func init() {
-	initScanCmd()
-	initListCmd()
-	initRestoreCmd()
-	initRemoveCmd()
-}
-
-func initScanCmd() {
-	Cmd.AddCommand(scanCmd)
-
-	scanCmd.Flags().StringP(commonflags.ConfigFlag, commonflags.ConfigFlagShorthand, "", commonflags.ConfigFlagUsage)
-	scanCmd.Flags().String(commonflags.ConfigDirFlag, "", commonflags.ConfigDirFlagUsage)
-	scanCmd.Flags().Uint32(flagBatchSize, 1000, flagBatchSizeUsage)
-	scanCmd.Flags().StringP(walletFlag, walletFlagShorthand, "", walletFlagUsage)
-	scanCmd.Flags().String(addressFlag, "", addressFlagUsage)
-	scanCmd.Flags().Bool(moveFlag, false, moveFlagUsage)
-}
-
-func initListCmd() {
-	Cmd.AddCommand(listCmd)
-
-	listCmd.Flags().StringP(commonflags.ConfigFlag, commonflags.ConfigFlagShorthand, "", commonflags.ConfigFlagUsage)
-	listCmd.Flags().String(commonflags.ConfigDirFlag, "", commonflags.ConfigDirFlagUsage)
-	listCmd.Flags().String(cidFlag, "", cidFlagUsage)
-}
-
-func initRestoreCmd() {
-	Cmd.AddCommand(restoreCmd)
-
-	restoreCmd.Flags().StringP(commonflags.ConfigFlag, commonflags.ConfigFlagShorthand, "", commonflags.ConfigFlagUsage)
-	restoreCmd.Flags().String(commonflags.ConfigDirFlag, "", commonflags.ConfigDirFlagUsage)
-	restoreCmd.Flags().String(cidFlag, "", cidFlagUsage)
-	restoreCmd.Flags().String(oidFlag, "", oidFlagUsage)
-}
-
-func initRemoveCmd() {
-	Cmd.AddCommand(removeCmd)
-
-	removeCmd.Flags().StringP(commonflags.ConfigFlag, commonflags.ConfigFlagShorthand, "", commonflags.ConfigFlagUsage)
-	removeCmd.Flags().String(commonflags.ConfigDirFlag, "", commonflags.ConfigDirFlagUsage)
-	removeCmd.Flags().String(cidFlag, "", cidFlagUsage)
-	removeCmd.Flags().String(oidFlag, "", oidFlagUsage)
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/scan.go

@@ -1,281 +0,0 @@
-package zombie
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"crypto/sha256"
-	"errors"
-	"fmt"
-	"sync"
-	"time"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	apiclientconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/apiclient"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	clientCore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/client"
-	netmapCore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/object"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/engine"
-	cntClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/container"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/netmap"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/network/cache"
-	clientSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
-	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
-	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/spf13/cobra"
-	"golang.org/x/sync/errgroup"
-)
-
-func scan(cmd *cobra.Command, _ []string) {
-	configFile, _ := cmd.Flags().GetString(commonflags.ConfigFlag)
-	configDir, _ := cmd.Flags().GetString(commonflags.ConfigDirFlag)
-	appCfg := config.New(configFile, configDir, config.EnvPrefix)
-	batchSize, _ := cmd.Flags().GetUint32(flagBatchSize)
-	if batchSize == 0 {
-		commonCmd.ExitOnErr(cmd, "invalid batch size: %w", errors.New("batch size must be positive value"))
-	}
-	move, _ := cmd.Flags().GetBool(moveFlag)
-
-	storageEngine := newEngine(cmd, appCfg)
-	morphClient := createMorphClient(cmd, appCfg)
-	cnrCli := createContainerClient(cmd, morphClient)
-	nmCli := createNetmapClient(cmd, morphClient)
-	q := createQuarantine(cmd, storageEngine.DumpInfo())
-	pk := getPrivateKey(cmd, appCfg)
-
-	epoch, err := nmCli.Epoch(cmd.Context())
-	commonCmd.ExitOnErr(cmd, "read epoch from morph: %w", err)
-
-	nm, err := nmCli.GetNetMapByEpoch(cmd.Context(), epoch)
-	commonCmd.ExitOnErr(cmd, "read netmap from morph: %w", err)
-
-	cmd.Printf("Epoch: %d\n", nm.Epoch())
-	cmd.Printf("Nodes in the netmap: %d\n", len(nm.Nodes()))
-
-	ps := &processStatus{
-		statusCount: make(map[status]uint64),
-	}
-
-	stopCh := make(chan struct{})
-	start := time.Now()
-	var wg sync.WaitGroup
-	wg.Add(2)
-	go func() {
-		defer wg.Done()
-		tick := time.NewTicker(time.Second)
-		defer tick.Stop()
-		for {
-			select {
-			case <-cmd.Context().Done():
-				return
-			case <-stopCh:
-				return
-			case <-tick.C:
-				fmt.Printf("Objects processed: %d; Time elapsed: %s\n", ps.total(), time.Since(start))
-			}
-		}
-	}()
-	go func() {
-		defer wg.Done()
-		err = scanStorageEngine(cmd, batchSize, storageEngine, ps, appCfg, cnrCli, nmCli, q, pk, move)
-		close(stopCh)
-	}()
-	wg.Wait()
-	commonCmd.ExitOnErr(cmd, "scan storage engine for zombie objects: %w", err)
-
-	cmd.Println()
-	cmd.Println("Status description:")
-	cmd.Println("undefined -- nothing is clear")
-	cmd.Println("found -- object is found in cluster")
-	cmd.Println("quarantine -- object is not found in cluster")
-	cmd.Println()
-	for status, count := range ps.statusCount {
-		cmd.Printf("Status: %s, Count: %d\n", status, count)
-	}
-}
-
-type status string
-
-const (
-	statusUndefined  status = "undefined"
-	statusFound      status = "found"
-	statusQuarantine status = "quarantine"
-)
-
-func checkAddr(ctx context.Context, cnrCli *cntClient.Client, nmCli *netmap.Client, cc *cache.ClientCache, obj object.Info) (status, error) {
-	rawCID := make([]byte, sha256.Size)
-	cid := obj.Address.Container()
-	cid.Encode(rawCID)
-
-	cnr, err := cnrCli.Get(ctx, rawCID)
-	if err != nil {
-		var errContainerNotFound *apistatus.ContainerNotFound
-		if errors.As(err, &errContainerNotFound) {
-			// Policer will deal with this object.
-			return statusFound, nil
-		}
-		return statusUndefined, fmt.Errorf("read container %s from morph: %w", cid, err)
-	}
-	nm, err := nmCli.NetMap(ctx)
-	if err != nil {
-		return statusUndefined, fmt.Errorf("read netmap from morph: %w", err)
-	}
-
-	nodes, err := nm.ContainerNodes(cnr.Value.PlacementPolicy(), rawCID)
-	if err != nil {
-		// Not enough nodes, check all netmap nodes.
-		nodes = append([][]netmap.NodeInfo{}, nm.Nodes())
-	}
-
-	objID := obj.Address.Object()
-	cnrID := obj.Address.Container()
-	local := true
-	raw := false
-	if obj.ECInfo != nil {
-		objID = obj.ECInfo.ParentID
-		local = false
-		raw = true
-	}
-	prm := clientSDK.PrmObjectHead{
-		ObjectID:    &objID,
-		ContainerID: &cnrID,
-		Local:       local,
-		Raw:         raw,
-	}
-
-	var ni clientCore.NodeInfo
-	for i := range nodes {
-		for j := range nodes[i] {
-			if err := clientCore.NodeInfoFromRawNetmapElement(&ni, netmapCore.Node(nodes[i][j])); err != nil {
-				return statusUndefined, fmt.Errorf("parse node info: %w", err)
-			}
-			c, err := cc.Get(ni)
-			if err != nil {
-				continue
-			}
-			res, err := c.ObjectHead(ctx, prm)
-			if err != nil {
-				var errECInfo *objectSDK.ECInfoError
-				if raw && errors.As(err, &errECInfo) {
-					return statusFound, nil
-				}
-				continue
-			}
-			if err := apistatus.ErrFromStatus(res.Status()); err != nil {
-				continue
-			}
-			return statusFound, nil
-		}
-	}
-
-	if cnr.Value.PlacementPolicy().NumberOfReplicas() == 1 && cnr.Value.PlacementPolicy().ReplicaDescriptor(0).NumberOfObjects() == 1 {
-		return statusFound, nil
-	}
-	return statusQuarantine, nil
-}
-
-func scanStorageEngine(cmd *cobra.Command, batchSize uint32, storageEngine *engine.StorageEngine, ps *processStatus,
-	appCfg *config.Config, cnrCli *cntClient.Client, nmCli *netmap.Client, q *quarantine, pk *ecdsa.PrivateKey, move bool,
-) error {
-	cc := cache.NewSDKClientCache(cache.ClientCacheOpts{
-		DialTimeout:      apiclientconfig.DialTimeout(appCfg),
-		StreamTimeout:    apiclientconfig.StreamTimeout(appCfg),
-		ReconnectTimeout: apiclientconfig.ReconnectTimeout(appCfg),
-		Key:              pk,
-		AllowExternal:    apiclientconfig.AllowExternal(appCfg),
-	})
-	ctx := cmd.Context()
-
-	var cursor *engine.Cursor
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-		}
-
-		var prm engine.ListWithCursorPrm
-		prm.WithCursor(cursor)
-		prm.WithCount(batchSize)
-
-		res, err := storageEngine.ListWithCursor(ctx, prm)
-		if err != nil {
-			if errors.Is(err, engine.ErrEndOfListing) {
-				return nil
-			}
-			return fmt.Errorf("list with cursor: %w", err)
-		}
-
-		cursor = res.Cursor()
-		addrList := res.AddressList()
-		eg, egCtx := errgroup.WithContext(ctx)
-		eg.SetLimit(int(batchSize))
-
-		for i := range addrList {
-			addr := addrList[i]
-			eg.Go(func() error {
-				result, err := checkAddr(egCtx, cnrCli, nmCli, cc, addr)
-				if err != nil {
-					return fmt.Errorf("check object %s status: %w", addr.Address, err)
-				}
-				ps.add(result)
-
-				if !move && result == statusQuarantine {
-					cmd.Println(addr)
-					return nil
-				}
-
-				if result == statusQuarantine {
-					return moveToQuarantine(egCtx, storageEngine, q, addr.Address)
-				}
-				return nil
-			})
-		}
-		if err := eg.Wait(); err != nil {
-			return fmt.Errorf("process objects batch: %w", err)
-		}
-	}
-}
-
-func moveToQuarantine(ctx context.Context, storageEngine *engine.StorageEngine, q *quarantine, addr oid.Address) error {
-	var getPrm engine.GetPrm
-	getPrm.WithAddress(addr)
-	res, err := storageEngine.Get(ctx, getPrm)
-	if err != nil {
-		return fmt.Errorf("get object %s from storage engine: %w", addr, err)
-	}
-
-	if err := q.Put(ctx, res.Object()); err != nil {
-		return fmt.Errorf("put object %s to quarantine: %w", addr, err)
-	}
-
-	var delPrm engine.DeletePrm
-	delPrm.WithForceRemoval()
-	delPrm.WithAddress(addr)
-
-	if err = storageEngine.Delete(ctx, delPrm); err != nil {
-		return fmt.Errorf("delete object %s from storage engine: %w", addr, err)
-	}
-	return nil
-}
-
-type processStatus struct {
-	guard       sync.RWMutex
-	statusCount map[status]uint64
-	count       uint64
-}
-
-func (s *processStatus) add(st status) {
-	s.guard.Lock()
-	defer s.guard.Unlock()
-	s.statusCount[st]++
-	s.count++
-}
-
-func (s *processStatus) total() uint64 {
-	s.guard.RLock()
-	defer s.guard.RUnlock()
-	return s.count
-}

cmd/frostfs-adm/internal/modules/maintenance/zombie/storage_engine.go

@@ -1,200 +0,0 @@
-package zombie
-
-import (
-	"context"
-	"time"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	engineconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine"
-	shardconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard"
-	blobovniczaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor/blobovnicza"
-	fstreeconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor/fstree"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/blobovniczatree"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/fstree"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/engine"
-	meta "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/metabase"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/pilorama"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/writecache"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
-	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
-	"github.com/panjf2000/ants/v2"
-	"github.com/spf13/cobra"
-	"go.etcd.io/bbolt"
-	"go.uber.org/zap"
-)
-
-func newEngine(cmd *cobra.Command, c *config.Config) *engine.StorageEngine {
-	ngOpts := storageEngineOptions(c)
-	shardOpts := shardOptions(cmd, c)
-	e := engine.New(ngOpts...)
-	for _, opts := range shardOpts {
-		_, err := e.AddShard(cmd.Context(), opts...)
-		commonCmd.ExitOnErr(cmd, "iterate shards from config: %w", err)
-	}
-	commonCmd.ExitOnErr(cmd, "open storage engine: %w", e.Open(cmd.Context()))
-	commonCmd.ExitOnErr(cmd, "init storage engine: %w", e.Init(cmd.Context()))
-	return e
-}
-
-func storageEngineOptions(c *config.Config) []engine.Option {
-	return []engine.Option{
-		engine.WithErrorThreshold(engineconfig.ShardErrorThreshold(c)),
-		engine.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-		engine.WithLowMemoryConsumption(engineconfig.EngineLowMemoryConsumption(c)),
-	}
-}
-
-func shardOptions(cmd *cobra.Command, c *config.Config) [][]shard.Option {
-	var result [][]shard.Option
-	err := engineconfig.IterateShards(c, false, func(sh *shardconfig.Config) error {
-		result = append(result, getShardOpts(cmd, c, sh))
-		return nil
-	})
-	commonCmd.ExitOnErr(cmd, "iterate shards from config: %w", err)
-	return result
-}
-
-func getShardOpts(cmd *cobra.Command, c *config.Config, sh *shardconfig.Config) []shard.Option {
-	wc, wcEnabled := getWriteCacheOpts(sh)
-	return []shard.Option{
-		shard.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-		shard.WithRefillMetabase(sh.RefillMetabase()),
-		shard.WithRefillMetabaseWorkersCount(sh.RefillMetabaseWorkersCount()),
-		shard.WithMode(sh.Mode()),
-		shard.WithBlobStorOptions(getBlobstorOpts(cmd.Context(), sh)...),
-		shard.WithMetaBaseOptions(getMetabaseOpts(sh)...),
-		shard.WithPiloramaOptions(getPiloramaOpts(c, sh)...),
-		shard.WithWriteCache(wcEnabled),
-		shard.WithWriteCacheOptions(wc),
-		shard.WithRemoverBatchSize(sh.GC().RemoverBatchSize()),
-		shard.WithGCRemoverSleepInterval(sh.GC().RemoverSleepInterval()),
-		shard.WithExpiredCollectorBatchSize(sh.GC().ExpiredCollectorBatchSize()),
-		shard.WithExpiredCollectorWorkerCount(sh.GC().ExpiredCollectorWorkerCount()),
-		shard.WithGCWorkerPoolInitializer(func(sz int) util.WorkerPool {
-			pool, err := ants.NewPool(sz)
-			commonCmd.ExitOnErr(cmd, "init GC pool: %w", err)
-			return pool
-		}),
-		shard.WithLimiter(qos.NewNoopLimiter()),
-	}
-}
-
-func getWriteCacheOpts(sh *shardconfig.Config) ([]writecache.Option, bool) {
-	if wc := sh.WriteCache(); wc != nil && wc.Enabled() {
-		var result []writecache.Option
-		result = append(result,
-			writecache.WithPath(wc.Path()),
-			writecache.WithFlushSizeLimit(wc.MaxFlushingObjectsSize()),
-			writecache.WithMaxObjectSize(wc.MaxObjectSize()),
-			writecache.WithFlushWorkersCount(wc.WorkerCount()),
-			writecache.WithMaxCacheSize(wc.SizeLimit()),
-			writecache.WithMaxCacheCount(wc.CountLimit()),
-			writecache.WithNoSync(wc.NoSync()),
-			writecache.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-			writecache.WithQoSLimiter(qos.NewNoopLimiter()),
-		)
-		return result, true
-	}
-	return nil, false
-}
-
-func getPiloramaOpts(c *config.Config, sh *shardconfig.Config) []pilorama.Option {
-	var piloramaOpts []pilorama.Option
-	if config.BoolSafe(c.Sub("tree"), "enabled") {
-		pr := sh.Pilorama()
-		piloramaOpts = append(piloramaOpts,
-			pilorama.WithPath(pr.Path()),
-			pilorama.WithPerm(pr.Perm()),
-			pilorama.WithNoSync(pr.NoSync()),
-			pilorama.WithMaxBatchSize(pr.MaxBatchSize()),
-			pilorama.WithMaxBatchDelay(pr.MaxBatchDelay()),
-		)
-	}
-	return piloramaOpts
-}
-
-func getMetabaseOpts(sh *shardconfig.Config) []meta.Option {
-	return []meta.Option{
-		meta.WithPath(sh.Metabase().Path()),
-		meta.WithPermissions(sh.Metabase().BoltDB().Perm()),
-		meta.WithMaxBatchSize(sh.Metabase().BoltDB().MaxBatchSize()),
-		meta.WithMaxBatchDelay(sh.Metabase().BoltDB().MaxBatchDelay()),
-		meta.WithBoltDBOptions(&bbolt.Options{
-			Timeout: 100 * time.Millisecond,
-		}),
-		meta.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-		meta.WithEpochState(&epochState{}),
-	}
-}
-
-func getBlobstorOpts(ctx context.Context, sh *shardconfig.Config) []blobstor.Option {
-	result := []blobstor.Option{
-		blobstor.WithCompression(sh.Compression()),
-		blobstor.WithStorages(getSubStorages(ctx, sh)),
-		blobstor.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-	}
-
-	return result
-}
-
-func getSubStorages(ctx context.Context, sh *shardconfig.Config) []blobstor.SubStorage {
-	var ss []blobstor.SubStorage
-	for _, storage := range sh.BlobStor().Storages() {
-		switch storage.Type() {
-		case blobovniczatree.Type:
-			sub := blobovniczaconfig.From((*config.Config)(storage))
-			blobTreeOpts := []blobovniczatree.Option{
-				blobovniczatree.WithRootPath(storage.Path()),
-				blobovniczatree.WithPermissions(storage.Perm()),
-				blobovniczatree.WithBlobovniczaSize(sub.Size()),
-				blobovniczatree.WithBlobovniczaShallowDepth(sub.ShallowDepth()),
-				blobovniczatree.WithBlobovniczaShallowWidth(sub.ShallowWidth()),
-				blobovniczatree.WithOpenedCacheSize(sub.OpenedCacheSize()),
-				blobovniczatree.WithOpenedCacheTTL(sub.OpenedCacheTTL()),
-				blobovniczatree.WithOpenedCacheExpInterval(sub.OpenedCacheExpInterval()),
-				blobovniczatree.WithInitWorkerCount(sub.InitWorkerCount()),
-				blobovniczatree.WithWaitBeforeDropDB(sub.RebuildDropTimeout()),
-				blobovniczatree.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-				blobovniczatree.WithObjectSizeLimit(sh.SmallSizeLimit()),
-			}
-
-			ss = append(ss, blobstor.SubStorage{
-				Storage: blobovniczatree.NewBlobovniczaTree(ctx, blobTreeOpts...),
-				Policy: func(_ *objectSDK.Object, data []byte) bool {
-					return uint64(len(data)) < sh.SmallSizeLimit()
-				},
-			})
-		case fstree.Type:
-			sub := fstreeconfig.From((*config.Config)(storage))
-			fstreeOpts := []fstree.Option{
-				fstree.WithPath(storage.Path()),
-				fstree.WithPerm(storage.Perm()),
-				fstree.WithDepth(sub.Depth()),
-				fstree.WithNoSync(sub.NoSync()),
-				fstree.WithLogger(logger.NewLoggerWrapper(zap.NewNop())),
-			}
-
-			ss = append(ss, blobstor.SubStorage{
-				Storage: fstree.New(fstreeOpts...),
-				Policy: func(_ *objectSDK.Object, _ []byte) bool {
-					return true
-				},
-			})
-		default:
-			// should never happen, that has already
-			// been handled: when the config was read
-		}
-	}
-	return ss
-}
-
-type epochState struct{}
-
-func (epochState) CurrentEpoch() uint64 {
-	return 0
-}

cmd/frostfs-adm/internal/modules/morph/balance/balance.go

@@ -9,7 +9,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-contract/nns"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
 	"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
@@ -162,7 +161,9 @@ func printAlphabetContractBalances(cmd *cobra.Command, c helper.Client, inv *inv
 			helper.GetAlphabetNNSDomain(i),
 			int64(nns.TXT))
 	}
-	assert.NoError(w.Err)
+	if w.Err != nil {
+		panic(w.Err)
+	}
 
 	alphaRes, err := c.InvokeScript(w.Bytes(), nil)
 	if err != nil {
@@ -225,7 +226,9 @@ func fetchBalances(c *invoker.Invoker, gasHash util.Uint160, accounts []accBalan
 	for i := range accounts {
 		emit.AppCall(w.BinWriter, gasHash, "balanceOf", callflag.ReadStates, accounts[i].scriptHash)
 	}
-	assert.NoError(w.Err)
+	if w.Err != nil {
+		panic(w.Err)
+	}
 
 	res, err := c.Run(w.Bytes())
 	if err != nil || res.State != vmstate.Halt.String() || len(res.Stack) != len(accounts) {

cmd/frostfs-adm/internal/modules/morph/config/config.go

@@ -65,14 +65,14 @@ func dumpNetworkConfig(cmd *cobra.Command, _ []string) error {
 			nbuf := make([]byte, 8)
 			copy(nbuf[:], v)
 			n := binary.LittleEndian.Uint64(nbuf)
-			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%d (int)\n", k, n))
+			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%d (int)\n", k, n)))
 		case netmap.HomomorphicHashingDisabledKey, netmap.MaintenanceModeAllowedConfig:
 			if len(v) == 0 || len(v) > 1 {
 				return helper.InvalidConfigValueErr(k)
 			}
-			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%t (bool)\n", k, v[0] == 1))
+			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%t (bool)\n", k, v[0] == 1)))
 		default:
-			_, _ = tw.Write(fmt.Appendf(nil, "%s:\t%s (hex)\n", k, hex.EncodeToString(v)))
+			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%s (hex)\n", k, hex.EncodeToString(v))))
 		}
 	}
 

cmd/frostfs-adm/internal/modules/morph/container/container.go

@@ -10,7 +10,6 @@ import (
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
 	"github.com/nspcc-dev/neo-go/pkg/io"
@@ -236,7 +235,9 @@ func restoreOrPutContainers(containers []Container, isOK func([]byte) bool, cmd
 
 		putContainer(bw, ch, cnt)
 
-		assert.NoError(bw.Err)
+		if bw.Err != nil {
+			panic(bw.Err)
+		}
 
 		if err := wCtx.SendConsensusTx(bw.Bytes()); err != nil {
 			return err

cmd/frostfs-adm/internal/modules/morph/contract/deploy.go

@@ -10,7 +10,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"github.com/nspcc-dev/neo-go/cli/cmdargs"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
@@ -121,7 +120,9 @@ func deployContractCmd(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	assert.NoError(writer.Err, "can't create deployment script")
+	if writer.Err != nil {
+		panic(fmt.Errorf("BUG: can't create deployment script: %w", writer.Err))
+	}
 
 	if err := c.SendCommitteeTx(writer.Bytes(), false); err != nil {
 		return err
@@ -172,8 +173,9 @@ func registerNNS(nnsCs *state.Contract, c *helper.InitializeContext, zone string
 			domain, int64(nns.TXT), address.Uint160ToString(cs.Hash))
 	}
 
-	assert.NoError(bw.Err, "can't create deployment script")
-	if bw.Len() != start {
+	if bw.Err != nil {
+		panic(fmt.Errorf("BUG: can't create deployment script: %w", writer.Err))
+	} else if bw.Len() != start {
 		writer.WriteBytes(bw.Bytes())
 		emit.Opcodes(writer.BinWriter, opcode.LDSFLD0, opcode.PUSH1, opcode.PACK)
 		emit.AppCallNoArgs(writer.BinWriter, nnsCs.Hash, "setPrice", callflag.All)

cmd/frostfs-adm/internal/modules/morph/contract/dump_hashes.go

@@ -11,7 +11,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	morphClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neo-go/pkg/io"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
@@ -220,8 +219,8 @@ func printContractInfo(cmd *cobra.Command, infos []contractDumpInfo) {
 		if info.version == "" {
 			info.version = "unknown"
 		}
-		_, _ = tw.Write(fmt.Appendf(nil, "%s\t(%s):\t%s\n",
-			info.name, info.version, info.hash.StringLE()))
+		_, _ = tw.Write([]byte(fmt.Sprintf("%s\t(%s):\t%s\n",
+			info.name, info.version, info.hash.StringLE())))
 	}
 	_ = tw.Flush()
 
@@ -237,17 +236,21 @@ func fillContractVersion(cmd *cobra.Command, c helper.Client, infos []contractDu
 		} else {
 			sub.Reset()
 			emit.AppCall(sub.BinWriter, infos[i].hash, "version", callflag.NoneFlag)
-			assert.NoError(sub.Err, "can't create version script")
+			if sub.Err != nil {
+				panic(fmt.Errorf("BUG: can't create version script: %w", bw.Err))
+			}
 
 			script := sub.Bytes()
 			emit.Instruction(bw.BinWriter, opcode.TRY, []byte{byte(3 + len(script) + 2), 0})
-			bw.WriteBytes(script)
+			bw.BinWriter.WriteBytes(script)
 			emit.Instruction(bw.BinWriter, opcode.ENDTRY, []byte{2 + 1})
 			emit.Opcodes(bw.BinWriter, opcode.PUSH0)
 		}
 	}
 	emit.Opcodes(bw.BinWriter, opcode.NOP) // for the last ENDTRY target
-	assert.NoError(bw.Err, "can't create version script")
+	if bw.Err != nil {
+		panic(fmt.Errorf("BUG: can't create version script: %w", bw.Err))
+	}
 
 	res, err := c.InvokeScript(bw.Bytes(), nil)
 	if err != nil {

cmd/frostfs-adm/internal/modules/morph/frostfsid/frostfsid.go

@@ -34,7 +34,7 @@ const (
 	subjectNameFlag    = "subject-name"
 	subjectKeyFlag     = "subject-key"
 	subjectAddressFlag = "subject-address"
-	extendedFlag       = "extended"
+	includeNamesFlag   = "include-names"
 	groupNameFlag      = "group-name"
 	groupIDFlag        = "group-id"
 
@@ -209,7 +209,7 @@ func initFrostfsIDListSubjectsCmd() {
 	Cmd.AddCommand(frostfsidListSubjectsCmd)
 	frostfsidListSubjectsCmd.Flags().StringP(commonflags.EndpointFlag, commonflags.EndpointFlagShort, "", commonflags.EndpointFlagDesc)
 	frostfsidListSubjectsCmd.Flags().String(namespaceFlag, "", "Namespace to list subjects")
-	frostfsidListSubjectsCmd.Flags().Bool(extendedFlag, false, "Whether include subject info (require additional requests)")
+	frostfsidListSubjectsCmd.Flags().Bool(includeNamesFlag, false, "Whether include subject name (require additional requests)")
 }
 
 func initFrostfsIDCreateGroupCmd() {
@@ -256,7 +256,7 @@ func initFrostfsIDListGroupSubjectsCmd() {
 	frostfsidListGroupSubjectsCmd.Flags().StringP(commonflags.EndpointFlag, commonflags.EndpointFlagShort, "", commonflags.EndpointFlagDesc)
 	frostfsidListGroupSubjectsCmd.Flags().String(namespaceFlag, "", "Namespace name")
 	frostfsidListGroupSubjectsCmd.Flags().Int64(groupIDFlag, 0, "Group id")
-	frostfsidListGroupSubjectsCmd.Flags().Bool(extendedFlag, false, "Whether include subject info (require additional requests)")
+	frostfsidListGroupSubjectsCmd.Flags().Bool(includeNamesFlag, false, "Whether include subject name (require additional requests)")
 }
 
 func initFrostfsIDSetKVCmd() {
@@ -336,7 +336,7 @@ func frostfsidDeleteSubject(cmd *cobra.Command, _ []string) {
 }
 
 func frostfsidListSubjects(cmd *cobra.Command, _ []string) {
-	extended, _ := cmd.Flags().GetBool(extendedFlag)
+	includeNames, _ := cmd.Flags().GetBool(includeNamesFlag)
 	ns := getFrostfsIDNamespace(cmd)
 	inv, _, hash := initInvoker(cmd)
 	reader := frostfsidrpclient.NewReader(inv, hash)
@@ -349,19 +349,21 @@ func frostfsidListSubjects(cmd *cobra.Command, _ []string) {
 	sort.Slice(subAddresses, func(i, j int) bool { return subAddresses[i].Less(subAddresses[j]) })
 
 	for _, addr := range subAddresses {
-		if !extended {
+		if !includeNames {
 			cmd.Println(address.Uint160ToString(addr))
 			continue
 		}
 
-		items, err := reader.GetSubject(addr)
+		sessionID, it, err := reader.ListSubjects()
 		commonCmd.ExitOnErr(cmd, "can't get subject: %w", err)
 
+		items, err := readIterator(inv, &it, sessionID)
+		commonCmd.ExitOnErr(cmd, "can't read iterator: %w", err)
+
 		subj, err := frostfsidclient.ParseSubject(items)
 		commonCmd.ExitOnErr(cmd, "can't parse subject: %w", err)
 
-		printSubjectInfo(cmd, addr, subj)
-		cmd.Println()
+		cmd.Printf("%s (%s)\n", address.Uint160ToString(addr), subj.Name)
 	}
 }
 
@@ -481,7 +483,7 @@ func frostfsidDeleteKV(cmd *cobra.Command, _ []string) {
 func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 	ns := getFrostfsIDNamespace(cmd)
 	groupID := getFrostfsIDGroupID(cmd)
-	extended, _ := cmd.Flags().GetBool(extendedFlag)
+	includeNames, _ := cmd.Flags().GetBool(includeNamesFlag)
 	inv, cs, hash := initInvoker(cmd)
 	_, err := helper.NNSResolveHash(inv, cs.Hash, helper.DomainOf(constants.FrostfsIDContract))
 	commonCmd.ExitOnErr(cmd, "can't get netmap contract hash: %w", err)
@@ -499,7 +501,7 @@ func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 	sort.Slice(subjects, func(i, j int) bool { return subjects[i].Less(subjects[j]) })
 
 	for _, subjAddr := range subjects {
-		if !extended {
+		if !includeNames {
 			cmd.Println(address.Uint160ToString(subjAddr))
 			continue
 		}
@@ -508,8 +510,7 @@ func frostfsidListGroupSubjects(cmd *cobra.Command, _ []string) {
 		commonCmd.ExitOnErr(cmd, "can't get subject: %w", err)
 		subj, err := frostfsidclient.ParseSubject(items)
 		commonCmd.ExitOnErr(cmd, "can't parse subject: %w", err)
-		printSubjectInfo(cmd, subjAddr, subj)
-		cmd.Println()
+		cmd.Printf("%s (%s)\n", address.Uint160ToString(subjAddr), subj.Name)
 	}
 }
 
@@ -599,30 +600,3 @@ func initInvoker(cmd *cobra.Command) (*invoker.Invoker, *state.Contract, util.Ui
 
 	return inv, cs, nmHash
 }
-
-func printSubjectInfo(cmd *cobra.Command, addr util.Uint160, subj *frostfsidclient.Subject) {
-	cmd.Printf("Address: %s\n", address.Uint160ToString(addr))
-	pk := "<nil>"
-	if subj.PrimaryKey != nil {
-		pk = subj.PrimaryKey.String()
-	}
-	cmd.Printf("Primary key: %s\n", pk)
-	cmd.Printf("Name: %s\n", subj.Name)
-	cmd.Printf("Namespace: %s\n", subj.Namespace)
-	if len(subj.AdditionalKeys) > 0 {
-		cmd.Printf("Additional keys:\n")
-		for _, key := range subj.AdditionalKeys {
-			k := "<nil>"
-			if key != nil {
-				k = key.String()
-			}
-			cmd.Printf("- %s\n", k)
-		}
-	}
-	if len(subj.KV) > 0 {
-		cmd.Printf("KV:\n")
-		for k, v := range subj.KV {
-			cmd.Printf("- %s: %s\n", k, v)
-		}
-	}
-}

cmd/frostfs-adm/internal/modules/morph/helper/initialize.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-contract/nns"
-	nns2 "git.frostfs.info/TrueCloudLab/frostfs-contract/rpcclient/nns"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/config"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
@@ -14,7 +13,9 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
 	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
+	nns2 "github.com/nspcc-dev/neo-go/pkg/rpcclient/nns"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
 	"github.com/nspcc-dev/neo-go/pkg/util"
@@ -186,9 +187,19 @@ func NNSResolveKey(inv *invoker.Invoker, nnsHash util.Uint160, domain string) (*
 }
 
 func NNSIsAvailable(c Client, nnsHash util.Uint160, name string) (bool, error) {
-	inv := invoker.New(c, nil)
-	reader := nns2.NewReader(inv, nnsHash)
-	return reader.IsAvailable(name)
+	switch c.(type) {
+	case *rpcclient.Client:
+		inv := invoker.New(c, nil)
+		reader := nns2.NewReader(inv, nnsHash)
+		return reader.IsAvailable(name)
+	default:
+		b, err := unwrap.Bool(InvokeFunction(c, nnsHash, "isAvailable", []any{name}, nil))
+		if err != nil {
+			return false, fmt.Errorf("`isAvailable`: invalid response: %w", err)
+		}
+
+		return b, nil
+	}
 }
 
 func CheckNotaryEnabled(c Client) error {

cmd/frostfs-adm/internal/modules/morph/helper/initialize_ctx.go

@@ -13,7 +13,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/config"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/innerring"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
@@ -22,7 +21,6 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/io"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/management"
-	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/context"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
@@ -30,6 +28,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
 	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
+	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
 	"github.com/nspcc-dev/neo-go/pkg/wallet"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -376,7 +375,9 @@ func (c *InitializeContext) sendMultiTx(script []byte, tryGroup bool, withConsen
 		}
 		act, err = actor.New(c.Client, signers)
 	} else {
-		assert.False(withConsensus, "BUG: should never happen")
+		if withConsensus {
+			panic("BUG: should never happen")
+		}
 		act, err = c.CommitteeAct, nil
 	}
 	if err != nil {
@@ -410,9 +411,11 @@ func (c *InitializeContext) MultiSignAndSend(tx *transaction.Transaction, accTyp
 
 func (c *InitializeContext) MultiSign(tx *transaction.Transaction, accType string) error {
 	version, err := c.Client.GetVersion()
-	// error appears only if client
-	// has not been initialized
-	assert.NoError(err)
+	if err != nil {
+		// error appears only if client
+		// has not been initialized
+		panic(err)
+	}
 	network := version.Protocol.Network
 
 	// Use parameter context to avoid dealing with signature order.
@@ -444,12 +447,12 @@ func (c *InitializeContext) MultiSign(tx *transaction.Transaction, accType strin
 
 	for i := range tx.Signers {
 		if tx.Signers[i].Account == h {
-			assert.True(i <= len(tx.Scripts), "BUG: invalid signing order")
 			if i < len(tx.Scripts) {
 				tx.Scripts[i] = *w
-			}
-			if i == len(tx.Scripts) {
+			} else if i == len(tx.Scripts) {
 				tx.Scripts = append(tx.Scripts, *w)
+			} else {
+				panic("BUG: invalid signing order")
 			}
 			return nil
 		}
@@ -507,7 +510,9 @@ func (c *InitializeContext) NNSRegisterDomainScript(nnsHash, expectedHash util.U
 			int64(constants.DefaultExpirationTime), constants.NNSTtlDefVal)
 		emit.Opcodes(bw.BinWriter, opcode.ASSERT)
 
-		assert.NoError(bw.Err)
+		if bw.Err != nil {
+			panic(bw.Err)
+		}
 		return bw.Bytes(), false, nil
 	}
 
@@ -519,8 +524,12 @@ func (c *InitializeContext) NNSRegisterDomainScript(nnsHash, expectedHash util.U
 }
 
 func (c *InitializeContext) NNSRootRegistered(nnsHash util.Uint160, zone string) (bool, error) {
-	avail, err := unwrap.Bool(c.CommitteeAct.Call(nnsHash, "isAvailable", zone))
-	return !avail, err
+	res, err := c.CommitteeAct.Call(nnsHash, "isAvailable", "name."+zone)
+	if err != nil {
+		return false, err
+	}
+
+	return res.State == vmstate.Halt.String(), nil
 }
 
 func (c *InitializeContext) IsUpdated(ctrHash util.Uint160, cs *ContractState) bool {

cmd/frostfs-adm/internal/modules/morph/helper/local_client.go

@@ -10,7 +10,6 @@ import (
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"github.com/google/uuid"
 	"github.com/nspcc-dev/neo-go/pkg/config"
 	"github.com/nspcc-dev/neo-go/pkg/core"
@@ -317,7 +316,9 @@ func (l *LocalClient) SendRawTransaction(tx *transaction.Transaction) (util.Uint
 func (l *LocalClient) putTransactions() error {
 	// 1. Prepare new block.
 	lastBlock, err := l.bc.GetBlock(l.bc.CurrentBlockHash())
-	assert.NoError(err)
+	if err != nil {
+		panic(err)
+	}
 	defer func() { l.transactions = l.transactions[:0] }()
 
 	b := &block.Block{
@@ -358,7 +359,9 @@ func InvokeFunction(c Client, h util.Uint160, method string, parameters []any, s
 	w := io.NewBufBinWriter()
 	emit.Array(w.BinWriter, parameters...)
 	emit.AppCallNoArgs(w.BinWriter, h, method, callflag.All)
-	assert.True(w.Err == nil, fmt.Sprintf("BUG: invalid parameters for '%s': %v", method, w.Err))
+	if w.Err != nil {
+		panic(fmt.Sprintf("BUG: invalid parameters for '%s': %v", method, w.Err))
+	}
 	return c.InvokeScript(w.Bytes(), signers)
 }
 

cmd/frostfs-adm/internal/modules/morph/helper/netmap.go

@@ -3,7 +3,6 @@ package helper
 import (
 	"errors"
 	"fmt"
-	"slices"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
@@ -119,8 +118,11 @@ func MergeNetmapConfig(roInvoker *invoker.Invoker, md map[string]any) error {
 		return err
 	}
 	for k, v := range m {
-		if slices.Contains(NetmapConfigKeys, k) {
-			md[k] = v
+		for _, key := range NetmapConfigKeys {
+			if k == key {
+				md[k] = v
+				break
+			}
 		}
 	}
 	return nil

cmd/frostfs-adm/internal/modules/morph/initialize/initialize_nns.go

@@ -7,7 +7,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-contract/nns"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	morphClient "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
@@ -112,7 +111,9 @@ func wrapRegisterScriptWithPrice(w *io.BufBinWriter, nnsHash util.Uint160, s []b
 	emit.Opcodes(w.BinWriter, opcode.LDSFLD0, opcode.PUSH1, opcode.PACK)
 	emit.AppCallNoArgs(w.BinWriter, nnsHash, "setPrice", callflag.All)
 
-	assert.NoError(w.Err, "can't wrap register script")
+	if w.Err != nil {
+		panic(fmt.Errorf("BUG: can't wrap register script: %w", w.Err))
+	}
 }
 
 func nnsRegisterDomain(c *helper.InitializeContext, nnsHash, expectedHash util.Uint160, domain string) error {

cmd/frostfs-adm/internal/modules/morph/initialize/initialize_register.go

@@ -1,18 +1,21 @@
 package initialize
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"github.com/nspcc-dev/neo-go/pkg/core/native"
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
 	"github.com/nspcc-dev/neo-go/pkg/io"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/neo"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17"
 	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
 	"github.com/nspcc-dev/neo-go/pkg/util"
@@ -27,8 +30,7 @@ const (
 )
 
 func registerCandidateRange(c *helper.InitializeContext, start, end int) error {
-	reader := neo.NewReader(c.ReadOnlyInvoker)
-	regPrice, err := reader.GetRegisterPrice()
+	regPrice, err := getCandidateRegisterPrice(c)
 	if err != nil {
 		return fmt.Errorf("can't fetch registration price: %w", err)
 	}
@@ -40,7 +42,9 @@ func registerCandidateRange(c *helper.InitializeContext, start, end int) error {
 		emit.Opcodes(w.BinWriter, opcode.ASSERT)
 	}
 	emit.AppCall(w.BinWriter, neo.Hash, "setRegisterPrice", callflag.States, regPrice)
-	assert.NoError(w.Err)
+	if w.Err != nil {
+		panic(fmt.Sprintf("BUG: %v", w.Err))
+	}
 
 	signers := []actor.SignerAccount{{
 		Signer:  c.GetSigner(false, c.CommitteeAcc),
@@ -112,7 +116,7 @@ func registerCandidates(c *helper.InitializeContext) error {
 func transferNEOToAlphabetContracts(c *helper.InitializeContext) error {
 	neoHash := neo.Hash
 
-	ok, err := transferNEOFinished(c)
+	ok, err := transferNEOFinished(c, neoHash)
 	if ok || err != nil {
 		return err
 	}
@@ -135,8 +139,33 @@ func transferNEOToAlphabetContracts(c *helper.InitializeContext) error {
 	return c.AwaitTx()
 }
 
-func transferNEOFinished(c *helper.InitializeContext) (bool, error) {
-	r := neo.NewReader(c.ReadOnlyInvoker)
+func transferNEOFinished(c *helper.InitializeContext, neoHash util.Uint160) (bool, error) {
+	r := nep17.NewReader(c.ReadOnlyInvoker, neoHash)
 	bal, err := r.BalanceOf(c.CommitteeAcc.Contract.ScriptHash())
 	return bal.Cmp(big.NewInt(native.NEOTotalSupply)) == -1, err
 }
+
+var errGetPriceInvalid = errors.New("`getRegisterPrice`: invalid response")
+
+func getCandidateRegisterPrice(c *helper.InitializeContext) (int64, error) {
+	switch c.Client.(type) {
+	case *rpcclient.Client:
+		inv := invoker.New(c.Client, nil)
+		reader := neo.NewReader(inv)
+		return reader.GetRegisterPrice()
+	default:
+		neoHash := neo.Hash
+		res, err := helper.InvokeFunction(c.Client, neoHash, "getRegisterPrice", nil, nil)
+		if err != nil {
+			return 0, err
+		}
+		if len(res.Stack) == 0 {
+			return 0, errGetPriceInvalid
+		}
+		bi, err := res.Stack[0].TryInteger()
+		if err != nil || !bi.IsInt64() {
+			return 0, errGetPriceInvalid
+		}
+		return bi.Int64(), nil
+	}
+}

cmd/frostfs-adm/internal/modules/morph/initialize/initialize_transfer.go

@@ -22,14 +22,15 @@ import (
 )
 
 const (
+	gasInitialTotalSupply = 30000000 * native.GASFactor
 	// initialAlphabetGASAmount represents the amount of GAS given to each alphabet node.
 	initialAlphabetGASAmount = 10_000 * native.GASFactor
 	// initialProxyGASAmount represents the amount of GAS given to a proxy contract.
 	initialProxyGASAmount = 50_000 * native.GASFactor
 )
 
-func initialCommitteeGASAmount(c *helper.InitializeContext, initialGasDistribution int64) int64 {
-	return (initialGasDistribution - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2
+func initialCommitteeGASAmount(c *helper.InitializeContext) int64 {
+	return (gasInitialTotalSupply - initialAlphabetGASAmount*int64(len(c.Wallets))) / 2
 }
 
 func transferFunds(c *helper.InitializeContext) error {
@@ -41,11 +42,6 @@ func transferFunds(c *helper.InitializeContext) error {
 		return err
 	}
 
-	version, err := c.Client.GetVersion()
-	if err != nil {
-		return err
-	}
-
 	var transfers []transferTarget
 	for _, acc := range c.Accounts {
 		to := acc.Contract.ScriptHash()
@@ -63,7 +59,7 @@ func transferFunds(c *helper.InitializeContext) error {
 		transferTarget{
 			Token:   gas.Hash,
 			Address: c.CommitteeAcc.Contract.ScriptHash(),
-			Amount:  initialCommitteeGASAmount(c, int64(version.Protocol.InitialGasDistribution)),
+			Amount:  initialCommitteeGASAmount(c),
 		},
 		transferTarget{
 			Token:   neo.Hash,
@@ -87,23 +83,16 @@ func transferFunds(c *helper.InitializeContext) error {
 // transferFundsFinished checks balances of accounts we transfer GAS to.
 // The stage is considered finished if the balance is greater than the half of what we need to transfer.
 func transferFundsFinished(c *helper.InitializeContext) (bool, error) {
-	r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash)
-	res, err := r.BalanceOf(c.ConsensusAcc.ScriptHash())
-	if err != nil {
-		return false, err
-	}
+	acc := c.Accounts[0]
 
-	version, err := c.Client.GetVersion()
-	if err != nil || res.Cmp(big.NewInt(int64(version.Protocol.InitialGasDistribution))) != -1 {
+	r := nep17.NewReader(c.ReadOnlyInvoker, gas.Hash)
+	res, err := r.BalanceOf(acc.Contract.ScriptHash())
+	if err != nil || res.Cmp(big.NewInt(initialAlphabetGASAmount/2)) != 1 {
 		return false, err
 	}
 
 	res, err = r.BalanceOf(c.CommitteeAcc.ScriptHash())
-	if err != nil {
-		return false, err
-	}
-
-	return res != nil && res.Cmp(big.NewInt(initialCommitteeGASAmount(c, int64(version.Protocol.InitialGasDistribution)))) == 1, err
+	return res != nil && res.Cmp(big.NewInt(initialCommitteeGASAmount(c)/2)) == 1, err
 }
 
 func transferGASToProxy(c *helper.InitializeContext) error {

cmd/frostfs-adm/internal/modules/morph/policy/policy.go

@@ -80,9 +80,9 @@ func dumpPolicyCmd(cmd *cobra.Command, _ []string) error {
 	buf := bytes.NewBuffer(nil)
 	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
 
-	_, _ = tw.Write(fmt.Appendf(nil, "Execution Fee Factor:\t%d (int)\n", execFee))
-	_, _ = tw.Write(fmt.Appendf(nil, "Fee Per Byte:\t%d (int)\n", feePerByte))
-	_, _ = tw.Write(fmt.Appendf(nil, "Storage Price:\t%d (int)\n", storagePrice))
+	_, _ = tw.Write([]byte(fmt.Sprintf("Execution Fee Factor:\t%d (int)\n", execFee)))
+	_, _ = tw.Write([]byte(fmt.Sprintf("Fee Per Byte:\t%d (int)\n", feePerByte)))
+	_, _ = tw.Write([]byte(fmt.Sprintf("Storage Price:\t%d (int)\n", storagePrice)))
 
 	_ = tw.Flush()
 	cmd.Print(buf.String())

cmd/frostfs-adm/internal/modules/root.go

@@ -5,9 +5,9 @@ import (
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/config"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/maintenance"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/metabase"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph"
+	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/storagecfg"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/misc"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/autocomplete"
 	utilConfig "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/config"
@@ -41,8 +41,8 @@ func init() {
 
 	rootCmd.AddCommand(config.RootCmd)
 	rootCmd.AddCommand(morph.RootCmd)
+	rootCmd.AddCommand(storagecfg.RootCmd)
 	rootCmd.AddCommand(metabase.RootCmd)
-	rootCmd.AddCommand(maintenance.RootCmd)
 
 	rootCmd.AddCommand(autocomplete.Command("frostfs-adm"))
 	rootCmd.AddCommand(gendoc.Command(rootCmd, gendoc.Options{}))

cmd/frostfs-adm/internal/modules/storagecfg/config.go

@@ -0,0 +1,137 @@
+package storagecfg
+
+const configTemplate = `logger:
+  level: info  # logger level: one of "debug", "info" (default), "warn", "error", "dpanic", "panic", "fatal"
+
+node:
+  wallet:
+    path: {{ .Wallet.Path }}  # path to a NEO wallet; ignored if key is presented
+    address: {{ .Wallet.Account }}  # address of a NEO account in the wallet; ignored if key is presented
+    password: {{ .Wallet.Password }}  # password for a NEO account in the wallet; ignored if key is presented
+  addresses:  # list of addresses announced by Storage node in the Network map
+    - {{ .AnnouncedAddress }}
+  attribute_0: UN-LOCODE:{{ .Attribute.Locode }}
+  relay: {{ .Relay }}  # start Storage node in relay mode without bootstrapping into the Network map
+
+grpc:
+  num: 1  # total number of listener endpoints
+  0:
+    endpoint: {{ .Endpoint }}  # endpoint for gRPC server
+    tls:{{if .TLSCert}}
+      enabled: true  # enable TLS for a gRPC connection (min version is TLS 1.2)
+      certificate: {{ .TLSCert }}  # path to TLS certificate
+      key: {{ .TLSKey }}  # path to TLS key
+    {{- else }}
+      enabled: false # disable TLS for a gRPC connection
+    {{- end}}
+
+control:
+  authorized_keys:  # list of hex-encoded public keys that have rights to use the Control Service
+    {{- range .AuthorizedKeys }}
+    - {{.}}{{end}}
+  grpc:
+    endpoint: {{.ControlEndpoint}}  # endpoint that is listened by the Control Service
+
+morph:
+  dial_timeout: 20s  # timeout for side chain NEO RPC client connection
+  cache_ttl: 15s  # use TTL cache for side chain GET operations
+  rpc_endpoint:  # side chain N3 RPC endpoints
+    {{- range .MorphRPC }}
+    - address: wss://{{.}}/ws{{end}}
+{{if not .Relay }}
+storage:
+  shard_pool_size: 15  # size of per-shard worker pools used for PUT operations
+
+  shard:
+    default: # section with the default shard parameters
+      metabase:
+        perm: 0644  # permissions for metabase files(directories: +x for current user and group)
+
+      blobstor:
+        perm: 0644  # permissions for blobstor files(directories: +x for current user and group)
+        depth: 2  # max depth of object tree storage in FS
+        small_object_size: 102400  # 100KiB, size threshold for "small" objects which are stored in key-value DB, not in FS, bytes
+        compress: true  # turn on/off Zstandard compression (level 3) of stored objects
+        compression_exclude_content_types:
+          - audio/*
+          - video/*
+
+        blobovnicza:
+          size: 1073741824  # approximate size limit of single blobovnicza instance, total size will be: size*width^(depth+1), bytes
+          depth: 1  # max depth of object tree storage in key-value DB
+          width: 4   # max width of object tree storage in key-value DB
+          opened_cache_capacity: 50  # maximum number of opened database files
+          opened_cache_ttl: 5m  # ttl for opened database file
+          opened_cache_exp_interval: 15s  # cache cleanup interval for expired blobovnicza's
+
+      gc:
+        remover_batch_size: 200  # number of objects to be removed by the garbage collector
+        remover_sleep_interval: 5m  # frequency of the garbage collector invocation
+    0:
+      mode: "read-write"  # mode of the shard, must be one of the: "read-write" (default), "read-only"
+
+      metabase:
+        path: {{ .MetabasePath }}  # path to the metabase
+
+      blobstor:
+        path: {{ .BlobstorPath }}  # path to the blobstor
+{{end}}`
+
+const (
+	neofsMainnetAddress   = "2cafa46838e8b564468ebd868dcafdd99dce6221"
+	balanceMainnetAddress = "dc1ec98d9d0c5f9dfade16144defe08cffc5ca55"
+	neofsTestnetAddress   = "b65d8243ac63983206d17e5221af0653a7266fa1"
+	balanceTestnetAddress = "e0420c216003747626670d1424569c17c79015bf"
+)
+
+var n3config = map[string]struct {
+	MorphRPC        []string
+	RPC             []string
+	NeoFSContract   string
+	BalanceContract string
+}{
+	"testnet": {
+		MorphRPC: []string{
+			"rpc01.morph.testnet.fs.neo.org:51331",
+			"rpc02.morph.testnet.fs.neo.org:51331",
+			"rpc03.morph.testnet.fs.neo.org:51331",
+			"rpc04.morph.testnet.fs.neo.org:51331",
+			"rpc05.morph.testnet.fs.neo.org:51331",
+			"rpc06.morph.testnet.fs.neo.org:51331",
+			"rpc07.morph.testnet.fs.neo.org:51331",
+		},
+		RPC: []string{
+			"rpc01.testnet.n3.nspcc.ru:21331",
+			"rpc02.testnet.n3.nspcc.ru:21331",
+			"rpc03.testnet.n3.nspcc.ru:21331",
+			"rpc04.testnet.n3.nspcc.ru:21331",
+			"rpc05.testnet.n3.nspcc.ru:21331",
+			"rpc06.testnet.n3.nspcc.ru:21331",
+			"rpc07.testnet.n3.nspcc.ru:21331",
+		},
+		NeoFSContract:   neofsTestnetAddress,
+		BalanceContract: balanceTestnetAddress,
+	},
+	"mainnet": {
+		MorphRPC: []string{
+			"rpc1.morph.fs.neo.org:40341",
+			"rpc2.morph.fs.neo.org:40341",
+			"rpc3.morph.fs.neo.org:40341",
+			"rpc4.morph.fs.neo.org:40341",
+			"rpc5.morph.fs.neo.org:40341",
+			"rpc6.morph.fs.neo.org:40341",
+			"rpc7.morph.fs.neo.org:40341",
+		},
+		RPC: []string{
+			"rpc1.n3.nspcc.ru:10331",
+			"rpc2.n3.nspcc.ru:10331",
+			"rpc3.n3.nspcc.ru:10331",
+			"rpc4.n3.nspcc.ru:10331",
+			"rpc5.n3.nspcc.ru:10331",
+			"rpc6.n3.nspcc.ru:10331",
+			"rpc7.n3.nspcc.ru:10331",
+		},
+		NeoFSContract:   neofsMainnetAddress,
+		BalanceContract: balanceMainnetAddress,
+	},
+}

cmd/frostfs-adm/internal/modules/storagecfg/root.go

@@ -0,0 +1,433 @@
+package storagecfg
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math/rand"
+	"net"
+	"net/url"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	netutil "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/network"
+	"github.com/chzyer/readline"
+	"github.com/nspcc-dev/neo-go/cli/flags"
+	"github.com/nspcc-dev/neo-go/cli/input"
+	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
+	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
+	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient/gas"
+	"github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17"
+	"github.com/nspcc-dev/neo-go/pkg/smartcontract/trigger"
+	"github.com/nspcc-dev/neo-go/pkg/util"
+	"github.com/nspcc-dev/neo-go/pkg/wallet"
+
+	"github.com/spf13/cobra"
+)
+
+const (
+	walletFlag  = "wallet"
+	accountFlag = "account"
+)
+
+const (
+	defaultControlEndpoint = "localhost:8090"
+	defaultDataEndpoint    = "localhost"
+)
+
+// RootCmd is a root command of config section.
+var RootCmd = &cobra.Command{
+	Use:   "storage-config [-w wallet] [-a acccount] [<path-to-config>]",
+	Short: "Section for storage node configuration commands",
+	Run:   storageConfig,
+}
+
+func init() {
+	fs := RootCmd.Flags()
+
+	fs.StringP(walletFlag, "w", "", "Path to wallet")
+	fs.StringP(accountFlag, "a", "", "Wallet account")
+}
+
+type config struct {
+	AnnouncedAddress string
+	AuthorizedKeys   []string
+	ControlEndpoint  string
+	Endpoint         string
+	TLSCert          string
+	TLSKey           string
+	MorphRPC         []string
+	Attribute        struct {
+		Locode string
+	}
+	Wallet struct {
+		Path     string
+		Account  string
+		Password string
+	}
+	Relay        bool
+	BlobstorPath string
+	MetabasePath string
+}
+
+func storageConfig(cmd *cobra.Command, args []string) {
+	outPath := getOutputPath(args)
+
+	historyPath := filepath.Join(os.TempDir(), "frostfs-adm.history")
+	readline.SetHistoryPath(historyPath)
+
+	var c config
+
+	c.Wallet.Path, _ = cmd.Flags().GetString(walletFlag)
+	if c.Wallet.Path == "" {
+		c.Wallet.Path = getPath("Path to the storage node wallet: ")
+	}
+
+	w, err := wallet.NewWalletFromFile(c.Wallet.Path)
+	fatalOnErr(err)
+
+	fillWalletAccount(cmd, &c, w)
+
+	accH, err := flags.ParseAddress(c.Wallet.Account)
+	fatalOnErr(err)
+
+	acc := w.GetAccount(accH)
+	if acc == nil {
+		fatalOnErr(errors.New("can't find account in wallet"))
+	}
+
+	c.Wallet.Password, err = input.ReadPassword(fmt.Sprintf("Enter password for %s > ", c.Wallet.Account))
+	fatalOnErr(err)
+
+	err = acc.Decrypt(c.Wallet.Password, keys.NEP2ScryptParams())
+	fatalOnErr(err)
+
+	c.AuthorizedKeys = append(c.AuthorizedKeys, hex.EncodeToString(acc.PrivateKey().PublicKey().Bytes()))
+
+	network := readNetwork(cmd)
+
+	c.MorphRPC = n3config[network].MorphRPC
+
+	depositGas(cmd, acc, network)
+
+	c.Attribute.Locode = getString("UN-LOCODE attribute in [XX YYY] format: ")
+
+	endpoint := getDefaultEndpoint(cmd, &c)
+	c.Endpoint = getString(fmt.Sprintf("Listening address [%s]: ", endpoint))
+	if c.Endpoint == "" {
+		c.Endpoint = endpoint
+	}
+
+	c.ControlEndpoint = getString(fmt.Sprintf("Listening address (control endpoint) [%s]: ", defaultControlEndpoint))
+	if c.ControlEndpoint == "" {
+		c.ControlEndpoint = defaultControlEndpoint
+	}
+
+	c.TLSCert = getPath("TLS Certificate (optional): ")
+	if c.TLSCert != "" {
+		c.TLSKey = getPath("TLS Key: ")
+	}
+
+	c.Relay = getConfirmation(false, "Use node as a relay? yes/[no]: ")
+	if !c.Relay {
+		p := getPath("Path to the storage directory (all available storage will be used): ")
+		c.BlobstorPath = filepath.Join(p, "blob")
+		c.MetabasePath = filepath.Join(p, "meta")
+	}
+
+	out := applyTemplate(c)
+	fatalOnErr(os.WriteFile(outPath, out, 0o644))
+
+	cmd.Println("Node is ready for work! Run `frostfs-node -config " + outPath + "`")
+}
+
+func getDefaultEndpoint(cmd *cobra.Command, c *config) string {
+	var addr, port string
+	for {
+		c.AnnouncedAddress = getString("Publicly announced address: ")
+		validator := netutil.Address{}
+		err := validator.FromString(c.AnnouncedAddress)
+		if err != nil {
+			cmd.Println("Incorrect address format. See https://git.frostfs.info/TrueCloudLab/frostfs-node/src/branch/master/pkg/network/address.go for details.")
+			continue
+		}
+		uriAddr, err := url.Parse(validator.URIAddr())
+		if err != nil {
+			panic(fmt.Errorf("unexpected error: %w", err))
+		}
+		addr = uriAddr.Hostname()
+		port = uriAddr.Port()
+		ip, err := net.ResolveIPAddr("ip", addr)
+		if err != nil {
+			cmd.Printf("Can't resolve IP address %s: %v\n", addr, err)
+			continue
+		}
+
+		if !ip.IP.IsGlobalUnicast() {
+			cmd.Println("IP must be global unicast.")
+			continue
+		}
+		cmd.Printf("Resolved IP address: %s\n", ip.String())
+
+		_, err = strconv.ParseUint(port, 10, 16)
+		if err != nil {
+			cmd.Println("Port must be an integer.")
+			continue
+		}
+
+		break
+	}
+	return net.JoinHostPort(defaultDataEndpoint, port)
+}
+
+func fillWalletAccount(cmd *cobra.Command, c *config, w *wallet.Wallet) {
+	c.Wallet.Account, _ = cmd.Flags().GetString(accountFlag)
+	if c.Wallet.Account == "" {
+		addr := address.Uint160ToString(w.GetChangeAddress())
+		c.Wallet.Account = getWalletAccount(w, fmt.Sprintf("Wallet account [%s]: ", addr))
+		if c.Wallet.Account == "" {
+			c.Wallet.Account = addr
+		}
+	}
+}
+
+func readNetwork(cmd *cobra.Command) string {
+	var network string
+	for {
+		network = getString("Choose network [mainnet]/testnet: ")
+		switch network {
+		case "":
+			network = "mainnet"
+		case "testnet", "mainnet":
+		default:
+			cmd.Println(`Network must be either "mainnet" or "testnet"`)
+			continue
+		}
+		break
+	}
+	return network
+}
+
+func getOutputPath(args []string) string {
+	if len(args) != 0 {
+		return args[0]
+	}
+	outPath := getPath("File to write config at [./config.yml]: ")
+	if outPath == "" {
+		outPath = "./config.yml"
+	}
+	return outPath
+}
+
+func getWalletAccount(w *wallet.Wallet, prompt string) string {
+	addrs := make([]readline.PrefixCompleterInterface, len(w.Accounts))
+	for i := range w.Accounts {
+		addrs[i] = readline.PcItem(w.Accounts[i].Address)
+	}
+
+	readline.SetAutoComplete(readline.NewPrefixCompleter(addrs...))
+	defer readline.SetAutoComplete(nil)
+
+	s, err := readline.Line(prompt)
+	fatalOnErr(err)
+	return strings.TrimSpace(s) // autocompleter can return a string with a trailing space
+}
+
+func getString(prompt string) string {
+	s, err := readline.Line(prompt)
+	fatalOnErr(err)
+	if s != "" {
+		_ = readline.AddHistory(s)
+	}
+	return s
+}
+
+type filenameCompleter struct{}
+
+func (filenameCompleter) Do(line []rune, pos int) (newLine [][]rune, length int) {
+	prefix := string(line[:pos])
+	dir := filepath.Dir(prefix)
+	de, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, 0
+	}
+
+	for i := range de {
+		name := filepath.Join(dir, de[i].Name())
+		if strings.HasPrefix(name, prefix) {
+			tail := []rune(strings.TrimPrefix(name, prefix))
+			if de[i].IsDir() {
+				tail = append(tail, filepath.Separator)
+			}
+			newLine = append(newLine, tail)
+		}
+	}
+	if pos != 0 {
+		return newLine, pos - len([]rune(dir))
+	}
+	return newLine, 0
+}
+
+func getPath(prompt string) string {
+	readline.SetAutoComplete(filenameCompleter{})
+	defer readline.SetAutoComplete(nil)
+
+	p, err := readline.Line(prompt)
+	fatalOnErr(err)
+
+	if p == "" {
+		return p
+	}
+
+	_ = readline.AddHistory(p)
+
+	abs, err := filepath.Abs(p)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("can't create an absolute path: %w", err))
+	}
+
+	return abs
+}
+
+func getConfirmation(def bool, prompt string) bool {
+	for {
+		s, err := readline.Line(prompt)
+		fatalOnErr(err)
+
+		switch strings.ToLower(s) {
+		case "y", "yes":
+			return true
+		case "n", "no":
+			return false
+		default:
+			if len(s) == 0 {
+				return def
+			}
+		}
+	}
+}
+
+func applyTemplate(c config) []byte {
+	tmpl, err := template.New("config").Parse(configTemplate)
+	fatalOnErr(err)
+
+	b := bytes.NewBuffer(nil)
+	fatalOnErr(tmpl.Execute(b, c))
+
+	return b.Bytes()
+}
+
+func fatalOnErr(err error) {
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func depositGas(cmd *cobra.Command, acc *wallet.Account, network string) {
+	sideClient := initClient(n3config[network].MorphRPC)
+	balanceHash, _ := util.Uint160DecodeStringLE(n3config[network].BalanceContract)
+
+	sideActor, err := actor.NewSimple(sideClient, acc)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("creating actor over side chain client: %w", err))
+	}
+
+	sideGas := nep17.NewReader(sideActor, balanceHash)
+	accSH := acc.Contract.ScriptHash()
+
+	balance, err := sideGas.BalanceOf(accSH)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("side chain balance: %w", err))
+	}
+
+	ok := getConfirmation(false, fmt.Sprintf("Current NeoFS balance is %s, make a deposit? y/[n]: ",
+		fixedn.ToString(balance, 12)))
+	if !ok {
+		return
+	}
+
+	amountStr := getString("Enter amount in GAS: ")
+	amount, err := fixedn.FromString(amountStr, 8)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("invalid amount: %w", err))
+	}
+
+	mainClient := initClient(n3config[network].RPC)
+	neofsHash, _ := util.Uint160DecodeStringLE(n3config[network].NeoFSContract)
+
+	mainActor, err := actor.NewSimple(mainClient, acc)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("creating actor over main chain client: %w", err))
+	}
+
+	mainGas := nep17.New(mainActor, gas.Hash)
+
+	txHash, _, err := mainGas.Transfer(accSH, neofsHash, amount, nil)
+	if err != nil {
+		fatalOnErr(fmt.Errorf("sending TX to the NeoFS contract: %w", err))
+	}
+
+	cmd.Print("Waiting for transactions to persist.")
+	tick := time.NewTicker(time.Second / 2)
+	defer tick.Stop()
+
+	timer := time.NewTimer(time.Second * 20)
+	defer timer.Stop()
+
+	at := trigger.Application
+
+loop:
+	for {
+		select {
+		case <-tick.C:
+			_, err := mainClient.GetApplicationLog(txHash, &at)
+			if err == nil {
+				cmd.Print("\n")
+				break loop
+			}
+			cmd.Print(".")
+		case <-timer.C:
+			cmd.Printf("\nTimeout while waiting for transaction to persist.\n")
+			if getConfirmation(false, "Continue configuration? yes/[no]: ") {
+				return
+			}
+			os.Exit(1)
+		}
+	}
+}
+
+func initClient(rpc []string) *rpcclient.Client {
+	var c *rpcclient.Client
+	var err error
+
+	shuffled := slices.Clone(rpc)
+	rand.Shuffle(len(shuffled), func(i, j int) { shuffled[i], shuffled[j] = shuffled[j], shuffled[i] })
+
+	for _, endpoint := range shuffled {
+		c, err = rpcclient.New(context.Background(), "https://"+endpoint, rpcclient.Options{
+			DialTimeout:    time.Second * 2,
+			RequestTimeout: time.Second * 5,
+		})
+		if err != nil {
+			continue
+		}
+		if err = c.Init(); err != nil {
+			continue
+		}
+		return c
+	}
+
+	fatalOnErr(fmt.Errorf("can't create N3 client: %w", err))
+	panic("unreachable")
+}

cmd/frostfs-cli/internal/client/client.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"slices"
+	"strings"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/accounting"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/checksum"
@@ -76,7 +77,9 @@ func ListContainers(ctx context.Context, prm ListContainersPrm) (res ListContain
 // SortedIDList returns sorted list of identifiers of user's containers.
 func (x ListContainersRes) SortedIDList() []cid.ID {
 	list := x.cliRes.Containers()
-	slices.SortFunc(list, cid.ID.Cmp)
+	slices.SortFunc(list, func(lhs, rhs cid.ID) int {
+		return strings.Compare(lhs.EncodeToString(), rhs.EncodeToString())
+	})
 	return list
 }
 
@@ -684,7 +687,9 @@ func SearchObjects(ctx context.Context, prm SearchObjectsPrm) (*SearchObjectsRes
 		return nil, fmt.Errorf("read object list: %w", err)
 	}
 
-	slices.SortFunc(list, oid.ID.Cmp)
+	slices.SortFunc(list, func(a, b oid.ID) int {
+		return strings.Compare(a.EncodeToString(), b.EncodeToString())
+	})
 
 	return &SearchObjectsRes{
 		ids: list,
@@ -858,8 +863,6 @@ type PatchObjectPrm struct {
 
 	ReplaceAttribute bool
 
-	NewSplitHeader *objectSDK.SplitHeader
-
 	PayloadPatches []PayloadPatch
 }
 
@@ -890,11 +893,7 @@ func Patch(ctx context.Context, prm PatchObjectPrm) (*PatchRes, error) {
 		return nil, fmt.Errorf("init payload reading: %w", err)
 	}
 
-	if patcher.PatchHeader(ctx, client.PatchHeaderPrm{
-		NewSplitHeader:    prm.NewSplitHeader,
-		NewAttributes:     prm.NewAttributes,
-		ReplaceAttributes: prm.ReplaceAttribute,
-	}) {
+	if patcher.PatchAttributes(ctx, prm.NewAttributes, prm.ReplaceAttribute) {
 		for _, pp := range prm.PayloadPatches {
 			payloadFile, err := os.OpenFile(pp.PayloadPath, os.O_RDONLY, os.ModePerm)
 			if err != nil {

cmd/frostfs-cli/internal/client/sdk.go

@@ -56,7 +56,7 @@ func GetSDKClient(ctx context.Context, cmd *cobra.Command, key *ecdsa.PrivateKey
 	prmDial := client.PrmDial{
 		Endpoint: addr.URIAddr(),
 		GRPCDialOptions: []grpc.DialOption{
-			grpc.WithChainUnaryInterceptor(tracing.NewUnaryClientInterceptor()),
+			grpc.WithChainUnaryInterceptor(tracing.NewUnaryClientInteceptor()),
 			grpc.WithChainStreamInterceptor(tracing.NewStreamClientInterceptor()),
 			grpc.WithDefaultCallOptions(grpc.WaitForReady(true)),
 		},

cmd/frostfs-cli/internal/commonflags/flags.go

@@ -28,7 +28,7 @@ const (
 	RPC          = "rpc-endpoint"
 	RPCShorthand = "r"
 	RPCDefault   = ""
-	RPCUsage     = "Remote node address ('<host>:<port>' or 'grpcs://<host>:<port>')"
+	RPCUsage     = "Remote node address (as 'multiaddr' or '<host>:<port>')"
 
 	Timeout          = "timeout"
 	TimeoutShorthand = "t"

cmd/frostfs-cli/modules/bearer/create.go

@@ -44,7 +44,6 @@ is set to current epoch + n.
 
 		_ = viper.BindPFlag(commonflags.WalletPath, ff.Lookup(commonflags.WalletPath))
 		_ = viper.BindPFlag(commonflags.Account, ff.Lookup(commonflags.Account))
-		_ = viper.BindPFlag(commonflags.RPC, ff.Lookup(commonflags.RPC))
 	},
 }
 
@@ -82,7 +81,7 @@ func createToken(cmd *cobra.Command, _ []string) {
 	commonCmd.ExitOnErr(cmd, "can't parse --"+notValidBeforeFlag+" flag: %w", err)
 
 	if iatRelative || expRelative || nvbRelative {
-		endpoint := viper.GetString(commonflags.RPC)
+		endpoint, _ := cmd.Flags().GetString(commonflags.RPC)
 		if len(endpoint) == 0 {
 			commonCmd.ExitOnErr(cmd, "can't fetch current epoch: %w", fmt.Errorf("'%s' flag value must be specified", commonflags.RPC))
 		}

cmd/frostfs-cli/modules/container/policy_playground.go

@@ -5,9 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"maps"
 	"os"
-	"slices"
 	"strings"
 
 	internalclient "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/client"
@@ -21,9 +19,8 @@ import (
 )
 
 type policyPlaygroundREPL struct {
-	cmd     *cobra.Command
-	nodes   map[string]netmap.NodeInfo
-	console *readline.Instance
+	cmd   *cobra.Command
+	nodes map[string]netmap.NodeInfo
 }
 
 func newPolicyPlaygroundREPL(cmd *cobra.Command) *policyPlaygroundREPL {
@@ -40,10 +37,10 @@ func (repl *policyPlaygroundREPL) handleLs(args []string) error {
 	i := 1
 	for id, node := range repl.nodes {
 		var attrs []string
-		for k, v := range node.Attributes() {
+		node.IterateAttributes(func(k, v string) {
 			attrs = append(attrs, fmt.Sprintf("%s:%q", k, v))
-		}
-		fmt.Fprintf(repl.console, "\t%2d: id=%s attrs={%v}\n", i, id, strings.Join(attrs, " "))
+		})
+		fmt.Printf("\t%2d: id=%s attrs={%v}\n", i, id, strings.Join(attrs, " "))
 		i++
 	}
 	return nil
@@ -150,29 +147,12 @@ func (repl *policyPlaygroundREPL) handleEval(args []string) error {
 		for _, node := range ns {
 			ids = append(ids, hex.EncodeToString(node.PublicKey()))
 		}
-		fmt.Fprintf(repl.console, "\t%2d: %v\n", i+1, ids)
+		fmt.Printf("\t%2d: %v\n", i+1, ids)
 	}
 
 	return nil
 }
 
-func (repl *policyPlaygroundREPL) handleHelp(args []string) error {
-	if len(args) != 0 {
-		if _, ok := commands[args[0]]; !ok {
-			return fmt.Errorf("unknown command: %q", args[0])
-		}
-		fmt.Fprintln(repl.console, commands[args[0]].usage)
-		return nil
-	}
-
-	commandList := slices.Collect(maps.Keys(commands))
-	slices.Sort(commandList)
-	for _, command := range commandList {
-		fmt.Fprintf(repl.console, "%s: %s\n", command, commands[command].descriprion)
-	}
-	return nil
-}
-
 func (repl *policyPlaygroundREPL) netMap() netmap.NetMap {
 	var nm netmap.NetMap
 	var nodes []netmap.NodeInfo
@@ -183,104 +163,15 @@ func (repl *policyPlaygroundREPL) netMap() netmap.NetMap {
 	return nm
 }
 
-type commandDescription struct {
-	descriprion string
-	usage       string
-}
-
-var commands = map[string]commandDescription{
-	"list": {
-		descriprion: "Display all nodes in the netmap",
-		usage: `Display all nodes in the netmap
-Example of usage:
-  list
-    1: id=03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae attrs={Continent:"Europe" Country:"Poland"}
-    2: id=02ac920cd7df0b61b289072e6b946e2da4e1a31b9ab1c621bb475e30fa4ab102c3 attrs={Continent:"Antarctica" Country:"Heard Island"}
-`,
-	},
-
-	"ls": {
-		descriprion: "Display all nodes in the netmap",
-		usage: `Display all nodes in the netmap
-Example of usage:
-  ls
-    1: id=03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae attrs={Continent:"Europe" Country:"Poland"}
-    2: id=02ac920cd7df0b61b289072e6b946e2da4e1a31b9ab1c621bb475e30fa4ab102c3 attrs={Continent:"Antarctica" Country:"Heard Island"}
-`,
-	},
-
-	"add": {
-		descriprion: "Add a new node: add <node-hash> attr=value",
-		usage: `Add a new node
-Example of usage:
-  add 03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae continent:Europe country:Poland`,
-	},
-
-	"load": {
-		descriprion: "Load netmap from file: load <path>",
-		usage: `Load netmap from file
-Example of usage:
-  load "netmap.json"
-File format (netmap.json):
-{
-  "03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae": {
-    "continent": "Europe",
-    "country": "Poland"
-  },
-  "02ac920cd7df0b61b289072e6b946e2da4e1a31b9ab1c621bb475e30fa4ab102c3": {
-    "continent": "Antarctica",
-    "country": "Heard Island"
-  }
-}`,
-	},
-
-	"remove": {
-		descriprion: "Remove a node: remove <node-hash>",
-		usage: `Remove a node
-Example of usage:
-  remove 03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae`,
-	},
-
-	"rm": {
-		descriprion: "Remove a node: rm <node-hash>",
-		usage: `Remove a node
-Example of usage:
-  rm 03ff65b6ae79134a4dce9d0d39d3851e9bab4ee97abf86e81e1c5bbc50cd2826ae`,
-	},
-
-	"eval": {
-		descriprion: "Evaluate a policy: eval <policy>",
-		usage: `Evaluate a policy
-Example of usage:
-  eval REP 2`,
-	},
-
-	"help": {
-		descriprion: "Show available commands",
-	},
-}
-
-func (repl *policyPlaygroundREPL) handleCommand(args []string) error {
-	if len(args) == 0 {
-		return nil
-	}
-
-	switch args[0] {
-	case "list", "ls":
-		return repl.handleLs(args[1:])
-	case "add":
-		return repl.handleAdd(args[1:])
-	case "load":
-		return repl.handleLoad(args[1:])
-	case "remove", "rm":
-		return repl.handleRemove(args[1:])
-	case "eval":
-		return repl.handleEval(args[1:])
-	case "help":
-		return repl.handleHelp(args[1:])
-	}
-	return fmt.Errorf("unknown command %q. See 'help' for assistance", args[0])
-}
+var policyPlaygroundCompleter = readline.NewPrefixCompleter(
+	readline.PcItem("list"),
+	readline.PcItem("ls"),
+	readline.PcItem("add"),
+	readline.PcItem("load"),
+	readline.PcItem("remove"),
+	readline.PcItem("rm"),
+	readline.PcItem("eval"),
+)
 
 func (repl *policyPlaygroundREPL) run() error {
 	if len(viper.GetString(commonflags.RPC)) > 0 {
@@ -299,32 +190,24 @@ func (repl *policyPlaygroundREPL) run() error {
 		}
 	}
 
-	if len(viper.GetString(netmapConfigPath)) > 0 {
-		err := repl.handleLoad([]string{viper.GetString(netmapConfigPath)})
-		commonCmd.ExitOnErr(repl.cmd, "load netmap config error: %w", err)
+	cmdHandlers := map[string]func([]string) error{
+		"list":   repl.handleLs,
+		"ls":     repl.handleLs,
+		"add":    repl.handleAdd,
+		"load":   repl.handleLoad,
+		"remove": repl.handleRemove,
+		"rm":     repl.handleRemove,
+		"eval":   repl.handleEval,
 	}
 
-	var cfgCompleter []readline.PrefixCompleterInterface
-	var helpSubItems []readline.PrefixCompleterInterface
-
-	for name := range commands {
-		if name != "help" {
-			cfgCompleter = append(cfgCompleter, readline.PcItem(name))
-			helpSubItems = append(helpSubItems, readline.PcItem(name))
-		}
-	}
-
-	cfgCompleter = append(cfgCompleter, readline.PcItem("help", helpSubItems...))
-	completer := readline.NewPrefixCompleter(cfgCompleter...)
 	rl, err := readline.NewEx(&readline.Config{
 		Prompt:          "> ",
 		InterruptPrompt: "^C",
-		AutoComplete:    completer,
+		AutoComplete:    policyPlaygroundCompleter,
 	})
 	if err != nil {
 		return fmt.Errorf("error initializing readline: %w", err)
 	}
-	repl.console = rl
 	defer rl.Close()
 
 	var exit bool
@@ -342,8 +225,17 @@ func (repl *policyPlaygroundREPL) run() error {
 		}
 		exit = false
 
-		if err := repl.handleCommand(strings.Fields(line)); err != nil {
-			fmt.Fprintf(repl.console, "error: %v\n", err)
+		parts := strings.Fields(line)
+		if len(parts) == 0 {
+			continue
+		}
+		cmd := parts[0]
+		if handler, exists := cmdHandlers[cmd]; exists {
+			if err := handler(parts[1:]); err != nil {
+				fmt.Printf("error: %v\n", err)
+			}
+		} else {
+			fmt.Printf("error: unknown command %q\n", cmd)
 		}
 	}
 }
@@ -359,14 +251,6 @@ If a wallet and endpoint is provided, the initial netmap data will be loaded fro
 	},
 }
 
-const (
-	netmapConfigPath  = "netmap-config"
-	netmapConfigUsage = "Path to the netmap configuration file"
-)
-
 func initContainerPolicyPlaygroundCmd() {
 	commonflags.Init(policyPlaygroundCmd)
-	policyPlaygroundCmd.Flags().String(netmapConfigPath, "", netmapConfigUsage)
-
-	_ = viper.BindPFlag(netmapConfigPath, policyPlaygroundCmd.Flags().Lookup(netmapConfigPath))
 }

cmd/frostfs-cli/modules/control/evacuation.go

@@ -296,7 +296,7 @@ func appendEstimation(sb *strings.Builder, resp *control.GetShardEvacuationStatu
 	leftSeconds := avgObjEvacuationTimeSeconds * objectsLeft
 	leftMinutes := int(leftSeconds / 60)
 
-	fmt.Fprintf(sb, " Estimated time left: %d minutes.", leftMinutes)
+	sb.WriteString(fmt.Sprintf(" Estimated time left: %d minutes.", leftMinutes))
 }
 
 func appendDuration(sb *strings.Builder, resp *control.GetShardEvacuationStatusResponse) {
@@ -305,20 +305,20 @@ func appendDuration(sb *strings.Builder, resp *control.GetShardEvacuationStatusR
 		hour := int(duration.Seconds() / 3600)
 		minute := int(duration.Seconds()/60) % 60
 		second := int(duration.Seconds()) % 60
-		fmt.Fprintf(sb, " Duration: %02d:%02d:%02d.", hour, minute, second)
+		sb.WriteString(fmt.Sprintf(" Duration: %02d:%02d:%02d.", hour, minute, second))
 	}
 }
 
 func appendStartedAt(sb *strings.Builder, resp *control.GetShardEvacuationStatusResponse) {
 	if resp.GetBody().GetStartedAt() != nil {
 		startedAt := time.Unix(resp.GetBody().GetStartedAt().GetValue(), 0).UTC()
-		fmt.Fprintf(sb, " Started at: %s UTC.", startedAt.Format(time.RFC3339))
+		sb.WriteString(fmt.Sprintf(" Started at: %s UTC.", startedAt.Format(time.RFC3339)))
 	}
 }
 
 func appendError(sb *strings.Builder, resp *control.GetShardEvacuationStatusResponse) {
 	if len(resp.GetBody().GetErrorMessage()) > 0 {
-		fmt.Fprintf(sb, " Error: %s.", resp.GetBody().GetErrorMessage())
+		sb.WriteString(fmt.Sprintf(" Error: %s.", resp.GetBody().GetErrorMessage()))
 	}
 }
 
@@ -332,7 +332,7 @@ func appendStatus(sb *strings.Builder, resp *control.GetShardEvacuationStatusRes
 	default:
 		status = "undefined"
 	}
-	fmt.Fprintf(sb, " Status: %s.", status)
+	sb.WriteString(fmt.Sprintf(" Status: %s.", status))
 }
 
 func appendShardIDs(sb *strings.Builder, resp *control.GetShardEvacuationStatusResponse) {
@@ -350,14 +350,14 @@ func appendShardIDs(sb *strings.Builder, resp *control.GetShardEvacuationStatusR
 }
 
 func appendCounts(sb *strings.Builder, resp *control.GetShardEvacuationStatusResponse) {
-	fmt.Fprintf(sb, " Evacuated %d objects out of %d, failed to evacuate: %d, skipped: %d; evacuated %d trees out of %d, failed to evacuate: %d.",
+	sb.WriteString(fmt.Sprintf(" Evacuated %d objects out of %d, failed to evacuate: %d, skipped: %d; evacuated %d trees out of %d, failed to evacuate: %d.",
 		resp.GetBody().GetEvacuatedObjects(),
 		resp.GetBody().GetTotalObjects(),
 		resp.GetBody().GetFailedObjects(),
 		resp.GetBody().GetSkippedObjects(),
 		resp.GetBody().GetEvacuatedTrees(),
 		resp.GetBody().GetTotalTrees(),
-		resp.GetBody().GetFailedTrees())
+		resp.GetBody().GetFailedTrees()))
 }
 
 func initControlEvacuationShardCmd() {

cmd/frostfs-cli/modules/control/list_targets.go

@@ -62,7 +62,7 @@ func listTargets(cmd *cobra.Command, _ []string) {
 	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
 	_, _ = tw.Write([]byte("#\tName\tType\n"))
 	for i, t := range targets {
-		_, _ = tw.Write(fmt.Appendf(nil, "%s\t%s\t%s\n", strconv.Itoa(i), t.GetName(), t.GetType()))
+		_, _ = tw.Write([]byte(fmt.Sprintf("%s\t%s\t%s\n", strconv.Itoa(i), t.GetName(), t.GetType())))
 	}
 	_ = tw.Flush()
 	cmd.Print(buf.String())

cmd/frostfs-cli/modules/control/locate.go

@@ -1,117 +0,0 @@
-package control
-
-import (
-	"bytes"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/commonflags"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/key"
-	object "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/modules/object"
-	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/services/control"
-	rawclient "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/client"
-	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
-	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
-	"github.com/mr-tron/base58"
-	"github.com/spf13/cobra"
-)
-
-const (
-	FullInfoFlag      = "full"
-	FullInfoFlagUsage = "Print full ShardInfo."
-)
-
-var locateObjectCmd = &cobra.Command{
-	Use:   "locate-object",
-	Short: "List shards storing the object",
-	Long:  "List shards storing the object",
-	Run:   locateObject,
-}
-
-func initControlLocateObjectCmd() {
-	initControlFlags(locateObjectCmd)
-
-	flags := locateObjectCmd.Flags()
-
-	flags.String(commonflags.CIDFlag, "", commonflags.CIDFlagUsage)
-	_ = locateObjectCmd.MarkFlagRequired(commonflags.CIDFlag)
-
-	flags.String(commonflags.OIDFlag, "", commonflags.OIDFlagUsage)
-	_ = locateObjectCmd.MarkFlagRequired(commonflags.OIDFlag)
-
-	flags.Bool(commonflags.JSON, false, "Print shard info as a JSON array. Requires --full flag.")
-	flags.Bool(FullInfoFlag, false, FullInfoFlagUsage)
-}
-
-func locateObject(cmd *cobra.Command, _ []string) {
-	var cnr cid.ID
-	var obj oid.ID
-
-	_ = object.ReadObjectAddress(cmd, &cnr, &obj)
-
-	pk := key.Get(cmd)
-
-	body := new(control.ListShardsForObjectRequest_Body)
-	body.SetContainerId(cnr.EncodeToString())
-	body.SetObjectId(obj.EncodeToString())
-	req := new(control.ListShardsForObjectRequest)
-	req.SetBody(body)
-	signRequest(cmd, pk, req)
-
-	cli := getClient(cmd, pk)
-
-	var err error
-	var resp *control.ListShardsForObjectResponse
-	err = cli.ExecRaw(func(client *rawclient.Client) error {
-		resp, err = control.ListShardsForObject(client, req)
-		return err
-	})
-	commonCmd.ExitOnErr(cmd, "rpc error: %w", err)
-
-	verifyResponse(cmd, resp.GetSignature(), resp.GetBody())
-
-	shardIDs := resp.GetBody().GetShard_ID()
-
-	isFull, _ := cmd.Flags().GetBool(FullInfoFlag)
-	if !isFull {
-		for _, id := range shardIDs {
-			cmd.Println(base58.Encode(id))
-		}
-		return
-	}
-
-	// get full shard info
-	listShardsReq := new(control.ListShardsRequest)
-	listShardsReq.SetBody(new(control.ListShardsRequest_Body))
-	signRequest(cmd, pk, listShardsReq)
-	var listShardsResp *control.ListShardsResponse
-	err = cli.ExecRaw(func(client *rawclient.Client) error {
-		listShardsResp, err = control.ListShards(client, listShardsReq)
-		return err
-	})
-	commonCmd.ExitOnErr(cmd, "rpc error: %w", err)
-
-	verifyResponse(cmd, listShardsResp.GetSignature(), listShardsResp.GetBody())
-
-	shards := listShardsResp.GetBody().GetShards()
-	sortShardsByID(shards)
-	shards = filterShards(shards, shardIDs)
-
-	isJSON, _ := cmd.Flags().GetBool(commonflags.JSON)
-	if isJSON {
-		prettyPrintShardsJSON(cmd, shards)
-	} else {
-		prettyPrintShards(cmd, shards)
-	}
-}
-
-func filterShards(info []control.ShardInfo, ids [][]byte) []control.ShardInfo {
-	var res []control.ShardInfo
-	for _, id := range ids {
-		for _, inf := range info {
-			if bytes.Equal(inf.Shard_ID, id) {
-				res = append(res, inf)
-			}
-		}
-	}
-	return res
-}

cmd/frostfs-cli/modules/control/root.go

@@ -39,7 +39,6 @@ func init() {
 		listRulesCmd,
 		getRuleCmd,
 		listTargetsCmd,
-		locateObjectCmd,
 	)
 
 	initControlHealthCheckCmd()
@@ -53,5 +52,4 @@ func init() {
 	initControlListRulesCmd()
 	initControGetRuleCmd()
 	initControlListTargetsCmd()
-	initControlLocateObjectCmd()
 }

cmd/frostfs-cli/modules/control/writecache.go

@@ -24,7 +24,7 @@ var writecacheShardCmd = &cobra.Command{
 var sealWritecacheShardCmd = &cobra.Command{
 	Use:   "seal",
 	Short: "Flush objects from write-cache and move write-cache to degraded read only mode.",
-	Long:  "Flush all the objects from the write-cache to the main storage and move the write-cache to the 'CLOSED' mode: write-cache will be empty and no objects will be put in it.",
+	Long:  "Flush all the objects from the write-cache to the main storage and move the write-cache to the degraded read only mode: write-cache will be empty and no objects will be put in it.",
 	Run:   sealWritecache,
 }
 

cmd/frostfs-cli/modules/netmap/nodeinfo.go

@@ -62,11 +62,11 @@ func prettyPrintNodeInfo(cmd *cobra.Command, i netmap.NodeInfo) {
 
 	cmd.Println("state:", stateWord)
 
-	for s := range i.NetworkEndpoints() {
+	netmap.IterateNetworkEndpoints(i, func(s string) {
 		cmd.Println("address:", s)
-	}
+	})
 
-	for key, value := range i.Attributes() {
+	i.IterateAttributes(func(key, value string) {
 		cmd.Printf("attribute: %s=%s\n", key, value)
-	}
+	})
 }

cmd/frostfs-cli/modules/object/delete.go

@@ -55,7 +55,7 @@ func deleteObject(cmd *cobra.Command, _ []string) {
 			commonCmd.ExitOnErr(cmd, "", fmt.Errorf("required flag \"%s\" not set", commonflags.OIDFlag))
 		}
 
-		objAddr = ReadObjectAddress(cmd, &cnr, &obj)
+		objAddr = readObjectAddress(cmd, &cnr, &obj)
 	}
 
 	pk := key.GetOrGenerate(cmd)

cmd/frostfs-cli/modules/object/get.go

@@ -46,7 +46,7 @@ func getObject(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
+	objAddr := readObjectAddress(cmd, &cnr, &obj)
 
 	filename := cmd.Flag(fileFlag).Value.String()
 	out, closer := createOutWriter(cmd, filename)

cmd/frostfs-cli/modules/object/hash.go

@@ -52,7 +52,7 @@ func getObjectHash(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
+	objAddr := readObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeList(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)

cmd/frostfs-cli/modules/object/head.go

@@ -47,7 +47,7 @@ func getObjectHeader(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
+	objAddr := readObjectAddress(cmd, &cnr, &obj)
 	pk := key.GetOrGenerate(cmd)
 
 	cli := internalclient.GetSDKClientByFlag(cmd, pk, commonflags.RPC)

cmd/frostfs-cli/modules/object/lock.go

@@ -18,7 +18,6 @@ import (
 	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 // object lock command.
@@ -79,7 +78,7 @@ var objectLockCmd = &cobra.Command{
 			ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 			defer cancel()
 
-			endpoint := viper.GetString(commonflags.RPC)
+			endpoint, _ := cmd.Flags().GetString(commonflags.RPC)
 
 			currEpoch, err := internalclient.GetCurrentEpoch(ctx, cmd, endpoint)
 			commonCmd.ExitOnErr(cmd, "Request current epoch: %w", err)

cmd/frostfs-cli/modules/object/nodes.go

@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"slices"
 	"sync"
 
 	internalclient "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/client"
@@ -49,12 +48,6 @@ type ecHeader struct {
 	parent oid.ID
 }
 
-type objectCounter struct {
-	sync.Mutex
-	total       uint32
-	isECcounted bool
-}
-
 type objectPlacement struct {
 	requiredNodes  []netmapSDK.NodeInfo
 	confirmedNodes []netmapSDK.NodeInfo
@@ -63,7 +56,6 @@ type objectPlacement struct {
 type objectNodesResult struct {
 	errors     []error
 	placements map[oid.ID]objectPlacement
-	total      uint32
 }
 
 type ObjNodesDataObject struct {
@@ -109,23 +101,23 @@ func initObjectNodesCmd() {
 func objectNodes(cmd *cobra.Command, _ []string) {
 	var cnrID cid.ID
 	var objID oid.ID
-	ReadObjectAddress(cmd, &cnrID, &objID)
+	readObjectAddress(cmd, &cnrID, &objID)
 
 	pk := key.GetOrGenerate(cmd)
 	cli := internalclient.GetSDKClientByFlag(cmd, pk, commonflags.RPC)
 
-	objects, count := getPhyObjects(cmd, cnrID, objID, cli, pk)
+	objects := getPhyObjects(cmd, cnrID, objID, cli, pk)
 
 	placementPolicy, netmap := getPlacementPolicyAndNetmap(cmd, cnrID, cli)
 
 	result := getRequiredPlacement(cmd, objects, placementPolicy, netmap)
 
-	getActualPlacement(cmd, netmap, pk, objects, count, result)
+	getActualPlacement(cmd, netmap, pk, objects, result)
 
 	printPlacement(cmd, objID, objects, result)
 }
 
-func getPhyObjects(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, pk *ecdsa.PrivateKey) ([]phyObject, int) {
+func getPhyObjects(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, pk *ecdsa.PrivateKey) []phyObject {
 	var addrObj oid.Address
 	addrObj.SetContainer(cnrID)
 	addrObj.SetObject(objID)
@@ -153,7 +145,7 @@ func getPhyObjects(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.C
 				parent: res.Header().ECHeader().Parent(),
 			}
 		}
-		return []phyObject{obj}, 1
+		return []phyObject{obj}
 	}
 
 	var errSplitInfo *objectSDK.SplitInfoError
@@ -163,34 +155,29 @@ func getPhyObjects(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.C
 
 	var ecInfoError *objectSDK.ECInfoError
 	if errors.As(err, &ecInfoError) {
-		return getECObjectChunks(cmd, cnrID, objID, ecInfoError), 1
+		return getECObjectChunks(cmd, cnrID, objID, ecInfoError)
 	}
 	commonCmd.ExitOnErr(cmd, "failed to get object info: %w", err)
-	return nil, 0
+	return nil
 }
 
-func getComplexObjectParts(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, prmHead internalclient.HeadObjectPrm, errSplitInfo *objectSDK.SplitInfoError) ([]phyObject, int) {
-	members, total := getCompexObjectMembers(cmd, cnrID, objID, cli, prmHead, errSplitInfo)
-	return flattenComplexMembersIfECContainer(cmd, cnrID, members, prmHead), total
+func getComplexObjectParts(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, prmHead internalclient.HeadObjectPrm, errSplitInfo *objectSDK.SplitInfoError) []phyObject {
+	members := getCompexObjectMembers(cmd, cnrID, objID, cli, prmHead, errSplitInfo)
+	return flattenComplexMembersIfECContainer(cmd, cnrID, members, prmHead)
 }
 
-func getCompexObjectMembers(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, prmHead internalclient.HeadObjectPrm, errSplitInfo *objectSDK.SplitInfoError) ([]oid.ID, int) {
-	var total int
+func getCompexObjectMembers(cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, prmHead internalclient.HeadObjectPrm, errSplitInfo *objectSDK.SplitInfoError) []oid.ID {
 	splitInfo := errSplitInfo.SplitInfo()
 
 	if members, ok := tryGetSplitMembersByLinkingObject(cmd, splitInfo, prmHead, cnrID); ok {
-		if total = len(members); total > 0 {
-			total-- // linking object is not data object
-		}
-		return members, total
+		return members
 	}
 
 	if members, ok := tryGetSplitMembersBySplitID(cmd, splitInfo, cli, cnrID); ok {
-		return members, len(members)
+		return members
 	}
 
-	members := tryRestoreChainInReverse(cmd, splitInfo, prmHead, cli, cnrID, objID)
-	return members, len(members)
+	return tryRestoreChainInReverse(cmd, splitInfo, prmHead, cli, cnrID, objID)
 }
 
 func flattenComplexMembersIfECContainer(cmd *cobra.Command, cnrID cid.ID, members []oid.ID, prmHead internalclient.HeadObjectPrm) []phyObject {
@@ -396,11 +383,8 @@ func getECRequiredPlacementInternal(cmd *cobra.Command, object phyObject, placem
 	}
 }
 
-func getActualPlacement(cmd *cobra.Command, netmap *netmapSDK.NetMap, pk *ecdsa.PrivateKey, objects []phyObject, count int, result *objectNodesResult) {
+func getActualPlacement(cmd *cobra.Command, netmap *netmapSDK.NetMap, pk *ecdsa.PrivateKey, objects []phyObject, result *objectNodesResult) {
 	resultMtx := &sync.Mutex{}
-	counter := &objectCounter{
-		total: uint32(count),
-	}
 
 	candidates := getNodesToCheckObjectExistance(cmd, netmap, result)
 
@@ -417,7 +401,7 @@ func getActualPlacement(cmd *cobra.Command, netmap *netmapSDK.NetMap, pk *ecdsa.
 
 			for _, object := range objects {
 				eg.Go(func() error {
-					stored, err := isObjectStoredOnNode(egCtx, cmd, object.containerID, object.objectID, cli, pk, counter)
+					stored, err := isObjectStoredOnNode(egCtx, cmd, object.containerID, object.objectID, cli, pk)
 					resultMtx.Lock()
 					defer resultMtx.Unlock()
 					if err == nil && stored {
@@ -436,7 +420,6 @@ func getActualPlacement(cmd *cobra.Command, netmap *netmapSDK.NetMap, pk *ecdsa.
 	}
 
 	commonCmd.ExitOnErr(cmd, "failed to get actual placement: %w", eg.Wait())
-	result.total = counter.total
 }
 
 func getNodesToCheckObjectExistance(cmd *cobra.Command, netmap *netmapSDK.NetMap, result *objectNodesResult) []netmapSDK.NodeInfo {
@@ -461,11 +444,17 @@ func createClient(ctx context.Context, cmd *cobra.Command, candidate netmapSDK.N
 	var cli *client.Client
 	var addresses []string
 	if preferInternal, _ := cmd.Flags().GetBool(preferInternalAddressesFlag); preferInternal {
-		addresses = slices.AppendSeq(addresses, candidate.NetworkEndpoints())
+		candidate.IterateNetworkEndpoints(func(s string) bool {
+			addresses = append(addresses, s)
+			return false
+		})
 		addresses = append(addresses, candidate.ExternalAddresses()...)
 	} else {
 		addresses = append(addresses, candidate.ExternalAddresses()...)
-		addresses = slices.AppendSeq(addresses, candidate.NetworkEndpoints())
+		candidate.IterateNetworkEndpoints(func(s string) bool {
+			addresses = append(addresses, s)
+			return false
+		})
 	}
 
 	var lastErr error
@@ -489,7 +478,7 @@ func createClient(ctx context.Context, cmd *cobra.Command, candidate netmapSDK.N
 	return cli, nil
 }
 
-func isObjectStoredOnNode(ctx context.Context, cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, pk *ecdsa.PrivateKey, counter *objectCounter) (bool, error) {
+func isObjectStoredOnNode(ctx context.Context, cmd *cobra.Command, cnrID cid.ID, objID oid.ID, cli *client.Client, pk *ecdsa.PrivateKey) (bool, error) {
 	var addrObj oid.Address
 	addrObj.SetContainer(cnrID)
 	addrObj.SetObject(objID)
@@ -504,14 +493,6 @@ func isObjectStoredOnNode(ctx context.Context, cmd *cobra.Command, cnrID cid.ID,
 
 	res, err := internalclient.HeadObject(ctx, prmHead)
 	if err == nil && res != nil {
-		if res.Header().ECHeader() != nil {
-			counter.Lock()
-			defer counter.Unlock()
-			if !counter.isECcounted {
-				counter.total *= res.Header().ECHeader().Total()
-			}
-			counter.isECcounted = true
-		}
 		return true, nil
 	}
 	var notFound *apistatus.ObjectNotFound
@@ -531,8 +512,7 @@ func printPlacement(cmd *cobra.Command, objID oid.ID, objects []phyObject, resul
 }
 
 func printObjectNodesAsText(cmd *cobra.Command, objID oid.ID, objects []phyObject, result *objectNodesResult) {
-	fmt.Fprintf(cmd.OutOrStdout(), "Object %s stores payload in %d data objects\n", objID.EncodeToString(), result.total)
-	fmt.Fprintf(cmd.OutOrStdout(), "Found %d:\n", len(objects))
+	fmt.Fprintf(cmd.OutOrStdout(), "Object %s stores payload in %d data objects:\n", objID.EncodeToString(), len(objects))
 
 	for _, object := range objects {
 		fmt.Fprintf(cmd.OutOrStdout(), "- %s\n", object.objectID)

cmd/frostfs-cli/modules/object/patch.go

@@ -2,7 +2,6 @@ package object
 
 import (
 	"fmt"
-	"os"
 	"strconv"
 	"strings"
 
@@ -10,7 +9,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/key"
 	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
-	objectV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/object"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
 	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
@@ -22,7 +20,6 @@ const (
 	replaceAttrsFlagName = "replace-attrs"
 	rangeFlagName        = "range"
 	payloadFlagName      = "payload"
-	splitHeaderFlagName  = "split-header"
 )
 
 var objectPatchCmd = &cobra.Command{
@@ -53,14 +50,13 @@ func initObjectPatchCmd() {
 	flags.Bool(replaceAttrsFlagName, false, "Replace object attributes by new ones.")
 	flags.StringSlice(rangeFlagName, []string{}, "Range to which patch payload is applied. Format: offset:length")
 	flags.StringSlice(payloadFlagName, []string{}, "Path to file with patch payload.")
-	flags.String(splitHeaderFlagName, "", "Path to binary or JSON-encoded split header")
 }
 
 func patch(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
+	objAddr := readObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeSlice(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)
@@ -88,8 +84,6 @@ func patch(cmd *cobra.Command, _ []string) {
 	prm.NewAttributes = newAttrs
 	prm.ReplaceAttribute = replaceAttrs
 
-	prm.NewSplitHeader = parseSplitHeaderBinaryOrJSON(cmd)
-
 	for i := range ranges {
 		prm.PayloadPatches = append(prm.PayloadPatches, internalclient.PayloadPatch{
 			Range:       ranges[i],
@@ -153,22 +147,3 @@ func patchPayloadPaths(cmd *cobra.Command) []string {
 	v, _ := cmd.Flags().GetStringSlice(payloadFlagName)
 	return v
 }
-
-func parseSplitHeaderBinaryOrJSON(cmd *cobra.Command) *objectSDK.SplitHeader {
-	path, _ := cmd.Flags().GetString(splitHeaderFlagName)
-	if path == "" {
-		return nil
-	}
-
-	data, err := os.ReadFile(path)
-	commonCmd.ExitOnErr(cmd, "read file error: %w", err)
-
-	splitHdrV2 := new(objectV2.SplitHeader)
-	err = splitHdrV2.Unmarshal(data)
-	if err != nil {
-		err = splitHdrV2.UnmarshalJSON(data)
-		commonCmd.ExitOnErr(cmd, "unmarshal error: %w", err)
-	}
-
-	return objectSDK.NewSplitHeaderFromV2(splitHdrV2)
-}

cmd/frostfs-cli/modules/object/range.go

@@ -47,7 +47,7 @@ func getObjectRange(cmd *cobra.Command, _ []string) {
 	var cnr cid.ID
 	var obj oid.ID
 
-	objAddr := ReadObjectAddress(cmd, &cnr, &obj)
+	objAddr := readObjectAddress(cmd, &cnr, &obj)
 
 	ranges, err := getRangeList(cmd)
 	commonCmd.ExitOnErr(cmd, "", err)
@@ -154,7 +154,7 @@ func printECInfoErr(cmd *cobra.Command, err error) bool {
 	if ok {
 		toJSON, _ := cmd.Flags().GetBool(commonflags.JSON)
 		toProto, _ := cmd.Flags().GetBool("proto")
-		if !toJSON && !toProto {
+		if !(toJSON || toProto) {
 			cmd.PrintErrln("Object is erasure-encoded, ec information received.")
 		}
 		printECInfo(cmd, errECInfo.ECInfo())

cmd/frostfs-cli/modules/object/util.go

@@ -74,7 +74,7 @@ func parseXHeaders(cmd *cobra.Command) []string {
 	return xs
 }
 
-func ReadObjectAddress(cmd *cobra.Command, cnr *cid.ID, obj *oid.ID) oid.Address {
+func readObjectAddress(cmd *cobra.Command, cnr *cid.ID, obj *oid.ID) oid.Address {
 	readCID(cmd, cnr)
 	readOID(cmd, obj)
 

cmd/frostfs-cli/modules/tree/client.go

@@ -2,19 +2,17 @@ package tree
 
 import (
 	"context"
-	"crypto/tls"
 	"fmt"
+	"strings"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/common"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/commonflags"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/network"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/services/tree"
 	tracing "git.frostfs.info/TrueCloudLab/frostfs-observability/tracing/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/rpc/client"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 )
 
@@ -33,29 +31,21 @@ func _client() (tree.TreeServiceClient, error) {
 		return nil, err
 	}
 
-	host, isTLS, err := client.ParseURI(netAddr.URIAddr())
-	if err != nil {
-		return nil, err
-	}
-
-	creds := insecure.NewCredentials()
-	if isTLS {
-		creds = credentials.NewTLS(&tls.Config{})
-	}
-
 	opts := []grpc.DialOption{
 		grpc.WithChainUnaryInterceptor(
-			tracing.NewUnaryClientInterceptor(),
+			tracing.NewUnaryClientInteceptor(),
 		),
 		grpc.WithChainStreamInterceptor(
 			tracing.NewStreamClientInterceptor(),
 		),
 		grpc.WithDefaultCallOptions(grpc.WaitForReady(true)),
-		grpc.WithDisableServiceConfig(),
-		grpc.WithTransportCredentials(creds),
 	}
 
-	cc, err := grpc.NewClient(host, opts...)
+	if !strings.HasPrefix(netAddr.URIAddr(), "grpcs:") {
+		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	}
+
+	cc, err := grpc.NewClient(netAddr.URIAddr(), opts...)
 	return tree.NewTreeServiceClient(cc), err
 }
 

cmd/frostfs-ir/config.go

@@ -4,14 +4,11 @@ import (
 	"context"
 	"os"
 	"os/signal"
-	"strconv"
 	"syscall"
 
 	configViper "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common/config"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
 	control "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/services/control/ir"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
-	"github.com/spf13/cast"
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
 )
@@ -41,33 +38,13 @@ func reloadConfig() error {
 	}
 	cmode.Store(cfg.GetBool("node.kludge_compatibility_mode"))
 	audit.Store(cfg.GetBool("audit.enabled"))
-	var logPrm logger.Prm
 	err = logPrm.SetLevelString(cfg.GetString("logger.level"))
 	if err != nil {
 		return err
 	}
-	err = logPrm.SetTags(loggerTags())
-	if err != nil {
-		return err
-	}
-	logger.UpdateLevelForTags(logPrm)
+	logPrm.PrependTimestamp = cfg.GetBool("logger.timestamp")
 
-	return nil
-}
-
-func loggerTags() [][]string {
-	var res [][]string
-	for i := 0; ; i++ {
-		var item []string
-		index := strconv.FormatInt(int64(i), 10)
-		names := cast.ToString(cfg.Get("logger.tags." + index + ".names"))
-		if names == "" {
-			break
-		}
-		item = append(item, names, cast.ToString(cfg.Get("logger.tags."+index+".level")))
-		res = append(res, item)
-	}
-	return res
+	return logPrm.Reload()
 }
 
 func watchForSignal(ctx context.Context, cancel func()) {

cmd/frostfs-ir/main.go

@@ -31,6 +31,7 @@ const (
 var (
 	wg         = new(sync.WaitGroup)
 	intErr     = make(chan error) // internal inner ring errors
+	logPrm     = new(logger.Prm)
 	innerRing  *innerring.Server
 	pprofCmp   *pprofComponent
 	metricsCmp *httpComponent
@@ -69,7 +70,6 @@ func main() {
 
 	metrics := irMetrics.NewInnerRingMetrics()
 
-	var logPrm logger.Prm
 	err = logPrm.SetLevelString(
 		cfg.GetString("logger.level"),
 	)
@@ -80,14 +80,10 @@ func main() {
 	exitErr(err)
 	logPrm.SamplingHook = metrics.LogMetrics().GetSamplingHook()
 	logPrm.PrependTimestamp = cfg.GetBool("logger.timestamp")
-	err = logPrm.SetTags(loggerTags())
-	exitErr(err)
 
 	log, err = logger.NewLogger(logPrm)
 	exitErr(err)
 
-	logger.UpdateLevelForTags(logPrm)
-
 	ctx, cancel := context.WithCancel(context.Background())
 
 	pprofCmp = newPprofComponent()

cmd/frostfs-lens/internal/meta/tui.go

@@ -2,17 +2,13 @@ package meta
 
 import (
 	"context"
-	"encoding/binary"
-	"errors"
 	"fmt"
 
 	common "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal"
-	schemaCommon "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	schema "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/metabase"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/tui"
 	"github.com/rivo/tview"
 	"github.com/spf13/cobra"
-	"go.etcd.io/bbolt"
 )
 
 var tuiCMD = &cobra.Command{
@@ -31,11 +27,6 @@ Available search filters:
 
 var initialPrompt string
 
-var parserPerSchemaVersion = map[uint64]schemaCommon.Parser{
-	2: schema.MetabaseParserV2,
-	3: schema.MetabaseParserV3,
-}
-
 func init() {
 	common.AddComponentPathFlag(tuiCMD, &vPath)
 
@@ -58,22 +49,12 @@ func runTUI(cmd *cobra.Command) error {
 	}
 	defer db.Close()
 
-	schemaVersion, hasVersion := lookupSchemaVersion(cmd, db)
-	if !hasVersion {
-		return errors.New("couldn't detect schema version")
-	}
-
-	metabaseParser, ok := parserPerSchemaVersion[schemaVersion]
-	if !ok {
-		return fmt.Errorf("unknown schema version %d", schemaVersion)
-	}
-
 	// Need if app was stopped with Ctrl-C.
 	ctx, cancel := context.WithCancel(cmd.Context())
 	defer cancel()
 
 	app := tview.NewApplication()
-	ui := tui.NewUI(ctx, app, db, metabaseParser, nil)
+	ui := tui.NewUI(ctx, app, db, schema.MetabaseParser, nil)
 
 	_ = ui.AddFilter("cid", tui.CIDParser, "CID")
 	_ = ui.AddFilter("oid", tui.OIDParser, "OID")
@@ -88,31 +69,3 @@ func runTUI(cmd *cobra.Command) error {
 	app.SetRoot(ui, true).SetFocus(ui)
 	return app.Run()
 }
-
-var (
-	shardInfoBucket = []byte{5}
-	versionRecord   = []byte("version")
-)
-
-func lookupSchemaVersion(cmd *cobra.Command, db *bbolt.DB) (version uint64, ok bool) {
-	err := db.View(func(tx *bbolt.Tx) error {
-		bkt := tx.Bucket(shardInfoBucket)
-		if bkt == nil {
-			return nil
-		}
-		rec := bkt.Get(versionRecord)
-		if rec == nil {
-			return nil
-		}
-
-		version = binary.LittleEndian.Uint64(rec)
-		ok = true
-
-		return nil
-	})
-	if err != nil {
-		common.ExitOnErr(cmd, fmt.Errorf("couldn't lookup version: %w", err))
-	}
-
-	return
-}

cmd/frostfs-lens/internal/schema/common/schema.go

@@ -3,8 +3,6 @@ package common
 import (
 	"errors"
 	"fmt"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 )
 
 type FilterResult byte
@@ -73,7 +71,11 @@ func (fp FallbackParser) ToParser() Parser {
 func (p Parser) ToFallbackParser() FallbackParser {
 	return func(key, value []byte) (SchemaEntry, Parser) {
 		entry, next, err := p(key, value)
-		assert.NoError(err, "couldn't use that parser as a fallback parser")
+		if err != nil {
+			panic(fmt.Errorf(
+				"couldn't use that parser as a fallback parser, it returned an error: %w", err,
+			))
+		}
 		return entry, next
 	}
 }

cmd/frostfs-lens/internal/schema/metabase/buckets/parsers.go

@@ -80,15 +80,10 @@ var (
 		},
 	)
 
-	UserAttributeParserV2 = NewUserAttributeKeyBucketParser(
+	UserAttributeParser = NewUserAttributeKeyBucketParser(
 		NewUserAttributeValueBucketParser(records.UserAttributeRecordParser),
 	)
 
-	UserAttributeParserV3 = NewUserAttributeKeyBucketParserWithSpecificKeys(
-		NewUserAttributeValueBucketParser(records.UserAttributeRecordParser),
-		[]string{"FilePath", "S3-Access-Box-CRDT-Name"},
-	)
-
 	PayloadHashParser = NewPrefixContainerBucketParser(PayloadHash, records.PayloadHashRecordParser, Resolvers{
 		cidResolver: StrictResolver,
 		oidResolver: StrictResolver,
@@ -113,14 +108,4 @@ var (
 		cidResolver: StrictResolver,
 		oidResolver: LenientResolver,
 	})
-
-	ExpirationEpochToObjectParser = NewPrefixBucketParser(ExpirationEpochToObject, records.ExpirationEpochToObjectRecordParser, Resolvers{
-		cidResolver: LenientResolver,
-		oidResolver: LenientResolver,
-	})
-
-	ObjectToExpirationEpochParser = NewPrefixContainerBucketParser(ObjectToExpirationEpoch, records.ObjectToExpirationEpochRecordParser, Resolvers{
-		cidResolver: StrictResolver,
-		oidResolver: LenientResolver,
-	})
 )

cmd/frostfs-lens/internal/schema/metabase/buckets/prefix.go

@@ -22,31 +22,27 @@ const (
 	Split
 	ContainerCounters
 	ECInfo
-	ExpirationEpochToObject
-	ObjectToExpirationEpoch
 )
 
 var x = map[Prefix]string{
-	Graveyard:               "Graveyard",
-	Garbage:                 "Garbage",
-	ToMoveIt:                "To Move It",
-	ContainerVolume:         "Container Volume",
-	Locked:                  "Locked",
-	ShardInfo:               "Shard Info",
-	Primary:                 "Primary",
-	Lockers:                 "Lockers",
-	Tombstone:               "Tombstone",
-	Small:                   "Small",
-	Root:                    "Root",
-	Owner:                   "Owner",
-	UserAttribute:           "User Attribute",
-	PayloadHash:             "Payload Hash",
-	Parent:                  "Parent",
-	Split:                   "Split",
-	ContainerCounters:       "Container Counters",
-	ECInfo:                  "EC Info",
-	ExpirationEpochToObject: "Exp. Epoch to Object",
-	ObjectToExpirationEpoch: "Object to Exp. Epoch",
+	Graveyard:         "Graveyard",
+	Garbage:           "Garbage",
+	ToMoveIt:          "To Move It",
+	ContainerVolume:   "Container Volume",
+	Locked:            "Locked",
+	ShardInfo:         "Shard Info",
+	Primary:           "Primary",
+	Lockers:           "Lockers",
+	Tombstone:         "Tombstone",
+	Small:             "Small",
+	Root:              "Root",
+	Owner:             "Owner",
+	UserAttribute:     "User Attribute",
+	PayloadHash:       "Payload Hash",
+	Parent:            "Parent",
+	Split:             "Split",
+	ContainerCounters: "Container Counters",
+	ECInfo:            "EC Info",
 }
 
 func (p Prefix) String() string {

cmd/frostfs-lens/internal/schema/metabase/buckets/string.go

@@ -9,7 +9,7 @@ import (
 
 func (b *PrefixBucket) String() string {
 	return common.FormatSimple(
-		fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
+		fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
 	)
 }
 
@@ -17,7 +17,7 @@ func (b *PrefixContainerBucket) String() string {
 	return fmt.Sprintf(
 		"%s CID %s",
 		common.FormatSimple(
-			fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
+			fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
 		),
 		common.FormatSimple(b.id.String(), tcell.ColorAqua),
 	)
@@ -34,7 +34,7 @@ func (b *ContainerBucket) String() string {
 func (b *UserAttributeKeyBucket) String() string {
 	return fmt.Sprintf("%s CID %s ATTR-KEY %s",
 		common.FormatSimple(
-			fmt.Sprintf("(%2d %-20s)", b.prefix, b.prefix), tcell.ColorLime,
+			fmt.Sprintf("(%2d %-18s)", b.prefix, b.prefix), tcell.ColorLime,
 		),
 		common.FormatSimple(
 			fmt.Sprintf("%-44s", b.id), tcell.ColorAqua,

cmd/frostfs-lens/internal/schema/metabase/buckets/types.go

@@ -2,7 +2,6 @@ package buckets
 
 import (
 	"errors"
-	"slices"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
@@ -58,11 +57,10 @@ var (
 )
 
 var (
-	ErrNotBucket              = errors.New("not a bucket")
-	ErrInvalidKeyLength       = errors.New("invalid key length")
-	ErrInvalidValueLength     = errors.New("invalid value length")
-	ErrInvalidPrefix          = errors.New("invalid prefix")
-	ErrUnexpectedAttributeKey = errors.New("unexpected attribute key")
+	ErrNotBucket          = errors.New("not a bucket")
+	ErrInvalidKeyLength   = errors.New("invalid key length")
+	ErrInvalidValueLength = errors.New("invalid value length")
+	ErrInvalidPrefix      = errors.New("invalid prefix")
 )
 
 func NewPrefixBucketParser(prefix Prefix, next common.Parser, resolvers Resolvers) common.Parser {
@@ -134,10 +132,6 @@ func NewContainerBucketParser(next common.Parser, resolvers Resolvers) common.Pa
 }
 
 func NewUserAttributeKeyBucketParser(next common.Parser) common.Parser {
-	return NewUserAttributeKeyBucketParserWithSpecificKeys(next, nil)
-}
-
-func NewUserAttributeKeyBucketParserWithSpecificKeys(next common.Parser, keys []string) common.Parser {
 	return func(key, value []byte) (common.SchemaEntry, common.Parser, error) {
 		if value != nil {
 			return nil, nil, ErrNotBucket
@@ -153,11 +147,6 @@ func NewUserAttributeKeyBucketParserWithSpecificKeys(next common.Parser, keys []
 			return nil, nil, err
 		}
 		b.key = string(key[33:])
-
-		if len(keys) != 0 && !slices.Contains(keys, b.key) {
-			return nil, nil, ErrUnexpectedAttributeKey
-		}
-
 		return &b, next, nil
 	}
 }

cmd/frostfs-lens/internal/schema/metabase/parser.go

@@ -5,30 +5,7 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/metabase/buckets"
 )
 
-var MetabaseParserV3 = common.WithFallback(
-	common.Any(
-		buckets.GraveyardParser,
-		buckets.GarbageParser,
-		buckets.ContainerVolumeParser,
-		buckets.LockedParser,
-		buckets.ShardInfoParser,
-		buckets.PrimaryParser,
-		buckets.LockersParser,
-		buckets.TombstoneParser,
-		buckets.SmallParser,
-		buckets.RootParser,
-		buckets.UserAttributeParserV3,
-		buckets.ParentParser,
-		buckets.SplitParser,
-		buckets.ContainerCountersParser,
-		buckets.ECInfoParser,
-		buckets.ExpirationEpochToObjectParser,
-		buckets.ObjectToExpirationEpochParser,
-	),
-	common.RawParser.ToFallbackParser(),
-)
-
-var MetabaseParserV2 = common.WithFallback(
+var MetabaseParser = common.WithFallback(
 	common.Any(
 		buckets.GraveyardParser,
 		buckets.GarbageParser,
@@ -41,7 +18,7 @@ var MetabaseParserV2 = common.WithFallback(
 		buckets.SmallParser,
 		buckets.RootParser,
 		buckets.OwnerParser,
-		buckets.UserAttributeParserV2,
+		buckets.UserAttributeParser,
 		buckets.PayloadHashParser,
 		buckets.ParentParser,
 		buckets.SplitParser,

cmd/frostfs-lens/internal/schema/metabase/records/detailed.go

@@ -63,11 +63,3 @@ func (r *ContainerCountersRecord) DetailedString() string {
 func (r *ECInfoRecord) DetailedString() string {
 	return spew.Sdump(*r)
 }
-
-func (r *ExpirationEpochToObjectRecord) DetailedString() string {
-	return spew.Sdump(*r)
-}
-
-func (r *ObjectToExpirationEpochRecord) DetailedString() string {
-	return spew.Sdump(*r)
-}

cmd/frostfs-lens/internal/schema/metabase/records/filter.go

@@ -143,26 +143,3 @@ func (r *ECInfoRecord) Filter(typ string, val any) common.FilterResult {
 		return common.No
 	}
 }
-
-func (r *ExpirationEpochToObjectRecord) Filter(typ string, val any) common.FilterResult {
-	switch typ {
-	case "cid":
-		id := val.(cid.ID)
-		return common.IfThenElse(r.cnt.Equals(id), common.Yes, common.No)
-	case "oid":
-		id := val.(oid.ID)
-		return common.IfThenElse(r.obj.Equals(id), common.Yes, common.No)
-	default:
-		return common.No
-	}
-}
-
-func (r *ObjectToExpirationEpochRecord) Filter(typ string, val any) common.FilterResult {
-	switch typ {
-	case "oid":
-		id := val.(oid.ID)
-		return common.IfThenElse(r.obj.Equals(id), common.Yes, common.No)
-	default:
-		return common.No
-	}
-}

cmd/frostfs-lens/internal/schema/metabase/records/parsers.go

@@ -249,45 +249,3 @@ func ECInfoRecordParser(key, value []byte) (common.SchemaEntry, common.Parser, e
 	}
 	return &r, nil, nil
 }
-
-func ExpirationEpochToObjectRecordParser(key, _ []byte) (common.SchemaEntry, common.Parser, error) {
-	if len(key) != 72 {
-		return nil, nil, ErrInvalidKeyLength
-	}
-
-	var (
-		r   ExpirationEpochToObjectRecord
-		err error
-	)
-
-	r.epoch = binary.BigEndian.Uint64(key[:8])
-	if err = r.cnt.Decode(key[8:40]); err != nil {
-		return nil, nil, err
-	}
-	if err = r.obj.Decode(key[40:]); err != nil {
-		return nil, nil, err
-	}
-
-	return &r, nil, nil
-}
-
-func ObjectToExpirationEpochRecordParser(key, value []byte) (common.SchemaEntry, common.Parser, error) {
-	if len(key) != 32 {
-		return nil, nil, ErrInvalidKeyLength
-	}
-	if len(value) != 8 {
-		return nil, nil, ErrInvalidValueLength
-	}
-
-	var (
-		r   ObjectToExpirationEpochRecord
-		err error
-	)
-
-	if err = r.obj.Decode(key); err != nil {
-		return nil, nil, err
-	}
-	r.epoch = binary.LittleEndian.Uint64(value)
-
-	return &r, nil, nil
-}

cmd/frostfs-lens/internal/schema/metabase/records/string.go

@@ -2,7 +2,6 @@ package records
 
 import (
 	"fmt"
-	"strconv"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
 	"github.com/gdamore/tcell/v2"
@@ -134,22 +133,3 @@ func (r *ECInfoRecord) String() string {
 		len(r.ids),
 	)
 }
-
-func (r *ExpirationEpochToObjectRecord) String() string {
-	return fmt.Sprintf(
-		"exp. epoch %s %c CID %s OID %s",
-		common.FormatSimple(fmt.Sprintf("%-20d", r.epoch), tcell.ColorAqua),
-		tview.Borders.Vertical,
-		common.FormatSimple(fmt.Sprintf("%-44s", r.cnt), tcell.ColorAqua),
-		common.FormatSimple(fmt.Sprintf("%-44s", r.obj), tcell.ColorAqua),
-	)
-}
-
-func (r *ObjectToExpirationEpochRecord) String() string {
-	return fmt.Sprintf(
-		"OID %s %c exp. epoch %s",
-		common.FormatSimple(fmt.Sprintf("%-44s", r.obj), tcell.ColorAqua),
-		tview.Borders.Vertical,
-		common.FormatSimple(strconv.FormatUint(r.epoch, 10), tcell.ColorAqua),
-	)
-}

cmd/frostfs-lens/internal/schema/metabase/records/types.go

@@ -79,15 +79,4 @@ type (
 		id  oid.ID
 		ids []oid.ID
 	}
-
-	ExpirationEpochToObjectRecord struct {
-		epoch uint64
-		cnt   cid.ID
-		obj   oid.ID
-	}
-
-	ObjectToExpirationEpochRecord struct {
-		obj   oid.ID
-		epoch uint64
-	}
 )

cmd/frostfs-lens/internal/tui/input.go

@@ -1,8 +1,6 @@
 package tui
 
 import (
-	"slices"
-
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
@@ -28,7 +26,7 @@ func (f *InputFieldWithHistory) AddToHistory(s string) {
 
 	// Used history data for search prompt, so just make that data recent.
 	if f.historyPointer != len(f.history) && s == f.history[f.historyPointer] {
-		f.history = slices.Delete(f.history, f.historyPointer, f.historyPointer+1)
+		f.history = append(f.history[:f.historyPointer], f.history[f.historyPointer+1:]...)
 		f.history = append(f.history, s)
 	}
 
@@ -53,17 +51,17 @@ func (f *InputFieldWithHistory) InputHandler() func(event *tcell.EventKey, setFo
 			f.historyPointer++
 			// Stop iterating over history.
 			if f.historyPointer == len(f.history) {
-				f.SetText(f.currentContent)
+				f.InputField.SetText(f.currentContent)
 				return
 			}
-			f.SetText(f.history[f.historyPointer])
+			f.InputField.SetText(f.history[f.historyPointer])
 		case tcell.KeyUp:
 			if len(f.history) == 0 {
 				return
 			}
 			// Start iterating over history.
 			if f.historyPointer == len(f.history) {
-				f.currentContent = f.GetText()
+				f.currentContent = f.InputField.GetText()
 			}
 			// End of history.
 			if f.historyPointer == 0 {
@@ -71,7 +69,7 @@ func (f *InputFieldWithHistory) InputHandler() func(event *tcell.EventKey, setFo
 			}
 			// Iterate to least recent prompts.
 			f.historyPointer--
-			f.SetText(f.history[f.historyPointer])
+			f.InputField.SetText(f.history[f.historyPointer])
 		default:
 			f.InputField.InputHandler()(event, func(tview.Primitive) {})
 		}

cmd/frostfs-lens/internal/tui/records.go

@@ -8,7 +8,6 @@ import (
 	"sync"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-lens/internal/schema/common"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/assert"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
@@ -95,7 +94,9 @@ func (v *RecordsView) Mount(ctx context.Context) error {
 }
 
 func (v *RecordsView) Unmount() {
-	assert.False(v.onUnmount == nil, "try to unmount not mounted component")
+	if v.onUnmount == nil {
+		panic("try to unmount not mounted component")
+	}
 	v.onUnmount()
 	v.onUnmount = nil
 }

cmd/frostfs-lens/internal/tui/ui.go

@@ -482,7 +482,7 @@ func (ui *UI) handleInputOnSearching(event *tcell.EventKey) {
 		ui.searchBar.InputHandler()(event, func(tview.Primitive) {})
 	}
 
-	ui.MouseHandler()
+	ui.Box.MouseHandler()
 }
 
 func (ui *UI) WithPrompt(prompt string) error {

cmd/frostfs-node/apemanager.go

@@ -14,7 +14,7 @@ import (
 func initAPEManagerService(c *cfg) {
 	contractStorage := ape_contract.NewProxyVerificationContractStorage(
 		morph.NewSwitchRPCGuardedActor(c.cfgMorph.client),
-		c.key,
+		c.shared.key,
 		c.cfgMorph.proxyScriptHash,
 		c.cfgObject.cfgAccessPolicyEngine.policyContractHash)
 

cmd/frostfs-node/cache.go

@@ -1,27 +1,20 @@
 package main
 
 import (
-	"bytes"
-	"cmp"
 	"context"
-	"slices"
 	"sync"
-	"sync/atomic"
 	"time"
 
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/metrics"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/container"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap"
 	objectwriter "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/services/object/common/writer"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
 	utilSync "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/sync"
 	apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status"
 	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
 	netmapSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/hashicorp/golang-lru/v2/expirable"
-	"github.com/hashicorp/golang-lru/v2/simplelru"
-	"go.uber.org/zap"
 )
 
 type netValueReader[K any, V any] func(ctx context.Context, cid K) (V, error)
@@ -117,6 +110,55 @@ func (c *ttlNetCache[K, V]) remove(key K) {
 	hit = c.cache.Remove(key)
 }
 
+// entity that provides LRU cache interface.
+type lruNetCache struct {
+	cache *lru.Cache[uint64, *netmapSDK.NetMap]
+
+	netRdr netValueReader[uint64, *netmapSDK.NetMap]
+
+	metrics cacheMetrics
+}
+
+// newNetworkLRUCache returns wrapper over netValueReader with LRU cache.
+func newNetworkLRUCache(sz int, netRdr netValueReader[uint64, *netmapSDK.NetMap], metrics cacheMetrics) *lruNetCache {
+	cache, err := lru.New[uint64, *netmapSDK.NetMap](sz)
+	fatalOnErr(err)
+
+	return &lruNetCache{
+		cache:   cache,
+		netRdr:  netRdr,
+		metrics: metrics,
+	}
+}
+
+// reads value by the key.
+//
+// updates the value from the network on cache miss.
+//
+// returned value should not be modified.
+func (c *lruNetCache) get(ctx context.Context, key uint64) (*netmapSDK.NetMap, error) {
+	hit := false
+	startedAt := time.Now()
+	defer func() {
+		c.metrics.AddMethodDuration("Get", time.Since(startedAt), hit)
+	}()
+
+	val, ok := c.cache.Get(key)
+	if ok {
+		hit = true
+		return val, nil
+	}
+
+	val, err := c.netRdr(ctx, key)
+	if err != nil {
+		return nil, err
+	}
+
+	c.cache.Add(key, val)
+
+	return val, nil
+}
+
 // wrapper over TTL cache of values read from the network
 // that implements container storage.
 type ttlContainerStorage struct {
@@ -158,222 +200,20 @@ func (s ttlContainerStorage) DeletionInfo(ctx context.Context, cnr cid.ID) (*con
 type lruNetmapSource struct {
 	netState netmap.State
 
-	client     rawSource
-	cache      *simplelru.LRU[uint64, *atomic.Pointer[netmapSDK.NetMap]]
-	mtx        sync.RWMutex
-	metrics    cacheMetrics
-	log        *logger.Logger
-	candidates atomic.Pointer[[]netmapSDK.NodeInfo]
+	cache *lruNetCache
 }
 
-type rawSource interface {
-	GetCandidates(ctx context.Context) ([]netmapSDK.NodeInfo, error)
-	GetNetMapByEpoch(ctx context.Context, epoch uint64) (*netmapSDK.NetMap, error)
-}
-
-func newCachedNetmapStorage(ctx context.Context, log *logger.Logger,
-	netState netmap.State, client rawSource, wg *sync.WaitGroup, d time.Duration,
-) netmap.Source {
+func newCachedNetmapStorage(s netmap.State, v netmap.Source) netmap.Source {
 	const netmapCacheSize = 10
 
-	cache, err := simplelru.NewLRU[uint64, *atomic.Pointer[netmapSDK.NetMap]](netmapCacheSize, nil)
-	fatalOnErr(err)
+	lruNetmapCache := newNetworkLRUCache(netmapCacheSize, func(ctx context.Context, key uint64) (*netmapSDK.NetMap, error) {
+		return v.GetNetMapByEpoch(ctx, key)
+	}, metrics.NewCacheMetrics("netmap"))
 
-	src := &lruNetmapSource{
-		netState: netState,
-		client:   client,
-		cache:    cache,
-		log:      log,
-		metrics:  metrics.NewCacheMetrics("netmap"),
+	return &lruNetmapSource{
+		netState: s,
+		cache:    lruNetmapCache,
 	}
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		src.updateCandidates(ctx, d)
-	}()
-
-	return src
-}
-
-// updateCandidates routine to merge netmap in cache with candidates list.
-func (s *lruNetmapSource) updateCandidates(ctx context.Context, d time.Duration) {
-	timer := time.NewTimer(d)
-	defer timer.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-timer.C:
-			newCandidates, err := s.client.GetCandidates(ctx)
-			if err != nil {
-				s.log.Debug(ctx, logs.FailedToUpdateNetmapCandidates, zap.Error(err))
-				timer.Reset(d)
-				break
-			}
-			if len(newCandidates) == 0 {
-				s.candidates.Store(&newCandidates)
-				timer.Reset(d)
-				break
-			}
-			slices.SortFunc(newCandidates, func(n1 netmapSDK.NodeInfo, n2 netmapSDK.NodeInfo) int {
-				return cmp.Compare(n1.Hash(), n2.Hash())
-			})
-
-			// Check once state changed
-			v := s.candidates.Load()
-			if v == nil {
-				s.candidates.Store(&newCandidates)
-				s.mergeCacheWithCandidates(newCandidates)
-				timer.Reset(d)
-				break
-			}
-			ret := slices.CompareFunc(*v, newCandidates, func(n1 netmapSDK.NodeInfo, n2 netmapSDK.NodeInfo) int {
-				if !bytes.Equal(n1.PublicKey(), n2.PublicKey()) ||
-					uint32(n1.Status()) != uint32(n2.Status()) ||
-					slices.Compare(n1.ExternalAddresses(), n2.ExternalAddresses()) != 0 {
-					return 1
-				}
-				ne1 := slices.Collect(n1.NetworkEndpoints())
-				ne2 := slices.Collect(n2.NetworkEndpoints())
-				return slices.Compare(ne1, ne2)
-			})
-			if ret != 0 {
-				s.candidates.Store(&newCandidates)
-				s.mergeCacheWithCandidates(newCandidates)
-			}
-			timer.Reset(d)
-		}
-	}
-}
-
-func (s *lruNetmapSource) mergeCacheWithCandidates(candidates []netmapSDK.NodeInfo) {
-	s.mtx.Lock()
-	tmp := s.cache.Values()
-	s.mtx.Unlock()
-	for _, pointer := range tmp {
-		nm := pointer.Load()
-		updates := getNetMapNodesToUpdate(nm, candidates)
-		if len(updates) > 0 {
-			nm = nm.Clone()
-			mergeNetmapWithCandidates(updates, nm)
-			pointer.Store(nm)
-		}
-	}
-}
-
-// reads value by the key.
-//
-// updates the value from the network on cache miss.
-//
-// returned value should not be modified.
-func (s *lruNetmapSource) get(ctx context.Context, key uint64) (*netmapSDK.NetMap, error) {
-	hit := false
-	startedAt := time.Now()
-	defer func() {
-		s.metrics.AddMethodDuration("Get", time.Since(startedAt), hit)
-	}()
-
-	s.mtx.RLock()
-	val, ok := s.cache.Get(key)
-	s.mtx.RUnlock()
-	if ok {
-		hit = true
-		return val.Load(), nil
-	}
-
-	s.mtx.Lock()
-	defer s.mtx.Unlock()
-
-	val, ok = s.cache.Get(key)
-	if ok {
-		hit = true
-		return val.Load(), nil
-	}
-
-	nm, err := s.client.GetNetMapByEpoch(ctx, key)
-	if err != nil {
-		return nil, err
-	}
-	v := s.candidates.Load()
-	if v != nil {
-		updates := getNetMapNodesToUpdate(nm, *v)
-		if len(updates) > 0 {
-			mergeNetmapWithCandidates(updates, nm)
-		}
-	}
-
-	p := atomic.Pointer[netmapSDK.NetMap]{}
-	p.Store(nm)
-	s.cache.Add(key, &p)
-
-	return nm, nil
-}
-
-// mergeNetmapWithCandidates updates nodes state in the provided netmap with state in the list of candidates.
-func mergeNetmapWithCandidates(updates []nodeToUpdate, nm *netmapSDK.NetMap) {
-	for _, v := range updates {
-		if v.status != netmapSDK.UnspecifiedState {
-			nm.Nodes()[v.netmapIndex].SetStatus(v.status)
-		}
-		if v.externalAddresses != nil {
-			nm.Nodes()[v.netmapIndex].SetExternalAddresses(v.externalAddresses...)
-		}
-		if v.endpoints != nil {
-			nm.Nodes()[v.netmapIndex].SetNetworkEndpoints(v.endpoints...)
-		}
-	}
-}
-
-type nodeToUpdate struct {
-	netmapIndex       int
-	status            netmapSDK.NodeState
-	externalAddresses []string
-	endpoints         []string
-}
-
-// getNetMapNodesToUpdate checks for the changes between provided netmap and the list of candidates.
-func getNetMapNodesToUpdate(nm *netmapSDK.NetMap, candidates []netmapSDK.NodeInfo) []nodeToUpdate {
-	var res []nodeToUpdate
-	for i := range nm.Nodes() {
-		for _, cnd := range candidates {
-			if bytes.Equal(nm.Nodes()[i].PublicKey(), cnd.PublicKey()) {
-				var tmp nodeToUpdate
-				var update bool
-
-				if cnd.Status() != nm.Nodes()[i].Status() &&
-					(cnd.Status() == netmapSDK.Online || cnd.Status() == netmapSDK.Maintenance) {
-					update = true
-					tmp.status = cnd.Status()
-				}
-
-				externalAddresses := cnd.ExternalAddresses()
-				if externalAddresses != nil &&
-					slices.Compare(externalAddresses, nm.Nodes()[i].ExternalAddresses()) != 0 {
-					update = true
-					tmp.externalAddresses = externalAddresses
-				}
-
-				nodeEndpoints := make([]string, 0, nm.Nodes()[i].NumberOfNetworkEndpoints())
-				nodeEndpoints = slices.AppendSeq(nodeEndpoints, nm.Nodes()[i].NetworkEndpoints())
-				candidateEndpoints := make([]string, 0, cnd.NumberOfNetworkEndpoints())
-				candidateEndpoints = slices.AppendSeq(candidateEndpoints, cnd.NetworkEndpoints())
-				if slices.Compare(nodeEndpoints, candidateEndpoints) != 0 {
-					update = true
-					tmp.endpoints = candidateEndpoints
-				}
-
-				if update {
-					tmp.netmapIndex = i
-					res = append(res, tmp)
-				}
-
-				break
-			}
-		}
-	}
-	return res
 }
 
 func (s *lruNetmapSource) GetNetMap(ctx context.Context, diff uint64) (*netmapSDK.NetMap, error) {
@@ -385,7 +225,7 @@ func (s *lruNetmapSource) GetNetMapByEpoch(ctx context.Context, epoch uint64) (*
 }
 
 func (s *lruNetmapSource) getNetMapByEpoch(ctx context.Context, epoch uint64) (*netmapSDK.NetMap, error) {
-	val, err := s.get(ctx, epoch)
+	val, err := s.cache.get(ctx, epoch)
 	if err != nil {
 		return nil, err
 	}

cmd/frostfs-node/cache_test.go

@@ -3,11 +3,9 @@ package main
 import (
 	"context"
 	"errors"
-	"sync"
 	"testing"
 	"time"
 
-	netmapSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
 	"github.com/stretchr/testify/require"
 )
 
@@ -61,75 +59,3 @@ func testNetValueReader(_ context.Context, key string) (time.Time, error) {
 type noopCacheMetricts struct{}
 
 func (m *noopCacheMetricts) AddMethodDuration(method string, d time.Duration, hit bool) {}
-
-type rawSrc struct{}
-
-func (r *rawSrc) GetCandidates(_ context.Context) ([]netmapSDK.NodeInfo, error) {
-	node0 := netmapSDK.NodeInfo{}
-	node0.SetPublicKey([]byte{byte(1)})
-	node0.SetStatus(netmapSDK.Online)
-	node0.SetExternalAddresses("1", "0")
-	node0.SetNetworkEndpoints("1", "0")
-
-	node1 := netmapSDK.NodeInfo{}
-	node1.SetPublicKey([]byte{byte(1)})
-	node1.SetStatus(netmapSDK.Online)
-	node1.SetExternalAddresses("1", "0")
-	node1.SetNetworkEndpoints("1", "0")
-
-	return []netmapSDK.NodeInfo{node0, node1}, nil
-}
-
-func (r *rawSrc) GetNetMapByEpoch(ctx context.Context, epoch uint64) (*netmapSDK.NetMap, error) {
-	nm := netmapSDK.NetMap{}
-	nm.SetEpoch(1)
-
-	node0 := netmapSDK.NodeInfo{}
-	node0.SetPublicKey([]byte{byte(1)})
-	node0.SetStatus(netmapSDK.Maintenance)
-	node0.SetExternalAddresses("0")
-	node0.SetNetworkEndpoints("0")
-
-	node1 := netmapSDK.NodeInfo{}
-	node1.SetPublicKey([]byte{byte(1)})
-	node1.SetStatus(netmapSDK.Maintenance)
-	node1.SetExternalAddresses("0")
-	node1.SetNetworkEndpoints("0")
-
-	nm.SetNodes([]netmapSDK.NodeInfo{node0, node1})
-
-	return &nm, nil
-}
-
-type st struct{}
-
-func (s *st) CurrentEpoch() uint64 {
-	return 1
-}
-
-func TestNetmapStorage(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	wg := sync.WaitGroup{}
-	cache := newCachedNetmapStorage(ctx, nil, &st{}, &rawSrc{}, &wg, time.Millisecond*50)
-
-	nm, err := cache.GetNetMapByEpoch(ctx, 1)
-	require.NoError(t, err)
-	require.True(t, nm.Nodes()[0].Status() == netmapSDK.Maintenance)
-	require.True(t, len(nm.Nodes()[0].ExternalAddresses()) == 1)
-	require.True(t, nm.Nodes()[0].NumberOfNetworkEndpoints() == 1)
-
-	require.Eventually(t, func() bool {
-		nm, err := cache.GetNetMapByEpoch(ctx, 1)
-		require.NoError(t, err)
-		for _, node := range nm.Nodes() {
-			if !(node.Status() == netmapSDK.Online && len(node.ExternalAddresses()) == 2 &&
-				node.NumberOfNetworkEndpoints() == 2) {
-				return false
-			}
-		}
-		return true
-	}, time.Second*5, time.Millisecond*10)
-
-	cancel()
-	wg.Wait()
-}

cmd/frostfs-node/config.go

@@ -33,14 +33,12 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/metrics"
 	internalNet "git.frostfs.info/TrueCloudLab/frostfs-node/internal/net"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/ape/chainbase"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/container"
 	frostfsidcore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/frostfsid"
 	netmapCore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/blobovniczatree"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/compression"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/fstree"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/engine"
 	meta "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/metabase"
@@ -71,7 +69,6 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/state"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/logging/lokicore"
 	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
-	"git.frostfs.info/TrueCloudLab/frostfs-qos/limiting"
 	netmapV2 "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/api/netmap"
 	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
 	objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
@@ -109,8 +106,6 @@ type applicationConfiguration struct {
 		level       string
 		destination string
 		timestamp   bool
-		options     []zap.Option
-		tags        [][]string
 	}
 
 	ObjectCfg struct {
@@ -120,6 +115,7 @@ type applicationConfiguration struct {
 
 	EngineCfg struct {
 		errorThreshold uint32
+		shardPoolSize  uint32
 		shards         []shardCfg
 		lowMem         bool
 	}
@@ -129,13 +125,15 @@ type applicationConfiguration struct {
 }
 
 type shardCfg struct {
-	compression compression.Config
+	compress                         bool
+	estimateCompressibility          bool
+	estimateCompressibilityThreshold float64
 
 	smallSizeObjectLimit       uint64
+	uncompressableContentType  []string
 	refillMetabase             bool
 	refillMetabaseWorkersCount int
 	mode                       shardmode.Mode
-	limiter                    qos.Limiter
 
 	metaCfg struct {
 		path          string
@@ -232,71 +230,62 @@ func (a *applicationConfiguration) readConfig(c *config.Config) error {
 	a.LoggerCfg.level = loggerconfig.Level(c)
 	a.LoggerCfg.destination = loggerconfig.Destination(c)
 	a.LoggerCfg.timestamp = loggerconfig.Timestamp(c)
-	var opts []zap.Option
-	if loggerconfig.ToLokiConfig(c).Enabled {
-		opts = []zap.Option{zap.WrapCore(func(core zapcore.Core) zapcore.Core {
-			lokiCore := lokicore.New(core, loggerconfig.ToLokiConfig(c))
-			return lokiCore
-		})}
-	}
-	a.LoggerCfg.options = opts
-	a.LoggerCfg.tags = loggerconfig.Tags(c)
 
 	// Object
 
 	a.ObjectCfg.tombstoneLifetime = objectconfig.TombstoneLifetime(c)
-	locodeDBPath := nodeconfig.LocodeDBPath(c)
-	parser, err := placement.NewMetricsParser(locodeDBPath)
-	if err != nil {
-		return fmt.Errorf("metrics parser creation: %w", err)
+	var pm []placement.Metric
+	for _, raw := range objectconfig.Get(c).Priority() {
+		m, err := placement.ParseMetric(raw)
+		if err != nil {
+			return err
+		}
+		pm = append(pm, m)
 	}
-	m, err := parser.ParseMetrics(objectconfig.Get(c).Priority())
-	if err != nil {
-		return fmt.Errorf("parse metrics: %w", err)
-	}
-	a.ObjectCfg.priorityMetrics = m
+	a.ObjectCfg.priorityMetrics = pm
 
 	// Storage Engine
 
 	a.EngineCfg.errorThreshold = engineconfig.ShardErrorThreshold(c)
+	a.EngineCfg.shardPoolSize = engineconfig.ShardPoolSize(c)
 	a.EngineCfg.lowMem = engineconfig.EngineLowMemoryConsumption(c)
 
 	return engineconfig.IterateShards(c, false, func(sc *shardconfig.Config) error { return a.updateShardConfig(c, sc) })
 }
 
-func (a *applicationConfiguration) updateShardConfig(c *config.Config, source *shardconfig.Config) error {
-	var target shardCfg
+func (a *applicationConfiguration) updateShardConfig(c *config.Config, oldConfig *shardconfig.Config) error {
+	var newConfig shardCfg
 
-	target.refillMetabase = source.RefillMetabase()
-	target.refillMetabaseWorkersCount = source.RefillMetabaseWorkersCount()
-	target.mode = source.Mode()
-	target.compression = source.Compression()
-	target.smallSizeObjectLimit = source.SmallSizeLimit()
+	newConfig.refillMetabase = oldConfig.RefillMetabase()
+	newConfig.refillMetabaseWorkersCount = oldConfig.RefillMetabaseWorkersCount()
+	newConfig.mode = oldConfig.Mode()
+	newConfig.compress = oldConfig.Compress()
+	newConfig.estimateCompressibility = oldConfig.EstimateCompressibility()
+	newConfig.estimateCompressibilityThreshold = oldConfig.EstimateCompressibilityThreshold()
+	newConfig.uncompressableContentType = oldConfig.UncompressableContentTypes()
+	newConfig.smallSizeObjectLimit = oldConfig.SmallSizeLimit()
 
-	a.setShardWriteCacheConfig(&target, source)
+	a.setShardWriteCacheConfig(&newConfig, oldConfig)
 
-	a.setShardPiloramaConfig(c, &target, source)
+	a.setShardPiloramaConfig(c, &newConfig, oldConfig)
 
-	if err := a.setShardStorageConfig(&target, source); err != nil {
+	if err := a.setShardStorageConfig(&newConfig, oldConfig); err != nil {
 		return err
 	}
 
-	a.setMetabaseConfig(&target, source)
+	a.setMetabaseConfig(&newConfig, oldConfig)
 
-	a.setGCConfig(&target, source)
-	if err := a.setLimiter(&target, source); err != nil {
-		return err
-	}
+	a.setGCConfig(&newConfig, oldConfig)
 
-	a.EngineCfg.shards = append(a.EngineCfg.shards, target)
+	a.EngineCfg.shards = append(a.EngineCfg.shards, newConfig)
 
 	return nil
 }
 
-func (a *applicationConfiguration) setShardWriteCacheConfig(target *shardCfg, source *shardconfig.Config) {
-	writeCacheCfg := source.WriteCache()
+func (a *applicationConfiguration) setShardWriteCacheConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
+	writeCacheCfg := oldConfig.WriteCache()
 	if writeCacheCfg.Enabled() {
-		wc := &target.writecacheCfg
+		wc := &newConfig.writecacheCfg
 
 		wc.enabled = true
 		wc.path = writeCacheCfg.Path()
@@ -309,10 +298,10 @@ func (a *applicationConfiguration) setShardWriteCacheConfig(target *shardCfg, so
 	}
 }
 
-func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, target *shardCfg, source *shardconfig.Config) {
+func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, newConfig *shardCfg, oldConfig *shardconfig.Config) {
 	if config.BoolSafe(c.Sub("tree"), "enabled") {
-		piloramaCfg := source.Pilorama()
-		pr := &target.piloramaCfg
+		piloramaCfg := oldConfig.Pilorama()
+		pr := &newConfig.piloramaCfg
 
 		pr.enabled = true
 		pr.path = piloramaCfg.Path()
@@ -323,8 +312,8 @@ func (a *applicationConfiguration) setShardPiloramaConfig(c *config.Config, targ
 	}
 }
 
-func (a *applicationConfiguration) setShardStorageConfig(target *shardCfg, source *shardconfig.Config) error {
-	blobStorCfg := source.BlobStor()
+func (a *applicationConfiguration) setShardStorageConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) error {
+	blobStorCfg := oldConfig.BlobStor()
 	storagesCfg := blobStorCfg.Storages()
 
 	ss := make([]subStorageCfg, 0, len(storagesCfg))
@@ -358,13 +347,13 @@ func (a *applicationConfiguration) setShardStorageConfig(target *shardCfg, sourc
 		ss = append(ss, sCfg)
 	}
 
-	target.subStorages = ss
+	newConfig.subStorages = ss
 	return nil
 }
 
-func (a *applicationConfiguration) setMetabaseConfig(target *shardCfg, source *shardconfig.Config) {
-	metabaseCfg := source.Metabase()
-	m := &target.metaCfg
+func (a *applicationConfiguration) setMetabaseConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
+	metabaseCfg := oldConfig.Metabase()
+	m := &newConfig.metaCfg
 
 	m.path = metabaseCfg.Path()
 	m.perm = metabaseCfg.BoltDB().Perm()
@@ -372,22 +361,12 @@ func (a *applicationConfiguration) setMetabaseConfig(target *shardCfg, source *s
 	m.maxBatchSize = metabaseCfg.BoltDB().MaxBatchSize()
 }
 
-func (a *applicationConfiguration) setGCConfig(target *shardCfg, source *shardconfig.Config) {
-	gcCfg := source.GC()
-	target.gcCfg.removerBatchSize = gcCfg.RemoverBatchSize()
-	target.gcCfg.removerSleepInterval = gcCfg.RemoverSleepInterval()
-	target.gcCfg.expiredCollectorBatchSize = gcCfg.ExpiredCollectorBatchSize()
-	target.gcCfg.expiredCollectorWorkerCount = gcCfg.ExpiredCollectorWorkerCount()
-}
-
-func (a *applicationConfiguration) setLimiter(target *shardCfg, source *shardconfig.Config) error {
-	limitsConfig := source.Limits().ToConfig()
-	limiter, err := qos.NewLimiter(limitsConfig)
-	if err != nil {
-		return err
-	}
-	target.limiter = limiter
-	return nil
+func (a *applicationConfiguration) setGCConfig(newConfig *shardCfg, oldConfig *shardconfig.Config) {
+	gcCfg := oldConfig.GC()
+	newConfig.gcCfg.removerBatchSize = gcCfg.RemoverBatchSize()
+	newConfig.gcCfg.removerSleepInterval = gcCfg.RemoverSleepInterval()
+	newConfig.gcCfg.expiredCollectorBatchSize = gcCfg.ExpiredCollectorBatchSize()
+	newConfig.gcCfg.expiredCollectorWorkerCount = gcCfg.ExpiredCollectorWorkerCount()
 }
 
 // internals contains application-specific internals that are created
@@ -477,6 +456,7 @@ type shared struct {
 // dynamicConfiguration stores parameters of the
 // components that supports runtime reconfigurations.
 type dynamicConfiguration struct {
+	logger  *logger.Prm
 	pprof   *httpComponent
 	metrics *httpComponent
 }
@@ -548,8 +528,6 @@ type cfgGRPC struct {
 	maxChunkSize     uint64
 	maxAddrAmount    uint64
 	reconnectTimeout time.Duration
-
-	limiter atomic.Pointer[limiting.SemaphoreLimiter]
 }
 
 func (c *cfgGRPC) append(e string, l net.Listener, s *grpc.Server) {
@@ -686,6 +664,10 @@ type cfgAccessPolicyEngine struct {
 }
 
 type cfgObjectRoutines struct {
+	putRemote *ants.Pool
+
+	putLocal *ants.Pool
+
 	replication *ants.Pool
 }
 
@@ -717,12 +699,16 @@ func initCfg(appCfg *config.Config) *cfg {
 
 	netState.metrics = c.metricsCollector
 
-	logPrm, err := c.loggerPrm()
-	fatalOnErr(err)
+	logPrm := c.loggerPrm()
 	logPrm.SamplingHook = c.metricsCollector.LogMetrics().GetSamplingHook()
 	log, err := logger.NewLogger(logPrm)
 	fatalOnErr(err)
-	logger.UpdateLevelForTags(logPrm)
+	if loggerconfig.ToLokiConfig(appCfg).Enabled {
+		log.WithOptions(zap.WrapCore(func(core zapcore.Core) zapcore.Core {
+			lokiCore := lokicore.New(core, loggerconfig.ToLokiConfig(appCfg))
+			return lokiCore
+		}))
+	}
 
 	c.internals = initInternals(appCfg, log)
 
@@ -866,14 +852,14 @@ func initFrostfsID(appCfg *config.Config) cfgFrostfsID {
 	}
 }
 
-func initCfgGRPC() (cfg cfgGRPC) {
+func initCfgGRPC() cfgGRPC {
 	maxChunkSize := uint64(maxMsgSize) * 3 / 4  // 25% to meta, 75% to payload
 	maxAddrAmount := maxChunkSize / addressSize // each address is about 72 bytes
 
-	cfg.maxChunkSize = maxChunkSize
-	cfg.maxAddrAmount = maxAddrAmount
-
-	return
+	return cfgGRPC{
+		maxChunkSize:  maxChunkSize,
+		maxAddrAmount: maxAddrAmount,
+	}
 }
 
 func initCfgObject(appCfg *config.Config) cfgObject {
@@ -890,6 +876,7 @@ func (c *cfg) engineOpts() []engine.Option {
 	var opts []engine.Option
 
 	opts = append(opts,
+		engine.WithShardPoolSize(c.EngineCfg.shardPoolSize),
 		engine.WithErrorThreshold(c.EngineCfg.errorThreshold),
 		engine.WithLogger(c.log),
 		engine.WithLowMemoryConsumption(c.EngineCfg.lowMem),
@@ -929,7 +916,6 @@ func (c *cfg) getWriteCacheOpts(shCfg shardCfg) []writecache.Option {
 			writecache.WithMaxCacheCount(wcRead.countLimit),
 			writecache.WithNoSync(wcRead.noSync),
 			writecache.WithLogger(c.log),
-			writecache.WithQoSLimiter(shCfg.limiter),
 		)
 	}
 	return writeCacheOpts
@@ -1021,7 +1007,10 @@ func (c *cfg) getShardOpts(ctx context.Context, shCfg shardCfg) shardOptsWithID
 	ss := c.getSubstorageOpts(ctx, shCfg)
 
 	blobstoreOpts := []blobstor.Option{
-		blobstor.WithCompression(shCfg.compression),
+		blobstor.WithCompressObjects(shCfg.compress),
+		blobstor.WithUncompressableContentTypes(shCfg.uncompressableContentType),
+		blobstor.WithCompressibilityEstimate(shCfg.estimateCompressibility),
+		blobstor.WithCompressibilityEstimateThreshold(shCfg.estimateCompressibilityThreshold),
 		blobstor.WithStorages(ss),
 		blobstor.WithLogger(c.log),
 	}
@@ -1042,7 +1031,6 @@ func (c *cfg) getShardOpts(ctx context.Context, shCfg shardCfg) shardOptsWithID
 	}
 	if c.metricsCollector != nil {
 		mbOptions = append(mbOptions, meta.WithMetrics(lsmetrics.NewMetabaseMetrics(shCfg.metaCfg.path, c.metricsCollector.MetabaseMetrics())))
-		shCfg.limiter.SetMetrics(c.metricsCollector.QoSMetrics())
 	}
 
 	var sh shardOptsWithID
@@ -1067,33 +1055,30 @@ func (c *cfg) getShardOpts(ctx context.Context, shCfg shardCfg) shardOptsWithID
 
 			return pool
 		}),
-		shard.WithLimiter(shCfg.limiter),
 	}
 	return sh
 }
 
-func (c *cfg) loggerPrm() (logger.Prm, error) {
-	var prm logger.Prm
-	// (re)init read configuration
-	err := prm.SetLevelString(c.LoggerCfg.level)
-	if err != nil {
-		// not expected since validation should be performed before
-		return logger.Prm{}, errors.New("incorrect log level format: " + c.LoggerCfg.level)
-	}
-	err = prm.SetDestination(c.LoggerCfg.destination)
-	if err != nil {
-		// not expected since validation should be performed before
-		return logger.Prm{}, errors.New("incorrect log destination format: " + c.LoggerCfg.destination)
-	}
-	prm.PrependTimestamp = c.LoggerCfg.timestamp
-	prm.Options = c.LoggerCfg.options
-	err = prm.SetTags(c.LoggerCfg.tags)
-	if err != nil {
-		// not expected since validation should be performed before
-		return logger.Prm{}, errors.New("incorrect allowed tags format: " + c.LoggerCfg.destination)
+func (c *cfg) loggerPrm() *logger.Prm {
+	// check if it has been inited before
+	if c.dynamicConfiguration.logger == nil {
+		c.dynamicConfiguration.logger = new(logger.Prm)
 	}
 
-	return prm, nil
+	// (re)init read configuration
+	err := c.dynamicConfiguration.logger.SetLevelString(c.LoggerCfg.level)
+	if err != nil {
+		// not expected since validation should be performed before
+		panic("incorrect log level format: " + c.LoggerCfg.level)
+	}
+	err = c.dynamicConfiguration.logger.SetDestination(c.LoggerCfg.destination)
+	if err != nil {
+		// not expected since validation should be performed before
+		panic("incorrect log destination format: " + c.LoggerCfg.destination)
+	}
+	c.dynamicConfiguration.logger.PrependTimestamp = c.LoggerCfg.timestamp
+
+	return c.dynamicConfiguration.logger
 }
 
 func (c *cfg) LocalAddress() network.AddressGroup {
@@ -1181,7 +1166,21 @@ func initAccessPolicyEngine(ctx context.Context, c *cfg) {
 func initObjectPool(cfg *config.Config) (pool cfgObjectRoutines) {
 	var err error
 
+	optNonBlocking := ants.WithNonblocking(true)
+
+	putRemoteCapacity := objectconfig.Put(cfg).PoolSizeRemote()
+	pool.putRemote, err = ants.NewPool(putRemoteCapacity, optNonBlocking)
+	fatalOnErr(err)
+
+	putLocalCapacity := objectconfig.Put(cfg).PoolSizeLocal()
+	pool.putLocal, err = ants.NewPool(putLocalCapacity, optNonBlocking)
+	fatalOnErr(err)
+
 	replicatorPoolSize := replicatorconfig.PoolSize(cfg)
+	if replicatorPoolSize <= 0 {
+		replicatorPoolSize = putRemoteCapacity
+	}
+
 	pool.replication, err = ants.NewPool(replicatorPoolSize)
 	fatalOnErr(err)
 
@@ -1333,7 +1332,11 @@ func (c *cfg) reloadConfig(ctx context.Context) {
 	// all the components are expected to support
 	// Logger's dynamic reconfiguration approach
 
-	components := c.getComponents(ctx)
+	// Logger
+
+	logPrm := c.loggerPrm()
+
+	components := c.getComponents(ctx, logPrm)
 
 	// Object
 	c.cfgObject.tombstoneLifetime.Store(c.ObjectCfg.tombstoneLifetime)
@@ -1371,17 +1374,10 @@ func (c *cfg) reloadConfig(ctx context.Context) {
 	c.log.Info(ctx, logs.FrostFSNodeConfigurationHasBeenReloadedSuccessfully)
 }
 
-func (c *cfg) getComponents(ctx context.Context) []dCmp {
+func (c *cfg) getComponents(ctx context.Context, logPrm *logger.Prm) []dCmp {
 	var components []dCmp
 
-	components = append(components, dCmp{"logger", func() error {
-		prm, err := c.loggerPrm()
-		if err != nil {
-			return err
-		}
-		logger.UpdateLevelForTags(prm)
-		return nil
-	}})
+	components = append(components, dCmp{"logger", logPrm.Reload})
 	components = append(components, dCmp{"runtime", func() error {
 		setRuntimeParameters(ctx, c)
 		return nil
@@ -1414,13 +1410,17 @@ func (c *cfg) getComponents(ctx context.Context) []dCmp {
 		components = append(components, dCmp{cmp.name, func() error { return cmp.reload(ctx) }})
 	}
 
-	components = append(components, dCmp{"rpc_limiter", func() error { return initRPCLimiter(c) }})
-
 	return components
 }
 
 func (c *cfg) reloadPools() error {
-	newSize := replicatorconfig.PoolSize(c.appCfg)
+	newSize := objectconfig.Put(c.appCfg).PoolSizeLocal()
+	c.reloadPool(c.cfgObject.pool.putLocal, newSize, "object.put.local_pool_size")
+
+	newSize = objectconfig.Put(c.appCfg).PoolSizeRemote()
+	c.reloadPool(c.cfgObject.pool.putRemote, newSize, "object.put.remote_pool_size")
+
+	newSize = replicatorconfig.PoolSize(c.appCfg)
 	c.reloadPool(c.cfgObject.pool.replication, newSize, "replicator.pool_size")
 
 	return nil

cmd/frostfs-node/config/configdir_test.go

@@ -12,10 +12,13 @@ import (
 func TestConfigDir(t *testing.T) {
 	dir := t.TempDir()
 
-	cfgFileName := path.Join(dir, "cfg_01.yml")
+	cfgFileName0 := path.Join(dir, "cfg_00.json")
+	cfgFileName1 := path.Join(dir, "cfg_01.yml")
 
-	require.NoError(t, os.WriteFile(cfgFileName, []byte("logger:\n  level: debug"), 0o777))
+	require.NoError(t, os.WriteFile(cfgFileName0, []byte(`{"storage":{"shard_pool_size":15}}`), 0o777))
+	require.NoError(t, os.WriteFile(cfgFileName1, []byte("logger:\n  level: debug"), 0o777))
 
 	c := New("", dir, "")
 	require.Equal(t, "debug", cast.ToString(c.Sub("logger").Value("level")))
+	require.EqualValues(t, 15, cast.ToUint32(c.Sub("storage").Value("shard_pool_size")))
 }

cmd/frostfs-node/config/engine/config.go

@@ -11,6 +11,10 @@ import (
 
 const (
 	subsection = "storage"
+
+	// ShardPoolSizeDefault is a default value of routine pool size per-shard to
+	// process object PUT operations in a storage engine.
+	ShardPoolSizeDefault = 20
 )
 
 // ErrNoShardConfigured is returned when at least 1 shard is required but none are found.
@@ -61,6 +65,18 @@ func IterateShards(c *config.Config, required bool, f func(*shardconfig.Config)
 	return nil
 }
 
+// ShardPoolSize returns the value of "shard_pool_size" config parameter from "storage" section.
+//
+// Returns ShardPoolSizeDefault if the value is not a positive number.
+func ShardPoolSize(c *config.Config) uint32 {
+	v := config.Uint32Safe(c.Sub(subsection), "shard_pool_size")
+	if v > 0 {
+		return v
+	}
+
+	return ShardPoolSizeDefault
+}
+
 // ShardErrorThreshold returns the value of "shard_ro_error_threshold" config parameter from "storage" section.
 //
 // Returns 0 if the the value is missing.

cmd/frostfs-node/config/engine/config_test.go

@@ -14,8 +14,6 @@ import (
 	piloramaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/pilorama"
 	writecacheconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/writecache"
 	configtest "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/test"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/compression"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
 	"github.com/stretchr/testify/require"
 )
@@ -55,6 +53,7 @@ func TestEngineSection(t *testing.T) {
 		require.False(t, handlerCalled)
 
 		require.EqualValues(t, 0, engineconfig.ShardErrorThreshold(empty))
+		require.EqualValues(t, engineconfig.ShardPoolSizeDefault, engineconfig.ShardPoolSize(empty))
 		require.EqualValues(t, mode.ReadWrite, shardconfig.From(empty).Mode())
 	})
 
@@ -64,6 +63,7 @@ func TestEngineSection(t *testing.T) {
 		num := 0
 
 		require.EqualValues(t, 100, engineconfig.ShardErrorThreshold(c))
+		require.EqualValues(t, 15, engineconfig.ShardPoolSize(c))
 
 		err := engineconfig.IterateShards(c, true, func(sc *shardconfig.Config) error {
 			defer func() {
@@ -76,7 +76,6 @@ func TestEngineSection(t *testing.T) {
 			ss := blob.Storages()
 			pl := sc.Pilorama()
 			gc := sc.GC()
-			limits := sc.Limits()
 
 			switch num {
 			case 0:
@@ -101,11 +100,10 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, 100, meta.BoltDB().MaxBatchSize())
 				require.Equal(t, 10*time.Millisecond, meta.BoltDB().MaxBatchDelay())
 
-				require.Equal(t, true, sc.Compression().Enabled)
-				require.Equal(t, compression.LevelFastest, sc.Compression().Level)
-				require.Equal(t, []string{"audio/*", "video/*"}, sc.Compression().UncompressableContentTypes)
-				require.Equal(t, true, sc.Compression().EstimateCompressibility)
-				require.Equal(t, float64(0.7), sc.Compression().EstimateCompressibilityThreshold)
+				require.Equal(t, true, sc.Compress())
+				require.Equal(t, []string{"audio/*", "video/*"}, sc.UncompressableContentTypes())
+				require.Equal(t, true, sc.EstimateCompressibility())
+				require.Equal(t, float64(0.7), sc.EstimateCompressibilityThreshold())
 				require.EqualValues(t, 102400, sc.SmallSizeLimit())
 
 				require.Equal(t, 2, len(ss))
@@ -136,86 +134,6 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, false, sc.RefillMetabase())
 				require.Equal(t, mode.ReadOnly, sc.Mode())
 				require.Equal(t, 100, sc.RefillMetabaseWorkersCount())
-
-				readLimits := limits.ToConfig().Read
-				writeLimits := limits.ToConfig().Write
-				require.Equal(t, 30*time.Second, readLimits.IdleTimeout)
-				require.Equal(t, int64(10_000), readLimits.MaxRunningOps)
-				require.Equal(t, int64(1_000), readLimits.MaxWaitingOps)
-				require.Equal(t, 45*time.Second, writeLimits.IdleTimeout)
-				require.Equal(t, int64(1_000), writeLimits.MaxRunningOps)
-				require.Equal(t, int64(100), writeLimits.MaxWaitingOps)
-				require.ElementsMatch(t, readLimits.Tags,
-					[]qos.IOTagConfig{
-						{
-							Tag:         "internal",
-							Weight:      toPtr(20),
-							ReservedOps: toPtr(1000),
-							LimitOps:    toPtr(0),
-						},
-						{
-							Tag:         "client",
-							Weight:      toPtr(70),
-							ReservedOps: toPtr(10000),
-						},
-						{
-							Tag:         "background",
-							Weight:      toPtr(5),
-							LimitOps:    toPtr(10000),
-							ReservedOps: toPtr(0),
-						},
-						{
-							Tag:      "writecache",
-							Weight:   toPtr(5),
-							LimitOps: toPtr(25000),
-						},
-						{
-							Tag:        "policer",
-							Weight:     toPtr(5),
-							LimitOps:   toPtr(25000),
-							Prohibited: true,
-						},
-						{
-							Tag:      "treesync",
-							Weight:   toPtr(5),
-							LimitOps: toPtr(25),
-						},
-					})
-				require.ElementsMatch(t, writeLimits.Tags,
-					[]qos.IOTagConfig{
-						{
-							Tag:         "internal",
-							Weight:      toPtr(200),
-							ReservedOps: toPtr(100),
-							LimitOps:    toPtr(0),
-						},
-						{
-							Tag:         "client",
-							Weight:      toPtr(700),
-							ReservedOps: toPtr(1000),
-						},
-						{
-							Tag:         "background",
-							Weight:      toPtr(50),
-							LimitOps:    toPtr(1000),
-							ReservedOps: toPtr(0),
-						},
-						{
-							Tag:      "writecache",
-							Weight:   toPtr(50),
-							LimitOps: toPtr(2500),
-						},
-						{
-							Tag:      "policer",
-							Weight:   toPtr(50),
-							LimitOps: toPtr(2500),
-						},
-						{
-							Tag:      "treesync",
-							Weight:   toPtr(50),
-							LimitOps: toPtr(100),
-						},
-					})
 			case 1:
 				require.Equal(t, "tmp/1/blob/pilorama.db", pl.Path())
 				require.Equal(t, fs.FileMode(0o644), pl.Perm())
@@ -238,9 +156,8 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, 200, meta.BoltDB().MaxBatchSize())
 				require.Equal(t, 20*time.Millisecond, meta.BoltDB().MaxBatchDelay())
 
-				require.Equal(t, false, sc.Compression().Enabled)
-				require.Equal(t, compression.LevelDefault, sc.Compression().Level)
-				require.Equal(t, []string(nil), sc.Compression().UncompressableContentTypes)
+				require.Equal(t, false, sc.Compress())
+				require.Equal(t, []string(nil), sc.UncompressableContentTypes())
 				require.EqualValues(t, 102400, sc.SmallSizeLimit())
 
 				require.Equal(t, 2, len(ss))
@@ -271,17 +188,6 @@ func TestEngineSection(t *testing.T) {
 				require.Equal(t, true, sc.RefillMetabase())
 				require.Equal(t, mode.ReadWrite, sc.Mode())
 				require.Equal(t, shardconfig.RefillMetabaseWorkersCountDefault, sc.RefillMetabaseWorkersCount())
-
-				readLimits := limits.ToConfig().Read
-				writeLimits := limits.ToConfig().Write
-				require.Equal(t, qos.DefaultIdleTimeout, readLimits.IdleTimeout)
-				require.Equal(t, qos.NoLimit, readLimits.MaxRunningOps)
-				require.Equal(t, qos.NoLimit, readLimits.MaxWaitingOps)
-				require.Equal(t, qos.DefaultIdleTimeout, writeLimits.IdleTimeout)
-				require.Equal(t, qos.NoLimit, writeLimits.MaxRunningOps)
-				require.Equal(t, qos.NoLimit, writeLimits.MaxWaitingOps)
-				require.Equal(t, 0, len(readLimits.Tags))
-				require.Equal(t, 0, len(writeLimits.Tags))
 			}
 			return nil
 		})
@@ -295,7 +201,3 @@ func TestEngineSection(t *testing.T) {
 		configtest.ForEnvFileType(t, path, fileConfigTest)
 	})
 }
-
-func toPtr(v float64) *float64 {
-	return &v
-}

cmd/frostfs-node/config/engine/shard/boltdb/boltdb.go

@@ -37,7 +37,10 @@ func (x *Config) Perm() fs.FileMode {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchDelay() time.Duration {
 	d := config.DurationSafe((*config.Config)(x), "max_batch_delay")
-	return max(d, 0)
+	if d < 0 {
+		d = 0
+	}
+	return d
 }
 
 // MaxBatchSize returns the value of "max_batch_size" config parameter.
@@ -45,7 +48,10 @@ func (x *Config) MaxBatchDelay() time.Duration {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchSize() int {
 	s := int(config.IntSafe((*config.Config)(x), "max_batch_size"))
-	return max(s, 0)
+	if s < 0 {
+		s = 0
+	}
+	return s
 }
 
 // NoSync returns the value of "no_sync" config parameter.
@@ -60,5 +66,8 @@ func (x *Config) NoSync() bool {
 // Returns 0 if the value is not a positive number.
 func (x *Config) PageSize() int {
 	s := int(config.SizeInBytesSafe((*config.Config)(x), "page_size"))
-	return max(s, 0)
+	if s < 0 {
+		s = 0
+	}
+	return s
 }

cmd/frostfs-node/config/engine/shard/config.go

@@ -4,11 +4,9 @@ import (
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
 	blobstorconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/blobstor"
 	gcconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/gc"
-	limitsconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/limits"
 	metabaseconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/metabase"
 	piloramaconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/pilorama"
 	writecacheconfig "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/engine/shard/writecache"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/compression"
 	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
 )
 
@@ -28,27 +26,42 @@ func From(c *config.Config) *Config {
 	return (*Config)(c)
 }
 
-func (x *Config) Compression() compression.Config {
-	cc := (*config.Config)(x).Sub("compression")
-	if cc == nil {
-		return compression.Config{}
-	}
-	return compression.Config{
-		Enabled:                          config.BoolSafe(cc, "enabled"),
-		UncompressableContentTypes:       config.StringSliceSafe(cc, "exclude_content_types"),
-		Level:                            compression.Level(config.StringSafe(cc, "level")),
-		EstimateCompressibility:          config.BoolSafe(cc, "estimate_compressibility"),
-		EstimateCompressibilityThreshold: estimateCompressibilityThreshold(cc),
-	}
+// Compress returns the value of "compress" config parameter.
+//
+// Returns false if the value is not a valid bool.
+func (x *Config) Compress() bool {
+	return config.BoolSafe(
+		(*config.Config)(x),
+		"compress",
+	)
+}
+
+// UncompressableContentTypes returns the value of "compress_skip_content_types" config parameter.
+//
+// Returns nil if a the value is missing or is invalid.
+func (x *Config) UncompressableContentTypes() []string {
+	return config.StringSliceSafe(
+		(*config.Config)(x),
+		"compression_exclude_content_types")
+}
+
+// EstimateCompressibility returns the value of "estimate_compressibility" config parameter.
+//
+// Returns false if the value is not a valid bool.
+func (x *Config) EstimateCompressibility() bool {
+	return config.BoolSafe(
+		(*config.Config)(x),
+		"compression_estimate_compressibility",
+	)
 }
 
 // EstimateCompressibilityThreshold returns the value of "estimate_compressibility_threshold" config parameter.
 //
 // Returns EstimateCompressibilityThresholdDefault if the value is not defined, not valid float or not in range [0.0; 1.0].
-func estimateCompressibilityThreshold(c *config.Config) float64 {
+func (x *Config) EstimateCompressibilityThreshold() float64 {
 	v := config.FloatOrDefault(
-		c,
-		"estimate_compressibility_threshold",
+		(*config.Config)(x),
+		"compression_estimate_compressibility_threshold",
 		EstimateCompressibilityThresholdDefault)
 	if v < 0.0 || v > 1.0 {
 		return EstimateCompressibilityThresholdDefault
@@ -112,14 +125,6 @@ func (x *Config) GC() *gcconfig.Config {
 	)
 }
 
-// Limits returns "limits" subsection as a limitsconfig.Config.
-func (x *Config) Limits() *limitsconfig.Config {
-	return limitsconfig.From(
-		(*config.Config)(x).
-			Sub("limits"),
-	)
-}
-
 // RefillMetabase returns the value of "resync_metabase" config parameter.
 //
 // Returns false if the value is not a valid bool.

cmd/frostfs-node/config/engine/shard/limits/config.go

@@ -1,112 +0,0 @@
-package limits
-
-import (
-	"strconv"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	"git.frostfs.info/TrueCloudLab/frostfs-node/internal/qos"
-	"github.com/spf13/cast"
-)
-
-// From wraps config section into Config.
-func From(c *config.Config) *Config {
-	return (*Config)(c)
-}
-
-// Config is a wrapper over the config section
-// which provides access to Shard's limits configurations.
-type Config config.Config
-
-func (x *Config) ToConfig() qos.LimiterConfig {
-	result := qos.LimiterConfig{
-		Read:  x.read(),
-		Write: x.write(),
-	}
-	panicOnErr(result.Validate())
-	return result
-}
-
-func (x *Config) read() qos.OpConfig {
-	return x.parse("read")
-}
-
-func (x *Config) write() qos.OpConfig {
-	return x.parse("write")
-}
-
-func (x *Config) parse(sub string) qos.OpConfig {
-	c := (*config.Config)(x).Sub(sub)
-	var result qos.OpConfig
-
-	if s := config.Int(c, "max_waiting_ops"); s > 0 {
-		result.MaxWaitingOps = s
-	} else {
-		result.MaxWaitingOps = qos.NoLimit
-	}
-
-	if s := config.Int(c, "max_running_ops"); s > 0 {
-		result.MaxRunningOps = s
-	} else {
-		result.MaxRunningOps = qos.NoLimit
-	}
-
-	if s := config.DurationSafe(c, "idle_timeout"); s > 0 {
-		result.IdleTimeout = s
-	} else {
-		result.IdleTimeout = qos.DefaultIdleTimeout
-	}
-
-	result.Tags = tags(c)
-
-	return result
-}
-
-func tags(c *config.Config) []qos.IOTagConfig {
-	c = c.Sub("tags")
-	var result []qos.IOTagConfig
-	for i := 0; ; i++ {
-		tag := config.String(c, strconv.Itoa(i)+".tag")
-		if tag == "" {
-			return result
-		}
-
-		var tagConfig qos.IOTagConfig
-		tagConfig.Tag = tag
-
-		v := c.Value(strconv.Itoa(i) + ".weight")
-		if v != nil {
-			w, err := cast.ToFloat64E(v)
-			panicOnErr(err)
-			tagConfig.Weight = &w
-		}
-
-		v = c.Value(strconv.Itoa(i) + ".limit_ops")
-		if v != nil {
-			l, err := cast.ToFloat64E(v)
-			panicOnErr(err)
-			tagConfig.LimitOps = &l
-		}
-
-		v = c.Value(strconv.Itoa(i) + ".reserved_ops")
-		if v != nil {
-			r, err := cast.ToFloat64E(v)
-			panicOnErr(err)
-			tagConfig.ReservedOps = &r
-		}
-
-		v = c.Value(strconv.Itoa(i) + ".prohibited")
-		if v != nil {
-			r, err := cast.ToBoolE(v)
-			panicOnErr(err)
-			tagConfig.Prohibited = r
-		}
-
-		result = append(result, tagConfig)
-	}
-}
-
-func panicOnErr(err error) {
-	if err != nil {
-		panic(err)
-	}
-}

cmd/frostfs-node/config/engine/shard/pilorama/config.go

@@ -52,7 +52,10 @@ func (x *Config) NoSync() bool {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchDelay() time.Duration {
 	d := config.DurationSafe((*config.Config)(x), "max_batch_delay")
-	return max(d, 0)
+	if d <= 0 {
+		d = 0
+	}
+	return d
 }
 
 // MaxBatchSize returns the value of "max_batch_size" config parameter.
@@ -60,5 +63,8 @@ func (x *Config) MaxBatchDelay() time.Duration {
 // Returns 0 if the value is not a positive number.
 func (x *Config) MaxBatchSize() int {
 	s := int(config.IntSafe((*config.Config)(x), "max_batch_size"))
-	return max(s, 0)
+	if s <= 0 {
+		s = 0
+	}
+	return s
 }

cmd/frostfs-node/config/logger/config.go

@@ -2,7 +2,6 @@ package loggerconfig
 
 import (
 	"os"
-	"strconv"
 	"time"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
@@ -61,21 +60,6 @@ func Timestamp(c *config.Config) bool {
 	return config.BoolSafe(c.Sub(subsection), "timestamp")
 }
 
-// Tags returns the value of "tags" config parameter from "logger" section.
-func Tags(c *config.Config) [][]string {
-	var res [][]string
-	sub := c.Sub(subsection).Sub("tags")
-	for i := 0; ; i++ {
-		s := sub.Sub(strconv.FormatInt(int64(i), 10))
-		names := config.StringSafe(s, "names")
-		if names == "" {
-			break
-		}
-		res = append(res, []string{names, config.StringSafe(s, "level")})
-	}
-	return res
-}
-
 // ToLokiConfig extracts loki config.
 func ToLokiConfig(c *config.Config) loki.Config {
 	hostname, _ := os.Hostname()

cmd/frostfs-node/config/morph/config.go

@@ -33,9 +33,6 @@ const (
 
 	// ContainerCacheSizeDefault represents the default size for the container cache.
 	ContainerCacheSizeDefault = 100
-
-	// PollCandidatesTimeoutDefault is a default poll timeout for netmap candidates.
-	PollCandidatesTimeoutDefault = 20 * time.Second
 )
 
 var errNoMorphEndpoints = errors.New("no morph chain RPC endpoints, see `morph.rpc_endpoint` section")
@@ -157,17 +154,3 @@ func FrostfsIDCacheSize(c *config.Config) uint32 {
 	}
 	return config.Uint32Safe(c.Sub(subsection), "frostfsid_cache_size")
 }
-
-// NetmapCandidatesPollInterval returns the value of "netmap.candidates.poll_interval" config parameter
-// from "morph" section.
-//
-// Returns PollCandidatesTimeoutDefault if the value is not positive duration.
-func NetmapCandidatesPollInterval(c *config.Config) time.Duration {
-	v := config.DurationSafe(c.Sub(subsection).
-		Sub("netmap").Sub("candidates"), "poll_interval")
-	if v > 0 {
-		return v
-	}
-
-	return PollCandidatesTimeoutDefault
-}

cmd/frostfs-node/config/node/config.go

@@ -3,9 +3,7 @@ package nodeconfig
 import (
 	"fmt"
 	"io/fs"
-	"iter"
 	"os"
-	"slices"
 	"strconv"
 
 	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
@@ -90,8 +88,12 @@ func Wallet(c *config.Config) *keys.PrivateKey {
 
 type stringAddressGroup []string
 
-func (x stringAddressGroup) Addresses() iter.Seq[string] {
-	return slices.Values(x)
+func (x stringAddressGroup) IterateAddresses(f func(string) bool) {
+	for i := range x {
+		if f(x[i]) {
+			break
+		}
+	}
 }
 
 func (x stringAddressGroup) NumberOfAddresses() int {
@@ -215,8 +217,3 @@ func (l PersistentPolicyRulesConfig) NoSync() bool {
 func CompatibilityMode(c *config.Config) bool {
 	return config.BoolSafe(c.Sub(subsection), "kludge_compatibility_mode")
 }
-
-// LocodeDBPath returns path to LOCODE database.
-func LocodeDBPath(c *config.Config) string {
-	return config.String(c.Sub(subsection), "locode_db_path")
-}

cmd/frostfs-node/config/object/config.go

@@ -21,6 +21,10 @@ const (
 
 	putSubsection = "put"
 	getSubsection = "get"
+
+	// PutPoolSizeDefault is a default value of routine pool size to
+	// process object.Put requests in object service.
+	PutPoolSizeDefault = 10
 )
 
 // Put returns structure that provides access to "put" subsection of
@@ -31,6 +35,30 @@ func Put(c *config.Config) PutConfig {
 	}
 }
 
+// PoolSizeRemote returns the value of "remote_pool_size" config parameter.
+//
+// Returns PutPoolSizeDefault if the value is not a positive number.
+func (g PutConfig) PoolSizeRemote() int {
+	v := config.Int(g.cfg, "remote_pool_size")
+	if v > 0 {
+		return int(v)
+	}
+
+	return PutPoolSizeDefault
+}
+
+// PoolSizeLocal returns the value of "local_pool_size" config parameter.
+//
+// Returns PutPoolSizeDefault if the value is not a positive number.
+func (g PutConfig) PoolSizeLocal() int {
+	v := config.Int(g.cfg, "local_pool_size")
+	if v > 0 {
+		return int(v)
+	}
+
+	return PutPoolSizeDefault
+}
+
 // SkipSessionTokenIssuerVerification returns the value of "skip_session_token_issuer_verification" config parameter or `false“ if is not defined.
 func (g PutConfig) SkipSessionTokenIssuerVerification() bool {
 	return config.BoolSafe(g.cfg, "skip_session_token_issuer_verification")

cmd/frostfs-node/config/object/config_test.go

@@ -13,6 +13,8 @@ func TestObjectSection(t *testing.T) {
 	t.Run("defaults", func(t *testing.T) {
 		empty := configtest.EmptyConfig()
 
+		require.Equal(t, objectconfig.PutPoolSizeDefault, objectconfig.Put(empty).PoolSizeRemote())
+		require.Equal(t, objectconfig.PutPoolSizeDefault, objectconfig.Put(empty).PoolSizeLocal())
 		require.EqualValues(t, objectconfig.DefaultTombstoneLifetime, objectconfig.TombstoneLifetime(empty))
 		require.False(t, objectconfig.Put(empty).SkipSessionTokenIssuerVerification())
 	})
@@ -20,6 +22,8 @@ func TestObjectSection(t *testing.T) {
 	const path = "../../../../config/example/node"
 
 	fileConfigTest := func(c *config.Config) {
+		require.Equal(t, 100, objectconfig.Put(c).PoolSizeRemote())
+		require.Equal(t, 200, objectconfig.Put(c).PoolSizeLocal())
 		require.EqualValues(t, 10, objectconfig.TombstoneLifetime(c))
 		require.True(t, objectconfig.Put(c).SkipSessionTokenIssuerVerification())
 	}

cmd/frostfs-node/config/replicator/config.go

@@ -11,8 +11,6 @@ const (
 
 	// PutTimeoutDefault is a default timeout of object put request in replicator.
 	PutTimeoutDefault = 5 * time.Second
-	// PoolSizeDefault is a default pool size for put request in replicator.
-	PoolSizeDefault = 10
 )
 
 // PutTimeout returns the value of "put_timeout" config parameter
@@ -30,13 +28,6 @@ func PutTimeout(c *config.Config) time.Duration {
 
 // PoolSize returns the value of "pool_size" config parameter
 // from "replicator" section.
-//
-// Returns PoolSizeDefault if the value is non-positive integer.
 func PoolSize(c *config.Config) int {
-	v := int(config.IntSafe(c.Sub(subsection), "pool_size"))
-	if v > 0 {
-		return v
-	}
-
-	return PoolSizeDefault
+	return int(config.IntSafe(c.Sub(subsection), "pool_size"))
 }

cmd/frostfs-node/config/replicator/config_test.go

@@ -15,7 +15,7 @@ func TestReplicatorSection(t *testing.T) {
 		empty := configtest.EmptyConfig()
 
 		require.Equal(t, replicatorconfig.PutTimeoutDefault, replicatorconfig.PutTimeout(empty))
-		require.Equal(t, replicatorconfig.PoolSizeDefault, replicatorconfig.PoolSize(empty))
+		require.Equal(t, 0, replicatorconfig.PoolSize(empty))
 	})
 
 	const path = "../../../../config/example/node"

cmd/frostfs-node/config/rpc/config.go

@@ -1,42 +0,0 @@
-package rpcconfig
-
-import (
-	"strconv"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-)
-
-const (
-	subsection       = "rpc"
-	limitsSubsection = "limits"
-)
-
-type LimitConfig struct {
-	Methods []string
-	MaxOps  int64
-}
-
-// Limits returns the "limits" config from "rpc" section.
-func Limits(c *config.Config) []LimitConfig {
-	c = c.Sub(subsection).Sub(limitsSubsection)
-
-	var limits []LimitConfig
-
-	for i := uint64(0); ; i++ {
-		si := strconv.FormatUint(i, 10)
-		sc := c.Sub(si)
-
-		methods := config.StringSliceSafe(sc, "methods")
-		if len(methods) == 0 {
-			break
-		}
-
-		if sc.Value("max_ops") == nil {
-			panic("no max operations for method group")
-		}
-
-		limits = append(limits, LimitConfig{methods, config.IntSafe(sc, "max_ops")})
-	}
-
-	return limits
-}

cmd/frostfs-node/config/rpc/config_test.go

@@ -1,77 +0,0 @@
-package rpcconfig
-
-import (
-	"testing"
-
-	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config"
-	configtest "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-node/config/test"
-	"github.com/stretchr/testify/require"
-)
-
-func TestRPCSection(t *testing.T) {
-	t.Run("defaults", func(t *testing.T) {
-		require.Empty(t, Limits(configtest.EmptyConfig()))
-	})
-
-	t.Run("correct config", func(t *testing.T) {
-		const path = "../../../../config/example/node"
-
-		fileConfigTest := func(c *config.Config) {
-			limits := Limits(c)
-			require.Len(t, limits, 2)
-
-			limit0 := limits[0]
-			limit1 := limits[1]
-
-			require.ElementsMatch(t, limit0.Methods, []string{"/neo.fs.v2.object.ObjectService/PutSingle", "/neo.fs.v2.object.ObjectService/Put"})
-			require.Equal(t, limit0.MaxOps, int64(1000))
-
-			require.ElementsMatch(t, limit1.Methods, []string{"/neo.fs.v2.object.ObjectService/Get"})
-			require.Equal(t, limit1.MaxOps, int64(10000))
-		}
-
-		configtest.ForEachFileType(path, fileConfigTest)
-
-		t.Run("ENV", func(t *testing.T) {
-			configtest.ForEnvFileType(t, path, fileConfigTest)
-		})
-	})
-
-	t.Run("no max operations", func(t *testing.T) {
-		const path = "testdata/no_max_ops"
-
-		fileConfigTest := func(c *config.Config) {
-			require.Panics(t, func() { _ = Limits(c) })
-		}
-
-		configtest.ForEachFileType(path, fileConfigTest)
-
-		t.Run("ENV", func(t *testing.T) {
-			configtest.ForEnvFileType(t, path, fileConfigTest)
-		})
-	})
-
-	t.Run("zero max operations", func(t *testing.T) {
-		const path = "testdata/zero_max_ops"
-
-		fileConfigTest := func(c *config.Config) {
-			limits := Limits(c)
-			require.Len(t, limits, 2)
-
-			limit0 := limits[0]
-			limit1 := limits[1]
-
-			require.ElementsMatch(t, limit0.Methods, []string{"/neo.fs.v2.object.ObjectService/PutSingle", "/neo.fs.v2.object.ObjectService/Put"})
-			require.Equal(t, limit0.MaxOps, int64(0))
-
-			require.ElementsMatch(t, limit1.Methods, []string{"/neo.fs.v2.object.ObjectService/Get"})
-			require.Equal(t, limit1.MaxOps, int64(10000))
-		}
-
-		configtest.ForEachFileType(path, fileConfigTest)
-
-		t.Run("ENV", func(t *testing.T) {
-			configtest.ForEnvFileType(t, path, fileConfigTest)
-		})
-	})
-}

cmd/frostfs-node/config/rpc/testdata/no_max_ops.env

@@ -1,3 +0,0 @@
-FROSTFS_RPC_LIMITS_0_METHODS="/neo.fs.v2.object.ObjectService/PutSingle /neo.fs.v2.object.ObjectService/Put"
-FROSTFS_RPC_LIMITS_1_METHODS="/neo.fs.v2.object.ObjectService/Get"
-FROSTFS_RPC_LIMITS_1_MAX_OPS=10000

cmd/frostfs-node/config/rpc/testdata/no_max_ops.json

@@ -1,18 +0,0 @@
-{
-  "rpc": {
-    "limits": [
-      {
-        "methods": [
-          "/neo.fs.v2.object.ObjectService/PutSingle",
-          "/neo.fs.v2.object.ObjectService/Put"
-        ]
-      },
-      {
-        "methods": [
-          "/neo.fs.v2.object.ObjectService/Get"
-        ],
-        "max_ops": 10000
-      }
-    ]
-  }
-}

cmd/frostfs-node/config/rpc/testdata/no_max_ops.yaml

@@ -1,8 +0,0 @@
-rpc:
-  limits:
-    - methods:
-      - /neo.fs.v2.object.ObjectService/PutSingle
-      - /neo.fs.v2.object.ObjectService/Put
-    - methods:
-      - /neo.fs.v2.object.ObjectService/Get
-      max_ops: 10000

cmd/frostfs-node/config/rpc/testdata/zero_max_ops.env

@@ -1,4 +0,0 @@
-FROSTFS_RPC_LIMITS_0_METHODS="/neo.fs.v2.object.ObjectService/PutSingle /neo.fs.v2.object.ObjectService/Put"
-FROSTFS_RPC_LIMITS_0_MAX_OPS=0
-FROSTFS_RPC_LIMITS_1_METHODS="/neo.fs.v2.object.ObjectService/Get"
-FROSTFS_RPC_LIMITS_1_MAX_OPS=10000

cmd/frostfs-node/config/rpc/testdata/zero_max_ops.json

@@ -1,19 +0,0 @@
-{
-  "rpc": {
-    "limits": [
-      {
-        "methods": [
-          "/neo.fs.v2.object.ObjectService/PutSingle",
-          "/neo.fs.v2.object.ObjectService/Put"
-        ],
-        "max_ops": 0
-      },
-      {
-        "methods": [
-          "/neo.fs.v2.object.ObjectService/Get"
-        ],
-        "max_ops": 10000
-      }
-    ]
-  }
-}

cmd/frostfs-node/config/rpc/testdata/zero_max_ops.yaml

@@ -1,9 +0,0 @@
-rpc:
-  limits:
-    - methods:
-      - /neo.fs.v2.object.ObjectService/PutSingle
-      - /neo.fs.v2.object.ObjectService/Put
-      max_ops: 0
-    - methods:
-      - /neo.fs.v2.object.ObjectService/Get
-      max_ops: 10000

cmd/frostfs-node/container.go

@@ -32,7 +32,7 @@ func initContainerService(_ context.Context, c *cfg) {
 	wrap, err := cntClient.NewFromMorph(c.cfgMorph.client, c.cfgContainer.scriptHash, 0)
 	fatalOnErr(err)
 
-	c.cnrClient = wrap
+	c.shared.cnrClient = wrap
 
 	cnrSrc := cntClient.AsContainerSource(wrap)
 
@@ -47,7 +47,7 @@ func initContainerService(_ context.Context, c *cfg) {
 		frostfsIDSubjectProvider = newMorphFrostfsIDCache(frostfsIDSubjectProvider, int(cacheSize), c.cfgMorph.cacheTTL, metrics.NewCacheMetrics("frostfs_id"))
 	}
 
-	c.frostfsidClient = frostfsIDSubjectProvider
+	c.shared.frostfsidClient = frostfsIDSubjectProvider
 	c.cfgContainer.containerBatchSize = containerconfig.ContainerBatchSize(c.appCfg)
 
 	defaultChainRouter := engine.NewDefaultChainRouterWithLocalOverrides(
@@ -57,7 +57,7 @@ func initContainerService(_ context.Context, c *cfg) {
 	service := containerService.NewSignService(
 		&c.key.PrivateKey,
 		containerService.NewAPEServer(defaultChainRouter, cnrRdr,
-			newCachedIRFetcher(createInnerRingFetcher(c)), c.netMapSource, c.frostfsidClient,
+			newCachedIRFetcher(createInnerRingFetcher(c)), c.netMapSource, c.shared.frostfsidClient,
 			containerService.NewSplitterService(
 				c.cfgContainer.containerBatchSize, c.respSvc,
 				containerService.NewExecutionService(containerMorph.NewExecutor(cnrRdr, cnrWrt), c.respSvc)),