[#123] Resolve funlen linter issue

Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>

.forgejo/workflows/dco.yml

@@ -0,0 +1,21 @@
+name: DCO action
+on: [pull_request]
+
+jobs:
+  dco:
+    name: DCO
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.23'
+
+      - name: Run commit format checker
+        uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3
+        with:
+          from: 'origin/${{ github.event.pull_request.base.ref }}'

.forgejo/workflows/tests.yml

@@ -0,0 +1,54 @@
+name: Tests and linters
+on: [pull_request]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.23'
+          cache: true
+
+      - name: golangci-lint
+        uses: https://github.com/golangci/golangci-lint-action@v3
+        with:
+          version: latest
+
+  tests:
+    name: Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go_versions: [ '1.22', '1.23' ]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '${{ matrix.go_versions }}'
+          cache: true
+
+      - name: Run tests
+        run: make test
+
+  tests-race:
+    name: Tests with -race
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.23'
+          cache: true
+
+      - name: Run tests
+        run: go test ./... -count=1 -race

.gitignore

@@ -1,4 +1,3 @@
 .idea
 bin
 temp
-/vendor/

.gitlint

@@ -1,10 +0,0 @@
-[general]
-fail-without-commits=true
-contrib=CC1
-
-[title-match-regex]
-regex=^\[\#[0-9Xx]+\]\s
-
-[ignore-by-title]
-regex=^Release(.*)
-ignore=title-match-regex

.golangci.yml

@@ -9,13 +9,11 @@ run:
   # include test files or not, default is true
   tests: false
 
-  skip-files:
-    - (^|.*/)grpc/(.*)
-
 # output configuration options
 output:
   # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
-  format: tab
+  formats:
+    - format: tab
 
 # all available settings of specific linters
 linters-settings:
@@ -52,7 +50,7 @@ linters:
     - bidichk
     - durationcheck
     - exhaustive
-    - exportloopref
+    - copyloopvar
     - gofmt
     - goimports
     - misspell
@@ -67,6 +65,9 @@ linters:
   fast: false
 
 issues:
+  exclude-files:
+    - (^|.*/)grpc/(.*)
+
   # Excluding configuration per-path, per-linter, per-text and per-source
   exclude-rules:
     - path: v2 # ignore stutters in universal structures due to protobuf compatibility

.pre-commit-config.yaml

@@ -18,13 +18,25 @@ repos:
     - id: end-of-file-fixer
       exclude: ".key$"
 
+  - repo: local
+    hooks:
+       - id: gofumpt
+         name: gofumpt
+         entry: make fumpt
+         pass_filenames: false
+         types: [go]
+         language: system
+
+  - repo: local
+    hooks:
+       - id: go-unit-tests
+         name: go unit tests
+         entry: make test GOFLAGS=''
+         pass_filenames: false
+         types: [go]
+         language: system
+
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.51.2
+    rev: v1.60.3
     hooks:
     - id: golangci-lint
-
-  - repo: https://github.com/jorisroovers/gitlint
-    rev:  v0.18.0
-    hooks:
-      - id: gitlint
-        stages: [commit-msg]

CHANGELOG.md

@@ -2,11 +2,23 @@
 
 ## [Unreleased]
 
+### Added
+### Fixed
+### Changed
+### Removed
+### Updated
+
+## [2.16.0] - 2023-09-14 - Academy of Sciences Glacier
+
 ### Added
 - Add impersonate flag to bearer token (#17)
+- `NOT` and `UNIQUE` keywords to the placement policy (#26)
+- `PutSingle` RPC (#45)
 
 ### Fixed
 ### Changed
+- `StableSize()` is optimized and no does no allocations (#49)
+- Marshaling code now uses `protowire` package (#50)
 ### Removed
 - Reputation system (#21)
 
@@ -35,4 +47,4 @@ Initial public release.
 This project is a fork of [NeoFS](https://github.com/nspcc-dev/neofs-api-go) from version v2.14.0.
 To see CHANGELOG for older versions, refer to https://github.com/nspcc-dev/neofs-api-go/blob/master/CHANGELOG.md.
 
-[Unreleased]: https://github.com/TrueCloudLab/compare/v2.15.0...master
+[Unreleased]: https://git.frostfs.info/TrueCloudLab/frostfs-api-go/compare/v2.16.0...master

CONTRIBUTING.md

@@ -3,8 +3,8 @@
 First, thank you for contributing! We love and encourage pull requests from
 everyone. Please follow the guidelines:
 
-- Check the open [issues](https://github.com/TrueCloudLab/frostfs-api-go/issues) and
+- Check the open [issues](https://git.frostfs.info/TrueCloudLab/frostfs-api-go/issues) and
-  [pull requests](https://github.com/TrueCloudLab/frostfs-api-go/pulls) for existing
+  [pull requests](https://git.frostfs.info/TrueCloudLab/frostfs-api-go/pulls) for existing
   discussions.
 
 - Open an issue first, to discuss a new feature or enhancement.
@@ -26,18 +26,18 @@ send a pull request. We encourage pull requests to discuss code changes. Here
 are the steps in details:
 
 ### Set up your GitHub Repository
-Fork [FrostFS node upstream](https://github.com/TrueCloudLab/frostfs-api-go/fork) source
+Fork [FrostFS node upstream](https://git.frostfs.info/TrueCloudLab/frostfs-api-go/fork) source
 repository to your own personal repository. Copy the URL of your fork (you will
 need it for the `git clone` command below).
 
 ```sh
-$ git clone https://github.com/TrueCloudLab/frostfs-api-go
+$ git clone https://git.frostfs.info/TrueCloudLab/frostfs-api-go
 ```
 
 ### Set up git remote as ``upstream``
 ```sh
 $ cd frostfs-api-go
-$ git remote add upstream https://github.com/TrueCloudLab/frostfs-api-go
+$ git remote add upstream https://git.frostfs.info/TrueCloudLab/frostfs-api-go
 $ git fetch upstream
 $ git merge upstream/master
 ...

Makefile

@@ -2,61 +2,95 @@
 SHELL = bash
 
 VERSION ?= $(shell git describe --tags --match "v*" --abbrev=8 --dirty --always)
+PROTOC_VERSION ?= 27.2
+PROTOC_GEN_GO_VERSION ?= $(shell go list -f '{{.Version}}' -m google.golang.org/protobuf)
+PROTOC_OS_VERSION=osx-x86_64
+ifeq ($(shell uname), Linux)
+	PROTOC_OS_VERSION=linux-x86_64
+endif
 
-.PHONY: dep fmts fmt imports protoc test lint version help
+BIN = bin
+PROTOBUF_DIR ?= $(abspath $(BIN))/protobuf
+PROTOC_DIR ?= $(PROTOBUF_DIR)/protoc-v$(PROTOC_VERSION)
+PROTOC_GEN_GO_DIR ?= $(PROTOBUF_DIR)/protoc-gen-go-$(PROTOC_GEN_GO_VERSION)
+
+.PHONY: dep fmts fumpt imports protoc test lint version help $(BIN)/protogen protoc-test
 
 # Pull go dependencies
 dep:
 	@printf "⇒ Tidy requirements : "
 	CGO_ENABLED=0 \
-	GO111MODULE=on \
 	go mod tidy -v && echo OK
 	@printf "⇒ Download requirements: "
 	CGO_ENABLED=0 \
-	GO111MODULE=on \
 	go mod download && echo OK
 	@printf "⇒ Install test requirements: "
 	CGO_ENABLED=0 \
-	GO111MODULE=on \
 	go test ./... && echo OK
 
 # Run all code formatters
-fmts: fmt imports
+fmts: fumpt imports
-
-# Reformat code
-fmt:
-	@echo "⇒ Processing gofmt check"
-	@for f in `find . -type f -name '*.go' -not -path './vendor/*' -not -name '*.pb.go' -prune`; do \
-		GO111MODULE=on gofmt -s -w $$f; \
-	done
 
 # Reformat imports
 imports:
 	@echo "⇒ Processing goimports check"
-	@for f in `find . -type f -name '*.go' -not -path './vendor/*' -not -name '*.pb.go' -prune`; do \
+	@for f in `find . -type f -name '*.go' -not -name '*.pb.go' -prune`; do \
-		GO111MODULE=on goimports -w $$f; \
+		goimports -w $$f; \
 	done
 
+# Run gofumpt
+fumpt:
+	@echo "⇒ Processing gofumpt check"
+	@gofumpt -l -w .
+
+# Install protoc
+protoc-install:
+	@rm -rf $(PROTOBUF_DIR)
+	@mkdir -p $(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)
+	@rm $(PROTOBUF_DIR)/protoc-$(PROTOC_VERSION).zip
+	@echo "⇒ Installing protoc-gen-go..."
+	@GOBIN=$(PROTOC_GEN_GO_DIR) go install -v google.golang.org/protobuf/...@$(PROTOC_GEN_GO_VERSION)
+
+
 # Regenerate code for proto files
 protoc:
-	@GOPRIVATE=github.com/TrueCloudLab go mod vendor
+	@if [ ! -d "$(PROTOC_DIR)" ] || [ ! -d "$(PROTOC_GEN_GO_DIR)" ]; then \
-	# Install specific version for protobuf lib
+		make protoc-install; \
-	@go list -f '{{.Path}}/...@{{.Version}}' -m  google.golang.org/protobuf | xargs go install -v
+	fi
 	# Protoc generate
-	@for f in `find . -type f -name '*.proto' -not -path './vendor/*'`; do \
+	@for f in `find . -type f -name '*.proto' -not -path './bin/*' -not -path './util/proto/test/*'`; do \
 		echo "⇒ Processing $$f "; \
-		protoc \
+		$(PROTOC_DIR)/bin/protoc \
-			--proto_path=.:./vendor:/usr/local/include \
+			--proto_path=.:$(PROTOC_DIR)/include:/usr/local/include \
-			--go_out=. --go_opt=paths=source_relative \
+			--plugin=protoc-gen-go-frostfs=$(abspath ./bin/protogen) \
+			--go-frostfs_out=fuzz=true:. \
+			--go-frostfs_opt=paths=source_relative \
 			--go-grpc_opt=require_unimplemented_servers=false \
 			--go-grpc_out=. --go-grpc_opt=paths=source_relative $$f; \
 	done
-	rm -rf vendor
+
+$(BIN)/protogen:
+	@go build -v -trimpath \
+		-o $(BIN)/protogen \
+		./util/protogen
+
+protoc-test: protoc $(BIN)/protogen
+	@$(PROTOC_DIR)/bin/protoc \
+			--go_out=. --go_opt=paths=source_relative \
+			--plugin=protoc-gen-go-frostfs=$(abspath $(BIN)/protogen) \
+			--go-frostfs_opt=Mutil/proto/test/test.proto=git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto/test/custom \
+			--go-frostfs_opt=module=git.frostfs.info/TrueCloudLab/frostfs-api-go/v2 \
+			--go-frostfs_out=. --go-frostfs_opt=paths=import \
+			./util/proto/test/test.proto
 
 # Run Unit Test with go test
+test: GOFLAGS ?= "-count=1"
 test:
 	@echo "⇒ Running go test"
-	@GO111MODULE=on go test ./...
+	@GOFLAGS="$(GOFLAGS)" go test ./...
 
 # Run linters
 lint:

README.md

@@ -6,22 +6,20 @@
 </p>
 
 ---
-![Tests](https://github.com/TrueCloudLab/frostfs-api-go/workflows/frostfs-api-go%20tests/badge.svg)
+![Tests](https://git.frostfs.info/TrueCloudLab/frostfs-api-go/badges/workflows/tests.yml/badge.svg)
-[![codecov](https://codecov.io/gh/TrueCloudLab/frostfs-api-go/branch/master/graph/badge.svg)](https://codecov.io/gh/TrueCloudLab/frostfs-api-go)
+[![Report](https://goreportcard.com/badge/git.frostfs.info/TrueCloudLab/frostfs-api-go)](https://goreportcard.com/report/git.frostfs.info/TrueCloudLab/frostfs-api-go)
-[![Report](https://goreportcard.com/badge/github.com/TrueCloudLab/frostfs-api-go)](https://goreportcard.com/report/github.com/TrueCloudLab/frostfs-api-go)
+[![Release](https://git.frostfs.info/TrueCloudLab/frostfs-api-go/badges/release.svg)](https://git.frostfs.info/TrueCloudLab/frostfs-api-go)
-[![GitHub release](https://img.shields.io/github/release/TrueCloudLab/frostfs-api-go.svg)](https://github.com/TrueCloudLab/frostfs-api-go)
-![GitHub license](https://img.shields.io/github/license/TrueCloudLab/frostfs-api-go.svg?style=popout)
 
 # Overview
 
-Go implementation of recent [FrostFS API](https://github.com/TrueCloudLab/frostfs-api)
+Go implementation of recent [FrostFS API](https://git.frostfs.info/TrueCloudLab/frostfs-api)
-versions. For a more high-level SDK see [FrostFS SDK](https://github.com/TrueCloudLab/frostfs-sdk-go).
+versions. For a more high-level SDK see [FrostFS SDK](https://git.frostfs.info/TrueCloudLab/frostfs-sdk-go).
 
 ## Frostfs-Api compatibility
 
 |frostfs-api-go version|supported frostfs-api versions|
 |:------------------:|:--------------------------:|
-|v2.14.x|[v2.14.0](https://github.com/TrueCloudLab/frostfs-api/releases/tag/v2.14.0)|
+|v2.14.x|[v2.14.0](https://git.frostfs.info/TrueCloudLab/frostfs-api/releases/tag/v2.14.0)|
 
 ## Contributing
 

accounting/grpc/service.go

@@ -1,46 +0,0 @@
-package accounting
-
-import (
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-	session "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/grpc"
-)
-
-// SetOwnerId sets identifier of the account owner.
-func (m *BalanceRequest_Body) SetOwnerId(v *refs.OwnerID) {
-	m.OwnerId = v
-}
-
-// SetBody sets body of the request.
-func (m *BalanceRequest) SetBody(v *BalanceRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *BalanceRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *BalanceRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetBalance sets balance value of the response.
-func (m *BalanceResponse_Body) SetBalance(v *Decimal) {
-	m.Balance = v
-}
-
-// SetBody sets body of the response.
-func (m *BalanceResponse) SetBody(v *BalanceResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *BalanceResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *BalanceResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}

accounting/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,45 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+func DoFuzzProtoBalanceRequest(data []byte) int {
+	msg := new(BalanceRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBalanceRequest(data []byte) int {
+	msg := new(BalanceRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoBalanceResponse(data []byte) int {
+	msg := new(BalanceResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBalanceResponse(data []byte) int {
+	msg := new(BalanceResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

accounting/grpc/service_frostfs_test.go

@@ -0,0 +1,31 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoBalanceRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBalanceRequest(data)
+	})
+}
+func FuzzJSONBalanceRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBalanceRequest(data)
+	})
+}
+func FuzzProtoBalanceResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBalanceResponse(data)
+	})
+}
+func FuzzJSONBalanceResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBalanceResponse(data)
+	})
+}

accounting/grpc/types.go

@@ -1,11 +0,0 @@
-package accounting
-
-// SetValue sets value of the decimal number.
-func (m *Decimal) SetValue(v int64) {
-	m.Value = v
-}
-
-// SetPrecision sets precision of the decimal number.
-func (m *Decimal) SetPrecision(v uint32) {
-	m.Precision = v
-}

accounting/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+func DoFuzzProtoDecimal(data []byte) int {
+	msg := new(Decimal)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDecimal(data []byte) int {
+	msg := new(Decimal)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

accounting/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package accounting
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoDecimal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDecimal(data)
+	})
+}
+func FuzzJSONDecimal(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDecimal(data)
+	})
+}

acl/bench_test.go

@@ -32,7 +32,7 @@ func BenchmarkTable_ToGRPCMessage(b *testing.B) {
 
 	b.Run("to grpc message", func(b *testing.B) {
 		b.ReportAllocs()
-		for i := 0; i < b.N; i++ {
+		for range b.N {
 			raw := tb.ToGRPCMessage()
 			if len(tb.GetRecords()) != len(raw.(*aclGrpc.EACLTable).Records) {
 				b.FailNow()
@@ -41,7 +41,7 @@ func BenchmarkTable_ToGRPCMessage(b *testing.B) {
 	})
 	b.Run("from grpc message", func(b *testing.B) {
 		b.ReportAllocs()
-		for i := 0; i < b.N; i++ {
+		for range b.N {
 			tb := new(acl.Table)
 			if tb.FromGRPCMessage(raw) != nil {
 				b.FailNow()

acl/convert.go

@@ -2,6 +2,8 @@ package acl
 
 import (
 	acl "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape"
+	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
 	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
@@ -164,7 +166,7 @@ func (f *HeaderFilter) ToGRPCMessage() grpc.Message {
 
 		m.SetKey(f.key)
 		m.SetValue(f.value)
-		m.SetHeader(HeaderTypeToGRPCField(f.hdrType))
+		m.SetHeaderType(HeaderTypeToGRPCField(f.hdrType))
 		m.SetMatchType(MatchTypeToGRPCField(f.matchType))
 	}
 
@@ -185,28 +187,26 @@ func (f *HeaderFilter) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func HeaderFiltersToGRPC(fs []HeaderFilter) (res []*acl.EACLRecord_Filter) {
+func HeaderFiltersToGRPC(fs []HeaderFilter) (res []acl.EACLRecord_Filter) {
 	if fs != nil {
-		res = make([]*acl.EACLRecord_Filter, 0, len(fs))
+		res = make([]acl.EACLRecord_Filter, 0, len(fs))
 
 		for i := range fs {
-			res = append(res, fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
+			res = append(res, *fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
 		}
 	}
 
 	return
 }
 
-func HeaderFiltersFromGRPC(fs []*acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
+func HeaderFiltersFromGRPC(fs []acl.EACLRecord_Filter) (res []HeaderFilter, err error) {
 	if fs != nil {
 		res = make([]HeaderFilter, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
+			err = res[i].FromGRPCMessage(&fs[i])
-				err = res[i].FromGRPCMessage(fs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -239,28 +239,26 @@ func (t *Target) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func TargetsToGRPC(ts []Target) (res []*acl.EACLRecord_Target) {
+func TargetsToGRPC(ts []Target) (res []acl.EACLRecord_Target) {
 	if ts != nil {
-		res = make([]*acl.EACLRecord_Target, 0, len(ts))
+		res = make([]acl.EACLRecord_Target, 0, len(ts))
 
 		for i := range ts {
-			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
 		}
 	}
 
 	return
 }
 
-func TargetsFromGRPC(fs []*acl.EACLRecord_Target) (res []Target, err error) {
+func TargetsFromGRPC(fs []acl.EACLRecord_Target) (res []Target, err error) {
 	if fs != nil {
 		res = make([]Target, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
+			err = res[i].FromGRPCMessage(&fs[i])
-				err = res[i].FromGRPCMessage(fs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -307,28 +305,26 @@ func (r *Record) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func RecordsToGRPC(ts []Record) (res []*acl.EACLRecord) {
+func RecordsToGRPC(ts []Record) (res []acl.EACLRecord) {
 	if ts != nil {
-		res = make([]*acl.EACLRecord, 0, len(ts))
+		res = make([]acl.EACLRecord, 0, len(ts))
 
 		for i := range ts {
-			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord))
+			res = append(res, *ts[i].ToGRPCMessage().(*acl.EACLRecord))
 		}
 	}
 
 	return
 }
 
-func RecordsFromGRPC(fs []*acl.EACLRecord) (res []Record, err error) {
+func RecordsFromGRPC(fs []acl.EACLRecord) (res []Record, err error) {
 	if fs != nil {
 		res = make([]Record, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
+			err = res[i].FromGRPCMessage(&fs[i])
-				err = res[i].FromGRPCMessage(fs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -418,6 +414,54 @@ func (l *TokenLifetime) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
+func (c *APEOverride) ToGRPCMessage() grpc.Message {
+	var m *acl.BearerToken_Body_APEOverride
+
+	if c != nil {
+		m = new(acl.BearerToken_Body_APEOverride)
+
+		m.SetTarget(c.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+
+		if len(c.chains) > 0 {
+			apeChains := make([]apeGRPC.Chain, len(c.chains))
+			for i := range c.chains {
+				apeChains[i] = *c.chains[i].ToGRPCMessage().(*apeGRPC.Chain)
+			}
+			m.SetChains(apeChains)
+		}
+	}
+
+	return m
+}
+
+func (c *APEOverride) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*acl.BearerToken_Body_APEOverride)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	if targetGRPC := v.GetTarget(); targetGRPC != nil {
+		if c.target == nil {
+			c.target = new(ape.ChainTarget)
+		}
+		if err := c.target.FromGRPCMessage(v.GetTarget()); err != nil {
+			return err
+		}
+	}
+
+	if apeChains := v.GetChains(); len(apeChains) > 0 {
+		c.chains = make([]*ape.Chain, len(apeChains))
+		for i := range apeChains {
+			c.chains[i] = new(ape.Chain)
+			if err := c.chains[i].FromGRPCMessage(&apeChains[i]); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
 func (bt *BearerTokenBody) ToGRPCMessage() grpc.Message {
 	var m *acl.BearerToken_Body
 
@@ -427,7 +471,8 @@ func (bt *BearerTokenBody) ToGRPCMessage() grpc.Message {
 		m.SetOwnerId(bt.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
 		m.SetLifetime(bt.lifetime.ToGRPCMessage().(*acl.BearerToken_Body_TokenLifetime))
 		m.SetEaclTable(bt.eacl.ToGRPCMessage().(*acl.EACLTable))
-		m.SetImpersonate(bt.impersonate)
+		m.SetAllowImpersonate(bt.impersonate)
+		m.SetApeOverride(bt.apeOverride.ToGRPCMessage().(*acl.BearerToken_Body_APEOverride))
 	}
 
 	return m
@@ -477,7 +522,19 @@ func (bt *BearerTokenBody) FromGRPCMessage(m grpc.Message) error {
 			bt.eacl = new(Table)
 		}
 
-		err = bt.eacl.FromGRPCMessage(eacl)
+		if err = bt.eacl.FromGRPCMessage(eacl); err != nil {
+			return err
+		}
+	}
+
+	if apeOverrideGRPC := v.GetApeOverride(); apeOverrideGRPC != nil {
+		if bt.apeOverride == nil {
+			bt.apeOverride = new(APEOverride)
+		}
+		err = bt.apeOverride.FromGRPCMessage(apeOverrideGRPC)
+		if err != nil {
+			return err
+		}
 	}
 
 	bt.impersonate = v.GetAllowImpersonate()

acl/grpc/types.go

@@ -1,180 +0,0 @@
-package acl
-
-import (
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-)
-
-// SetVersion sets version of EACL rules in table.
-func (m *EACLTable) SetVersion(v *refs.Version) {
-	m.Version = v
-}
-
-// SetContainerId sets container identifier of the eACL table.
-func (m *EACLTable) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetRecords sets record list of the eACL table.
-func (m *EACLTable) SetRecords(v []*EACLRecord) {
-	m.Records = v
-}
-
-// SetOperation sets operation of the eACL record.
-func (m *EACLRecord) SetOperation(v Operation) {
-	m.Operation = v
-}
-
-// SetAction sets action of the eACL record.
-func (m *EACLRecord) SetAction(v Action) {
-	m.Action = v
-}
-
-// SetFilters sets filter list of the eACL record.
-func (m *EACLRecord) SetFilters(v []*EACLRecord_Filter) {
-	m.Filters = v
-}
-
-// SetTargets sets target list of the eACL record.
-func (m *EACLRecord) SetTargets(v []*EACLRecord_Target) {
-	m.Targets = v
-}
-
-// SetHeader sets header type of the eACL filter.
-func (m *EACLRecord_Filter) SetHeader(v HeaderType) {
-	m.HeaderType = v
-}
-
-// SetMatchType sets match type of the eACL filter.
-func (m *EACLRecord_Filter) SetMatchType(v MatchType) {
-	m.MatchType = v
-}
-
-// SetKey sets key of the eACL filter.
-func (m *EACLRecord_Filter) SetKey(v string) {
-	m.Key = v
-}
-
-// SetValue sets value of the eACL filter.
-func (m *EACLRecord_Filter) SetValue(v string) {
-	m.Value = v
-}
-
-// SetRole sets target group of the eACL target.
-func (m *EACLRecord_Target) SetRole(v Role) {
-	m.Role = v
-}
-
-// SetKeys of the eACL target.
-func (m *EACLRecord_Target) SetKeys(v [][]byte) {
-	m.Keys = v
-}
-
-// SetEaclTable sets eACL table of the bearer token.
-func (m *BearerToken_Body) SetEaclTable(v *EACLTable) {
-	m.EaclTable = v
-}
-
-// SetOwnerId sets identifier of the bearer token owner.
-func (m *BearerToken_Body) SetOwnerId(v *refs.OwnerID) {
-	m.OwnerId = v
-}
-
-// SetLifetime sets lifetime of the bearer token.
-func (m *BearerToken_Body) SetLifetime(v *BearerToken_Body_TokenLifetime) {
-	m.Lifetime = v
-}
-
-// SetImpersonate allows impersonate.
-func (m *BearerToken_Body) SetImpersonate(v bool) {
-	m.AllowImpersonate = v
-}
-
-// SetBody sets bearer token body.
-func (m *BearerToken) SetBody(v *BearerToken_Body) {
-	m.Body = v
-}
-
-// SetSignature sets bearer token signature.
-func (m *BearerToken) SetSignature(v *refs.Signature) {
-	m.Signature = v
-}
-
-// SetExp sets epoch number of the token expiration.
-func (m *BearerToken_Body_TokenLifetime) SetExp(v uint64) {
-	m.Exp = v
-}
-
-// SetNbf sets starting epoch number of the token.
-func (m *BearerToken_Body_TokenLifetime) SetNbf(v uint64) {
-	m.Nbf = v
-}
-
-// SetIat sets the number of the epoch in which the token was issued.
-func (m *BearerToken_Body_TokenLifetime) SetIat(v uint64) {
-	m.Iat = v
-}
-
-// FromString parses Action from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *Action) FromString(s string) bool {
-	i, ok := Action_value[s]
-	if ok {
-		*x = Action(i)
-	}
-
-	return ok
-}
-
-// FromString parses Role from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *Role) FromString(s string) bool {
-	i, ok := Role_value[s]
-	if ok {
-		*x = Role(i)
-	}
-
-	return ok
-}
-
-// FromString parses Operation from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *Operation) FromString(s string) bool {
-	i, ok := Operation_value[s]
-	if ok {
-		*x = Operation(i)
-	}
-
-	return ok
-}
-
-// FromString parses MatchType from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *MatchType) FromString(s string) bool {
-	i, ok := MatchType_value[s]
-	if ok {
-		*x = MatchType(i)
-	}
-
-	return ok
-}
-
-// FromString parses HeaderType from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *HeaderType) FromString(s string) bool {
-	i, ok := HeaderType_value[s]
-	if ok {
-		*x = HeaderType(i)
-	}
-
-	return ok
-}

acl/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,64 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package acl
+
+func DoFuzzProtoEACLRecord(data []byte) int {
+	msg := new(EACLRecord)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONEACLRecord(data []byte) int {
+	msg := new(EACLRecord)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoEACLTable(data []byte) int {
+	msg := new(EACLTable)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONEACLTable(data []byte) int {
+	msg := new(EACLTable)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoBearerToken(data []byte) int {
+	msg := new(BearerToken)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONBearerToken(data []byte) int {
+	msg := new(BearerToken)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

acl/grpc/types_frostfs_test.go

@@ -0,0 +1,41 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package acl
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoEACLRecord(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoEACLRecord(data)
+	})
+}
+func FuzzJSONEACLRecord(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONEACLRecord(data)
+	})
+}
+func FuzzProtoEACLTable(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoEACLTable(data)
+	})
+}
+func FuzzJSONEACLTable(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONEACLTable(data)
+	})
+}
+func FuzzProtoBearerToken(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoBearerToken(data)
+	})
+}
+func FuzzJSONBearerToken(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONBearerToken(data)
+	})
+}

acl/json.go

@@ -21,6 +21,14 @@ func (t *Target) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(t, data, new(acl.EACLRecord_Target))
 }
 
+func (a *APEOverride) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(a)
+}
+
+func (a *APEOverride) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(a, data, new(acl.BearerToken_Body_APEOverride))
+}
+
 func (r *Record) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(r)
 }

acl/marshal.go

@@ -28,10 +28,14 @@ const (
 	lifetimeNotValidBeforeField = 2
 	lifetimeIssuedAtField       = 3
 
-	bearerTokenBodyACLField      = 1
+	tokenAPEChainsTargetField = 1
-	bearerTokenBodyOwnerField    = 2
+	tokenAPEChainsChainsField = 2
-	bearerTokenBodyLifetimeField = 3
+
-	bearerTokenBodyImpersonate   = 4
+	bearerTokenBodyACLField        = 1
+	bearerTokenBodyOwnerField      = 2
+	bearerTokenBodyLifetimeField   = 3
+	bearerTokenBodyImpersonate     = 4
+	bearerTokenTokenAPEChainsField = 5
 
 	bearerTokenBodyField      = 1
 	bearerTokenSignatureField = 2
@@ -239,6 +243,42 @@ func (l *TokenLifetime) Unmarshal(data []byte) error {
 	return message.Unmarshal(l, data, new(acl.BearerToken_Body_TokenLifetime))
 }
 
+func (c *APEOverride) StableMarshal(buf []byte) []byte {
+	if c == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, c.StableSize())
+	}
+
+	var offset int
+
+	offset += protoutil.NestedStructureMarshal(tokenAPEChainsTargetField, buf[offset:], c.target)
+	for i := range c.chains {
+		offset += protoutil.NestedStructureMarshal(tokenAPEChainsChainsField, buf[offset:], c.chains[i])
+	}
+
+	return buf
+}
+
+func (c *APEOverride) StableSize() (size int) {
+	if c == nil {
+		return 0
+	}
+
+	size += protoutil.NestedStructureSize(tokenAPEChainsTargetField, c.target)
+	for i := range c.chains {
+		size += protoutil.NestedStructureSize(tokenAPEChainsChainsField, c.chains[i])
+	}
+
+	return size
+}
+
+func (c *APEOverride) Unmarshal(data []byte) error {
+	return message.Unmarshal(c, data, new(acl.BearerToken_Body_APEOverride))
+}
+
 func (bt *BearerTokenBody) StableMarshal(buf []byte) []byte {
 	if bt == nil {
 		return []byte{}
@@ -253,7 +293,8 @@ func (bt *BearerTokenBody) StableMarshal(buf []byte) []byte {
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyACLField, buf[offset:], bt.eacl)
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyOwnerField, buf[offset:], bt.ownerID)
 	offset += protoutil.NestedStructureMarshal(bearerTokenBodyLifetimeField, buf[offset:], bt.lifetime)
-	protoutil.BoolMarshal(bearerTokenBodyImpersonate, buf[offset:], bt.impersonate)
+	offset += protoutil.BoolMarshal(bearerTokenBodyImpersonate, buf[offset:], bt.impersonate)
+	protoutil.NestedStructureMarshal(bearerTokenTokenAPEChainsField, buf[offset:], bt.apeOverride)
 
 	return buf
 }
@@ -267,6 +308,7 @@ func (bt *BearerTokenBody) StableSize() (size int) {
 	size += protoutil.NestedStructureSize(bearerTokenBodyOwnerField, bt.ownerID)
 	size += protoutil.NestedStructureSize(bearerTokenBodyLifetimeField, bt.lifetime)
 	size += protoutil.BoolSize(bearerTokenBodyImpersonate, bt.impersonate)
+	size += protoutil.NestedStructureSize(bearerTokenTokenAPEChainsField, bt.apeOverride)
 
 	return size
 }

acl/test/generate.go

@@ -2,6 +2,7 @@ package acltest
 
 import (
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl"
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/test"
 	accountingtest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/test"
 )
 
@@ -22,8 +23,20 @@ func GenerateBearerTokenBody(empty bool) *acl.BearerTokenBody {
 
 	if !empty {
 		m.SetOwnerID(accountingtest.GenerateOwnerID(false))
-		m.SetEACL(GenerateTable(false))
 		m.SetLifetime(GenerateTokenLifetime(false))
+		m.SetAPEOverride(GenerateAPEOverride(empty))
+	}
+
+	return m
+}
+
+func GenerateAPEOverride(empty bool) *acl.APEOverride {
+	var m *acl.APEOverride
+
+	if !empty {
+		m = new(acl.APEOverride)
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+		m.SetChains(apetest.GenerateRawChains(false, 3))
 	}
 
 	return m

acl/types.go

@@ -1,6 +1,9 @@
 package acl
 
-import "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
+)
 
 // HeaderFilter is a unified structure of FilterInfo
 // message from proto definition.
@@ -46,6 +49,12 @@ type TokenLifetime struct {
 	exp, nbf, iat uint64
 }
 
+type APEOverride struct {
+	target *ape.ChainTarget
+
+	chains []*ape.Chain
+}
+
 type BearerTokenBody struct {
 	eacl *Table
 
@@ -53,6 +62,8 @@ type BearerTokenBody struct {
 
 	lifetime *TokenLifetime
 
+	apeOverride *APEOverride
+
 	impersonate bool
 }
 
@@ -318,6 +329,42 @@ func (bt *BearerTokenBody) SetEACL(v *Table) {
 	bt.eacl = v
 }
 
+func (t *APEOverride) GetTarget() *ape.ChainTarget {
+	if t == nil {
+		return nil
+	}
+
+	return t.target
+}
+
+func (t *APEOverride) GetChains() []*ape.Chain {
+	if t == nil {
+		return nil
+	}
+
+	return t.chains
+}
+
+func (t *APEOverride) SetTarget(v *ape.ChainTarget) {
+	t.target = v
+}
+
+func (t *APEOverride) SetChains(v []*ape.Chain) {
+	t.chains = v
+}
+
+func (bt *BearerTokenBody) GetAPEOverride() *APEOverride {
+	if bt != nil {
+		return bt.apeOverride
+	}
+
+	return nil
+}
+
+func (bt *BearerTokenBody) SetAPEOverride(v *APEOverride) {
+	bt.apeOverride = v
+}
+
 func (bt *BearerTokenBody) GetOwnerID() *refs.OwnerID {
 	if bt != nil {
 		return bt.ownerID

ape/convert.go

@@ -0,0 +1,132 @@
+package ape
+
+import (
+	"fmt"
+
+	ape "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+)
+
+func TargetTypeToGRPCField(typ TargetType) ape.TargetType {
+	switch typ {
+	case TargetTypeNamespace:
+		return ape.TargetType_NAMESPACE
+	case TargetTypeContainer:
+		return ape.TargetType_CONTAINER
+	case TargetTypeUser:
+		return ape.TargetType_USER
+	case TargetTypeGroup:
+		return ape.TargetType_GROUP
+	default:
+		return ape.TargetType_UNDEFINED
+	}
+}
+
+func TargetTypeFromGRPCField(typ ape.TargetType) TargetType {
+	switch typ {
+	case ape.TargetType_NAMESPACE:
+		return TargetTypeNamespace
+	case ape.TargetType_CONTAINER:
+		return TargetTypeContainer
+	case ape.TargetType_USER:
+		return TargetTypeUser
+	case ape.TargetType_GROUP:
+		return TargetTypeGroup
+	default:
+		return TargetTypeUndefined
+	}
+}
+
+func TargetTypeToGRPC(typ TargetType) ape.TargetType {
+	return ape.TargetType(typ)
+}
+
+func TargetTypeFromGRPC(typ ape.TargetType) TargetType {
+	return TargetType(typ)
+}
+
+func (v2 *ChainTarget) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.ChainTarget
+
+	if v2 != nil {
+		mgrpc = new(ape.ChainTarget)
+
+		mgrpc.SetType(TargetTypeToGRPC(v2.GetTargetType()))
+		mgrpc.SetName(v2.GetName())
+	}
+
+	return mgrpc
+}
+
+func (v2 *ChainTarget) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.ChainTarget)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	v2.SetTargetType(TargetTypeFromGRPC(mgrpc.GetType()))
+	v2.SetName(mgrpc.GetName())
+
+	return nil
+}
+
+func (v2 *ChainRaw) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.Chain_Raw
+
+	if v2 != nil {
+		mgrpc = new(ape.Chain_Raw)
+
+		mgrpc.SetRaw(v2.GetRaw())
+	}
+
+	return mgrpc
+}
+
+func (v2 *ChainRaw) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.Chain_Raw)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	v2.SetRaw(mgrpc.GetRaw())
+
+	return nil
+}
+
+func (v2 *Chain) ToGRPCMessage() grpc.Message {
+	var mgrpc *ape.Chain
+
+	if v2 != nil {
+		mgrpc = new(ape.Chain)
+
+		switch chainKind := v2.GetKind().(type) {
+		default:
+			panic(fmt.Sprintf("unsupported chain kind: %T", chainKind))
+		case *ChainRaw:
+			mgrpc.SetKind(chainKind.ToGRPCMessage().(*ape.Chain_Raw))
+		}
+	}
+
+	return mgrpc
+}
+
+func (v2 *Chain) FromGRPCMessage(m grpc.Message) error {
+	mgrpc, ok := m.(*ape.Chain)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, mgrpc)
+	}
+
+	switch chainKind := mgrpc.GetKind().(type) {
+	default:
+		return fmt.Errorf("unsupported chain kind: %T", chainKind)
+	case *ape.Chain_Raw:
+		chainRaw := new(ChainRaw)
+		if err := chainRaw.FromGRPCMessage(chainKind); err != nil {
+			return err
+		}
+		v2.SetKind(chainRaw)
+	}
+
+	return nil
+}

ape/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,45 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+func DoFuzzProtoChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChainTarget(data []byte) int {
+	msg := new(ChainTarget)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONChain(data []byte) int {
+	msg := new(Chain)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

ape/grpc/types_frostfs_test.go

@@ -0,0 +1,31 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package ape
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChainTarget(data)
+	})
+}
+func FuzzJSONChainTarget(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChainTarget(data)
+	})
+}
+func FuzzProtoChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoChain(data)
+	})
+}
+func FuzzJSONChain(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONChain(data)
+	})
+}

ape/json.go

@@ -0,0 +1,14 @@
+package ape
+
+import (
+	ape "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+)
+
+func (t *ChainTarget) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(t)
+}
+
+func (t *ChainTarget) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(t, data, new(ape.ChainTarget))
+}

ape/marshal.go

@@ -0,0 +1,92 @@
+package ape
+
+import (
+	"fmt"
+
+	ape "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
+)
+
+const (
+	chainTargetTargetTypeField = 1
+	chainTargetNameField       = 2
+
+	chainRawField = 1
+)
+
+func (t *ChainTarget) StableSize() (size int) {
+	if t == nil {
+		return 0
+	}
+
+	size += proto.EnumSize(chainTargetTargetTypeField, int32(t.targeType))
+	size += proto.StringSize(chainTargetNameField, t.name)
+
+	return size
+}
+
+func (t *ChainTarget) StableMarshal(buf []byte) []byte {
+	if t == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, t.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.EnumMarshal(chainTargetTargetTypeField, buf[offset:], int32(t.targeType))
+	proto.StringMarshal(chainTargetNameField, buf[offset:], t.name)
+
+	return buf
+}
+
+func (t *ChainTarget) Unmarshal(data []byte) error {
+	return message.Unmarshal(t, data, new(ape.ChainTarget))
+}
+
+func (c *Chain) StableSize() (size int) {
+	if c == nil {
+		return 0
+	}
+
+	switch v := c.GetKind().(type) {
+	case *ChainRaw:
+		if v != nil {
+			size += proto.BytesSize(chainRawField, v.GetRaw())
+		}
+	default:
+		panic(fmt.Sprintf("unsupported chain kind: %T", v))
+	}
+
+	return size
+}
+
+func (c *Chain) StableMarshal(buf []byte) []byte {
+	if c == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, c.StableSize())
+	}
+
+	var offset int
+
+	switch v := c.GetKind().(type) {
+	case *ChainRaw:
+		if v != nil {
+			proto.BytesMarshal(chainRawField, buf[offset:], v.GetRaw())
+		}
+	default:
+		panic(fmt.Sprintf("unsupported chain kind: %T", v))
+	}
+
+	return buf
+}
+
+func (c *Chain) Unmarshal(data []byte) error {
+	return message.Unmarshal(c, data, new(ape.Chain))
+}

ape/message_test.go

@@ -1,15 +1,15 @@
-package audit_test
+package ape_test
 
 import (
 	"testing"
 
-	audittest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/audit/test"
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/test"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
 	messagetest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message/test"
 )
 
 func TestMessageConvert(t *testing.T) {
 	messagetest.TestRPCMessage(t,
-		func(empty bool) message.Message { return audittest.GenerateDataAuditResult(empty) },
+		func(empty bool) message.Message { return apetest.GenerateChainTarget(empty) },
 	)
 }

ape/string.go

@@ -0,0 +1,18 @@
+package ape
+
+import (
+	apegrpc "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
+)
+
+func (tt TargetType) String() string {
+	return TargetTypeToGRPCField(tt).String()
+}
+
+func (tt *TargetType) FromString(s string) bool {
+	i, ok := apegrpc.TargetType_value[s]
+	if ok {
+		*tt = TargetType(i)
+	}
+
+	return ok
+}

ape/test/generate.go

@@ -0,0 +1,71 @@
+package test
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape"
+)
+
+func GenerateRawChains(empty bool, n int) []*ape.Chain {
+	if empty {
+		return []*ape.Chain{}
+	}
+
+	res := make([]*ape.Chain, n)
+	for i := range res {
+		res[i] = GenerateRawChain(empty)
+	}
+	return res
+}
+
+func GenerateRawChain(empty bool) *ape.Chain {
+	chRaw := new(ape.ChainRaw)
+
+	if empty {
+		chRaw.SetRaw([]byte("{}"))
+	} else {
+		chRaw.SetRaw([]byte(`{
+			"ID": "",
+			"Rules": [
+			  {
+				"Status": "Allow",
+				"Actions": {
+				  "Inverted": false,
+				  "Names": [
+					"GetObject"
+				  ]
+				},
+				"Resources": {
+				  "Inverted": false,
+				  "Names": [
+					"native:object/*"
+				  ]
+				},
+				"Any": false,
+				"Condition": [
+				  {
+					"Op": "StringEquals",
+					"Object": "Resource",
+					"Key": "Department",
+					"Value": "HR"
+				  }
+				]
+			  }
+			],
+			"MatchType": "DenyPriority"
+			}`))
+	}
+
+	ch := new(ape.Chain)
+	ch.SetKind(chRaw)
+	return ch
+}
+
+func GenerateChainTarget(empty bool) *ape.ChainTarget {
+	m := new(ape.ChainTarget)
+
+	if !empty {
+		m.SetTargetType(ape.TargetTypeContainer)
+		m.SetName("BzQw5HH3feoxFDD5tCT87Y1726qzgLfxEE7wgtoRzB3R")
+	}
+
+	return m
+}

ape/types.go

@@ -0,0 +1,79 @@
+package ape
+
+type TargetType uint32
+
+const (
+	TargetTypeUndefined TargetType = iota
+	TargetTypeNamespace
+	TargetTypeContainer
+	TargetTypeUser
+	TargetTypeGroup
+)
+
+type ChainTarget struct {
+	targeType TargetType
+
+	name string
+}
+
+func (ct *ChainTarget) SetTargetType(targeType TargetType) {
+	ct.targeType = targeType
+}
+
+func (ct *ChainTarget) SetName(name string) {
+	ct.name = name
+}
+
+func (ct *ChainTarget) GetTargetType() TargetType {
+	if ct != nil {
+		return ct.targeType
+	}
+
+	return 0
+}
+
+func (ct *ChainTarget) GetName() string {
+	if ct != nil {
+		return ct.name
+	}
+
+	return ""
+}
+
+type chainKind interface {
+	isChainKind()
+}
+
+type Chain struct {
+	kind chainKind
+}
+
+func (c *Chain) SetKind(kind chainKind) {
+	c.kind = kind
+}
+
+func (c *Chain) GetKind() chainKind {
+	if c == nil {
+		return nil
+	}
+
+	return c.kind
+}
+
+type ChainRaw struct {
+	Raw []byte
+}
+
+func (*ChainRaw) isChainKind() {}
+
+func (c *ChainRaw) SetRaw(raw []byte) {
+	c.Raw = raw
+}
+
+func (c *ChainRaw) GetRaw() []byte {
+	if c == nil {
+		return nil
+	}
+
+	return c.Raw
+}

apemanager/convert.go

@@ -0,0 +1,358 @@
+package apemanager
+
+import (
+	ape "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape"
+	apeGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/grpc"
+	apemanager "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+)
+
+func (reqBody *AddChainRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.AddChainRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.AddChainRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.GetTarget().ToGRPCMessage().(*apeGRPC.ChainTarget))
+		reqBodygrpc.SetChain(reqBody.GetChain().ToGRPCMessage().(*apeGRPC.Chain))
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *AddChainRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.AddChainRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	if chaingrpc := reqBodygrpc.GetChain(); chaingrpc != nil {
+		reqBody.chain = new(ape.Chain)
+		if err := reqBody.GetChain().FromGRPCMessage(chaingrpc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (req *AddChainRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.AddChainRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.AddChainRequest)
+
+		reqgrpc.SetBody(req.GetBody().ToGRPCMessage().(*apemanager.AddChainRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *AddChainRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.AddChainRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(AddChainRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *AddChainResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.AddChainResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.AddChainResponse_Body)
+
+		respBodygrpc.SetChainId(respBody.GetChainID())
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *AddChainResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.AddChainResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	respBody.SetChainID(respBodygrpc.GetChainId())
+
+	return nil
+}
+
+func (resp *AddChainResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.AddChainResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.AddChainResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.AddChainResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *AddChainResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.AddChainResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(AddChainResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}
+
+func (reqBody *RemoveChainRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.RemoveChainRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.RemoveChainRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+		reqBodygrpc.SetChainId(reqBody.GetChainID())
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *RemoveChainRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.RemoveChainRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	reqBody.SetChainID(reqBodygrpc.GetChainId())
+
+	return nil
+}
+
+func (req *RemoveChainRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.RemoveChainRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.RemoveChainRequest)
+
+		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.RemoveChainRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *RemoveChainRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.RemoveChainRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(RemoveChainRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *RemoveChainResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.RemoveChainResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.RemoveChainResponse_Body)
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *RemoveChainResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.RemoveChainResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	return nil
+}
+
+func (resp *RemoveChainResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.RemoveChainResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.RemoveChainResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.RemoveChainResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *RemoveChainResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.RemoveChainResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(RemoveChainResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}
+
+func (reqBody *ListChainsRequestBody) ToGRPCMessage() grpc.Message {
+	var reqBodygrpc *apemanager.ListChainsRequest_Body
+
+	if reqBody != nil {
+		reqBodygrpc = new(apemanager.ListChainsRequest_Body)
+
+		reqBodygrpc.SetTarget(reqBody.target.ToGRPCMessage().(*apeGRPC.ChainTarget))
+	}
+
+	return reqBodygrpc
+}
+
+func (reqBody *ListChainsRequestBody) FromGRPCMessage(m grpc.Message) error {
+	reqBodygrpc, ok := m.(*apemanager.ListChainsRequest_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqBodygrpc)
+	}
+
+	if targetgrpc := reqBodygrpc.GetTarget(); targetgrpc != nil {
+		reqBody.target = new(ape.ChainTarget)
+		if err := reqBody.target.FromGRPCMessage(targetgrpc); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (req *ListChainsRequest) ToGRPCMessage() grpc.Message {
+	var reqgrpc *apemanager.ListChainsRequest
+
+	if req != nil {
+		reqgrpc = new(apemanager.ListChainsRequest)
+
+		reqgrpc.SetBody(req.body.ToGRPCMessage().(*apemanager.ListChainsRequest_Body))
+		req.RequestHeaders.ToMessage(reqgrpc)
+	}
+
+	return reqgrpc
+}
+
+func (req *ListChainsRequest) FromGRPCMessage(m grpc.Message) error {
+	reqgrpc, ok := m.(*apemanager.ListChainsRequest)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, reqgrpc)
+	}
+
+	if reqBodygrpc := reqgrpc.GetBody(); reqBodygrpc != nil {
+		req.body = new(ListChainsRequestBody)
+		if err := req.body.FromGRPCMessage(reqBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return req.RequestHeaders.FromMessage(reqgrpc)
+}
+
+func (respBody *ListChainsResponseBody) ToGRPCMessage() grpc.Message {
+	var respBodygrpc *apemanager.ListChainsResponse_Body
+
+	if respBody != nil {
+		respBodygrpc = new(apemanager.ListChainsResponse_Body)
+
+		chainsgrpc := make([]apeGRPC.Chain, 0, len(respBody.GetChains()))
+		for _, chain := range respBody.GetChains() {
+			chainsgrpc = append(chainsgrpc, *chain.ToGRPCMessage().(*apeGRPC.Chain))
+		}
+
+		respBodygrpc.SetChains(chainsgrpc)
+	}
+
+	return respBodygrpc
+}
+
+func (respBody *ListChainsResponseBody) FromGRPCMessage(m grpc.Message) error {
+	respBodygrpc, ok := m.(*apemanager.ListChainsResponse_Body)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respBodygrpc)
+	}
+
+	chains := make([]*ape.Chain, 0, len(respBodygrpc.GetChains()))
+
+	for _, chaingrpc := range respBodygrpc.GetChains() {
+		chain := new(ape.Chain)
+		if err := chain.FromGRPCMessage(&chaingrpc); err != nil {
+			return err
+		}
+		chains = append(chains, chain)
+	}
+
+	respBody.SetChains(chains)
+
+	return nil
+}
+
+func (resp *ListChainsResponse) ToGRPCMessage() grpc.Message {
+	var respgrpc *apemanager.ListChainsResponse
+
+	if resp != nil {
+		respgrpc = new(apemanager.ListChainsResponse)
+
+		respgrpc.SetBody(resp.body.ToGRPCMessage().(*apemanager.ListChainsResponse_Body))
+		resp.ResponseHeaders.ToMessage(respgrpc)
+	}
+
+	return respgrpc
+}
+
+func (resp *ListChainsResponse) FromGRPCMessage(m grpc.Message) error {
+	respgrpc, ok := m.(*apemanager.ListChainsResponse)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, respgrpc)
+	}
+
+	if respBodygrpc := respgrpc.GetBody(); respBodygrpc != nil {
+		resp.body = new(ListChainsResponseBody)
+		if err := resp.body.FromGRPCMessage(respBodygrpc); err != nil {
+			return err
+		}
+	}
+
+	return resp.ResponseHeaders.FromMessage(respgrpc)
+}

apemanager/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,121 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package apemanager
+
+func DoFuzzProtoAddChainRequest(data []byte) int {
+	msg := new(AddChainRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONAddChainRequest(data []byte) int {
+	msg := new(AddChainRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoAddChainResponse(data []byte) int {
+	msg := new(AddChainResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONAddChainResponse(data []byte) int {
+	msg := new(AddChainResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoRemoveChainRequest(data []byte) int {
+	msg := new(RemoveChainRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONRemoveChainRequest(data []byte) int {
+	msg := new(RemoveChainRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoRemoveChainResponse(data []byte) int {
+	msg := new(RemoveChainResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONRemoveChainResponse(data []byte) int {
+	msg := new(RemoveChainResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListChainsRequest(data []byte) int {
+	msg := new(ListChainsRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListChainsRequest(data []byte) int {
+	msg := new(ListChainsRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListChainsResponse(data []byte) int {
+	msg := new(ListChainsResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListChainsResponse(data []byte) int {
+	msg := new(ListChainsResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

apemanager/grpc/service_frostfs_test.go

@@ -0,0 +1,71 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package apemanager
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoAddChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoAddChainRequest(data)
+	})
+}
+func FuzzJSONAddChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONAddChainRequest(data)
+	})
+}
+func FuzzProtoAddChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoAddChainResponse(data)
+	})
+}
+func FuzzJSONAddChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONAddChainResponse(data)
+	})
+}
+func FuzzProtoRemoveChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoRemoveChainRequest(data)
+	})
+}
+func FuzzJSONRemoveChainRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONRemoveChainRequest(data)
+	})
+}
+func FuzzProtoRemoveChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoRemoveChainResponse(data)
+	})
+}
+func FuzzJSONRemoveChainResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONRemoveChainResponse(data)
+	})
+}
+func FuzzProtoListChainsRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListChainsRequest(data)
+	})
+}
+func FuzzJSONListChainsRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListChainsRequest(data)
+	})
+}
+func FuzzProtoListChainsResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListChainsResponse(data)
+	})
+}
+func FuzzJSONListChainsResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListChainsResponse(data)
+	})
+}

apemanager/marshal.go

@@ -0,0 +1,205 @@
+package apemanager
+
+import (
+	apemanager "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager/grpc"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
+)
+
+const (
+	addChainReqBodyTargetField = 1
+	addChainReqBodyChainField  = 2
+
+	addChainRespBodyChainIDField = 1
+
+	removeChainReqBodyTargetField = 1
+	removeChainReqBodyChainField  = 2
+
+	/*
+		Fields for RemoveResponseBody are missed since RemoveResponseBody is empty.
+	*/
+
+	listChainsReqBodyTargetField = 1
+
+	listChainsRespBodyChainsField = 1
+)
+
+func (rb *AddChainRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
+	size += proto.NestedStructureSize(addChainReqBodyChainField, rb.chain)
+
+	return size
+}
+
+func (rb *AddChainRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
+	proto.NestedStructureMarshal(addChainReqBodyChainField, buf[offset:], rb.chain)
+
+	return buf
+}
+
+func (rb *AddChainRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.AddChainRequest_Body))
+}
+
+func (rb *AddChainResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.BytesSize(addChainRespBodyChainIDField, rb.chainID)
+
+	return size
+}
+
+func (rb *AddChainResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	proto.BytesMarshal(addChainRespBodyChainIDField, buf[offset:], rb.chainID)
+
+	return buf
+}
+
+func (rb *AddChainResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.AddChainResponse_Body))
+}
+
+func (rb *RemoveChainRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(addChainReqBodyTargetField, rb.target)
+	size += proto.BytesSize(addChainReqBodyChainField, rb.chainID)
+
+	return size
+}
+
+func (rb *RemoveChainRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+
+	offset += proto.NestedStructureMarshal(removeChainReqBodyTargetField, buf[offset:], rb.target)
+	proto.BytesMarshal(removeChainReqBodyChainField, buf[offset:], rb.chainID)
+
+	return buf
+}
+
+func (rb *RemoveChainRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.RemoveChainRequest_Body))
+}
+
+func (rb *RemoveChainResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	return size
+}
+
+func (rb *RemoveChainResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	return buf
+}
+
+func (rb *RemoveChainResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.RemoveChainResponse_Body))
+}
+
+func (rb *ListChainsRequestBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	size += proto.NestedStructureSize(listChainsReqBodyTargetField, rb.target)
+
+	return size
+}
+
+func (rb *ListChainsRequestBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+	proto.NestedStructureMarshal(addChainReqBodyTargetField, buf[offset:], rb.target)
+
+	return buf
+}
+
+func (rb *ListChainsRequestBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.ListChainsRequest_Body))
+}
+
+func (rb *ListChainsResponseBody) StableSize() (size int) {
+	if rb == nil {
+		return 0
+	}
+
+	for _, chain := range rb.GetChains() {
+		size += proto.NestedStructureSize(listChainsRespBodyChainsField, chain)
+	}
+
+	return size
+}
+
+func (rb *ListChainsResponseBody) StableMarshal(buf []byte) []byte {
+	if rb == nil {
+		return []byte{}
+	}
+
+	if buf == nil {
+		buf = make([]byte, rb.StableSize())
+	}
+
+	var offset int
+	for _, chain := range rb.GetChains() {
+		offset += proto.NestedStructureMarshal(listChainsRespBodyChainsField, buf[offset:], chain)
+	}
+
+	return buf
+}
+
+func (rb *ListChainsResponseBody) Unmarshal(data []byte) error {
+	return message.Unmarshal(rb, data, new(apemanager.ListChainsResponse_Body))
+}

apemanager/message_test.go

@@ -0,0 +1,26 @@
+package apemanager_test
+
+import (
+	"testing"
+
+	apemanagertest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
+	messagetest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message/test"
+)
+
+func TestMessageConvert(t *testing.T) {
+	messagetest.TestRPCMessage(t,
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateAddChainResponse(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateRemoveChainResponse(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequestBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsRequest(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponseBody(empty) },
+		func(empty bool) message.Message { return apemanagertest.GenerateListChainsResponse(empty) },
+	)
+}

apemanager/status.go

@@ -0,0 +1,76 @@
+package apemanager
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/status"
+	statusgrpc "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/status/grpc"
+)
+
+// LocalizeFailStatus checks if passed global status.Code is related to ape manager failure and:
+//
+//	then localizes the code and returns true,
+//	else leaves the code unchanged and returns false.
+//
+// Arg must be non-nil.
+func LocalizeFailStatus(c *status.Code) bool {
+	return status.LocalizeIfInSection(c, uint32(statusgrpc.Section_SECTION_APE_MANAGER))
+}
+
+// GlobalizeFail globalizes local code of ape manager failure.
+//
+// Arg must be non-nil.
+func GlobalizeFail(c *status.Code) {
+	c.GlobalizeSection(uint32(statusgrpc.Section_SECTION_APE_MANAGER))
+}
+
+const (
+	// StatusAPEManagerAccessDenied is a local status.Code value for
+	// ACCESS_DENIED ape manager failure.
+	StatusAPEManagerAccessDenied status.Code = iota
+)
+
+const (
+	// detailAccessDeniedDesc is a StatusAccessDenied detail ID for
+	// human-readable description.
+	detailAccessDeniedDesc = iota
+)
+
+// WriteAccessDeniedDesc writes human-readable description of StatusAccessDenied
+// into status.Status as a detail. The status must not be nil.
+//
+// Existing details are expected to be ID-unique, otherwise undefined behavior.
+func WriteAccessDeniedDesc(st *status.Status, desc string) {
+	var found bool
+
+	st.IterateDetails(func(d *status.Detail) bool {
+		if d.ID() == detailAccessDeniedDesc {
+			found = true
+			d.SetValue([]byte(desc))
+		}
+
+		return found
+	})
+
+	if !found {
+		var d status.Detail
+
+		d.SetID(detailAccessDeniedDesc)
+		d.SetValue([]byte(desc))
+
+		st.AppendDetails(d)
+	}
+}
+
+// ReadAccessDeniedDesc looks up for status detail with human-readable description
+// of StatusAccessDenied. Returns empty string if detail is missing.
+func ReadAccessDeniedDesc(st status.Status) (desc string) {
+	st.IterateDetails(func(d *status.Detail) bool {
+		if d.ID() == detailAccessDeniedDesc {
+			desc = string(d.Value())
+			return true
+		}
+
+		return false
+	})
+
+	return
+}

apemanager/status_test.go

@@ -0,0 +1,30 @@
+package apemanager_test
+
+import (
+	"testing"
+
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/status"
+	statustest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/status/test"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStatusCodes(t *testing.T) {
+	statustest.TestCodes(t, apemanager.LocalizeFailStatus, apemanager.GlobalizeFail,
+		apemanager.StatusAPEManagerAccessDenied, 5120,
+	)
+}
+
+func TestAccessDeniedDesc(t *testing.T) {
+	var st status.Status
+
+	require.Empty(t, apemanager.ReadAccessDeniedDesc(st))
+
+	const desc = "some description"
+
+	apemanager.WriteAccessDeniedDesc(&st, desc)
+	require.Equal(t, desc, apemanager.ReadAccessDeniedDesc(st))
+
+	apemanager.WriteAccessDeniedDesc(&st, desc+"1")
+	require.Equal(t, desc+"1", apemanager.ReadAccessDeniedDesc(st))
+}

apemanager/test/generate.go

@@ -0,0 +1,143 @@
+package apemanagertest
+
+import (
+	apetest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape/test"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/apemanager"
+	sessiontest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/test"
+)
+
+func generateChainID(empty bool) []byte {
+	if empty {
+		return []byte{}
+	}
+
+	return []byte("616c6c6f774f626a476574436e72")
+}
+
+func GenerateAddChainRequestBody(empty bool) *apemanager.AddChainRequestBody {
+	m := new(apemanager.AddChainRequestBody)
+
+	if !empty {
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+		m.SetChain(apetest.GenerateRawChain(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainRequest(empty bool) *apemanager.AddChainRequest {
+	m := new(apemanager.AddChainRequest)
+
+	if !empty {
+		m.SetBody(GenerateAddChainRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainResponseBody(empty bool) *apemanager.AddChainResponseBody {
+	m := new(apemanager.AddChainResponseBody)
+
+	if !empty {
+		m.SetChainID(generateChainID(empty))
+	}
+
+	return m
+}
+
+func GenerateAddChainResponse(empty bool) *apemanager.AddChainResponse {
+	m := new(apemanager.AddChainResponse)
+
+	if !empty {
+		m.SetBody(GenerateAddChainResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainRequestBody(empty bool) *apemanager.RemoveChainRequestBody {
+	m := new(apemanager.RemoveChainRequestBody)
+
+	if !empty {
+		m.SetChainID(generateChainID(empty))
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainRequest(empty bool) *apemanager.RemoveChainRequest {
+	m := new(apemanager.RemoveChainRequest)
+
+	if !empty {
+		m.SetBody(GenerateRemoveChainRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateRemoveChainResponseBody(_ bool) *apemanager.RemoveChainResponseBody {
+	return new(apemanager.RemoveChainResponseBody)
+}
+
+func GenerateRemoveChainResponse(empty bool) *apemanager.RemoveChainResponse {
+	m := new(apemanager.RemoveChainResponse)
+
+	if !empty {
+		m.SetBody(GenerateRemoveChainResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsRequestBody(empty bool) *apemanager.ListChainsRequestBody {
+	m := new(apemanager.ListChainsRequestBody)
+
+	if !empty {
+		m.SetTarget(apetest.GenerateChainTarget(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsRequest(empty bool) *apemanager.ListChainsRequest {
+	m := new(apemanager.ListChainsRequest)
+
+	if !empty {
+		m.SetBody(GenerateListChainsRequestBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
+	}
+
+	return m
+}
+
+func GenerateListChainsResponseBody(empty bool) *apemanager.ListChainsResponseBody {
+	m := new(apemanager.ListChainsResponseBody)
+
+	if !empty {
+		m.SetChains(apetest.GenerateRawChains(empty, 10))
+	}
+
+	return m
+}
+
+func GenerateListChainsResponse(empty bool) *apemanager.ListChainsResponse {
+	m := new(apemanager.ListChainsResponse)
+
+	if !empty {
+		m.SetBody(GenerateListChainsResponseBody(empty))
+		m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
+		m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
+	}
+
+	return m
+}

apemanager/types.go

@@ -0,0 +1,226 @@
+package apemanager
+
+import (
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/ape"
+	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session"
+)
+
+type AddChainRequest struct {
+	body *AddChainRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *AddChainRequest) SetBody(body *AddChainRequestBody) {
+	r.body = body
+}
+
+func (r *AddChainRequest) GetBody() *AddChainRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type AddChainRequestBody struct {
+	target *ape.ChainTarget
+
+	chain *ape.Chain
+}
+
+func (rb *AddChainRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *AddChainRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+func (rb *AddChainRequestBody) SetChain(chain *ape.Chain) {
+	rb.chain = chain
+}
+
+func (rb *AddChainRequestBody) GetChain() *ape.Chain {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chain
+}
+
+type AddChainResponse struct {
+	body *AddChainResponseBody
+
+	session.ResponseHeaders
+}
+
+func (r *AddChainResponse) SetBody(body *AddChainResponseBody) {
+	r.body = body
+}
+
+func (r *AddChainResponse) GetBody() *AddChainResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type AddChainResponseBody struct {
+	chainID []byte
+}
+
+func (rb *AddChainResponseBody) SetChainID(chainID []byte) {
+	rb.chainID = chainID
+}
+
+func (rb *AddChainResponseBody) GetChainID() []byte {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chainID
+}
+
+type RemoveChainRequest struct {
+	body *RemoveChainRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *RemoveChainRequest) SetBody(body *RemoveChainRequestBody) {
+	r.body = body
+}
+
+func (r *RemoveChainRequest) GetBody() *RemoveChainRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type RemoveChainRequestBody struct {
+	target *ape.ChainTarget
+
+	chainID []byte
+}
+
+func (rb *RemoveChainRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *RemoveChainRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+func (rb *RemoveChainRequestBody) SetChainID(chainID []byte) {
+	rb.chainID = chainID
+}
+
+func (rb *RemoveChainRequestBody) GetChainID() []byte {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.chainID
+}
+
+type RemoveChainResponse struct {
+	body *RemoveChainResponseBody
+
+	session.ResponseHeaders
+}
+
+type RemoveChainResponseBody struct{}
+
+func (r *RemoveChainResponse) SetBody(body *RemoveChainResponseBody) {
+	r.body = body
+}
+
+func (r *RemoveChainResponse) GetBody() *RemoveChainResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsRequest struct {
+	body *ListChainsRequestBody
+
+	session.RequestHeaders
+}
+
+func (r *ListChainsRequest) SetBody(body *ListChainsRequestBody) {
+	r.body = body
+}
+
+func (r *ListChainsRequest) GetBody() *ListChainsRequestBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsRequestBody struct {
+	target *ape.ChainTarget
+}
+
+func (rb *ListChainsRequestBody) SetTarget(target *ape.ChainTarget) {
+	rb.target = target
+}
+
+func (rb *ListChainsRequestBody) GetTarget() *ape.ChainTarget {
+	if rb == nil {
+		return nil
+	}
+
+	return rb.target
+}
+
+type ListChainsResponse struct {
+	body *ListChainsResponseBody
+
+	session.ResponseHeaders
+}
+
+func (r *ListChainsResponse) SetBody(body *ListChainsResponseBody) {
+	r.body = body
+}
+
+func (r *ListChainsResponse) GetBody() *ListChainsResponseBody {
+	if r == nil {
+		return nil
+	}
+
+	return r.body
+}
+
+type ListChainsResponseBody struct {
+	chains []*ape.Chain
+
+	session.RequestHeaders
+}
+
+func (r *ListChainsResponseBody) SetChains(chains []*ape.Chain) {
+	r.chains = chains
+}
+
+func (r *ListChainsResponseBody) GetChains() []*ape.Chain {
+	if r == nil {
+		return nil
+	}
+
+	return r.chains
+}

audit/convert.go

@@ -1,94 +0,0 @@
-package audit
-
-import (
-	audit "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/audit/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
-	refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
-)
-
-func (a *DataAuditResult) ToGRPCMessage() grpc.Message {
-	var m *audit.DataAuditResult
-
-	if a != nil {
-		m = new(audit.DataAuditResult)
-
-		m.SetAuditEpoch(a.auditEpoch)
-		m.SetPublicKey(a.pubKey)
-		m.SetContainerId(a.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
-		m.SetComplete(a.complete)
-		m.SetVersion(a.version.ToGRPCMessage().(*refsGRPC.Version))
-		m.SetPassNodes(a.passNodes)
-		m.SetFailNodes(a.failNodes)
-		m.SetRetries(a.retries)
-		m.SetRequests(a.requests)
-		m.SetHit(a.hit)
-		m.SetMiss(a.miss)
-		m.SetFail(a.fail)
-		m.SetPassSg(refs.ObjectIDListToGRPCMessage(a.passSG))
-		m.SetFailSg(refs.ObjectIDListToGRPCMessage(a.failSG))
-	}
-
-	return m
-}
-
-func (a *DataAuditResult) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*audit.DataAuditResult)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	cid := v.GetContainerId()
-	if cid == nil {
-		a.cid = nil
-	} else {
-		if a.cid == nil {
-			a.cid = new(refs.ContainerID)
-		}
-
-		err = a.cid.FromGRPCMessage(cid)
-		if err != nil {
-			return err
-		}
-	}
-
-	version := v.GetVersion()
-	if version == nil {
-		a.version = nil
-	} else {
-		if a.version == nil {
-			a.version = new(refs.Version)
-		}
-
-		err = a.version.FromGRPCMessage(version)
-		if err != nil {
-			return err
-		}
-	}
-
-	a.passSG, err = refs.ObjectIDListFromGRPCMessage(v.GetPassSg())
-	if err != nil {
-		return err
-	}
-
-	a.failSG, err = refs.ObjectIDListFromGRPCMessage(v.GetFailSg())
-	if err != nil {
-		return err
-	}
-
-	a.auditEpoch = v.GetAuditEpoch()
-	a.pubKey = v.GetPublicKey()
-	a.complete = v.GetComplete()
-	a.passNodes = v.GetPassNodes()
-	a.failNodes = v.GetFailNodes()
-	a.retries = v.GetRetries()
-	a.requests = v.GetRequests()
-	a.hit = v.GetHit()
-	a.miss = v.GetMiss()
-	a.fail = v.GetFail()
-
-	return err
-}

audit/grpc/types.go

@@ -1,75 +0,0 @@
-package audit
-
-import (
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-)
-
-// SetVersion is a Version field setter.
-func (x *DataAuditResult) SetVersion(v *refs.Version) {
-	x.Version = v
-}
-
-// SetAuditEpoch is an AuditEpoch field setter.
-func (x *DataAuditResult) SetAuditEpoch(v uint64) {
-	x.AuditEpoch = v
-}
-
-// SetContainerId is a ContainerId field setter.
-func (x *DataAuditResult) SetContainerId(v *refs.ContainerID) {
-	x.ContainerId = v
-}
-
-// SetPublicKey is a PublicKey field setter.
-func (x *DataAuditResult) SetPublicKey(v []byte) {
-	x.PublicKey = v
-}
-
-// SetComplete is a Complete field setter.
-func (x *DataAuditResult) SetComplete(v bool) {
-	x.Complete = v
-}
-
-// SetRequests is a Requests field setter.
-func (x *DataAuditResult) SetRequests(v uint32) {
-	x.Requests = v
-}
-
-// SetRetries is a Retries field setter.
-func (x *DataAuditResult) SetRetries(v uint32) {
-	x.Retries = v
-}
-
-// SetPassSg is a PassSg field setter.
-func (x *DataAuditResult) SetPassSg(v []*refs.ObjectID) {
-	x.PassSg = v
-}
-
-// SetFailSg is a FailSg field setter.
-func (x *DataAuditResult) SetFailSg(v []*refs.ObjectID) {
-	x.FailSg = v
-}
-
-// SetHit is a Hit field setter.
-func (x *DataAuditResult) SetHit(v uint32) {
-	x.Hit = v
-}
-
-// SetMiss is a Miss field setter.
-func (x *DataAuditResult) SetMiss(v uint32) {
-	x.Miss = v
-}
-
-// SetFail is a Fail field setter.
-func (x *DataAuditResult) SetFail(v uint32) {
-	x.Fail = v
-}
-
-// SetPassNodes is a PassNodes field setter.
-func (x *DataAuditResult) SetPassNodes(v [][]byte) {
-	x.PassNodes = v
-}
-
-// SetFailNodes is a FailNodes field setter.
-func (x *DataAuditResult) SetFailNodes(v [][]byte) {
-	x.FailNodes = v
-}

audit/json.go

@@ -1,14 +0,0 @@
-package audit
-
-import (
-	audit "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/audit/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
-)
-
-func (a *DataAuditResult) MarshalJSON() ([]byte, error) {
-	return message.MarshalJSON(a)
-}
-
-func (a *DataAuditResult) UnmarshalJSON(data []byte) error {
-	return message.UnmarshalJSON(a, data, new(audit.DataAuditResult))
-}

audit/marshal.go

@@ -1,88 +0,0 @@
-package audit
-
-import (
-	audit "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/audit/grpc"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
-)
-
-const (
-	_ = iota
-	versionFNum
-	auditEpochFNum
-	cidFNum
-	pubKeyFNum
-	completeFNum
-	requestsFNum
-	retriesFNum
-	passSGFNum
-	failSGFNum
-	hitFNum
-	missFNum
-	failFNum
-	passNodesFNum
-	failNodesFNum
-)
-
-// StableMarshal marshals unified DataAuditResult structure into a protobuf
-// binary format without field order shuffle.
-func (a *DataAuditResult) StableMarshal(buf []byte) []byte {
-	if a == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, a.StableSize())
-	}
-
-	var offset int
-
-	offset += proto.NestedStructureMarshal(versionFNum, buf[offset:], a.version)
-	offset += proto.Fixed64Marshal(auditEpochFNum, buf[offset:], a.auditEpoch)
-	offset += proto.NestedStructureMarshal(cidFNum, buf[offset:], a.cid)
-	offset += proto.BytesMarshal(pubKeyFNum, buf[offset:], a.pubKey)
-	offset += proto.BoolMarshal(completeFNum, buf[offset:], a.complete)
-	offset += proto.UInt32Marshal(requestsFNum, buf[offset:], a.requests)
-	offset += proto.UInt32Marshal(retriesFNum, buf[offset:], a.retries)
-	offset += refs.ObjectIDNestedListMarshal(passSGFNum, buf[offset:], a.passSG)
-	offset += refs.ObjectIDNestedListMarshal(failSGFNum, buf[offset:], a.failSG)
-	offset += proto.UInt32Marshal(hitFNum, buf[offset:], a.hit)
-	offset += proto.UInt32Marshal(missFNum, buf[offset:], a.miss)
-	offset += proto.UInt32Marshal(failFNum, buf[offset:], a.fail)
-	offset += proto.RepeatedBytesMarshal(passNodesFNum, buf[offset:], a.passNodes)
-	proto.RepeatedBytesMarshal(failNodesFNum, buf[offset:], a.failNodes)
-
-	return buf
-}
-
-// StableSize returns byte length of DataAuditResult structure
-// marshaled by StableMarshal function.
-func (a *DataAuditResult) StableSize() (size int) {
-	if a == nil {
-		return 0
-	}
-
-	size += proto.NestedStructureSize(versionFNum, a.version)
-	size += proto.Fixed64Size(auditEpochFNum, a.auditEpoch)
-	size += proto.NestedStructureSize(cidFNum, a.cid)
-	size += proto.BytesSize(pubKeyFNum, a.pubKey)
-	size += proto.BoolSize(completeFNum, a.complete)
-	size += proto.UInt32Size(requestsFNum, a.requests)
-	size += proto.UInt32Size(retriesFNum, a.retries)
-	size += refs.ObjectIDNestedListSize(passSGFNum, a.passSG)
-	size += refs.ObjectIDNestedListSize(failSGFNum, a.failSG)
-	size += proto.UInt32Size(hitFNum, a.hit)
-	size += proto.UInt32Size(missFNum, a.miss)
-	size += proto.UInt32Size(failFNum, a.fail)
-	size += proto.RepeatedBytesSize(passNodesFNum, a.passNodes)
-	size += proto.RepeatedBytesSize(failNodesFNum, a.failNodes)
-
-	return size
-}
-
-// Unmarshal unmarshals DataAuditResult structure from its protobuf
-// binary representation.
-func (a *DataAuditResult) Unmarshal(data []byte) error {
-	return message.Unmarshal(a, data, new(audit.DataAuditResult))
-}

audit/test/generate.go

@@ -1,29 +0,0 @@
-package audittest
-
-import (
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/audit"
-	refstest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/test"
-)
-
-func GenerateDataAuditResult(empty bool) *audit.DataAuditResult {
-	m := new(audit.DataAuditResult)
-
-	if !empty {
-		m.SetPublicKey([]byte{1, 2, 3})
-		m.SetAuditEpoch(13)
-		m.SetHit(100)
-		m.SetMiss(200)
-		m.SetFail(300)
-		m.SetComplete(true)
-		m.SetPassNodes([][]byte{{1}, {2}})
-		m.SetFailNodes([][]byte{{3}, {4}})
-		m.SetRequests(666)
-		m.SetRetries(777)
-		m.SetVersion(refstest.GenerateVersion(false))
-		m.SetContainerID(refstest.GenerateContainerID(false))
-		m.SetPassSG(refstest.GenerateObjectIDs(false))
-		m.SetFailSG(refstest.GenerateObjectIDs(false))
-	}
-
-	return m
-}

audit/types.go

@@ -1,243 +0,0 @@
-package audit
-
-import (
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
-)
-
-// DataAuditResult is a unified structure of
-// DataAuditResult message from proto definition.
-type DataAuditResult struct {
-	version *refs.Version
-
-	auditEpoch uint64
-
-	requests, retries uint32
-
-	hit, miss, fail uint32
-
-	cid *refs.ContainerID
-
-	pubKey []byte
-
-	passSG, failSG []refs.ObjectID
-
-	failNodes, passNodes [][]byte
-
-	complete bool
-}
-
-// GetVersion returns version of Data Audit structure.
-func (a *DataAuditResult) GetVersion() *refs.Version {
-	if a != nil {
-		return a.version
-	}
-
-	return nil
-}
-
-// SetVersion sets version of Data Audit structure.
-func (a *DataAuditResult) SetVersion(v *refs.Version) {
-	a.version = v
-}
-
-// GetAuditEpoch returns epoch number when the Data Audit was conducted.
-func (a *DataAuditResult) GetAuditEpoch() uint64 {
-	if a != nil {
-		return a.auditEpoch
-	}
-
-	return 0
-}
-
-// SetAuditEpoch sets epoch number when the Data Audit was conducted.
-func (a *DataAuditResult) SetAuditEpoch(v uint64) {
-	a.auditEpoch = v
-}
-
-// GetContainerID returns container under audit.
-func (a *DataAuditResult) GetContainerID() *refs.ContainerID {
-	if a != nil {
-		return a.cid
-	}
-
-	return nil
-}
-
-// SetContainerID sets container under audit.
-func (a *DataAuditResult) SetContainerID(v *refs.ContainerID) {
-	a.cid = v
-}
-
-// GetPublicKey returns public key of the auditing InnerRing node in a binary format.
-func (a *DataAuditResult) GetPublicKey() []byte {
-	if a != nil {
-		return a.pubKey
-	}
-
-	return nil
-}
-
-// SetPublicKey sets public key of the auditing InnerRing node in a binary format.
-func (a *DataAuditResult) SetPublicKey(v []byte) {
-	a.pubKey = v
-}
-
-// GetPassSG returns list of Storage Groups that passed audit PoR stage.
-func (a *DataAuditResult) GetPassSG() []refs.ObjectID {
-	if a != nil {
-		return a.passSG
-	}
-
-	return nil
-}
-
-// SetPassSG sets list of Storage Groups that passed audit PoR stage.
-func (a *DataAuditResult) SetPassSG(v []refs.ObjectID) {
-	a.passSG = v
-}
-
-// GetFailSG returns list of Storage Groups that failed audit PoR stage.
-func (a *DataAuditResult) GetFailSG() []refs.ObjectID {
-	if a != nil {
-		return a.failSG
-	}
-
-	return nil
-}
-
-// SetFailSG sets list of Storage Groups that failed audit PoR stage.
-func (a *DataAuditResult) SetFailSG(v []refs.ObjectID) {
-	a.failSG = v
-}
-
-// GetRequests returns number of requests made by PoR audit check to get
-// all headers of the objects inside storage groups.
-func (a *DataAuditResult) GetRequests() uint32 {
-	if a != nil {
-		return a.requests
-	}
-
-	return 0
-}
-
-// SetRequests sets number of requests made by PoR audit check to get
-// all headers of the objects inside storage groups.
-func (a *DataAuditResult) SetRequests(v uint32) {
-	a.requests = v
-}
-
-// GetRetries returns number of retries made by PoR audit check to get
-// all headers of the objects inside storage groups.
-func (a *DataAuditResult) GetRetries() uint32 {
-	if a != nil {
-		return a.retries
-	}
-
-	return 0
-}
-
-// SetRetries sets number of retries made by PoR audit check to get
-// all headers of the objects inside storage groups.
-func (a *DataAuditResult) SetRetries(v uint32) {
-	a.retries = v
-}
-
-// GetHit returns number of sampled objects under audit placed
-// in an optimal way according to the containers placement policy
-// when checking PoP.
-func (a *DataAuditResult) GetHit() uint32 {
-	if a != nil {
-		return a.hit
-	}
-
-	return 0
-}
-
-// SetHit sets number of sampled objects under audit placed
-// in an optimal way according to the containers placement policy
-// when checking PoP.
-func (a *DataAuditResult) SetHit(v uint32) {
-	a.hit = v
-}
-
-// GetMiss returns number of sampled objects under audit placed
-// in suboptimal way according to the containers placement policy,
-// but still at a satisfactory level when checking PoP.
-func (a *DataAuditResult) GetMiss() uint32 {
-	if a != nil {
-		return a.miss
-	}
-
-	return 0
-}
-
-// SetMiss sets number of sampled objects under audit placed
-// in suboptimal way according to the containers placement policy,
-// but still at a satisfactory level when checking PoP.
-func (a *DataAuditResult) SetMiss(v uint32) {
-	a.miss = v
-}
-
-// GetFail returns number of sampled objects under audit stored
-// in a way not confirming placement policy or not found at all
-// when checking PoP.
-func (a *DataAuditResult) GetFail() uint32 {
-	if a != nil {
-		return a.fail
-	}
-
-	return 0
-}
-
-// SetFail sets number of sampled objects under audit stored
-// in a way not confirming placement policy or not found at all
-// when checking PoP.
-func (a *DataAuditResult) SetFail(v uint32) {
-	a.fail = v
-}
-
-// GetPassNodes returns list of storage node public keys that
-// passed at least one PDP.
-func (a *DataAuditResult) GetPassNodes() [][]byte {
-	if a != nil {
-		return a.passNodes
-	}
-
-	return nil
-}
-
-// SetPassNodes sets list of storage node public keys that
-// passed at least one PDP.
-func (a *DataAuditResult) SetPassNodes(v [][]byte) {
-	a.passNodes = v
-}
-
-// GetFailNodes returns list of storage node public keys that
-// failed at least one PDP.
-func (a *DataAuditResult) GetFailNodes() [][]byte {
-	if a != nil {
-		return a.failNodes
-	}
-
-	return nil
-}
-
-// SetFailNodes sets list of storage node public keys that
-// failed at least one PDP.
-func (a *DataAuditResult) SetFailNodes(v [][]byte) {
-	a.failNodes = v
-}
-
-// GetComplete returns boolean completion statement of audit result.
-func (a *DataAuditResult) GetComplete() bool {
-	if a != nil {
-		return a.complete
-	}
-
-	return false // bool default
-}
-
-// SetComplete sets boolean completion statement of audit result.
-func (a *DataAuditResult) SetComplete(v bool) {
-	a.complete = v
-}

container/convert.go

@@ -1,8 +1,6 @@
 package container
 
 import (
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl"
-	aclGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl/grpc"
 	container "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/container/grpc"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap"
 	netmapGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap/grpc"
@@ -39,28 +37,26 @@ func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func AttributesToGRPC(xs []Attribute) (res []*container.Container_Attribute) {
+func AttributesToGRPC(xs []Attribute) (res []container.Container_Attribute) {
 	if xs != nil {
-		res = make([]*container.Container_Attribute, 0, len(xs))
+		res = make([]container.Container_Attribute, 0, len(xs))
 
 		for i := range xs {
-			res = append(res, xs[i].ToGRPCMessage().(*container.Container_Attribute))
+			res = append(res, *xs[i].ToGRPCMessage().(*container.Container_Attribute))
 		}
 	}
 
 	return
 }
 
-func AttributesFromGRPC(xs []*container.Container_Attribute) (res []Attribute, err error) {
+func AttributesFromGRPC(xs []container.Container_Attribute) (res []Attribute, err error) {
 	if xs != nil {
 		res = make([]Attribute, len(xs))
 
 		for i := range xs {
-			if xs[i] != nil {
+			err = res[i].FromGRPCMessage(&xs[i])
-				err = res[i].FromGRPCMessage(xs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -766,515 +762,3 @@ func (r *ListResponse) FromGRPCMessage(m grpc.Message) error {
 
 	return r.ResponseHeaders.FromMessage(v)
 }
-
-func (r *SetExtendedACLRequestBody) ToGRPCMessage() grpc.Message {
-	var m *container.SetExtendedACLRequest_Body
-
-	if r != nil {
-		m = new(container.SetExtendedACLRequest_Body)
-
-		m.SetEacl(r.eacl.ToGRPCMessage().(*aclGRPC.EACLTable))
-		m.SetSignature(toSignatureRFC6979(r.sig))
-	}
-
-	return m
-}
-
-func (r *SetExtendedACLRequestBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.SetExtendedACLRequest_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	eacl := v.GetEacl()
-	if eacl == nil {
-		r.eacl = nil
-	} else {
-		if r.eacl == nil {
-			r.eacl = new(acl.Table)
-		}
-
-		err = r.eacl.FromGRPCMessage(eacl)
-		if err != nil {
-			return err
-		}
-	}
-
-	sig := v.GetSignature()
-	if sig == nil {
-		r.sig = nil
-	} else {
-		if r.sig == nil {
-			r.sig = new(refs.Signature)
-		}
-
-		r.sig.SetKey(sig.GetKey())
-		r.sig.SetSign(sig.GetSign())
-	}
-
-	return err
-}
-
-func (r *SetExtendedACLRequest) ToGRPCMessage() grpc.Message {
-	var m *container.SetExtendedACLRequest
-
-	if r != nil {
-		m = new(container.SetExtendedACLRequest)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.SetExtendedACLRequest_Body))
-		r.RequestHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *SetExtendedACLRequest) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.SetExtendedACLRequest)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(SetExtendedACLRequestBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.RequestHeaders.FromMessage(v)
-}
-
-func (r *SetExtendedACLResponseBody) ToGRPCMessage() grpc.Message {
-	var m *container.SetExtendedACLResponse_Body
-
-	if r != nil {
-		m = new(container.SetExtendedACLResponse_Body)
-	}
-
-	return m
-}
-
-func (r *SetExtendedACLResponseBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.SetExtendedACLResponse_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	return nil
-}
-
-func (r *SetExtendedACLResponse) ToGRPCMessage() grpc.Message {
-	var m *container.SetExtendedACLResponse
-
-	if r != nil {
-		m = new(container.SetExtendedACLResponse)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.SetExtendedACLResponse_Body))
-		r.ResponseHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *SetExtendedACLResponse) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.SetExtendedACLResponse)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(SetExtendedACLResponseBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.ResponseHeaders.FromMessage(v)
-}
-
-func (r *GetExtendedACLRequestBody) ToGRPCMessage() grpc.Message {
-	var m *container.GetExtendedACLRequest_Body
-
-	if r != nil {
-		m = new(container.GetExtendedACLRequest_Body)
-
-		m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
-	}
-
-	return m
-}
-
-func (r *GetExtendedACLRequestBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.GetExtendedACLRequest_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	cid := v.GetContainerId()
-	if cid == nil {
-		r.cid = nil
-	} else {
-		if r.cid == nil {
-			r.cid = new(refs.ContainerID)
-		}
-
-		err = r.cid.FromGRPCMessage(cid)
-	}
-
-	return err
-}
-
-func (r *GetExtendedACLRequest) ToGRPCMessage() grpc.Message {
-	var m *container.GetExtendedACLRequest
-
-	if r != nil {
-		m = new(container.GetExtendedACLRequest)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.GetExtendedACLRequest_Body))
-		r.RequestHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *GetExtendedACLRequest) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.GetExtendedACLRequest)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(GetExtendedACLRequestBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.RequestHeaders.FromMessage(v)
-}
-
-func (r *GetExtendedACLResponseBody) ToGRPCMessage() grpc.Message {
-	var m *container.GetExtendedACLResponse_Body
-
-	if r != nil {
-		m = new(container.GetExtendedACLResponse_Body)
-
-		m.SetEacl(r.eacl.ToGRPCMessage().(*aclGRPC.EACLTable))
-		m.SetSignature(toSignatureRFC6979(r.sig))
-		m.SetSessionToken(r.token.ToGRPCMessage().(*sessionGRPC.SessionToken))
-	}
-
-	return m
-}
-
-func (r *GetExtendedACLResponseBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.GetExtendedACLResponse_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	eacl := v.GetEacl()
-	if eacl == nil {
-		r.eacl = nil
-	} else {
-		if r.eacl == nil {
-			r.eacl = new(acl.Table)
-		}
-
-		err = r.eacl.FromGRPCMessage(eacl)
-		if err != nil {
-			return err
-		}
-	}
-
-	sig := v.GetSignature()
-	if sig == nil {
-		r.sig = nil
-	} else {
-		if r.sig == nil {
-			r.sig = new(refs.Signature)
-		}
-
-		r.sig.SetKey(sig.GetKey())
-		r.sig.SetSign(sig.GetSign())
-	}
-
-	token := v.GetSessionToken()
-	if token == nil {
-		r.token = nil
-	} else {
-		if r.token == nil {
-			r.token = new(session.Token)
-		}
-
-		err = r.token.FromGRPCMessage(token)
-	}
-
-	return err
-}
-
-func (r *GetExtendedACLResponse) ToGRPCMessage() grpc.Message {
-	var m *container.GetExtendedACLResponse
-
-	if r != nil {
-		m = new(container.GetExtendedACLResponse)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.GetExtendedACLResponse_Body))
-		r.ResponseHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *GetExtendedACLResponse) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.GetExtendedACLResponse)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(GetExtendedACLResponseBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.ResponseHeaders.FromMessage(v)
-}
-
-func (a *UsedSpaceAnnouncement) ToGRPCMessage() grpc.Message {
-	var m *container.AnnounceUsedSpaceRequest_Body_Announcement
-
-	if a != nil {
-		m = new(container.AnnounceUsedSpaceRequest_Body_Announcement)
-
-		m.SetContainerId(a.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
-		m.SetEpoch(a.epoch)
-		m.SetUsedSpace(a.usedSpace)
-	}
-
-	return m
-}
-
-func (a *UsedSpaceAnnouncement) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.AnnounceUsedSpaceRequest_Body_Announcement)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	cid := v.GetContainerId()
-	if cid == nil {
-		a.cid = nil
-	} else {
-		if a.cid == nil {
-			a.cid = new(refs.ContainerID)
-		}
-
-		err = a.cid.FromGRPCMessage(cid)
-		if err != nil {
-			return err
-		}
-	}
-
-	a.epoch = v.GetEpoch()
-	a.usedSpace = v.GetUsedSpace()
-
-	return nil
-}
-
-func UsedSpaceAnnouncementsToGRPCMessage(
-	ids []UsedSpaceAnnouncement,
-) (res []*container.AnnounceUsedSpaceRequest_Body_Announcement) {
-	if ids != nil {
-		res = make([]*container.AnnounceUsedSpaceRequest_Body_Announcement, 0, len(ids))
-
-		for i := range ids {
-			res = append(res, ids[i].ToGRPCMessage().(*container.AnnounceUsedSpaceRequest_Body_Announcement))
-		}
-	}
-
-	return
-}
-
-func UsedSpaceAnnouncementssFromGRPCMessage(
-	asV2 []*container.AnnounceUsedSpaceRequest_Body_Announcement,
-) (res []UsedSpaceAnnouncement, err error) {
-	if asV2 != nil {
-		res = make([]UsedSpaceAnnouncement, len(asV2))
-
-		for i := range asV2 {
-			if asV2[i] != nil {
-				err = res[i].FromGRPCMessage(asV2[i])
-				if err != nil {
-					return
-				}
-			}
-		}
-	}
-
-	return
-}
-
-func (r *AnnounceUsedSpaceRequestBody) ToGRPCMessage() grpc.Message {
-	var m *container.AnnounceUsedSpaceRequest_Body
-
-	if r != nil {
-		m = new(container.AnnounceUsedSpaceRequest_Body)
-
-		m.SetAnnouncements(UsedSpaceAnnouncementsToGRPCMessage(r.announcements))
-	}
-
-	return m
-}
-
-func (r *AnnounceUsedSpaceRequestBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.AnnounceUsedSpaceRequest_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	r.announcements, err = UsedSpaceAnnouncementssFromGRPCMessage(v.GetAnnouncements())
-
-	return err
-}
-
-func (r *AnnounceUsedSpaceRequest) ToGRPCMessage() grpc.Message {
-	var m *container.AnnounceUsedSpaceRequest
-
-	if r != nil {
-		m = new(container.AnnounceUsedSpaceRequest)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.AnnounceUsedSpaceRequest_Body))
-		r.RequestHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *AnnounceUsedSpaceRequest) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.AnnounceUsedSpaceRequest)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(AnnounceUsedSpaceRequestBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.RequestHeaders.FromMessage(v)
-}
-
-func (r *AnnounceUsedSpaceResponseBody) ToGRPCMessage() grpc.Message {
-	var m *container.AnnounceUsedSpaceResponse_Body
-
-	if r != nil {
-		m = new(container.AnnounceUsedSpaceResponse_Body)
-	}
-
-	return m
-}
-
-func (r *AnnounceUsedSpaceResponseBody) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.AnnounceUsedSpaceResponse_Body)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	return nil
-}
-
-func (r *AnnounceUsedSpaceResponse) ToGRPCMessage() grpc.Message {
-	var m *container.AnnounceUsedSpaceResponse
-
-	if r != nil {
-		m = new(container.AnnounceUsedSpaceResponse)
-
-		m.SetBody(r.body.ToGRPCMessage().(*container.AnnounceUsedSpaceResponse_Body))
-		r.ResponseHeaders.ToMessage(m)
-	}
-
-	return m
-}
-
-func (r *AnnounceUsedSpaceResponse) FromGRPCMessage(m grpc.Message) error {
-	v, ok := m.(*container.AnnounceUsedSpaceResponse)
-	if !ok {
-		return message.NewUnexpectedMessageType(m, v)
-	}
-
-	var err error
-
-	body := v.GetBody()
-	if body == nil {
-		r.body = nil
-	} else {
-		if r.body == nil {
-			r.body = new(AnnounceUsedSpaceResponseBody)
-		}
-
-		err = r.body.FromGRPCMessage(body)
-		if err != nil {
-			return err
-		}
-	}
-
-	return r.ResponseHeaders.FromMessage(v)
-}

container/grpc/service.go

@@ -1,324 +0,0 @@
-package container
-
-import (
-	acl "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl/grpc"
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-	session "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/grpc"
-)
-
-// SetContainer sets container of the request.
-func (m *PutRequest_Body) SetContainer(v *Container) {
-	m.Container = v
-}
-
-// SetSignature sets signature of the container structure.
-func (m *PutRequest_Body) SetSignature(v *refs.SignatureRFC6979) {
-	m.Signature = v
-}
-
-// SetBody sets body of the request.
-func (m *PutRequest) SetBody(v *PutRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *PutRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *PutRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainerId sets identifier of the container.
-func (m *PutResponse_Body) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetBody sets body of the response.
-func (m *PutResponse) SetBody(v *PutResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *PutResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *PutResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainerId sets identifier of the container.
-func (m *DeleteRequest_Body) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetSignature sets signature of the container identifier.
-func (m *DeleteRequest_Body) SetSignature(v *refs.SignatureRFC6979) {
-	m.Signature = v
-}
-
-// SetBody sets body of the request.
-func (m *DeleteRequest) SetBody(v *DeleteRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *DeleteRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *DeleteRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetBody sets body of the response.
-func (m *DeleteResponse) SetBody(v *DeleteResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *DeleteResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *DeleteResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainerId sets identifier of the container.
-func (m *GetRequest_Body) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetBody sets body of the request.
-func (m *GetRequest) SetBody(v *GetRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *GetRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *GetRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainer sets the container structure.
-func (m *GetResponse_Body) SetContainer(v *Container) {
-	m.Container = v
-}
-
-// SetSessionToken sets token of the session within which requested
-// container was created.
-func (m *GetResponse_Body) SetSessionToken(v *session.SessionToken) {
-	m.SessionToken = v
-}
-
-// SetSignature sets signature of the container structure.
-func (m *GetResponse_Body) SetSignature(v *refs.SignatureRFC6979) {
-	m.Signature = v
-}
-
-// SetBody sets body of the response.
-func (m *GetResponse) SetBody(v *GetResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *GetResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *GetResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetOwnerId sets identifier of the container owner.
-func (m *ListRequest_Body) SetOwnerId(v *refs.OwnerID) {
-	m.OwnerId = v
-}
-
-// SetBody sets body of the request.
-func (m *ListRequest) SetBody(v *ListRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *ListRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *ListRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainerIds sets list of the container identifiers.
-func (m *ListResponse_Body) SetContainerIds(v []*refs.ContainerID) {
-	m.ContainerIds = v
-}
-
-// SetBody sets body of the response.
-func (m *ListResponse) SetBody(v *ListResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *ListResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *ListResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetEacl sets eACL table structure.
-func (m *SetExtendedACLRequest_Body) SetEacl(v *acl.EACLTable) {
-	m.Eacl = v
-}
-
-// SetSignature sets signature of the eACL table structure.
-func (m *SetExtendedACLRequest_Body) SetSignature(v *refs.SignatureRFC6979) {
-	m.Signature = v
-}
-
-// SetBody sets body of the request.
-func (m *SetExtendedACLRequest) SetBody(v *SetExtendedACLRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *SetExtendedACLRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *SetExtendedACLRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetBody sets body of the response.
-func (m *SetExtendedACLResponse) SetBody(v *SetExtendedACLResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *SetExtendedACLResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *SetExtendedACLResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetContainerId sets identifier of the container.
-func (m *GetExtendedACLRequest_Body) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetBody sets body of the request.
-func (m *GetExtendedACLRequest) SetBody(v *GetExtendedACLRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *GetExtendedACLRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *GetExtendedACLRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetEacl sets eACL table structure.
-func (m *GetExtendedACLResponse_Body) SetEacl(v *acl.EACLTable) {
-	m.Eacl = v
-}
-
-// SetSignature sets signature of the eACL table structure.
-func (m *GetExtendedACLResponse_Body) SetSignature(v *refs.SignatureRFC6979) {
-	m.Signature = v
-}
-
-// SetSessionToken sets token of the session within which requested
-// eACl table was set.
-func (m *GetExtendedACLResponse_Body) SetSessionToken(v *session.SessionToken) {
-	m.SessionToken = v
-}
-
-// SetBody sets body of the response.
-func (m *GetExtendedACLResponse) SetBody(v *GetExtendedACLResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *GetExtendedACLResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *GetExtendedACLResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetEpoch sets epoch of the size estimation.
-func (m *AnnounceUsedSpaceRequest_Body_Announcement) SetEpoch(v uint64) {
-	m.Epoch = v
-}
-
-// SetContainerId sets identifier of the container.
-func (m *AnnounceUsedSpaceRequest_Body_Announcement) SetContainerId(v *refs.ContainerID) {
-	m.ContainerId = v
-}
-
-// SetUsedSpace sets used space value of the container.
-func (m *AnnounceUsedSpaceRequest_Body_Announcement) SetUsedSpace(v uint64) {
-	m.UsedSpace = v
-}
-
-// SetAnnouncements sets list of announcement for shared containers between nodes.
-func (m *AnnounceUsedSpaceRequest_Body) SetAnnouncements(v []*AnnounceUsedSpaceRequest_Body_Announcement) {
-	m.Announcements = v
-}
-
-// SetBody sets body of the request.
-func (m *AnnounceUsedSpaceRequest) SetBody(v *AnnounceUsedSpaceRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *AnnounceUsedSpaceRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *AnnounceUsedSpaceRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetBody sets body of the response.
-func (m *AnnounceUsedSpaceResponse) SetBody(v *AnnounceUsedSpaceResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *AnnounceUsedSpaceResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *AnnounceUsedSpaceResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}

container/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,159 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+func DoFuzzProtoPutRequest(data []byte) int {
+	msg := new(PutRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPutRequest(data []byte) int {
+	msg := new(PutRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoPutResponse(data []byte) int {
+	msg := new(PutResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPutResponse(data []byte) int {
+	msg := new(PutResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoDeleteRequest(data []byte) int {
+	msg := new(DeleteRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDeleteRequest(data []byte) int {
+	msg := new(DeleteRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoDeleteResponse(data []byte) int {
+	msg := new(DeleteResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONDeleteResponse(data []byte) int {
+	msg := new(DeleteResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoGetRequest(data []byte) int {
+	msg := new(GetRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONGetRequest(data []byte) int {
+	msg := new(GetRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoGetResponse(data []byte) int {
+	msg := new(GetResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONGetResponse(data []byte) int {
+	msg := new(GetResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListRequest(data []byte) int {
+	msg := new(ListRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListRequest(data []byte) int {
+	msg := new(ListRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoListResponse(data []byte) int {
+	msg := new(ListResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONListResponse(data []byte) int {
+	msg := new(ListResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

container/grpc/service_frostfs_test.go

@@ -0,0 +1,91 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoPutRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPutRequest(data)
+	})
+}
+func FuzzJSONPutRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPutRequest(data)
+	})
+}
+func FuzzProtoPutResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPutResponse(data)
+	})
+}
+func FuzzJSONPutResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPutResponse(data)
+	})
+}
+func FuzzProtoDeleteRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDeleteRequest(data)
+	})
+}
+func FuzzJSONDeleteRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDeleteRequest(data)
+	})
+}
+func FuzzProtoDeleteResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoDeleteResponse(data)
+	})
+}
+func FuzzJSONDeleteResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONDeleteResponse(data)
+	})
+}
+func FuzzProtoGetRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoGetRequest(data)
+	})
+}
+func FuzzJSONGetRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONGetRequest(data)
+	})
+}
+func FuzzProtoGetResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoGetResponse(data)
+	})
+}
+func FuzzJSONGetResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONGetResponse(data)
+	})
+}
+func FuzzProtoListRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListRequest(data)
+	})
+}
+func FuzzJSONListRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListRequest(data)
+	})
+}
+func FuzzProtoListResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoListResponse(data)
+	})
+}
+func FuzzJSONListResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONListResponse(data)
+	})
+}

container/grpc/types.go

@@ -1,46 +0,0 @@
-package container
-
-import (
-	netmap "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap/grpc"
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-)
-
-// SetKey sets key to the container attribute.
-func (m *Container_Attribute) SetKey(v string) {
-	m.Key = v
-}
-
-// SetValue sets value of the container attribute.
-func (m *Container_Attribute) SetValue(v string) {
-	m.Value = v
-}
-
-// SetOwnerId sets identifier of the container owner,
-func (m *Container) SetOwnerId(v *refs.OwnerID) {
-	m.OwnerId = v
-}
-
-// SetNonce sets nonce of the container structure.
-func (m *Container) SetNonce(v []byte) {
-	m.Nonce = v
-}
-
-// SetBasicAcl sets basic ACL of the container.
-func (m *Container) SetBasicAcl(v uint32) {
-	m.BasicAcl = v
-}
-
-// SetAttributes sets list of the container attributes.
-func (m *Container) SetAttributes(v []*Container_Attribute) {
-	m.Attributes = v
-}
-
-// SetPlacementPolicy sets placement policy of the container.
-func (m *Container) SetPlacementPolicy(v *netmap.PlacementPolicy) {
-	m.PlacementPolicy = v
-}
-
-// SetVersion sets version of the container.
-func (m *Container) SetVersion(v *refs.Version) {
-	m.Version = v
-}

container/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+func DoFuzzProtoContainer(data []byte) int {
+	msg := new(Container)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONContainer(data []byte) int {
+	msg := new(Container)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

container/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package container
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoContainer(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoContainer(data)
+	})
+}
+func FuzzJSONContainer(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONContainer(data)
+	})
+}

container/marshal.go

@@ -34,21 +34,6 @@ const (
 	listReqBodyOwnerField = 1
 
 	listRespBodyIDsField = 1
-
-	setEACLReqBodyTableField     = 1
-	setEACLReqBodySignatureField = 2
-
-	getEACLReqBodyIDField = 1
-
-	getEACLRespBodyTableField     = 1
-	getEACLRespBodySignatureField = 2
-	getEACLRespBodyTokenField     = 3
-
-	usedSpaceAnnounceEpochField     = 1
-	usedSpaceAnnounceCIDField       = 2
-	usedSpaceAnnounceUsedSpaceField = 3
-
-	usedSpaceReqBodyAnnouncementsField = 1
 )
 
 func (a *Attribute) StableMarshal(buf []byte) []byte {
@@ -358,189 +343,3 @@ func (r *ListResponseBody) StableSize() (size int) {
 func (r *ListResponseBody) Unmarshal(data []byte) error {
 	return message.Unmarshal(r, data, new(container.ListResponse_Body))
 }
-
-func (r *SetExtendedACLRequestBody) StableMarshal(buf []byte) []byte {
-	if r == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, r.StableSize())
-	}
-
-	var offset int
-
-	offset += protoutil.NestedStructureMarshal(setEACLReqBodyTableField, buf[offset:], r.eacl)
-	protoutil.NestedStructureMarshal(setEACLReqBodySignatureField, buf[offset:], r.sig)
-
-	return buf
-}
-
-func (r *SetExtendedACLRequestBody) StableSize() (size int) {
-	if r == nil {
-		return 0
-	}
-
-	size += protoutil.NestedStructureSize(setEACLReqBodyTableField, r.eacl)
-	size += protoutil.NestedStructureSize(setEACLReqBodySignatureField, r.sig)
-
-	return size
-}
-
-func (r *SetExtendedACLRequestBody) Unmarshal(data []byte) error {
-	return message.Unmarshal(r, data, new(container.SetExtendedACLRequest_Body))
-}
-
-func (r *SetExtendedACLResponseBody) StableMarshal(_ []byte) []byte {
-	return nil
-}
-
-func (r *SetExtendedACLResponseBody) StableSize() (size int) {
-	return 0
-}
-
-func (r *SetExtendedACLResponseBody) Unmarshal([]byte) error {
-	return nil
-}
-
-func (r *GetExtendedACLRequestBody) StableMarshal(buf []byte) []byte {
-	if r == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, r.StableSize())
-	}
-
-	protoutil.NestedStructureMarshal(getEACLReqBodyIDField, buf, r.cid)
-
-	return buf
-}
-
-func (r *GetExtendedACLRequestBody) StableSize() (size int) {
-	if r == nil {
-		return 0
-	}
-
-	size += protoutil.NestedStructureSize(getEACLReqBodyIDField, r.cid)
-
-	return size
-}
-
-func (r *GetExtendedACLRequestBody) Unmarshal(data []byte) error {
-	return message.Unmarshal(r, data, new(container.GetExtendedACLRequest_Body))
-}
-
-func (r *GetExtendedACLResponseBody) StableMarshal(buf []byte) []byte {
-	if r == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, r.StableSize())
-	}
-
-	var offset int
-
-	offset += protoutil.NestedStructureMarshal(getEACLRespBodyTableField, buf[offset:], r.eacl)
-	offset += protoutil.NestedStructureMarshal(getEACLRespBodySignatureField, buf[offset:], r.sig)
-	protoutil.NestedStructureMarshal(getEACLRespBodyTokenField, buf[offset:], r.token)
-
-	return buf
-}
-
-func (r *GetExtendedACLResponseBody) StableSize() (size int) {
-	if r == nil {
-		return 0
-	}
-
-	size += protoutil.NestedStructureSize(getEACLRespBodyTableField, r.eacl)
-	size += protoutil.NestedStructureSize(getEACLRespBodySignatureField, r.sig)
-	size += protoutil.NestedStructureSize(getEACLRespBodyTokenField, r.token)
-
-	return size
-}
-
-func (r *GetExtendedACLResponseBody) Unmarshal(data []byte) error {
-	return message.Unmarshal(r, data, new(container.GetExtendedACLResponse_Body))
-}
-
-func (a *UsedSpaceAnnouncement) StableMarshal(buf []byte) []byte {
-	if a == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, a.StableSize())
-	}
-
-	var offset int
-
-	offset += protoutil.UInt64Marshal(usedSpaceAnnounceEpochField, buf[offset:], a.epoch)
-	offset += protoutil.NestedStructureMarshal(usedSpaceAnnounceCIDField, buf[offset:], a.cid)
-	protoutil.UInt64Marshal(usedSpaceAnnounceUsedSpaceField, buf[offset:], a.usedSpace)
-
-	return buf
-}
-
-func (a *UsedSpaceAnnouncement) StableSize() (size int) {
-	if a == nil {
-		return 0
-	}
-
-	size += protoutil.UInt64Size(usedSpaceAnnounceEpochField, a.epoch)
-	size += protoutil.NestedStructureSize(usedSpaceAnnounceCIDField, a.cid)
-	size += protoutil.UInt64Size(usedSpaceAnnounceUsedSpaceField, a.usedSpace)
-
-	return size
-}
-
-func (a *UsedSpaceAnnouncement) Unmarshal(data []byte) error {
-	return message.Unmarshal(a, data, new(container.AnnounceUsedSpaceRequest_Body_Announcement))
-}
-
-func (r *AnnounceUsedSpaceRequestBody) StableMarshal(buf []byte) []byte {
-	if r == nil {
-		return []byte{}
-	}
-
-	if buf == nil {
-		buf = make([]byte, r.StableSize())
-	}
-
-	var offset int
-
-	for i := range r.announcements {
-		offset += protoutil.NestedStructureMarshal(usedSpaceReqBodyAnnouncementsField, buf[offset:], &r.announcements[i])
-	}
-
-	return buf
-}
-
-func (r *AnnounceUsedSpaceRequestBody) StableSize() (size int) {
-	if r == nil {
-		return 0
-	}
-
-	for i := range r.announcements {
-		size += protoutil.NestedStructureSize(usedSpaceReqBodyAnnouncementsField, &r.announcements[i])
-	}
-
-	return size
-}
-
-func (r *AnnounceUsedSpaceRequestBody) Unmarshal(data []byte) error {
-	return message.Unmarshal(r, data, new(container.AnnounceUsedSpaceRequest_Body))
-}
-
-func (r *AnnounceUsedSpaceResponseBody) StableMarshal(_ []byte) []byte {
-	return nil
-}
-
-func (r *AnnounceUsedSpaceResponseBody) StableSize() (size int) {
-	return 0
-}
-
-func (r *AnnounceUsedSpaceResponseBody) Unmarshal([]byte) error {
-	return nil
-}

container/message_test.go

@@ -28,20 +28,9 @@ func TestMessageConvert(t *testing.T) {
 		func(empty bool) message.Message { return containertest.GenerateListRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateListResponse(empty) },
-		func(empty bool) message.Message { return containertest.GenerateSetExtendedACLRequestBody(empty) },
-		func(empty bool) message.Message { return containertest.GenerateSetExtendedACLRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequestBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetRequest(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponseBody(empty) },
 		func(empty bool) message.Message { return containertest.GenerateGetResponse(empty) },
-		func(empty bool) message.Message { return containertest.GenerateGetExtendedACLRequestBody(empty) },
-		func(empty bool) message.Message { return containertest.GenerateGetExtendedACLRequest(empty) },
-		func(empty bool) message.Message { return containertest.GenerateGetExtendedACLResponseBody(empty) },
-		func(empty bool) message.Message { return containertest.GenerateGetExtendedACLResponse(empty) },
-		func(empty bool) message.Message { return containertest.GenerateUsedSpaceAnnouncement(empty) },
-		func(empty bool) message.Message { return containertest.GenerateAnnounceUsedSpaceRequestBody(empty) },
-		func(empty bool) message.Message { return containertest.GenerateAnnounceUsedSpaceRequest(empty) },
-		func(empty bool) message.Message { return containertest.GenerateAnnounceUsedSpaceResponseBody(empty) },
-		func(empty bool) message.Message { return containertest.GenerateAnnounceUsedSpaceResponse(empty) },
 	)
 }

container/test/generate.go

@@ -1,7 +1,8 @@
 package containertest
 
 import (
-	acltest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl/test"
+	"crypto/rand"
+
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/container"
 	netmaptest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap/test"
 	refstest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/test"
@@ -36,8 +37,11 @@ func GenerateContainer(empty bool) *container.Container {
 	m := new(container.Container)
 
 	if !empty {
+		nonce := make([]byte, 16)
+		_, _ = rand.Read(nonce)
+
 		m.SetBasicACL(12)
-		m.SetNonce([]byte{1, 2, 3})
+		m.SetNonce(nonce)
 		m.SetOwnerID(refstest.GenerateOwnerID(false))
 		m.SetAttributes(GenerateAttributes(false))
 		m.SetPlacementPolicy(netmaptest.GeneratePlacementPolicy(false))
@@ -234,163 +238,3 @@ func GenerateListResponse(empty bool) *container.ListResponse {
 
 	return m
 }
-
-func GenerateSetExtendedACLRequestBody(empty bool) *container.SetExtendedACLRequestBody {
-	m := new(container.SetExtendedACLRequestBody)
-
-	if !empty {
-		m.SetEACL(acltest.GenerateTable(false))
-	}
-
-	m.SetSignature(refstest.GenerateSignature(empty))
-
-	return m
-}
-
-func GenerateSetExtendedACLRequest(empty bool) *container.SetExtendedACLRequest {
-	m := new(container.SetExtendedACLRequest)
-
-	if !empty {
-		m.SetBody(GenerateSetExtendedACLRequestBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
-
-	return m
-}
-
-func GenerateSetExtendedACLResponseBody(_ bool) *container.SetExtendedACLResponseBody {
-	m := new(container.SetExtendedACLResponseBody)
-
-	return m
-}
-
-func GenerateSetExtendedACLResponse(empty bool) *container.SetExtendedACLResponse {
-	m := new(container.SetExtendedACLResponse)
-
-	if !empty {
-		m.SetBody(GenerateSetExtendedACLResponseBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
-
-	return m
-}
-
-func GenerateGetExtendedACLRequestBody(empty bool) *container.GetExtendedACLRequestBody {
-	m := new(container.GetExtendedACLRequestBody)
-
-	if !empty {
-		m.SetContainerID(refstest.GenerateContainerID(false))
-	}
-
-	return m
-}
-
-func GenerateGetExtendedACLRequest(empty bool) *container.GetExtendedACLRequest {
-	m := new(container.GetExtendedACLRequest)
-
-	if !empty {
-		m.SetBody(GenerateGetExtendedACLRequestBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
-
-	return m
-}
-
-func GenerateGetExtendedACLResponseBody(empty bool) *container.GetExtendedACLResponseBody {
-	m := new(container.GetExtendedACLResponseBody)
-
-	if !empty {
-		m.SetEACL(acltest.GenerateTable(false))
-	}
-
-	m.SetSignature(refstest.GenerateSignature(empty))
-	m.SetSessionToken(sessiontest.GenerateSessionToken(empty))
-
-	return m
-}
-
-func GenerateGetExtendedACLResponse(empty bool) *container.GetExtendedACLResponse {
-	m := new(container.GetExtendedACLResponse)
-
-	if !empty {
-		m.SetBody(GenerateGetExtendedACLResponseBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
-
-	return m
-}
-
-func GenerateUsedSpaceAnnouncement(empty bool) *container.UsedSpaceAnnouncement {
-	m := new(container.UsedSpaceAnnouncement)
-
-	if !empty {
-		m.SetContainerID(refstest.GenerateContainerID(false))
-		m.SetEpoch(1)
-		m.SetUsedSpace(2)
-	}
-
-	return m
-}
-
-func GenerateUsedSpaceAnnouncements(empty bool) []container.UsedSpaceAnnouncement {
-	var res []container.UsedSpaceAnnouncement
-
-	if !empty {
-		res = append(res,
-			*GenerateUsedSpaceAnnouncement(false),
-			*GenerateUsedSpaceAnnouncement(false),
-		)
-	}
-
-	return res
-}
-
-func GenerateAnnounceUsedSpaceRequestBody(empty bool) *container.AnnounceUsedSpaceRequestBody {
-	m := new(container.AnnounceUsedSpaceRequestBody)
-
-	if !empty {
-		m.SetAnnouncements(GenerateUsedSpaceAnnouncements(false))
-	}
-
-	return m
-}
-
-func GenerateAnnounceUsedSpaceRequest(empty bool) *container.AnnounceUsedSpaceRequest {
-	m := new(container.AnnounceUsedSpaceRequest)
-
-	if !empty {
-		m.SetBody(GenerateAnnounceUsedSpaceRequestBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
-
-	return m
-}
-
-func GenerateAnnounceUsedSpaceResponseBody(_ bool) *container.AnnounceUsedSpaceResponseBody {
-	m := new(container.AnnounceUsedSpaceResponseBody)
-
-	return m
-}
-
-func GenerateAnnounceUsedSpaceResponse(empty bool) *container.AnnounceUsedSpaceResponse {
-	m := new(container.AnnounceUsedSpaceResponse)
-
-	if !empty {
-		m.SetBody(GenerateAnnounceUsedSpaceResponseBody(false))
-	}
-
-	m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
-	m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
-
-	return m
-}

container/types.go

@@ -1,7 +1,6 @@
 package container
 
 import (
-	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/acl"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
 	"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session"
@@ -110,76 +109,6 @@ type ListResponse struct {
 	session.ResponseHeaders
 }
 
-type SetExtendedACLRequestBody struct {
-	eacl *acl.Table
-
-	sig *refs.Signature
-}
-
-type SetExtendedACLRequest struct {
-	body *SetExtendedACLRequestBody
-
-	session.RequestHeaders
-}
-
-type SetExtendedACLResponseBody struct{}
-
-type SetExtendedACLResponse struct {
-	body *SetExtendedACLResponseBody
-
-	session.ResponseHeaders
-}
-
-type GetExtendedACLRequestBody struct {
-	cid *refs.ContainerID
-}
-
-type GetExtendedACLRequest struct {
-	body *GetExtendedACLRequestBody
-
-	session.RequestHeaders
-}
-
-type GetExtendedACLResponseBody struct {
-	eacl *acl.Table
-
-	sig *refs.Signature
-
-	token *session.Token
-}
-
-type GetExtendedACLResponse struct {
-	body *GetExtendedACLResponseBody
-
-	session.ResponseHeaders
-}
-
-type UsedSpaceAnnouncement struct {
-	epoch uint64
-
-	cid *refs.ContainerID
-
-	usedSpace uint64
-}
-
-type AnnounceUsedSpaceRequestBody struct {
-	announcements []UsedSpaceAnnouncement
-}
-
-type AnnounceUsedSpaceRequest struct {
-	body *AnnounceUsedSpaceRequestBody
-
-	session.RequestHeaders
-}
-
-type AnnounceUsedSpaceResponseBody struct{}
-
-type AnnounceUsedSpaceResponse struct {
-	body *AnnounceUsedSpaceResponseBody
-
-	session.ResponseHeaders
-}
-
 func (a *Attribute) GetKey() string {
 	if a != nil {
 		return a.key
@@ -515,203 +444,3 @@ func (r *ListResponse) GetBody() *ListResponseBody {
 func (r *ListResponse) SetBody(v *ListResponseBody) {
 	r.body = v
 }
-
-func (r *SetExtendedACLRequestBody) GetEACL() *acl.Table {
-	if r != nil {
-		return r.eacl
-	}
-
-	return nil
-}
-
-func (r *SetExtendedACLRequestBody) SetEACL(v *acl.Table) {
-	r.eacl = v
-}
-
-func (r *SetExtendedACLRequestBody) GetSignature() *refs.Signature {
-	if r != nil {
-		return r.sig
-	}
-
-	return nil
-}
-
-func (r *SetExtendedACLRequestBody) SetSignature(v *refs.Signature) {
-	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
-	v.SetScheme(0)
-	r.sig = v
-}
-
-func (r *SetExtendedACLRequest) GetBody() *SetExtendedACLRequestBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *SetExtendedACLRequest) SetBody(v *SetExtendedACLRequestBody) {
-	r.body = v
-}
-
-func (r *SetExtendedACLResponse) GetBody() *SetExtendedACLResponseBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *SetExtendedACLResponse) SetBody(v *SetExtendedACLResponseBody) {
-	r.body = v
-}
-
-func (r *GetExtendedACLRequestBody) GetContainerID() *refs.ContainerID {
-	if r != nil {
-		return r.cid
-	}
-
-	return nil
-}
-
-func (r *GetExtendedACLRequestBody) SetContainerID(v *refs.ContainerID) {
-	r.cid = v
-}
-
-func (r *GetExtendedACLRequest) GetBody() *GetExtendedACLRequestBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *GetExtendedACLRequest) SetBody(v *GetExtendedACLRequestBody) {
-	r.body = v
-}
-
-func (r *GetExtendedACLResponseBody) GetEACL() *acl.Table {
-	if r != nil {
-		return r.eacl
-	}
-
-	return nil
-}
-
-func (r *GetExtendedACLResponseBody) SetEACL(v *acl.Table) {
-	r.eacl = v
-}
-
-func (r *GetExtendedACLResponseBody) GetSignature() *refs.Signature {
-	if r != nil {
-		return r.sig
-	}
-
-	return nil
-}
-
-func (r *GetExtendedACLResponseBody) SetSignature(v *refs.Signature) {
-	// TODO: (neofs-api-go#381) avoid this hack (e.g. create refs.SignatureRFC6979 type)
-	v.SetScheme(0)
-	r.sig = v
-}
-
-// GetSessionToken returns token of the session within which requested
-// eACL table was set.
-func (r *GetExtendedACLResponseBody) GetSessionToken() *session.Token {
-	if r != nil {
-		return r.token
-	}
-
-	return nil
-}
-
-// SetSessionToken sets token of the session within which requested
-// eACL table was set.
-func (r *GetExtendedACLResponseBody) SetSessionToken(v *session.Token) {
-	r.token = v
-}
-
-func (r *GetExtendedACLResponse) GetBody() *GetExtendedACLResponseBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *GetExtendedACLResponse) SetBody(v *GetExtendedACLResponseBody) {
-	r.body = v
-}
-
-func (a *UsedSpaceAnnouncement) GetEpoch() uint64 {
-	if a != nil {
-		return a.epoch
-	}
-
-	return 0
-}
-
-func (a *UsedSpaceAnnouncement) SetEpoch(v uint64) {
-	a.epoch = v
-}
-
-func (a *UsedSpaceAnnouncement) GetUsedSpace() uint64 {
-	if a != nil {
-		return a.usedSpace
-	}
-
-	return 0
-}
-
-func (a *UsedSpaceAnnouncement) SetUsedSpace(v uint64) {
-	a.usedSpace = v
-}
-
-func (a *UsedSpaceAnnouncement) GetContainerID() *refs.ContainerID {
-	if a != nil {
-		return a.cid
-	}
-
-	return nil
-}
-
-func (a *UsedSpaceAnnouncement) SetContainerID(v *refs.ContainerID) {
-	a.cid = v
-}
-
-func (r *AnnounceUsedSpaceRequestBody) GetAnnouncements() []UsedSpaceAnnouncement {
-	if r != nil {
-		return r.announcements
-	}
-
-	return nil
-}
-
-func (r *AnnounceUsedSpaceRequestBody) SetAnnouncements(v []UsedSpaceAnnouncement) {
-	r.announcements = v
-}
-
-func (r *AnnounceUsedSpaceRequest) GetBody() *AnnounceUsedSpaceRequestBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *AnnounceUsedSpaceRequest) SetBody(v *AnnounceUsedSpaceRequestBody) {
-	r.body = v
-}
-
-func (r *AnnounceUsedSpaceResponse) GetBody() *AnnounceUsedSpaceResponseBody {
-	if r != nil {
-		return r.body
-	}
-
-	return nil
-}
-
-func (r *AnnounceUsedSpaceResponse) SetBody(v *AnnounceUsedSpaceResponseBody) {
-	r.body = v
-}

go.mod

@@ -1,36 +1,28 @@
 module git.frostfs.info/TrueCloudLab/frostfs-api-go/v2
 
-go 1.19
+go 1.22
 
 require (
 	git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0
+	github.com/VictoriaMetrics/easyproto v0.1.4
+	github.com/mailru/easyjson v0.7.7
 	github.com/stretchr/testify v1.8.3
-	go.opentelemetry.io/otel v1.15.1
+	golang.org/x/sync v0.7.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.15.1
+	google.golang.org/grpc v1.66.2
-	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.15.1
+	google.golang.org/protobuf v1.34.1
-	go.opentelemetry.io/otel/sdk v1.15.1
-	go.opentelemetry.io/otel/trace v1.15.1
-	golang.org/x/sync v0.2.0
-	google.golang.org/grpc v1.55.0
-	google.golang.org/protobuf v1.30.0
 )
 
 require (
 	git.frostfs.info/TrueCloudLab/rfc6979 v0.4.0 // indirect
-	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-logr/logr v1.2.4 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/kr/pretty v0.1.0 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2 // indirect
 	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.15.1 // indirect
+	golang.org/x/net v0.26.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.15.1 // indirect
+	golang.org/x/sys v0.21.0 // indirect
-	go.opentelemetry.io/proto/otlp v0.19.0 // indirect
+	golang.org/x/text v0.16.0 // indirect
-	golang.org/x/net v0.10.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117 // indirect
-	golang.org/x/sys v0.8.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,460 +1,48 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
-cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
-cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
-cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
-cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
-cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
-cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0 h1:FxqFDhQYYgpe41qsIHVOcdzSVCB8JNSfPG7Uk4r2oSk=
 git.frostfs.info/TrueCloudLab/frostfs-crypto v0.6.0/go.mod h1:RUIKZATQLJ+TaYQa60X2fTDwfuhMfm8Ar60bQ5fr+vU=
 git.frostfs.info/TrueCloudLab/rfc6979 v0.4.0 h1:M2KR3iBj7WpY3hP10IevfIB9MURr4O9mwVfJ+SjT3HA=
 git.frostfs.info/TrueCloudLab/rfc6979 v0.4.0/go.mod h1:okpbKfVYf/BpejtfFTfhZqFP+sZ8rsHrP8Rr/jYPNRc=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/VictoriaMetrics/easyproto v0.1.4 h1:r8cNvo8o6sR4QShBXQd1bKw/VVLSQma/V2KhTBPf+Sc=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/VictoriaMetrics/easyproto v0.1.4/go.mod h1:QlGlzaJnDfFd8Lk6Ci/fuLxfTo3/GThPs2KH23mv710=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
-github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
-github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
-github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
-github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2 h1:gDLXvp5S9izjldquuoAhDzccbskOL6tDC5jMSyx3zxE=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2/go.mod h1:7pdNwVWBBHGiCxa9lAszqCJMbfTISJ7oMftp8+UGV08=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
 github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
 github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-go.opentelemetry.io/otel v1.15.1 h1:3Iwq3lfRByPaws0f6bU3naAqOR1n5IeDWd9390kWHa8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117 h1:1GBuWVLM/KMVUv1t1En5Gs+gFZCNd360GGb4sSxtrhU=
-go.opentelemetry.io/otel v1.15.1/go.mod h1:mHHGEHVDLal6YrKMmk9LqC4a3sF5g+fHfrttQIB1NTc=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
-go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.15.1 h1:XYDQtNzdb2T4uM1pku2m76eSMDJgqhJ+6KzkqgQBALc=
+google.golang.org/grpc v1.66.2 h1:3QdXkuq3Bkh7w+ywLdLvM56cmGvQHUMZpiCzt6Rqaoo=
-go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.15.1/go.mod h1:uOTV75+LOzV+ODmL8ahRLWkFA3eQcSC2aAsbxIu4duk=
+google.golang.org/grpc v1.66.2/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.15.1 h1:tyoeaUh8REKay72DVYsSEBYV18+fGONe+YYPaOxgLoE=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.15.1/go.mod h1:HUSnrjQQ19KX9ECjpQxufsF+3ioD3zISPMlauTPZu2g=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.15.1 h1:pIfoG5IAZFzp9EUlJzdSkpUwpaUAAnD+Ru1nBLTACIQ=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.15.1/go.mod h1:poNKBqF5+nR/6ke2oGTDjHfksrsHDOHXAl2g4+9ONsY=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.15.1 h1:2PunuO5SbkN5MhCbuHCd3tC6qrcaj+uDAkX/qBU5BAs=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.15.1/go.mod h1:q8+Tha+5LThjeSU8BW93uUC5w5/+DnYHMKBMpRCsui0=
-go.opentelemetry.io/otel/sdk v1.15.1 h1:5FKR+skgpzvhPQHIEfcwMYjCBr14LWzs3uSqKiQzETI=
-go.opentelemetry.io/otel/sdk v1.15.1/go.mod h1:8rVtxQfrbmbHKfqzpQkT5EzZMcbMBwTzNAggbEAM0KA=
-go.opentelemetry.io/otel/trace v1.15.1 h1:uXLo6iHJEzDfrNC0L0mNjItIp06SyaBQxu5t3xMlngY=
-go.opentelemetry.io/otel/trace v1.15.1/go.mod h1:IWdQG/5N1x7f6YUlmdLeJvH9yxtuJAfc4VW5Agv9r/8=
-go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw=
-go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
-golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
-golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
-google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
-google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
-google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/grpc v1.55.0 h1:3Oj82/tFSCeUrRTg/5E/7d/W5A1tj6Ky1ABAuZuv5ag=
-google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

internal/random/rand.go

@@ -1,15 +0,0 @@
-package random
-
-import (
-	"math/rand"
-	"time"
-)
-
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
-// Uint32 returns random uint32 value [0, max).
-func Uint32(max uint32) uint32 {
-	return rand.Uint32() % max
-}

lock/grpc/types.go

@@ -1,8 +0,0 @@
-package lock
-
-import refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-
-// SetMembers sets `members` field.
-func (x *Lock) SetMembers(ids []*refs.ObjectID) {
-	x.Members = ids
-}

lock/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,26 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package lock
+
+func DoFuzzProtoLock(data []byte) int {
+	msg := new(Lock)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLock(data []byte) int {
+	msg := new(Lock)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

lock/grpc/types_frostfs_test.go

@@ -0,0 +1,21 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package lock
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoLock(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLock(data)
+	})
+}
+func FuzzJSONLock(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLock(data)
+	})
+}

netmap/convert.go

@@ -45,28 +45,26 @@ func (f *Filter) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func FiltersToGRPC(fs []Filter) (res []*netmap.Filter) {
+func FiltersToGRPC(fs []Filter) (res []netmap.Filter) {
 	if fs != nil {
-		res = make([]*netmap.Filter, 0, len(fs))
+		res = make([]netmap.Filter, 0, len(fs))
 
 		for i := range fs {
-			res = append(res, fs[i].ToGRPCMessage().(*netmap.Filter))
+			res = append(res, *fs[i].ToGRPCMessage().(*netmap.Filter))
 		}
 	}
 
 	return
 }
 
-func FiltersFromGRPC(fs []*netmap.Filter) (res []Filter, err error) {
+func FiltersFromGRPC(fs []netmap.Filter) (res []Filter, err error) {
 	if fs != nil {
 		res = make([]Filter, len(fs))
 
 		for i := range fs {
-			if fs[i] != nil {
+			err = res[i].FromGRPCMessage(&fs[i])
-				err = res[i].FromGRPCMessage(fs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -105,28 +103,26 @@ func (s *Selector) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func SelectorsToGRPC(ss []Selector) (res []*netmap.Selector) {
+func SelectorsToGRPC(ss []Selector) (res []netmap.Selector) {
 	if ss != nil {
-		res = make([]*netmap.Selector, 0, len(ss))
+		res = make([]netmap.Selector, 0, len(ss))
 
 		for i := range ss {
-			res = append(res, ss[i].ToGRPCMessage().(*netmap.Selector))
+			res = append(res, *ss[i].ToGRPCMessage().(*netmap.Selector))
 		}
 	}
 
 	return
 }
 
-func SelectorsFromGRPC(ss []*netmap.Selector) (res []Selector, err error) {
+func SelectorsFromGRPC(ss []netmap.Selector) (res []Selector, err error) {
 	if ss != nil {
 		res = make([]Selector, len(ss))
 
 		for i := range ss {
-			if ss[i] != nil {
+			err = res[i].FromGRPCMessage(&ss[i])
-				err = res[i].FromGRPCMessage(ss[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -142,6 +138,8 @@ func (r *Replica) ToGRPCMessage() grpc.Message {
 
 		m.SetSelector(r.selector)
 		m.SetCount(r.count)
+		m.EcDataCount = r.ecDataCount
+		m.EcParityCount = r.ecParityCount
 	}
 
 	return m
@@ -155,32 +153,32 @@ func (r *Replica) FromGRPCMessage(m grpc.Message) error {
 
 	r.selector = v.GetSelector()
 	r.count = v.GetCount()
+	r.ecDataCount = v.GetEcDataCount()
+	r.ecParityCount = v.GetEcParityCount()
 
 	return nil
 }
 
-func ReplicasToGRPC(rs []Replica) (res []*netmap.Replica) {
+func ReplicasToGRPC(rs []Replica) (res []netmap.Replica) {
 	if rs != nil {
-		res = make([]*netmap.Replica, 0, len(rs))
+		res = make([]netmap.Replica, 0, len(rs))
 
 		for i := range rs {
-			res = append(res, rs[i].ToGRPCMessage().(*netmap.Replica))
+			res = append(res, *rs[i].ToGRPCMessage().(*netmap.Replica))
 		}
 	}
 
 	return
 }
 
-func ReplicasFromGRPC(rs []*netmap.Replica) (res []Replica, err error) {
+func ReplicasFromGRPC(rs []netmap.Replica) (res []Replica, err error) {
 	if rs != nil {
 		res = make([]Replica, len(rs))
 
 		for i := range rs {
-			if rs[i] != nil {
+			err = res[i].FromGRPCMessage(&rs[i])
-				err = res[i].FromGRPCMessage(rs[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -198,6 +196,7 @@ func (p *PlacementPolicy) ToGRPCMessage() grpc.Message {
 		m.SetSelectors(SelectorsToGRPC(p.selectors))
 		m.SetReplicas(ReplicasToGRPC(p.replicas))
 		m.SetContainerBackupFactor(p.backupFactor)
+		m.SetUnique(p.unique)
 	}
 
 	return m
@@ -228,6 +227,8 @@ func (p *PlacementPolicy) FromGRPCMessage(m grpc.Message) error {
 
 	p.backupFactor = v.GetContainerBackupFactor()
 
+	p.unique = v.GetUnique()
+
 	return nil
 }
 
@@ -282,28 +283,26 @@ func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
-func AttributesToGRPC(as []Attribute) (res []*netmap.NodeInfo_Attribute) {
+func AttributesToGRPC(as []Attribute) (res []netmap.NodeInfo_Attribute) {
 	if as != nil {
-		res = make([]*netmap.NodeInfo_Attribute, 0, len(as))
+		res = make([]netmap.NodeInfo_Attribute, 0, len(as))
 
 		for i := range as {
-			res = append(res, as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
+			res = append(res, *as[i].ToGRPCMessage().(*netmap.NodeInfo_Attribute))
 		}
 	}
 
 	return
 }
 
-func AttributesFromGRPC(as []*netmap.NodeInfo_Attribute) (res []Attribute, err error) {
+func AttributesFromGRPC(as []netmap.NodeInfo_Attribute) (res []Attribute, err error) {
 	if as != nil {
 		res = make([]Attribute, len(as))
 
 		for i := range as {
-			if as[i] != nil {
+			err = res[i].FromGRPCMessage(&as[i])
-				err = res[i].FromGRPCMessage(as[i])
+			if err != nil {
-				if err != nil {
+				return
-					return
-				}
 			}
 		}
 	}
@@ -521,13 +520,13 @@ func (x *NetworkConfig) ToGRPCMessage() grpc.Message {
 	if x != nil {
 		m = new(netmap.NetworkConfig)
 
-		var ps []*netmap.NetworkConfig_Parameter
+		var ps []netmap.NetworkConfig_Parameter
 
 		if ln := len(x.ps); ln > 0 {
-			ps = make([]*netmap.NetworkConfig_Parameter, 0, ln)
+			ps = make([]netmap.NetworkConfig_Parameter, 0, ln)
 
-			for i := 0; i < ln; i++ {
+			for i := range ln {
-				ps = append(ps, x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
+				ps = append(ps, *x.ps[i].ToGRPCMessage().(*netmap.NetworkConfig_Parameter))
 			}
 		}
 
@@ -553,11 +552,9 @@ func (x *NetworkConfig) FromGRPCMessage(m grpc.Message) error {
 
 		ps = make([]NetworkParameter, ln)
 
-		for i := 0; i < ln; i++ {
+		for i := range ln {
-			if psV2[i] != nil {
+			if err := ps[i].FromGRPCMessage(&psV2[i]); err != nil {
-				if err := ps[i].FromGRPCMessage(psV2[i]); err != nil {
+				return err
-					return err
-				}
 			}
 		}
 	}
@@ -749,10 +746,10 @@ func (x *NetMap) ToGRPCMessage() grpc.Message {
 		m.SetEpoch(x.epoch)
 
 		if x.nodes != nil {
-			nodes := make([]*netmap.NodeInfo, len(x.nodes))
+			nodes := make([]netmap.NodeInfo, len(x.nodes))
 
 			for i := range x.nodes {
-				nodes[i] = x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
+				nodes[i] = *x.nodes[i].ToGRPCMessage().(*netmap.NodeInfo)
 			}
 
 			m.SetNodes(nodes)
@@ -777,7 +774,7 @@ func (x *NetMap) FromGRPCMessage(m grpc.Message) error {
 		x.nodes = make([]NodeInfo, len(nodes))
 
 		for i := range nodes {
-			err = x.nodes[i].FromGRPCMessage(nodes[i])
+			err = x.nodes[i].FromGRPCMessage(&nodes[i])
 			if err != nil {
 				return err
 			}

netmap/grpc/service.go

@@ -1,116 +0,0 @@
-package netmap
-
-import (
-	refs "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
-	session "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/grpc"
-)
-
-// SetBody sets body of the request.
-func (m *LocalNodeInfoRequest) SetBody(v *LocalNodeInfoRequest_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (m *LocalNodeInfoRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (m *LocalNodeInfoRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetVersion sets version of response body.
-func (m *LocalNodeInfoResponse_Body) SetVersion(v *refs.Version) {
-	m.Version = v
-}
-
-// SetNodeInfo sets node info of response body.
-func (m *LocalNodeInfoResponse_Body) SetNodeInfo(v *NodeInfo) {
-	m.NodeInfo = v
-}
-
-// SetBody sets body of the response.
-func (m *LocalNodeInfoResponse) SetBody(v *LocalNodeInfoResponse_Body) {
-	m.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (m *LocalNodeInfoResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	m.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (m *LocalNodeInfoResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	m.VerifyHeader = v
-}
-
-// SetBody sets body of the request.
-func (x *NetworkInfoRequest) SetBody(v *NetworkInfoRequest_Body) {
-	x.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (x *NetworkInfoRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	x.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (x *NetworkInfoRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	x.VerifyHeader = v
-}
-
-// SetNetworkInfo sets information about the network.
-func (x *NetworkInfoResponse_Body) SetNetworkInfo(v *NetworkInfo) {
-	x.NetworkInfo = v
-}
-
-// SetBody sets body of the response.
-func (x *NetworkInfoResponse) SetBody(v *NetworkInfoResponse_Body) {
-	x.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (x *NetworkInfoResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	x.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (x *NetworkInfoResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	x.VerifyHeader = v
-}
-
-// SetBody sets body of the request.
-func (x *NetmapSnapshotRequest) SetBody(v *NetmapSnapshotRequest_Body) {
-	x.Body = v
-}
-
-// SetMetaHeader sets meta header of the request.
-func (x *NetmapSnapshotRequest) SetMetaHeader(v *session.RequestMetaHeader) {
-	x.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the request.
-func (x *NetmapSnapshotRequest) SetVerifyHeader(v *session.RequestVerificationHeader) {
-	x.VerifyHeader = v
-}
-
-// SetNetmap sets current Netmap.
-func (x *NetmapSnapshotResponse_Body) SetNetmap(v *Netmap) {
-	x.Netmap = v
-}
-
-// SetBody sets body of the response.
-func (x *NetmapSnapshotResponse) SetBody(v *NetmapSnapshotResponse_Body) {
-	x.Body = v
-}
-
-// SetMetaHeader sets meta header of the response.
-func (x *NetmapSnapshotResponse) SetMetaHeader(v *session.ResponseMetaHeader) {
-	x.MetaHeader = v
-}
-
-// SetVerifyHeader sets verification header of the response.
-func (x *NetmapSnapshotResponse) SetVerifyHeader(v *session.ResponseVerificationHeader) {
-	x.VerifyHeader = v
-}

netmap/grpc/service_frostfs_fuzz.go

@@ -0,0 +1,121 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+func DoFuzzProtoLocalNodeInfoRequest(data []byte) int {
+	msg := new(LocalNodeInfoRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLocalNodeInfoRequest(data []byte) int {
+	msg := new(LocalNodeInfoRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoLocalNodeInfoResponse(data []byte) int {
+	msg := new(LocalNodeInfoResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONLocalNodeInfoResponse(data []byte) int {
+	msg := new(LocalNodeInfoResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfoRequest(data []byte) int {
+	msg := new(NetworkInfoRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfoRequest(data []byte) int {
+	msg := new(NetworkInfoRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfoResponse(data []byte) int {
+	msg := new(NetworkInfoResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfoResponse(data []byte) int {
+	msg := new(NetworkInfoResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmapSnapshotRequest(data []byte) int {
+	msg := new(NetmapSnapshotRequest)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmapSnapshotRequest(data []byte) int {
+	msg := new(NetmapSnapshotRequest)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmapSnapshotResponse(data []byte) int {
+	msg := new(NetmapSnapshotResponse)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmapSnapshotResponse(data []byte) int {
+	msg := new(NetmapSnapshotResponse)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

netmap/grpc/service_frostfs_test.go

@@ -0,0 +1,71 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoLocalNodeInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLocalNodeInfoRequest(data)
+	})
+}
+func FuzzJSONLocalNodeInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLocalNodeInfoRequest(data)
+	})
+}
+func FuzzProtoLocalNodeInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoLocalNodeInfoResponse(data)
+	})
+}
+func FuzzJSONLocalNodeInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONLocalNodeInfoResponse(data)
+	})
+}
+func FuzzProtoNetworkInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfoRequest(data)
+	})
+}
+func FuzzJSONNetworkInfoRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfoRequest(data)
+	})
+}
+func FuzzProtoNetworkInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfoResponse(data)
+	})
+}
+func FuzzJSONNetworkInfoResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfoResponse(data)
+	})
+}
+func FuzzProtoNetmapSnapshotRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmapSnapshotRequest(data)
+	})
+}
+func FuzzJSONNetmapSnapshotRequest(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmapSnapshotRequest(data)
+	})
+}
+func FuzzProtoNetmapSnapshotResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmapSnapshotResponse(data)
+	})
+}
+func FuzzJSONNetmapSnapshotResponse(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmapSnapshotResponse(data)
+	})
+}

netmap/grpc/types.go

@@ -1,207 +0,0 @@
-package netmap
-
-// SetReplicas of placement policy.
-func (m *PlacementPolicy) SetReplicas(v []*Replica) {
-	m.Replicas = v
-}
-
-// SetContainerBackupFactor of placement policy.
-func (m *PlacementPolicy) SetContainerBackupFactor(v uint32) {
-	m.ContainerBackupFactor = v
-}
-
-// SetSelectors of placement policy.
-func (m *PlacementPolicy) SetSelectors(v []*Selector) {
-	m.Selectors = v
-}
-
-// SetFilters of placement policy.
-func (m *PlacementPolicy) SetFilters(v []*Filter) {
-	m.Filters = v
-}
-
-// SetName of placement filter.
-func (m *Filter) SetName(v string) {
-	m.Name = v
-}
-
-// SetKey of placement filter.
-func (m *Filter) SetKey(v string) {
-	m.Key = v
-}
-
-// SetOperation of placement filter.
-func (m *Filter) SetOp(v Operation) {
-	m.Op = v
-}
-
-// SetValue of placement filter.
-func (m *Filter) SetValue(v string) {
-	m.Value = v
-}
-
-// SetFilters sets sub-filters of placement filter.
-func (m *Filter) SetFilters(v []*Filter) {
-	m.Filters = v
-}
-
-// SetName of placement selector.
-func (m *Selector) SetName(v string) {
-	m.Name = v
-}
-
-// SetCount of nodes of placement selector.
-func (m *Selector) SetCount(v uint32) {
-	m.Count = v
-}
-
-// SetAttribute of nodes of placement selector.
-func (m *Selector) SetAttribute(v string) {
-	m.Attribute = v
-}
-
-// SetFilter of placement selector.
-func (m *Selector) SetFilter(v string) {
-	m.Filter = v
-}
-
-// SetClause of placement selector.
-func (m *Selector) SetClause(v Clause) {
-	m.Clause = v
-}
-
-// SetCount of object replica.
-func (m *Replica) SetCount(v uint32) {
-	m.Count = v
-}
-
-// SetSelector of object replica.
-func (m *Replica) SetSelector(v string) {
-	m.Selector = v
-}
-
-// SetKey sets key to the node attribute.
-func (m *NodeInfo_Attribute) SetKey(v string) {
-	m.Key = v
-}
-
-// SetValue sets value of the node attribute.
-func (m *NodeInfo_Attribute) SetValue(v string) {
-	m.Value = v
-}
-
-// SetParent sets value of the node parents.
-func (m *NodeInfo_Attribute) SetParents(v []string) {
-	m.Parents = v
-}
-
-// SetAddress sets node network address.
-//
-// Deprecated: use SetAddresses.
-func (m *NodeInfo) SetAddress(v string) {
-	m.SetAddresses([]string{v})
-}
-
-// SetAddresses sets list of network addresses of the node.
-func (m *NodeInfo) SetAddresses(v []string) {
-	m.Addresses = v
-}
-
-// SetPublicKey sets node public key in a binary format.
-func (m *NodeInfo) SetPublicKey(v []byte) {
-	m.PublicKey = v
-}
-
-// SetAttributes sets list of the node attributes.
-func (m *NodeInfo) SetAttributes(v []*NodeInfo_Attribute) {
-	m.Attributes = v
-}
-
-// SetState sets node state.
-func (m *NodeInfo) SetState(v NodeInfo_State) {
-	m.State = v
-}
-
-// SetCurrentEpoch sets number of the current epoch.
-func (x *NetworkInfo) SetCurrentEpoch(v uint64) {
-	x.CurrentEpoch = v
-}
-
-// SetMagicNumber sets magic number of the sidechain.
-func (x *NetworkInfo) SetMagicNumber(v uint64) {
-	x.MagicNumber = v
-}
-
-// SetMsPerBlock sets MillisecondsPerBlock network parameter.
-func (x *NetworkInfo) SetMsPerBlock(v int64) {
-	x.MsPerBlock = v
-}
-
-// SetNetworkConfig sets NeoFS network configuration.
-func (x *NetworkInfo) SetNetworkConfig(v *NetworkConfig) {
-	x.NetworkConfig = v
-}
-
-// FromString parses Clause from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *Clause) FromString(s string) bool {
-	i, ok := Clause_value[s]
-	if ok {
-		*x = Clause(i)
-	}
-
-	return ok
-}
-
-// FromString parses Operation from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *Operation) FromString(s string) bool {
-	i, ok := Operation_value[s]
-	if ok {
-		*x = Operation(i)
-	}
-
-	return ok
-}
-
-// FromString parses NodeInfo_State from a string representation,
-// It is a reverse action to String().
-//
-// Returns true if s was parsed successfully.
-func (x *NodeInfo_State) FromString(s string) bool {
-	i, ok := NodeInfo_State_value[s]
-	if ok {
-		*x = NodeInfo_State(i)
-	}
-
-	return ok
-}
-
-// SetKey sets parameter key.
-func (x *NetworkConfig_Parameter) SetKey(v []byte) {
-	x.Key = v
-}
-
-// SetValue sets parameter value.
-func (x *NetworkConfig_Parameter) SetValue(v []byte) {
-	x.Value = v
-}
-
-// SetParameters sets NeoFS network parameters.
-func (x *NetworkConfig) SetParameters(v []*NetworkConfig_Parameter) {
-	x.Parameters = v
-}
-
-// SetEpoch sets revision number of the Netmap.
-func (x *Netmap) SetEpoch(v uint64) {
-	x.Epoch = v
-}
-
-// SetNodes sets nodes presented in the Netmap.
-func (x *Netmap) SetNodes(v []*NodeInfo) {
-	x.Nodes = v
-}

netmap/grpc/types_frostfs_fuzz.go

@@ -0,0 +1,159 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+func DoFuzzProtoFilter(data []byte) int {
+	msg := new(Filter)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONFilter(data []byte) int {
+	msg := new(Filter)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoSelector(data []byte) int {
+	msg := new(Selector)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONSelector(data []byte) int {
+	msg := new(Selector)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoReplica(data []byte) int {
+	msg := new(Replica)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONReplica(data []byte) int {
+	msg := new(Replica)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoPlacementPolicy(data []byte) int {
+	msg := new(PlacementPolicy)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONPlacementPolicy(data []byte) int {
+	msg := new(PlacementPolicy)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNodeInfo(data []byte) int {
+	msg := new(NodeInfo)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNodeInfo(data []byte) int {
+	msg := new(NodeInfo)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetmap(data []byte) int {
+	msg := new(Netmap)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetmap(data []byte) int {
+	msg := new(Netmap)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkConfig(data []byte) int {
+	msg := new(NetworkConfig)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkConfig(data []byte) int {
+	msg := new(NetworkConfig)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}
+func DoFuzzProtoNetworkInfo(data []byte) int {
+	msg := new(NetworkInfo)
+	if err := msg.UnmarshalProtobuf(data); err != nil {
+		return 0
+	}
+	_ = msg.MarshalProtobuf(nil)
+	return 1
+}
+func DoFuzzJSONNetworkInfo(data []byte) int {
+	msg := new(NetworkInfo)
+	if err := msg.UnmarshalJSON(data); err != nil {
+		return 0
+	}
+	_, err := msg.MarshalJSON()
+	if err != nil {
+		panic(err)
+	}
+	return 1
+}

netmap/grpc/types_frostfs_test.go

@@ -0,0 +1,91 @@
+//go:build gofuzz
+// +build gofuzz
+
+// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
+
+package netmap
+
+import (
+	testing "testing"
+)
+
+func FuzzProtoFilter(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoFilter(data)
+	})
+}
+func FuzzJSONFilter(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONFilter(data)
+	})
+}
+func FuzzProtoSelector(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoSelector(data)
+	})
+}
+func FuzzJSONSelector(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONSelector(data)
+	})
+}
+func FuzzProtoReplica(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoReplica(data)
+	})
+}
+func FuzzJSONReplica(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONReplica(data)
+	})
+}
+func FuzzProtoPlacementPolicy(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoPlacementPolicy(data)
+	})
+}
+func FuzzJSONPlacementPolicy(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONPlacementPolicy(data)
+	})
+}
+func FuzzProtoNodeInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNodeInfo(data)
+	})
+}
+func FuzzJSONNodeInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNodeInfo(data)
+	})
+}
+func FuzzProtoNetmap(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetmap(data)
+	})
+}
+func FuzzJSONNetmap(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetmap(data)
+	})
+}
+func FuzzProtoNetworkConfig(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkConfig(data)
+	})
+}
+func FuzzJSONNetworkConfig(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkConfig(data)
+	})
+}
+func FuzzProtoNetworkInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzProtoNetworkInfo(data)
+	})
+}
+func FuzzJSONNetworkInfo(f *testing.F) {
+	f.Fuzz(func(t *testing.T, data []byte) {
+		DoFuzzJSONNetworkInfo(data)
+	})
+}

netmap/marshal.go

@@ -19,13 +19,16 @@ const (
 	attributeSelectorField = 4
 	filterSelectorField    = 5
 
-	countReplicaField    = 1
+	countReplicaField         = 1
-	selectorReplicaField = 2
+	selectorReplicaField      = 2
+	ecDataCountReplicaField   = 3
+	ecParityCountReplicaField = 4
 
 	replicasPolicyField  = 1
 	backupPolicyField    = 2
 	selectorsPolicyField = 3
 	filtersPolicyField   = 4
+	uniquePolicyField    = 5
 
 	keyAttributeField     = 1
 	valueAttributeField   = 2
@@ -64,6 +67,10 @@ func (f *Filter) StableMarshal(buf []byte) []byte {
 }
 
 func (f *Filter) StableSize() (size int) {
+	if f == nil {
+		return 0
+	}
+
 	size += protoutil.StringSize(nameFilterField, f.name)
 	size += protoutil.StringSize(keyFilterField, f.key)
 	size += protoutil.EnumSize(opFilterField, int32(f.op))
@@ -100,6 +107,10 @@ func (s *Selector) StableMarshal(buf []byte) []byte {
 }
 
 func (s *Selector) StableSize() (size int) {
+	if s == nil {
+		return 0
+	}
+
 	size += protoutil.StringSize(nameSelectorField, s.name)
 	size += protoutil.UInt32Size(countSelectorField, s.count)
 	size += protoutil.EnumSize(countSelectorField, int32(s.clause))
@@ -125,14 +136,22 @@ func (r *Replica) StableMarshal(buf []byte) []byte {
 	var offset int
 
 	offset += protoutil.UInt32Marshal(countReplicaField, buf[offset:], r.count)
-	protoutil.StringMarshal(selectorReplicaField, buf[offset:], r.selector)
+	offset += protoutil.StringMarshal(selectorReplicaField, buf[offset:], r.selector)
+	offset += protoutil.UInt32Marshal(ecDataCountReplicaField, buf[offset:], r.ecDataCount)
+	protoutil.UInt32Marshal(ecParityCountReplicaField, buf[offset:], r.ecParityCount)
 
 	return buf
 }
 
 func (r *Replica) StableSize() (size int) {
+	if r == nil {
+		return 0
+	}
+
 	size += protoutil.UInt32Size(countReplicaField, r.count)
 	size += protoutil.StringSize(selectorReplicaField, r.selector)
+	size += protoutil.UInt32Size(ecDataCountReplicaField, r.ecDataCount)
+	size += protoutil.UInt32Size(ecParityCountReplicaField, r.ecParityCount)
 
 	return size
 }
@@ -166,10 +185,16 @@ func (p *PlacementPolicy) StableMarshal(buf []byte) []byte {
 		offset += protoutil.NestedStructureMarshal(filtersPolicyField, buf[offset:], &p.filters[i])
 	}
 
+	protoutil.BoolMarshal(uniquePolicyField, buf[offset:], p.unique)
+
 	return buf
 }
 
 func (p *PlacementPolicy) StableSize() (size int) {
+	if p == nil {
+		return 0
+	}
+
 	for i := range p.replicas {
 		size += protoutil.NestedStructureSize(replicasPolicyField, &p.replicas[i])
 	}
@@ -184,6 +209,8 @@ func (p *PlacementPolicy) StableSize() (size int) {
 		size += protoutil.NestedStructureSize(filtersPolicyField, &p.filters[i])
 	}
 
+	size += protoutil.BoolSize(uniquePolicyField, p.unique)
+
 	return size
 }
 

netmap/test/generate.go

@@ -81,6 +81,17 @@ func GenerateReplica(empty bool) *netmap.Replica {
 	return m
 }
 
+func GenerateEC(empty bool) *netmap.Replica {
+	m := new(netmap.Replica)
+
+	if !empty {
+		m.SetECDataCount(4)
+		m.SetECParityCount(2)
+	}
+
+	return m
+}
+
 func GenerateReplicas(empty bool) []netmap.Replica {
 	var res []netmap.Replica
 
@@ -88,6 +99,7 @@ func GenerateReplicas(empty bool) []netmap.Replica {
 		res = append(res,
 			*GenerateReplica(false),
 			*GenerateReplica(false),
+			*GenerateEC(false),
 		)
 	}
 
@@ -102,6 +114,7 @@ func GeneratePlacementPolicy(empty bool) *netmap.PlacementPolicy {
 		m.SetFilters(GenerateFilters(false))
 		m.SetSelectors(GenerateSelectors(false))
 		m.SetReplicas(GenerateReplicas(false))
+		m.SetUnique(true)
 	}
 
 	return m

netmap/types.go

@@ -50,16 +50,19 @@ type Selector struct {
 type Replica struct {
 	count    uint32
 	selector string
+
+	ecDataCount   uint32
+	ecParityCount uint32
 }
 
 type Operation uint32
 
 type PlacementPolicy struct {
-	unique       bool
 	replicas     []Replica
 	backupFactor uint32
 	selectors    []Selector
 	filters      []Filter
+	unique       bool
 }
 
 // Attribute of storage node.
@@ -108,6 +111,7 @@ const (
 	OR
 	AND
 	NOT
+	LIKE
 )
 
 const (
@@ -259,6 +263,30 @@ func (r *Replica) SetCount(count uint32) {
 	r.count = count
 }
 
+func (r *Replica) GetECDataCount() uint32 {
+	if r != nil {
+		return r.ecDataCount
+	}
+
+	return 0
+}
+
+func (r *Replica) SetECDataCount(count uint32) {
+	r.ecDataCount = count
+}
+
+func (r *Replica) GetECParityCount() uint32 {
+	if r != nil {
+		return r.ecParityCount
+	}
+
+	return 0
+}
+
+func (r *Replica) SetECParityCount(count uint32) {
+	r.ecParityCount = count
+}
+
 func (p *PlacementPolicy) GetUnique() bool {
 	if p != nil {
 		return p.unique
@@ -307,6 +335,10 @@ func (p *PlacementPolicy) SetContainerBackupFactor(backupFactor uint32) {
 }
 
 func (p *PlacementPolicy) GetReplicas() []Replica {
+	if p == nil {
+		return nil
+	}
+
 	return p.replicas
 }
 

object/attributes_test.go

@@ -10,7 +10,7 @@ import (
 func TestSetNotification(t *testing.T) {
 	o := new(Object)
 
-	var ni = NotificationInfo{
+	ni := NotificationInfo{
 		epoch: 10,
 		topic: "test",
 	}