From 1ae89614d4652e27b3a76a2c8b9dc507d86336a2 Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Wed, 17 Apr 2024 13:24:59 +0800 Subject: [PATCH 1/7] chore(*): use strict fomatter --- .flox/.gitignore | 2 + .flox/env.json | 4 + .flox/env/manifest.lock | 254 +++++++++++ .flox/env/manifest.toml | 45 ++ .github/workflows/damocles-manager.yaml | 44 +- .github/workflows/damocles-worker-util.yaml | 13 +- .github/workflows/damocles-worker.yaml | 24 +- Makefile | 51 ++- README.md | 7 + damocles-manager/.golangci.yml | 425 ++++++++++++++++-- damocles-manager/Makefile | 21 +- .../cmd/damocles-manager/internal/global.go | 21 +- .../damocles-manager/internal/global_test.go | 1 - .../cmd/damocles-manager/internal/run.go | 4 +- .../internal/util_kvstore_migrate.go | 2 +- .../damocles-manager/internal/util_miner.go | 1 - .../internal/util_sealer_actor.go | 51 ++- .../internal/util_sealer_proving.go | 104 ++++- .../internal/util_sealer_sectors.go | 305 ++++++++----- .../internal/util_sealer_snap.go | 6 +- .../damocles-manager/internal/util_storage.go | 53 ++- .../damocles-manager/internal/util_worker.go | 19 +- damocles-manager/cmd/damocles-manager/main.go | 2 - damocles-manager/cmd/damocles-manager/mock.go | 1 - .../cmd/damocles-manager/server.go | 4 +- damocles-manager/cmd/plugin/main.go | 1 - damocles-manager/core/api.go | 48 +- damocles-manager/core/ifaces.go | 58 ++- damocles-manager/core/prover.go | 39 +- damocles-manager/core/types.go | 8 +- damocles-manager/core/types_sector_state.go | 20 +- damocles-manager/core/types_wdpost.go | 7 +- damocles-manager/dep/gateway.go | 39 +- damocles-manager/dep/poster.go | 1 + damocles-manager/dep/prover.go | 23 +- damocles-manager/dep/sealer.go | 8 +- damocles-manager/dep/sealer_constructor.go | 170 +++++-- damocles-manager/dep/util.go | 7 +- damocles-manager/metrics/metrics.go | 100 ++++- damocles-manager/metrics/proxy/proxy.go | 30 +- damocles-manager/modules/address/lookup_id.go | 50 ++- .../modules/address/sender_selector.go | 158 +++++-- .../modules/address/sender_selector_test.go | 84 +++- damocles-manager/modules/config.go | 55 ++- damocles-manager/modules/config_util.go | 1 - damocles-manager/modules/config_util_test.go | 28 +- .../modules/impl/commitmgr/batcher.go | 24 +- .../modules/impl/commitmgr/check.go | 147 ++++-- .../impl/commitmgr/commit_processor.go | 68 ++- .../modules/impl/commitmgr/commitmgr.go | 87 +++- .../modules/impl/commitmgr/params.go | 16 +- .../modules/impl/commitmgr/policy.go | 31 +- .../impl/commitmgr/precommit_processor.go | 21 +- .../modules/impl/commitmgr/sealing.go | 106 ++++- .../modules/impl/commitmgr/sealing_api.go | 62 ++- .../impl/commitmgr/terminate_processor.go | 105 ++++- .../modules/impl/dealmgr/dealmgr.go | 9 +- damocles-manager/modules/impl/mock/commit.go | 16 +- damocles-manager/modules/impl/mock/deal.go | 14 +- .../modules/impl/mock/randomness.go | 20 +- damocles-manager/modules/impl/mock/sealer.go | 165 +++++-- damocles-manager/modules/impl/mock/sector.go | 6 +- .../modules/impl/prover/ext/prover.go | 85 +++- .../modules/impl/prover/prover_fake.go | 41 +- .../modules/impl/prover/prover_prod.go | 69 ++- .../modules/impl/prover/worker/job_mgr_kv.go | 56 ++- .../impl/prover/worker/job_mgr_kv_test.go | 2 +- .../modules/impl/prover/worker/prover.go | 57 ++- .../modules/impl/prover/worker/rpc.go | 20 +- .../modules/impl/randomness/rand.go | 53 ++- .../modules/impl/sectors/indexer.go | 1 - .../modules/impl/sectors/indexer_proxy.go | 2 +- damocles-manager/modules/impl/sectors/mgr.go | 6 +- .../modules/impl/sectors/miner_selector.go | 8 +- .../modules/impl/sectors/number_allocator.go | 8 +- .../impl/sectors/number_allocator_test.go | 11 +- .../modules/impl/sectors/proving.go | 41 +- .../modules/impl/sectors/rebuild.go | 17 +- .../modules/impl/sectors/rebuild_test.go | 11 +- .../modules/impl/sectors/snapup_allocator.go | 52 ++- .../modules/impl/sectors/snapup_commit.go | 124 +++-- .../impl/sectors/snapup_commit_test.go | 1 - .../modules/impl/sectors/snapup_mgr.go | 14 +- .../modules/impl/sectors/state_mgr.go | 72 ++- .../modules/impl/sectors/tracker.go | 35 +- .../modules/impl/sectors/unseal.go | 58 ++- .../modules/impl/sectors/unseal_test.go | 6 +- damocles-manager/modules/impl/worker/mgr.go | 14 +- damocles-manager/modules/miner/proof_event.go | 13 +- damocles-manager/modules/policy/sealer.go | 8 +- damocles-manager/modules/poster/poster.go | 35 +- .../modules/poster/poster_test.go | 87 +++- damocles-manager/modules/poster/runner.go | 80 +++- .../modules/poster/runner_test.go | 2 +- .../modules/poster/scheduler_test.go | 9 +- damocles-manager/modules/sealer/sealer.go | 125 +++++- damocles-manager/modules/sealer/sealer_cli.go | 82 +++- damocles-manager/modules/util/piece/piece.go | 11 +- damocles-manager/modules/util/pledge/alloc.go | 21 +- .../modules/util/pledge/pledge.go | 21 +- damocles-manager/pkg/chain/api.go | 42 +- damocles-manager/pkg/chain/eventbus.go | 7 +- damocles-manager/pkg/chain/miner_api.go | 1 - damocles-manager/pkg/confmgr/conf_mgr.go | 12 +- damocles-manager/pkg/confmgr/local_mgr.go | 23 +- damocles-manager/pkg/extproc/config.go | 1 + damocles-manager/pkg/extproc/extproc.go | 25 +- damocles-manager/pkg/extproc/io.go | 2 +- damocles-manager/pkg/extproc/req_resp.go | 8 +- .../pkg/extproc/stage/ext_window_post.go | 2 +- damocles-manager/pkg/kvstore/badger.go | 20 +- damocles-manager/pkg/kvstore/kvstore.go | 17 +- damocles-manager/pkg/kvstore/mongo.go | 11 +- damocles-manager/pkg/kvstore/mongo_test.go | 5 +- damocles-manager/pkg/logging/log.go | 8 +- .../pkg/lotusminer/lotus_miner.go | 9 +- damocles-manager/pkg/messager/api.go | 1 + .../pkg/objstore/filestore/store.go | 17 +- damocles-manager/pkg/objstore/mgr.go | 26 +- damocles-manager/pkg/objstore/mgr_test.go | 31 +- damocles-manager/pkg/objstore/mock_store.go | 6 +- .../pkg/objstore/plugin/plugin.go | 12 +- damocles-manager/pkg/piecestore/proxy.go | 2 +- damocles-manager/pkg/slices/map.go | 1 - damocles-manager/pkg/strings/join.go | 6 +- damocles-manager/pkg/workercli/client.go | 2 +- .../testutil/testmodules/modules.go | 4 +- damocles-manager/ver/prover_prod.go | 1 + damocles-worker-util/Makefile | 3 +- damocles-worker/Makefile | 3 +- 130 files changed, 3831 insertions(+), 1131 deletions(-) create mode 100644 .flox/.gitignore create mode 100644 .flox/env.json create mode 100644 .flox/env/manifest.lock create mode 100644 .flox/env/manifest.toml diff --git a/.flox/.gitignore b/.flox/.gitignore new file mode 100644 index 000000000..3af4dbf18 --- /dev/null +++ b/.flox/.gitignore @@ -0,0 +1,2 @@ +run/ +cache/ diff --git a/.flox/env.json b/.flox/env.json new file mode 100644 index 000000000..2e4467987 --- /dev/null +++ b/.flox/env.json @@ -0,0 +1,4 @@ +{ + "name": "damocles", + "version": 1 +} \ No newline at end of file diff --git a/.flox/env/manifest.lock b/.flox/env/manifest.lock new file mode 100644 index 000000000..dcd443162 --- /dev/null +++ b/.flox/env/manifest.lock @@ -0,0 +1,254 @@ +{ + "lockfile-version": 0, + "manifest": { + "hook": {}, + "install": { + "go": { + "pkg-path": "go", + "version": "~1.21.8" + }, + "gofumpt": { + "pkg-path": "gofumpt", + "version": "~0.3.1" + }, + "golangci-lint": { + "pkg-path": "golangci-lint", + "version": "~1.55.2" + }, + "golines": { + "pkg-path": "golines", + "version": "~0.11.0" + }, + "pkg-config": { + "pkg-path": "pkg-config", + "version": "~0.29.2" + }, + "rustup": { + "pkg-path": "rustup", + "version": "~1.26.0" + } + }, + "options": { + "systems": [ + "x86_64-linux" + ] + }, + "registry": { + "defaults": { + "subtrees": null + }, + "inputs": { + "nixpkgs": { + "from": { + "owner": "NixOS", + "ref": "release-23.11", + "repo": "nixpkgs", + "type": "github" + }, + "subtrees": [ + "legacyPackages" + ] + } + }, + "priority": [ + "nixpkgs" + ] + }, + "vars": {} + }, + "packages": { + "x86_64-linux": { + "go": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "go" + ], + "info": { + "broken": false, + "description": "The Go Programming language", + "license": "BSD-3-Clause", + "pname": "go", + "unfree": false, + "version": "1.21.9" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "gofumpt": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "gofumpt" + ], + "info": { + "broken": false, + "description": "A stricter gofmt", + "license": "BSD-3-Clause", + "pname": "gofumpt", + "unfree": false, + "version": "0.3.1" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "golangci-lint": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "golangci-lint" + ], + "info": { + "broken": false, + "description": "Fast linters Runner for Go", + "license": "GPL-3.0-or-later", + "pname": "golangci-lint", + "unfree": false, + "version": "1.55.2" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "golines": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "golines" + ], + "info": { + "broken": false, + "description": "A golang formatter that fixes long lines", + "license": "MIT", + "pname": "golines", + "unfree": false, + "version": "0.11.0" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "pkg-config": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "pkg-config" + ], + "info": { + "broken": false, + "description": "A tool that allows packages to find out information about other packages (wrapper script)", + "license": "GPL-2.0-or-later", + "pname": "pkg-config-wrapper", + "unfree": false, + "version": "0.29.2" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "rustup": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "rustup" + ], + "info": { + "broken": false, + "description": "The Rust toolchain installer", + "license": null, + "pname": "rustup", + "unfree": false, + "version": "1.26.0" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + } + } + }, + "registry": { + "defaults": { + "subtrees": null + }, + "inputs": { + "nixpkgs": { + "from": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "subtrees": [ + "legacyPackages" + ] + } + }, + "priority": [ + "nixpkgs" + ] + } +} \ No newline at end of file diff --git a/.flox/env/manifest.toml b/.flox/env/manifest.toml new file mode 100644 index 000000000..37e389050 --- /dev/null +++ b/.flox/env/manifest.toml @@ -0,0 +1,45 @@ +# +# This is a flox environment manifest. +# Visit flox.dev/docs/concepts/manifest/ +# or see flox-edit(1) for more information +# + +# List packages you wish to install in your environment inside +# the 'install' section + +[install] +go = { version = "~1.21.8", pkg-path = "go" } +golangci-lint = { version = "~1.55.2", pkg-path = "golangci-lint" } +golines = { version = "~0.11.0", pkg-path = "golines" } +gofumpt = { version = "~0.3.1", pkg-path = "gofumpt" } +pkg-config = { version = "~0.29.2", pkg-path = "pkg-config" } +rustup = { version="~1.26.0", pkg-path = "rustup" } +# pre-commit = { version = "~3.3.3", pkg-path = "pre-commit" } + +# Set an environment variable. +# These variables may not reference once another +# and are added to the environment without expansion. + +[vars] +# message = "Howdy" +# pass-in = "$some-env-var" + +# An activation hook will be run when entering the environment. +# You can define one in the 'hook' table inline via the 'script' field, +# or provide a file using the 'file' field. +# If 'file' is provided, the path should be relative to this file. +# If both 'file' and 'script' are provided, +# only the hook defined in 'file' will be run . + +[hook] +# script = """ +# pre-commit install +# """ + +# An environment that works on one system is guaranteed to work on the +# same type of system, +# but other systems may not have the same packages available, etc. +# In order to use the environment on a system you must explicitly +# add it to this list. +[options] +systems = ["x86_64-linux"] diff --git a/.github/workflows/damocles-manager.yaml b/.github/workflows/damocles-manager.yaml index 3c1719acb..61b022eaf 100644 --- a/.github/workflows/damocles-manager.yaml +++ b/.github/workflows/damocles-manager.yaml @@ -14,47 +14,31 @@ jobs: runs-on: ubuntu-20.04 steps: - uses: actions/checkout@v4 - - - name: dependencies - run: sudo apt update && sudo apt install --reinstall ocl-icd-opencl-dev libhwloc-dev -y - - - name: setup go - uses: actions/setup-go@v5 - with: - go-version: "1.21" - - - name: cache paths - id: cache-paths - run: | - echo "go-build=$(go env GOCACHE)" >> $GITHUB_OUTPUT - echo "go-mod=$(go env GOMODCACHE)" >> $GITHUB_OUTPUT - - - name: setup go cache - uses: actions/cache@v4 - continue-on-error: false + - uses: actions/setup-go@v5 with: - path: | - ${{ steps.cache-paths.outputs.go-build }} - ${{ steps.cache-paths.outputs.go-mod }} - key: ${{ runner.os }}-go-${{ hashFiles('damocles-manager/go.sum') }} - restore-keys: ${{ runner.os }}-go- + go-version-file: 'damocles-manager/go.mod' + cache-dependency-path: 'damocles-manager/go.sum' - - name: install golangci-lint - run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 + - name: Instal Dependencies + run: | + sudo apt update && sudo apt install --reinstall ocl-icd-opencl-dev libhwloc-dev -y + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.55.2 + go install github.com/segmentio/golines@v0.11.0 + go install mvdan.cc/gofumpt@v0.3.1 - - name: test damocles-manager + - name: Test damocles-manager run: make test-manager - - name: build damocles-manager + - name: Build damocles-manager run: make build-manager - - name: check damocles-manager + - name: Check damocles-manager run: make check-manager - - name: check git dirty + - name: Check git dirty run: make check-git - - name: show bins + - name: Show bins run: ls -lha ./dist/bin/ # - name: upload damocles-manager diff --git a/.github/workflows/damocles-worker-util.yaml b/.github/workflows/damocles-worker-util.yaml index 3c44b48a0..12a8dc202 100644 --- a/.github/workflows/damocles-worker-util.yaml +++ b/.github/workflows/damocles-worker-util.yaml @@ -15,7 +15,7 @@ jobs: steps: - uses: actions/checkout@v4 - - name: dependencies + - name: Install dependencies run: | sudo apt update && sudo apt install --reinstall ocl-icd-opencl-dev libhwloc-dev -y wget https://github.com/gnprice/toml-cli/releases/download/v0.2.3/toml-0.2.3-x86_64-linux.tar.gz && tar -xzf toml-0.2.3-x86_64-linux.tar.gz @@ -27,12 +27,11 @@ jobs: run: | echo "toolchain=$(toml get ./rust-toolchain.toml toolchain.channel --raw)" >> "$GITHUB_OUTPUT" - - name: setup rust - uses: actions-rs/toolchain@v1 - with: - toolchain: ${{ steps.read-rust-toolchain.outputs.toolchain }} - override: true - components: rustfmt, clippy + - name: Setup rust + run: rustup toolchain install ${{ steps.read-rust-toolchain.outputs.toolchain }} --profile minimal + + - uses: Swatinem/rust-cache@v2 + continue-on-error: false - name: test damocles-worker-util run: make test-worker-util diff --git a/.github/workflows/damocles-worker.yaml b/.github/workflows/damocles-worker.yaml index bbe79e85f..026b43b10 100644 --- a/.github/workflows/damocles-worker.yaml +++ b/.github/workflows/damocles-worker.yaml @@ -15,36 +15,22 @@ jobs: steps: - uses: actions/checkout@v4 - - name: dependencies + - name: Install dependencies run: | sudo apt update && sudo apt install --reinstall ocl-icd-opencl-dev libhwloc-dev -y wget https://github.com/gnprice/toml-cli/releases/download/v0.2.3/toml-0.2.3-x86_64-linux.tar.gz && tar -xzf toml-0.2.3-x86_64-linux.tar.gz sudo mv toml-0.2.3-x86_64-linux/toml /usr/local/bin rm -rf toml-0.2.3-x86_64-linux.tar.gz toml-0.2.3-x86_64-linux - - - name: read rust toolchain + - name: Read rust toolchain id: read-rust-toolchain run: | echo "toolchain=$(toml get ./rust-toolchain.toml toolchain.channel --raw)" >> "$GITHUB_OUTPUT" - - name: setup rust - uses: actions-rs/toolchain@v1 - with: - toolchain: ${{ steps.read-rust-toolchain.outputs.toolchain }} - override: true - components: rustfmt, clippy + - name: Setup rust + run: rustup toolchain install ${{ steps.read-rust-toolchain.outputs.toolchain }} --profile minimal - - name: setup cargo cache - uses: actions/cache@v4 + - uses: Swatinem/rust-cache@v2 continue-on-error: false - with: - path: | - ~/.cargo/ - damocles-worker/target/ - key: ${{ runner.os }}-cargo-${{ hashFiles('rust-toolchain') }}-${{ hashFiles('damocles-worker/Cargo.lock') }} - restore-keys: | - ${{ runner.os }}-cargo-${{ hashFiles('rust-toolchain') }}- - ${{ runner.os }}-cargo- - name: test damocles-worker run: make test-worker diff --git a/Makefile b/Makefile index 5a9685343..7c254f77d 100644 --- a/Makefile +++ b/Makefile @@ -2,9 +2,39 @@ all: build-manager build-worker build-worker-util check-all: check-manager check-worker check-worker-util check-git +check: check-manager check-worker check-worker-util +fix: fix-manager fix-worker fix-worker-util +test: test-manager test-worker test-worker-util + +check-manager: + $(MAKE) -C ./damocles-manager/ check + +check-worker: + $(MAKE) -C ./damocles-worker/ check + +check-worker-util: + $(MAKE) -C ./damocles-worker-util/ check + +fix-manager: + $(MAKE) -C ./damocles-manager/ fix + +fix-worker: + $(MAKE) -C ./damocles-worker/ fix + +fix-worker-util: + $(MAKE) -C ./damocles-worker-util/ fix + test-manager: $(MAKE) -C ./damocles-manager/ test-all +test-worker: + $(MAKE) -C ./damocles-worker/ test-all + +test-worker-util: + $(MAKE) -C ./damocles-worker-util/ test-all + +build: build-manager build-worker build-worker-util + build-manager: mkdir -p ./dist/bin/ rm -rf ./dist/bin/damocles-manager @@ -13,23 +43,12 @@ build-manager: # mv ./damocles-manager/plugin-fsstore.so ./dist/bin/ # mv ./damocles-manager/plugin-memdb.so ./dist/bin/ -check-manager: - $(MAKE) -C ./damocles-manager/ check-all - -test-worker: - $(MAKE) -C ./damocles-worker/ test-all - build-worker: mkdir -p ./dist/bin/ rm -rf ./dist/bin/damocles-worker $(MAKE) -C ./damocles-worker/ build-all cp $(shell cargo metadata --format-version=1 --manifest-path=./damocles-worker/Cargo.toml | jq -r ".target_directory")/release/damocles-worker ./dist/bin/ -check-worker: - $(MAKE) -C ./damocles-worker/ check-all - -test-worker-util: - $(MAKE) -C ./damocles-worker-util/ test-all build-worker-util: mkdir -p ./dist/bin/ @@ -37,9 +56,6 @@ build-worker-util: $(MAKE) -C ./damocles-worker-util/ build-all cp $(shell cargo metadata --format-version=1 --manifest-path=./damocles-worker-util/Cargo.toml | jq -r ".target_directory")/release/damocles-worker-util ./dist/bin/ -check-worker-util: - $(MAKE) -C ./damocles-worker-util/ check-all - check-git: ./scripts/check-git-dirty.sh @@ -57,6 +73,9 @@ dev-env: $(MAKE) -C ./damocles-worker/ dev-env $(MAKE) -C ./damocles-worker-util/ dev-env +docker: docker-manager docker-worker +docker-push: docker-push-manager docker-push-worker + docker-manager: docker build \ -f Dockerfile.manager \ @@ -67,9 +86,6 @@ docker-manager: docker-worker: $(MAKE) -C ./damocles-worker/ docker - -docker: docker-manager docker-worker - TAG:=test docker-push-manager: docker-manager @@ -80,4 +96,3 @@ docker-push-worker: docker-worker docker tag damocles-worker $(PRIVATE_REGISTRY)/filvenus/damocles-worker:$(TAG) docker push $(PRIVATE_REGISTRY)/filvenus/damocles-worker:$(TAG) -docker-push: docker-push-manager docker-push-worker diff --git a/README.md b/README.md index 16d6a7bf5..642231f9a 100644 --- a/README.md +++ b/README.md @@ -37,6 +37,13 @@ Venus is a universally open project and welcomes contributions of all kinds: cod 1. If the proposal entails a protocol change, please first submit a [Filecoin Improvement Proposal](https://github.com/filecoin-project/FIPs). 2. If the change is complex and requires prior discussion, [open an issue](https://github.com/ipfs-force-community/damocles/issues) or a [discussion](https://github.com/ipfs-force-community/damocles/discussions) to request feedback before you start working on a pull request. This is to avoid disappointment and sunk costs, in case the change is not actually needed or accepted. +Here are some resources to help you get started: + +### Development environment +1. [Install flox](https://flox.dev/docs/install-flox/) +2. Activate the environment with `flox activate` + + ## Community For general help in using `damocles`, please refer to the [documentation](https://github.com/ipfs-force-community/damocles/tree/main/docs) hosted within the repo. For additional help, you can use one of these channels to ask a question: diff --git a/damocles-manager/.golangci.yml b/damocles-manager/.golangci.yml index eff9fd2b4..87d01545f 100644 --- a/damocles-manager/.golangci.yml +++ b/damocles-manager/.golangci.yml @@ -1,43 +1,404 @@ run: - timeout: 5m - + timeout: 10m linters: disable-all: true enable: - - gofmt - - govet + - ineffassign + - typecheck + - unused + - gosimple - goimports - - misspell - - goconst - - revive - errcheck - - gosec - - unconvert - staticcheck + - stylecheck + - gosec + - asciicheck + - bodyclose - exportloopref + - rowserrcheck + - makezero + - durationcheck + - prealloc + - predeclared + - revive + - gofmt -# We don't want to skip builtin/ -skip-dirs-use-default: false -skip-dirs: - - extern$ +linters-settings: + staticcheck: + checks: ["S1002","S1004","S1007","S1009","S1010","S1012","S1019","S1020","S1021","S1024","S1030","SA2*","SA3*","SA4009","SA5*","SA6000","SA6001","SA6005", "-SA2002"] + stylecheck: + checks: ["-ST1003"] + gosec: + severity: "low" + confidence: "low" + excludes: + - G101 + - G112 + - G404 + revive: + # Maximum number of open files at the same time. + # See https://github.com/mgechev/revive#command-line-flags + # Defaults to unlimited. + max-open-files: 2048 -issues: - exclude: - - "File is not `gofmt`-ed with `-s`" - - "func name will be used as test\\.Test.* by other packages, and that stutters; consider calling this" - - "Potential file inclusion via variable" - - "should have( a package)? comment" - - "Error return value of `logging.SetLogLevel` is not checked" - - "comment on exported" - - "(func|method) \\w+ should be \\w+" - - "(type|var|struct field|(method|func) parameter) `\\w+` should be `\\w+`" - - "(G306|G301|G307|G108|G302|G204|G104)" - - "don't use ALL_CAPS in Go names" - - "string .* has .* occurrences, make it a constant" - - "a blank import should be only in a main or test package, or have a comment justifying it" - - "package comment should be of the form" - - "G404: Use of weak random number generator" + # When set to false, ignores files with "GENERATED" header, similar to golint. + # See https://github.com/mgechev/revive#available-rules for details. + # Default: false + ignore-generated-header: true -linters-settings: - goconst: - min-occurrences: 6 + # Sets the default severity. + # See https://github.com/mgechev/revive#configuration + # Default: warning + severity: error + + # Enable all available rules. + # Default: false + enable-all-rules: true + + # Sets the default failure confidence. + # This means that linting errors with less than 0.8 confidence will be ignored. + # Default: 0.8 + confidence: 0.1 + + rules: + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#add-constant + - name: add-constant + severity: warning + disabled: true + arguments: + - maxLitCount: "3" + allowStrs: '""' + allowInts: "0,1,2" + allowFloats: "0.0,0.,1.0,1.,2.0,2." + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#argument-limit + - name: argument-limit + severity: warning + disabled: false + arguments: [ 7 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#atomic + - name: atomic + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#banned-characters + - name: banned-characters + severity: warning + disabled: false + arguments: [ "Ω","Σ","σ" ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#bare-return + - name: bare-return + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#blank-imports + - name: blank-imports + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#bool-literal-in-expr + - name: bool-literal-in-expr + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#call-to-gc + - name: call-to-gc + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#cognitive-complexity + - name: cognitive-complexity + severity: warning + disabled: true + arguments: [ 7 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#comment-spacings + - name: comment-spacings + severity: warning + disabled: false + arguments: + - mypragma + - otherpragma + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#confusing-naming + - name: confusing-naming + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#confusing-results + - name: confusing-results + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#constant-logical-expr + - name: constant-logical-expr + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#context-as-argument + - name: context-as-argument + severity: warning + disabled: false + arguments: + - allowTypesBefore: "*testing.T,*github.com/user/repo/testing.Harness" + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#context-keys-type + - name: context-keys-type + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#cyclomatic + - name: cyclomatic + severity: warning + disabled: true + arguments: [ 3 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#datarace + - name: datarace + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#deep-exit + - name: deep-exit + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#defer + - name: defer + severity: warning + disabled: false + arguments: + - [ "call-chain", "loop" ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#dot-imports + - name: dot-imports + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#duplicated-imports + - name: duplicated-imports + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#early-return + - name: early-return + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#empty-block + - name: empty-block + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#empty-lines + - name: empty-lines + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-naming + - name: error-naming + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-return + - name: error-return + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#error-strings + - name: error-strings + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#errorf + - name: errorf + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#exported + - name: exported + severity: warning + disabled: false + arguments: + - "checkPrivateReceivers" + - "sayRepetitiveInsteadOfStutters" + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#file-header + - name: file-header + severity: warning + disabled: true + arguments: + - This is the text that must appear at the top of source files. + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#flag-parameter + - name: flag-parameter + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#function-result-limit + - name: function-result-limit + severity: warning + disabled: false + arguments: [ 7 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#function-length + - name: function-length + severity: warning + disabled: false + arguments: [ 100, 0 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#get-return + - name: get-return + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#identical-branches + - name: identical-branches + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#if-return + - name: if-return + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#increment-decrement + - name: increment-decrement + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#indent-error-flow + - name: indent-error-flow + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#imports-blacklist + - name: imports-blacklist + severity: warning + disabled: false + arguments: + - "crypto/md5" + - "crypto/sha1" + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#import-shadowing + - name: import-shadowing + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#line-length-limit + - name: line-length-limit + severity: warning + disabled: false + arguments: [ 120 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#max-public-structs + - name: max-public-structs + severity: warning + disabled: true + arguments: [ 3 ] + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#modifies-parameter + - name: modifies-parameter + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#modifies-value-receiver + - name: modifies-value-receiver + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#nested-structs + - name: nested-structs + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#optimize-operands-order + - name: optimize-operands-order + severity: warning + disabled: true + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#package-comments + - name: package-comments + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range + - name: range + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range-val-in-closure + - name: range-val-in-closure + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#range-val-address + - name: range-val-address + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#receiver-naming + - name: receiver-naming + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#redefines-builtin-id + - name: redefines-builtin-id + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#string-of-int + - name: string-of-int + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#string-format + - name: string-format + severity: warning + disabled: false + arguments: + - - 'core.WriteError[1].Message' + - '/^([^A-Z]|$)/' + - must not start with a capital letter + - - 'fmt.Errorf[0]' + - '/(^|[^\.!?])$/' + - must not end in punctuation + - - panic + - '/^[^\n]*$/' + - must not contain line breaks + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#struct-tag + - name: struct-tag + arguments: + - "json,inline" + - "bson,outline,gnu" + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#superfluous-else + - name: superfluous-else + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#time-equal + - name: time-equal + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#time-naming + - name: time-naming + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#var-naming + - name: var-naming + severity: warning + disabled: false + arguments: + - [ "ID" ] # AllowList + - [ "VM" ] # DenyList + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#var-declaration + - name: var-declaration + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unconditional-recursion + - name: unconditional-recursion + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unexported-naming + - name: unexported-naming + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unexported-return + - name: unexported-return + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unhandled-error + - name: unhandled-error + severity: warning + disabled: true + arguments: + - "fmt.Printf" + - "fmt.Println" + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unnecessary-stmt + - name: unnecessary-stmt + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unreachable-code + - name: unreachable-code + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unused-parameter + - name: unused-parameter + severity: warning + disabled: false + - name: unused-receiver + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#useless-break + - name: useless-break + severity: warning + disabled: false + # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#waitgroup-by-value + - name: waitgroup-by-value + severity: warning + disabled: false + gofmt: + # https://golangci-lint.run/usage/linters/#gofmt + # disable for faster check + simplify: false + rewrite-rules: + - pattern: 'interface{}' + replacement: 'any' +issues: + exclude-rules: + - path: _test\.go + linters: + - errcheck + - gosec + - rowserrcheck + - makezero diff --git a/damocles-manager/Makefile b/damocles-manager/Makefile index a88101f20..dd98fb0b7 100644 --- a/damocles-manager/Makefile +++ b/damocles-manager/Makefile @@ -68,13 +68,22 @@ test-all: GOTAGS+=prod test-all: $(BUILD_DEPS) $(GO) test -tags="$(GOTAGS)" $(GOFLAGS) -v -failfast `go list ./... | grep -v /extern/` -check-all: check-lint check-go-mod +check: $(BUILD_DEPS) tidy check-fmt check-lint -check-lint: $(BUILD_DEPS) - golangci-lint run -c .golangci.yml +fix: $(BUILD_DEPS) tidy fmt lint -check-go-mod: +check-fmt: + @echo "check format for golang" + @if [ "$$(find ./ -type d \( -name ".git" -o -name "extern" \) -prune -o -type f -regex '.*[^\.pb]\.go' -print | xargs golines --dry-run --max-len=120 --base-formatter=gofumpt | wc -l)" -gt 0 ]; then exit 1; fi + +fmt: + find ./ -type d \( -name ".git" -o -name "extern" \) -prune -o -type f -regex '.*[^\.pb]\.go' -print | xargs golines --max-len=120 --base-formatter=gofumpt -w + +tidy: $(GO) mod tidy -dev-env: - $(GO) install -v github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2 +check-lint: + golangci-lint run + +lint: + golangci-lint run --fix diff --git a/damocles-manager/cmd/damocles-manager/internal/global.go b/damocles-manager/cmd/damocles-manager/internal/global.go index 50d5bc515..01bc1c6a7 100644 --- a/damocles-manager/cmd/damocles-manager/internal/global.go +++ b/damocles-manager/cmd/damocles-manager/internal/global.go @@ -54,7 +54,7 @@ var SealerListenFlag = &cli.StringFlag{ var ConfDirFlag = &cli.StringFlag{ Name: "conf-dir", - Usage: "the dir path in which the sector-manager.cfg file exists, set this only if you don't want to use the config file inside home dir", + Usage: "the dir path in which the sector-manager.cfg file exists, set this only if you don't want to use the config file inside home dir", //revive:disable-line:line-length-limit EnvVars: []string{"DAMOCLES_CONF_DIR", "VENUS_SECTOR_MANAGER_CONF_DIR", "VSM_CONF_DIR"}, } @@ -120,11 +120,11 @@ type APIClient struct { Damocles *core.APIClient } -func extractAPI(cctx *cli.Context, target ...interface{}) (*APIClient, context.Context, stopper, error) { +func extractAPI(cctx *cli.Context, target ...any) (*APIClient, context.Context, stopper, error) { gctx, gcancel := NewSigContext(cctx.Context) var a APIClient - wants := append([]interface{}{&a}, target...) + wants := append([]any{&a}, target...) stopper, err := dix.New( gctx, @@ -133,7 +133,6 @@ func extractAPI(cctx *cli.Context, target ...interface{}) (*APIClient, context.C dix.Override(new(dep.GlobalContext), gctx), dix.Override(new(dep.ListenAddress), dep.ListenAddress(cctx.String(SealerListenFlag.Name))), ) - if err != nil { gcancel() return nil, nil, nil, fmt.Errorf("construct api: %w", err) @@ -189,7 +188,14 @@ func ShouldSectorNumber(s string) (abi.SectorNumber, error) { return abi.SectorNumber(num), nil } -func waitMessage(ctx context.Context, api *APIClient, rawMsg *messager.UnsignedMessage, exid string, mlog *logging.ZapLogger, ret cbor.Unmarshaler) error { +func waitMessage( + ctx context.Context, + api *APIClient, + rawMsg *messager.UnsignedMessage, + exid string, + mlog *logging.ZapLogger, + ret cbor.Unmarshaler, +) error { if mlog == nil { mlog = Log.With("action", "wait-message") } @@ -263,13 +269,13 @@ WAIT_RET: return nil } -func OutputJSON(w io.Writer, v interface{}) error { +func OutputJSON(w io.Writer, v any) error { enc := json.NewEncoder(w) enc.SetIndent("", "\t") return enc.Encode(v) } -func FormatOrNull(arg interface{}, f func() string) string { +func FormatOrNull(arg any, f func() string) string { if arg == nil { return "NULL" } @@ -278,7 +284,6 @@ func FormatOrNull(arg interface{}, f func() string) string { rt := rv.Type() if rt.Kind() == reflect.Ptr && rv.IsNil() { return "NULL" - } return f() diff --git a/damocles-manager/cmd/damocles-manager/internal/global_test.go b/damocles-manager/cmd/damocles-manager/internal/global_test.go index a6a075dc6..01322b2e7 100644 --- a/damocles-manager/cmd/damocles-manager/internal/global_test.go +++ b/damocles-manager/cmd/damocles-manager/internal/global_test.go @@ -9,7 +9,6 @@ import ( ) func TestOutputJSONWithNil(t *testing.T) { - var sb strings.Builder require.NoError(t, internal.OutputJSON(&sb, nil)) diff --git a/damocles-manager/cmd/damocles-manager/internal/run.go b/damocles-manager/cmd/damocles-manager/internal/run.go index a2ba27f58..2b4912545 100644 --- a/damocles-manager/cmd/damocles-manager/internal/run.go +++ b/damocles-manager/cmd/damocles-manager/internal/run.go @@ -21,7 +21,7 @@ func (e *PrintHelpErr) Unwrap() error { return e.Err } -func (e *PrintHelpErr) Is(o error) bool { +func (*PrintHelpErr) Is(o error) bool { _, ok := o.(*PrintHelpErr) return ok } @@ -33,7 +33,7 @@ func ShowHelp(cctx *cli.Context, err error) error { } } -func ShowHelpf(cctx *cli.Context, format string, args ...interface{}) error { +func ShowHelpf(cctx *cli.Context, format string, args ...any) error { return ShowHelp(cctx, fmt.Errorf(format, args...)) } diff --git a/damocles-manager/cmd/damocles-manager/internal/util_kvstore_migrate.go b/damocles-manager/cmd/damocles-manager/internal/util_kvstore_migrate.go index d36011369..4fc8aa055 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_kvstore_migrate.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_kvstore_migrate.go @@ -121,7 +121,7 @@ func migrate(ctx context.Context, src, dst kvstore.KVStore) error { return nil } -func Dep(cctx *cli.Context, wants ...interface{}) (stop func(), err error) { +func Dep(cctx *cli.Context, wants ...any) (stop func(), err error) { gctx, gcancel := NewSigContext(cctx.Context) cfgmu := &sync.RWMutex{} diff --git a/damocles-manager/cmd/damocles-manager/internal/util_miner.go b/damocles-manager/cmd/damocles-manager/internal/util_miner.go index 5542a8a5b..1d9c1e1e8 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_miner.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_miner.go @@ -245,7 +245,6 @@ var utilMinerCreateCmd = &cli.Command{ Peer: pid, Multiaddrs: multiaddrs, }) - if err != nil { return fmt.Errorf("serialize params: %w", err) } diff --git a/damocles-manager/cmd/damocles-manager/internal/util_sealer_actor.go b/damocles-manager/cmd/damocles-manager/internal/util_sealer_actor.go index 98275e6f6..4a4365c14 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_sealer_actor.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_sealer_actor.go @@ -6,7 +6,6 @@ import ( "os" "strconv" "strings" - "text/tabwriter" "github.com/fatih/color" @@ -196,7 +195,11 @@ var utilSealerActorWithdrawCmd = &cli.Command{ amount = abi.TokenAmount(f) if amount.GreaterThan(available) { - return fmt.Errorf("can't withdraw more funds than available; requested: %s; available: %s", types.FIL(amount), types.FIL(available)) + return fmt.Errorf( + "can't withdraw more funds than available; requested: %s; available: %s", + types.FIL(amount), + types.FIL(available), + ) } } @@ -441,7 +444,7 @@ var utilSealerActorControlList = &cli.Command{ return } - var k = addr + k := addr // `a` maybe a `robust`, in that case, `StateAccountKey` returns an error. if builtin.IsAccountActor(actor.Code) { if k, err = api.Chain.StateAccountKey(ctx, addr, types.EmptyTSK); err != nil { @@ -626,7 +629,7 @@ var utilSealerActorControlSet = &cli.Command{ var utilSealerActorSetOwnerCmd = &cli.Command{ Name: "set-owner", - Usage: "Set owner address (this command should be invoked twice, first with the old owner as the senderAddress, and then with the new owner)", + Usage: "Set owner address (this command should be invoked twice, first with the old owner as the senderAddress, and then with the new owner)", //revive:disable-line:line-length-limit ArgsUsage: "[newOwnerAddress senderAddress]", Flags: []cli.Flag{ &cli.BoolFlag{ @@ -818,7 +821,11 @@ var utilSealerActorProposeChangeWorker = &cli.Command{ return err } if mi.NewWorker != newAddr { - return fmt.Errorf("proposed worker address change not reflected on chain: expected %s, found %s", na, mi.NewWorker) + return fmt.Errorf( + "proposed worker address change not reflected on chain: expected %s, found %s", + na, + mi.NewWorker, + ) } fmt.Printf("Worker key change to %s successfully proposed.\n", na) @@ -879,7 +886,7 @@ var utilSealerActorConfirmChangeWorker = &cli.Command{ if head, err := api.Chain.ChainHead(ctx); err != nil { return fmt.Errorf("failed to get the chain head: %w", err) } else if head.Height() < mi.WorkerChangeEpoch { - return fmt.Errorf("worker key change cannot be confirmed until %d, current height is %d", mi.WorkerChangeEpoch, head.Height()) + return fmt.Errorf("worker key change cannot be confirmed until %d, current height is %d", mi.WorkerChangeEpoch, head.Height()) //revive:disable-line:line-length-limit } if !cctx.Bool("really-do-it") { @@ -916,7 +923,11 @@ var utilSealerActorConfirmChangeWorker = &cli.Command{ return err } if mi.Worker != newAddr { - return fmt.Errorf("confirmed worker address change not reflected on chain: expected '%s', found '%s'", newAddr, mi.Worker) + return fmt.Errorf( + "confirmed worker address change not reflected on chain: expected '%s', found '%s'", + newAddr, + mi.Worker, + ) } return nil @@ -1004,14 +1015,16 @@ var utilSealerActorCompactAllocatedCmd = &cli.Command{ } maskBf, err = bitfield.NewFromIter(&rlepluslazy.RunSliceIterator{ - Runs: []rlepluslazy.Run{{Val: true, Len: last - m}}}) + Runs: []rlepluslazy.Run{{Val: true, Len: last - m}}, + }) if err != nil { return fmt.Errorf("forming bitfield: %w", err) } case cctx.IsSet("mask-upto-n"): n := cctx.Uint64("mask-upto-n") maskBf, err = bitfield.NewFromIter(&rlepluslazy.RunSliceIterator{ - Runs: []rlepluslazy.Run{{Val: true, Len: n}}}) + Runs: []rlepluslazy.Run{{Val: true, Len: n}}, + }) if err != nil { return fmt.Errorf("forming bitfield: %w", err) } @@ -1129,12 +1142,16 @@ var utilSealerActorProposeChangeBeneficiary = &cli.Command{ fmt.Println("Expiration Epoch:", mi.PendingBeneficiaryTerm.NewExpiration) if !cctx.Bool("overwrite-pending-change") { - return fmt.Errorf("must pass --overwrite-pending-change to replace current pending beneficiary change. Please review CAREFULLY") + return fmt.Errorf( + "must pass --overwrite-pending-change to replace current pending beneficiary change. Please review CAREFULLY", //revive:disable-line:line-length-limit + ) } } if !cctx.Bool("really-do-it") { - fmt.Println("Pass --really-do-it to actually execute this action. Review what you're about to approve CAREFULLY please") + fmt.Println( + "Pass --really-do-it to actually execute this action. Review what you're about to approve CAREFULLY please", //revive:disable-line:line-length-limit + ) return nil } @@ -1156,7 +1173,6 @@ var utilSealerActorProposeChangeBeneficiary = &cli.Command{ Value: big.Zero(), Params: sp, }, nil) - if err != nil { return fmt.Errorf("push message: %w", err) } @@ -1185,6 +1201,7 @@ var utilSealerActorProposeChangeBeneficiary = &cli.Command{ return nil }, } + var utilSealerActorConfirmChangeBeneficiary = &cli.Command{ Name: "confirm-change-beneficiary", Usage: "Confirm a beneficiary address change", @@ -1223,7 +1240,8 @@ var utilSealerActorConfirmChangeBeneficiary = &cli.Command{ return fmt.Errorf("no pending beneficiary term found for miner %s", maddr) } - if (cctx.IsSet("existing-beneficiary") && cctx.IsSet("new-beneficiary")) || (!cctx.IsSet("existing-beneficiary") && !cctx.IsSet("new-beneficiary")) { + if (cctx.IsSet("existing-beneficiary") && cctx.IsSet("new-beneficiary")) || + (!cctx.IsSet("existing-beneficiary") && !cctx.IsSet("new-beneficiary")) { return fmt.Errorf("must pass exactly one of --existing-beneficiary or --new-beneficiary") } @@ -1245,7 +1263,9 @@ var utilSealerActorConfirmChangeBeneficiary = &cli.Command{ fmt.Println("Quota:", mi.PendingBeneficiaryTerm.NewQuota) fmt.Println("Expiration Epoch:", mi.PendingBeneficiaryTerm.NewExpiration) if !cctx.Bool("really-do-it") { - fmt.Println("Pass --really-do-it to actually execute this action. Review what you're about to approve CAREFULLY please") + fmt.Println( + "Pass --really-do-it to actually execute this action. Review what you're about to approve CAREFULLY please", //revive:disable-line:line-length-limit + ) return nil } @@ -1288,7 +1308,8 @@ var utilSealerActorConfirmChangeBeneficiary = &cli.Command{ return fmt.Errorf("getting miner info: %w", err) } - if updatedMinerInfo.PendingBeneficiaryTerm == nil && updatedMinerInfo.Beneficiary == mi.PendingBeneficiaryTerm.NewBeneficiary { + if updatedMinerInfo.PendingBeneficiaryTerm == nil && + updatedMinerInfo.Beneficiary == mi.PendingBeneficiaryTerm.NewBeneficiary { fmt.Println("Beneficiary address successfully changed") } else { fmt.Println("Beneficiary address change awaiting additional confirmations") diff --git a/damocles-manager/cmd/damocles-manager/internal/util_sealer_proving.go b/damocles-manager/cmd/damocles-manager/internal/util_sealer_proving.go index 421d5ea4a..4229146d2 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_sealer_proving.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_sealer_proving.go @@ -60,11 +60,19 @@ var utilSealerProvingCmd = &cli.Command{ func EpochTime(curr, e abi.ChainEpoch, blockDelay uint64) string { if curr > e { - return fmt.Sprintf("%d (%s ago)", e, durafmt.Parse(time.Second*time.Duration(int64(blockDelay)*int64(curr-e))).LimitFirstN(2)) + return fmt.Sprintf( + "%d (%s ago)", + e, + durafmt.Parse(time.Second*time.Duration(int64(blockDelay)*int64(curr-e))).LimitFirstN(2), + ) } if curr < e { - return fmt.Sprintf("%d (in %s)", e, durafmt.Parse(time.Second*time.Duration(int64(blockDelay)*int64(e-curr))).LimitFirstN(2)) + return fmt.Sprintf( + "%d (in %s)", + e, + durafmt.Parse(time.Second*time.Duration(int64(blockDelay)*int64(e-curr))).LimitFirstN(2), + ) } return fmt.Sprintf("%d (now)", e) @@ -170,7 +178,10 @@ var utilSealerProvingInfoCmd = &cli.Command{ fmt.Printf("Proving Period Boundary: %d\n", cd.PeriodStart%cd.WPoStProvingPeriod) fmt.Printf("Proving Period Start: %s\n", EpochTime(cd.CurrentEpoch, cd.PeriodStart, blockDelaySecs)) - fmt.Printf("Next Period Start: %s\n\n", EpochTime(cd.CurrentEpoch, cd.PeriodStart+cd.WPoStProvingPeriod, blockDelaySecs)) + fmt.Printf( + "Next Period Start: %s\n\n", + EpochTime(cd.CurrentEpoch, cd.PeriodStart+cd.WPoStProvingPeriod, blockDelaySecs), + ) fmt.Printf("Faults: %d (%.2f%%)\n", faults, faultPerc) fmt.Printf("Recovering: %d\n", recovering) @@ -235,7 +246,14 @@ var utilSealerProvingFaultsCmd = &cli.Command{ if err != nil { return err } - _, _ = fmt.Fprintf(tw, " %d\t%d\t%d\t%v\n", dlIdx, partIdx, num, float64((se.Early-curHeight)*builtin.EpochDurationSeconds)/60/60/24) + fmt.Fprintf( + tw, + " %d\t%d\t%d\t%v\n", + dlIdx, + partIdx, + num, + float64((se.Early-curHeight)*builtin.EpochDurationSeconds)/60/60/24, + ) return nil }) }) @@ -346,7 +364,17 @@ var utilSealerProvingDeadlinesCmd = &cli.Command{ gapHeight := uint64(30*60) / policy.NetParams.BlockDelaySecs * gapIdx open := HeightToTime(head, di.Open+abi.ChainEpoch(gapHeight), policy.NetParams.BlockDelaySecs) - _, _ = fmt.Fprintf(tw, "%d\t%s\t%d\t%d (%d)\t%d%s\n", dlIdx, open, partitionCount, sectors, faults, provenPartitions, cur) + fmt.Fprintf( + tw, + "%d\t%s\t%d\t%d (%d)\t%d%s\n", + dlIdx, + open, + partitionCount, + sectors, + faults, + provenPartitions, + cur, + ) } return tw.Flush() @@ -420,7 +448,10 @@ var utilSealerProvingDeadlineInfoCmd = &cli.Command{ gapHeight := uint64(30*60) / policy.NetParams.BlockDelaySecs * gapIdx fmt.Printf("Deadline Index: %d\n", dlIdx) - fmt.Printf("Deadline Open: %s\n", HeightToTime(head, di.Open+abi.ChainEpoch(gapHeight), policy.NetParams.BlockDelaySecs)) + fmt.Printf( + "Deadline Open: %s\n", + HeightToTime(head, di.Open+abi.ChainEpoch(gapHeight), policy.NetParams.BlockDelaySecs), + ) fmt.Printf("Partitions: %d\n", len(partitions)) fmt.Printf("Proven Partitions: %d\n", provenPartitions) fmt.Printf("Current: %t\n\n", di.Index == dlIdx) @@ -465,7 +496,20 @@ var utilSealerProvingDeadlineInfoCmd = &cli.Command{ sz := len(buf.Bytes()) szstr := types.SizeStr(types.NewInt(uint64(sz))) - fmt.Printf("\t%s Sectors:%s%d (bitfield - runs %d+%d=%d - %d 0s %d 1s - %d inv - %s %dB)\n", name, strings.Repeat(" ", 18-len(name)), count, zeroRuns, oneRuns, zeroRuns+oneRuns, zeros, ones, invalid, szstr, sz) + fmt.Printf( + "\t%s Sectors:%s%d (bitfield - runs %d+%d=%d - %d 0s %d 1s - %d inv - %s %dB)\n", + name, + strings.Repeat(" ", 18-len(name)), + count, + zeroRuns, + oneRuns, + zeroRuns+oneRuns, + zeros, + ones, + invalid, + szstr, + sz, + ) } else { fmt.Printf("\t%s Sectors:%s%d\n", name, strings.Repeat(" ", 18-len(name)), count) } @@ -634,7 +678,14 @@ var utilSealerProvingCheckProvableCmd = &cli.Command{ if showDetail { for s := range sectors { if err, exist := bad[s]; exist { - _, _ = fmt.Fprintf(tw, "%d\t%d\t%d\t%s\n", dlIdx, parIdx, s, color.RedString("bad")+fmt.Sprintf(" (%s)", err)) + _, _ = fmt.Fprintf( + tw, + "%d\t%d\t%d\t%s\n", + dlIdx, + parIdx, + s, + color.RedString("bad")+fmt.Sprintf(" (%s)", err), + ) } else if !cctx.Bool("only-bad") { _, _ = fmt.Fprintf(tw, "%d\t%d\t%d\t%s\n", dlIdx, parIdx, s, color.GreenString("good")) } @@ -700,7 +751,7 @@ var utilSealerProvingSimulateWdPoStCmd = &cli.Command{ toProve := partitions[pidx].LiveSectors if !cctx.Bool("include-faulty") { - if toProve, err = bitfield.SubtractBitField(partitions[pidx].LiveSectors, partitions[pidx].FaultySectors); err != nil { + if toProve, err = bitfield.SubtractBitField(partitions[pidx].LiveSectors, partitions[pidx].FaultySectors); err != nil { //revive:disable-line:line-length-limit return err } } @@ -756,7 +807,12 @@ var utilSealerProvingSimulateWdPoStCmd = &cli.Command{ if err != nil { return err } - r, err := api.Damocles.GetWindowPoStChanlleengeRand(ctx, ts.Key(), abi.ChainEpoch(cctx.Int64("challenge")), abi.ActorID(mid)) + r, err := api.Damocles.GetWindowPoStChanlleengeRand( + ctx, + ts.Key(), + abi.ChainEpoch(cctx.Int64("challenge")), + abi.ActorID(mid), + ) if err != nil { return fmt.Errorf("getting challenge rand: %w", err) } @@ -773,7 +829,10 @@ var utilSealerProvingSimulateWdPoStCmd = &cli.Command{ return err } - fmt.Printf("Simulate sectors %v wdpost start, please retrieve `mock generate window post` from the log to view execution info.\n", proofSectors) + fmt.Printf( + "Simulate sectors %v wdpost start, please retrieve `mock generate window post` from the log to view execution info.\n", //revive:disable-line:line-length-limit + proofSectors, + ) return nil }, @@ -812,7 +871,6 @@ var utilSealerProvingSectorInfoCmd = &cli.Command{ Miner: mid, Number: abi.SectorNumber(num), }) - if err != nil { slog.Warnf("failed to get info: %w", err) continue @@ -898,7 +956,13 @@ var utilSealerProvingWinningVanillaCmd = &cli.Command{ randomness := make(abi.PoStRandomness, abi.RandomnessLength) - challenges, err := prover.GeneratePoStFallbackSectorChallenges(actx, abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, sectorID.Miner, randomness, []abi.SectorNumber{sectorID.Number}) + challenges, err := prover.GeneratePoStFallbackSectorChallenges( + actx, + abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, + sectorID.Miner, + randomness, + []abi.SectorNumber{sectorID.Number}, + ) if err != nil { return fmt.Errorf("generate challenge for sector %s: %w", sealedFileName, err) } @@ -922,7 +986,13 @@ var utilSealerProvingWinningVanillaCmd = &cli.Command{ slog.Infof("vannilla generated with %d bytes", len(vannilla)) - proofs, err := prover.GenerateWinningPoStWithVanilla(actx, abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, sectorID.Miner, randomness, [][]byte{vannilla}) + proofs, err := prover.GenerateWinningPoStWithVanilla( + actx, + abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, + sectorID.Miner, + randomness, + [][]byte{vannilla}, + ) if err != nil { return fmt.Errorf("generate winning post with vannilla for %s: %w", sealedFileName, err) } @@ -944,7 +1014,7 @@ var utilSealerProvingWinningVanillaCmd = &cli.Command{ } if output := cctx.String("output"); output != "" { - if err := os.WriteFile(output, vannilla, 0644); err != nil { + if err := os.WriteFile(output, vannilla, 0644); err != nil { //nolint:gosec return fmt.Errorf("write vannilla proof into file: %w", err) } @@ -982,7 +1052,7 @@ var utilSealerProvingCompactPartitionsCmd = &cli.Command{ }, &cli.StringFlag{ Name: "exid", - Usage: "external identifier of the message, ensure that we could make the message unique, or we could catch up with a previous message", + Usage: "external identifier of the message, ensure that we could make the message unique, or we could catch up with a previous message", //revive:disable-line:line-length-limit }, }, Action: func(cctx *cli.Context) error { @@ -1070,7 +1140,7 @@ var utilSealerProvingRecoverFaultsCmd = &cli.Command{ }, &cli.StringFlag{ Name: "exid", - Usage: "external identifier of the message, ensure that we could make the message unique, or we could catch up with a previous message", + Usage: "external identifier of the message, ensure that we could make the message unique, or we could catch up with a previous message", //revive:disable-line:line-length-limit }, }, Action: func(cctx *cli.Context) error { diff --git a/damocles-manager/cmd/damocles-manager/internal/util_sealer_sectors.go b/damocles-manager/cmd/damocles-manager/internal/util_sealer_sectors.go index 804d304bd..cb12ecd1a 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_sealer_sectors.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_sealer_sectors.go @@ -41,7 +41,7 @@ import ( "github.com/filecoin-project/venus/venus-shared/actors/builtin/miner" specpolicy "github.com/filecoin-project/venus/venus-shared/actors/policy" "github.com/filecoin-project/venus/venus-shared/types" - marketTypes "github.com/filecoin-project/venus/venus-shared/types/market" + markettypes "github.com/filecoin-project/venus/venus-shared/types/market" "github.com/filecoin-project/lotus/api" "github.com/ipfs-force-community/damocles/damocles-manager/core" @@ -120,12 +120,11 @@ var utilSealerSectorsAbortCmd = &cli.Command{ Flags: []cli.Flag{ &cli.BoolFlag{ Name: "really-do-it", - Usage: "WARNING: This command may result in inconsistent state of damocles-manager and damocles-worker. If you know what you're doing, use it", + Usage: "WARNING: This command may result in inconsistent state of damocles-manager and damocles-worker. If you know what you're doing, use it", //revive:disable-line:line-length-limit Value: false, }, }, Action: func(cctx *cli.Context) error { - // return fmt.Errorf("this command is not available in the current version, please use the `damocles-worker worker -c resume --state Aborted --index ` or `damocles-manager util worker resume Aborted` commands instead.\n See: https://github.com/ipfs-force-community/damocles/blob/main/docs/en/11.task-status-flow.md#1-for-a-sector-sealing-task-that-has-been-paused-due-to-an-error-and-cannot-be-resumed-such-as-the-ticket-has-expired-you-can-use") if count := cctx.Args().Len(); count < 2 { return fmt.Errorf("both miner actor id & sector number are required, only %d args provided", count) } @@ -220,7 +219,7 @@ var utilSealerSectorsListCmd = &cli.Command{ } count := 0 - fmt.Fprintln(os.Stdout, "Sectors:") + _, _ = fmt.Fprintln(os.Stdout, "Sectors:") for _, state := range states { if minerID != nil && state.ID.Miner != *minerID { @@ -261,19 +260,30 @@ var utilSealerSectorsListCmd = &cli.Command{ sectorMark = fmt.Sprintf("(%s)", strings.Join(marks, ", ")) } - fmt.Fprintf(os.Stdout, "%s%s:\n", util.FormatSectorID(state.ID), sectorMark) + _, _ = fmt.Fprintf(os.Stdout, "%s%s:\n", util.FormatSectorID(state.ID), sectorMark) if state.LatestState != nil { - fmt.Fprintf(os.Stdout, "\tWorker: %s @ %s\n", state.LatestState.Worker.Instance, state.LatestState.Worker.Location) - fmt.Fprintf(os.Stdout, "\tState: %s => %s @%s\n", state.LatestState.StateChange.Prev, state.LatestState.StateChange.Next, state.LatestState.StateChange.Event) + _, _ = fmt.Fprintf( + os.Stdout, + "\tWorker: %s @ %s\n", + state.LatestState.Worker.Instance, + state.LatestState.Worker.Location, + ) + _, _ = fmt.Fprintf( + os.Stdout, + "\tState: %s => %s @%s\n", + state.LatestState.StateChange.Prev, + state.LatestState.StateChange.Next, + state.LatestState.StateChange.Event, + ) } - fmt.Fprintf(os.Stdout, "\tFinalized: %v, Removed: %v\n", state.Finalized, state.Removed) + _, _ = fmt.Fprintf(os.Stdout, "\tFinalized: %v, Removed: %v\n", state.Finalized, state.Removed) - fmt.Fprintln(os.Stdout, "") + _, _ = fmt.Fprintln(os.Stdout, "") } - fmt.Fprintf(os.Stdout, "Count: %d\n", count) + _, _ = fmt.Fprintf(os.Stdout, "Count: %d\n", count) return nil }, @@ -382,28 +392,28 @@ var utilSealerSectorsCheckExpireCmd = &cli.Command{ }) blockDelaySecs := policy.NetParams.BlockDelaySecs - fmt.Fprintf(os.Stdout, "Sectors(%d):\n", len(sectors)) + _, _ = fmt.Fprintf(os.Stdout, "Sectors(%d):\n", len(sectors)) for _, sector := range sectors { - MaxExpiration := sector.Activation + specpolicy.GetSectorMaxLifetime(sector.SealProof, nv) + maxExpiration := sector.Activation + specpolicy.GetSectorMaxLifetime(sector.SealProof, nv) maxExpirationExtension, err := specpolicy.GetMaxSectorExpirationExtension(nv) if err != nil { return err } - MaxExtendNow := currEpoch + maxExpirationExtension + maxExtendNow := currEpoch + maxExpirationExtension - if MaxExtendNow > MaxExpiration { - MaxExtendNow = MaxExpiration + if maxExtendNow > maxExpiration { + maxExtendNow = maxExpiration } - fmt.Fprintf(os.Stdout, "\tID: %d\n", sector.SectorNumber) - fmt.Fprintf(os.Stdout, "\tSealProof: %d\n", sector.SealProof) - fmt.Fprintf(os.Stdout, "\tInitialPledge: %v\n", types.FIL(sector.InitialPledge).Short()) - fmt.Fprintf(os.Stdout, "\tActivation: %s\n", EpochTime(currEpoch, sector.Activation, blockDelaySecs)) - fmt.Fprintf(os.Stdout, "\tExpiration: %s\n", EpochTime(currEpoch, sector.Expiration, blockDelaySecs)) - fmt.Fprintf(os.Stdout, "\tMaxExpiration: %s\n", EpochTime(currEpoch, MaxExpiration, blockDelaySecs)) - fmt.Fprintf(os.Stdout, "\tMaxExtendNow: %s\n", EpochTime(currEpoch, MaxExtendNow, blockDelaySecs)) + _, _ = fmt.Fprintf(os.Stdout, "\tID: %d\n", sector.SectorNumber) + _, _ = fmt.Fprintf(os.Stdout, "\tSealProof: %d\n", sector.SealProof) + _, _ = fmt.Fprintf(os.Stdout, "\tInitialPledge: %v\n", types.FIL(sector.InitialPledge).Short()) + _, _ = fmt.Fprintf(os.Stdout, "\tActivation: %s\n", EpochTime(currEpoch, sector.Activation, blockDelaySecs)) + _, _ = fmt.Fprintf(os.Stdout, "\tExpiration: %s\n", EpochTime(currEpoch, sector.Expiration, blockDelaySecs)) + _, _ = fmt.Fprintf(os.Stdout, "\tMaxExpiration: %s\n", EpochTime(currEpoch, maxExpiration, blockDelaySecs)) + _, _ = fmt.Fprintf(os.Stdout, "\tMaxExtendNow: %s\n", EpochTime(currEpoch, maxExtendNow, blockDelaySecs)) - fmt.Fprintln(os.Stdout, "") + _, _ = fmt.Fprintln(os.Stdout, "") } return nil @@ -578,9 +588,23 @@ var utilSealerSectorsExpiredCmd = &cli.Command{ if cctx.Bool("remove-expired") { if !cctx.IsSet("confirm-remove-count") { fmt.Println() - fmt.Println(color.YellowString("All"), color.GreenString("%d", len(toRemove)), color.YellowString("sectors listed above will be removed\n")) - fmt.Println(color.YellowString("To confirm removal of the above sectors, including\n all related sealed and unsealed data, run:\n")) - fmt.Println(color.RedString("venus-sealer sectors expired --remove-expired --confirm-remove-count=%d --expired-epoch=%d\n", len(toRemove), lbts.Height())) + fmt.Println( + color.YellowString("All"), + color.GreenString("%d", len(toRemove)), + color.YellowString("sectors listed above will be removed\n"), + ) + fmt.Println( + color.YellowString( + "To confirm removal of the above sectors, including\n all related sealed and unsealed data, run:\n", //revive:disable-line:line-length-limit + ), + ) + fmt.Println( + color.RedString( + "venus-sealer sectors expired --remove-expired --confirm-remove-count=%d --expired-epoch=%d\n", + len(toRemove), + lbts.Height(), + ), + ) fmt.Println(color.YellowString("WARNING: This operation is irreversible")) return nil } @@ -588,7 +612,10 @@ var utilSealerSectorsExpiredCmd = &cli.Command{ fmt.Println() if int64(len(toRemove)) != cctx.Int64("confirm-remove-count") { - return fmt.Errorf("value of confirm-remove-count doesn't match the number of sectors which can be removed (%d)", len(toRemove)) + return fmt.Errorf( + "value of confirm-remove-count doesn't match the number of sectors which can be removed (%d)", + len(toRemove), + ) } actor, _ := address.IDFromAddress(maddr) @@ -636,9 +663,9 @@ func getSectorsFromFile(filePath string) ([]abi.SectorNumber, error) { } func SectorNumsToBitfield(sectors []abi.SectorNumber) bitfield.BitField { - var numbers []uint64 - for _, sector := range sectors { - numbers = append(numbers, uint64(sector)) + numbers := make([]uint64, len(sectors)) + for i, sector := range sectors { + numbers[i] = uint64(sector) } return bitfield.NewFromSet(numbers) @@ -719,11 +746,11 @@ var utilSealerSectorsExtendCmd = &cli.Command{ }, &cli.Int64Flag{ Name: "from", - Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 120 (1 hour)", + Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 120 (1 hour)", //revive:disable-line:line-length-limit }, &cli.Int64Flag{ Name: "to", - Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 92160 (32 days)", + Usage: "only consider sectors whose current expiration epoch is in the range of [from, to], defaults to: now + 92160 (32 days)", //revive:disable-line:line-length-limit }, &cli.StringFlag{ Name: "sector-file", @@ -748,7 +775,7 @@ var utilSealerSectorsExtendCmd = &cli.Command{ }, &cli.BoolFlag{ Name: "drop-claims", - Usage: "drop claims for sectors that can be extended, but only by dropping some of their verified power claims", + Usage: "drop claims for sectors that can be extended, but only by dropping some of their verified power claims", //revive:disable-line:line-length-limit }, &cli.Int64Flag{ Name: "tolerance", @@ -766,7 +793,7 @@ var utilSealerSectorsExtendCmd = &cli.Command{ }, &cli.BoolFlag{ Name: "really-do-it", - Usage: "pass this flag to really extend sectors, otherwise will only print out json representation of parameters", + Usage: "pass this flag to really extend sectors, otherwise will only print out json representation of parameters", //revive:disable-line:line-length-limit }, }, Action: func(cctx *cli.Context) error { @@ -1015,7 +1042,6 @@ var utilSealerSectorsExtendCmd = &cli.Command{ for l, exts := range extensions { for newExp, numbers := range exts { - sectorsWithoutClaimsToExtend := bitfield.New() var sectorsWithClaims []core.SectorClaim @@ -1042,12 +1068,13 @@ var utilSealerSectorsExtendCmd = &cli.Command{ if !ok { return fmt.Errorf("failed to find sector in active sector set: %w", err) } + //revive:disable-next-line:line-length-limit if !cctx.Bool("drop-claims") || // FIP-0045 requires the claim minimum duration to have passed currEpoch <= (claim.TermStart+claim.TermMin) || // FIP-0045 requires the sector to be in its last 30 days of life (currEpoch <= sectorInfo.Expiration-stbuiltin.EndOfLifeClaimDropPeriod) { - fmt.Printf("skipping sector %d because claim %d does not live long enough \n", sectorNumber, claimID) + fmt.Printf("skipping sector %d because claim %d does not live long enough \n", sectorNumber, claimID) //revive:disable-line:line-length-limit cannotExtendSector = true break } @@ -1202,7 +1229,10 @@ var utilSealerSectorsTerminateCmd = &cli.Command{ } actor := cctx.Uint64("actor") - resp, err := cli.Damocles.TerminateSector(gctx, abi.SectorID{Miner: abi.ActorID(actor), Number: abi.SectorNumber(id)}) + resp, err := cli.Damocles.TerminateSector( + gctx, + abi.SectorID{Miner: abi.ActorID(actor), Number: abi.SectorNumber(id)}, + ) if err != nil { return err } @@ -1234,13 +1264,21 @@ var utilSealerSectorsTerminateQueryCmd = &cli.Command{ } actor := cctx.Uint64("actor") - resp, err := cli.Damocles.PollTerminateSectorState(gctx, abi.SectorID{Miner: abi.ActorID(actor), Number: abi.SectorNumber(id)}) + resp, err := cli.Damocles.PollTerminateSectorState( + gctx, + abi.SectorID{Miner: abi.ActorID(actor), Number: abi.SectorNumber(id)}, + ) if err != nil { return err } if resp.TerminateCid != nil { - fmt.Printf("msg: %s, height: %v, added height: %v\n", resp.TerminateCid.String(), resp.TerminatedAt, resp.AddedHeight) + fmt.Printf( + "msg: %s, height: %v, added height: %v\n", + resp.TerminateCid.String(), + resp.TerminatedAt, + resp.AddedHeight, + ) } else { fmt.Printf("msg: null, added height: %v\n", resp.AddedHeight) } @@ -1251,7 +1289,7 @@ var utilSealerSectorsTerminateQueryCmd = &cli.Command{ var utilSealerSectorsRemoveCmd = &cli.Command{ Name: "remove", - Usage: "Forcefully remove persist stores of sector(WARNING: This means losing power and collateral for the removed sector (use 'terminate' for lower penalty))", + Usage: "Forcefully remove persist stores of sector(WARNING: This means losing power and collateral for the removed sector (use 'terminate' for lower penalty))", //revive:disable-line:line-length-limit ArgsUsage: "", Flags: []cli.Flag{ &cli.Uint64Flag{ @@ -1294,7 +1332,7 @@ var utilSealerSectorsRemoveCmd = &cli.Command{ var utilSealerSectorsFinalizeCmd = &cli.Command{ Name: "finalize", - Usage: "Mandatory label the sector status as the finalize, this is only to the sector that has been on the chain.", + Usage: "Mandatory label the sector status as the finalize, this is only to the sector that has been on the chain.", //revive:disable-line:line-length-limit ArgsUsage: "", Flags: []cli.Flag{ &cli.StringFlag{ @@ -1422,15 +1460,15 @@ var utilSealerSectorsFindDealCmd = &cli.Command{ } if len(sectors) == 0 { - fmt.Fprintln(os.Stdout, "Not Found") + _, _ = fmt.Fprintln(os.Stdout, "Not Found") return nil } for _, sector := range sectors { - fmt.Fprintln(os.Stdout, util.FormatSectorID(sector.ID)) + _, _ = fmt.Fprintln(os.Stdout, util.FormatSectorID(sector.ID)) } - fmt.Fprintln(os.Stdout, "") + _, _ = fmt.Fprintln(os.Stdout, "") return nil }, @@ -1438,7 +1476,7 @@ var utilSealerSectorsFindDealCmd = &cli.Command{ var utilSealerSectorsResendPreCommitCmd = &cli.Command{ Name: "resend-pre", - Usage: "Resend the pre commit on chain info for the specified sector, should only be used in situations that won't recover automatically", + Usage: "Resend the pre commit on chain info for the specified sector, should only be used in situations that won't recover automatically", //revive:disable-line:line-length-limit ArgsUsage: " ", Flags: []cli.Flag{}, Action: func(cctx *cli.Context) error { @@ -1495,7 +1533,6 @@ var utilSealerSectorsResendPreCommitCmd = &cli.Command{ ID: sid, ProofType: state.SectorType, }, onChainInfo, true) - if err != nil { return RPCCallError("SubmitPreCommit", err) } @@ -1513,7 +1550,7 @@ var utilSealerSectorsResendPreCommitCmd = &cli.Command{ var utilSealerSectorsResendProveCommitCmd = &cli.Command{ Name: "resend-prove", - Usage: "Resend the prove commit on chain info for the specified sector, should only be used in situations that won't recover automatically", + Usage: "Resend the prove commit on chain info for the specified sector, should only be used in situations that won't recover automatically", //revive:disable-line:line-length-limit ArgsUsage: " ", Flags: []cli.Flag{}, Action: func(cctx *cli.Context) error { @@ -1558,7 +1595,6 @@ var utilSealerSectorsResendProveCommitCmd = &cli.Command{ } resp, err := cli.Damocles.SubmitProof(gctx, sid, *state.Proof, true) - if err != nil { return RPCCallError("SubmitProof", err) } @@ -1762,16 +1798,16 @@ var utilSealerSectorsExportMetadataCmd = &cli.Command{ sector, err := sectorState2SectorInfo(ctx, cli, state) if err != nil { - fmt.Fprintf(os.Stdout, "sector %v to sector info err: %s\n", state.ID.Number, err) + _, _ = fmt.Fprintf(os.Stdout, "sector %v to sector info err: %s\n", state.ID.Number, err) failCounts++ } else { buf, err := cborutil.Dump(sector) if err != nil { - fmt.Fprintf(os.Stdout, "cborutil dump sector %v err: %s\n", state.ID.Number, err) + _, _ = fmt.Fprintf(os.Stdout, "cborutil dump sector %v err: %s\n", state.ID.Number, err) failCounts++ } else { if err = ds.Put(ctx, sectorKey, buf); err != nil { - fmt.Fprintf(os.Stdout, "put sector %v err: %s\n", state.ID.Number, err) + _, _ = fmt.Fprintf(os.Stdout, "put sector %v err: %s\n", state.ID.Number, err) failCounts++ } } @@ -1781,13 +1817,13 @@ var utilSealerSectorsExportMetadataCmd = &cli.Command{ nextSid = state.ID.Number } } - fmt.Fprintf(os.Stdout, "export failure counts: %d\n", failCounts) + _, _ = fmt.Fprintf(os.Stdout, "export failure counts: %d\n", failCounts) } // export the sector number of the new sector if cctx.IsSet("next-number") { nextNumber := cctx.Uint64("next-number") - fmt.Fprintf(os.Stdout, "next sector number: %d\n", nextNumber) + _, _ = fmt.Fprintf(os.Stdout, "next sector number: %d\n", nextNumber) if nextSid < abi.SectorNumber(nextNumber) { nextSid = abi.SectorNumber(nextNumber) } @@ -1798,7 +1834,7 @@ var utilSealerSectorsExportMetadataCmd = &cli.Command{ if err != nil { return fmt.Errorf("update next sector number: %v", err) } - fmt.Fprintf(os.Stdout, "update next sector number: %d\n", nextSid) + _, _ = fmt.Fprintf(os.Stdout, "update next sector number: %d\n", nextSid) return nil }, @@ -1911,13 +1947,13 @@ var utilSealerSectorsExportFilesCmd = &cli.Command{ loc, err := cli.Damocles.ProvingSectorInfo(ctx, state.ID) if err != nil { - fmt.Fprintf(os.Stdout, "find sector %v location: %s\n", state.ID.Number, err) + _, _ = fmt.Fprintf(os.Stdout, "find sector %v location: %s\n", state.ID.Number, err) failCounts++ continue } // move - fmt.Fprintf(os.Stdout, "move sector %d file ...\n", state.ID.Number) + _, _ = fmt.Fprintf(os.Stdout, "move sector %d file ...\n", state.ID.Number) totalCunts++ wg.Add(1) throttle <- struct{}{} @@ -1948,7 +1984,7 @@ var utilSealerSectorsExportFilesCmd = &cli.Command{ if os.IsNotExist(err) { needMove = true } else { - fmt.Fprintf(os.Stdout, "stat path %s: %s", destPath, err) + _, _ = fmt.Fprintf(os.Stdout, "stat path %s: %s", destPath, err) } } else { if equal, _ := fileCompare(path, destPath); !equal { @@ -1957,15 +1993,14 @@ var utilSealerSectorsExportFilesCmd = &cli.Command{ } if needMove { - fmt.Fprintf(os.Stdout, "copy file from %s to %s\n", path, destPath) + _, _ = fmt.Fprintf(os.Stdout, "copy file from %s to %s\n", path, destPath) err = copyFile(path, destPath) if err != nil { return fmt.Errorf("copy %s to %s err: %w", path, destPath, err) } } - } else { - fmt.Fprintf(os.Stdout, "move file from %s to %s\n", path, destPath) + _, _ = fmt.Fprintf(os.Stdout, "move file from %s to %s\n", path, destPath) err = os.Rename(path, destPath) if err != nil { return fmt.Errorf("move %s to %s err: %w", path, destPath, err) @@ -1978,7 +2013,7 @@ var utilSealerSectorsExportFilesCmd = &cli.Command{ } return nil }); err != nil { - fmt.Fprintf(os.Stdout, "export sector %v file: %s\n", sid, err) + _, _ = fmt.Fprintf(os.Stdout, "export sector %v file: %s\n", sid, err) lockCts.Lock() failCounts++ lockCts.Unlock() @@ -1988,13 +2023,17 @@ var utilSealerSectorsExportFilesCmd = &cli.Command{ }(state.ID.Number) } wg.Wait() - fmt.Fprintf(os.Stdout, "export failure counts: %d, total: %d\n", failCounts, totalCunts) + _, _ = fmt.Fprintf(os.Stdout, "export failure counts: %d, total: %d\n", failCounts, totalCunts) return nil }, } -func sectorInfo2SectorState(sid abi.SectorID, lotusSectorInfo *lotusminer.SectorInfo, cli api.StorageMiner) (*core.SectorState, error) { +func sectorInfo2SectorState( + sid abi.SectorID, + lotusSectorInfo *lotusminer.SectorInfo, + cli api.StorageMiner, +) (*core.SectorState, error) { var upgraded core.SectorUpgraded switch lotusminer.SectorState(lotusSectorInfo.State) { case lotusminer.FinalizeSector, lotusminer.Proving: @@ -2049,7 +2088,7 @@ func sectorInfo2SectorState(sid abi.SectorID, lotusSectorInfo *lotusminer.Sector if lotusPiece.DealInfo != nil { spiece.DealInfo = &core.DealInfoV2{ - DealInfoV2: &marketTypes.DealInfoV2{ + DealInfoV2: &markettypes.DealInfoV2{ DealID: lotusPiece.DealInfo.DealID, PieceCID: lotusPiece.DealInfo.PieceCID(), PieceSize: lotusPiece.Piece.Size, @@ -2065,9 +2104,9 @@ func sectorInfo2SectorState(sid abi.SectorID, lotusSectorInfo *lotusminer.Sector spiece.DealInfo.Provider = lotusPiece.DealInfo.DealProposal.Provider } else { // DDO deal - spiece.DealInfo.AllocationID = types.AllocationId(lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.ID) - if spiece.DealInfo.Client, err = address.NewIDAddress(uint64(lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.Client)); err != nil { - return nil, fmt.Errorf("invalid client(%s): %w", lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.Client, err) + spiece.DealInfo.AllocationID = types.AllocationId(lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.ID) //revive:disable-line:line-length-limit + if spiece.DealInfo.Client, err = address.NewIDAddress(uint64(lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.Client)); err != nil { //revive:disable-line:line-length-limit + return nil, fmt.Errorf("invalid client(%s): %w", lotusPiece.DealInfo.PieceActivationManifest.VerifiedAllocationKey.Client, err) //revive:disable-line:line-length-limit } } if spiece.DealInfo.StartEpoch, err = lotusPiece.DealInfo.StartEpoch(); err != nil { @@ -2084,9 +2123,9 @@ func sectorInfo2SectorState(sid abi.SectorID, lotusSectorInfo *lotusminer.Sector pieceInfo, err := cli.PiecesGetPieceInfo(context.Background(), lotusPiece.Piece.PieceCID) if err != nil { - fmt.Fprintf(os.Stdout, "get piece info %s: %s\n", lotusPiece.Piece.PieceCID, err) + _, _ = fmt.Fprintf(os.Stdout, "get piece info %s: %s\n", lotusPiece.Piece.PieceCID, err) } else if pieceInfo == nil { - fmt.Fprintf(os.Stdout, "piece info not found %s\n", lotusPiece.Piece.PieceCID) + _, _ = fmt.Fprintf(os.Stdout, "piece info not found %s\n", lotusPiece.Piece.PieceCID) } else { for _, deal := range pieceInfo.Deals { if deal.DealID == lotusPiece.DealInfo.DealID { @@ -2096,7 +2135,6 @@ func sectorInfo2SectorState(sid abi.SectorID, lotusSectorInfo *lotusminer.Sector } } } - } pieces = append(pieces, spiece) @@ -2166,12 +2204,16 @@ func openDestDatastore(repoPath string) (datastore.Batching, error) { }) } -func sectorState2SectorInfo(ctx context.Context, api *APIClient, state *core.SectorState) (*lotusminer.SectorSealingInfo, error) { - var toChainCid = func(mid string) *cid.Cid { +func sectorState2SectorInfo( + ctx context.Context, + client *APIClient, + state *core.SectorState, +) (*lotusminer.SectorSealingInfo, error) { + toChainCid := func(mid string) *cid.Cid { undefCid := cid.NewCidV0(u.Hash([]byte("undef"))) c := &undefCid if len(mid) > 0 { - if msg, err := api.Messager.GetMessageByUid(ctx, mid); err == nil { + if msg, err := client.Messager.GetMessageByUid(ctx, mid); err == nil { c = msg.SignedCid } } @@ -2191,7 +2233,8 @@ func sectorState2SectorInfo(ctx context.Context, api *APIClient, state *core.Sec for _, sp := range state.SectorPiece() { piece := sp.PieceInfo() lotusPieceDealInfo := &lotusminer.PieceDealInfo{} - // Since damocles and lotus dealinfo are too different, only dealID or allocationID is exported here for the time being. + // Since damocles and lotus dealinfo are too different, + // only dealID or allocationID is exported here for the time being. if sp.IsBuiltinMarket() { lotusPieceDealInfo.DealID = sp.DealID() } else { @@ -2359,12 +2402,11 @@ var utilSealerSectorsUnsealCmd = &cli.Command{ }, &cli.StringFlag{ Name: "dest", - Usage: "specify destination to transfer piece manually, there are five protocols can be used:" + "\"file:///path\",\"http://\" \"https://\", \"market://store_name/piece_cid\", \"store://store_name/piece_cid\"", + Usage: "specify destination to transfer piece manually, there are five protocols can be used:" + "\"file:///path\",\"http://\" \"https://\", \"market://store_name/piece_cid\", \"store://store_name/piece_cid\"", //revive:disable-line:line-length-limit Required: false, }, }, Action: func(cctx *cli.Context) error { - if count := cctx.Args().Len(); count < 1 { return cli.ShowSubcommandHelp(cctx) } @@ -2440,7 +2482,8 @@ var utilSealerSectorsUnsealCmd = &cli.Command{ // } // if offsetPadded == math.MaxUint64 || sizePadded == 0 { - // Log.Warnf("no matched deal found in market with sector %d and piece %s", sectorState.ID.Number, pieceCid) + // Log.Warnf("no matched deal found in market with sector %d and piece %s", + // sectorState.ID.Number, pieceCid) // // get piece info from sector state // for _, p := range sectorState.Pieces { // if pieceCid.Equals(p.PieceCID) { @@ -2534,19 +2577,18 @@ var utilSealerSectorsUnsealCmd = &cli.Command{ fr32.Unpad(data, res) - err = os.WriteFile(output, res[:payloadSize], 0644) + err = os.WriteFile(output, res[:payloadSize], 0644) //nolint:gosec if err != nil { return fmt.Errorf("write piece file failed: %w", err) } } else { // todo: set payloadsize to unseal task - stream, err := cli.Damocles.UnsealPiece(gctx, sectorID, pieceCid, types.UnpaddedByteIndex(offset), size, dest) + stream, err := cli.Damocles.UnsealPiece(gctx, sectorID, pieceCid, types.UnpaddedByteIndex(offset), size, dest) //revive:disable-line:line-length-limit if err != nil { return fmt.Errorf("set task for unseal failed: %w", err) } if stream != nil { - fi, err := os.OpenFile(output, os.O_CREATE|os.O_WRONLY, 0644) if err != nil { return err @@ -2694,105 +2736,126 @@ var utilSealerSectorsStateImportJSONCmd = &cli.Command{ } func showSectorState(state *core.SectorState) { - fmt.Fprintf(os.Stdout, "Sector %s: \n", util.FormatSectorID(state.ID)) + _, _ = fmt.Fprintf(os.Stdout, "Sector %s: \n", util.FormatSectorID(state.ID)) // Common - fmt.Fprintln(os.Stdout, "\nCommon:") - fmt.Fprintf(os.Stdout, "\tFinalized: %v\n", state.Finalized) - fmt.Fprintf(os.Stdout, "\tRemoved: %v\n", state.Removed) + _, _ = fmt.Fprintln(os.Stdout, "\nCommon:") + _, _ = fmt.Fprintf(os.Stdout, "\tFinalized: %v\n", state.Finalized) + _, _ = fmt.Fprintf(os.Stdout, "\tRemoved: %v\n", state.Removed) abortReason := state.AbortReason if abortReason == "" { abortReason = "NULL" } - fmt.Fprintf(os.Stdout, "\tAborting: \n\t\t%s\n", strings.ReplaceAll(abortReason, "\n", "\n\t\t")) + _, _ = fmt.Fprintf(os.Stdout, "\tAborting: \n\t\t%s\n", strings.ReplaceAll(abortReason, "\n", "\n\t\t")) // LatestState - fmt.Fprintln(os.Stdout, "\nLatestState:") - fmt.Fprintf(os.Stdout, "\tState Change: %s\n", FormatOrNull(state.LatestState, func() string { - return fmt.Sprintf("%s => %s, by %s", state.LatestState.StateChange.Prev, state.LatestState.StateChange.Next, state.LatestState.StateChange.Event) + _, _ = fmt.Fprintln(os.Stdout, "\nLatestState:") + _, _ = fmt.Fprintf(os.Stdout, "\tState Change: %s\n", FormatOrNull(state.LatestState, func() string { + return fmt.Sprintf( + "%s => %s, by %s", + state.LatestState.StateChange.Prev, + state.LatestState.StateChange.Next, + state.LatestState.StateChange.Event, + ) })) - fmt.Fprintf(os.Stdout, "\tWorker: %s\n", FormatOrNull(state.LatestState, func() string { + _, _ = fmt.Fprintf(os.Stdout, "\tWorker: %s\n", FormatOrNull(state.LatestState, func() string { return fmt.Sprintf("%s(%s)", state.LatestState.Worker.Instance, state.LatestState.Worker.Location) })) - fmt.Fprintf(os.Stdout, "\tFailure: %s\n", FormatOrNull(state.LatestState, func() string { + _, _ = fmt.Fprintf(os.Stdout, "\tFailure: %s\n", FormatOrNull(state.LatestState, func() string { return FormatOrNull(state.LatestState.Failure, func() string { - return fmt.Sprintf("\n\t\t[%s] %s", state.LatestState.Failure.Level, strings.ReplaceAll(state.LatestState.Failure.Desc, "\n", "\n\t\t")) + return fmt.Sprintf( + "\n\t\t[%s] %s", + state.LatestState.Failure.Level, + strings.ReplaceAll(state.LatestState.Failure.Desc, "\n", "\n\t\t"), + ) }) })) // Deals - fmt.Fprintln(os.Stdout, "\nDeals:") + _, _ = fmt.Fprintln(os.Stdout, "\nDeals:") if !state.HasData() { - fmt.Fprintln(os.Stdout, "\tNULL") + _, _ = fmt.Fprintln(os.Stdout, "\tNULL") } else { for _, piece := range state.SectorPiece() { if !piece.HasDealInfo() { continue } if piece.IsBuiltinMarket() { - fmt.Fprintf(os.Stdout, "\tDealID: %s\n", piece.DisplayDealID()) + _, _ = fmt.Fprintf(os.Stdout, "\tDealID: %s\n", piece.DisplayDealID()) } else { - fmt.Fprintf(os.Stdout, "\tAllocID: %s\n", piece.DisplayDealID()) + _, _ = fmt.Fprintf(os.Stdout, "\tAllocID: %s\n", piece.DisplayDealID()) } pieceInfo := piece.PieceInfo() - fmt.Fprintf(os.Stdout, "\tPiece: { cid: %s; size: %d; offset: %d }\n", pieceInfo.Cid, pieceInfo.Size, pieceInfo.Offset) + _, _ = fmt.Fprintf(os.Stdout, "\tPiece: { cid: %s; size: %d; offset: %d }\n", pieceInfo.Cid, pieceInfo.Size, pieceInfo.Offset) //revive:disable-line:line-length-limit } } // Sealing - fmt.Fprintln(os.Stdout, "\nSealing:") - fmt.Fprintf(os.Stdout, "\tTicket: %s\n", FormatOrNull(state.Ticket, func() string { + _, _ = fmt.Fprintln(os.Stdout, "\nSealing:") + _, _ = fmt.Fprintf(os.Stdout, "\tTicket: %s\n", FormatOrNull(state.Ticket, func() string { return fmt.Sprintf("(%d) %x", state.Ticket.Epoch, state.Ticket.Ticket) })) - fmt.Fprintf(os.Stdout, "\tPreCommit Info:\n\t\t%s\n", FormatOrNull(state.Pre, func() string { + _, _ = fmt.Fprintf(os.Stdout, "\tPreCommit Info:\n\t\t%s\n", FormatOrNull(state.Pre, func() string { return fmt.Sprintf("CommD: %s\n\t\tCommR: %s", state.Pre.CommD, state.Pre.CommR) })) - fmt.Fprintf(os.Stdout, "\tPreCommit Message: %s\n", FormatOrNull(state.MessageInfo.PreCommitCid, func() string { - return state.MessageInfo.PreCommitCid.String() - })) + _, _ = fmt.Fprintf( + os.Stdout, + "\tPreCommit Message: %s\n", + FormatOrNull(state.MessageInfo.PreCommitCid, func() string { + return state.MessageInfo.PreCommitCid.String() + }), + ) - fmt.Fprintf(os.Stdout, "\tSeed: %s\n", FormatOrNull(state.Seed, func() string { + _, _ = fmt.Fprintf(os.Stdout, "\tSeed: %s\n", FormatOrNull(state.Seed, func() string { return fmt.Sprintf("(%d) %x", state.Seed.Epoch, state.Seed.Seed) })) - fmt.Fprintf(os.Stdout, "\tProveCommit Info:\n\t\t%s\n", FormatOrNull(state.Proof, func() string { + _, _ = fmt.Fprintf(os.Stdout, "\tProveCommit Info:\n\t\t%s\n", FormatOrNull(state.Proof, func() string { return fmt.Sprintf("Proof: %x", state.Proof.Proof) })) - fmt.Fprintf(os.Stdout, "\tProveCommit Message: %s\n", FormatOrNull(state.MessageInfo.CommitCid, func() string { - return state.MessageInfo.CommitCid.String() - })) + _, _ = fmt.Fprintf( + os.Stdout, + "\tProveCommit Message: %s\n", + FormatOrNull(state.MessageInfo.CommitCid, func() string { + return state.MessageInfo.CommitCid.String() + }), + ) - fmt.Fprintf(os.Stdout, "\tMessage NeedSend: %v\n", state.MessageInfo.NeedSend) + _, _ = fmt.Fprintf(os.Stdout, "\tMessage NeedSend: %v\n", state.MessageInfo.NeedSend) // Upgrading - fmt.Fprintln(os.Stdout, "\nSnapUp:") - fmt.Fprintf(os.Stdout, "\tUpgraded: %v\n", state.Upgraded) + _, _ = fmt.Fprintln(os.Stdout, "\nSnapUp:") + _, _ = fmt.Fprintf(os.Stdout, "\tUpgraded: %v\n", state.Upgraded) if state.Upgraded { if state.UpgradedInfo != nil { - fmt.Fprintf(os.Stdout, "\tUnsealedCID: %s\n", state.UpgradedInfo.UnsealedCID) - fmt.Fprintf(os.Stdout, "\tSealedCID: %s\n", state.UpgradedInfo.UnsealedCID) - fmt.Fprintf(os.Stdout, "\tProof: %x\n", state.UpgradedInfo.Proof[:]) + _, _ = fmt.Fprintf(os.Stdout, "\tUnsealedCID: %s\n", state.UpgradedInfo.UnsealedCID) + _, _ = fmt.Fprintf(os.Stdout, "\tSealedCID: %s\n", state.UpgradedInfo.UnsealedCID) + _, _ = fmt.Fprintf(os.Stdout, "\tProof: %x\n", state.UpgradedInfo.Proof[:]) } if state.UpgradeMessageID != nil { - fmt.Fprintf(os.Stdout, "\tUpgrade Message: %s\n", *state.UpgradeMessageID) + _, _ = fmt.Fprintf(os.Stdout, "\tUpgrade Message: %s\n", *state.UpgradeMessageID) } if state.UpgradeLandedEpoch != nil { - fmt.Fprintf(os.Stdout, "\tLanded Epoch: %d\n", *state.UpgradeLandedEpoch) + _, _ = fmt.Fprintf(os.Stdout, "\tLanded Epoch: %d\n", *state.UpgradeLandedEpoch) } } // Termination - fmt.Fprintln(os.Stdout, "\nTermination:") - fmt.Fprintf(os.Stdout, "\tTerminate Message: %s\n", FormatOrNull(state.TerminateInfo.TerminateCid, func() string { - return state.TerminateInfo.TerminateCid.String() - })) + _, _ = fmt.Fprintln(os.Stdout, "\nTermination:") + _, _ = fmt.Fprintf( + os.Stdout, + "\tTerminate Message: %s\n", + FormatOrNull(state.TerminateInfo.TerminateCid, func() string { + return state.TerminateInfo.TerminateCid.String() + }), + ) // Rebuild - fmt.Fprintf(os.Stdout, "\nRebuild: %v\n", state.NeedRebuild) + _, _ = fmt.Fprintf(os.Stdout, "\nRebuild: %v\n", state.NeedRebuild) - fmt.Fprintln(os.Stdout, "") + _, _ = fmt.Fprintln(os.Stdout, "") } diff --git a/damocles-manager/cmd/damocles-manager/internal/util_sealer_snap.go b/damocles-manager/cmd/damocles-manager/internal/util_sealer_snap.go index 1885c15ce..960accc7f 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_sealer_snap.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_sealer_snap.go @@ -94,7 +94,7 @@ var utilSealerSnapCandidatesCmd = &cli.Command{ } if len(candidates) == 0 { - fmt.Fprintln(os.Stdout, "no candidates available") + _, _ = fmt.Fprintln(os.Stdout, "no candidates available") return nil } @@ -103,7 +103,7 @@ var utilSealerSnapCandidatesCmd = &cli.Command{ tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0) defer tw.Flush() - fmt.Fprintln(tw, "deadline\tcount") + _, _ = fmt.Fprintln(tw, "deadline\tcount") for i, bits := range candidates { var count uint64 if bits != nil { @@ -114,7 +114,7 @@ var utilSealerSnapCandidatesCmd = &cli.Command{ } if count > 0 || showAll { - fmt.Fprintf(tw, "%d\t%d\n", i, count) + _, _ = fmt.Fprintf(tw, "%d\t%d\n", i, count) } } diff --git a/damocles-manager/cmd/damocles-manager/internal/util_storage.go b/damocles-manager/cmd/damocles-manager/internal/util_storage.go index 31dd3610a..3eb38c1a8 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_storage.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_storage.go @@ -82,8 +82,14 @@ var utilStorageGenSectorStoreJSONCmd = &cli.Command{ Weight: cctx.Uint("weight"), }, StoreSelectPolicy: objstore.StoreSelectPolicy{ - AllowMiners: slices.Map(cctx.Uint64Slice("allow-miners"), func(x uint64) abi.ActorID { return abi.ActorID(x) }), - DenyMiners: slices.Map(cctx.Uint64Slice("deny-miners"), func(x uint64) abi.ActorID { return abi.ActorID(x) }), + AllowMiners: slices.Map( + cctx.Uint64Slice("allow-miners"), + func(x uint64) abi.ActorID { return abi.ActorID(x) }, + ), + DenyMiners: slices.Map( + cctx.Uint64Slice("deny-miners"), + func(x uint64) abi.ActorID { return abi.ActorID(x) }, + ), }, PluginName: cctx.String("plugin-name"), }, @@ -103,7 +109,7 @@ var utilStorageGenSectorStoreJSONCmd = &cli.Command{ if filepath.Base(targetPath) != modules.FilenameSectorStoreJSON { targetPath = filepath.Join(targetPath, modules.FilenameSectorStoreJSON) } - return os.WriteFile(targetPath, b, 0644) + return os.WriteFile(targetPath, b, 0644) //nolint:gosec }, } @@ -194,7 +200,6 @@ var utilStorageAttachCmd = &cli.Command{ dix.Override(new(dep.ListenAddress), dep.ListenAddress(cctx.String(SealerListenFlag.Name))), dix.Populate(dep.InvokePopulate, &indexer, &chainAPI), ) - if err != nil { return fmt.Errorf("construct sector indexer: %w", err) } @@ -240,7 +245,17 @@ var utilStorageAttachCmd = &cli.Command{ if allowSplitted { logger.Infof("scan for splitted cache dirs(upgrade=%v)", upgrade) - cachedSIDs, err := scanForSectors(gctx, logger, cacheInfo, abs, pattern, upgrade, true, allowSplitted, verbose) + cachedSIDs, err := scanForSectors( + gctx, + logger, + cacheInfo, + abs, + pattern, + upgrade, + true, + allowSplitted, + verbose, + ) if err != nil { return fmt.Errorf("scan splitted cache dirs(upgrade=%v): %w", upgrade, err) } @@ -305,7 +320,17 @@ func (c *cachedInfoForScanning) getSectorSize(ctx context.Context, mid abi.Actor return ssize, nil } -func scanForSectors(ctx context.Context, logger *logging.ZapLogger, cachedInfo *cachedInfoForScanning, abs, pattern string, upgrade bool, useCacheDir bool, allowSplitted bool, verbose bool) ([]abi.SectorID, error) { +//revive:disable-next-line:argument-limit +func scanForSectors( + ctx context.Context, + logger *logging.ZapLogger, + cachedInfo *cachedInfoForScanning, + abs, pattern string, + upgrade bool, + useCacheDir bool, + allowSplitted bool, + verbose bool, +) ([]abi.SectorID, error) { var dirOfSealedFile string var dirOfCacheDir string @@ -467,7 +492,12 @@ var utilStorageFindCmd = &cli.Command{ return nil } - Log.Infof("sector %s located, sealed file in %q, cache dir in %q", util.FormatSectorID(sid), stores.SealedFile, stores.CacheDir) + Log.Infof( + "sector %s located, sealed file in %q, cache dir in %q", + util.FormatSectorID(sid), + stores.SealedFile, + stores.CacheDir, + ) for _, instanceName := range []string{stores.SealedFile, stores.CacheDir} { iLog := Log.With("instance", instanceName) @@ -483,7 +513,6 @@ var utilStorageFindCmd = &cli.Command{ } iLog.Error("failed to get store instance") - } return nil @@ -525,7 +554,13 @@ var utilStorageListCmd = &cli.Command{ if len(detail.ReservedBy) > 0 { fmt.Println("\tReserved Items:") for i, res := range detail.ReservedBy { - fmt.Printf("\t\t#%d: %s, %s, %s ago\n", i, res.By, units.BytesSize(float64(res.Size)), time.Since(time.Unix(res.At, 0))) + fmt.Printf( + "\t\t#%d: %s, %s, %s ago\n", + i, + res.By, + units.BytesSize(float64(res.Size)), + time.Since(time.Unix(res.At, 0)), + ) } } diff --git a/damocles-manager/cmd/damocles-manager/internal/util_worker.go b/damocles-manager/cmd/damocles-manager/internal/util_worker.go index 79c2a18a3..ce22b4a78 100644 --- a/damocles-manager/cmd/damocles-manager/internal/util_worker.go +++ b/damocles-manager/cmd/damocles-manager/internal/util_worker.go @@ -55,7 +55,10 @@ var utilWorkerListCmd = &cli.Command{ tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0) defer tw.Flush() - _, _ = fmt.Fprintln(tw, "Name\tDest\tVersion\tThreads\tEmpty\tPaused\tRunning\tWaiting\tErrors\tLastPing(with ! if expired)") + _, _ = fmt.Fprintln( + tw, + "Name\tDest\tVersion\tThreads\tEmpty\tPaused\tRunning\tWaiting\tErrors\tLastPing(with ! if expired)", + ) for _, pinfo := range pinfos { lastPing := time.Since(time.Unix(pinfo.LastPing, 0)) lastPingWarn := "" @@ -347,9 +350,13 @@ var utilWorkerWdPostListCmd = &cli.Command{ w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0) if detail { - _, err = w.Write([]byte("JobID\tPrefix\tMiner\tDDL\tPartitions\tSectors\tWorker\tState\tTry\tCreateAt\tStartedAt\tHeartbeatAt\tFinishedAt\tUpdatedAt\tError\n")) + _, err = w.Write( + []byte( + "JobID\tPrefix\tMiner\tDDL\tPartitions\tSectors\tWorker\tState\tTry\tCreateAt\tStartedAt\tHeartbeatAt\tFinishedAt\tUpdatedAt\tError\n", //revive:disable-line:line-length-limit + ), + ) } else { - _, err = w.Write([]byte("JobID\tMinerID\tDDL\tPartitions\tSectors\tWorker\tState\tTry\tCreateAt\tElapsed\tHeartbeat\tError\n")) + _, err = w.Write([]byte("JobID\tMinerID\tDDL\tPartitions\tSectors\tWorker\tState\tTry\tCreateAt\tElapsed\tHeartbeat\tError\n")) //revive:disable-line:line-length-limit } if err != nil { return err @@ -376,7 +383,7 @@ var utilWorkerWdPostListCmd = &cli.Command{ tryNum += "(Max)" } if detail { - fmt.Fprintf(w, "%s\t%s\t%s\t%d\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", + _, _ = fmt.Fprintf(w, "%s\t%s\t%s\t%d\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", job.ID, job.State, job.Input.MinerID, @@ -408,7 +415,7 @@ var utilWorkerWdPostListCmd = &cli.Command{ heartbeat = "-" } - fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", + _, _ = fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", job.ID, job.Input.MinerID, job.DeadlineIdx, @@ -425,7 +432,7 @@ var utilWorkerWdPostListCmd = &cli.Command{ } } - w.Flush() + _ = w.Flush() return nil }, } diff --git a/damocles-manager/cmd/damocles-manager/main.go b/damocles-manager/cmd/damocles-manager/main.go index 30e223dcb..becf92708 100644 --- a/damocles-manager/cmd/damocles-manager/main.go +++ b/damocles-manager/cmd/damocles-manager/main.go @@ -1,8 +1,6 @@ package main import ( - _ "net/http/pprof" - "github.com/urfave/cli/v2" "github.com/ipfs-force-community/damocles/damocles-manager/cmd/damocles-manager/internal" diff --git a/damocles-manager/cmd/damocles-manager/mock.go b/damocles-manager/cmd/damocles-manager/mock.go index c53003113..315c69dea 100644 --- a/damocles-manager/cmd/damocles-manager/mock.go +++ b/damocles-manager/cmd/damocles-manager/mock.go @@ -53,7 +53,6 @@ var mockCmd = &cli.Command{ dep.Mock(), dep.MockSealer(&apiService), ) - if err != nil { return fmt.Errorf("construct mock api: %w", err) } diff --git a/damocles-manager/cmd/damocles-manager/server.go b/damocles-manager/cmd/damocles-manager/server.go index 8e1894678..0c5ccffc2 100644 --- a/damocles-manager/cmd/damocles-manager/server.go +++ b/damocles-manager/cmd/damocles-manager/server.go @@ -71,11 +71,11 @@ func NewAPIServiceDisbaleWorkerWdPoSt( type handler struct { namespace string - hdl interface{} + hdl any } type APIService struct { - coreAPI interface{} + coreAPI any plugins *managerplugin.LoadedPlugins } diff --git a/damocles-manager/cmd/plugin/main.go b/damocles-manager/cmd/plugin/main.go index 44f5a51f5..5a6469900 100644 --- a/damocles-manager/cmd/plugin/main.go +++ b/damocles-manager/cmd/plugin/main.go @@ -9,7 +9,6 @@ import ( ) func main() { - app := &cli.App{ Name: "Tools for damocles-manager-plugin", Commands: []*cli.Command{ diff --git a/damocles-manager/core/api.go b/damocles-manager/core/api.go index fda0a43de..2aedac631 100644 --- a/damocles-manager/core/api.go +++ b/damocles-manager/core/api.go @@ -66,7 +66,11 @@ type SealerAPI interface { // Snap AllocateSanpUpSector(ctx context.Context, spec AllocateSnapUpSpec) (*AllocatedSnapUpSector, error) - SubmitSnapUpProof(ctx context.Context, sid abi.SectorID, snapupInfo SnapUpOnChainInfo) (SubmitSnapUpProofResp, error) + SubmitSnapUpProof( + ctx context.Context, + sid abi.SectorID, + snapupInfo SnapUpOnChainInfo, + ) (SubmitSnapUpProofResp, error) // Rebuild AllocateRebuildSector(ctx context.Context, spec AllocateSectorSpec) (*SectorRebuildInfo, error) @@ -100,9 +104,22 @@ type SealerCliAPI interface { RestoreSector(ctx context.Context, sid abi.SectorID, forced bool) (Meta, error) - CheckProvable(ctx context.Context, mid abi.ActorID, postProofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, strict, stateCheck bool) (map[abi.SectorNumber]string, error) - - SimulateWdPoSt(ctx context.Context, ddlIndex, partitionIndex uint64, maddr address.Address, postProofType abi.RegisteredPoStProof, sis []builtin.ExtendedSectorInfo, rand abi.PoStRandomness) error + CheckProvable( + ctx context.Context, + mid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + strict, stateCheck bool, + ) (map[abi.SectorNumber]string, error) + + SimulateWdPoSt( + ctx context.Context, + ddlIndex, partitionIndex uint64, + maddr address.Address, + postProofType abi.RegisteredPoStProof, + sis []builtin.ExtendedSectorInfo, + rand abi.PoStRandomness, + ) error SnapUpPreFetch(ctx context.Context, mid abi.ActorID, dlindex *uint64) (*SnapUpFetchResult, error) @@ -135,7 +152,14 @@ type SealerCliAPI interface { SectorSetForRebuild(ctx context.Context, sid abi.SectorID, opt RebuildOptions) (bool, error) // Unseal Sector - UnsealPiece(ctx context.Context, sid abi.SectorID, pieceCid cid.Cid, offset types.UnpaddedByteIndex, size abi.UnpaddedPieceSize, dest string) (<-chan []byte, error) + UnsealPiece( + ctx context.Context, + sid abi.SectorID, + pieceCid cid.Cid, + offset types.UnpaddedByteIndex, + size abi.UnpaddedPieceSize, + dest string, + ) (<-chan []byte, error) Version(ctx context.Context) (string, error) } @@ -143,7 +167,12 @@ type SealerCliAPI interface { type RandomnessAPI interface { GetTicket(context.Context, types.TipSetKey, abi.ChainEpoch, abi.ActorID) (Ticket, error) GetSeed(context.Context, types.TipSetKey, abi.ChainEpoch, abi.ActorID) (Seed, error) - GetWindowPoStChanlleengeRand(context.Context, types.TipSetKey, abi.ChainEpoch, abi.ActorID) (WindowPoStRandomness, error) + GetWindowPoStChanlleengeRand( + context.Context, + types.TipSetKey, + abi.ChainEpoch, + abi.ActorID, + ) (WindowPoStRandomness, error) GetWindowPoStCommitRand(context.Context, types.TipSetKey, abi.ChainEpoch) (WindowPoStRandomness, error) } @@ -154,7 +183,12 @@ type MinerAPI interface { type WorkerWdPoStAPI interface { WdPoStHeartbeatJobs(ctx context.Context, runningJobIDs []string, workerName string) (Meta, error) - WdPoStAllocateJobs(ctx context.Context, spec AllocateWdPoStJobSpec, num uint32, workerName string) (allocatedJobs []*WdPoStAllocatedJob, err error) + WdPoStAllocateJobs( + ctx context.Context, + spec AllocateWdPoStJobSpec, + num uint32, + workerName string, + ) (allocatedJobs []*WdPoStAllocatedJob, err error) WdPoStFinishJob(ctx context.Context, jobID string, output *stage.WindowPoStOutput, errorReason string) (Meta, error) WdPoStResetJob(ctx context.Context, jobID string) (Meta, error) WdPoStRemoveJob(ctx context.Context, jobID string) (Meta, error) diff --git a/damocles-manager/core/ifaces.go b/damocles-manager/core/ifaces.go index c8171646a..c117bfd9e 100644 --- a/damocles-manager/core/ifaces.go +++ b/damocles-manager/core/ifaces.go @@ -19,7 +19,13 @@ type SectorManager interface { } type DealManager interface { - Acquire(ctx context.Context, sid abi.SectorID, spec AcquireDealsSpec, lifetime *AcquireDealsLifetime, job SectorWorkerJob) (SectorPieces, error) + Acquire( + ctx context.Context, + sid abi.SectorID, + spec AcquireDealsSpec, + lifetime *AcquireDealsLifetime, + job SectorWorkerJob, + ) (SectorPieces, error) Release(ctx context.Context, sid abi.SectorID, deals SectorPieces) error ReleaseLegacyDeal(ctx context.Context, sid abi.SectorID, acquired Deals) error } @@ -44,15 +50,21 @@ type CommitmentManager interface { } type SectorNumberAllocator interface { - NextN(ctx context.Context, mid abi.ActorID, n uint32, minNumber uint64, check func(uint64) bool) (uint64, bool, error) + NextN( + ctx context.Context, + mid abi.ActorID, + n uint32, + minNumber uint64, + check func(uint64) bool, + ) (uint64, bool, error) } type SectorStateManager interface { Import(ctx context.Context, ws SectorWorkerState, state *SectorState, override bool) (bool, error) Init(ctx context.Context, sectors []*AllocatedSector, ws SectorWorkerState) error - InitWith(ctx context.Context, sectors []*AllocatedSector, ws SectorWorkerState, fields ...interface{}) error + InitWith(ctx context.Context, sectors []*AllocatedSector, ws SectorWorkerState, fields ...any) error Load(ctx context.Context, sid abi.SectorID, ws SectorWorkerState) (*SectorState, error) - Update(ctx context.Context, sid abi.SectorID, ws SectorWorkerState, fieldvals ...interface{}) error + Update(ctx context.Context, sid abi.SectorID, ws SectorWorkerState, fieldvals ...any) error Finalize(context.Context, abi.SectorID, SectorStateChangeHook) error Restore(context.Context, abi.SectorID, SectorStateChangeHook) error All(ctx context.Context, ws SectorWorkerState, job SectorWorkerJob) ([]*SectorState, error) @@ -71,14 +83,42 @@ type SectorIndexer interface { } type SectorTracker interface { - SinglePubToPrivateInfo(ctx context.Context, mid abi.ActorID, sectorInfo builtin.ExtendedSectorInfo, locator SectorLocator) (PrivateSectorInfo, error) - SinglePrivateInfo(ctx context.Context, sref SectorRef, upgrade bool, locator SectorLocator) (PrivateSectorInfo, error) - PubToPrivate(ctx context.Context, mid abi.ActorID, postProofType abi.RegisteredPoStProof, sectorInfo []builtin.ExtendedSectorInfo) ([]FFIPrivateSectorInfo, error) + SinglePubToPrivateInfo( + ctx context.Context, + mid abi.ActorID, + sectorInfo builtin.ExtendedSectorInfo, + locator SectorLocator, + ) (PrivateSectorInfo, error) + SinglePrivateInfo( + ctx context.Context, + sref SectorRef, + upgrade bool, + locator SectorLocator, + ) (PrivateSectorInfo, error) + PubToPrivate( + ctx context.Context, + mid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectorInfo []builtin.ExtendedSectorInfo, + ) ([]FFIPrivateSectorInfo, error) } type SectorProving interface { - SingleProvable(ctx context.Context, postProofType abi.RegisteredPoStProof, sref SectorRef, upgrade bool, locator SectorLocator, strict, stateCheck bool) error - Provable(ctx context.Context, mid abi.ActorID, postProofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, strict, stateCheck bool) (map[abi.SectorNumber]string, error) + SingleProvable( + ctx context.Context, + postProofType abi.RegisteredPoStProof, + sref SectorRef, + upgrade bool, + locator SectorLocator, + strict, stateCheck bool, + ) error + Provable( + ctx context.Context, + mid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + strict, stateCheck bool, + ) (map[abi.SectorNumber]string, error) SectorTracker } diff --git a/damocles-manager/core/prover.go b/damocles-manager/core/prover.go index b915a4d86..c1f948367 100644 --- a/damocles-manager/core/prover.go +++ b/damocles-manager/core/prover.go @@ -43,9 +43,7 @@ type ( WinningPoStVerifyInfo = proof.WinningPoStVerifyInfo ) -var ( - NewSortedPrivateSectorInfo = ffi.NewSortedPrivateSectorInfo -) +var NewSortedPrivateSectorInfo = ffi.NewSortedPrivateSectorInfo type Verifier interface { VerifySeal(context.Context, SealVerifyInfo) (bool, error) @@ -64,13 +62,38 @@ type GenerateWindowPoStParams struct { } type Prover interface { - AggregateSealProofs(ctx context.Context, aggregateInfo AggregateSealVerifyProofAndInfos, proofs [][]byte) ([]byte, error) - GenerateWindowPoSt(ctx context.Context, params GenerateWindowPoStParams) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) - GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, ppt abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]builtin.PoStProof, error) + AggregateSealProofs( + ctx context.Context, + aggregateInfo AggregateSealVerifyProofAndInfos, + proofs [][]byte, + ) ([]byte, error) + GenerateWindowPoSt( + ctx context.Context, + params GenerateWindowPoStParams, + ) (postProof []builtin.PoStProof, skipped []abi.SectorID, err error) + GenerateWinningPoSt( + ctx context.Context, + minerID abi.ActorID, + ppt abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + randomness abi.PoStRandomness, + ) ([]builtin.PoStProof, error) - GeneratePoStFallbackSectorChallenges(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, sectorIds []abi.SectorNumber) (*FallbackChallenges, error) + GeneratePoStFallbackSectorChallenges( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + sectorIds []abi.SectorNumber, + ) (*FallbackChallenges, error) GenerateSingleVanillaProof(ctx context.Context, replica FFIPrivateSectorInfo, challenges []uint64) ([]byte, error) - GenerateWinningPoStWithVanilla(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte) ([]PoStProof, error) + GenerateWinningPoStWithVanilla( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + proofs [][]byte, + ) ([]PoStProof, error) } type ProveDataChecker interface { diff --git a/damocles-manager/core/types.go b/damocles-manager/core/types.go index 04650b0f1..f17041b79 100644 --- a/damocles-manager/core/types.go +++ b/damocles-manager/core/types.go @@ -81,7 +81,7 @@ func (ldi LegacyDealInfo) DealID() abi.DealID { return ldi.ID } -func (ldi LegacyDealInfo) AllocationID() verifregtypes.AllocationId { +func (LegacyDealInfo) AllocationID() verifregtypes.AllocationId { return verifregtypes.NoAllocationID } @@ -203,8 +203,10 @@ func (sp SectorPieceV2) EndEpoch() abi.ChainEpoch { return abi.ChainEpoch(0) } -type Deals []LegacyDealInfo -type SectorPieces []SectorPieceV2 +type ( + Deals []LegacyDealInfo + SectorPieces []SectorPieceV2 +) type AcquireDealsSpec struct { MaxDeals *uint diff --git a/damocles-manager/core/types_sector_state.go b/damocles-manager/core/types_sector_state.go index 6c66343e0..cc882fc02 100644 --- a/damocles-manager/core/types_sector_state.go +++ b/damocles-manager/core/types_sector_state.go @@ -14,15 +14,17 @@ type SectorStateChangeHook func(st *SectorState) (bool, error) // returns the persist instance name, existence type SectorLocator func(ctx context.Context, sid abi.SectorID) (SectorAccessStores, bool, error) -type SectorFinalized bool -type SectorUpgraded bool -type SectorRemoved bool -type SectorImported bool -type SectorUpgradeLandedEpoch abi.ChainEpoch -type SectorUpgradeMessageID string -type SectorUpgradePublic SectorPublicInfo -type SectorNeedRebuild bool -type SectorUnsealing bool +type ( + SectorFinalized bool + SectorUpgraded bool + SectorRemoved bool + SectorImported bool + SectorUpgradeLandedEpoch abi.ChainEpoch + SectorUpgradeMessageID string + SectorUpgradePublic SectorPublicInfo + SectorNeedRebuild bool + SectorUnsealing bool +) type SectorUpgradedInfo struct { AccessInstance string diff --git a/damocles-manager/core/types_wdpost.go b/damocles-manager/core/types_wdpost.go index 4ae8c6d0d..c8563703d 100644 --- a/damocles-manager/core/types_wdpost.go +++ b/damocles-manager/core/types_wdpost.go @@ -128,7 +128,12 @@ type WorkerWdPoStJobManager interface { All(ctx context.Context, filter func(*WdPoStJob) bool) ([]*WdPoStJob, error) ListByJobIDs(ctx context.Context, jobIDs ...string) ([]*WdPoStJob, error) Create(ctx context.Context, deadlineIdx uint64, partitions []uint64, input WdPoStInput) (*WdPoStJob, error) - AllocateJobs(ctx context.Context, spec AllocateWdPoStJobSpec, num uint32, workerName string) (allocatedJobs []*WdPoStAllocatedJob, err error) + AllocateJobs( + ctx context.Context, + spec AllocateWdPoStJobSpec, + num uint32, + workerName string, + ) (allocatedJobs []*WdPoStAllocatedJob, err error) Heartbeat(ctx context.Context, jobIDs []string, workerName string) error Finish(ctx context.Context, jobID string, output *stage.WindowPoStOutput, errorReason string) error MakeJobsDie(ctx context.Context, shouldDeadDur time.Duration, limit uint32) error diff --git a/damocles-manager/dep/gateway.go b/damocles-manager/dep/gateway.go index dce10d2a7..2d67b5454 100644 --- a/damocles-manager/dep/gateway.go +++ b/damocles-manager/dep/gateway.go @@ -13,14 +13,16 @@ import ( mkapi "github.com/filecoin-project/venus/venus-shared/api/market/v1" "github.com/ipfs-force-community/damocles/damocles-manager/core" "github.com/ipfs-force-community/damocles/damocles-manager/modules" - market "github.com/ipfs-force-community/damocles/damocles-manager/modules/market" + "github.com/ipfs-force-community/damocles/damocles-manager/modules/market" "github.com/ipfs-force-community/damocles/damocles-manager/modules/miner" assets "github.com/ipfs-force-community/venus-cluster-assets" ) -type GatewayClients []gateway.IGateway -type MarketEventClients []gateway.IMarketServiceProvider -type WinningPoStWarmUp bool +type ( + GatewayClients []gateway.IGateway + MarketEventClients []gateway.IMarketServiceProvider + WinningPoStWarmUp bool +) func Gateway() dix.Option { return dix.Options( @@ -41,7 +43,7 @@ func NewGatewayClients(_ GlobalContext, lc fx.Lifecycle, cfg *modules.SafeConfig urls, commonToken := cfg.Common.API.Gateway, cfg.Common.API.Token cfg.Unlock() - var ret GatewayClients + ret := GatewayClients{} for _, u := range urls { addr, token := extractAPIInfo(u, commonToken) @@ -64,7 +66,12 @@ func NewGatewayClients(_ GlobalContext, lc fx.Lifecycle, cfg *modules.SafeConfig return ret, nil } -func NewMarketEventClients(_ GlobalContext, lc fx.Lifecycle, cfg *modules.SafeConfig, gatewayClients GatewayClients) (MarketEventClients, error) { +func NewMarketEventClients( + _ GlobalContext, + lc fx.Lifecycle, + cfg *modules.SafeConfig, + gatewayClients GatewayClients, +) (MarketEventClients, error) { cfg.Lock() var addr, token string if cfg.Common.API.Market != nil { @@ -73,7 +80,7 @@ func NewMarketEventClients(_ GlobalContext, lc fx.Lifecycle, cfg *modules.SafeCo // should vsm call droplet for market event when use unit entry from gateway cfg.Unlock() - var ret MarketEventClients + ret := MarketEventClients{} if addr != "" { cli, closer, err := mkapi.DialIMarketRPC(context.Background(), addr, token, nil, jsonrpc.WithRetry(true)) @@ -96,7 +103,14 @@ func NewMarketEventClients(_ GlobalContext, lc fx.Lifecycle, cfg *modules.SafeCo return ret, nil } -func StartProofEvent(gctx GlobalContext, prover core.Prover, cfg *modules.SafeConfig, tracker core.SectorTracker, warmup WinningPoStWarmUp, gClients GatewayClients) error { +func StartProofEvent( + gctx GlobalContext, + prover core.Prover, + cfg *modules.SafeConfig, + tracker core.SectorTracker, + warmup WinningPoStWarmUp, + gClients GatewayClients, +) error { if warmup { log.Info("warm up for winning post") _, err := prover.GenerateWinningPoStWithVanilla( @@ -109,7 +123,6 @@ func StartProofEvent(gctx GlobalContext, prover core.Prover, cfg *modules.SafeCo if err != nil { return fmt.Errorf("warmup proof: %w", err) } - } cfg.Lock() @@ -148,8 +161,12 @@ func StartProofEvent(gctx GlobalContext, prover core.Prover, cfg *modules.SafeCo return nil } -func StartMarketEvent(gctx GlobalContext, cfg *modules.SafeConfig, unseal core.UnsealSectorManager, mClients MarketEventClients) error { - +func StartMarketEvent( + gctx GlobalContext, + cfg *modules.SafeConfig, + unseal core.UnsealSectorManager, + mClients MarketEventClients, +) error { cfg.Lock() miners := cfg.Miners cfg.Unlock() diff --git a/damocles-manager/dep/poster.go b/damocles-manager/dep/poster.go index 452a81a6a..583a6b870 100644 --- a/damocles-manager/dep/poster.go +++ b/damocles-manager/dep/poster.go @@ -19,6 +19,7 @@ func PoSter() dix.Option { ) } +//revive:disable-next-line:argument-limit func RunPoSter( gctx GlobalContext, lc fx.Lifecycle, diff --git a/damocles-manager/dep/prover.go b/damocles-manager/dep/prover.go index 7934e2ce8..c0b0f3378 100644 --- a/damocles-manager/dep/prover.go +++ b/damocles-manager/dep/prover.go @@ -39,7 +39,12 @@ func WorkerProver() dix.Option { ) } -func BuildExtProver(gctx GlobalContext, lc fx.Lifecycle, sectorTracker core.SectorTracker, cfg *modules.ProcessorConfig) (*ext.Prover, error) { +func BuildExtProver( + gctx GlobalContext, + lc fx.Lifecycle, + sectorTracker core.SectorTracker, + cfg *modules.ProcessorConfig, +) (*ext.Prover, error) { p, err := ext.New(gctx, sectorTracker, cfg.WdPost, cfg.WinPost) if err != nil { return nil, fmt.Errorf("construct ext prover: %w", err) @@ -60,7 +65,12 @@ func BuildExtProver(gctx GlobalContext, lc fx.Lifecycle, sectorTracker core.Sect return p, nil } -func ProvideExtProverConfig(gctx GlobalContext, lc fx.Lifecycle, cfgmgr confmgr.ConfigManager, locker confmgr.WLocker) (*modules.ProcessorConfig, error) { +func ProvideExtProverConfig( + gctx GlobalContext, + lc fx.Lifecycle, + cfgmgr confmgr.ConfigManager, + locker confmgr.WLocker, +) (*modules.ProcessorConfig, error) { cfg := modules.DefaultProcessorConfig(false) if err := cfgmgr.Load(gctx, modules.ProcessorConfigKey, &cfg); err != nil { return nil, err @@ -78,7 +88,7 @@ func ProvideExtProverConfig(gctx GlobalContext, lc fx.Lifecycle, cfgmgr confmgr. lc.Append(fx.Hook{ OnStart: func(context.Context) error { - return cfgmgr.Watch(gctx, modules.ProcessorConfigKey, &cfg, locker, func() interface{} { + return cfgmgr.Watch(gctx, modules.ProcessorConfigKey, &cfg, locker, func() any { c := modules.DefaultProcessorConfig(false) return &c }) @@ -92,7 +102,12 @@ func BuildWorkerProverStore(gctx GlobalContext, db UnderlyingDB) (WorkerProverSt return db.OpenCollection(gctx, "prover") } -func BuildWorkerProver(lc fx.Lifecycle, jobMgr core.WorkerWdPoStJobManager, sectorTracker core.SectorTracker, scfg *modules.SafeConfig) (core.Prover, error) { +func BuildWorkerProver( + lc fx.Lifecycle, + jobMgr core.WorkerWdPoStJobManager, + sectorTracker core.SectorTracker, + scfg *modules.SafeConfig, +) (core.Prover, error) { cfg := scfg.MustCommonConfig() p := proverworker.NewProver(jobMgr, sectorTracker, &proverworker.Config{ RetryFailedJobsInterval: 10 * time.Second, diff --git a/damocles-manager/dep/sealer.go b/damocles-manager/dep/sealer.go index d3525880c..56219eb44 100644 --- a/damocles-manager/dep/sealer.go +++ b/damocles-manager/dep/sealer.go @@ -17,7 +17,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/confmgr" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/market" - messager "github.com/ipfs-force-community/damocles/damocles-manager/pkg/messager" + "github.com/ipfs-force-community/damocles/damocles-manager/pkg/messager" "github.com/ipfs-force-community/damocles/damocles-manager/ver" ) @@ -33,7 +33,7 @@ func Mock() dix.Option { ) } -func MockSealer(s ...interface{}) dix.Option { +func MockSealer(s ...any) dix.Option { return dix.Options( dix.Override(new(*mock.Sealer), mock.NewSealer), dix.Override(new(core.SealerAPI), dix.From(new(*mock.Sealer))), @@ -119,7 +119,7 @@ func Proxy(dest string, opt ProxyOptions) dix.Option { ) } -func Sealer(target ...interface{}) dix.Option { +func Sealer(target ...any) dix.Option { return dix.Options( dix.Override(new(*sealer.Sealer), sealer.New), dix.Override(new(core.SealerAPI), dix.From(new(*sealer.Sealer))), @@ -128,7 +128,7 @@ func Sealer(target ...interface{}) dix.Option { ) } -func APIClient(target ...interface{}) dix.Option { +func APIClient(target ...any) dix.Option { cfgmu := &sync.RWMutex{} return dix.Options( dix.Override(new(confmgr.WLocker), cfgmu), diff --git a/damocles-manager/dep/sealer_constructor.go b/damocles-manager/dep/sealer_constructor.go index 611eb7a1a..03dfc9f6e 100644 --- a/damocles-manager/dep/sealer_constructor.go +++ b/damocles-manager/dep/sealer_constructor.go @@ -24,7 +24,6 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/modules/impl/worker" "github.com/ipfs-force-community/damocles/damocles-manager/modules/policy" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/confmgr" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/homedir" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/kvstore" @@ -50,7 +49,11 @@ type ( CommonMetaStore kvstore.KVStore ) -func BuildLocalSectorManager(scfg *modules.SafeConfig, mapi core.MinerAPI, numAlloc core.SectorNumberAllocator) (core.SectorManager, error) { +func BuildLocalSectorManager( + scfg *modules.SafeConfig, + mapi core.MinerAPI, + numAlloc core.SectorNumberAllocator, +) (core.SectorManager, error) { return sectors.NewManager(scfg, mapi, numAlloc) } @@ -76,7 +79,12 @@ func BuildLocalConfigManager(gctx GlobalContext, lc fx.Lifecycle, confDir ConfDi return cfgmgr, nil } -func ProvideConfig(gctx GlobalContext, lc fx.Lifecycle, cfgmgr confmgr.ConfigManager, locker confmgr.WLocker) (*modules.Config, error) { +func ProvideConfig( + gctx GlobalContext, + lc fx.Lifecycle, + cfgmgr confmgr.ConfigManager, + locker confmgr.WLocker, +) (*modules.Config, error) { cfg := modules.DefaultConfig(false) if err := cfgmgr.Load(gctx, modules.ConfigKey, &cfg); err != nil { return nil, err @@ -94,7 +102,7 @@ func ProvideConfig(gctx GlobalContext, lc fx.Lifecycle, cfgmgr confmgr.ConfigMan lc.Append(fx.Hook{ OnStart: func(context.Context) error { - return cfgmgr.Watch(gctx, modules.ConfigKey, &cfg, locker, func() interface{} { + return cfgmgr.Watch(gctx, modules.ConfigKey, &cfg, locker, func() any { c := modules.DefaultConfig(false) return &c }) @@ -111,7 +119,11 @@ func ProvideSafeConfig(cfg *modules.Config, locker confmgr.RLocker) (*modules.Sa }, nil } -func ProvidePlugins(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeConfig) (*managerplugin.LoadedPlugins, error) { +func ProvidePlugins( + gctx GlobalContext, + lc fx.Lifecycle, + scfg *modules.SafeConfig, +) (*managerplugin.LoadedPlugins, error) { pluginsConfig := scfg.MustCommonConfig().Plugins if pluginsConfig == nil { pluginsConfig = modules.DefaultPluginConfig() @@ -142,7 +154,13 @@ func ProvidePlugins(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeConfi return plugins, nil } -func BuildUnderlyingDB(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeConfig, home *homedir.Home, loadedPlugins *managerplugin.LoadedPlugins) (UnderlyingDB, error) { +func BuildUnderlyingDB( + gctx GlobalContext, + lc fx.Lifecycle, + scfg *modules.SafeConfig, + home *homedir.Home, + loadedPlugins *managerplugin.LoadedPlugins, +) (UnderlyingDB, error) { commonCfg := scfg.MustCommonConfig() var dbCfg modules.DBConfig @@ -158,7 +176,13 @@ func BuildUnderlyingDB(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeCo return BuildKVStoreDB(gctx, lc, dbCfg, home, loadedPlugins) } -func BuildKVStoreDB(gctx GlobalContext, lc fx.Lifecycle, cfg modules.DBConfig, home *homedir.Home, loadedPlugins *managerplugin.LoadedPlugins) (UnderlyingDB, error) { +func BuildKVStoreDB( + gctx GlobalContext, + lc fx.Lifecycle, + cfg modules.DBConfig, + home *homedir.Home, + loadedPlugins *managerplugin.LoadedPlugins, +) (UnderlyingDB, error) { switch cfg.Driver { case "badger", "Badger": return BuildKVStoreBadgerDB(lc, cfg.Badger, home) @@ -171,7 +195,11 @@ func BuildKVStoreDB(gctx GlobalContext, lc fx.Lifecycle, cfg modules.DBConfig, h } } -func BuildKVStoreBadgerDB(lc fx.Lifecycle, badgerCfg *modules.KVStoreBadgerDBConfig, home *homedir.Home) (UnderlyingDB, error) { +func BuildKVStoreBadgerDB( + lc fx.Lifecycle, + badgerCfg *modules.KVStoreBadgerDBConfig, + home *homedir.Home, +) (UnderlyingDB, error) { if badgerCfg == nil { *badgerCfg = *modules.DefaultDBConfig().Badger } @@ -195,7 +223,11 @@ func BuildKVStoreBadgerDB(lc fx.Lifecycle, badgerCfg *modules.KVStoreBadgerDBCon return db, nil } -func BuildKVStoreMongoDB(gctx GlobalContext, lc fx.Lifecycle, mongoCfg *modules.KVStoreMongoDBConfig) (UnderlyingDB, error) { +func BuildKVStoreMongoDB( + gctx GlobalContext, + lc fx.Lifecycle, + mongoCfg *modules.KVStoreMongoDBConfig, +) (UnderlyingDB, error) { if mongoCfg == nil { return nil, fmt.Errorf("invalid mongodb config") } @@ -218,7 +250,11 @@ func BuildKVStoreMongoDB(gctx GlobalContext, lc fx.Lifecycle, mongoCfg *modules. return db, err } -func BuildPluginDB(lc fx.Lifecycle, pluginDBCfg *modules.KVStorePluginDBConfig, loadedPlugins *managerplugin.LoadedPlugins) (UnderlyingDB, error) { +func BuildPluginDB( + lc fx.Lifecycle, + pluginDBCfg *modules.KVStorePluginDBConfig, + loadedPlugins *managerplugin.LoadedPlugins, +) (UnderlyingDB, error) { if pluginDBCfg == nil { return nil, fmt.Errorf("invalid plugin db config") } @@ -260,7 +296,11 @@ func BuildSectorNumberAllocator(meta OnlineMetaStore) (core.SectorNumberAllocato return sectors.NewNumberAllocator(store) } -func BuildLocalSectorStateManager(online OnlineMetaStore, offline OfflineMetaStore, loadedPlugins *managerplugin.LoadedPlugins) (core.SectorStateManager, error) { +func BuildLocalSectorStateManager( + online OnlineMetaStore, + offline OfflineMetaStore, + loadedPlugins *managerplugin.LoadedPlugins, +) (core.SectorStateManager, error) { onlineStore, err := kvstore.NewWrappedKVStore([]byte("sector-states"), online) if err != nil { return nil, err @@ -274,7 +314,12 @@ func BuildLocalSectorStateManager(online OnlineMetaStore, offline OfflineMetaSto return sectors.NewStateManager(onlineStore, offlineStore, loadedPlugins) } -func BuildMessagerClient(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.Config, locker confmgr.RLocker) (messager.API, error) { +func BuildMessagerClient( + gctx GlobalContext, + lc fx.Lifecycle, + scfg *modules.Config, + locker confmgr.RLocker, +) (messager.API, error) { locker.Lock() var api, token string if scfg.Common.API.Messager != nil { @@ -317,7 +362,14 @@ func BuildAPIProxyClient(gctx GlobalContext, lc fx.Lifecycle, proxy ProxyAddress return &proxyClient, err } -func buildDamoclesAPIClient(gctx GlobalContext, lc fx.Lifecycle, namespace string, out interface{}, serverAddr string, useHTTP bool) error { +func buildDamoclesAPIClient( + gctx GlobalContext, + lc fx.Lifecycle, + namespace string, + out any, + serverAddr string, + useHTTP bool, +) error { addr, err := net.ResolveTCPAddr("tcp", serverAddr) if err != nil { return err @@ -339,7 +391,14 @@ func buildDamoclesAPIClient(gctx GlobalContext, lc fx.Lifecycle, namespace strin return err } - closer, err := jsonrpc.NewMergeClient(gctx, apiAddr, namespace, []interface{}{out}, ainfo.AuthHeader(), jsonrpc.WithRetry(true)) + closer, err := jsonrpc.NewMergeClient( + gctx, + apiAddr, + namespace, + []any{out}, + ainfo.AuthHeader(), + jsonrpc.WithRetry(true), + ) if err != nil { return err } @@ -354,7 +413,12 @@ func buildDamoclesAPIClient(gctx GlobalContext, lc fx.Lifecycle, namespace strin return nil } -func BuildChainClient(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.Config, locker confmgr.RLocker) (chain.API, error) { +func BuildChainClient( + gctx GlobalContext, + lc fx.Lifecycle, + scfg *modules.Config, + locker confmgr.RLocker, +) (chain.API, error) { locker.Lock() var api, token string if scfg.Common.API.Chain != nil { @@ -396,6 +460,7 @@ func BuildMinerAPI(_ GlobalContext, lc fx.Lifecycle, capi chain.API, scfg *modul return mapi, nil } +//revive:disable-next-line:argument-limit func BuildCommitmentManager( gctx GlobalContext, lc fx.Lifecycle, @@ -404,7 +469,7 @@ func BuildCommitmentManager( rapi core.RandomnessAPI, stmgr core.SectorStateManager, minerAPI core.MinerAPI, - chain chainAPI.API, + chainAPI chain.API, lookupID core.LookupID, scfg *modules.SafeConfig, verif core.Verifier, @@ -421,10 +486,9 @@ func BuildCommitmentManager( verif, prover, senderSelecotr, - chain, + chainAPI, lookupID, ) - if err != nil { return nil, err } @@ -452,7 +516,11 @@ func BuildSnapUpMetaStore(gctx GlobalContext, db UnderlyingDB) (SnapUpMetaStore, return db.OpenCollection(gctx, "snapup") } -func openObjStore(cfg objstore.Config, pluginName string, loadedPlugins *managerplugin.LoadedPlugins) (st objstore.Store, err error) { +func openObjStore( + cfg objstore.Config, + pluginName string, + loadedPlugins *managerplugin.LoadedPlugins, +) (st objstore.Store, err error) { if cfg.Name == "" { cfg.Name = cfg.Path } @@ -468,19 +536,31 @@ func openObjStore(cfg objstore.Config, pluginName string, loadedPlugins *manager if err != nil { return } - log.Infow("store constructed", "type", st.Type(), "ver", st.Version(), "instance", st.Instance(context.Background())) + log.Infow( + "store constructed", + "type", + st.Type(), + "ver", + st.Version(), + "instance", + st.Instance(context.Background()), + ) return } -func BuildPersistedFileStoreMgr(scfg *modules.SafeConfig, globalStore CommonMetaStore, loadedPlugins *managerplugin.LoadedPlugins) (PersistedObjectStoreManager, error) { +func BuildPersistedFileStoreMgr( + scfg *modules.SafeConfig, + globalStore CommonMetaStore, + loadedPlugins *managerplugin.LoadedPlugins, +) (PersistedObjectStoreManager, error) { persistCfg, err := scfg.MustCommonConfig().GetPersistStores() if err != nil { return nil, fmt.Errorf("get persist store config: %w", err) } stores := make([]objstore.Store, 0, len(persistCfg)) - policy := map[string]objstore.StoreSelectPolicy{} + storePolicy := map[string]objstore.StoreSelectPolicy{} for pi := range persistCfg { // For compatibility with v0.5 if persistCfg[pi].PluginName == "" && persistCfg[pi].Plugin != "" { @@ -492,7 +572,7 @@ func BuildPersistedFileStoreMgr(scfg *modules.SafeConfig, globalStore CommonMeta } stores = append(stores, st) - policy[st.Instance(context.Background())] = persistCfg[pi].StoreSelectPolicy + storePolicy[st.Instance(context.Background())] = persistCfg[pi].StoreSelectPolicy } wrapped, err := kvstore.NewWrappedKVStore([]byte("objstore"), globalStore) @@ -500,7 +580,7 @@ func BuildPersistedFileStoreMgr(scfg *modules.SafeConfig, globalStore CommonMeta return nil, fmt.Errorf("construct wrapped kv store for objstore: %w", err) } - return objstore.NewStoreManager(stores, policy, wrapped) + return objstore.NewStoreManager(stores, storePolicy, wrapped) } func BuildSectorIndexer(storeMgr PersistedObjectStoreManager, kv SectorIndexMetaStore) (core.SectorIndexer, error) { @@ -512,7 +592,14 @@ func BuildSectorIndexer(storeMgr PersistedObjectStoreManager, kv SectorIndexMeta return sectors.NewIndexer(storeMgr, kv, upgrade) } -func BuildSectorProving(tracker core.SectorTracker, state core.SectorStateManager, storeMgr PersistedObjectStoreManager, prover core.Prover, capi chain.API, scfg *modules.SafeConfig) (core.SectorProving, error) { +func BuildSectorProving( + tracker core.SectorTracker, + state core.SectorStateManager, + storeMgr PersistedObjectStoreManager, + prover core.Prover, + capi chain.API, + scfg *modules.SafeConfig, +) (core.SectorProving, error) { return sectors.NewProving(tracker, state, storeMgr, prover, capi, scfg.MustCommonConfig().Proving) } @@ -561,7 +648,13 @@ func BuildMarketAPI(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeConfi return mapi, nil } -func BuildMarketAPIRelated(gctx GlobalContext, lc fx.Lifecycle, scfg *modules.SafeConfig, minerAPI core.MinerAPI, loadedPlugins *managerplugin.LoadedPlugins) (MarketAPIRelatedComponents, error) { +func BuildMarketAPIRelated( + gctx GlobalContext, + lc fx.Lifecycle, + scfg *modules.SafeConfig, + minerAPI core.MinerAPI, + loadedPlugins *managerplugin.LoadedPlugins, +) (MarketAPIRelatedComponents, error) { mapi, err := BuildMarketAPI(gctx, lc, scfg) if err != nil { return MarketAPIRelatedComponents{}, fmt.Errorf("build market api: %w", err) @@ -649,6 +742,7 @@ func BuildSenderSelector(chainAPI chain.API, lookupID core.LookupID) *dmaddress. return dmaddress.NewSenderSelector(chainAPI, lookupID) } +//revive:disable-next-line:argument-limit func BuildSnapUpManager( gctx GlobalContext, lc fx.Lifecycle, @@ -664,7 +758,20 @@ func BuildSnapUpManager( lookupID core.LookupID, senderSelector core.SenderSelector, ) (core.SnapUpSectorManager, error) { - mgr, err := sectors.NewSnapUpMgr(gctx, tracker, indexer, chainAPI, eventbus, messagerAPI, minerAPI, stateMgr, scfg, store, lookupID, senderSelector) + mgr, err := sectors.NewSnapUpMgr( + gctx, + tracker, + indexer, + chainAPI, + eventbus, + messagerAPI, + minerAPI, + stateMgr, + scfg, + store, + lookupID, + senderSelector, + ) if err != nil { return nil, fmt.Errorf("construct snapup manager: %w", err) } @@ -709,7 +816,10 @@ func BuildWorkerManager(gctx GlobalContext, meta WorkerMetaStore) (core.WorkerMa return worker.NewManager(gctx, meta) } -func BuildProxiedSectorIndex(client *core.SealerCliAPIClient, storeMgr PersistedObjectStoreManager) (core.SectorIndexer, error) { +func BuildProxiedSectorIndex( + client *core.SealerCliAPIClient, + storeMgr PersistedObjectStoreManager, +) (core.SectorIndexer, error) { log.Debug("build proxied sector indexer") return sectors.NewProxiedIndexer(client, storeMgr) } @@ -718,7 +828,7 @@ func BuildUnsealManager( gctx GlobalContext, db UnderlyingDB, scfg *modules.SafeConfig, - MinerAPI core.MinerAPI, + minerAPI core.MinerAPI, ) (core.UnsealSectorManager, error) { store, err := db.OpenCollection(gctx, "unseal") if err != nil { @@ -734,7 +844,7 @@ func BuildUnsealManager( } scfg.Unlock() - mgr, err := sectors.NewUnsealManager(gctx, scfg, MinerAPI, store, addr, token) + mgr, err := sectors.NewUnsealManager(gctx, scfg, minerAPI, store, addr, token) if err != nil { return nil, fmt.Errorf("construct unseal manager: %w", err) } diff --git a/damocles-manager/dep/util.go b/damocles-manager/dep/util.go index d4d10b787..6704cc6b0 100644 --- a/damocles-manager/dep/util.go +++ b/damocles-manager/dep/util.go @@ -5,11 +5,10 @@ import ( "strings" ) -var ( - infoWithToken = regexp.MustCompile("^[a-zA-Z0-9\\-_]+?\\.[a-zA-Z0-9\\-_]+?\\.([a-zA-Z0-9\\-_]+)?:.+$") -) +// token:addr +var infoWithToken = regexp.MustCompile(`^[a-zA-Z0-9\-_]+?\.[a-zA-Z0-9\-_]+?\.([a-zA-Z0-9\-_]+)?:.+$`) -func extractAPIInfo(raw string, commonToken string) (string, string) { +func extractAPIInfo(raw string, commonToken string) (addr string, token string) { if !infoWithToken.Match([]byte(raw)) { return raw, commonToken } diff --git a/damocles-manager/metrics/metrics.go b/damocles-manager/metrics/metrics.go index dc754d7f2..3115b31c1 100644 --- a/damocles-manager/metrics/metrics.go +++ b/damocles-manager/metrics/metrics.go @@ -10,9 +10,55 @@ import ( "go.opencensus.io/tag" ) -var defaultMillisecondsDistribution = view.Distribution(0.01, 0.05, 0.1, 0.3, 0.6, 0.8, 1, 2, 3, 4, 5, 6, 8, 10, 13, 16, 20, 25, 30, 40, 50, 65, 80, 100, 130, 160, 200, 250, 300, 400, 500, 650, 800, 1000, 2000, 3000, 4000, 5000, 7500, 10000, 20000, 50000, 100000) -var winningPostSecondsDistribution = view.Distribution(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 100) -var windowPostMinutesDistribution = view.Distribution(1, 5, 10, 15, 20, 25, 30) +var ( + defaultMillisecondsDistribution = view.Distribution( + 0.01, + 0.05, + 0.1, + 0.3, + 0.6, + 0.8, + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 10, + 13, + 16, + 20, + 25, + 30, + 40, + 50, + 65, + 80, + 100, + 130, + 160, + 200, + 250, + 300, + 400, + 500, + 650, + 800, + 1000, + 2000, + 3000, + 4000, + 5000, + 7500, + 10000, + 20000, + 50000, + 100000, + ) + winningPostSecondsDistribution = view.Distribution(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 100) + windowPostMinutesDistribution = view.Distribution(1, 5, 10, 15, 20, 25, 30) +) var ( Endpoint, _ = tag.NewKey("endpoint") @@ -27,9 +73,13 @@ var ( var ( APIState = metrics.NewInt64("api/state", "api service state. 0: down, 1: up", "") ThreadCount = metrics.NewInt64WithCategory("thread/count", "thread count in vary state", "") - WorkerLatencyCount = metrics.NewInt64WithCategory("worker/count", "worker count in latency range ('<=60s','<=120s','<=300s','>300s')", "") - WdPostJobCount = metrics.NewCounterWithCategory("wdpost/job/count", "wdpost job count in vary state") - WdPostJobElapsed = metrics.NewInt64("wdpost/job/elapsed", "wdpost job elapsed time", "s") + WorkerLatencyCount = metrics.NewInt64WithCategory( + "worker/count", + "worker count in latency range ('<=60s','<=120s','<=300s','>300s')", + "", + ) + WdPostJobCount = metrics.NewCounterWithCategory("wdpost/job/count", "wdpost job count in vary state") + WdPostJobElapsed = metrics.NewInt64("wdpost/job/elapsed", "wdpost job elapsed time", "s") ) var ( @@ -38,15 +88,35 @@ var ( SectorManagerNewSector = stats.Int64("sector_manager/new_sector", "Count the new sector", stats.UnitDimensionless) - SectorManagerPreCommitSector = stats.Int64("sector_manager/pre_commit_sector", "Count the pre commit sector", stats.UnitDimensionless) - - SectorManagerCommitSector = stats.Int64("sector_manager/commit_sector", "Count the commit sector", stats.UnitDimensionless) - - ProverWinningPostDuration = stats.Float64("prover/winning_post_duration", "Duration of winning post ", stats.UnitDimensionless) - - ProverWindowPostDuration = stats.Float64("prover/window_post_duration", "Duration of window post", stats.UnitDimensionless) - - ProverWindowPostCompleteRate = stats.Float64("prover/window_post_complete_rate", "Complete rate of window post", stats.UnitDimensionless) + SectorManagerPreCommitSector = stats.Int64( + "sector_manager/pre_commit_sector", + "Count the pre commit sector", + stats.UnitDimensionless, + ) + + SectorManagerCommitSector = stats.Int64( + "sector_manager/commit_sector", + "Count the commit sector", + stats.UnitDimensionless, + ) + + ProverWinningPostDuration = stats.Float64( + "prover/winning_post_duration", + "Duration of winning post ", + stats.UnitDimensionless, + ) + + ProverWindowPostDuration = stats.Float64( + "prover/window_post_duration", + "Duration of window post", + stats.UnitDimensionless, + ) + + ProverWindowPostCompleteRate = stats.Float64( + "prover/window_post_complete_rate", + "Complete rate of window post", + stats.UnitDimensionless, + ) APIRequestDuration = stats.Float64("api/request_duration_ms", "Duration of API requests", stats.UnitMilliseconds) ) diff --git a/damocles-manager/metrics/proxy/proxy.go b/damocles-manager/metrics/proxy/proxy.go index 75ca19a65..03afe4d1f 100644 --- a/damocles-manager/metrics/proxy/proxy.go +++ b/damocles-manager/metrics/proxy/proxy.go @@ -8,17 +8,20 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/metrics" ) -func MetricedAPI(namespace string, hdl interface{}) interface{} { +func MetricedAPI(namespace string, hdl any) any { return proxy(namespace, hdl) } -func proxy(namespace string, in interface{}) interface{} { +func proxy(namespace string, in any) any { fields := []reflect.StructField{} valueIn := reflect.ValueOf(in) for i := 0; i < valueIn.NumMethod(); i++ { - fields = append(fields, reflect.StructField{Name: valueIn.Type().Method(i).Name, Type: valueIn.Method(i).Type()}) + fields = append( + fields, + reflect.StructField{Name: valueIn.Type().Method(i).Name, Type: valueIn.Method(i).Type()}, + ) } internal := reflect.StructOf(fields) @@ -26,16 +29,17 @@ func proxy(namespace string, in interface{}) interface{} { for i := 0; i < valueIn.NumMethod(); i++ { fn := valueIn.Method(i) funcName := valueIn.Type().Method(i).Name - internalValue.Field(i).Set(reflect.MakeFunc(valueIn.Method(i).Type(), func(args []reflect.Value) (results []reflect.Value) { - ctx := args[0].Interface().(context.Context) - // upsert function name into context - ctx, _ = metrics.New(ctx, metrics.Upsert(metrics.Endpoint, fmt.Sprintf("%s.%s", namespace, funcName))) - stop := metrics.Timer(ctx, metrics.APIRequestDuration, metrics.SinceInMilliseconds) - defer stop() - // pass tagged ctx back into function call - args[0] = reflect.ValueOf(ctx) - return fn.Call(args) - })) + internalValue.Field(i). + Set(reflect.MakeFunc(valueIn.Method(i).Type(), func(args []reflect.Value) (results []reflect.Value) { + ctx := args[0].Interface().(context.Context) //revive:disable-line:unchecked-type-assertion + // upsert function name into context + ctx, _ = metrics.New(ctx, metrics.Upsert(metrics.Endpoint, fmt.Sprintf("%s.%s", namespace, funcName))) + stop := metrics.Timer(ctx, metrics.APIRequestDuration, metrics.SinceInMilliseconds) + defer stop() + // pass tagged ctx back into function call + args[0] = reflect.ValueOf(ctx) + return fn.Call(args) + })) } outStruct := reflect.StructOf([]reflect.StructField{{ diff --git a/damocles-manager/modules/address/lookup_id.go b/damocles-manager/modules/address/lookup_id.go index a7c529420..443027a28 100644 --- a/damocles-manager/modules/address/lookup_id.go +++ b/damocles-manager/modules/address/lookup_id.go @@ -14,14 +14,22 @@ import ( var log = logging.New("address") type ChainAPI interface { - StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) + StateLookupID( + ctx context.Context, + addr address.Address, + tsk types.TipSetKey, + ) (address.Address, error) } -func NewCacheableLookupID(api ChainAPI) *CacheableLookupID { +func NewCacheableLookupID( + api ChainAPI, +) *CacheableLookupID { return &CacheableLookupID{ - chain: api, - toF0mapping: make(map[address.Address]address.Address), - mu: &sync.RWMutex{}, + chain: api, + toF0mapping: make( + map[address.Address]address.Address, + ), + mu: &sync.RWMutex{}, } } @@ -32,7 +40,10 @@ type CacheableLookupID struct { mu *sync.RWMutex } -func (l *CacheableLookupID) StateLookupID(ctx context.Context, nonF0 address.Address) (address.Address, error) { +func (l *CacheableLookupID) StateLookupID( + ctx context.Context, + nonF0 address.Address, +) (address.Address, error) { l.mu.RLock() f0, has := l.toF0mapping[nonF0] l.mu.RUnlock() @@ -41,13 +52,24 @@ func (l *CacheableLookupID) StateLookupID(ctx context.Context, nonF0 address.Add } key := nonF0.String() - idAddr, err, _ := l.group.Do(key, func() (interface{}, error) { - idAddr, err := l.chain.StateLookupID(ctx, nonF0, types.EmptyTSK) - if err != nil { - return address.Undef, fmt.Errorf("convert non-f0 address to f0 address %s: %w", nonF0, err) - } - return idAddr, err - }) + idAddr, err, _ := l.group.Do( + key, + func() (any, error) { + idAddr, err := l.chain.StateLookupID( + ctx, + nonF0, + types.EmptyTSK, + ) + if err != nil { + return address.Undef, fmt.Errorf( + "convert non-f0 address to f0 address %s: %w", + nonF0, + err, + ) + } + return idAddr, err + }, + ) if err != nil { return address.Undef, err @@ -55,6 +77,6 @@ func (l *CacheableLookupID) StateLookupID(ctx context.Context, nonF0 address.Add l.mu.Lock() defer l.mu.Unlock() - l.toF0mapping[nonF0] = idAddr.(address.Address) + l.toF0mapping[nonF0] = idAddr.(address.Address) //revive:disable-line:unchecked-type-assertion return l.toF0mapping[nonF0], nil } diff --git a/damocles-manager/modules/address/sender_selector.go b/damocles-manager/modules/address/sender_selector.go index 9671957c1..e0212a794 100644 --- a/damocles-manager/modules/address/sender_selector.go +++ b/damocles-manager/modules/address/sender_selector.go @@ -21,10 +21,20 @@ import ( "golang.org/x/sync/singleflight" ) -func NewSenderSelector(chain chain.API, lookupID core.LookupID) *SenderSelector { - cache := cache.New(time.Duration(policy.NetParams.BlockDelaySecs/2), time.Duration(policy.NetParams.BlockDelaySecs)) +func NewSenderSelector( + chainAPI chain.API, + lookupID core.LookupID, +) *SenderSelector { + cache := cache.New( + time.Duration( + policy.NetParams.BlockDelaySecs/2, + ), + time.Duration( + policy.NetParams.BlockDelaySecs, + ), + ) return &SenderSelector{ - chain: chain, + chain: chainAPI, cache: cache, lookupID: lookupID, } @@ -38,80 +48,158 @@ type SenderSelector struct { lookupID core.LookupID } -func (s *SenderSelector) Select(ctx context.Context, mid abi.ActorID, senders []address.Address) (address.Address, error) { +func (s *SenderSelector) Select( + ctx context.Context, + mid abi.ActorID, + senders []address.Address, +) (address.Address, error) { key := cacheKey(mid, senders) sender, found := s.cache.Get(key) if !found { var err error - sender, err, _ = s.group.Do(key, func() (interface{}, error) { - senderInner, errInner := s.selectInner(ctx, mid, senders) - if err == nil { - s.cache.Set(key, sender, cache.DefaultExpiration) - } - return senderInner, errInner - }) + sender, err, _ = s.group.Do( + key, + func() (any, error) { + senderInner, errInner := s.selectInner( + ctx, + mid, + senders, + ) + if err == nil { + s.cache.Set( + key, + sender, + cache.DefaultExpiration, + ) + } + return senderInner, errInner + }, + ) if err != nil { return address.Undef, err } } log.Infof("selected sender: %s", sender) - return sender.(address.Address), nil + return sender.(address.Address), nil //revive:disable-line:unchecked-type-assertion } -func (s *SenderSelector) selectInner(ctx context.Context, mid abi.ActorID, senders []address.Address) (address.Address, error) { +func (s *SenderSelector) selectInner( + ctx context.Context, + mid abi.ActorID, + senders []address.Address, +) (address.Address, error) { // convert non-f0 address to f0 address for i := range senders { if senders[i].Protocol() != address.ID { var err error - senders[i], err = s.lookupID.StateLookupID(ctx, senders[i]) + senders[i], err = s.lookupID.StateLookupID( + ctx, + senders[i], + ) if err != nil { return address.Undef, err } } } - maddr, err := address.NewIDAddress(uint64(mid)) + maddr, err := address.NewIDAddress( + uint64(mid), + ) if err != nil { return address.Undef, err } - minerInfo, err := s.chain.StateMinerInfo(ctx, maddr, types.EmptyTSK) + minerInfo, err := s.chain.StateMinerInfo( + ctx, + maddr, + types.EmptyTSK, + ) if err != nil { - return address.Undef, fmt.Errorf("get miner info for %s: %w", maddr, err) + return address.Undef, fmt.Errorf( + "get miner info for %s: %w", + maddr, + err, + ) } - minerAddrs := lo.Flatten([][]address.Address{{minerInfo.Owner, minerInfo.Worker}, minerInfo.ControlAddresses}) - validAddrs := lo.Intersect(senders, minerAddrs) + minerAddrs := lo.Flatten( + [][]address.Address{ + {minerInfo.Owner, minerInfo.Worker}, + minerInfo.ControlAddresses, + }, + ) + validAddrs := lo.Intersect( + senders, + minerAddrs, + ) if len(validAddrs) == 0 { - return address.Undef, fmt.Errorf("no valid sender found") + return address.Undef, fmt.Errorf( + "no valid sender found", + ) } - balancesCache := make(map[address.Address]types.BigInt) + balancesCache := make( + map[address.Address]types.BigInt, + ) sort.Slice(validAddrs, func(i, j int) bool { - balanceI := valueOrInsert(balancesCache, validAddrs[i], func() types.BigInt { - return s.getBalance(ctx, validAddrs[i], big.Zero()) - }) - balanceJ := valueOrInsert(balancesCache, validAddrs[j], func() types.BigInt { - return s.getBalance(ctx, validAddrs[j], big.Zero()) - }) + balanceI := valueOrInsert( + balancesCache, + validAddrs[i], + func() types.BigInt { + return s.getBalance( + ctx, + validAddrs[i], + big.Zero(), + ) + }, + ) + balanceJ := valueOrInsert( + balancesCache, + validAddrs[j], + func() types.BigInt { + return s.getBalance( + ctx, + validAddrs[j], + big.Zero(), + ) + }, + ) return balanceI.GreaterThan(balanceJ) }) return validAddrs[0], nil } -func (s *SenderSelector) getBalance(ctx context.Context, addr address.Address, defaultBalance types.BigInt) types.BigInt { - actor, err := s.chain.StateGetActor(ctx, addr, types.EmptyTSK) +func (s *SenderSelector) getBalance( + ctx context.Context, + addr address.Address, + defaultBalance types.BigInt, +) types.BigInt { + actor, err := s.chain.StateGetActor( + ctx, + addr, + types.EmptyTSK, + ) if err != nil { - log.Warnf("get actor for: %s, %w", addr, err) + log.Warnf( + "get actor for: %s, %w", + addr, + err, + ) return defaultBalance } return actor.Balance } -func cacheKey(mid abi.ActorID, senders []address.Address) string { +func cacheKey( + mid abi.ActorID, + senders []address.Address, +) string { h := xxhash.New() midBytes := make([]byte, 8) - binary.LittleEndian.PutUint64(midBytes, uint64(mid)) + binary.LittleEndian.PutUint64( + midBytes, + uint64(mid), + ) // It always returns len(b), nil. _, _ = h.Write(midBytes) for _, sender := range senders { @@ -123,7 +211,11 @@ func cacheKey(mid abi.ActorID, senders []address.Address) string { } // valueOrInsert returns the value of the given key or insert the fallback value into map if the key is not present. -func valueOrInsert[K comparable, V any](in map[K]V, key K, fallback func() V) V { +func valueOrInsert[K comparable, V any]( + in map[K]V, + key K, + fallback func() V, +) V { if v, ok := in[key]; ok { return v } diff --git a/damocles-manager/modules/address/sender_selector_test.go b/damocles-manager/modules/address/sender_selector_test.go index da06917ab..cf360e1c0 100644 --- a/damocles-manager/modules/address/sender_selector_test.go +++ b/damocles-manager/modules/address/sender_selector_test.go @@ -14,14 +14,25 @@ import ( ) func TestSelectSender(t *testing.T) { - balances := map[address.Address]big.Int{ - lo.Must(address.NewIDAddress(1000)): big.NewInt(1000), - lo.Must(address.NewIDAddress(2000)): big.NewInt(2000), - lo.Must(address.NewIDAddress(3000)): big.NewInt(3000), - lo.Must(address.NewIDAddress(4000)): big.NewInt(4000), - lo.Must(address.NewIDAddress(5000)): big.NewInt(5000), - lo.Must(address.NewIDAddress(6000)): big.NewInt(6000), + lo.Must(address.NewIDAddress(1000)): big.NewInt( + 1000, + ), + lo.Must(address.NewIDAddress(2000)): big.NewInt( + 2000, + ), + lo.Must(address.NewIDAddress(3000)): big.NewInt( + 3000, + ), + lo.Must(address.NewIDAddress(4000)): big.NewInt( + 4000, + ), + lo.Must(address.NewIDAddress(5000)): big.NewInt( + 5000, + ), + lo.Must(address.NewIDAddress(6000)): big.NewInt( + 6000, + ), } var mockChain chain.MockStruct @@ -30,33 +41,70 @@ func TestSelectSender(t *testing.T) { BlockDelaySecs: 30, } - mockChain.IMinerStateStruct.Internal.StateMinerInfo = func(_ context.Context, _ address.Address, _ types.TipSetKey) (types.MinerInfo, error) { + mockChain.IMinerStateStruct.Internal.StateMinerInfo = func(_ context.Context, _ address.Address, _ types.TipSetKey) (types.MinerInfo, error) { //revive:disable-line:line-length-limit return types.MinerInfo{ - Owner: lo.Must(address.NewIDAddress(1000)), - Worker: lo.Must(address.NewIDAddress(2000)), - ControlAddresses: []address.Address{lo.Must(address.NewIDAddress(3000)), lo.Must(address.NewIDAddress(4000)), lo.Must(address.NewIDAddress(5000))}, + Owner: lo.Must( + address.NewIDAddress(1000), + ), + Worker: lo.Must( + address.NewIDAddress(2000), + ), + ControlAddresses: []address.Address{ + lo.Must( + address.NewIDAddress(3000), + ), + lo.Must( + address.NewIDAddress(4000), + ), + lo.Must( + address.NewIDAddress(5000), + ), + }, }, nil } - mockChain.IActorStruct.Internal.StateGetActor = func(_ context.Context, actor address.Address, _ types.TipSetKey) (*types.Actor, error) { + mockChain.IActorStruct.Internal.StateGetActor = func(_ context.Context, actor address.Address, _ types.TipSetKey) (*types.Actor, error) { //revive:disable-line:line-length-limit return &types.Actor{ Balance: balances[actor], }, nil } - id5000F3 := lo.Must(address.NewBLSAddress(lo.Times(address.BlsPublicKeyBytes, func(_ int) byte { return 0 }))) + id5000F3 := lo.Must( + address.NewBLSAddress( + lo.Times( + address.BlsPublicKeyBytes, + func(_ int) byte { return 0 }, + ), + ), + ) f3f0mapping := map[address.Address]address.Address{ - id5000F3: lo.Must(address.NewIDAddress(5000)), + id5000F3: lo.Must( + address.NewIDAddress(5000), + ), } - mockChain.IMinerStateStruct.Internal.StateLookupID = func(_ context.Context, addr address.Address, _ types.TipSetKey) (address.Address, error) { + mockChain.IMinerStateStruct.Internal.StateLookupID = func(_ context.Context, addr address.Address, _ types.TipSetKey) (address.Address, error) { //revive:disable-line:line-length-limit return f3f0mapping[addr], nil } ctx := context.TODO() - sel := NewSenderSelector(&mockChain, NewCacheableLookupID(&mockChain)) - senders := []address.Address{lo.Must(address.NewIDAddress(2000)), lo.Must(address.NewIDAddress(9999)), id5000F3, lo.Must(address.NewIDAddress(1000)), lo.Must(address.NewIDAddress(6000))} + sel := NewSenderSelector( + &mockChain, + NewCacheableLookupID(&mockChain), + ) + senders := []address.Address{ + lo.Must(address.NewIDAddress(2000)), + lo.Must(address.NewIDAddress(9999)), + id5000F3, + lo.Must(address.NewIDAddress(1000)), + lo.Must(address.NewIDAddress(6000)), + } sender, err := sel.Select(ctx, 1, senders) require.NoError(t, err) - require.Equal(t, lo.Must(address.NewIDAddress(5000)).String(), sender.String()) + require.Equal( + t, + lo.Must(address.NewIDAddress(5000)). + String(), + sender.String(), + ) } diff --git a/damocles-manager/modules/config.go b/damocles-manager/modules/config.go index 567dfac9d..f8af036cb 100644 --- a/damocles-manager/modules/config.go +++ b/damocles-manager/modules/config.go @@ -166,21 +166,22 @@ type ProvingConfig struct { // to late submission. ParallelCheckLimit int - // Maximum amount of time a proving pre-check can take for a sector. If the check times out the sector will be skipped + // Maximum amount of time a proving pre-check can take for a sector. + // If the check times out the sector will be skipped // - // WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, just reading the - // test challenge took longer than this timeout - // WARNING: Setting this value too high risks missing PoSt deadline in case IO operations related to this sector are - // blocked (e.g. in case of disconnected NFS mount) + // WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, + // just reading the test challenge took longer than this timeout + // WARNING: Setting this value too high risks missing PoSt deadline in case IO operations + // related to this sector are blocked (e.g. in case of disconnected NFS mount) SingleCheckTimeout Duration - // Maximum amount of time a proving pre-check can take for an entire partition. If the check times out, sectors in - // the partition which didn't get checked on time will be skipped + // Maximum amount of time a proving pre-check can take for an entire partition. + // If the check times out, sectors in the partition which didn't get checked on time will be skipped // - // WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, just reading the - // test challenge took longer than this timeout - // WARNING: Setting this value too high risks missing PoSt deadline in case IO operations related to this partition are - // blocked or slow + // WARNING: Setting this value too low risks in sectors being skipped even though they are accessible, + // just reading the test challenge took longer than this timeout + // WARNING: Setting this value too high risks missing PoSt deadline in case IO operations + // related to this partition are blocked or slow PartitionCheckTimeout Duration WorkerProver *WorkerProverConfig @@ -222,7 +223,8 @@ type CommonConfig struct { // PersistStores should not be used directly, use GetPersistStores instead PersistStores []PersistStoreConfig - // Configure the storage directory for scanning the directory that contains `sectorstore.json` file, supporting `glob` mode. + // Configure the storage directory for scanning the directory that contains `sectorstore.json` file, + // supporting `glob` mode. ScanPersistStores []string MongoKVStore *KVStoreMongoDBConfig // For compatibility with v0.5 @@ -240,7 +242,7 @@ func (c CommonConfig) GetPersistStores() (cfgs []PersistStoreConfig, err error) if err != nil { return } - cfgs = append(cfgs, scanned...) + cfgs = append(cfgs, scanned...) //nolint:makezero } checkName := make(map[string]struct{}) @@ -300,8 +302,11 @@ func defaultCommonConfig(example bool) CommonConfig { Path: exampleCfg.Path, Meta: exampleCfg.Meta, }, - StoreSelectPolicy: objstore.StoreSelectPolicy{AllowMiners: []abi.ActorID{1, 2}, DenyMiners: []abi.ActorID{3, 4}}, - PluginName: "s3store", + StoreSelectPolicy: objstore.StoreSelectPolicy{ + AllowMiners: []abi.ActorID{1, 2}, + DenyMiners: []abi.ActorID{3, 4}, + }, + PluginName: "s3store", }) } @@ -309,18 +314,18 @@ func defaultCommonConfig(example bool) CommonConfig { } type FeeConfig struct { - //included in msg send spec + // included in msg send spec GasOverEstimation float64 GasOverPremium float64 - //set to msg directly + // set to msg directly GasFeeCap FIL - MaxFeeCap FIL //兼容老字段， FeeConfig用在embed字段， 使用TextUnmarshaler会影响上层结构体解析 + MaxFeeCap FIL // 兼容老字段， FeeConfig用在embed字段， 使用TextUnmarshaler会影响上层结构体解析 } func (feeCfg *FeeConfig) GetGasFeeCap() FIL { gasFeeCap := feeCfg.GasFeeCap if (*big.Int)(&feeCfg.GasFeeCap).NilOrZero() && !(*big.Int)(&feeCfg.MaxFeeCap).NilOrZero() { - //if not set GasFeeCap but set MaxFeecap use MaxFeecap as GasFeecap + // if not set GasFeeCap but set MaxFeecap use MaxFeecap as GasFeecap gasFeeCap = feeCfg.MaxFeeCap } return gasFeeCap @@ -592,13 +597,17 @@ func defaultMinerSealingConfig() MinerSealingConfig { return MinerSealingConfig{ SealingEpochDuration: 0, - // Whether to abort if any sector activation in a batch fails (newly sealed sectors, only with ProveCommitSectors3). + // Whether to abort if any sector activation in a batch fails + // (newly sealed sectors, only with ProveCommitSectors3). RequireActivationSuccess: false, - // Whether to abort if any piece activation notification returns a non-zero exit code (newly sealed sectors, only with ProveCommitSectors3). + // Whether to abort if any piece activation notification returns a non-zero exit code + // (newly sealed sectors, only with ProveCommitSectors3). RequireActivationSuccessUpdate: false, - // Whether to abort if any sector activation in a batch fails (updating sectors, only with ProveReplicaUpdates3). + // Whether to abort if any sector activation in a batch fails + // (updating sectors, only with ProveReplicaUpdates3). RequireNotificationSuccess: false, - // Whether to abort if any piece activation notification returns a non-zero exit code (updating sectors, only with ProveReplicaUpdates3). + // Whether to abort if any piece activation notification returns a non-zero exit code + // (updating sectors, only with ProveReplicaUpdates3). RequireNotificationSuccessUpdate: false, UseSyntheticPoRep: false, diff --git a/damocles-manager/modules/config_util.go b/damocles-manager/modules/config_util.go index 5646643db..9a767baee 100644 --- a/damocles-manager/modules/config_util.go +++ b/damocles-manager/modules/config_util.go @@ -229,7 +229,6 @@ const FilenameSectorStoreJSON = "sectorstore.json" func ScanPersistStores(patterns []string) ([]PersistStoreConfig, error) { var stores []PersistStoreConfig for _, pattern := range patterns { - matches, err := filepath.Glob(pattern) if err != nil { return nil, fmt.Errorf("glob pattern `%s`: %w", pattern, err) diff --git a/damocles-manager/modules/config_util_test.go b/damocles-manager/modules/config_util_test.go index 58c40205b..7c2028a13 100644 --- a/damocles-manager/modules/config_util_test.go +++ b/damocles-manager/modules/config_util_test.go @@ -16,13 +16,16 @@ import ( ) func TestMustAddressMarshalText(t *testing.T) { - testCases := []struct { addr address.Address expected string }{ { - testutil.Must(address.NewFromString("t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a")), + testutil.Must( + address.NewFromString( + "t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a", + ), + ), "t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a", }, { @@ -39,14 +42,17 @@ func TestMustAddressMarshalText(t *testing.T) { } func TestMustAddressUnmarshalText(t *testing.T) { - testCases := []struct { addr string expected address.Address }{ { "t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a", - testutil.Must(address.NewFromString("t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a")), + testutil.Must( + address.NewFromString( + "t3vvmn62lofvhjd2ugzca6sof2j2ubwok6cj4xxbfzz4yuxfkgobpihhd2thlanmsh3w2ptld2gqkn2jvlss4a", + ), + ), }, { address.UndefAddressString, @@ -77,7 +83,6 @@ func TestStructWithNilField(t *testing.T) { err := enc.Encode(a) require.NoError(t, err) fmt.Println(buf.String()) - } func TestTomlUnmarshalForFIL(t *testing.T) { @@ -85,7 +90,6 @@ func TestTomlUnmarshalForFIL(t *testing.T) { F modules.FIL } t.Run("Marshal", func(t *testing.T) { - a := A{ F: modules.AttoFIL, } @@ -95,7 +99,7 @@ func TestTomlUnmarshalForFIL(t *testing.T) { enc.Indent = "" err := enc.Encode(a) require.NoError(t, err) - require.Equalf(t, "F = \"1 attoFIL\"\n", string(buf.Bytes()), "got: %s", string(buf.Bytes())) + require.Equalf(t, "F = \"1 attoFIL\"\n", buf.String(), "got: %s", buf.String()) }) t.Run("Unmarshal", func(t *testing.T) { @@ -202,7 +206,10 @@ func TestScanPersistStores(t *testing.T) { "Meta": {}, "CanSeal": true }` - require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "1", modules.FilenameSectorStoreJSON), []byte(jsonConf1), 0644)) + require.NoError( + t, + os.WriteFile(filepath.Join(tmpDir, "1", modules.FilenameSectorStoreJSON), []byte(jsonConf1), 0644), + ) jsonConf2 := `{ "Name": "456", @@ -214,7 +221,10 @@ func TestScanPersistStores(t *testing.T) { "PluginName": "2234234", "CanSeal": true }` - require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "2", modules.FilenameSectorStoreJSON), []byte(jsonConf2), 0644)) + require.NoError( + t, + os.WriteFile(filepath.Join(tmpDir, "2", modules.FilenameSectorStoreJSON), []byte(jsonConf2), 0644), + ) cfgs, err := modules.ScanPersistStores([]string{filepath.Join(tmpDir, "*")}) require.NoError(t, err) diff --git a/damocles-manager/modules/impl/commitmgr/batcher.go b/damocles-manager/modules/impl/commitmgr/batcher.go index 21c8f907c..521c62777 100644 --- a/damocles-manager/modules/impl/commitmgr/batcher.go +++ b/damocles-manager/modules/impl/commitmgr/batcher.go @@ -88,7 +88,7 @@ func (b *Batcher) run() { processList = make([]core.SectorState, 0, len(pending)) for i := range pending { if _, ok := expired[pending[i].ID]; ok { - processList = append(processList, pending[i]) + processList = append(processList, pending[i]) //nolint:all } else { remain = append(remain, pending[i]) } @@ -99,7 +99,19 @@ func (b *Batcher) run() { } if len(processList) > 0 { - b.log.Debugw("will process sectors", "len", len(processList), "full", full, "manual", manual, "all", cleanAll, "tick", tick) + b.log.Debugw( + "will process sectors", + "len", + len(processList), + "full", + full, + "manual", + manual, + "all", + cleanAll, + "tick", + tick, + ) wg.Add(1) go func() { defer wg.Done() @@ -117,7 +129,13 @@ func (b *Batcher) run() { } } -func NewBatcher(ctx context.Context, mid abi.ActorID, ctrlAddr address.Address, processor Processor, l *logging.ZapLogger) *Batcher { +func NewBatcher( + ctx context.Context, + mid abi.ActorID, + ctrlAddr address.Address, + processor Processor, + l *logging.ZapLogger, +) *Batcher { b := &Batcher{ ctx: ctx, mid: mid, diff --git a/damocles-manager/modules/impl/commitmgr/check.go b/damocles-manager/modules/impl/commitmgr/check.go index d0dd741a5..5d72d4a25 100644 --- a/damocles-manager/modules/impl/commitmgr/check.go +++ b/damocles-manager/modules/impl/commitmgr/check.go @@ -20,20 +20,24 @@ import ( type ErrAPI struct{ error } -type ErrInvalidDeals struct{ error } -type ErrInvalidPiece struct{ error } -type ErrExpiredDeals struct{ error } - -type ErrBadCommD struct{ error } -type ErrExpiredTicket struct{ error } -type ErrBadTicket struct{ error } -type ErrPrecommitOnChain struct{ error } -type ErrSectorNumberAllocated struct{ error } -type ErrMarshalAddr struct{ error } -type ErrBadSeed struct{ error } -type ErrInvalidProof struct{ error } -type ErrNoPrecommit struct{ error } -type ErrCommitWaitFailed struct{ error } +type ( + ErrInvalidDeals struct{ error } + ErrInvalidPiece struct{ error } + ErrExpiredDeals struct{ error } +) + +type ( + ErrBadCommD struct{ error } + ErrExpiredTicket struct{ error } + ErrBadTicket struct{ error } + ErrPrecommitOnChain struct{ error } + ErrSectorNumberAllocated struct{ error } + ErrMarshalAddr struct{ error } + ErrBadSeed struct{ error } + ErrInvalidProof struct{ error } + ErrNoPrecommit struct{ error } + ErrCommitWaitFailed struct{ error } +) // checkPrecommit checks that data commitment generated in the sealing process // matches pieces, and that the seal ticket isn't expired @@ -66,7 +70,13 @@ func checkPrecommit(ctx context.Context, maddr address.Address, si *core.SectorS ticketEarliest := height - policy.MaxPreCommitRandomnessLookback if si.Ticket.Epoch < ticketEarliest { - return &ErrExpiredTicket{fmt.Errorf("ticket expired: seal height: %d, head: %d", si.Ticket.Epoch+policy.SealRandomnessLookback, height)} + return &ErrExpiredTicket{ + fmt.Errorf( + "ticket expired: seal height: %d, head: %d", + si.Ticket.Epoch+policy.SealRandomnessLookback, + height, + ), + } } pci, err := api.StateSectorPreCommitInfo(ctx, maddr, si.ID.Number, tok) @@ -100,7 +110,9 @@ func checkPieces(ctx context.Context, maddr address.Address, sector *core.Sector checkZeroPiece := func(pieceIdx int, piece abi.PieceInfo) error { exp := zerocomm.ZeroPieceCommitment(piece.Size.Unpadded()) if !piece.PieceCID.Equals(exp) { - return &ErrInvalidPiece{fmt.Errorf("sector %d piece %d had non-zero PieceCID %+v", sector.ID, pieceIdx, piece.PieceCID)} + return &ErrInvalidPiece{ + fmt.Errorf("sector %d piece %d had non-zero PieceCID %+v", sector.ID, pieceIdx, piece.PieceCID), + } } return nil } @@ -112,19 +124,59 @@ func checkPieces(ctx context.Context, maddr address.Address, sector *core.Sector } if proposal.Provider != maddr { - return &ErrInvalidDeals{fmt.Errorf("piece %d (of %v) of sector %d refers deal %d with wrong provider: %s != %s", pieceIdx, numDeals, sector.ID, dealID, proposal.Provider, maddr)} + return &ErrInvalidDeals{ + fmt.Errorf( + "piece %d (of %v) of sector %d refers deal %d with wrong provider: %s != %s", + pieceIdx, + numDeals, + sector.ID, + dealID, + proposal.Provider, + maddr, + ), + } } if proposal.PieceCID != piece.PieceCID { - return &ErrInvalidDeals{fmt.Errorf("piece %d (of %v) of sector %d refers deal %d with wrong PieceCID: %x != %x", pieceIdx, numDeals, sector.ID, dealID, piece.PieceCID, proposal.PieceCID)} + return &ErrInvalidDeals{ + fmt.Errorf( + "piece %d (of %v) of sector %d refers deal %d with wrong PieceCID: %x != %x", + pieceIdx, + numDeals, + sector.ID, + dealID, + piece.PieceCID, + proposal.PieceCID, + ), + } } if piece.Size != proposal.PieceSize { - return &ErrInvalidDeals{fmt.Errorf("piece %d (of %v) of sector %d refers deal %d with different size: %d != %d", pieceIdx, numDeals, sector.ID, dealID, piece.Size, proposal.PieceSize)} + return &ErrInvalidDeals{ + fmt.Errorf( + "piece %d (of %v) of sector %d refers deal %d with different size: %d != %d", + pieceIdx, + numDeals, + sector.ID, + dealID, + piece.Size, + proposal.PieceSize, + ), + } } if height >= proposal.StartEpoch { - return &ErrExpiredDeals{fmt.Errorf("piece %d (of %v) of sector %d refers expired deal %d - should start at %d, head %d", pieceIdx, numDeals, sector.ID, dealID, proposal.StartEpoch, height)} + return &ErrExpiredDeals{ + fmt.Errorf( + "piece %d (of %v) of sector %d refers expired deal %d - should start at %d, head %d", + pieceIdx, + numDeals, + sector.ID, + dealID, + proposal.StartEpoch, + height, + ), + } } return nil } @@ -146,11 +198,31 @@ func checkPieces(ctx context.Context, maddr address.Address, sector *core.Sector } if height >= all.Expiration { - return &ErrExpiredDeals{fmt.Errorf("piece allocation %d (of %d) of sector %d refers expired deal %d - should start at %d, head %d", pieceIdx, numDeals, sector.ID, allocationID, all.Expiration, height)} + return &ErrExpiredDeals{ + fmt.Errorf( + "piece allocation %d (of %d) of sector %d refers expired deal %d - should start at %d, head %d", + pieceIdx, + numDeals, + sector.ID, + allocationID, + all.Expiration, + height, + ), + } } if all.Size < piece.Size { - return &ErrInvalidDeals{fmt.Errorf("piece allocation %d (of %d) of sector %d refers deal %d with different size: %d != %d", pieceIdx, numDeals, sector.ID, allocationID, piece.Size, all.Size)} + return &ErrInvalidDeals{ + fmt.Errorf( + "piece allocation %d (of %d) of sector %d refers deal %d with different size: %d != %d", + pieceIdx, + numDeals, + sector.ID, + allocationID, + piece.Size, + all.Size, + ), + } } } return nil @@ -191,7 +263,15 @@ func checkPieces(ctx context.Context, maddr address.Address, sector *core.Sector return nil } -func checkCommit(ctx context.Context, si *core.SectorState, proof []byte, tok core.TipSetToken, maddr address.Address, verif core.Verifier, api SealingAPI) (err error) { +func checkCommit( + ctx context.Context, + si *core.SectorState, + proof []byte, + tok core.TipSetToken, + maddr address.Address, + verif core.Verifier, + api SealingAPI, +) (err error) { if si.Seed == nil { return &ErrBadSeed{fmt.Errorf("seed epoch was not set")} } @@ -211,7 +291,9 @@ func checkCommit(ctx context.Context, si *core.SectorState, proof []byte, tok co seedEpoch := pci.PreCommitEpoch + policy.GetPreCommitChallengeDelay() if seedEpoch != si.Seed.Epoch { - return &ErrBadSeed{fmt.Errorf("seed epoch doesn't match on chain info: %d(chain) != %d", seedEpoch, si.Seed.Epoch)} + return &ErrBadSeed{ + fmt.Errorf("seed epoch doesn't match on chain info: %d(chain) != %d", seedEpoch, si.Seed.Epoch), + } } buf := new(bytes.Buffer) @@ -248,11 +330,14 @@ func checkCommit(ctx context.Context, si *core.SectorState, proof []byte, tok co } func computeUnsealedCIDFromPieces(sector *core.SectorState) (cid.Cid, error) { - return ffi.GenerateUnsealedCID(sector.SectorType, lo.Map(sector.SectorPiece(), func(p core.SectorPiece, i int) abi.PieceInfo { - pi := p.PieceInfo() - return abi.PieceInfo{ - Size: pi.Size, - PieceCID: pi.Cid, - } - })) + return ffi.GenerateUnsealedCID( + sector.SectorType, + lo.Map(sector.SectorPiece(), func(p core.SectorPiece, i int) abi.PieceInfo { + pi := p.PieceInfo() + return abi.PieceInfo{ + Size: pi.Size, + PieceCID: pi.Cid, + } + }), + ) } diff --git a/damocles-manager/modules/impl/commitmgr/commit_processor.go b/damocles-manager/modules/impl/commitmgr/commit_processor.go index caba89134..ebb081599 100644 --- a/damocles-manager/modules/impl/commitmgr/commit_processor.go +++ b/damocles-manager/modules/impl/commitmgr/commit_processor.go @@ -23,13 +23,13 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/core" "github.com/ipfs-force-community/damocles/damocles-manager/modules" "github.com/ipfs-force-community/damocles/damocles-manager/modules/util/piece" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/logging" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/messager" ) type CommitProcessor struct { - chain chainAPI.API + chain chainapi.API api SealingAPI msgClient messager.API lookupID core.LookupID @@ -41,7 +41,13 @@ type CommitProcessor struct { prover core.Prover } -func (c CommitProcessor) processIndividually(ctx context.Context, sectors []core.SectorState, from address.Address, mid abi.ActorID, plog *logging.ZapLogger) { +func (c CommitProcessor) processIndividually( + ctx context.Context, + sectors []core.SectorState, + from address.Address, + mid abi.ActorID, + plog *logging.ZapLogger, +) { mcfg, err := c.config.MinerConfig(mid) if err != nil { plog.Errorf("get miner config for %d: %s", mid, err) @@ -82,7 +88,17 @@ func (c CommitProcessor) processIndividually(ctx context.Context, sectors []core } } - mcid, err := pushMessage(ctx, from, mid, collateral, stbuiltin.MethodsMiner.ProveCommitSector, c.msgClient, &mcfg.Commitment.Prove.FeeConfig, enc.Bytes(), slog) + mcid, err := pushMessage( + ctx, + from, + mid, + collateral, + stbuiltin.MethodsMiner.ProveCommitSector, + c.msgClient, + &mcfg.Commitment.Prove.FeeConfig, + enc.Bytes(), + slog, + ) if err != nil { slog.Error("push commit single failed: ", err) return @@ -95,8 +111,12 @@ func (c CommitProcessor) processIndividually(ctx context.Context, sectors []core wg.Wait() } -func (c CommitProcessor) Process(ctx context.Context, sectors []core.SectorState, mid abi.ActorID, ctrlAddr address.Address) error { - +func (c CommitProcessor) Process( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, + ctrlAddr address.Address, +) error { tok, _, err := c.api.ChainHead(ctx) if err != nil { return fmt.Errorf("get chain head failed: %w", err) @@ -126,7 +146,15 @@ func (c CommitProcessor) Process(ctx context.Context, sectors []core.SectorState return c.ProcessV1(ctx, builtinMarketSectors, mid, ctrlAddr, tok, nv, aggregate) } -func (c CommitProcessor) ProcessV1(ctx context.Context, sectors []core.SectorState, mid abi.ActorID, ctrlAddr address.Address, tok core.TipSetToken, nv network.Version, batch bool) error { +func (c CommitProcessor) ProcessV1( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, + ctrlAddr address.Address, + tok core.TipSetToken, + nv network.Version, + batch bool, +) error { // Notice: If a sector in sectors has been sent, it's cid failed should be changed already. plog := log.With("proc", "prove", "miner", mid, "ctrl", ctrlAddr.String(), "len", len(sectors)) @@ -230,7 +258,15 @@ func (c CommitProcessor) ProcessV1(ctx context.Context, sectors []core.SectorSta // processBatchV2 processes a batch of sectors after nv22. It will always send // ProveCommitSectors3Params which may contain either individual proofs or an // aggregate proof depending on SP condition and network conditions. -func (c CommitProcessor) ProcessV2(ctx context.Context, sectors []core.SectorState, mid abi.ActorID, ctrlAddr address.Address, tok core.TipSetToken, nv network.Version, aggregate bool) error { +func (c CommitProcessor) ProcessV2( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, + ctrlAddr address.Address, + tok core.TipSetToken, + nv network.Version, + aggregate bool, +) error { // Notice: If a sector in sectors has been sent, it's cid failed should be changed already. plog := log.With("proc", "prove", "miner", mid, "ctrl", ctrlAddr.String(), "len", len(sectors)) @@ -340,14 +376,18 @@ func (c CommitProcessor) ProcessV2(ctx context.Context, sectors []core.SectorSta return nil } -func (c CommitProcessor) aggregateProofType(nv network.Version) (abi.RegisteredAggregationProof, error) { +func (CommitProcessor) aggregateProofType(nv network.Version) (abi.RegisteredAggregationProof, error) { if nv < network.Version16 { return abi.RegisteredAggregationProof_SnarkPackV1, nil } return abi.RegisteredAggregationProof_SnarkPackV2, nil } -func (c CommitProcessor) Expire(ctx context.Context, sectors []core.SectorState, mid abi.ActorID) (map[abi.SectorID]struct{}, error) { +func (c CommitProcessor) Expire( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, +) (map[abi.SectorID]struct{}, error) { maxWait := c.config.MustMinerConfig(mid).Commitment.Prove.Batch.MaxWait.Std() maxWaitHeight := abi.ChainEpoch(maxWait / (builtin.EpochDurationSeconds * time.Second)) _, h, err := c.api.ChainHead(ctx) @@ -390,7 +430,6 @@ func (c CommitProcessor) ShouldBatch(mid abi.ActorID) bool { } return c.api.ChainBaseFee(ctx, tok) }() - if err != nil { bLog.Errorf("get basefee: %w", err) return false @@ -398,7 +437,12 @@ func (c CommitProcessor) ShouldBatch(mid abi.ActorID) bool { bcfg := c.config.MustMinerConfig(mid).Commitment.Prove.Batch basefeeAbove := basefee.GreaterThanEqual(abi.TokenAmount(bcfg.BatchCommitAboveBaseFee)) - bLog.Debugf("should batch(%t): basefee(%s), basefee above(%s)", basefeeAbove, modules.FIL(basefee).Short(), bcfg.BatchCommitAboveBaseFee.Short()) + bLog.Debugf( + "should batch(%t): basefee(%s), basefee above(%s)", + basefeeAbove, + modules.FIL(basefee).Short(), + bcfg.BatchCommitAboveBaseFee.Short(), + ) return basefeeAbove } diff --git a/damocles-manager/modules/impl/commitmgr/commitmgr.go b/damocles-manager/modules/impl/commitmgr/commitmgr.go index 9cb02adab..edfb07478 100644 --- a/damocles-manager/modules/impl/commitmgr/commitmgr.go +++ b/damocles-manager/modules/impl/commitmgr/commitmgr.go @@ -18,7 +18,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/core" "github.com/ipfs-force-community/damocles/damocles-manager/modules" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/kvstore" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/logging" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/messager" @@ -39,7 +39,7 @@ type CommitmentMgrImpl struct { msgClient messager.API - chain chainAPI.API + chain chainapi.API stateMgr SealingAPI minerAPI core.MinerAPI lookupID core.LookupID @@ -64,8 +64,19 @@ type CommitmentMgrImpl struct { stop chan struct{} } -func NewCommitmentMgr(ctx context.Context, commitAPI messager.API, stateMgr SealingAPI, minerAPI core.MinerAPI, smgr core.SectorStateManager, - cfg *modules.SafeConfig, verif core.Verifier, prover core.Prover, senderSelector core.SenderSelector, chain chainAPI.API, lookupID core.LookupID, +//revive:disable-next-line:argument-limit +func NewCommitmentMgr( + ctx context.Context, + commitAPI messager.API, + stateMgr SealingAPI, + minerAPI core.MinerAPI, + smgr core.SectorStateManager, + cfg *modules.SafeConfig, + verif core.Verifier, + prover core.Prover, + senderSelector core.SenderSelector, + chain chainapi.API, + lookupID core.LookupID, ) (*CommitmentMgrImpl, error) { prePendingChan := make(chan core.SectorState, 1024) proPendingChan := make(chan core.SectorState, 1024) @@ -98,7 +109,12 @@ func NewCommitmentMgr(ctx context.Context, commitAPI messager.API, stateMgr Seal return &mgr, nil } -func updateSector(ctx context.Context, stmgr core.SectorStateManager, sector []core.SectorState, plog *logging.ZapLogger) { +func updateSector( + ctx context.Context, + stmgr core.SectorStateManager, + sector []core.SectorState, + plog *logging.ZapLogger, +) { sectorID := make([]abi.SectorID, len(sector)) for i := range sector { sectorID[i] = sector[i].ID @@ -112,9 +128,18 @@ func updateSector(ctx context.Context, stmgr core.SectorStateManager, sector []c plog.Infof("Process sectors %v finished", sectorID) } -func pushMessage(ctx context.Context, from address.Address, mid abi.ActorID, value abi.TokenAmount, method abi.MethodNum, - msgClient messager.API, feeCfg *modules.FeeConfig, params []byte, mlog *logging.ZapLogger) (cid.Cid, error) { - +//revive:disable-next-line:argument-limit +func pushMessage( + ctx context.Context, + from address.Address, + mid abi.ActorID, + value abi.TokenAmount, + method abi.MethodNum, + msgClient messager.API, + feeCfg *modules.FeeConfig, + params []byte, + mlog *logging.ZapLogger, +) (cid.Cid, error) { to, err := address.NewIDAddress(uint64(mid)) if err != nil { return cid.Undef, err @@ -450,7 +475,12 @@ func (c *CommitmentMgrImpl) restartSector(ctx context.Context) { } } -func (c *CommitmentMgrImpl) SubmitPreCommit(ctx context.Context, id abi.SectorID, info core.PreCommitInfo, hardReset bool) (core.SubmitPreCommitResp, error) { +func (c *CommitmentMgrImpl) SubmitPreCommit( + ctx context.Context, + id abi.SectorID, + info core.PreCommitInfo, + hardReset bool, +) (core.SubmitPreCommitResp, error) { _, err := c.preSender(ctx, id.Miner) if err != nil { return core.SubmitPreCommitResp{}, err @@ -492,9 +522,10 @@ func (c *CommitmentMgrImpl) SubmitPreCommit(ctx context.Context, id abi.SectorID case *ErrBadCommD: // When encountering `ErrBadCommD` error, damocles-worker should not release these deals, - // as it is highly likely that the same error will occur when these deals are released and re claimed by damocles. - // The current approach is to return an error of type `SubmitMismatchedSubmission``, causing damocles-worker to pause the sealing_thread - // to waiting for manual processing + // as it is highly likely that the same error will occur when these deals are released + // and re-acquired by damocles. + // The current approach is to return an error of type `SubmitMismatchedSubmission`, + // causing damocles-worker to pause the sealing_thread to waiting for manual processing errMsg := err.Error() return core.SubmitPreCommitResp{Res: core.SubmitMismatchedSubmission, Desc: &errMsg}, nil @@ -559,14 +590,22 @@ func (c *CommitmentMgrImpl) PreCommitState(ctx context.Context, id abi.SectorID) } if pci == nil { - return core.PollPreCommitStateResp{State: core.OnChainStateShouldAbort, Desc: &errMsgPreCommitInfoNotFound}, nil + return core.PollPreCommitStateResp{ + State: core.OnChainStateShouldAbort, + Desc: &errMsgPreCommitInfoNotFound, + }, nil } } return core.PollPreCommitStateResp{State: state, Desc: maybe}, nil } -func (c *CommitmentMgrImpl) SubmitProof(ctx context.Context, id abi.SectorID, info core.ProofInfo, hardReset bool) (core.SubmitProofResp, error) { +func (c *CommitmentMgrImpl) SubmitProof( + ctx context.Context, + id abi.SectorID, + info core.ProofInfo, + hardReset bool, +) (core.SubmitProofResp, error) { _, err := c.proveSender(ctx, id.Miner) if err != nil { return core.SubmitProofResp{}, err @@ -663,7 +702,6 @@ func (c *CommitmentMgrImpl) ProofState(ctx context.Context, id abi.SectorID) (co state, maybe := c.handleMessage(ctx, id.Miner, msg, mlog) if state == core.OnChainStateLanded { si, err := c.stateMgr.StateSectorGetInfo(ctx, maddr, id.Number, nil) - if err != nil { return core.PollProofStateResp{}, err } @@ -705,7 +743,9 @@ func (c *CommitmentMgrImpl) SubmitTerminate(ctx context.Context, sid abi.SectorI return core.SubmitTerminateResp{}, fmt.Errorf("checking precommit presence: %w", err) } if pci != nil { - return core.SubmitTerminateResp{}, fmt.Errorf("sector was precommitted but not proven, remove instead of terminating") + return core.SubmitTerminateResp{}, fmt.Errorf( + "sector was precommitted but not proven, remove instead of terminating", + ) } return core.SubmitTerminateResp{}, fmt.Errorf("already terminated") @@ -749,11 +789,15 @@ func (c *CommitmentMgrImpl) SubmitTerminate(ctx context.Context, sid abi.SectorI sector.ID = sid sector.SectorType = si.SealProof - ierr := c.smgr.InitWith(ctx, []*core.AllocatedSector{{ID: sid, ProofType: si.SealProof}}, core.WorkerOffline, newTerminateInfo) + ierr := c.smgr.InitWith( + ctx, + []*core.AllocatedSector{{ID: sid, ProofType: si.SealProof}}, + core.WorkerOffline, + newTerminateInfo, + ) if ierr != nil { return core.SubmitTerminateResp{}, fmt.Errorf("init non-exist snapup sector: %w", err) } - } else { if loadedSector.TerminateInfo.AddedHeight > 0 { errMsg := "duplicate submit" @@ -787,7 +831,12 @@ func (c *CommitmentMgrImpl) TerminateState(ctx context.Context, sid abi.SectorID return sector.TerminateInfo, nil } -func (c *CommitmentMgrImpl) handleMessage(_ context.Context, mid abi.ActorID, msg *messager.Message, mlog *logging.ZapLogger) (core.OnChainState, *string) { +func (c *CommitmentMgrImpl) handleMessage( + _ context.Context, + mid abi.ActorID, + msg *messager.Message, + mlog *logging.ZapLogger, +) (core.OnChainState, *string) { mlog = mlog.With("msg-cid", msg.ID, "msg-state", messager.MessageStateToString(msg.State)) if msg.SignedCid != nil { mlog = mlog.With("msg-signed-cid", msg.SignedCid.String()) diff --git a/damocles-manager/modules/impl/commitmgr/params.go b/damocles-manager/modules/impl/commitmgr/params.go index 21fbc5cee..d85202c09 100644 --- a/damocles-manager/modules/impl/commitmgr/params.go +++ b/damocles-manager/modules/impl/commitmgr/params.go @@ -12,7 +12,10 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/core" ) -func (p PreCommitProcessor) preCommitInfo(ctx context.Context, sector *core.SectorState) (*miner.SectorPreCommitInfo, big.Int, core.TipSetToken, error) { +func (p PreCommitProcessor) preCommitInfo( + ctx context.Context, + sector *core.SectorState, +) (*miner.SectorPreCommitInfo, big.Int, core.TipSetToken, error) { stateMgr := p.api tok, _, err := stateMgr.ChainHead(ctx) if err != nil { @@ -30,7 +33,8 @@ func (p PreCommitProcessor) preCommitInfo(ctx context.Context, sector *core.Sect case *ErrAPI: log.Errorf("handlePreCommitting: api error, not proceeding: %s", err) return nil, big.Zero(), nil, fmt.Errorf("call api failed %w", err) - case *ErrBadCommD: // TODO: Should this just back to packing? (not really needed since handlePreCommit1 will do that too) + case *ErrBadCommD: + // TODO: Should this just back to packing? (not really needed since handlePreCommit1 will do that too) return nil, big.Zero(), nil, fmt.Errorf("bad CommD error: %w", err) case *ErrExpiredTicket: return nil, big.Zero(), nil, fmt.Errorf("ticket expired: %w", err) @@ -81,7 +85,13 @@ func (p PreCommitProcessor) preCommitInfo(ctx context.Context, sector *core.Sect return params, deposit, tok, nil } -func getSectorCollateral(ctx context.Context, stateMgr SealingAPI, mid abi.ActorID, sn abi.SectorNumber, tok core.TipSetToken) (abi.TokenAmount, error) { +func getSectorCollateral( + ctx context.Context, + stateMgr SealingAPI, + mid abi.ActorID, + sn abi.SectorNumber, + tok core.TipSetToken, +) (abi.TokenAmount, error) { maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { return big.Zero(), fmt.Errorf("invalid miner actor id: %w", err) diff --git a/damocles-manager/modules/impl/commitmgr/policy.go b/damocles-manager/modules/impl/commitmgr/policy.go index 38d96c43a..e2faa3f56 100644 --- a/damocles-manager/modules/impl/commitmgr/policy.go +++ b/damocles-manager/modules/impl/commitmgr/policy.go @@ -44,6 +44,7 @@ func (pp PreCommitProcessor) sectorExpiration(ctx context.Context, state *core.S return 0, fmt.Errorf("calculate sector end: %w", err) } + //revive:disable-next-line:line-length-limit if minExpiration := state.Ticket.Epoch + policy.MaxPreCommitRandomnessLookback + mpcd + policy.MinSectorExpiration; expiration < minExpiration { expiration = minExpiration } @@ -61,7 +62,13 @@ func (pp PreCommitProcessor) sectorExpiration(ctx context.Context, state *core.S return expiration, nil } -func (pp PreCommitProcessor) sectorEnd(height abi.ChainEpoch, nv network.Version, state *core.SectorState, lifetimeDays uint64, provingPeriod abi.ChainEpoch) (abi.ChainEpoch, error) { +func (pp PreCommitProcessor) sectorEnd( + height abi.ChainEpoch, + nv network.Version, + state *core.SectorState, + lifetimeDays uint64, + provingPeriod abi.ChainEpoch, +) (abi.ChainEpoch, error) { var end *abi.ChainEpoch for _, p := range state.SectorPiece() { @@ -83,7 +90,11 @@ func (pp PreCommitProcessor) sectorEnd(height abi.ChainEpoch, nv network.Version if end == nil { // no deal pieces, get expiration for committed capacity sector - expirationDuration, err := pp.ccSectorLifetime(nv, abi.ChainEpoch(lifetimeDays*policy.EpochsInDay), provingPeriod) + expirationDuration, err := pp.ccSectorLifetime( + nv, + abi.ChainEpoch(lifetimeDays*policy.EpochsInDay), + provingPeriod, + ) if err != nil { return 0, fmt.Errorf("failed to get cc sector lifetime: %w", err) } @@ -102,7 +113,11 @@ func (pp PreCommitProcessor) sectorEnd(height abi.ChainEpoch, nv network.Version return *end, nil } -func (pp PreCommitProcessor) ccSectorLifetime(nv network.Version, ccLifetimeEpochs abi.ChainEpoch, provingPeriod abi.ChainEpoch) (abi.ChainEpoch, error) { +func (PreCommitProcessor) ccSectorLifetime( + nv network.Version, + ccLifetimeEpochs abi.ChainEpoch, + provingPeriod abi.ChainEpoch, +) (abi.ChainEpoch, error) { maxExpiration, err := policy.GetMaxSectorExpirationExtension(nv) if err != nil { return 0, fmt.Errorf("get max sector expiration extension: %w", err) @@ -113,11 +128,17 @@ func (pp PreCommitProcessor) ccSectorLifetime(nv network.Version, ccLifetimeEpoc } if minExpiration := abi.ChainEpoch(policy.MinSectorExpiration); ccLifetimeEpochs < minExpiration { - log.Warnf("value for CommittedCapacitySectorLifetime is too short, using default minimum (%d epochs)", minExpiration) + log.Warnf( + "value for CommittedCapacitySectorLifetime is too short, using default minimum (%d epochs)", + minExpiration, + ) return minExpiration, nil } if ccLifetimeEpochs > maxExpiration { - log.Warnf("value for CommittedCapacitySectorLifetime is too long, using default maximum (%d epochs)", maxExpiration) + log.Warnf( + "value for CommittedCapacitySectorLifetime is too long, using default maximum (%d epochs)", + maxExpiration, + ) return maxExpiration, nil } diff --git a/damocles-manager/modules/impl/commitmgr/precommit_processor.go b/damocles-manager/modules/impl/commitmgr/precommit_processor.go index 7bb961343..0a3b74bda 100644 --- a/damocles-manager/modules/impl/commitmgr/precommit_processor.go +++ b/damocles-manager/modules/impl/commitmgr/precommit_processor.go @@ -30,7 +30,12 @@ type PreCommitProcessor struct { config *modules.SafeConfig } -func (p PreCommitProcessor) Process(ctx context.Context, sectors []core.SectorState, mid abi.ActorID, ctrlAddr address.Address) error { +func (p PreCommitProcessor) Process( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, + ctrlAddr address.Address, +) error { // Notice: If a sector in sectors has been sent, it's cid failed should be changed already. plog := log.With("proc", "pre", "miner", mid, "ctrl", ctrlAddr.String(), "len", len(sectors)) @@ -124,7 +129,11 @@ func (p PreCommitProcessor) Process(ctx context.Context, sectors []core.SectorSt return nil } -func (p PreCommitProcessor) Expire(ctx context.Context, sectors []core.SectorState, mid abi.ActorID) (map[abi.SectorID]struct{}, error) { +func (p PreCommitProcessor) Expire( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, +) (map[abi.SectorID]struct{}, error) { maxWait := p.config.MustMinerConfig(mid).Commitment.Pre.Batch.MaxWait.Std() maxWaitHeight := abi.ChainEpoch(maxWait / (builtin.EpochDurationSeconds * time.Second)) _, h, err := p.api.ChainHead(ctx) @@ -168,7 +177,6 @@ func (p PreCommitProcessor) ShouldBatch(mid abi.ActorID) bool { } return p.api.ChainBaseFee(ctx, tok) }() - if err != nil { log.Errorf("get basefee: %w", err) return false @@ -176,7 +184,12 @@ func (p PreCommitProcessor) ShouldBatch(mid abi.ActorID) bool { bcfg := p.config.MustMinerConfig(mid).Commitment.Pre.Batch basefeeAbove := basefee.GreaterThanEqual(abi.TokenAmount(bcfg.BatchCommitAboveBaseFee)) - bLog.Debugf("should batch(%t): basefee(%s), basefee above(%s)", basefeeAbove, modules.FIL(basefee).Short(), bcfg.BatchCommitAboveBaseFee.Short()) + bLog.Debugf( + "should batch(%t): basefee(%s), basefee above(%s)", + basefeeAbove, + modules.FIL(basefee).Short(), + bcfg.BatchCommitAboveBaseFee.Short(), + ) return basefeeAbove } diff --git a/damocles-manager/modules/impl/commitmgr/sealing.go b/damocles-manager/modules/impl/commitmgr/sealing.go index a1f61b6b1..6fe2ef536 100644 --- a/damocles-manager/modules/impl/commitmgr/sealing.go +++ b/damocles-manager/modules/impl/commitmgr/sealing.go @@ -21,22 +21,28 @@ import ( "github.com/filecoin-project/venus/venus-shared/types" "github.com/ipfs-force-community/damocles/damocles-manager/core" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" ) type SealingAPIImpl struct { - api chainAPI.API + api chainapi.API core.RandomnessAPI } -func NewSealingAPIImpl(api chainAPI.API, rand core.RandomnessAPI) SealingAPIImpl { +func NewSealingAPIImpl(api chainapi.API, rand core.RandomnessAPI) SealingAPIImpl { return SealingAPIImpl{ api: api, RandomnessAPI: rand, } } -func (s SealingAPIImpl) StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tok core.TipSetToken) (cid.Cid, error) { +func (s SealingAPIImpl) StateComputeDataCommitment( + ctx context.Context, + maddr address.Address, + sectorType abi.RegisteredSealProof, + deals []abi.DealID, + tok core.TipSetToken, +) (cid.Cid, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return cid.Undef, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -45,7 +51,12 @@ func (s SealingAPIImpl) StateComputeDataCommitment(ctx context.Context, maddr ad return s.api.StateComputeDataCID(ctx, maddr, sectorType, deals, tsk) } -func (s SealingAPIImpl) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok core.TipSetToken) (*stminer.SectorPreCommitOnChainInfo, error) { +func (s SealingAPIImpl) StateSectorPreCommitInfo( + ctx context.Context, + maddr address.Address, + sectorNumber abi.SectorNumber, + tok core.TipSetToken, +) (*stminer.SectorPreCommitOnChainInfo, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return nil, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -81,7 +92,12 @@ func (s SealingAPIImpl) StateSectorPreCommitInfo(ctx context.Context, maddr addr return pci, nil } -func (s SealingAPIImpl) StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok core.TipSetToken) (*miner.SectorOnChainInfo, error) { +func (s SealingAPIImpl) StateSectorGetInfo( + ctx context.Context, + maddr address.Address, + sectorNumber abi.SectorNumber, + tok core.TipSetToken, +) (*miner.SectorOnChainInfo, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return nil, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -89,7 +105,11 @@ func (s SealingAPIImpl) StateSectorGetInfo(ctx context.Context, maddr address.Ad return s.api.StateSectorGetInfo(ctx, maddr, sectorNumber, tsk) } -func (s SealingAPIImpl) StateMinerSectorSize(ctx context.Context, maddr address.Address, tok core.TipSetToken) (abi.SectorSize, error) { +func (s SealingAPIImpl) StateMinerSectorSize( + ctx context.Context, + maddr address.Address, + tok core.TipSetToken, +) (abi.SectorSize, error) { mi, err := s.StateMinerInfo(ctx, maddr, tok) if err != nil { return 0, err @@ -97,7 +117,12 @@ func (s SealingAPIImpl) StateMinerSectorSize(ctx context.Context, maddr address. return mi.SectorSize, nil } -func (s SealingAPIImpl) StateMinerPreCommitDepositForPower(ctx context.Context, address address.Address, info stminer.SectorPreCommitInfo, token core.TipSetToken) (big.Int, error) { +func (s SealingAPIImpl) StateMinerPreCommitDepositForPower( + ctx context.Context, + address address.Address, + info stminer.SectorPreCommitInfo, + token core.TipSetToken, +) (big.Int, error) { tsk, err := types.TipSetKeyFromBytes(token) if err != nil { return big.Zero(), fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -106,7 +131,12 @@ func (s SealingAPIImpl) StateMinerPreCommitDepositForPower(ctx context.Context, return s.api.StateMinerPreCommitDepositForPower(ctx, address, info, tsk) } -func (s SealingAPIImpl) StateMinerInitialPledgeCollateral(ctx context.Context, address address.Address, info stminer.SectorPreCommitInfo, token core.TipSetToken) (big.Int, error) { +func (s SealingAPIImpl) StateMinerInitialPledgeCollateral( + ctx context.Context, + address address.Address, + info stminer.SectorPreCommitInfo, + token core.TipSetToken, +) (big.Int, error) { tsk, err := types.TipSetKeyFromBytes(token) if err != nil { return big.Zero(), fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -115,7 +145,11 @@ func (s SealingAPIImpl) StateMinerInitialPledgeCollateral(ctx context.Context, a return s.api.StateMinerInitialPledgeCollateral(ctx, address, info, tsk) } -func (s SealingAPIImpl) StateMarketStorageDealProposal(ctx context.Context, id abi.DealID, token core.TipSetToken) (market.DealProposal, error) { +func (s SealingAPIImpl) StateMarketStorageDealProposal( + ctx context.Context, + id abi.DealID, + token core.TipSetToken, +) (market.DealProposal, error) { tsk, err := types.TipSetKeyFromBytes(token) if err != nil { return market.DealProposal{}, err @@ -129,7 +163,11 @@ func (s SealingAPIImpl) StateMarketStorageDealProposal(ctx context.Context, id a return deal.Proposal, nil } -func (s SealingAPIImpl) StateGetAllocationIdForPendingDeal(ctx context.Context, dealID abi.DealID, tst core.TipSetToken) (verifreg.AllocationId, error) { +func (s SealingAPIImpl) StateGetAllocationIdForPendingDeal( + ctx context.Context, + dealID abi.DealID, + tst core.TipSetToken, +) (verifreg.AllocationId, error) { tsk, err := types.TipSetKeyFromBytes(tst) if err != nil { return verifreg.AllocationId(0), err @@ -137,7 +175,11 @@ func (s SealingAPIImpl) StateGetAllocationIdForPendingDeal(ctx context.Context, return s.api.StateGetAllocationIdForPendingDeal(ctx, dealID, tsk) } -func (s SealingAPIImpl) StateGetAllocationForPendingDeal(ctx context.Context, dealID abi.DealID, tst core.TipSetToken) (*types.Allocation, error) { +func (s SealingAPIImpl) StateGetAllocationForPendingDeal( + ctx context.Context, + dealID abi.DealID, + tst core.TipSetToken, +) (*types.Allocation, error) { tsk, err := types.TipSetKeyFromBytes(tst) if err != nil { return nil, err @@ -145,7 +187,12 @@ func (s SealingAPIImpl) StateGetAllocationForPendingDeal(ctx context.Context, de return s.api.StateGetAllocationForPendingDeal(ctx, dealID, tsk) } -func (s SealingAPIImpl) StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationID types.AllocationId, tst core.TipSetToken) (*types.Allocation, error) { +func (s SealingAPIImpl) StateGetAllocation( + ctx context.Context, + clientAddr address.Address, + allocationID types.AllocationId, + tst core.TipSetToken, +) (*types.Allocation, error) { tsk, err := types.TipSetKeyFromBytes(tst) if err != nil { return nil, err @@ -153,7 +200,11 @@ func (s SealingAPIImpl) StateGetAllocation(ctx context.Context, clientAddr addre return s.api.StateGetAllocation(ctx, clientAddr, allocationID, tsk) } -func (s SealingAPIImpl) StateMinerInfo(ctx context.Context, address address.Address, token core.TipSetToken) (types.MinerInfo, error) { +func (s SealingAPIImpl) StateMinerInfo( + ctx context.Context, + address address.Address, + token core.TipSetToken, +) (types.MinerInfo, error) { tsk, err := types.TipSetKeyFromBytes(token) if err != nil { return types.MinerInfo{}, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -163,7 +214,12 @@ func (s SealingAPIImpl) StateMinerInfo(ctx context.Context, address address.Addr return s.api.StateMinerInfo(ctx, address, tsk) } -func (s SealingAPIImpl) StateMinerSectorAllocated(ctx context.Context, address address.Address, number abi.SectorNumber, token core.TipSetToken) (bool, error) { +func (s SealingAPIImpl) StateMinerSectorAllocated( + ctx context.Context, + address address.Address, + number abi.SectorNumber, + token core.TipSetToken, +) (bool, error) { tsk, err := types.TipSetKeyFromBytes(token) if err != nil { return false, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -204,7 +260,12 @@ func (s SealingAPIImpl) ChainBaseFee(ctx context.Context, tok core.TipSetToken) return ts.Blocks()[0].ParentBaseFee, nil } -func (s SealingAPIImpl) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok core.TipSetToken) (*miner.SectorLocation, error) { +func (s SealingAPIImpl) StateSectorPartition( + ctx context.Context, + maddr address.Address, + sectorNumber abi.SectorNumber, + tok core.TipSetToken, +) (*miner.SectorLocation, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return nil, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -224,7 +285,12 @@ func (s SealingAPIImpl) StateSectorPartition(ctx context.Context, maddr address. return nil, nil // not found } -func (s SealingAPIImpl) StateMinerPartitions(ctx context.Context, maddr address.Address, dlIdx uint64, tok core.TipSetToken) ([]chainAPI.Partition, error) { +func (s SealingAPIImpl) StateMinerPartitions( + ctx context.Context, + maddr address.Address, + dlIdx uint64, + tok core.TipSetToken, +) ([]chainapi.Partition, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return nil, fmt.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err) @@ -233,7 +299,11 @@ func (s SealingAPIImpl) StateMinerPartitions(ctx context.Context, maddr address. return s.api.StateMinerPartitions(ctx, maddr, dlIdx, tsk) } -func (s SealingAPIImpl) StateMinerProvingDeadline(ctx context.Context, maddr address.Address, tok core.TipSetToken) (*dline.Info, error) { +func (s SealingAPIImpl) StateMinerProvingDeadline( + ctx context.Context, + maddr address.Address, + tok core.TipSetToken, +) (*dline.Info, error) { tsk, err := types.TipSetKeyFromBytes(tok) if err != nil { return nil, err diff --git a/damocles-manager/modules/impl/commitmgr/sealing_api.go b/damocles-manager/modules/impl/commitmgr/sealing_api.go index 668454869..88113d9ce 100644 --- a/damocles-manager/modules/impl/commitmgr/sealing_api.go +++ b/damocles-manager/modules/impl/commitmgr/sealing_api.go @@ -25,25 +25,69 @@ import ( var ErrSectorAllocated = errors.New("sectorNumber is allocated, but PreCommit info wasn't found on chain") type SealingAPI interface { - StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tok core.TipSetToken) (cid.Cid, error) + StateComputeDataCommitment( + ctx context.Context, + maddr address.Address, + sectorType abi.RegisteredSealProof, + deals []abi.DealID, + tok core.TipSetToken, + ) (cid.Cid, error) // Can return ErrSectorAllocated in case precommit info wasn't found, but the sector number is marked as allocated - StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok core.TipSetToken) (*stminer.SectorPreCommitOnChainInfo, error) - StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok core.TipSetToken) (*miner.SectorOnChainInfo, error) + StateSectorPreCommitInfo( + ctx context.Context, + maddr address.Address, + sectorNumber abi.SectorNumber, + tok core.TipSetToken, + ) (*stminer.SectorPreCommitOnChainInfo, error) + StateSectorGetInfo( + ctx context.Context, + maddr address.Address, + sectorNumber abi.SectorNumber, + tok core.TipSetToken, + ) (*miner.SectorOnChainInfo, error) StateMinerSectorSize(context.Context, address.Address, core.TipSetToken) (abi.SectorSize, error) - StateMinerPreCommitDepositForPower(context.Context, address.Address, stminer.SectorPreCommitInfo, core.TipSetToken) (big.Int, error) - StateMinerInitialPledgeCollateral(context.Context, address.Address, stminer.SectorPreCommitInfo, core.TipSetToken) (big.Int, error) + StateMinerPreCommitDepositForPower( + context.Context, + address.Address, + stminer.SectorPreCommitInfo, + core.TipSetToken, + ) (big.Int, error) + StateMinerInitialPledgeCollateral( + context.Context, + address.Address, + stminer.SectorPreCommitInfo, + core.TipSetToken, + ) (big.Int, error) StateMarketStorageDealProposal(context.Context, abi.DealID, core.TipSetToken) (market.DealProposal, error) - StateGetAllocationIdForPendingDeal(ctx context.Context, dealID abi.DealID, tst core.TipSetToken) (verifreg.AllocationId, error) - StateGetAllocationForPendingDeal(ctx context.Context, dealID abi.DealID, tst core.TipSetToken) (*types.Allocation, error) - StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationID types.AllocationId, tst core.TipSetToken) (*types.Allocation, error) + StateGetAllocationIdForPendingDeal( + ctx context.Context, + dealID abi.DealID, + tst core.TipSetToken, + ) (verifreg.AllocationId, error) + StateGetAllocationForPendingDeal( + ctx context.Context, + dealID abi.DealID, + tst core.TipSetToken, + ) (*types.Allocation, error) + StateGetAllocation( + ctx context.Context, + clientAddr address.Address, + allocationID types.AllocationId, + tst core.TipSetToken, + ) (*types.Allocation, error) StateMinerInfo(context.Context, address.Address, core.TipSetToken) (types.MinerInfo, error) StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, core.TipSetToken) (bool, error) StateNetworkVersion(ctx context.Context, tok core.TipSetToken) (network.Version, error) ChainHead(ctx context.Context) (core.TipSetToken, abi.ChainEpoch, error) ChainBaseFee(ctx context.Context, tok core.TipSetToken) (abi.TokenAmount, error) - StateSectorPartition(context.Context, address.Address, abi.SectorNumber, core.TipSetToken) (*miner.SectorLocation, error) + StateSectorPartition( + context.Context, + address.Address, + abi.SectorNumber, + core.TipSetToken, + ) (*miner.SectorLocation, error) StateMinerPartitions(context.Context, address.Address, uint64, core.TipSetToken) ([]chain.Partition, error) StateMinerProvingDeadline(context.Context, address.Address, core.TipSetToken) (*dline.Info, error) diff --git a/damocles-manager/modules/impl/commitmgr/terminate_processor.go b/damocles-manager/modules/impl/commitmgr/terminate_processor.go index e9dcb3683..2596cd778 100644 --- a/damocles-manager/modules/impl/commitmgr/terminate_processor.go +++ b/damocles-manager/modules/impl/commitmgr/terminate_processor.go @@ -35,7 +35,13 @@ type TerminateProcessor struct { prover core.Prover } -func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors []core.SectorState, from address.Address, mid abi.ActorID, plog *logging.ZapLogger) { +func (tp TerminateProcessor) processIndividually( + ctx context.Context, + sectors []core.SectorState, + from address.Address, + mid abi.ActorID, + plog *logging.ZapLogger, +) { maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { plog.Error("actor id: ", err) @@ -66,6 +72,7 @@ func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors [] } // don't send terminations for currently challenged sectors + //revive:disable-next-line:line-length-limit if loc.Deadline == (dl.Index+1)%stminer.WPoStPeriodDeadlines || // not in next (in case the terminate message takes a while to get on chain) loc.Deadline == dl.Index || // not in current (loc.Deadline+1)%stminer.WPoStPeriodDeadlines == dl.Index { // not in previous @@ -74,7 +81,15 @@ func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors [] ps, err := tp.api.StateMinerPartitions(ctx, maddr, loc.Deadline, nil) if err != nil { - slog.Warn("getting miner partitions", "deadline", loc.Deadline, "partition", loc.Partition, "error", err) + slog.Warn( + "getting miner partitions", + "deadline", + loc.Deadline, + "partition", + loc.Partition, + "error", + err, + ) return } @@ -82,7 +97,15 @@ func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors [] toTerminate.Set(uint64(sectors[idx].ID.Number)) toTerminate, err = bitfield.IntersectBitField(ps[loc.Partition].LiveSectors, toTerminate) if err != nil { - slog.Warn("intersecting liveSectors and toTerminate bitfields", "deadline", loc.Deadline, "partition", loc.Partition, "error", err) + slog.Warn( + "intersecting liveSectors and toTerminate bitfields", + "deadline", + loc.Deadline, + "partition", + loc.Partition, + "error", + err, + ) return } @@ -103,7 +126,17 @@ func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors [] return } - mcid, err := pushMessage(ctx, from, mid, big.Zero(), stbuiltin.MethodsMiner.TerminateSectors, tp.msgClient, &mcfg.Commitment.Terminate.FeeConfig, enc.Bytes(), slog) + mcid, err := pushMessage( + ctx, + from, + mid, + big.Zero(), + stbuiltin.MethodsMiner.TerminateSectors, + tp.msgClient, + &mcfg.Commitment.Terminate.FeeConfig, + enc.Bytes(), + slog, + ) if err != nil { slog.Error("push terminate single failed: ", err) return @@ -118,7 +151,12 @@ func (tp TerminateProcessor) processIndividually(ctx context.Context, sectors [] wg.Wait() } -func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorState, mid abi.ActorID, ctrlAddr address.Address) error { +func (tp TerminateProcessor) Process( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, + ctrlAddr address.Address, +) error { // Notice: If a sector in sectors has been sent, it's cid failed should be changed already. plog := log.With("proc", "terminate", "miner", mid, "ctrl", ctrlAddr.String(), "len", len(sectors)) @@ -190,11 +228,20 @@ func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorS for loc, bfSectors := range todo { n, err := bfSectors.Count() if err != nil { - plog.Error("failed to count sectors to terminate", "deadline", loc.Deadline, "partition", loc.Partition, "error", err) + plog.Error( + "failed to count sectors to terminate", + "deadline", + loc.Deadline, + "partition", + loc.Partition, + "error", + err, + ) continue } // don't send terminations for currently challenged sectors + //revive:disable-next-line:line-length-limit if loc.Deadline == (dl.Index+1)%stminer.WPoStPeriodDeadlines || // not in next (in case the terminate message takes a while to get on chain) loc.Deadline == dl.Index || // not in current (loc.Deadline+1)%stminer.WPoStPeriodDeadlines == dl.Index { // not in previous @@ -220,7 +267,15 @@ func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorS toTerminate, err = bitfield.IntersectBitField(ps[loc.Partition].LiveSectors, toTerminate) if err != nil { - plog.Warn("intersecting liveSectors and toTerminate bitfields", "deadline", loc.Deadline, "partition", loc.Partition, "error", err) + plog.Warn( + "intersecting liveSectors and toTerminate bitfields", + "deadline", + loc.Deadline, + "partition", + loc.Partition, + "error", + err, + ) continue } @@ -229,7 +284,15 @@ func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorS toTerminate, err = toTerminate.Slice(0, n) if err != nil { - plog.Warn("slice toTerminate bitfield", "deadline", loc.Deadline, "partition", loc.Partition, "error", err) + plog.Warn( + "slice toTerminate bitfield", + "deadline", + loc.Deadline, + "partition", + loc.Partition, + "error", + err, + ) continue } @@ -268,7 +331,17 @@ func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorS } mcfg := tp.config.MustMinerConfig(mid) - mcid, err := pushMessage(ctx, ctrlAddr, mid, big.Zero(), stbuiltin.MethodsMiner.TerminateSectors, tp.msgClient, &mcfg.Commitment.Terminate.Batch.FeeConfig, enc.Bytes(), plog) + mcid, err := pushMessage( + ctx, + ctrlAddr, + mid, + big.Zero(), + stbuiltin.MethodsMiner.TerminateSectors, + tp.msgClient, + &mcfg.Commitment.Terminate.Batch.FeeConfig, + enc.Bytes(), + plog, + ) if err != nil { return fmt.Errorf("push aggregate terminate message failed: %w", err) } @@ -297,7 +370,11 @@ func (tp TerminateProcessor) Process(ctx context.Context, sectors []core.SectorS return nil } -func (tp TerminateProcessor) Expire(ctx context.Context, sectors []core.SectorState, mid abi.ActorID) (map[abi.SectorID]struct{}, error) { +func (tp TerminateProcessor) Expire( + ctx context.Context, + sectors []core.SectorState, + mid abi.ActorID, +) (map[abi.SectorID]struct{}, error) { maxWait := tp.config.MustMinerConfig(mid).Commitment.Terminate.Batch.MaxWait.Std() maxWaitHeight := abi.ChainEpoch(maxWait / (builtin.EpochDurationSeconds * time.Second)) _, h, err := tp.api.ChainHead(ctx) @@ -342,7 +419,6 @@ func (tp TerminateProcessor) ShouldBatch(mid abi.ActorID) bool { } return tp.api.ChainBaseFee(ctx, tok) }() - if err != nil { log.Errorf("get basefee: %w", err) return false @@ -350,7 +426,12 @@ func (tp TerminateProcessor) ShouldBatch(mid abi.ActorID) bool { bcfg := tp.config.MustMinerConfig(mid).Commitment.Terminate.Batch basefeeAbove := basefee.GreaterThanEqual(abi.TokenAmount(bcfg.BatchCommitAboveBaseFee)) - bLog.Debugf("should batch(%t): basefee(%s), basefee above(%s)", basefeeAbove, modules.FIL(basefee).Short(), bcfg.BatchCommitAboveBaseFee.Short()) + bLog.Debugf( + "should batch(%t): basefee(%s), basefee above(%s)", + basefeeAbove, + modules.FIL(basefee).Short(), + bcfg.BatchCommitAboveBaseFee.Short(), + ) return basefeeAbove } diff --git a/damocles-manager/modules/impl/dealmgr/dealmgr.go b/damocles-manager/modules/impl/dealmgr/dealmgr.go index c213ee7dd..068785e83 100644 --- a/damocles-manager/modules/impl/dealmgr/dealmgr.go +++ b/damocles-manager/modules/impl/dealmgr/dealmgr.go @@ -32,7 +32,13 @@ type DealManager struct { acquireMu sync.Mutex } -func (dm *DealManager) Acquire(ctx context.Context, sid abi.SectorID, spec core.AcquireDealsSpec, lifetime *core.AcquireDealsLifetime, job core.SectorWorkerJob) (core.SectorPieces, error) { +func (dm *DealManager) Acquire( + ctx context.Context, + sid abi.SectorID, + spec core.AcquireDealsSpec, + lifetime *core.AcquireDealsLifetime, + job core.SectorWorkerJob, +) (core.SectorPieces, error) { mcfg, err := dm.scfg.MinerConfig(sid.Miner) if err != nil { return nil, fmt.Errorf("get miner config: %w", err) @@ -45,7 +51,6 @@ func (dm *DealManager) Acquire(ctx context.Context, sid abi.SectorID, spec core. case core.SectorWorkerJobSnapUp: enabled = mcfg.SnapUp.Enabled - } if !enabled { diff --git a/damocles-manager/modules/impl/mock/commit.go b/damocles-manager/modules/impl/mock/commit.go index d9e876bd5..ffc883e7f 100644 --- a/damocles-manager/modules/impl/mock/commit.go +++ b/damocles-manager/modules/impl/mock/commit.go @@ -36,7 +36,12 @@ type commitMgr struct { } } -func (c *commitMgr) SubmitPreCommit(_ context.Context, sid abi.SectorID, info core.PreCommitInfo, hardReset bool) (core.SubmitPreCommitResp, error) { +func (c *commitMgr) SubmitPreCommit( + _ context.Context, + sid abi.SectorID, + info core.PreCommitInfo, + hardReset bool, +) (core.SubmitPreCommitResp, error) { c.pres.Lock() defer c.pres.Unlock() @@ -74,7 +79,12 @@ func (c *commitMgr) PreCommitState(_ context.Context, sid abi.SectorID) (core.Po }, nil } -func (c *commitMgr) SubmitProof(_ context.Context, sid abi.SectorID, info core.ProofInfo, hardReset bool) (core.SubmitProofResp, error) { +func (c *commitMgr) SubmitProof( + _ context.Context, + sid abi.SectorID, + info core.ProofInfo, + hardReset bool, +) (core.SubmitProofResp, error) { c.proofs.Lock() defer c.proofs.Unlock() @@ -131,6 +141,6 @@ func (c *commitMgr) SubmitTerminate(_ context.Context, sid abi.SectorID) (core.S }, nil } -func (c *commitMgr) TerminateState(context.Context, abi.SectorID) (core.TerminateInfo, error) { +func (*commitMgr) TerminateState(context.Context, abi.SectorID) (core.TerminateInfo, error) { return core.TerminateInfo{}, nil } diff --git a/damocles-manager/modules/impl/mock/deal.go b/damocles-manager/modules/impl/mock/deal.go index 71b60219e..b5fe24d68 100644 --- a/damocles-manager/modules/impl/mock/deal.go +++ b/damocles-manager/modules/impl/mock/deal.go @@ -16,10 +16,15 @@ func NewDealManager() core.DealManager { return &nullDeal{} } -type nullDeal struct { -} - -func (*nullDeal) Acquire(_ context.Context, _ abi.SectorID, spec core.AcquireDealsSpec, _ *core.AcquireDealsLifetime, _ core.SectorWorkerJob) (core.SectorPieces, error) { +type nullDeal struct{} + +func (*nullDeal) Acquire( + _ context.Context, + _ abi.SectorID, + spec core.AcquireDealsSpec, + _ *core.AcquireDealsLifetime, + _ core.SectorWorkerJob, +) (core.SectorPieces, error) { b, err := json.Marshal(spec) if err != nil { return nil, fmt.Errorf("marshal core.AcquireDealsSpec: %w", err) @@ -32,6 +37,7 @@ func (*nullDeal) Acquire(_ context.Context, _ abi.SectorID, spec core.AcquireDea func (*nullDeal) Release(context.Context, abi.SectorID, core.SectorPieces) error { return nil } + func (*nullDeal) ReleaseLegacyDeal(context.Context, abi.SectorID, core.Deals) error { return nil } diff --git a/damocles-manager/modules/impl/mock/randomness.go b/damocles-manager/modules/impl/mock/randomness.go index 97fef4d14..9ec6c1518 100644 --- a/damocles-manager/modules/impl/mock/randomness.go +++ b/damocles-manager/modules/impl/mock/randomness.go @@ -35,7 +35,12 @@ type random struct { wdcommit [32]byte } -func (r *random) GetTicket(_ context.Context, _ types.TipSetKey, epoch abi.ChainEpoch, _ abi.ActorID) (core.Ticket, error) { +func (r *random) GetTicket( + _ context.Context, + _ types.TipSetKey, + epoch abi.ChainEpoch, + _ abi.ActorID, +) (core.Ticket, error) { return core.Ticket{ Ticket: r.ticket[:], Epoch: epoch, @@ -49,14 +54,23 @@ func (r *random) GetSeed(_ context.Context, _ types.TipSetKey, epoch abi.ChainEp }, nil } -func (r *random) GetWindowPoStChanlleengeRand(_ context.Context, _ types.TipSetKey, epoch abi.ChainEpoch, _ abi.ActorID) (core.WindowPoStRandomness, error) { +func (r *random) GetWindowPoStChanlleengeRand( + _ context.Context, + _ types.TipSetKey, + epoch abi.ChainEpoch, + _ abi.ActorID, +) (core.WindowPoStRandomness, error) { return core.WindowPoStRandomness{ Rand: r.wdchallenge[:], Epoch: epoch, }, nil } -func (r *random) GetWindowPoStCommitRand(_ context.Context, _ types.TipSetKey, epoch abi.ChainEpoch) (core.WindowPoStRandomness, error) { +func (r *random) GetWindowPoStCommitRand( + _ context.Context, + _ types.TipSetKey, + epoch abi.ChainEpoch, +) (core.WindowPoStRandomness, error) { return core.WindowPoStRandomness{ Rand: r.wdcommit[:], Epoch: epoch, diff --git a/damocles-manager/modules/impl/mock/sealer.go b/damocles-manager/modules/impl/mock/sealer.go index 26807e031..52722f382 100644 --- a/damocles-manager/modules/impl/mock/sealer.go +++ b/damocles-manager/modules/impl/mock/sealer.go @@ -17,17 +17,22 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/core" "github.com/ipfs-force-community/damocles/damocles-manager/modules" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/ver" ) var _ core.SealerAPI = (*Sealer)(nil) -func NewSealer(rand core.RandomnessAPI, sector core.SectorManager, deal core.DealManager, commit core.CommitmentManager, - api chainAPI.API, scfg modules.SafeConfig, +func NewSealer( + randAPI core.RandomnessAPI, + sector core.SectorManager, + deal core.DealManager, + commit core.CommitmentManager, + api chainapi.API, + scfg modules.SafeConfig, ) (*Sealer, error) { return &Sealer{ - rand: rand, + rand: randAPI, sector: sector, deal: deal, commit: commit, @@ -41,7 +46,7 @@ type Sealer struct { sector core.SectorManager deal core.DealManager commit core.CommitmentManager - api chainAPI.API + api chainapi.API scfg modules.SafeConfig } @@ -56,11 +61,19 @@ func (s *Sealer) AllocateSector(ctx context.Context, spec core.AllocateSectorSpe return nil, nil } -func (s *Sealer) AllocateSectorsBatch(ctx context.Context, spec core.AllocateSectorSpec, count uint32) ([]*core.AllocatedSector, error) { +func (s *Sealer) AllocateSectorsBatch( + ctx context.Context, + spec core.AllocateSectorSpec, + count uint32, +) ([]*core.AllocatedSector, error) { return s.sector.Allocate(ctx, spec, count) } -func (s *Sealer) AcquireDeals(ctx context.Context, sid abi.SectorID, spec core.AcquireDealsSpec) (core.SectorPieces, error) { +func (s *Sealer) AcquireDeals( + ctx context.Context, + sid abi.SectorID, + spec core.AcquireDealsSpec, +) (core.SectorPieces, error) { s.scfg.Lock() mcfg, err := s.scfg.MinerConfig(sid.Miner) s.scfg.Unlock() @@ -86,7 +99,12 @@ func (s *Sealer) AssignTicket(ctx context.Context, sid abi.SectorID) (core.Ticke return s.rand.GetTicket(ctx, types.EmptyTSK, 0, sid.Miner) } -func (s *Sealer) SubmitPreCommit(ctx context.Context, sector core.AllocatedSector, info core.PreCommitOnChainInfo, reset bool) (core.SubmitPreCommitResp, error) { +func (s *Sealer) SubmitPreCommit( + ctx context.Context, + sector core.AllocatedSector, + info core.PreCommitOnChainInfo, + reset bool, +) (core.SubmitPreCommitResp, error) { pinfo, err := info.IntoPreCommitInfo() if err != nil { return core.SubmitPreCommitResp{}, err @@ -116,12 +134,22 @@ func (s *Sealer) SubmitPersisted(ctx context.Context, sid abi.SectorID, instance return s.SubmitPersistedEx(ctx, sid, instance, false) } -func (s *Sealer) SubmitPersistedEx(_ context.Context, sid abi.SectorID, instanceName string, isUpgrade bool) (bool, error) { +func (*Sealer) SubmitPersistedEx( + _ context.Context, + sid abi.SectorID, + instanceName string, + isUpgrade bool, +) (bool, error) { log.Warnf("sector m-%d-s-%d(up=%v) is in the instance %s", sid.Miner, sid.Number, isUpgrade, instanceName) return true, nil } -func (s *Sealer) SubmitProof(ctx context.Context, sid abi.SectorID, info core.ProofInfo, reset bool) (core.SubmitProofResp, error) { +func (s *Sealer) SubmitProof( + ctx context.Context, + sid abi.SectorID, + info core.ProofInfo, + reset bool, +) (core.SubmitProofResp, error) { return s.commit.SubmitProof(ctx, sid, info, reset) } @@ -129,84 +157,109 @@ func (s *Sealer) PollProofState(ctx context.Context, sid abi.SectorID) (core.Pol return s.commit.ProofState(ctx, sid) } -func (s *Sealer) ListSectors(context.Context, core.SectorWorkerState, core.SectorWorkerJob) ([]*core.SectorState, error) { +func (*Sealer) ListSectors( + context.Context, + core.SectorWorkerState, + core.SectorWorkerJob, +) ([]*core.SectorState, error) { return nil, nil } -func (s *Sealer) FindSector(context.Context, core.SectorWorkerState, abi.SectorID) (*core.SectorState, error) { +func (*Sealer) FindSector(context.Context, core.SectorWorkerState, abi.SectorID) (*core.SectorState, error) { return nil, nil } -func (s *Sealer) FindSectorInAllStates(context.Context, abi.SectorID) (*core.SectorState, error) { +func (*Sealer) FindSectorInAllStates(context.Context, abi.SectorID) (*core.SectorState, error) { return nil, nil } -func (s *Sealer) FindSectorsWithDeal(context.Context, core.SectorWorkerState, abi.DealID) ([]*core.SectorState, error) { +func (*Sealer) FindSectorsWithDeal(context.Context, core.SectorWorkerState, abi.DealID) ([]*core.SectorState, error) { return nil, nil } -func (s *Sealer) FindSectorWithPiece(context.Context, core.SectorWorkerState, cid.Cid) (*core.SectorState, error) { +func (*Sealer) FindSectorWithPiece(context.Context, core.SectorWorkerState, cid.Cid) (*core.SectorState, error) { return nil, nil } -func (s *Sealer) ImportSector(context.Context, core.SectorWorkerState, *core.SectorState, bool) (bool, error) { +func (*Sealer) ImportSector(context.Context, core.SectorWorkerState, *core.SectorState, bool) (bool, error) { return false, nil } -func (s *Sealer) RestoreSector(context.Context, abi.SectorID, bool) (core.Meta, error) { +func (*Sealer) RestoreSector(context.Context, abi.SectorID, bool) (core.Meta, error) { return core.Empty, nil } -func (s *Sealer) ReportState(_ context.Context, sid abi.SectorID, req core.ReportStateReq) (*core.SectorStateResp, error) { +func (*Sealer) ReportState( + _ context.Context, + sid abi.SectorID, + req core.ReportStateReq, +) (*core.SectorStateResp, error) { log.Warnf("report state change for m-%d-s-%d: %#v", sid.Miner, sid.Number, req) return &core.SectorStateResp{}, nil } -func (s *Sealer) ReportFinalized(_ context.Context, sid abi.SectorID) (core.Meta, error) { +func (*Sealer) ReportFinalized(_ context.Context, sid abi.SectorID) (core.Meta, error) { log.Warnf("report finalized for m-%d-s-%d", sid.Miner, sid.Number) return core.Empty, nil } -func (s *Sealer) ReportAborted(_ context.Context, sid abi.SectorID, reason string) (core.Meta, error) { +func (*Sealer) ReportAborted(_ context.Context, sid abi.SectorID, reason string) (core.Meta, error) { log.Warnf("report aborted for m-%d-s-%d: %s", sid.Miner, sid.Number, reason) return core.Empty, nil } -func (s *Sealer) CheckProvable(context.Context, abi.ActorID, abi.RegisteredPoStProof, []builtin.ExtendedSectorInfo, bool, bool) (map[abi.SectorNumber]string, error) { +func (*Sealer) CheckProvable( + context.Context, + abi.ActorID, + abi.RegisteredPoStProof, + []builtin.ExtendedSectorInfo, + bool, + bool, +) (map[abi.SectorNumber]string, error) { return nil, nil } -func (s *Sealer) SimulateWdPoSt(context.Context, address.Address, abi.RegisteredPoStProof, []builtin.ExtendedSectorInfo, abi.PoStRandomness) error { +func (*Sealer) SimulateWdPoSt( + context.Context, + address.Address, + abi.RegisteredPoStProof, + []builtin.ExtendedSectorInfo, + abi.PoStRandomness, +) error { return nil } -func (s *Sealer) AllocateSanpUpSector(context.Context, core.AllocateSnapUpSpec) (*core.AllocatedSnapUpSector, error) { - //TODO: impl +func (*Sealer) AllocateSanpUpSector(context.Context, core.AllocateSnapUpSpec) (*core.AllocatedSnapUpSector, error) { + // TODO: impl return nil, nil } -func (s *Sealer) SubmitSnapUpProof(context.Context, abi.SectorID, core.SnapUpOnChainInfo) (core.SubmitSnapUpProofResp, error) { - //TODO: impl +func (*Sealer) SubmitSnapUpProof( + context.Context, + abi.SectorID, + core.SnapUpOnChainInfo, +) (core.SubmitSnapUpProofResp, error) { + // TODO: impl return core.SubmitSnapUpProofResp{Res: core.SubmitAccepted}, nil } -func (s *Sealer) SnapUpPreFetch(context.Context, abi.ActorID, *uint64) (*core.SnapUpFetchResult, error) { +func (*Sealer) SnapUpPreFetch(context.Context, abi.ActorID, *uint64) (*core.SnapUpFetchResult, error) { return &core.SnapUpFetchResult{}, nil } -func (s *Sealer) SnapUpCandidates(context.Context, abi.ActorID) ([]*bitfield.BitField, error) { +func (*Sealer) SnapUpCandidates(context.Context, abi.ActorID) ([]*bitfield.BitField, error) { return nil, nil } -func (s *Sealer) SnapUpCancelCommitment(context.Context, abi.SectorID) error { +func (*Sealer) SnapUpCancelCommitment(context.Context, abi.SectorID) error { return nil } -func (s *Sealer) ProvingSectorInfo(context.Context, abi.SectorID) (core.ProvingSectorInfo, error) { +func (*Sealer) ProvingSectorInfo(context.Context, abi.SectorID) (core.ProvingSectorInfo, error) { return core.ProvingSectorInfo{}, nil } -func (s *Sealer) WorkerPing(_ context.Context, winfo core.WorkerInfo) (core.Meta, error) { +func (*Sealer) WorkerPing(_ context.Context, winfo core.WorkerInfo) (core.Meta, error) { var buf bytes.Buffer enc := json.NewEncoder(&buf) enc.SetIndent("", "\t") @@ -219,19 +272,23 @@ func (s *Sealer) WorkerPing(_ context.Context, winfo core.WorkerInfo) (core.Meta return core.Empty, nil } -func (s *Sealer) WorkerGetPingInfo(context.Context, string) (*core.WorkerPingInfo, error) { +func (*Sealer) WorkerGetPingInfo(context.Context, string) (*core.WorkerPingInfo, error) { return nil, nil } -func (s *Sealer) WorkerPingInfoList(context.Context) ([]core.WorkerPingInfo, error) { +func (*Sealer) WorkerPingInfoList(context.Context) ([]core.WorkerPingInfo, error) { return nil, nil } -func (s *Sealer) WorkerPingInfoRemove(context.Context, string) error { +func (*Sealer) WorkerPingInfoRemove(context.Context, string) error { return nil } -func (s *Sealer) SectorIndexerFind(context.Context, core.SectorIndexType, abi.SectorID) (core.SectorIndexLocation, error) { +func (*Sealer) SectorIndexerFind( + context.Context, + core.SectorIndexType, + abi.SectorID, +) (core.SectorIndexLocation, error) { return core.SectorIndexLocation{ Found: false, Instance: core.SectorAccessStores{}, @@ -246,15 +303,20 @@ func (s *Sealer) PollTerminateSectorState(ctx context.Context, sid abi.SectorID) return s.commit.TerminateState(ctx, sid) } -func (s *Sealer) RemoveSector(context.Context, abi.SectorID) error { +func (*Sealer) RemoveSector(context.Context, abi.SectorID) error { return nil } -func (s *Sealer) FinalizeSector(context.Context, abi.SectorID) error { +func (*Sealer) FinalizeSector(context.Context, abi.SectorID) error { return nil } -func (s *Sealer) StoreReserveSpace(_ context.Context, _ abi.SectorID, _ uint64, candidates []string) (*core.StoreBasicInfo, error) { +func (*Sealer) StoreReserveSpace( + _ context.Context, + _ abi.SectorID, + _ uint64, + candidates []string, +) (*core.StoreBasicInfo, error) { if len(candidates) == 0 { return nil, nil } @@ -271,15 +333,15 @@ func (s *Sealer) StoreReserveSpace(_ context.Context, _ abi.SectorID, _ uint64, }, nil } -func (s *Sealer) StoreReleaseReserved(context.Context, abi.SectorID) (bool, error) { +func (*Sealer) StoreReleaseReserved(context.Context, abi.SectorID) (bool, error) { return true, nil } -func (s *Sealer) StoreList(context.Context) ([]core.StoreDetailedInfo, error) { +func (*Sealer) StoreList(context.Context) ([]core.StoreDetailedInfo, error) { return nil, nil } -func (s *Sealer) StoreBasicInfo(_ context.Context, instanceName string) (*core.StoreBasicInfo, error) { +func (*Sealer) StoreBasicInfo(_ context.Context, instanceName string) (*core.StoreBasicInfo, error) { log.Warnw("get store basic info", "instance", instanceName) return &core.StoreBasicInfo{ Name: instanceName, @@ -288,30 +350,37 @@ func (s *Sealer) StoreBasicInfo(_ context.Context, instanceName string) (*core.S }, nil } -func (s *Sealer) SectorSetForRebuild(context.Context, abi.SectorID, core.RebuildOptions) (bool, error) { +func (*Sealer) SectorSetForRebuild(context.Context, abi.SectorID, core.RebuildOptions) (bool, error) { return false, nil } -func (s *Sealer) AllocateRebuildSector(context.Context, core.AllocateSectorSpec) (*core.SectorRebuildInfo, error) { +func (*Sealer) AllocateRebuildSector(context.Context, core.AllocateSectorSpec) (*core.SectorRebuildInfo, error) { return nil, nil } -func (s *Sealer) UnsealPiece(context.Context, abi.SectorID, cid.Cid, types.UnpaddedByteIndex, abi.UnpaddedPieceSize, string) (<-chan []byte, error) { +func (*Sealer) UnsealPiece( + context.Context, + abi.SectorID, + cid.Cid, + types.UnpaddedByteIndex, + abi.UnpaddedPieceSize, + string, +) (<-chan []byte, error) { return nil, nil } -func (s *Sealer) AllocateUnsealSector(context.Context, core.AllocateSectorSpec) (*core.SectorUnsealInfo, error) { +func (*Sealer) AllocateUnsealSector(context.Context, core.AllocateSectorSpec) (*core.SectorUnsealInfo, error) { return nil, nil } -func (s *Sealer) AchieveUnsealSector(context.Context, abi.SectorID, cid.Cid, string) (core.Meta, error) { +func (*Sealer) AchieveUnsealSector(context.Context, abi.SectorID, cid.Cid, string) (core.Meta, error) { return nil, nil } -func (s *Sealer) AcquireUnsealDest(context.Context, abi.SectorID, cid.Cid) ([]string, error) { +func (*Sealer) AcquireUnsealDest(context.Context, abi.SectorID, cid.Cid) ([]string, error) { return nil, nil } -func (s *Sealer) Version(context.Context) (string, error) { +func (*Sealer) Version(context.Context) (string, error) { return ver.VersionStr(), nil } diff --git a/damocles-manager/modules/impl/mock/sector.go b/damocles-manager/modules/impl/mock/sector.go index 00a0acb86..f3ce3bc23 100644 --- a/damocles-manager/modules/impl/mock/sector.go +++ b/damocles-manager/modules/impl/mock/sector.go @@ -26,7 +26,11 @@ type sectorMgr struct { sectorNum uint64 } -func (s *sectorMgr) Allocate(_ context.Context, spec core.AllocateSectorSpec, count uint32) ([]*core.AllocatedSector, error) { +func (s *sectorMgr) Allocate( + _ context.Context, + spec core.AllocateSectorSpec, + count uint32, +) ([]*core.AllocatedSector, error) { allowedMiners := spec.AllowedMiners allowedProofTypes := spec.AllowedProofTypes if count == 0 { diff --git a/damocles-manager/modules/impl/prover/ext/prover.go b/damocles-manager/modules/impl/prover/ext/prover.go index b462bffd1..a1cf72c1b 100644 --- a/damocles-manager/modules/impl/prover/ext/prover.go +++ b/damocles-manager/modules/impl/prover/ext/prover.go @@ -19,7 +19,12 @@ var log = logging.New("ext-prover") var _ core.Prover = (*Prover)(nil) -func New(ctx context.Context, sectorTracker core.SectorTracker, windowCfgs []extproc.ExtProcessorConfig, winningCfgs []extproc.ExtProcessorConfig) (*Prover, error) { +func New( + ctx context.Context, + sectorTracker core.SectorTracker, + windowCfgs []extproc.ExtProcessorConfig, + winningCfgs []extproc.ExtProcessorConfig, +) (*Prover, error) { var windowProc, winningPorc *extproc.Processor var err error if len(windowCfgs) > 0 { @@ -79,12 +84,18 @@ func (p *Prover) Close() { } } -func (p *Prover) AggregateSealProofs(ctx context.Context, aggregateInfo core.AggregateSealVerifyProofAndInfos, proofs [][]byte) ([]byte, error) { +func (p *Prover) AggregateSealProofs( + ctx context.Context, + aggregateInfo core.AggregateSealVerifyProofAndInfos, + proofs [][]byte, +) ([]byte, error) { return p.localProver.AggregateSealProofs(ctx, aggregateInfo, proofs) } -func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWindowPoStParams) ([]builtin.PoStProof, []abi.SectorID, error) { - +func (p *Prover) GenerateWindowPoSt( + ctx context.Context, + params core.GenerateWindowPoStParams, +) ([]builtin.PoStProof, []abi.SectorID, error) { if p.windowProc == nil { return p.localProver.GenerateWindowPoSt(ctx, params) } @@ -109,12 +120,24 @@ func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWin inner := privSectors[i] if pt := inner.PoStProofType; pt != proofType { - return nil, nil, fmt.Errorf("proof type not match for sector %d of miner %d: want %s, got %s", inner.SectorNumber, minerID, stage.ProofType2String(proofType), stage.ProofType2String(pt)) + return nil, nil, fmt.Errorf( + "proof type not match for sector %d of miner %d: want %s, got %s", + inner.SectorNumber, + minerID, + stage.ProofType2String(proofType), + stage.ProofType2String(pt), + ) } commR, err := util.CID2ReplicaCommitment(inner.SealedCID) if err != nil { - return nil, nil, fmt.Errorf("invalid selaed cid %s for sector %d of miner %d: %w", inner.SealedCID, inner.SectorNumber, minerID, err) + return nil, nil, fmt.Errorf( + "invalid selaed cid %s for sector %d of miner %d: %w", + inner.SealedCID, + inner.SectorNumber, + minerID, + err, + ) } data.Replicas = append(data.Replicas, stage.PoStReplicaInfo{ @@ -129,7 +152,7 @@ func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWin err = p.windowProc.Process(ctx, data, &res) if err != nil { - return nil, nil, fmt.Errorf("WindowPoStProcessor.Process: %w", err) + return nil, nil, fmt.Errorf("WindowPoStProcessor.Process: %w", err) //revive:disable-line:error-strings } if faultCount := len(res.Faults); faultCount != 0 { @@ -154,7 +177,13 @@ func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWin return proofs, nil, nil } -func (p *Prover) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, proofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]builtin.PoStProof, error) { +func (p *Prover) GenerateWinningPoSt( + ctx context.Context, + minerID abi.ActorID, + proofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + randomness abi.PoStRandomness, +) ([]builtin.PoStProof, error) { randomness[31] &= 0x3f if p.winningPorc == nil { return p.localProver.GenerateWinningPoSt(ctx, minerID, proofType, sectors, randomness) @@ -179,12 +208,24 @@ func (p *Prover) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, p inner := privSectors[i] if pt := inner.PoStProofType; pt != proofType { - return nil, fmt.Errorf("proof type not match for sector %d of miner %d: want %s, got %s", inner.SectorNumber, minerID, stage.ProofType2String(proofType), stage.ProofType2String(pt)) + return nil, fmt.Errorf( + "proof type not match for sector %d of miner %d: want %s, got %s", + inner.SectorNumber, + minerID, + stage.ProofType2String(proofType), + stage.ProofType2String(pt), + ) } commR, err := util.CID2ReplicaCommitment(inner.SealedCID) if err != nil { - return nil, fmt.Errorf("invalid sealed cid %s for sector %d of miner %d: %w", inner.SealedCID, inner.SectorNumber, minerID, err) + return nil, fmt.Errorf( + "invalid sealed cid %s for sector %d of miner %d: %w", + inner.SealedCID, + inner.SectorNumber, + minerID, + err, + ) } data.Replicas = append(data.Replicas, stage.PoStReplicaInfo{ @@ -199,7 +240,7 @@ func (p *Prover) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, p err = p.winningPorc.Process(ctx, data, &res) if err != nil { - return nil, fmt.Errorf("WinningPoStProcessor.Process: %w", err) + return nil, fmt.Errorf("WinningPoStProcessor.Process: %w", err) //revive:disable-line:error-strings } proofs := make([]builtin.PoStProof, len(res.Proofs)) @@ -213,16 +254,32 @@ func (p *Prover) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, p return proofs, nil } -func (p *Prover) GeneratePoStFallbackSectorChallenges(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, sectorIds []abi.SectorNumber) (*core.FallbackChallenges, error) { +func (p *Prover) GeneratePoStFallbackSectorChallenges( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + sectorIds []abi.SectorNumber, +) (*core.FallbackChallenges, error) { randomness[31] &= 0x3f return p.localProver.GeneratePoStFallbackSectorChallenges(ctx, proofType, minerID, randomness, sectorIds) } -func (p *Prover) GenerateSingleVanillaProof(ctx context.Context, replica core.FFIPrivateSectorInfo, challenges []uint64) ([]byte, error) { +func (p *Prover) GenerateSingleVanillaProof( + ctx context.Context, + replica core.FFIPrivateSectorInfo, + challenges []uint64, +) ([]byte, error) { return p.localProver.GenerateSingleVanillaProof(ctx, replica, challenges) } -func (p *Prover) GenerateWinningPoStWithVanilla(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte) ([]core.PoStProof, error) { +func (p *Prover) GenerateWinningPoStWithVanilla( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + proofs [][]byte, +) ([]core.PoStProof, error) { randomness[31] &= 0x3f return p.localProver.GenerateWinningPoStWithVanilla(ctx, proofType, minerID, randomness, proofs) } diff --git a/damocles-manager/modules/impl/prover/prover_fake.go b/damocles-manager/modules/impl/prover/prover_fake.go index 8a3708bb9..8cc91b605 100644 --- a/damocles-manager/modules/impl/prover/prover_fake.go +++ b/damocles-manager/modules/impl/prover/prover_fake.go @@ -14,8 +14,7 @@ func NewFakeVerifier() core.Verifier { return &fakeVerifier{} } -type fakeVerifier struct { -} +type fakeVerifier struct{} func (fakeVerifier) VerifySeal(context.Context, core.SealVerifyInfo) (bool, error) { return false, nil @@ -37,22 +36,40 @@ func NewFakeProver() core.Prover { return &fakeProver{} } -type fakeProver struct { -} +type fakeProver struct{} -func (fakeProver) AggregateSealProofs(context.Context, core.AggregateSealVerifyProofAndInfos, [][]byte) ([]byte, error) { +func (fakeProver) AggregateSealProofs( + context.Context, + core.AggregateSealVerifyProofAndInfos, + [][]byte, +) ([]byte, error) { return make([]byte, 32), nil } -func (fakeProver) GenerateWindowPoSt(context.Context, core.GenerateWindowPoStParams) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { +func (fakeProver) GenerateWindowPoSt( + context.Context, + core.GenerateWindowPoStParams, +) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { return nil, nil, nil } -func (fakeProver) GenerateWinningPoSt(context.Context, abi.ActorID, abi.RegisteredPoStProof, []builtin.ExtendedSectorInfo, abi.PoStRandomness) ([]builtin.PoStProof, error) { +func (fakeProver) GenerateWinningPoSt( + context.Context, + abi.ActorID, + abi.RegisteredPoStProof, + []builtin.ExtendedSectorInfo, + abi.PoStRandomness, +) ([]builtin.PoStProof, error) { return nil, nil } -func (fakeProver) GeneratePoStFallbackSectorChallenges(context.Context, abi.RegisteredPoStProof, abi.ActorID, abi.PoStRandomness, []abi.SectorNumber) (*core.FallbackChallenges, error) { +func (fakeProver) GeneratePoStFallbackSectorChallenges( + context.Context, + abi.RegisteredPoStProof, + abi.ActorID, + abi.PoStRandomness, + []abi.SectorNumber, +) (*core.FallbackChallenges, error) { return nil, nil } @@ -60,6 +77,12 @@ func (fakeProver) GenerateSingleVanillaProof(context.Context, core.FFIPrivateSec return nil, nil } -func (fakeProver) GenerateWinningPoStWithVanilla(context.Context, abi.RegisteredPoStProof, abi.ActorID, abi.PoStRandomness, [][]byte) ([]core.PoStProof, error) { +func (fakeProver) GenerateWinningPoStWithVanilla( + context.Context, + abi.RegisteredPoStProof, + abi.ActorID, + abi.PoStRandomness, + [][]byte, +) ([]core.PoStProof, error) { return nil, nil } diff --git a/damocles-manager/modules/impl/prover/prover_prod.go b/damocles-manager/modules/impl/prover/prover_prod.go index 606aae27a..08cee46cc 100644 --- a/damocles-manager/modules/impl/prover/prover_prod.go +++ b/damocles-manager/modules/impl/prover/prover_prod.go @@ -20,14 +20,16 @@ func NewProdVerifier() core.Verifier { return &prodVerifier{} } -type prodVerifier struct { -} +type prodVerifier struct{} func (prodVerifier) VerifySeal(_ context.Context, svi core.SealVerifyInfo) (bool, error) { return ffi.VerifySeal(svi) } -func (prodVerifier) VerifyAggregateSeals(_ context.Context, aggregate core.AggregateSealVerifyProofAndInfos) (bool, error) { +func (prodVerifier) VerifyAggregateSeals( + _ context.Context, + aggregate core.AggregateSealVerifyProofAndInfos, +) (bool, error) { return ffi.VerifyAggregateSeals(aggregate) } @@ -51,11 +53,18 @@ type prodProver struct { sectorTracker core.SectorTracker } -func (prodProver) AggregateSealProofs(_ context.Context, aggregateInfo core.AggregateSealVerifyProofAndInfos, proofs [][]byte) ([]byte, error) { +func (prodProver) AggregateSealProofs( + _ context.Context, + aggregateInfo core.AggregateSealVerifyProofAndInfos, + proofs [][]byte, +) ([]byte, error) { return ffi.AggregateSealProofs(aggregateInfo, proofs) } -func (p prodProver) GenerateWindowPoSt(ctx context.Context, params core.GenerateWindowPoStParams) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { +func (p prodProver) GenerateWindowPoSt( + ctx context.Context, + params core.GenerateWindowPoStParams, +) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { minerID, proofType, sectors, randomness := params.MinerID, params.ProofType, params.Sectors, params.Randomness randomness[31] &= 0x3f @@ -66,18 +75,24 @@ func (p prodProver) GenerateWindowPoSt(ctx context.Context, params core.Generate proof, faulty, err := ffi.GenerateWindowPoSt(minerID, core.NewSortedPrivateSectorInfo(privSectors...), randomness) - var faultyIDs []abi.SectorID - for _, f := range faulty { - faultyIDs = append(faultyIDs, abi.SectorID{ + faultyIDs := make([]abi.SectorID, len(faulty)) + for i, f := range faulty { + faultyIDs[i] = abi.SectorID{ Miner: minerID, Number: f, - }) + } } return proof, faultyIDs, err } -func (p prodProver) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, ppt abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]builtin.PoStProof, error) { +func (p prodProver) GenerateWinningPoSt( + ctx context.Context, + minerID abi.ActorID, + ppt abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + randomness abi.PoStRandomness, +) ([]builtin.PoStProof, error) { randomness[31] &= 0x3f privSectors, err := p.sectorTracker.PubToPrivate(ctx, minerID, ppt, sectors) @@ -88,12 +103,22 @@ func (p prodProver) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID return ffi.GenerateWinningPoSt(minerID, core.NewSortedPrivateSectorInfo(privSectors...), randomness) } -func (prodProver) GeneratePoStFallbackSectorChallenges(_ context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, sectorIds []abi.SectorNumber) (*core.FallbackChallenges, error) { +func (prodProver) GeneratePoStFallbackSectorChallenges( + _ context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + sectorIds []abi.SectorNumber, +) (*core.FallbackChallenges, error) { randomness[31] &= 0x3f return ffi.GeneratePoStFallbackSectorChallenges(proofType, minerID, randomness, sectorIds) } -func (prodProver) GenerateSingleVanillaProof(ctx context.Context, replica core.FFIPrivateSectorInfo, challenges []uint64) ([]byte, error) { +func (prodProver) GenerateSingleVanillaProof( + ctx context.Context, + replica core.FFIPrivateSectorInfo, + challenges []uint64, +) ([]byte, error) { start := time.Now() resCh := make(chan core.Result[[]byte], 1) @@ -105,14 +130,30 @@ func (prodProver) GenerateSingleVanillaProof(ctx context.Context, replica core.F case r := <-resCh: return r.Unwrap() case <-ctx.Done(): - log.Errorw("failed to generate valilla PoSt proof before context cancellation", "err", ctx.Err(), "duration", time.Since(start), "cache", replica.CacheDirPath, "sealed", replica.SealedSectorPath) + log.Errorw( + "failed to generate valilla PoSt proof before context cancellation", + "err", + ctx.Err(), + "duration", + time.Since(start), + "cache", + replica.CacheDirPath, + "sealed", + replica.SealedSectorPath, + ) // this will leave the GenerateSingleVanillaProof goroutine hanging, but that's still less bad than failing PoSt return nil, fmt.Errorf("failed to generate vanilla proof before context cancellation: %w", ctx.Err()) } } -func (prodProver) GenerateWinningPoStWithVanilla(_ context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte) ([]core.PoStProof, error) { +func (prodProver) GenerateWinningPoStWithVanilla( + _ context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + proofs [][]byte, +) ([]core.PoStProof, error) { randomness[31] &= 0x3f return ffi.GenerateWinningPoStWithVanilla(proofType, minerID, randomness, proofs) } diff --git a/damocles-manager/modules/impl/prover/worker/job_mgr_kv.go b/damocles-manager/modules/impl/prover/worker/job_mgr_kv.go index d8abc0e7f..14de1990d 100644 --- a/damocles-manager/modules/impl/prover/worker/job_mgr_kv.go +++ b/damocles-manager/modules/impl/prover/worker/job_mgr_kv.go @@ -27,7 +27,13 @@ type kvJobManager struct { } // TODO(0x5459): Consider putting `txn` into context? -func (tm *kvJobManager) filter(ctx context.Context, txn kvstore.TxnExt, state core.WdPoStJobState, limit uint32, f func(*core.WdPoStJob) bool) (jobs []*core.WdPoStJob, err error) { +func (*kvJobManager) filter( + ctx context.Context, + txn kvstore.TxnExt, + state core.WdPoStJobState, + limit uint32, + f func(*core.WdPoStJob) bool, +) (jobs []*core.WdPoStJob, err error) { var it kvstore.Iter it, err = txn.Scan(kvstore.Prefix(makeWdPoStPrefix(state))) if err != nil { @@ -50,7 +56,10 @@ func allStates() []core.WdPoStJobState { return []core.WdPoStJobState{core.WdPoStJobReadyToRun, core.WdPoStJobRunning, core.WdPoStJobFinished} } -func (tm *kvJobManager) All(ctx context.Context, filter func(*core.WdPoStJob) bool) (jobs []*core.WdPoStJob, err error) { +func (tm *kvJobManager) All( + ctx context.Context, + filter func(*core.WdPoStJob) bool, +) (jobs []*core.WdPoStJob, err error) { jobs = make([]*core.WdPoStJob, 0) err = tm.kv.ViewMustNoConflict(ctx, func(txn kvstore.TxnExt) error { jobs = jobs[:0] @@ -91,7 +100,12 @@ func (tm *kvJobManager) ListByJobIDs(ctx context.Context, jobIDs ...string) ([]* return jobs, err } -func (tm *kvJobManager) Create(ctx context.Context, deadlineIdx uint64, partitions []uint64, input core.WdPoStInput) (*core.WdPoStJob, error) { +func (tm *kvJobManager) Create( + ctx context.Context, + deadlineIdx uint64, + partitions []uint64, + input core.WdPoStInput, +) (*core.WdPoStJob, error) { var ( jobID string job core.WdPoStJob @@ -134,7 +148,7 @@ func (tm *kvJobManager) Create(ctx context.Context, deadlineIdx uint64, partitio CreatedAt: uint64(now), UpdatedAt: uint64(now), } - return txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, jobID)), &job) + return txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, jobID)), &job) }) if err == nil { @@ -143,7 +157,12 @@ func (tm *kvJobManager) Create(ctx context.Context, deadlineIdx uint64, partitio return &job, err } -func (tm *kvJobManager) AllocateJobs(ctx context.Context, spec core.AllocateWdPoStJobSpec, n uint32, workerName string) (allocatedJobs []*core.WdPoStAllocatedJob, err error) { +func (tm *kvJobManager) AllocateJobs( + ctx context.Context, + spec core.AllocateWdPoStJobSpec, + n uint32, + workerName string, +) (allocatedJobs []*core.WdPoStAllocatedJob, err error) { var readyToRun []*core.WdPoStJob allocatedJobs = make([]*core.WdPoStAllocatedJob, 0) err = tm.kv.UpdateMustNoConflict(ctx, func(txn kvstore.TxnExt) error { @@ -172,7 +191,7 @@ func (tm *kvJobManager) AllocateJobs(ctx context.Context, spec core.AllocateWdPo job.WorkerName = workerName job.HeartbeatAt = now job.UpdatedAt = now - if err := txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobRunning, job.ID)), job); err != nil { + if err := txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobRunning, job.ID)), job); err != nil { return err } allocatedJobs = append(allocatedJobs, &core.WdPoStAllocatedJob{ @@ -220,10 +239,9 @@ func (tm *kvJobManager) Heartbeat(ctx context.Context, jobIDs []string, workerNa job.WorkerName = workerName job.State = string(core.WdPoStJobRunning) job.UpdatedAt = now - if err := txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobRunning, jobID)), &job); err != nil { + if err := txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobRunning, jobID)), &job); err != nil { return err } - } return nil }) @@ -233,7 +251,12 @@ func (tm *kvJobManager) Heartbeat(ctx context.Context, jobIDs []string, workerNa return err } -func (tm *kvJobManager) Finish(ctx context.Context, jobID string, output *stage.WindowPoStOutput, errorReason string) error { +func (tm *kvJobManager) Finish( + ctx context.Context, + jobID string, + output *stage.WindowPoStOutput, + errorReason string, +) error { err := tm.kv.UpdateMustNoConflict(ctx, func(txn kvstore.TxnExt) error { var job core.WdPoStJob key, err := txn.PeekAny( @@ -254,7 +277,7 @@ func (tm *kvJobManager) Finish(ctx context.Context, jobID string, output *stage. job.ErrorReason = errorReason job.FinishedAt = now job.UpdatedAt = now - return txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobFinished, jobID)), &job) + return txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobFinished, jobID)), &job) }) if err == nil { @@ -289,7 +312,7 @@ func (tm *kvJobManager) MakeJobsDie(ctx context.Context, heartbeatTimeout time.D job.Output = nil job.ErrorReason = "heartbeat timeout" job.UpdatedAt = now - if err := txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobFinished, job.ID)), job); err != nil { + if err := txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobFinished, job.ID)), job); err != nil { return err } } @@ -298,7 +321,11 @@ func (tm *kvJobManager) MakeJobsDie(ctx context.Context, heartbeatTimeout time.D if err == nil { for _, job := range shouldDead { - log.Infof("make wdPoSt job die: %s; heartbeat_at: %s", job.ID, time.Unix(int64(job.HeartbeatAt), 0).Format(time.RFC3339)) + log.Infof( + "make wdPoSt job die: %s; heartbeat_at: %s", + job.ID, + time.Unix(int64(job.HeartbeatAt), 0).Format(time.RFC3339), + ) } } @@ -355,7 +382,7 @@ func (tm *kvJobManager) RetryFailedJobs(ctx context.Context, maxTry, limit uint3 job.StartedAt = 0 job.FinishedAt = 0 job.UpdatedAt = now - if err := txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, job.ID)), job); err != nil { + if err := txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, job.ID)), job); err != nil { return err } } @@ -400,7 +427,7 @@ func (tm *kvJobManager) Reset(ctx context.Context, jobID string) error { if err := txn.Del(key); err != nil { return err } - return txn.PutJson(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, jobID)), &job) + return txn.PutJSON(kvstore.Key(makeWdPoStKey(core.WdPoStJobReadyToRun, jobID)), &job) }) if err == nil { @@ -446,7 +473,6 @@ func makeWdPoStKey(state core.WdPoStJobState, jobID string) string { return fmt.Sprintf("%s%s%s", makeWdPoStPrefix(state), prefixJobIDdelimiter, jobID) } -//lint:ignore U1000 Ignore unused function func splitKey(key string) (state core.WdPoStJobState, jobID string) { x := strings.SplitN(key, prefixJobIDdelimiter, 2) return core.WdPoStJobState(x[0]), x[1] diff --git a/damocles-manager/modules/impl/prover/worker/job_mgr_kv_test.go b/damocles-manager/modules/impl/prover/worker/job_mgr_kv_test.go index 56dc5a167..ead6295fa 100644 --- a/damocles-manager/modules/impl/prover/worker/job_mgr_kv_test.go +++ b/damocles-manager/modules/impl/prover/worker/job_mgr_kv_test.go @@ -13,7 +13,7 @@ import ( func TestSplitKey(t *testing.T) { for _, jobID := range []string{"normal123", "with-", "-", "-with", "wi-th", "with:xxx", ":xxx", ":"} { - for _, state := range []core.WdPoStJobState{core.WdPoStJobReadyToRun, core.WdPoStJobRunning, core.WdPoStJobFinished} { + for _, state := range []core.WdPoStJobState{core.WdPoStJobReadyToRun, core.WdPoStJobRunning, core.WdPoStJobFinished} { //revive:disable-line:line-length-limit actualState, actualJobID := splitKey(makeWdPoStKey(state, jobID)) require.Equalf(t, state, actualState, "test state for \"state: `%s`; jobID: `%s`\"", state, jobID) require.Equalf(t, jobID, actualJobID, "test jobID for \"state: `%s`; jobID: `%s`\"", state, jobID) diff --git a/damocles-manager/modules/impl/prover/worker/prover.go b/damocles-manager/modules/impl/prover/worker/prover.go index 5c30143a4..b2d1d5cb4 100644 --- a/damocles-manager/modules/impl/prover/worker/prover.go +++ b/damocles-manager/modules/impl/prover/worker/prover.go @@ -194,11 +194,19 @@ func (p *Prover) runCleanupExpiredJobs(ctx context.Context) { } } -func (p *Prover) AggregateSealProofs(ctx context.Context, aggregateInfo core.AggregateSealVerifyProofAndInfos, proofs [][]byte) ([]byte, error) { +func (p *Prover) AggregateSealProofs( + ctx context.Context, + aggregateInfo core.AggregateSealVerifyProofAndInfos, + proofs [][]byte, +) ([]byte, error) { return p.localProver.AggregateSealProofs(ctx, aggregateInfo, proofs) } -func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWindowPoStParams) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { +func (p *Prover) GenerateWindowPoSt( + ctx context.Context, + params core.GenerateWindowPoStParams, +) (proof []builtin.PoStProof, skipped []abi.SectorID, err error) { + //revive:disable-next-line:line-length-limit deadlineIdx, partitions, minerID, proofType, sectors, randomness := params.DeadlineIdx, params.Partitions, params.MinerID, params.ProofType, params.Sectors, params.Randomness randomness[31] &= 0x3f @@ -211,7 +219,13 @@ func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWin } commR, err := util.CID2ReplicaCommitment(s.SealedCID) if err != nil { - return nil, nil, fmt.Errorf("invalid sealed cid %s for sector %d of miner %d: %w", s.SealedCID, s.SectorNumber, minerID, err) + return nil, nil, fmt.Errorf( + "invalid sealed cid %s for sector %d of miner %d: %w", + s.SealedCID, + s.SectorNumber, + minerID, + err, + ) } sis[i] = core.WdPoStSectorInfo{ @@ -264,7 +278,12 @@ func (p *Prover) GenerateWindowPoSt(ctx context.Context, params core.GenerateWin return proofs, nil, nil } -func (p *Prover) doWindowPoSt(ctx context.Context, deadlineIdx uint64, partitions []uint64, input core.WdPoStInput) (output *stage.WindowPoStOutput, err error) { +func (p *Prover) doWindowPoSt( + ctx context.Context, + deadlineIdx uint64, + partitions []uint64, + input core.WdPoStInput, +) (output *stage.WindowPoStOutput, err error) { job, err := p.jobMgr.Create(ctx, deadlineIdx, partitions, input) if err != nil { return nil, fmt.Errorf("create wdPoSt job: %w", err) @@ -290,18 +309,40 @@ func (p *Prover) doWindowPoSt(ctx context.Context, deadlineIdx uint64, partition return } -func (p *Prover) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, proofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]builtin.PoStProof, error) { +func (p *Prover) GenerateWinningPoSt( + ctx context.Context, + minerID abi.ActorID, + proofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + randomness abi.PoStRandomness, +) ([]builtin.PoStProof, error) { return p.localProver.GenerateWinningPoSt(ctx, minerID, proofType, sectors, randomness) } -func (p *Prover) GeneratePoStFallbackSectorChallenges(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, sectorIds []abi.SectorNumber) (*core.FallbackChallenges, error) { +func (p *Prover) GeneratePoStFallbackSectorChallenges( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + sectorIds []abi.SectorNumber, +) (*core.FallbackChallenges, error) { return p.localProver.GeneratePoStFallbackSectorChallenges(ctx, proofType, minerID, randomness, sectorIds) } -func (p *Prover) GenerateSingleVanillaProof(ctx context.Context, replica core.FFIPrivateSectorInfo, challenges []uint64) ([]byte, error) { +func (p *Prover) GenerateSingleVanillaProof( + ctx context.Context, + replica core.FFIPrivateSectorInfo, + challenges []uint64, +) ([]byte, error) { return p.localProver.GenerateSingleVanillaProof(ctx, replica, challenges) } -func (p *Prover) GenerateWinningPoStWithVanilla(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte) ([]core.PoStProof, error) { +func (p *Prover) GenerateWinningPoStWithVanilla( + ctx context.Context, + proofType abi.RegisteredPoStProof, + minerID abi.ActorID, + randomness abi.PoStRandomness, + proofs [][]byte, +) ([]core.PoStProof, error) { return p.localProver.GenerateWinningPoStWithVanilla(ctx, proofType, minerID, randomness, proofs) } diff --git a/damocles-manager/modules/impl/prover/worker/rpc.go b/damocles-manager/modules/impl/prover/worker/rpc.go index 03bebcdcf..8e0dce069 100644 --- a/damocles-manager/modules/impl/prover/worker/rpc.go +++ b/damocles-manager/modules/impl/prover/worker/rpc.go @@ -24,15 +24,29 @@ type WdPoStAPIImpl struct { cfg modules.WorkerProverConfig } -func (api WdPoStAPIImpl) WdPoStHeartbeatJobs(ctx context.Context, runningJobIDs []string, workerName string) (core.Meta, error) { +func (api WdPoStAPIImpl) WdPoStHeartbeatJobs( + ctx context.Context, + runningJobIDs []string, + workerName string, +) (core.Meta, error) { return nil, api.jobMgr.Heartbeat(ctx, runningJobIDs, workerName) } -func (api WdPoStAPIImpl) WdPoStAllocateJobs(ctx context.Context, spec core.AllocateWdPoStJobSpec, num uint32, workerName string) (allocatedJobs []*core.WdPoStAllocatedJob, err error) { +func (api WdPoStAPIImpl) WdPoStAllocateJobs( + ctx context.Context, + spec core.AllocateWdPoStJobSpec, + num uint32, + workerName string, +) (allocatedJobs []*core.WdPoStAllocatedJob, err error) { return api.jobMgr.AllocateJobs(ctx, spec, num, workerName) } -func (api WdPoStAPIImpl) WdPoStFinishJob(ctx context.Context, jobID string, output *stage.WindowPoStOutput, errorReason string) (core.Meta, error) { +func (api WdPoStAPIImpl) WdPoStFinishJob( + ctx context.Context, + jobID string, + output *stage.WindowPoStOutput, + errorReason string, +) (core.Meta, error) { return nil, api.jobMgr.Finish(ctx, jobID, output, errorReason) } diff --git a/damocles-manager/modules/impl/randomness/rand.go b/damocles-manager/modules/impl/randomness/rand.go index 66c3e14bc..1283e192a 100644 --- a/damocles-manager/modules/impl/randomness/rand.go +++ b/damocles-manager/modules/impl/randomness/rand.go @@ -26,7 +26,7 @@ type Randomness struct { api chain.API } -func (r *Randomness) getRandomnessEntropy(mid abi.ActorID) ([]byte, error) { +func (*Randomness) getRandomnessEntropy(mid abi.ActorID) ([]byte, error) { maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { return nil, err @@ -40,7 +40,12 @@ func (r *Randomness) getRandomnessEntropy(mid abi.ActorID) ([]byte, error) { return buf.Bytes(), nil } -func (r *Randomness) GetTicket(ctx context.Context, tsk types.TipSetKey, epoch abi.ChainEpoch, mid abi.ActorID) (core.Ticket, error) { +func (r *Randomness) GetTicket( + ctx context.Context, + tsk types.TipSetKey, + epoch abi.ChainEpoch, + mid abi.ActorID, +) (core.Ticket, error) { entropy, err := r.getRandomnessEntropy(mid) if err != nil { return core.Ticket{}, err @@ -55,7 +60,13 @@ func (r *Randomness) GetTicket(ctx context.Context, tsk types.TipSetKey, epoch a tsk = ts.Key() } - rand, err := r.api.StateGetRandomnessFromTickets(ctx, crypto.DomainSeparationTag_SealRandomness, epoch, entropy, tsk) + rand, err := r.api.StateGetRandomnessFromTickets( + ctx, + crypto.DomainSeparationTag_SealRandomness, + epoch, + entropy, + tsk, + ) if err != nil { return core.Ticket{}, err } @@ -66,7 +77,12 @@ func (r *Randomness) GetTicket(ctx context.Context, tsk types.TipSetKey, epoch a }, nil } -func (r *Randomness) GetSeed(ctx context.Context, tsk types.TipSetKey, epoch abi.ChainEpoch, mid abi.ActorID) (core.Seed, error) { +func (r *Randomness) GetSeed( + ctx context.Context, + tsk types.TipSetKey, + epoch abi.ChainEpoch, + mid abi.ActorID, +) (core.Seed, error) { entropy, err := r.getRandomnessEntropy(mid) if err != nil { return core.Seed{}, err @@ -81,7 +97,13 @@ func (r *Randomness) GetSeed(ctx context.Context, tsk types.TipSetKey, epoch abi tsk = ts.Key() } - rand, err := r.api.StateGetRandomnessFromBeacon(ctx, crypto.DomainSeparationTag_InteractiveSealChallengeSeed, epoch, entropy, tsk) + rand, err := r.api.StateGetRandomnessFromBeacon( + ctx, + crypto.DomainSeparationTag_InteractiveSealChallengeSeed, + epoch, + entropy, + tsk, + ) if err != nil { return core.Seed{}, err } @@ -92,7 +114,12 @@ func (r *Randomness) GetSeed(ctx context.Context, tsk types.TipSetKey, epoch abi }, nil } -func (r *Randomness) GetWindowPoStChanlleengeRand(ctx context.Context, tsk types.TipSetKey, epoch abi.ChainEpoch, mid abi.ActorID) (core.WindowPoStRandomness, error) { +func (r *Randomness) GetWindowPoStChanlleengeRand( + ctx context.Context, + tsk types.TipSetKey, + epoch abi.ChainEpoch, + mid abi.ActorID, +) (core.WindowPoStRandomness, error) { entropy, err := r.getRandomnessEntropy(mid) if err != nil { return core.WindowPoStRandomness{}, err @@ -107,7 +134,13 @@ func (r *Randomness) GetWindowPoStChanlleengeRand(ctx context.Context, tsk types tsk = ts.Key() } - rand, err := r.api.StateGetRandomnessFromBeacon(ctx, crypto.DomainSeparationTag_WindowedPoStChallengeSeed, epoch, entropy, tsk) + rand, err := r.api.StateGetRandomnessFromBeacon( + ctx, + crypto.DomainSeparationTag_WindowedPoStChallengeSeed, + epoch, + entropy, + tsk, + ) if err != nil { return core.WindowPoStRandomness{}, err } @@ -118,7 +151,11 @@ func (r *Randomness) GetWindowPoStChanlleengeRand(ctx context.Context, tsk types }, nil } -func (r *Randomness) GetWindowPoStCommitRand(ctx context.Context, tsk types.TipSetKey, epoch abi.ChainEpoch) (core.WindowPoStRandomness, error) { +func (r *Randomness) GetWindowPoStCommitRand( + ctx context.Context, + tsk types.TipSetKey, + epoch abi.ChainEpoch, +) (core.WindowPoStRandomness, error) { if tsk == types.EmptyTSK { ts, err := r.api.ChainHead(ctx) if err != nil { diff --git a/damocles-manager/modules/impl/sectors/indexer.go b/damocles-manager/modules/impl/sectors/indexer.go index e6d9e8f19..b30b91b44 100644 --- a/damocles-manager/modules/impl/sectors/indexer.go +++ b/damocles-manager/modules/impl/sectors/indexer.go @@ -59,7 +59,6 @@ func (i *innerIndexer) Find(ctx context.Context, sid abi.SectorID) (core.SectorA stores.SealedFile = string(b) return nil }) - if err != nil { if errors.Is(err, kvstore.ErrKeyNotFound) { return stores, false, nil diff --git a/damocles-manager/modules/impl/sectors/indexer_proxy.go b/damocles-manager/modules/impl/sectors/indexer_proxy.go index 28deece1b..daee004ec 100644 --- a/damocles-manager/modules/impl/sectors/indexer_proxy.go +++ b/damocles-manager/modules/impl/sectors/indexer_proxy.go @@ -27,7 +27,7 @@ func (p *proxiedTypeIndexer) Find(ctx context.Context, sid abi.SectorID) (core.S return found.Instance, found.Found, nil } -func (p *proxiedTypeIndexer) Update(_ context.Context, _ abi.SectorID, _ core.SectorAccessStores) error { +func (*proxiedTypeIndexer) Update(_ context.Context, _ abi.SectorID, _ core.SectorAccessStores) error { return ErrProxiedTypedIndexerUnableForUpdating } diff --git a/damocles-manager/modules/impl/sectors/mgr.go b/damocles-manager/modules/impl/sectors/mgr.go index 12e86e321..f361c0cf3 100644 --- a/damocles-manager/modules/impl/sectors/mgr.go +++ b/damocles-manager/modules/impl/sectors/mgr.go @@ -36,7 +36,11 @@ type Manager struct { numAlloc core.SectorNumberAllocator } -func (m *Manager) Allocate(ctx context.Context, spec core.AllocateSectorSpec, count uint32) ([]*core.AllocatedSector, error) { +func (m *Manager) Allocate( + ctx context.Context, + spec core.AllocateSectorSpec, + count uint32, +) ([]*core.AllocatedSector, error) { allowedMiners := spec.AllowedMiners allowedProofs := spec.AllowedProofTypes if count == 0 { diff --git a/damocles-manager/modules/impl/sectors/miner_selector.go b/damocles-manager/modules/impl/sectors/miner_selector.go index f161c92e9..3e290e59e 100644 --- a/damocles-manager/modules/impl/sectors/miner_selector.go +++ b/damocles-manager/modules/impl/sectors/miner_selector.go @@ -26,7 +26,13 @@ type minerSelector struct { minerAPI core.MinerAPI } -func (m *minerSelector) candidates(ctx context.Context, allowedMiners []abi.ActorID, allowedProofs []abi.RegisteredSealProof, check func(mcfg modules.MinerConfig) bool, usage string) []*minerCandidate { +func (m *minerSelector) candidates( + ctx context.Context, + allowedMiners []abi.ActorID, + allowedProofs []abi.RegisteredSealProof, + check func(mcfg modules.MinerConfig) bool, + usage string, +) []*minerCandidate { m.scfg.Lock() miners := m.scfg.Miners m.scfg.Unlock() diff --git a/damocles-manager/modules/impl/sectors/number_allocator.go b/damocles-manager/modules/impl/sectors/number_allocator.go index 2ccc1fd9c..2e1d10eb9 100644 --- a/damocles-manager/modules/impl/sectors/number_allocator.go +++ b/damocles-manager/modules/impl/sectors/number_allocator.go @@ -26,7 +26,13 @@ type NumberAllocator struct { locker *sectorsLocker } -func (na *NumberAllocator) NextN(ctx context.Context, mid abi.ActorID, n uint32, minNum uint64, check func(uint64) bool) (uint64, bool, error) { +func (na *NumberAllocator) NextN( + ctx context.Context, + mid abi.ActorID, + n uint32, + minNum uint64, + check func(uint64) bool, +) (uint64, bool, error) { lock := na.locker.lock(abi.SectorID{ Miner: mid, Number: 0, diff --git a/damocles-manager/modules/impl/sectors/number_allocator_test.go b/damocles-manager/modules/impl/sectors/number_allocator_test.go index d1492b037..7686c3c88 100644 --- a/damocles-manager/modules/impl/sectors/number_allocator_test.go +++ b/damocles-manager/modules/impl/sectors/number_allocator_test.go @@ -12,11 +12,9 @@ import ( ) func TestAllocatorNextN(t *testing.T) { - actorID := abi.ActorID(10086) for _, n := range []uint32{1, 2, 3, 4, 5} { - store := testutil.BadgerKVStore(t, fmt.Sprintf("test_%d", n)) allocator, err := NewNumberAllocator(store) require.NoError(t, err, "new number allocator") @@ -45,7 +43,14 @@ func TestAllocatorNextN(t *testing.T) { next, ok, err := allocator.NextN(context.Background(), actorID, n, 0, func(_ uint64) bool { return true }) require.NoErrorf(t, err, "allocate sector number, last %d, round %d", last, i) require.Truef(t, ok, "sector number allocated, last %d, round %d", last, i) - require.Equal(t, uint64(i+1)*uint64(n)+last, next, "allocated sector number with last %d, round %d", last, i) + require.Equal( + t, + uint64(i+1)*uint64(n)+last, + next, + "allocated sector number with last %d, round %d", + last, + i, + ) } // with max limit diff --git a/damocles-manager/modules/impl/sectors/proving.go b/damocles-manager/modules/impl/sectors/proving.go index a91b5dff6..caf31c339 100644 --- a/damocles-manager/modules/impl/sectors/proving.go +++ b/damocles-manager/modules/impl/sectors/proving.go @@ -13,12 +13,19 @@ import ( "github.com/filecoin-project/venus/venus-shared/types" "github.com/ipfs-force-community/damocles/damocles-manager/core" "github.com/ipfs-force-community/damocles/damocles-manager/modules" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" "github.com/ipfs-force-community/damocles/damocles-manager/pkg/objstore" "github.com/ipfs/go-cid" ) -func NewProving(sectorTracker core.SectorTracker, state core.SectorStateManager, storeMgr objstore.Manager, prover core.Prover, capi chainAPI.API, stCfg modules.ProvingConfig) (core.SectorProving, error) { +func NewProving( + sectorTracker core.SectorTracker, + state core.SectorStateManager, + storeMgr objstore.Manager, + prover core.Prover, + capi chainapi.API, + stCfg modules.ProvingConfig, +) (core.SectorProving, error) { return &Proving{ SectorTracker: sectorTracker, state: state, @@ -37,14 +44,21 @@ type Proving struct { state core.SectorStateManager storeMgr objstore.Manager prover core.Prover - capi chainAPI.API + capi chainapi.API parallelCheckLimit int singleCheckTimeout time.Duration partitionCheckTimeout time.Duration } -func (p *Proving) SingleProvable(ctx context.Context, postProofType abi.RegisteredPoStProof, sref core.SectorRef, upgrade bool, locator core.SectorLocator, strict, stateCheck bool) error { +func (p *Proving) SingleProvable( + ctx context.Context, + postProofType abi.RegisteredPoStProof, + sref core.SectorRef, + upgrade bool, + locator core.SectorLocator, + strict, stateCheck bool, +) error { ssize, err := sref.ProofType.SectorSize() if err != nil { return fmt.Errorf("get sector size: %w", err) @@ -101,7 +115,13 @@ func (p *Proving) SingleProvable(ctx context.Context, postProofType abi.Register if sz != 0 && strict { if st.Size != int64(ssize)*sz { - return fmt.Errorf("%s for %s with wrong size (got %d, expect %d)", p, check.title, st.Size, int64(ssize)*sz) + return fmt.Errorf( + "%s for %s with wrong size (got %d, expect %d)", + p, + check.title, + st.Size, + int64(ssize)*sz, + ) } } } @@ -126,6 +146,7 @@ func (p *Proving) SingleProvable(ctx context.Context, postProofType abi.Register if err != nil { return fmt.Errorf("not exist in Offline, maybe in Online: %w", err) } + //revive:disable-line:line-length-limit // for snap: onChain.SealedCID == local.UpgradedInfo.SealedCID, onChain.SectorKeyCID == ss.Pre.CommR, for other(CC/DC): onChain.SealedCID == onChain.SealedCID if !upgrade { if !ss.Pre.CommR.Equals(sinfo.SealedCID) { @@ -136,6 +157,7 @@ func (p *Proving) SingleProvable(ctx context.Context, postProofType abi.Register return fmt.Errorf("the SectorKeyCID on the local and the chain is inconsistent") } + //revive:disable-line:line-length-limit // 从 lotus 导入的扇区 UpgradedInfo 是空值,见代码: damocles-manager/cmd/damocles-manager/internal/util_sealer_sectors.go#L1735 if ss.UpgradedInfo.SealedCID != cid.Undef && !sinfo.SealedCID.Equals(ss.UpgradedInfo.SealedCID) { return fmt.Errorf("the SealedCID on the local and the chain is inconsistent") @@ -159,7 +181,13 @@ func (p *Proving) SingleProvable(ctx context.Context, postProofType abi.Register return nil } -func (p *Proving) Provable(ctx context.Context, mid abi.ActorID, postProofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, strict, stateCheck bool) (map[abi.SectorNumber]string, error) { +func (p *Proving) Provable( + ctx context.Context, + mid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + strict, stateCheck bool, +) (map[abi.SectorNumber]string, error) { limit := p.parallelCheckLimit if limit <= 0 { limit = len(sectors) @@ -207,7 +235,6 @@ func (p *Proving) Provable(ctx context.Context, mid abi.ActorID, postProofType a } results[i] = err.Error() - }(ti) } diff --git a/damocles-manager/modules/impl/sectors/rebuild.go b/damocles-manager/modules/impl/sectors/rebuild.go index 650a9ace7..5966bdec9 100644 --- a/damocles-manager/modules/impl/sectors/rebuild.go +++ b/damocles-manager/modules/impl/sectors/rebuild.go @@ -26,7 +26,11 @@ type RebuildInfosForActor struct { Infos map[abi.SectorNumber]core.SectorRebuildInfo } -func NewRebuildManager(scfg *modules.SafeConfig, minerAPI core.MinerAPI, infoKVStore kvstore.KVStore) (*RebuildManager, error) { +func NewRebuildManager( + scfg *modules.SafeConfig, + minerAPI core.MinerAPI, + infoKVStore kvstore.KVStore, +) (*RebuildManager, error) { return &RebuildManager{ msel: newMinerSelector(scfg, minerAPI), kv: infoKVStore, @@ -66,7 +70,6 @@ func (rm *RebuildManager) Set(ctx context.Context, sid abi.SectorID, info core.S return true }) - if err != nil { return fmt.Errorf("add rebuild info: %w", err) } @@ -75,7 +78,13 @@ func (rm *RebuildManager) Set(ctx context.Context, sid abi.SectorID, info core.S } func (rm *RebuildManager) Allocate(ctx context.Context, spec core.AllocateSectorSpec) (*core.SectorRebuildInfo, error) { - cands := rm.msel.candidates(ctx, spec.AllowedMiners, spec.AllowedProofTypes, func(mcfg modules.MinerConfig) bool { return true }, "rebuild") + cands := rm.msel.candidates( + ctx, + spec.AllowedMiners, + spec.AllowedProofTypes, + func(mcfg modules.MinerConfig) bool { return true }, + "rebuild", + ) if len(cands) == 0 { return nil, nil } @@ -104,7 +113,6 @@ func (rm *RebuildManager) Allocate(ctx context.Context, spec core.AllocateSector return false }) - if err != nil { return nil, fmt.Errorf("allocate rebuid info: %w", err) } @@ -125,7 +133,6 @@ func (rm *RebuildManager) loadAndUpdate(ctx context.Context, modify func(infos * return nil }) - if err != nil { if !errors.Is(err, kvstore.ErrKeyNotFound) { return fmt.Errorf("load rebuild infos: %w", err) diff --git a/damocles-manager/modules/impl/sectors/rebuild_test.go b/damocles-manager/modules/impl/sectors/rebuild_test.go index fa72ba66d..bf6be9a74 100644 --- a/damocles-manager/modules/impl/sectors/rebuild_test.go +++ b/damocles-manager/modules/impl/sectors/rebuild_test.go @@ -28,7 +28,7 @@ func (m *mockMinerAPI) GetInfo(_ context.Context, mid abi.ActorID) (*core.MinerI return minfo, nil } -func (m *mockMinerAPI) GetMinerConfig(_ context.Context, _ abi.ActorID) (*modules.MinerConfig, error) { +func (*mockMinerAPI) GetMinerConfig(_ context.Context, _ abi.ActorID) (*modules.MinerConfig, error) { return nil, fmt.Errorf("not impl") } @@ -148,7 +148,14 @@ func TestRebuildManager(t *testing.T) { require.Len(t, infos.Actors, 12, "actors count") for ai := range infos.Actors { allocated := allocatedCount[infos.Actors[ai].Actor] - require.Lenf(t, infos.Actors[ai].Infos, 16-allocated, "rebuild info count for actor %d with %d allocated", infos.Actors[ai].Actor, allocated) + require.Lenf( + t, + infos.Actors[ai].Infos, + 16-allocated, + "rebuild info count for actor %d with %d allocated", + infos.Actors[ai].Actor, + allocated, + ) } return false }) diff --git a/damocles-manager/modules/impl/sectors/snapup_allocator.go b/damocles-manager/modules/impl/sectors/snapup_allocator.go index b84493821..b287f5783 100644 --- a/damocles-manager/modules/impl/sectors/snapup_allocator.go +++ b/damocles-manager/modules/impl/sectors/snapup_allocator.go @@ -23,14 +23,21 @@ import ( ) func sectorGoodForSnapup(sinfo *miner.SectorOnChainInfo, currentHeight abi.ChainEpoch) bool { - return sinfo.SectorKeyCID == nil && len(sinfo.DealIDs) == 0 && sinfo.Expiration-currentHeight >= market8.DealMinDuration + return sinfo.SectorKeyCID == nil && len(sinfo.DealIDs) == 0 && + sinfo.Expiration-currentHeight >= market8.DealMinDuration } func kvKeyForMinerActorID(mid abi.ActorID) kvstore.Key { return kvstore.Key(strconv.FormatUint(uint64(mid), 10)) } -func NewSnapUpAllocator(chainAPI chain.API, minerAPI core.MinerAPI, allocStore kvstore.KVStore, indexer core.SectorIndexer, scfg *modules.SafeConfig) (*SnapUpAllocator, error) { +func NewSnapUpAllocator( + chainAPI chain.API, + minerAPI core.MinerAPI, + allocStore kvstore.KVStore, + indexer core.SectorIndexer, + scfg *modules.SafeConfig, +) (*SnapUpAllocator, error) { allocator := &SnapUpAllocator{ chain: chainAPI, @@ -55,7 +62,11 @@ type SnapUpAllocator struct { indexer core.SectorIndexer } -func (s *SnapUpAllocator) PreFetch(ctx context.Context, mid abi.ActorID, dlindex *uint64) (uint64, uint64, error) { +func (s *SnapUpAllocator) PreFetch( + ctx context.Context, + mid abi.ActorID, + dlindex *uint64, +) (count uint64, diff uint64, err error) { maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { return 0, 0, fmt.Errorf("invalid miner actor id %d: %w", mid, err) @@ -101,7 +112,7 @@ func (s *SnapUpAllocator) PreFetch(ctx context.Context, mid abi.ActorID, dlindex } } - count, err := actives.Count() + count, err = actives.Count() if err != nil { return 0, 0, fmt.Errorf("get active count: %w", err) } @@ -113,7 +124,7 @@ func (s *SnapUpAllocator) PreFetch(ctx context.Context, mid abi.ActorID, dlindex s.kvMu.Lock() defer s.kvMu.Unlock() - diff, err := s.addSectors(ctx, mid, dlidx, deadline.WPoStPeriodDeadlines, actives, count) + diff, err = s.addSectors(ctx, mid, dlidx, deadline.WPoStPeriodDeadlines, actives, count) if err != nil { return 0, 0, fmt.Errorf("add active sectors: %w", err) } @@ -132,9 +143,15 @@ func (s *SnapUpAllocator) Candidates(ctx context.Context, mid abi.ActorID) ([]*b } func (s *SnapUpAllocator) Allocate(ctx context.Context, spec core.AllocateSectorSpec) (*core.SnapUpCandidate, error) { - mcandidates := s.msel.candidates(ctx, spec.AllowedMiners, spec.AllowedProofTypes, func(mcfg modules.MinerConfig) bool { - return mcfg.SnapUp.Enabled - }, "snapup") + mcandidates := s.msel.candidates( + ctx, + spec.AllowedMiners, + spec.AllowedProofTypes, + func(mcfg modules.MinerConfig) bool { + return mcfg.SnapUp.Enabled + }, + "snapup", + ) if len(mcandidates) == 0 { return nil, nil @@ -154,7 +171,10 @@ type deadlineCandidate struct { count uint64 } -func (s *SnapUpAllocator) allocateForMiner(ctx context.Context, mcandidate *minerCandidate) (*core.SnapUpCandidate, error) { +func (s *SnapUpAllocator) allocateForMiner( + ctx context.Context, + mcandidate *minerCandidate, +) (*core.SnapUpCandidate, error) { mid := mcandidate.info.ID maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { @@ -177,7 +197,7 @@ func (s *SnapUpAllocator) allocateForMiner(ctx context.Context, mcandidate *mine rootLog := log.With("mid", mid) - var candidates []deadlineCandidate + candidates := []deadlineCandidate{} for dlidx := range exists { exist := exists[dlidx] @@ -304,7 +324,6 @@ func (s *SnapUpAllocator) allocateForMiner(ctx context.Context, mcandidate *mine AccessInstance: instances.SealedFile, }, }, nil - } func (s *SnapUpAllocator) Release(ctx context.Context, candidate *core.SnapUpCandidate) error { @@ -351,9 +370,7 @@ func (s *SnapUpAllocator) loadExists(ctx context.Context, key kvstore.Key) ([]*b return nil }) - if err != nil { - if !errors.Is(err, kvstore.ErrKeyNotFound) { return nil, fmt.Errorf("load exist sectors: %w", err) } @@ -378,7 +395,14 @@ func (s *SnapUpAllocator) updateExists(ctx context.Context, key kvstore.Key, exi return nil } -func (s *SnapUpAllocator) addSectors(ctx context.Context, mid abi.ActorID, dlidx uint64, deadlines uint64, sectors bitfield.BitField, _ uint64) (uint64, error) { +func (s *SnapUpAllocator) addSectors( + ctx context.Context, + mid abi.ActorID, + dlidx uint64, + deadlines uint64, + sectors bitfield.BitField, + _ uint64, +) (uint64, error) { key := kvKeyForMinerActorID(mid) exists, err := s.loadExists(ctx, key) diff --git a/damocles-manager/modules/impl/sectors/snapup_commit.go b/damocles-manager/modules/impl/sectors/snapup_commit.go index 627f215fd..6e4b1d87e 100644 --- a/damocles-manager/modules/impl/sectors/snapup_commit.go +++ b/damocles-manager/modules/impl/sectors/snapup_commit.go @@ -31,6 +31,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/objstore" ) +//revive:disable-next-line:argument-limit func NewSnapUpCommitter( ctx context.Context, tracker core.SectorTracker, @@ -88,17 +89,22 @@ func (sc *SnapUpCommitter) Start() error { sc.jobsMu.Lock() defer sc.jobsMu.Unlock() - err = sc.state.ForEach(sc.ctx, core.WorkerOnline, core.SectorWorkerJobSnapUp, func(state core.SectorState) error { - if !state.Upgraded { - return nil - } + err = sc.state.ForEach( + sc.ctx, + core.WorkerOnline, + core.SectorWorkerJobSnapUp, + func(state core.SectorState) error { + if !state.Upgraded { + return nil + } - ctx, cancel := context.WithCancel(sc.ctx) - sc.jobs[state.ID] = cancel - go sc.commitSector(ctx, state) - count++ - return nil - }) + ctx, cancel := context.WithCancel(sc.ctx) + sc.jobs[state.ID] = cancel + go sc.commitSector(ctx, state) + count++ + return nil + }, + ) snapupLog.Infow("snapup sectors loaded", "count", count) }) @@ -150,8 +156,6 @@ func (sc *SnapUpCommitter) CancelCommitment(_ context.Context, sid abi.SectorID) delete(sc.jobs, sid) cancel() - - return } func (sc *SnapUpCommitter) commitSector(ctx context.Context, state core.SectorState) { @@ -248,10 +252,12 @@ func (sc *SnapUpCommitter) commitSector(ctx context.Context, state core.SectorSt } } -var errMsgNotLanded = fmt.Errorf("msg not landed") -var errMsgNoReceipt = fmt.Errorf("msg without receipt") -var errMsgPending = fmt.Errorf("pending msg") -var errMsgTempErr = fmt.Errorf("msg temp error") +var ( + errMsgNotLanded = fmt.Errorf("msg not landed") + errMsgNoReceipt = fmt.Errorf("msg without receipt") + errMsgPending = fmt.Errorf("pending msg") + errMsgTempErr = fmt.Errorf("msg temp error") +) func newTempErr(err error, retryAfter time.Duration) snapupCommitTempError { te := snapupCommitTempError{ @@ -306,7 +312,7 @@ func (h *snapupCommitHandler) handle() (bool, error) { return false, h.submitMessage() } -func (h *snapupCommitHandler) checkUpgradeInfo() error { +func (*snapupCommitHandler) checkUpgradeInfo() error { // TODO: check more methods return nil } @@ -356,11 +362,18 @@ func (h *snapupCommitHandler) submitMessage() error { // We assume that deadlines are immutable when being proven. // // `abi.ChainEpoch(10)` indicates that we assume that the message will be real executed within 10 heights - // + //nolint:all // See: https://github.com/filecoin-project/builtin-actors/blob/10f547c950a99a07231c08a3c6f4f76ff0080a7c/actors/miner/src/lib.rs#L1113-L1124 - if isMut, delayBlock := deadlineIsMutable(currDeadline.PeriodStart, sl.Deadline, ts.Height(), abi.ChainEpoch(10)); !isMut { + if isMut, delayBlock := deadlineIsMutable(currDeadline.PeriodStart, sl.Deadline, ts.Height(), abi.ChainEpoch(10)); !isMut { //revive:disable-line:line-length-limit delayTime := time.Duration(mpolicy.NetParams.BlockDelaySecs*uint64(delayBlock)) * time.Second - return newTempErr(fmt.Errorf("cannot upgrade sectors in immutable deadline: %d. sector: %s", sl.Deadline, util.FormatSectorID(h.state.ID)), delayTime) + return newTempErr( + fmt.Errorf( + "cannot upgrade sectors in immutable deadline: %d. sector: %s", + sl.Deadline, + util.FormatSectorID(h.state.ID), + ), + delayTime, + ) } pams, deals, err := piece.ProcessPieces(h.committer.ctx, &h.state, h.committer.chain, h.committer.lookupID) @@ -384,8 +397,8 @@ func (h *snapupCommitHandler) submitMessage() error { }, SectorProofs: [][]byte{h.state.UpgradedInfo.Proof}, UpdateProofsType: updateProof, - //AggregateProof - //AggregateProofType + // AggregateProof + // AggregateProofType RequireActivationSuccess: mcfg.Sealing.RequireActivationSuccessUpdate, RequireNotificationSuccess: mcfg.Sealing.RequireNotificationSuccessUpdate, } @@ -454,7 +467,10 @@ func (h *snapupCommitHandler) submitMessage() error { uid, err := h.committer.messager.PushMessageWithId(h.committer.ctx, mcid, &msg, &spec) if err != nil { - return newTempErr(fmt.Errorf("push ProveReplicaUpdates message: %w", err), mcfg.SnapUp.Retry.APIFailureWait.Std()) + return newTempErr( + fmt.Errorf("push ProveReplicaUpdates message: %w", err), + mcfg.SnapUp.Retry.APIFailureWait.Std(), + ) } mcid = uid @@ -472,12 +488,12 @@ func (h *snapupCommitHandler) submitMessage() error { func (h *snapupCommitHandler) calcCollateral(tsk types.TipSetKey, proofType abi.RegisteredPoStProof) (big.Int, error) { onChainInfo, err := h.committer.chain.StateSectorGetInfo(h.committer.ctx, h.maddr, h.state.ID.Number, tsk) if err != nil { - return big.Int{}, fmt.Errorf("StateSectorGetInfo: %w", err) + return big.Int{}, fmt.Errorf("StateSectorGetInfo: %w", err) //revive:disable-line:error-strings } nv, err := h.committer.chain.StateNetworkVersion(h.committer.ctx, tsk) if err != nil { - return big.Int{}, fmt.Errorf("StateNetworkVersion: %w", err) + return big.Int{}, fmt.Errorf("StateNetworkVersion: %w", err) //revive:disable-line:error-strings } // TODO: Drop after nv19 comes and goes if nv >= network.Version19 { @@ -491,7 +507,13 @@ func (h *snapupCommitHandler) calcCollateral(tsk types.TipSetKey, proofType abi. return big.Int{}, fmt.Errorf("get seal proof type: %w", err) } - weightUpdate, err := pledge.SectorWeight(h.committer.ctx, &h.state, sealType, h.committer.chain, onChainInfo.Expiration) + weightUpdate, err := pledge.SectorWeight( + h.committer.ctx, + &h.state, + sealType, + h.committer.chain, + onChainInfo.Expiration, + ) if err != nil { return big.Int{}, fmt.Errorf("get sector weight: %w", err) } @@ -522,7 +544,9 @@ func (h *snapupCommitHandler) waitForMessage() error { } var maybeMsg string - if msg.State != messager.MessageState.OnChainMsg && msg.State != messager.MessageState.NonceConflictMsg && msg.Receipt != nil && len(msg.Receipt.Return) > 0 { + if msg.State != messager.MessageState.OnChainMsg && msg.State != messager.MessageState.NonceConflictMsg && + msg.Receipt != nil && + len(msg.Receipt.Return) > 0 { maybeMsg = string(msg.Receipt.Return) } @@ -563,7 +587,10 @@ func (h *snapupCommitHandler) waitForMessage() error { ts, err := h.committer.chain.ChainGetTipSet(h.committer.ctx, msg.TipSetKey) if err != nil { - return newTempErr(fmt.Errorf("get tipset %q: %w", msg.TipSetKey.String(), err), mcfg.SnapUp.Retry.APIFailureWait.Std()) + return newTempErr( + fmt.Errorf("get tipset %q: %w", msg.TipSetKey.String(), err), + mcfg.SnapUp.Retry.APIFailureWait.Std(), + ) } landedEpoch := core.SectorUpgradeLandedEpoch(ts.Height()) @@ -583,18 +610,23 @@ func (h *snapupCommitHandler) landed() error { } errChan := make(chan error, 1) - h.committer.eventbus.At(h.committer.ctx, abi.ChainEpoch(*h.state.UpgradeLandedEpoch)+policy.ChainFinality, mcfg.SnapUp.GetReleaseConfidence(), func(ts *types.TipSet) { - defer close(errChan) - if err := h.cleanupForSector(); err != nil { - errChan <- fmt.Errorf("cleanup data before upgrading: %w", err) - return - } + h.committer.eventbus.At( + h.committer.ctx, + abi.ChainEpoch(*h.state.UpgradeLandedEpoch)+policy.ChainFinality, + mcfg.SnapUp.GetReleaseConfidence(), + func(ts *types.TipSet) { + defer close(errChan) + if err := h.cleanupForSector(); err != nil { + errChan <- fmt.Errorf("cleanup data before upgrading: %w", err) + return + } - if err := h.committer.state.Finalize(h.committer.ctx, h.state.ID, nil); err != nil { - errChan <- fmt.Errorf("finalize sector: %w", err) - return - } - }) + if err := h.committer.state.Finalize(h.committer.ctx, h.state.ID, nil); err != nil { + errChan <- fmt.Errorf("finalize sector: %w", err) + return + } + }, + ) select { case <-h.committer.ctx.Done(): @@ -607,7 +639,6 @@ func (h *snapupCommitHandler) landed() error { return nil } - } func (h *snapupCommitHandler) cleanupForSector() error { @@ -679,7 +710,11 @@ func (h *snapupCommitHandler) cleanupForSector() error { } // Returns true if the deadline at the given index is currently mutable. -func deadlineIsMutable(provingPeriodStart abi.ChainEpoch, deadlineIdx uint64, currentEpoch, msgExecInterval abi.ChainEpoch) (bool, abi.ChainEpoch) { +func deadlineIsMutable( + provingPeriodStart abi.ChainEpoch, + deadlineIdx uint64, + currentEpoch, msgExecInterval abi.ChainEpoch, +) (bool, abi.ChainEpoch) { // Get the next non-elapsed deadline (i.e., the next time we care about // mutations to the deadline). deadlineInfo := stminer.NewDeadlineInfo(provingPeriodStart, deadlineIdx, currentEpoch).NextNotElapsed() @@ -691,7 +726,12 @@ func deadlineIsMutable(provingPeriodStart abi.ChainEpoch, deadlineIdx uint64, cu if !isMut { // deadline is immutable. should delay delay = deadlineInfo.Close - currentEpoch - log.Warnf("delay upgrade to avoid mutating deadline %d at %d before it opens at %d", deadlineIdx, currentEpoch, deadlineInfo.Open) + log.Warnf( + "delay upgrade to avoid mutating deadline %d at %d before it opens at %d", + deadlineIdx, + currentEpoch, + deadlineInfo.Open, + ) } return isMut, delay diff --git a/damocles-manager/modules/impl/sectors/snapup_commit_test.go b/damocles-manager/modules/impl/sectors/snapup_commit_test.go index 3d075ef69..24a1435c4 100644 --- a/damocles-manager/modules/impl/sectors/snapup_commit_test.go +++ b/damocles-manager/modules/impl/sectors/snapup_commit_test.go @@ -87,5 +87,4 @@ func TestDeadlineIsMutable(t *testing.T) { require.Equal(t, c.isMut, isMut, "test isMut for `%v`", c) require.Equal(t, c.delay, delay, "test delay for `%v`", c) } - } diff --git a/damocles-manager/modules/impl/sectors/snapup_mgr.go b/damocles-manager/modules/impl/sectors/snapup_mgr.go index ba9263a22..34e6a6204 100644 --- a/damocles-manager/modules/impl/sectors/snapup_mgr.go +++ b/damocles-manager/modules/impl/sectors/snapup_mgr.go @@ -16,6 +16,7 @@ var snapupLog = logging.New("sector-snapup") var _ core.SnapUpSectorManager = (*SnapUpMgr)(nil) +//revive:disable-next-line:argument-limit func NewSnapUpMgr( ctx context.Context, tracker core.SectorTracker, @@ -35,7 +36,18 @@ func NewSnapUpMgr( return nil, fmt.Errorf("construct snapup allocator: %w", err) } - committer, err := NewSnapUpCommitter(ctx, tracker, indexer, chainAPI, eventbus, messagerAPI, stateMgr, scfg, lookupID, senderSelector) + committer, err := NewSnapUpCommitter( + ctx, + tracker, + indexer, + chainAPI, + eventbus, + messagerAPI, + stateMgr, + scfg, + lookupID, + senderSelector, + ) if err != nil { return nil, fmt.Errorf("construct snapup committer: %w", err) } diff --git a/damocles-manager/modules/impl/sectors/state_mgr.go b/damocles-manager/modules/impl/sectors/state_mgr.go index 5a65f3293..dba5ebde9 100644 --- a/damocles-manager/modules/impl/sectors/state_mgr.go +++ b/damocles-manager/modules/impl/sectors/state_mgr.go @@ -30,7 +30,11 @@ func init() { var _ core.SectorStateManager = (*StateManager)(nil) -func NewStateManager(online kvstore.KVStore, offline kvstore.KVStore, plugins *managerplugin.LoadedPlugins) (*StateManager, error) { +func NewStateManager( + online kvstore.KVStore, + offline kvstore.KVStore, + plugins *managerplugin.LoadedPlugins, +) (*StateManager, error) { return &StateManager{ online: online, offline: offline, @@ -61,7 +65,12 @@ func (sm *StateManager) pickStore(ws core.SectorWorkerState) (kvstore.KVStore, e } } -func (sm *StateManager) load(ctx context.Context, key kvstore.Key, state *core.SectorState, ws core.SectorWorkerState) error { +func (sm *StateManager) loadInner( + ctx context.Context, + key kvstore.Key, + state *core.SectorState, + ws core.SectorWorkerState, +) error { kv, err := sm.pickStore(ws) if err != nil { return fmt.Errorf("load: %w", err) @@ -76,7 +85,12 @@ func (sm *StateManager) load(ctx context.Context, key kvstore.Key, state *core.S return nil } -func (sm *StateManager) save(ctx context.Context, key kvstore.Key, state core.SectorState, ws core.SectorWorkerState) error { +func (sm *StateManager) save( + ctx context.Context, + key kvstore.Key, + state core.SectorState, + ws core.SectorWorkerState, +) error { kv, err := sm.pickStore(ws) if err != nil { return fmt.Errorf("save: %w", err) @@ -99,7 +113,11 @@ func (sm *StateManager) getIter(ctx context.Context, ws core.SectorWorkerState) return kv.Scan(ctx, nil) } -func (sm *StateManager) All(ctx context.Context, ws core.SectorWorkerState, job core.SectorWorkerJob) ([]*core.SectorState, error) { +func (sm *StateManager) All( + ctx context.Context, + ws core.SectorWorkerState, + job core.SectorWorkerJob, +) ([]*core.SectorState, error) { iter, err := sm.getIter(ctx, ws) if err != nil { return nil, fmt.Errorf("get iter for All: %w", err) @@ -124,7 +142,12 @@ func (sm *StateManager) All(ctx context.Context, ws core.SectorWorkerState, job return states, nil } -func (sm *StateManager) ForEach(ctx context.Context, ws core.SectorWorkerState, job core.SectorWorkerJob, fn func(core.SectorState) error) error { +func (sm *StateManager) ForEach( + ctx context.Context, + ws core.SectorWorkerState, + job core.SectorWorkerJob, + fn func(core.SectorState) error, +) error { iter, err := sm.getIter(ctx, ws) if err != nil { return fmt.Errorf("get iter for ForEach: %w", err) @@ -152,7 +175,12 @@ func (sm *StateManager) ForEach(ctx context.Context, ws core.SectorWorkerState, return nil } -func (sm *StateManager) Import(ctx context.Context, ws core.SectorWorkerState, state *core.SectorState, override bool) (bool, error) { +func (sm *StateManager) Import( + ctx context.Context, + ws core.SectorWorkerState, + state *core.SectorState, + override bool, +) (bool, error) { lock := sm.locker.lock(state.ID) defer lock.unlock() @@ -196,7 +224,12 @@ func (sm *StateManager) Init(ctx context.Context, sectors []*core.AllocatedSecto return sm.InitWith(ctx, sectors, ws) } -func (sm *StateManager) InitWith(ctx context.Context, sectors []*core.AllocatedSector, ws core.SectorWorkerState, fieldvals ...interface{}) error { +func (sm *StateManager) InitWith( + ctx context.Context, + sectors []*core.AllocatedSector, + ws core.SectorWorkerState, + fieldvals ...any, +) error { sids := make([]abi.SectorID, len(sectors)) for i, s := range sectors { sids[i] = s.ID @@ -256,26 +289,35 @@ func (sm *StateManager) InitWith(ctx context.Context, sectors []*core.AllocatedS return err } -func (sm *StateManager) Load(ctx context.Context, sid abi.SectorID, ws core.SectorWorkerState) (*core.SectorState, error) { +func (sm *StateManager) Load( + ctx context.Context, + sid abi.SectorID, + ws core.SectorWorkerState, +) (*core.SectorState, error) { lock := sm.locker.lock(sid) defer lock.unlock() var state core.SectorState key := makeSectorKey(sid) - if err := sm.load(ctx, key, &state, ws); err != nil { + if err := sm.loadInner(ctx, key, &state, ws); err != nil { return nil, err } return &state, nil } -func (sm *StateManager) Update(ctx context.Context, sid abi.SectorID, ws core.SectorWorkerState, fieldvals ...interface{}) error { +func (sm *StateManager) Update( + ctx context.Context, + sid abi.SectorID, + ws core.SectorWorkerState, + fieldvals ...any, +) error { lock := sm.locker.lock(sid) defer lock.unlock() var state core.SectorState key := makeSectorKey(sid) - if err := sm.load(ctx, key, &state, ws); err != nil { + if err := sm.loadInner(ctx, key, &state, ws); err != nil { return err } @@ -307,7 +349,7 @@ func (sm *StateManager) Finalize(ctx context.Context, sid abi.SectorID, onFinali key := makeSectorKey(sid) var state core.SectorState - if err := sm.load(ctx, key, &state, core.WorkerOnline); err != nil { + if err := sm.loadInner(ctx, key, &state, core.WorkerOnline); err != nil { return fmt.Errorf("load from online store: %w", err) } @@ -351,7 +393,7 @@ func (sm *StateManager) Restore(ctx context.Context, sid abi.SectorID, onRestore key := makeSectorKey(sid) var state core.SectorState - if err := sm.load(ctx, key, &state, core.WorkerOffline); err != nil { + if err := sm.loadInner(ctx, key, &state, core.WorkerOffline); err != nil { return fmt.Errorf("load from offline store: %w", err) } @@ -389,7 +431,7 @@ func (sm *StateManager) Restore(ctx context.Context, sid abi.SectorID, onRestore return nil } -func processStateField(rv reflect.Value, fieldval interface{}) error { +func processStateField(rv reflect.Value, fieldval any) error { rfv := reflect.ValueOf(fieldval) // most likely, reflect.ValueOf(nil) if !rfv.IsValid() { @@ -412,7 +454,7 @@ func makeSectorKey(sid abi.SectorID) kvstore.Key { return []byte(fmt.Sprintf("m-%d-n-%d", sid.Miner, sid.Number)) } -func apply(_ context.Context, state *core.SectorState, fieldvals ...interface{}) error { +func apply(_ context.Context, state *core.SectorState, fieldvals ...any) error { statev := reflect.ValueOf(state).Elem() for fi := range fieldvals { fieldval := fieldvals[fi] diff --git a/damocles-manager/modules/impl/sectors/tracker.go b/damocles-manager/modules/impl/sectors/tracker.go index 19fc444fd..6fefd0b0d 100644 --- a/damocles-manager/modules/impl/sectors/tracker.go +++ b/damocles-manager/modules/impl/sectors/tracker.go @@ -31,7 +31,12 @@ type Tracker struct { indexer core.SectorIndexer } -func (t *Tracker) SinglePubToPrivateInfo(ctx context.Context, mid abi.ActorID, sector builtin.ExtendedSectorInfo, locator core.SectorLocator) (core.PrivateSectorInfo, error) { +func (t *Tracker) SinglePubToPrivateInfo( + ctx context.Context, + mid abi.ActorID, + sector builtin.ExtendedSectorInfo, + locator core.SectorLocator, +) (core.PrivateSectorInfo, error) { sref := core.SectorRef{ ID: abi.SectorID{Miner: mid, Number: sector.SectorNumber}, ProofType: sector.SealProof, @@ -40,7 +45,12 @@ func (t *Tracker) SinglePubToPrivateInfo(ctx context.Context, mid abi.ActorID, s return t.SinglePrivateInfo(ctx, sref, sector.SectorKey != nil, locator) } -func (t *Tracker) getPrivateInfo(ctx context.Context, sref core.SectorRef, upgrade bool, locator core.SectorLocator) (*sectorStoreInstances, core.PrivateSectorInfo, error) { +func (t *Tracker) getPrivateInfo( + ctx context.Context, + sref core.SectorRef, + upgrade bool, + locator core.SectorLocator, +) (*sectorStoreInstances, core.PrivateSectorInfo, error) { objins, err := t.getObjInstanceForSector(ctx, sref.ID, locator, upgrade) if err != nil { return nil, core.PrivateSectorInfo{}, fmt.Errorf("get location for %s: %w", util.FormatSectorID(sref.ID), err) @@ -65,7 +75,12 @@ func (t *Tracker) getPrivateInfo(ctx context.Context, sref core.SectorRef, upgra }, nil } -func (t *Tracker) SinglePrivateInfo(ctx context.Context, sref core.SectorRef, upgrade bool, locator core.SectorLocator) (core.PrivateSectorInfo, error) { +func (t *Tracker) SinglePrivateInfo( + ctx context.Context, + sref core.SectorRef, + upgrade bool, + locator core.SectorLocator, +) (core.PrivateSectorInfo, error) { _, privateInfo, err := t.getPrivateInfo(ctx, sref, upgrade, locator) if err != nil { return core.PrivateSectorInfo{}, fmt.Errorf("get private info: %w", err) @@ -74,7 +89,12 @@ func (t *Tracker) SinglePrivateInfo(ctx context.Context, sref core.SectorRef, up return privateInfo, nil } -func (t *Tracker) PubToPrivate(ctx context.Context, aid abi.ActorID, postProofType abi.RegisteredPoStProof, sectorInfo []builtin.ExtendedSectorInfo) ([]core.FFIPrivateSectorInfo, error) { +func (t *Tracker) PubToPrivate( + ctx context.Context, + aid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectorInfo []builtin.ExtendedSectorInfo, +) ([]core.FFIPrivateSectorInfo, error) { if len(sectorInfo) == 0 { return []core.FFIPrivateSectorInfo{}, nil } @@ -91,7 +111,12 @@ func (t *Tracker) PubToPrivate(ctx context.Context, aid abi.ActorID, postProofTy return out, nil } -func (t *Tracker) getObjInstanceForSector(ctx context.Context, sid abi.SectorID, locator core.SectorLocator, upgrade bool) (*sectorStoreInstances, error) { +func (t *Tracker) getObjInstanceForSector( + ctx context.Context, + sid abi.SectorID, + locator core.SectorLocator, + upgrade bool, +) (*sectorStoreInstances, error) { if locator == nil { if upgrade { locator = t.indexer.Upgrade().Find diff --git a/damocles-manager/modules/impl/sectors/unseal.go b/damocles-manager/modules/impl/sectors/unseal.go index a23c70079..15dd7a3cc 100644 --- a/damocles-manager/modules/impl/sectors/unseal.go +++ b/damocles-manager/modules/impl/sectors/unseal.go @@ -22,11 +22,13 @@ var unsealInfoKey = kvstore.Key("unseal-infos") const invalidMarketHost = "invalid.market.host" -type Key = string -type UnsealInfos struct { - AllocIndex map[abi.ActorID]map[Key]struct{} - Data map[Key]*core.SectorUnsealInfo -} +type ( + Key = string + UnsealInfos struct { + AllocIndex map[abi.ActorID]map[Key]struct{} + Data map[Key]*core.SectorUnsealInfo + } +) // UnsealManager manage unseal task type UnsealManager struct { @@ -39,7 +41,13 @@ type UnsealManager struct { var _ core.UnsealSectorManager = (*UnsealManager)(nil) -func NewUnsealManager(_ context.Context, scfg *modules.SafeConfig, minfoAPI core.MinerAPI, kv kvstore.KVStore, marketAddr, marketToken string) (ret *UnsealManager, err error) { +func NewUnsealManager( + _ context.Context, + scfg *modules.SafeConfig, + minfoAPI core.MinerAPI, + kv kvstore.KVStore, + marketAddr, marketToken string, +) (ret *UnsealManager, err error) { ret = &UnsealManager{ kv: kv, msel: newMinerSelector(scfg, minfoAPI), @@ -47,7 +55,11 @@ func NewUnsealManager(_ context.Context, scfg *modules.SafeConfig, minfoAPI core ret.defaultDest, err = getDefaultMarketPiecesStore(marketAddr) if err != nil { - log.Warnw("get default market pieces store fail, upload unseal piece to market will not be possible", "error", err) + log.Warnw( + "get default market pieces store fail, upload unseal piece to market will not be possible", + "error", + err, + ) } q := ret.defaultDest.Query() q.Set("token", marketToken) @@ -57,10 +69,12 @@ func NewUnsealManager(_ context.Context, scfg *modules.SafeConfig, minfoAPI core } // SetAndCheck set unseal task -func (u *UnsealManager) SetAndCheck(ctx context.Context, req *core.SectorUnsealInfo) (state gtypes.UnsealState, err error) { - +func (u *UnsealManager) SetAndCheck( + ctx context.Context, + req *core.SectorUnsealInfo, +) (state gtypes.UnsealState, err error) { // check dest url - supplied, err := u.checkDestUrl(req.Dest[0]) + supplied, err := u.checkDestURL(req.Dest[0]) if err != nil { return gtypes.UnsealStateFailed, err } @@ -77,7 +91,7 @@ func (u *UnsealManager) SetAndCheck(ctx context.Context, req *core.SectorUnsealI err = u.loadAndUpdate(ctx, func(db *UnsealInfos) bool { info, ok := db.Data[key] if !ok { - //not found, add new task + // not found, add new task req.State = gtypes.UnsealStateSet db.Data[key] = req @@ -154,7 +168,13 @@ func (u *UnsealManager) OnAchieve(_ context.Context, sid abi.SectorID, pieceCid // allocate a unseal task func (u *UnsealManager) Allocate(ctx context.Context, spec core.AllocateSectorSpec) (*core.SectorUnsealInfo, error) { - cands := u.msel.candidates(ctx, spec.AllowedMiners, spec.AllowedProofTypes, func(mcfg modules.MinerConfig) bool { return true }, "unseal") + cands := u.msel.candidates( + ctx, + spec.AllowedMiners, + spec.AllowedProofTypes, + func(mcfg modules.MinerConfig) bool { return true }, + "unseal", + ) if len(cands) == 0 { return nil, nil } @@ -162,7 +182,6 @@ func (u *UnsealManager) Allocate(ctx context.Context, spec core.AllocateSectorSp // read db var allocated *core.SectorUnsealInfo err := u.loadAndUpdate(ctx, func(db *UnsealInfos) bool { - if len(db.AllocIndex) == 0 { return false } @@ -188,7 +207,6 @@ func (u *UnsealManager) Allocate(ctx context.Context, spec core.AllocateSectorSp } return false }) - if err != nil { return nil, fmt.Errorf("allocate unseal info: %w", err) } @@ -216,7 +234,6 @@ func (u *UnsealManager) Achieve(ctx context.Context, sid abi.SectorID, pieceCid db.Data[key] = info return true }) - if err != nil { return fmt.Errorf("achieve unseal info(%s): load task fail: %w", key, err) } @@ -254,9 +271,7 @@ func (u *UnsealManager) AcquireDest(ctx context.Context, sid abi.SectorID, piece info.State = gtypes.UnsealStateUploading db.Data[key] = info return true - }) - if err != nil { return nil, fmt.Errorf("achieve unseal info(%s): %w", key, err) } @@ -277,7 +292,6 @@ func (u *UnsealManager) loadAndUpdate(ctx context.Context, modify func(infos *Un return nil }) - if err != nil { if !errors.Is(err, kvstore.ErrKeyNotFound) { return fmt.Errorf("load unseal infos: %w", err) @@ -314,13 +328,13 @@ func (u *UnsealManager) loadAndUpdate(ctx context.Context, modify func(infos *Un return nil } -// checkDestUrl check dest url conform to the out expect +// checkDestURL check dest url conform to the out expect // we accept three kinds of url by now // 1. http://xxx or https://xxx , it means we will put data to a http server // 2. market://store_name/piece_cid, it means we will put data to the target path of pieces store from market // 3. file:///path , it means we will put data to a local file // 4. store://store_name/piece_cid , it means we will put data to damocles-manager -func (u *UnsealManager) checkDestUrl(dest string) (string, error) { +func (u *UnsealManager) checkDestURL(dest string) (string, error) { urlStruct, err := url.Parse(dest) if err != nil { return "", err @@ -330,7 +344,9 @@ func (u *UnsealManager) checkDestUrl(dest string) (string, error) { case "http", "https", "file", "store": case "market": if u.defaultDest.Host == invalidMarketHost { - return "", fmt.Errorf("upload pieces to market will not be possible when market address dose not set, please check you config") + return "", fmt.Errorf( + "upload pieces to market will not be possible when market address dose not set, please check you config", //revive:disable-line:line-length-limit + ) } // add host , scheme and token q := urlStruct.Query() diff --git a/damocles-manager/modules/impl/sectors/unseal_test.go b/damocles-manager/modules/impl/sectors/unseal_test.go index d1dd81fd2..f15a22b84 100644 --- a/damocles-manager/modules/impl/sectors/unseal_test.go +++ b/damocles-manager/modules/impl/sectors/unseal_test.go @@ -167,7 +167,6 @@ func TestUnsealManager(t *testing.T) { } require.Equal(t, 3, len(allocatable.Dest), "allocatable task has 3 destinations") }) - } func TestCheckUrl(t *testing.T) { @@ -205,12 +204,12 @@ func TestCheckUrl(t *testing.T) { } for _, v := range testCases { - res, err := u.checkDestUrl(v.url) + res, err := u.checkDestURL(v.url) require.NoError(t, err) require.Equal(t, v.expect, res) } - _, err = u.checkDestUrl("oss://bucket/path") + _, err = u.checkDestURL("oss://bucket/path") require.Error(t, err) } @@ -246,5 +245,4 @@ func TestMarketPieceStore(t *testing.T) { } }) } - } diff --git a/damocles-manager/modules/impl/worker/mgr.go b/damocles-manager/modules/impl/worker/mgr.go index a13bcb39e..9375f0507 100644 --- a/damocles-manager/modules/impl/worker/mgr.go +++ b/damocles-manager/modules/impl/worker/mgr.go @@ -12,8 +12,10 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/logging" ) -var log = logging.New("worker-manager") -var _ core.WorkerManager = (*Manager)(nil) +var ( + log = logging.New("worker-manager") + _ core.WorkerManager = (*Manager)(nil) +) func makeWorkerKey(name string) kvstore.Key { return kvstore.Key(name) @@ -77,7 +79,6 @@ func (m *Manager) All(ctx context.Context, filter func(*core.WorkerPingInfo) boo if filter == nil || filter(&winfo) { infos = append(infos, winfo) } - } return infos, nil @@ -103,7 +104,12 @@ func (m *Manager) doMetrics(ctx context.Context) { continue } - workerLatencyCount := map[string]int64{"latency<=60s": 0, "latency<=120s": 0, "latency<=300s": 0, "latency>300s": 0} + workerLatencyCount := map[string]int64{ + "latency<=60s": 0, + "latency<=120s": 0, + "latency<=300s": 0, + "latency>300s": 0, + } threadStateCount := map[string]int64{} now := time.Now().Unix() for _, info := range infos { diff --git a/damocles-manager/modules/miner/proof_event.go b/damocles-manager/modules/miner/proof_event.go index b68126e85..f37a69858 100644 --- a/damocles-manager/modules/miner/proof_event.go +++ b/damocles-manager/modules/miner/proof_event.go @@ -8,7 +8,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/venus/venus-shared/actors/builtin" - v2 "github.com/filecoin-project/venus/venus-shared/api/gateway/v2" + gatewayv2 "github.com/filecoin-project/venus/venus-shared/api/gateway/v2" vtypes "github.com/filecoin-project/venus/venus-shared/types" gtypes "github.com/filecoin-project/venus/venus-shared/types/gateway" @@ -20,12 +20,17 @@ var log = logging.New("proof_event") type ProofEvent struct { prover core.Prover - client v2.IGateway + client gatewayv2.IGateway actor core.ActorIdent tracker core.SectorTracker } -func NewProofEvent(prover core.Prover, client v2.IGateway, actor core.ActorIdent, tracker core.SectorTracker) *ProofEvent { +func NewProofEvent( + prover core.Prover, + client gatewayv2.IGateway, + actor core.ActorIdent, + tracker core.SectorTracker, +) *ProofEvent { pe := &ProofEvent{ prover: prover, client: client, @@ -139,7 +144,7 @@ func (pe *ProofEvent) processComputeProof(ctx context.Context, reqID vtypes.UUID } } -func (pe *ProofEvent) postProofType(sectorInfo []builtin.ExtendedSectorInfo) (abi.RegisteredPoStProof, error) { +func (*ProofEvent) postProofType(sectorInfo []builtin.ExtendedSectorInfo) (abi.RegisteredPoStProof, error) { if len(sectorInfo) == 0 { return 0, fmt.Errorf("must provide sectors for winning post") } diff --git a/damocles-manager/modules/policy/sealer.go b/damocles-manager/modules/policy/sealer.go index 01e3022eb..bf09a5bdc 100644 --- a/damocles-manager/modules/policy/sealer.go +++ b/damocles-manager/modules/policy/sealer.go @@ -10,9 +10,11 @@ const InteractivePoRepConfidence = 6 const MinSectorExpiration = miner.MinSectorExpiration -var GetMinSectorExpiration = policy.GetMinSectorExpiration -var GetMaxSectorExpirationExtension = policy.GetMaxSectorExpirationExtension -var GetMaxProveCommitDuration = policy.GetMaxProveCommitDuration +var ( + GetMinSectorExpiration = policy.GetMinSectorExpiration + GetMaxSectorExpirationExtension = policy.GetMaxSectorExpirationExtension + GetMaxProveCommitDuration = policy.GetMaxProveCommitDuration +) func GetPreCommitChallengeDelay() abi.ChainEpoch { // TODO: remove the guard code here diff --git a/damocles-manager/modules/poster/poster.go b/damocles-manager/modules/poster/poster.go index e24b828f8..42b66da5b 100644 --- a/damocles-manager/modules/poster/poster.go +++ b/damocles-manager/modules/poster/poster.go @@ -27,8 +27,9 @@ const ( var log = logging.New("poster") +//revive:disable-next-line:argument-limit func newPostDeps( - chain chain.API, + chainAPI chain.API, msg messager.API, rand core.RandomnessAPI, minerAPI core.MinerAPI, @@ -38,7 +39,7 @@ func newPostDeps( senderSelect core.SenderSelector, ) postDeps { return postDeps{ - chain: chain, + chain: chainAPI, msg: msg, rand: rand, minerAPI: minerAPI, @@ -62,9 +63,10 @@ type postDeps struct { senderSelector core.SenderSelector } +//revive:disable-next-line:argument-limit func NewPoSter( scfg *modules.SafeConfig, - chain chain.API, + chainAPI chain.API, msg messager.API, rand core.RandomnessAPI, minerAPI core.MinerAPI, @@ -75,7 +77,7 @@ func NewPoSter( ) (*PoSter, error) { return newPoSterWithRunnerConstructor( scfg, - chain, + chainAPI, msg, rand, minerAPI, @@ -87,9 +89,10 @@ func NewPoSter( ) } +//revive:disable-next-line:argument-limit func newPoSterWithRunnerConstructor( scfg *modules.SafeConfig, - chain chain.API, + chainAPI chain.API, msg messager.API, rand core.RandomnessAPI, minerAPI core.MinerAPI, @@ -101,7 +104,7 @@ func newPoSterWithRunnerConstructor( ) (*PoSter, error) { return &PoSter{ cfg: scfg, - deps: newPostDeps(chain, msg, rand, minerAPI, prover, verifier, sectorProving, senderSelector), + deps: newPostDeps(chainAPI, msg, rand, minerAPI, prover, verifier, sectorProving, senderSelector), schedulers: make(map[abi.ActorID]map[abi.ChainEpoch]*scheduler), runnerConstructor: runnerCtor, }, nil @@ -134,9 +137,7 @@ CHAIN_HEAD_LOOP: return case <-time.After(reconnectWait): - } - } else { firstTime = false } @@ -226,7 +227,11 @@ func (p *PoSter) getEnabledMiners(ctx context.Context, mlog *logging.ZapLogger) return mids } -func (p *PoSter) fetchMinerProvingDeadlineInfos(ctx context.Context, mids []abi.ActorID, ts *types.TipSet) map[abi.ActorID]map[abi.ChainEpoch]*dline.Info { +func (p *PoSter) fetchMinerProvingDeadlineInfos( + ctx context.Context, + mids []abi.ActorID, + ts *types.TipSet, +) map[abi.ActorID]map[abi.ChainEpoch]*dline.Info { count := len(mids) infos := make([]*dline.Info, count) errs := make([]error, count) @@ -288,7 +293,12 @@ func (p *PoSter) fetchMinerProvingDeadlineInfos(ctx context.Context, mids []abi. // handleHeadChange 处理以下逻辑： // 1. 是否需要根据 revert 回退或 abort 已存在的 runner // 2. 是否开启新的 runner -func (p *PoSter) handleHeadChange(ctx context.Context, revert *types.TipSet, advance *types.TipSet, dinfos map[abi.ActorID]map[abi.ChainEpoch]*dline.Info) { +func (p *PoSter) handleHeadChange( + ctx context.Context, + revert *types.TipSet, + advance *types.TipSet, + dinfos map[abi.ActorID]map[abi.ChainEpoch]*dline.Info, +) { // 对于当前高度来说，最少会处于1个活跃区间内，最多会处于2个活跃区间内 [next.Challenge, prev.Close) // 启动一个新 runner 的最基本条件为：当前高度所属的活跃区间存在没有与之对应的 runner 的情况 currHeight := advance.Height() @@ -324,9 +334,7 @@ func (p *PoSter) handleHeadChange(ctx context.Context, revert *types.TipSet, adv if dls, dlsOk := dinfos[mid]; dlsOk { // 尝试开启的 deadline 已经存在 - if _, dlOk := dls[open]; dlOk { - delete(dls, open) - } + delete(dls, open) } // 中断此 runner @@ -347,7 +355,6 @@ func (p *PoSter) handleHeadChange(ctx context.Context, revert *types.TipSet, adv sched.runner.submit(pcfg, advance) } } - } } diff --git a/damocles-manager/modules/poster/poster_test.go b/damocles-manager/modules/poster/poster_test.go index 96495a2d6..608eb53b8 100644 --- a/damocles-manager/modules/poster/poster_test.go +++ b/damocles-manager/modules/poster/poster_test.go @@ -22,9 +22,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/testutil/testmodules" ) -var ( - invalidSender = modules.MustAddress(address.Undef) -) +var invalidSender = modules.MustAddress(address.Undef) func mockSafeConfig(count int) (*modules.SafeConfig, sync.Locker) { return testmodules.MockSafeConfig(count, func(mcfg *modules.MinerConfig) { @@ -34,6 +32,7 @@ func mockSafeConfig(count int) (*modules.SafeConfig, sync.Locker) { }) } +// nolint const blkRaw = `{"Miner":"t038057","Ticket":{"VRFProof":"kfggWR2GcEbfTuJ20hkAFNRbF7xusDuAQR7XwTjJ2/gc1rwIDmaXbSVxXe4j1njcCBoMhmlYIn9D/BLqQuIOayMHPYvDmOJGc9M27Hwg1UZkiuJmXji+iM/JBNYaOA61"},"ElectionProof":{"WinCount":1,"VRFProof":"tI7cWWM9sGsKc69N9DjN41glaO5Hg7r742H56FPzg7szbhTrxj8kw0OsiJzcPJdiAa6D5jZ1S2WKoLK7lwg2R5zYvCRwwWLGDiExqbqsvqmH5z/e6YGpaD7ghTPRH1SR"},"BeaconEntries":[{"Round":2118576,"Data":"rintMKcvVAslYpn9DcshDBmlPN6hUR+wjvVQSkkVUK5klx1kOSpcDvzODSc2wXFQA7BVbEcXJW/5KLoL0KHx2alLUWDOwxhsIQnAydXdZqG8G76nTIgogthfIMgSGdB2"}],"WinPoStProof":[{"PoStProof":3,"ProofBytes":"t0ZgPHFv0ao9fVZJ/fxbBrzATmOiIv9/IueSyAjtcqEpxqWViqchaaxnz1afwzAbhahpfZsGiGWyc408WYh7Q8u0Aa52KGPmUNtf3pAvxWfsUDMz9QUfhLZVg/p8/PUVC/O/E7RBNq4YPrRK5b6Q8PVwzIOxGOS14ge6ys8Htq+LfNJbcqY676qOYF4lzMuMtQIe3CxMSAEaEBfNpHhAEs83dO6vll9MZKzcXYpNWeqmMIz4xSdF18StQq9vL/Lo"}],"Parents":[{"/":"bafy2bzacecf4wtqz3kgumeowhdulejk3xbfzgibfyhs42x4vx2guqgudem2hg"},{"/":"bafy2bzacebkpxh2k63xreigl6a3ggdr2adwk67b4zw5dddckhqex2tmha6hee"},{"/":"bafy2bzacecor3xq4ykmhhrgq55rdo5w7up65elc4qwx5uwjy25ffynidskbxw"},{"/":"bafy2bzacedr2mztmef65fodqzvyjcdnsgpcjthstseinll4maqg24avnv7ljo"}],"ParentWeight":"21779626255","Height":1164251,"ParentStateRoot":{"/":"bafy2bzacecypgutbewmyop2wfuafvxt7dm7ew4u3ssy2p4rn457f6ynrj2i6a"},"ParentMessageReceipts":{"/":"bafy2bzaceaflsspsxuxew2y4g6o72wp5i2ewp3fcolga6n2plw3gycam7s4lg"},"Messages":{"/":"bafy2bzaceanux5ivzlxzvhqxtwc5vkktcfqepubwtwgv26dowzbl3rtgqk54k"},"BLSAggregate":{"Type":2,"Data":"lQg9jBfYhY2vvjB/RPlWg6i+MBTlH1u0lmdasiab5BigsKAuZSeLNlTGbdoVZhAsDUT59ZdGsMmueHjafygDUN2KLhZoChFf6LQHH42PTSXFlkRVHvmKVz9DDU03FLMB"},"Timestamp":1658988330,"BlockSig":{"Type":2,"Data":"rMOv2tXKqV5VDOq5IQ35cP0cCAzGmaugVr/g5JTrilhAn4LYK0h6ByPL5cX5ONzlDTx9+zYZFteIzaenirZhw7G510Lh0J8lbTLP5X2EX251rEA8dpkPZPcNylzN0r8X"},"ForkSignaling":0,"ParentBaseFee":"100"}` func mockTipSet(t *testing.T, height abi.ChainEpoch) *types.TipSet { @@ -66,7 +65,18 @@ func TestPoSterGetEnabledMiners(t *testing.T) { require.Len(t, scfg.Miners, minerCount, "mocked miners") - poster, err := newPoSterWithRunnerConstructor(scfg, nil, nil, nil, nil, nil, nil, nil, mockSelecotor{}, mockRunnerConstructor(&mockRunner{})) + poster, err := newPoSterWithRunnerConstructor( + scfg, + nil, + nil, + nil, + nil, + nil, + nil, + nil, + mockSelecotor{}, + mockRunnerConstructor(&mockRunner{}), + ) require.NoError(t, err, "new poster") mids := poster.getEnabledMiners(ctx, logging.Nop) @@ -128,18 +138,28 @@ func TestFetchMinerProvingDeadlineInfos(t *testing.T) { dl := randomDeadline() var mockChain chain.MockStruct - mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { + mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { //revive:disable-line:line-length-limit return dl, nil } - poster, err := newPoSterWithRunnerConstructor(scfg, &mockChain, nil, nil, nil, nil, nil, nil, nil, mockRunnerConstructor(&mockRunner{})) + poster, err := newPoSterWithRunnerConstructor( + scfg, + &mockChain, + nil, + nil, + nil, + nil, + nil, + nil, + nil, + mockRunnerConstructor(&mockRunner{}), + ) require.NoError(t, err, "new poster") ts := mockTipSet(t, dl.Open) // 默认行为 { - dinfos := poster.fetchMinerProvingDeadlineInfos(context.Background(), mids, ts) require.Len(t, dinfos, len(mids), "get all dlines for miners") for mid, dls := range dinfos { @@ -163,7 +183,7 @@ func TestFetchMinerProvingDeadlineInfos(t *testing.T) { { for i := 0; i < 8; i++ { available := rand.Intn(minerCount) - mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { + mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { //revive:disable-line:line-length-limit id, err := address.IDFromAddress(p1) if err != nil { return nil, err @@ -180,7 +200,6 @@ func TestFetchMinerProvingDeadlineInfos(t *testing.T) { require.Lenf(t, dinfos, available, "get only available dlines for miners") } } - } func TestHandleHeadChange(t *testing.T) { @@ -194,7 +213,7 @@ func TestHandleHeadChange(t *testing.T) { } var mockChain chain.MockStruct - mockChain.IMinerStateStruct.Internal.StateMinerInfo = func(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.MinerInfo, error) { + mockChain.IMinerStateStruct.Internal.StateMinerInfo = func(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.MinerInfo, error) { //revive:disable-line:line-length-limit _, err := address.IDFromAddress(maddr) if err != nil { return types.MinerInfo{}, err @@ -206,7 +225,7 @@ func TestHandleHeadChange(t *testing.T) { }, nil } - mockChain.IChainInfoStruct.Internal.StateNetworkVersion = func(ctx context.Context, tsk types.TipSetKey) (network.Version, error) { + mockChain.IChainInfoStruct.Internal.StateNetworkVersion = func(ctx context.Context, tsk types.TipSetKey) (network.Version, error) { //revive:disable-line:line-length-limit return network.Version21, nil } @@ -227,11 +246,22 @@ func TestHandleHeadChange(t *testing.T) { dl := deadlineAt(10000, 0) nextDl := nextDeadline(dl, dl.Open) - mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { + mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { //revive:disable-line:line-length-limit return dl, nil } - poster, err := newPoSterWithRunnerConstructor(scfg, &mockChain, nil, nil, chain.NewMinerAPI(&mockChain, scfg), nil, nil, nil, nil, mockRunnerConstructor(runner)) + poster, err := newPoSterWithRunnerConstructor( + scfg, + &mockChain, + nil, + nil, + chain.NewMinerAPI(&mockChain, scfg), + nil, + nil, + nil, + nil, + mockRunnerConstructor(runner), + ) require.NoError(t, err, "new poster") cases := []struct { @@ -309,7 +339,6 @@ func TestHandleHeadChange(t *testing.T) { require.Equal(t, c.submited, runner.submited, "submited runners", c.title, c.height) require.Equal(t, c.aborted, runner.aborted, "aborted runners", c.title, c.height) } - } // 连续 deadlines @@ -324,7 +353,7 @@ func TestHandleHeadChange(t *testing.T) { called := uint32(0) - mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { + mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { //revive:disable-line:line-length-limit index := (atomic.AddUint32(&called, 1) - 1) / uint32(minerCount) if int(index) >= len(dls) { return nil, fmt.Errorf("invalid index %d", index) @@ -334,7 +363,18 @@ func TestHandleHeadChange(t *testing.T) { } runner := &mockRunner{} - poster, err := newPoSterWithRunnerConstructor(scfg, &mockChain, nil, nil, chain.NewMinerAPI(&mockChain, scfg), nil, nil, nil, nil, mockRunnerConstructor(runner)) + poster, err := newPoSterWithRunnerConstructor( + scfg, + &mockChain, + nil, + nil, + chain.NewMinerAPI(&mockChain, scfg), + nil, + nil, + nil, + nil, + mockRunnerConstructor(runner), + ) require.NoError(t, err, "new poster") for di := range dls { @@ -360,11 +400,22 @@ func TestHandleHeadChange(t *testing.T) { runner := &mockRunner{} dl := deadlineAt(10000, 0) - mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { + mockChain.IMinerStateStruct.Internal.StateMinerProvingDeadline = func(p0 context.Context, p1 address.Address, p2 types.TipSetKey) (*dline.Info, error) { //revive:disable-line:line-length-limit return dl, nil } - poster, err := newPoSterWithRunnerConstructor(scfg, &mockChain, nil, nil, chain.NewMinerAPI(&mockChain, scfg), nil, nil, nil, nil, mockRunnerConstructor(runner)) + poster, err := newPoSterWithRunnerConstructor( + scfg, + &mockChain, + nil, + nil, + chain.NewMinerAPI(&mockChain, scfg), + nil, + nil, + nil, + nil, + mockRunnerConstructor(runner), + ) require.NoError(t, err, "new poster") ts := mockTipSet(t, dl.Open) diff --git a/damocles-manager/modules/poster/runner.go b/damocles-manager/modules/poster/runner.go index 71922879a..38e65265a 100644 --- a/damocles-manager/modules/poster/runner.go +++ b/damocles-manager/modules/poster/runner.go @@ -33,7 +33,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/slices" ) -type runnerConstructor func(ctx context.Context, deps postDeps, mid abi.ActorID, maddr address.Address, proofType abi.RegisteredPoStProof, dinfo *dline.Info) PoStRunner +type runnerConstructor func(ctx context.Context, deps postDeps, mid abi.ActorID, maddr address.Address, proofType abi.RegisteredPoStProof, dinfo *dline.Info) PoStRunner //revive:disable-line:line-length-limit // PoStRunner 的各方法应当保持 Once 语义 type PoStRunner interface { @@ -57,7 +57,14 @@ type proofResult struct { proofs []miner.SubmitWindowedPoStParams } -func postRunnerConstructor(ctx context.Context, deps postDeps, mid abi.ActorID, maddr address.Address, proofType abi.RegisteredPoStProof, dinfo *dline.Info) PoStRunner { +func postRunnerConstructor( + ctx context.Context, + deps postDeps, + mid abi.ActorID, + maddr address.Address, + proofType abi.RegisteredPoStProof, + dinfo *dline.Info, +) PoStRunner { ctx, cancel := context.WithCancel(ctx) return &postRunner{ deps: deps, @@ -66,8 +73,19 @@ func postRunnerConstructor(ctx context.Context, deps postDeps, mid abi.ActorID, proofType: proofType, dinfo: dinfo, ctx: ctx, - log: log.With("mid", mid, "ddl-idx", dinfo.Index, "ddl-open", dinfo.Open, "ddl-close", dinfo.Close, "ddl-challenge", dinfo.Challenge), - cancel: cancel, + log: log.With( + "mid", + mid, + "ddl-idx", + dinfo.Index, + "ddl-open", + dinfo.Open, + "ddl-close", + dinfo.Close, + "ddl-challenge", + dinfo.Challenge, + ), + cancel: cancel, } } @@ -125,7 +143,11 @@ func (pr *postRunner) abort() { }) } -func (pr *postRunner) submitPoSts(pcfg *modules.MinerPoStConfig, ts *types.TipSet, proofs []miner.SubmitWindowedPoStParams) { +func (pr *postRunner) submitPoSts( + pcfg *modules.MinerPoStConfig, + ts *types.TipSet, + proofs []miner.SubmitWindowedPoStParams, +) { if len(proofs) == 0 { return } @@ -165,7 +187,11 @@ func (pr *postRunner) submitPoSts(pcfg *modules.MinerPoStConfig, ts *types.TipSe } } -func (pr *postRunner) submitSinglePost(slog *logging.ZapLogger, _ *modules.MinerPoStConfig, proof *miner.SubmitWindowedPoStParams) { +func (pr *postRunner) submitSinglePost( + slog *logging.ZapLogger, + _ *modules.MinerPoStConfig, + proof *miner.SubmitWindowedPoStParams, +) { // to avoid being cancelled by proving period detection, use context.Background here uid, resCh, err := pr.publishMessage(stbuiltin.MethodsMiner.SubmitWindowedPoSt, proof, false) if err != nil { @@ -234,12 +260,15 @@ func (pr *postRunner) generatePoSt(baseLog *logging.ZapLogger) { batchPartitionStartIdx += len(batch) } - - return } -func (pr *postRunner) generatePoStForPartitionBatch(glog *logging.ZapLogger, rand core.WindowPoStRandomness, batchIdx int, batch []chain.Partition, batchPartitionStartIdx int) { - +func (pr *postRunner) generatePoStForPartitionBatch( + glog *logging.ZapLogger, + rand core.WindowPoStRandomness, + batchIdx int, + batch []chain.Partition, + batchPartitionStartIdx int, +) { params := miner.SubmitWindowedPoStParams{ Deadline: pr.dinfo.Index, Partitions: make([]miner.PoStPartition, 0, len(batch)), @@ -350,7 +379,12 @@ func (pr *postRunner) generatePoStForPartitionBatch(glog *logging.ZapLogger, ran return true, fmt.Errorf("getting current head: %w", err) } - checkRand, err := pr.deps.rand.GetWindowPoStChanlleengeRand(pr.ctx, headTs.Key(), pr.dinfo.Challenge, pr.mid) + checkRand, err := pr.deps.rand.GetWindowPoStChanlleengeRand( + pr.ctx, + headTs.Key(), + pr.dinfo.Challenge, + pr.mid, + ) if err != nil { return true, fmt.Errorf("get chain randomness for checking from beacon for window post: %w", err) } @@ -442,7 +476,6 @@ func (pr *postRunner) generatePoStForPartitionBatch(glog *logging.ZapLogger, ran alog.Debug("retry partition batch") } - } func (pr *postRunner) sectorsForProof(goodSectors, allSectors bitfield.BitField) ([]builtin.ExtendedSectorInfo, error) { @@ -546,8 +579,6 @@ func (pr *postRunner) handleFaults(baseLog *logging.ZapLogger) { // TODO: This is also potentially really bad, but we try to post anyways hflog.Errorf("checking sector faults: %v", err) } - - return } func (pr *postRunner) checkRecoveries(l *logging.ZapLogger, declIndex uint64, partitions []chain.Partition) error { @@ -637,7 +668,11 @@ func (pr *postRunner) checkRecoveries(l *logging.ZapLogger, declIndex uint64, pa if recoverSectorsLimit > 0 { // something weird happened, break because we can't recover any more if recoverSectorsLimit < recoverTotal { - log.Warnf("accepted more recoveries (%d) than RecoveringSectorLimit (%d)", recoverTotal, recoverSectorsLimit) + log.Warnf( + "accepted more recoveries (%d) than RecoveringSectorLimit (%d)", + recoverTotal, + recoverSectorsLimit, + ) break } @@ -651,7 +686,11 @@ func (pr *postRunner) checkRecoveries(l *logging.ZapLogger, declIndex uint64, pa break } - log.Warnf("only adding %d sectors to respect RecoveringSectorLimit %d", maxNewRecoverable, recoverSectorsLimit) + log.Warnf( + "only adding %d sectors to respect RecoveringSectorLimit %d", + maxNewRecoverable, + recoverSectorsLimit, + ) recovered = bitfield.NewFromSet(recoverySlice[:maxNewRecoverable]) recoveredCount = maxNewRecoverable @@ -668,7 +707,6 @@ func (pr *postRunner) checkRecoveries(l *logging.ZapLogger, declIndex uint64, pa if max := pr.startCtx.pcfg.MaxPartitionsPerRecoveryMessage; max > 0 && len(currentParams.Recoveries) >= int(max) { - go handleRecoverMessage(currentParams) currentParams = newParams() } @@ -766,7 +804,7 @@ func (pr *postRunner) checkSectors(clog *logging.ZapLogger, check bitfield.BitFi } sectors := make(map[abi.SectorNumber]struct{}) - var tocheck []builtin.ExtendedSectorInfo + tocheck := []builtin.ExtendedSectorInfo{} for _, info := range sectorInfos { sectors[info.SectorNumber] = struct{}{} tocheck = append(tocheck, util.SectorOnChainInfoToExtended(info)) @@ -811,7 +849,11 @@ type msgResult struct { err error } -func (pr *postRunner) publishMessage(method abi.MethodNum, params cbor.Marshaler, useExtraMsgID bool) (string, <-chan msgResult, error) { +func (pr *postRunner) publishMessage( + method abi.MethodNum, + params cbor.Marshaler, + useExtraMsgID bool, +) (string, <-chan msgResult, error) { encoded, aerr := actors.SerializeParams(params) if aerr != nil { return "", nil, fmt.Errorf("serialize params: %w", aerr) diff --git a/damocles-manager/modules/poster/runner_test.go b/damocles-manager/modules/poster/runner_test.go index 1df8d8361..01b6c813f 100644 --- a/damocles-manager/modules/poster/runner_test.go +++ b/damocles-manager/modules/poster/runner_test.go @@ -19,7 +19,7 @@ import ( ) func mockRunnerConstructor(runner *mockRunner) runnerConstructor { - return func(ctx context.Context, deps postDeps, mid abi.ActorID, maddr address.Address, proofType abi.RegisteredPoStProof, dinfo *dline.Info) PoStRunner { + return func(ctx context.Context, deps postDeps, mid abi.ActorID, maddr address.Address, proofType abi.RegisteredPoStProof, dinfo *dline.Info) PoStRunner { //revive:disable-line:line-length-limit return runner } } diff --git a/damocles-manager/modules/poster/scheduler_test.go b/damocles-manager/modules/poster/scheduler_test.go index 966f7edc3..192c56fa9 100644 --- a/damocles-manager/modules/poster/scheduler_test.go +++ b/damocles-manager/modules/poster/scheduler_test.go @@ -76,8 +76,12 @@ func TestScheduler(t *testing.T) { // disabled pcfg.Enabled = false - require.Falsef(t, sched.shouldStart(&pcfg, start+half), "%#v: half with customized confidence, disabled", dl) - + require.Falsef( + t, + sched.shouldStart(&pcfg, start+half), + "%#v: half with customized confidence, disabled", + dl, + ) } }) @@ -127,5 +131,4 @@ func TestScheduler(t *testing.T) { require.True(t, sched.shouldAbort(&before, dl.Challenge), "%#v: revert to before", dl) } }) - } diff --git a/damocles-manager/modules/sealer/sealer.go b/damocles-manager/modules/sealer/sealer.go index 86dae9c6f..122077d3b 100644 --- a/damocles-manager/modules/sealer/sealer.go +++ b/damocles-manager/modules/sealer/sealer.go @@ -26,9 +26,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/piecestore" ) -var ( - ErrSectorAllocated = fmt.Errorf("sector allocated") -) +var ErrSectorAllocated = fmt.Errorf("sector allocated") var _ core.SealerAPI = (*Sealer)(nil) @@ -50,6 +48,7 @@ func sectorStateErr(err error) error { return fmt.Errorf("sector state: %w", err) } +//revive:disable-next-line:argument-limit func New( scfg *modules.SafeConfig, capi chain.API, @@ -144,7 +143,11 @@ func (s *Sealer) AllocateSector(ctx context.Context, spec core.AllocateSectorSpe return nil, nil } -func (s *Sealer) AllocateSectorsBatch(ctx context.Context, spec core.AllocateSectorSpec, count uint32) ([]*core.AllocatedSector, error) { +func (s *Sealer) AllocateSectorsBatch( + ctx context.Context, + spec core.AllocateSectorSpec, + count uint32, +) ([]*core.AllocatedSector, error) { sectors, err := s.sector.Allocate(ctx, spec, count) if err != nil { return nil, err @@ -177,7 +180,11 @@ func (s *Sealer) AllocateSectorsBatch(ctx context.Context, spec core.AllocateSec return sectors, nil } -func (s *Sealer) AcquireDeals(ctx context.Context, sid abi.SectorID, spec core.AcquireDealsSpec) (core.SectorPieces, error) { +func (s *Sealer) AcquireDeals( + ctx context.Context, + sid abi.SectorID, + spec core.AcquireDealsSpec, +) (core.SectorPieces, error) { state, err := s.state.Load(ctx, sid, core.WorkerOnline) if err != nil { return nil, sectorStateErr(err) @@ -265,7 +272,12 @@ func (s *Sealer) AssignTicket(ctx context.Context, sid abi.SectorID) (core.Ticke return ticket, nil } -func (s *Sealer) SubmitPreCommit(ctx context.Context, sector core.AllocatedSector, info core.PreCommitOnChainInfo, hardReset bool) (core.SubmitPreCommitResp, error) { +func (s *Sealer) SubmitPreCommit( + ctx context.Context, + sector core.AllocatedSector, + info core.PreCommitOnChainInfo, + hardReset bool, +) (core.SubmitPreCommitResp, error) { pinfo, err := info.IntoPreCommitInfo() if err != nil { return core.SubmitPreCommitResp{}, err @@ -288,7 +300,12 @@ func (s *Sealer) SubmitPersisted(ctx context.Context, sid abi.SectorID, instance return s.SubmitPersistedEx(ctx, sid, instance, false) } -func (s *Sealer) SubmitPersistedEx(ctx context.Context, sid abi.SectorID, instance string, isUpgrade bool) (bool, error) { +func (s *Sealer) SubmitPersistedEx( + ctx context.Context, + sid abi.SectorID, + instance string, + isUpgrade bool, +) (bool, error) { state, err := s.state.Load(ctx, sid, core.WorkerOnline) if err != nil { return false, sectorStateErr(err) @@ -370,7 +387,12 @@ func (s *Sealer) WaitSeed(ctx context.Context, sid abi.SectorID) (core.WaitSeedR }, nil } -func (s *Sealer) SubmitProof(ctx context.Context, sid abi.SectorID, info core.ProofOnChainInfo, hardReset bool) (core.SubmitProofResp, error) { +func (s *Sealer) SubmitProof( + ctx context.Context, + sid abi.SectorID, + info core.ProofOnChainInfo, + hardReset bool, +) (core.SubmitProofResp, error) { resp, err := s.commit.SubmitProof(ctx, sid, info, hardReset) if err == nil { ctx, _ = metrics.New(ctx, metrics.Upsert(metrics.Miner, sid.Miner.String())) @@ -384,7 +406,11 @@ func (s *Sealer) PollProofState(ctx context.Context, sid abi.SectorID) (core.Pol return resp, sectorStateErr(err) } -func (s *Sealer) ReportState(ctx context.Context, sid abi.SectorID, req core.ReportStateReq) (*core.SectorStateResp, error) { +func (s *Sealer) ReportState( + ctx context.Context, + sid abi.SectorID, + req core.ReportStateReq, +) (*core.SectorStateResp, error) { state, err := s.state.Load(ctx, sid, core.WorkerOnline) if err != nil { if !errors.Is(err, kvstore.ErrKeyNotFound) { @@ -411,9 +437,9 @@ func (s *Sealer) ReportState(ctx context.Context, sid abi.SectorID, req core.Rep func (s *Sealer) ReportFinalized(ctx context.Context, sid abi.SectorID) (core.Meta, error) { sectorLogger(sid).Info("sector finalized") if err := s.state.Finalize(ctx, sid, func(st *core.SectorState) (bool, error) { - // Upgrading sectors are not finalized via api calls - // Except in the case of sector rebuild and unseal, because the prerequisite for sector rebuild is that the sector has been finalized. + // Except in the case of sector rebuild and unseal, + // because the prerequisite for sector rebuild is that the sector has been finalized. if bool(st.Unsealing) { st.Unsealing = false } else if bool(st.NeedRebuild) { @@ -458,7 +484,6 @@ func (s *Sealer) ReportAborted(ctx context.Context, sid abi.SectorID, reason str st.AbortReason = reason return true, nil }) - if err != nil { return core.Empty, sectorStateErr(err) } @@ -471,7 +496,10 @@ func (s *Sealer) ReportAborted(ctx context.Context, sid abi.SectorID, reason str } // snap -func (s *Sealer) AllocateSanpUpSector(ctx context.Context, spec core.AllocateSnapUpSpec) (*core.AllocatedSnapUpSector, error) { +func (s *Sealer) AllocateSanpUpSector( + ctx context.Context, + spec core.AllocateSnapUpSpec, +) (*core.AllocatedSnapUpSector, error) { candidateSector, err := s.snapup.Allocate(ctx, spec.Sector) if err != nil { return nil, fmt.Errorf("allocate snapup sector: %w", err) @@ -546,7 +574,14 @@ func (s *Sealer) AllocateSanpUpSector(ctx context.Context, spec core.AllocateSna } if err != nil { - ierr := s.state.InitWith(ctx, []*core.AllocatedSector{{ID: candidateSector.Sector.ID, ProofType: candidateSector.Sector.ProofType}}, core.WorkerOnline, core.SectorUpgraded(true), pieces, &upgradePublic) + ierr := s.state.InitWith( + ctx, + []*core.AllocatedSector{{ID: candidateSector.Sector.ID, ProofType: candidateSector.Sector.ProofType}}, + core.WorkerOnline, + core.SectorUpgraded(true), + pieces, + &upgradePublic, + ) if ierr != nil { return nil, fmt.Errorf("init non-exist snapup sector: %w", ierr) } @@ -561,7 +596,11 @@ func (s *Sealer) AllocateSanpUpSector(ctx context.Context, spec core.AllocateSna }, nil } -func (s *Sealer) SubmitSnapUpProof(ctx context.Context, sid abi.SectorID, snapupInfo core.SnapUpOnChainInfo) (core.SubmitSnapUpProofResp, error) { +func (s *Sealer) SubmitSnapUpProof( + ctx context.Context, + sid abi.SectorID, + snapupInfo core.SnapUpOnChainInfo, +) (core.SubmitSnapUpProofResp, error) { resp := core.SubmitSnapUpProofResp{} desc := "" @@ -643,7 +682,13 @@ func (s *Sealer) SubmitSnapUpProof(ctx context.Context, sid abi.SectorID, snapup return resp, nil } -func (s *Sealer) checkPersistedFiles(ctx context.Context, sid abi.SectorID, proofType abi.RegisteredSealProof, instance string, upgrade bool) (bool, error) { +func (s *Sealer) checkPersistedFiles( + ctx context.Context, + sid abi.SectorID, + proofType abi.RegisteredSealProof, + instance string, + upgrade bool, +) (bool, error) { locator := core.SectorLocator(func(lctx context.Context, lsid abi.SectorID) (core.SectorAccessStores, bool, error) { if lsid != sid { return core.SectorAccessStores{}, false, nil @@ -662,13 +707,26 @@ func (s *Sealer) checkPersistedFiles(ctx context.Context, sid abi.SectorID, proo if err != nil { return false, fmt.Errorf("convert to v1_1 post proof: %w", err) } - err = s.sectorProving.SingleProvable(ctx, ppt, core.SectorRef{ID: sid, ProofType: proofType}, upgrade, locator, false, false) + err = s.sectorProving.SingleProvable( + ctx, + ppt, + core.SectorRef{ID: sid, ProofType: proofType}, + upgrade, + locator, + false, + false, + ) if err != nil { if errors.Is(err, objstore.ErrObjectNotFound) { return false, nil } - return false, fmt.Errorf("check provable for sector %s in instance %s: %w", util.FormatSectorID(sid), instance, err) + return false, fmt.Errorf( + "check provable for sector %s in instance %s: %w", + util.FormatSectorID(sid), + instance, + err, + ) } return true, nil @@ -681,7 +739,12 @@ func checkPieces(pieces core.SectorPieces) error { if pinfo.IsBuiltinMarket() && !pinfo.HasDealInfo() { expected := zerocomm.ZeroPieceCommitment(pinfo.Piece.Size.Unpadded()) if !expected.Equals(pinfo.DealInfo.PieceCID) { - return fmt.Errorf("got unexpected non-deal piece with seq=#%d, size=%d, cid=%s", pi, pinfo.Piece.Size, pinfo.DealInfo.PieceCID) + return fmt.Errorf( + "got unexpected non-deal piece with seq=#%d, size=%d, cid=%s", + pi, + pinfo.Piece.Size, + pinfo.DealInfo.PieceCID, + ) } } } @@ -731,7 +794,12 @@ func (s *Sealer) WorkerPing(ctx context.Context, winfo core.WorkerInfo) (core.Me return core.Empty, nil } -func (s *Sealer) StoreReserveSpace(ctx context.Context, sid abi.SectorID, size uint64, candidates []string) (*core.StoreBasicInfo, error) { +func (s *Sealer) StoreReserveSpace( + ctx context.Context, + sid abi.SectorID, + size uint64, + candidates []string, +) (*core.StoreBasicInfo, error) { // TODO: check state? _, err := s.state.Load(ctx, sid, core.WorkerOnline) if err != nil { @@ -766,7 +834,10 @@ func (s *Sealer) StoreBasicInfo(ctx context.Context, instanceName string) (*core return &basic, nil } -func (s *Sealer) AllocateRebuildSector(ctx context.Context, spec core.AllocateSectorSpec) (*core.SectorRebuildInfo, error) { +func (s *Sealer) AllocateRebuildSector( + ctx context.Context, + spec core.AllocateSectorSpec, +) (*core.SectorRebuildInfo, error) { info, err := s.rebuild.Allocate(ctx, spec) if err != nil { return nil, fmt.Errorf("allocate rebuild sector: %w", err) @@ -784,7 +855,10 @@ func (s *Sealer) AllocateRebuildSector(ctx context.Context, spec core.AllocateSe return info, nil } -func (s *Sealer) AllocateUnsealSector(ctx context.Context, spec core.AllocateSectorSpec) (*core.SectorUnsealInfo, error) { +func (s *Sealer) AllocateUnsealSector( + ctx context.Context, + spec core.AllocateSectorSpec, +) (*core.SectorUnsealInfo, error) { info, err := s.unseal.Allocate(ctx, spec) if err != nil { return nil, fmt.Errorf("allocate unseal sector: %w", err) @@ -830,7 +904,12 @@ func (s *Sealer) AllocateUnsealSector(ctx context.Context, spec core.AllocateSec return info, nil } -func (s *Sealer) AchieveUnsealSector(ctx context.Context, sid abi.SectorID, pieceCid cid.Cid, errInfo string) (core.Meta, error) { +func (s *Sealer) AchieveUnsealSector( + ctx context.Context, + sid abi.SectorID, + pieceCid cid.Cid, + errInfo string, +) (core.Meta, error) { return core.Empty, s.unseal.Achieve(ctx, sid, pieceCid, errInfo) } diff --git a/damocles-manager/modules/sealer/sealer_cli.go b/damocles-manager/modules/sealer/sealer_cli.go index cc40ff6c8..f709e7ac6 100644 --- a/damocles-manager/modules/sealer/sealer_cli.go +++ b/damocles-manager/modules/sealer/sealer_cli.go @@ -27,7 +27,11 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/ver" ) -func (s *Sealer) ListSectors(ctx context.Context, ws core.SectorWorkerState, job core.SectorWorkerJob) ([]*core.SectorState, error) { +func (s *Sealer) ListSectors( + ctx context.Context, + ws core.SectorWorkerState, + job core.SectorWorkerJob, +) ([]*core.SectorState, error) { return s.state.All(ctx, ws, job) } @@ -56,11 +60,24 @@ func (s *Sealer) RestoreSector(ctx context.Context, sid abi.SectorID, forced boo return core.Empty, nil } -func (s *Sealer) CheckProvable(ctx context.Context, mid abi.ActorID, postProofType abi.RegisteredPoStProof, sectors []builtin.ExtendedSectorInfo, strict, stateCheck bool) (map[abi.SectorNumber]string, error) { +func (s *Sealer) CheckProvable( + ctx context.Context, + mid abi.ActorID, + postProofType abi.RegisteredPoStProof, + sectors []builtin.ExtendedSectorInfo, + strict, stateCheck bool, +) (map[abi.SectorNumber]string, error) { return s.sectorProving.Provable(ctx, mid, postProofType, sectors, strict, stateCheck) } -func (s *Sealer) SimulateWdPoSt(_ context.Context, ddlIndex, partitionIndex uint64, maddr address.Address, postProofType abi.RegisteredPoStProof, sis []builtin.ExtendedSectorInfo, rand abi.PoStRandomness) error { +func (s *Sealer) SimulateWdPoSt( + _ context.Context, + ddlIndex, partitionIndex uint64, + maddr address.Address, + postProofType abi.RegisteredPoStProof, + sis []builtin.ExtendedSectorInfo, + rand abi.PoStRandomness, +) error { mid, err := address.IDFromAddress(maddr) if err != nil { return err @@ -95,7 +112,11 @@ func (s *Sealer) SimulateWdPoSt(_ context.Context, ddlIndex, partitionIndex uint return nil } -func (s *Sealer) SnapUpPreFetch(ctx context.Context, mid abi.ActorID, dlindex *uint64) (*core.SnapUpFetchResult, error) { +func (s *Sealer) SnapUpPreFetch( + ctx context.Context, + mid abi.ActorID, + dlindex *uint64, +) (*core.SnapUpFetchResult, error) { count, diff, err := s.snapup.PreFetch(ctx, mid, dlindex) if err != nil { return nil, fmt.Errorf("prefetch: %w", err) @@ -136,7 +157,6 @@ func (s *Sealer) ProvingSectorInfo(ctx context.Context, sid abi.SectorID) (core. OnChain: *sinfo, Private: private, }, nil - } func (s *Sealer) WorkerGetPingInfo(ctx context.Context, name string) (*core.WorkerPingInfo, error) { @@ -165,7 +185,11 @@ func (s *Sealer) WorkerPingInfoRemove(ctx context.Context, name string) error { return s.workerMgr.Remove(ctx, name) } -func (s *Sealer) SectorIndexerFind(ctx context.Context, indexType core.SectorIndexType, sid abi.SectorID) (core.SectorIndexLocation, error) { +func (s *Sealer) SectorIndexerFind( + ctx context.Context, + indexType core.SectorIndexType, + sid abi.SectorID, +) (core.SectorIndexLocation, error) { var indexer core.SectorTypedIndexer switch indexType { @@ -366,7 +390,11 @@ func storeConfig2StoreBasic(ocfg *objstore.Config) core.StoreBasicInfo { } } -func (s *Sealer) FindSector(ctx context.Context, state core.SectorWorkerState, sid abi.SectorID) (*core.SectorState, error) { +func (s *Sealer) FindSector( + ctx context.Context, + state core.SectorWorkerState, + sid abi.SectorID, +) (*core.SectorState, error) { return s.state.Load(ctx, sid, state) } @@ -380,7 +408,11 @@ func (s *Sealer) FindSectorInAllStates(ctx context.Context, sid abi.SectorID) (* return nil, kvstore.ErrKeyNotFound } -func (s *Sealer) FindSectorsWithDeal(ctx context.Context, state core.SectorWorkerState, dealID abi.DealID) ([]*core.SectorState, error) { +func (s *Sealer) FindSectorsWithDeal( + ctx context.Context, + state core.SectorWorkerState, + dealID abi.DealID, +) ([]*core.SectorState, error) { if dealID == 0 { return nil, fmt.Errorf("empty deal id") } @@ -401,7 +433,6 @@ func (s *Sealer) FindSectorsWithDeal(ctx context.Context, state core.SectorWorke return nil }) - if err != nil { return nil, fmt.Errorf("iterate sectors: %w", err) } @@ -409,8 +440,11 @@ func (s *Sealer) FindSectorsWithDeal(ctx context.Context, state core.SectorWorke return sectors, nil } -func (s *Sealer) FindSectorWithPiece(ctx context.Context, state core.SectorWorkerState, pieceCid cid.Cid) (*core.SectorState, error) { - +func (s *Sealer) FindSectorWithPiece( + ctx context.Context, + state core.SectorWorkerState, + pieceCid cid.Cid, +) (*core.SectorState, error) { var ret *core.SectorState err := s.state.ForEach(ctx, state, core.SectorWorkerJobAll, func(ss core.SectorState) error { pieces := ss.SectorPiece() @@ -426,7 +460,6 @@ func (s *Sealer) FindSectorWithPiece(ctx context.Context, state core.SectorWorke } return nil }) - if err != nil { return nil, fmt.Errorf("iterate sectors: %w", err) } @@ -434,7 +467,12 @@ func (s *Sealer) FindSectorWithPiece(ctx context.Context, state core.SectorWorke return ret, nil } -func (s *Sealer) ImportSector(ctx context.Context, ws core.SectorWorkerState, state *core.SectorState, override bool) (bool, error) { +func (s *Sealer) ImportSector( + ctx context.Context, + ws core.SectorWorkerState, + state *core.SectorState, + override bool, +) (bool, error) { if state == nil { return false, nil } @@ -526,8 +564,14 @@ func (s *Sealer) SectorSetForRebuild(ctx context.Context, sid abi.SectorID, opt return true, nil } -func (s *Sealer) UnsealPiece(ctx context.Context, sid abi.SectorID, pieceCid cid.Cid, offset types.UnpaddedByteIndex, size abi.UnpaddedPieceSize, dest string) (<-chan []byte, error) { - +func (s *Sealer) UnsealPiece( + ctx context.Context, + sid abi.SectorID, + pieceCid cid.Cid, + offset types.UnpaddedByteIndex, + size abi.UnpaddedPieceSize, + dest string, +) (<-chan []byte, error) { var stream chan []byte req := &core.SectorUnsealInfo{ Sector: core.AllocatedSector{ @@ -573,12 +617,11 @@ func (s *Sealer) UnsealPiece(ctx context.Context, sid abi.SectorID, pieceCid cid buf := make([]byte, 2<<20) n, err := r.Read(buf) if err != nil { - if err == io.EOF { - readEnd = true - } else { + if err != io.EOF { log.Errorf("read piece file error: %v", err) return } + readEnd = true } // log buf with hex format log.Infof("read piece file: %x", buf[:n]) @@ -601,7 +644,6 @@ func (s *Sealer) UnsealPiece(ctx context.Context, sid abi.SectorID, pieceCid cid } } }() - } s.unseal.OnAchieve(ctx, sid, pieceCid, hook) } @@ -620,6 +662,6 @@ func (s *Sealer) UnsealPiece(ctx context.Context, sid abi.SectorID, pieceCid cid return stream, nil } -func (s *Sealer) Version(_ context.Context) (string, error) { +func (*Sealer) Version(_ context.Context) (string, error) { return ver.VersionStr(), nil } diff --git a/damocles-manager/modules/util/piece/piece.go b/damocles-manager/modules/util/piece/piece.go index 6a2edbb64..715e3e68a 100644 --- a/damocles-manager/modules/util/piece/piece.go +++ b/damocles-manager/modules/util/piece/piece.go @@ -13,13 +13,18 @@ import ( "github.com/filecoin-project/venus/venus-shared/actors/builtin/market" "github.com/filecoin-project/venus/venus-shared/types" "github.com/ipfs-force-community/damocles/damocles-manager/core" - chainAPI "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" + chainapi "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" ) // ProcessPieces returns either: // - a list of piece activation manifests // - a list of deal IDs, if all non-filler pieces are deal-id pieces -func ProcessPieces(ctx context.Context, sector *core.SectorState, chain chainAPI.API, lookupID core.LookupID) ([]miner13.PieceActivationManifest, []abi.DealID, error) { +func ProcessPieces( + ctx context.Context, + sector *core.SectorState, + chain chainapi.API, + lookupID core.LookupID, +) ([]miner13.PieceActivationManifest, []abi.DealID, error) { pams := make([]miner13.PieceActivationManifest, 0, len(sector.Pieces)) dealIDs := make([]abi.DealID, 0, len(sector.Pieces)) @@ -36,7 +41,7 @@ func ProcessPieces(ctx context.Context, sector *core.SectorState, chain chainAPI continue } pieceInfo := piece.PieceInfo() - if piece.IsBuiltinMarket() && hasDDO { + if hasDDO && piece.IsBuiltinMarket() { // mixed ddo and builtinmarket alloc, err := chain.StateGetAllocationIdForPendingDeal(ctx, piece.DealID(), types.EmptyTSK) if err != nil { diff --git a/damocles-manager/modules/util/pledge/alloc.go b/damocles-manager/modules/util/pledge/alloc.go index 3312ff57f..8c832ba52 100644 --- a/damocles-manager/modules/util/pledge/alloc.go +++ b/damocles-manager/modules/util/pledge/alloc.go @@ -12,11 +12,25 @@ import ( ) type AllocationAPI interface { - StateGetAllocationForPendingDeal(ctx context.Context, dealID abi.DealID, tsk types.TipSetKey) (*verifregtypes.Allocation, error) //perm:read - StateGetAllocation(ctx context.Context, clientAddr address.Address, allocationID verifregtypes.AllocationId, tsk types.TipSetKey) (*verifregtypes.Allocation, error) + StateGetAllocationForPendingDeal( + ctx context.Context, + dealID abi.DealID, + tsk types.TipSetKey, + ) (*verifregtypes.Allocation, error) + StateGetAllocation( + ctx context.Context, + clientAddr address.Address, + allocationID verifregtypes.AllocationId, + tsk types.TipSetKey, + ) (*verifregtypes.Allocation, error) } -func GetAllocation(ctx context.Context, aapi AllocationAPI, tsk types.TipSetKey, piece core.SectorPiece) (*verifregtypes.Allocation, error) { +func GetAllocation( + ctx context.Context, + aapi AllocationAPI, + tsk types.TipSetKey, + piece core.SectorPiece, +) (*verifregtypes.Allocation, error) { if !piece.HasDealInfo() { return nil, nil } @@ -26,7 +40,6 @@ func GetAllocation(ctx context.Context, aapi AllocationAPI, tsk types.TipSetKey, client := piece.Client() all, err := aapi.StateGetAllocation(ctx, client, piece.AllocationID(), tsk) - if err != nil { return nil, err } diff --git a/damocles-manager/modules/util/pledge/pledge.go b/damocles-manager/modules/util/pledge/pledge.go index 48df07ca6..f7cada7a9 100644 --- a/damocles-manager/modules/util/pledge/pledge.go +++ b/damocles-manager/modules/util/pledge/pledge.go @@ -18,8 +18,10 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/pkg/chain" ) -var initialPledgeNum = types.NewInt(110) -var initialPledgeDen = types.NewInt(100) +var ( + initialPledgeNum = types.NewInt(110) + initialPledgeDen = types.NewInt(100) +) func CalcPledgeForPower(ctx context.Context, api chain.API, addedPower abi.StoragePower) (abi.TokenAmount, error) { store := adt.WrapStore(ctx, cbor.NewCborStore(bstore.NewAPIBlockstore(api))) @@ -29,6 +31,7 @@ func CalcPledgeForPower(ctx context.Context, api chain.API, addedPower abi.Stora powerSmoothed builtin.FilterEstimate pledgeCollateral abi.TokenAmount ) + //nolint:all if act, err := api.StateGetActor(ctx, power.Address, types.EmptyTSK); err != nil { return types.EmptyInt, fmt.Errorf("loading power actor: %w", err) } else if s, err := power.Load(store, act); err != nil { @@ -73,19 +76,25 @@ func CalcPledgeForPower(ctx context.Context, api chain.API, addedPower abi.Stora return types.BigDiv(types.BigMul(initialPledge, initialPledgeNum), initialPledgeDen), nil } -func SectorWeight(ctx context.Context, sector *core.SectorState, proofType abi.RegisteredSealProof, chain chain.API, expiration abi.ChainEpoch) (abi.StoragePower, error) { +func SectorWeight( + ctx context.Context, + sector *core.SectorState, + proofType abi.RegisteredSealProof, + chainAPI chain.API, + expiration abi.ChainEpoch, +) (abi.StoragePower, error) { ssize, err := proofType.SectorSize() if err != nil { return types.EmptyInt, fmt.Errorf("getting sector size: %w", err) } - ts, err := chain.ChainHead(ctx) + ts, err := chainAPI.ChainHead(ctx) if err != nil { return types.EmptyInt, fmt.Errorf("getting chain head: %w", err) } // get verified deal infos - var w, vw = big.Zero(), big.Zero() + w, vw := big.Zero(), big.Zero() for _, piece := range sector.SectorPiece() { if !piece.HasDealInfo() { @@ -95,7 +104,7 @@ func SectorWeight(ctx context.Context, sector *core.SectorState, proofType abi.R pieceInfo := piece.PieceInfo() - alloc, err := GetAllocation(ctx, chain, ts.Key(), piece) + alloc, err := GetAllocation(ctx, chainAPI, ts.Key(), piece) if err != nil || alloc == nil { w = big.Add(w, abi.NewStoragePower(int64(pieceInfo.Size))) continue diff --git a/damocles-manager/pkg/chain/api.go b/damocles-manager/pkg/chain/api.go index 790a250f3..97e0da712 100644 --- a/damocles-manager/pkg/chain/api.go +++ b/damocles-manager/pkg/chain/api.go @@ -11,7 +11,7 @@ import ( "github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/venus/pkg/constants" "github.com/filecoin-project/venus/venus-shared/api" - v1 "github.com/filecoin-project/venus/venus-shared/api/chain/v1" + chainv1 "github.com/filecoin-project/venus/venus-shared/api/chain/v1" "github.com/filecoin-project/venus/venus-shared/types" ) @@ -26,20 +26,22 @@ type ( Partition = types.Partition ) -type API = v1.FullNode +type API = chainv1.FullNode -func New(ctx context.Context, api, token string) (API, jsonrpc.ClientCloser, error) { - client, closer, err := DialFullNodeRPC(ctx, api, token, nil, jsonrpc.WithRetry(true)) +func New(ctx context.Context, apiAddr, token string) (API, jsonrpc.ClientCloser, error) { + client, closer, err := DialFullNodeRPC(ctx, apiAddr, token, nil, jsonrpc.WithRetry(true)) if err != nil { return nil, nil, err } - client.IChainInfoStruct.Internal.StateNetworkVersion = cacheStateNetworkVersion(client.IChainInfoStruct.Internal.StateNetworkVersion) + client.IChainInfoStruct.Internal.StateNetworkVersion = cacheStateNetworkVersion( + client.IChainInfoStruct.Internal.StateNetworkVersion, + ) return client, closer, nil } -type MockStruct = v1.FullNodeStruct +type MockStruct = chainv1.FullNodeStruct type stateNetworkVersion func(p0 context.Context, p1 types.TipSetKey) (network.Version, error) @@ -51,7 +53,8 @@ func cacheStateNetworkVersion(inner stateNetworkVersion) stateNetworkVersion { var latestUpdate time.Time return func(p0 context.Context, p1 types.TipSetKey) (network.Version, error) { - if nv < constants.TestNetworkVersion && time.Since(latestUpdate) > time.Second*time.Duration(constants.MainNetBlockDelaySecs) { + if nv < constants.TestNetworkVersion && + time.Since(latestUpdate) > time.Second*time.Duration(constants.MainNetBlockDelaySecs) { var err error nv, err = inner(p0, p1) if err != nil { @@ -64,10 +67,17 @@ func cacheStateNetworkVersion(inner stateNetworkVersion) stateNetworkVersion { } } -// DialFullNodeRPC is modify from v1.DialFullNodeRPC, which will return a FullNodeStruct directly rather then a FullNode interface -func DialFullNodeRPC(ctx context.Context, addr string, token string, requestHeader http.Header, opts ...jsonrpc.Option) (*v1.FullNodeStruct, jsonrpc.ClientCloser, error) { +// DialFullNodeRPC is modify from chainV1.DialFullNodeRPC, +// which will return a FullNodeStruct directly rather then a FullNode interface +func DialFullNodeRPC( + ctx context.Context, + addr string, + token string, + requestHeader http.Header, + opts ...jsonrpc.Option, +) (*chainv1.FullNodeStruct, jsonrpc.ClientCloser, error) { ainfo := api.NewAPIInfo(addr, token) - endpoint, err := ainfo.DialArgs(api.VerString(v1.MajorVersion)) + endpoint, err := ainfo.DialArgs(api.VerString(chainv1.MajorVersion)) if err != nil { return nil, nil, fmt.Errorf("get dial args: %w", err) } @@ -75,11 +85,17 @@ func DialFullNodeRPC(ctx context.Context, addr string, token string, requestHead if requestHeader == nil { requestHeader = http.Header{} } - requestHeader.Set(api.VenusAPINamespaceHeader, v1.APINamespace) + requestHeader.Set(api.VenusAPINamespaceHeader, chainv1.APINamespace) ainfo.SetAuthHeader(requestHeader) - var res v1.FullNodeStruct - closer, err := jsonrpc.NewMergeClient(ctx, endpoint, v1.MethodNamespace, api.GetInternalStructs(&res), requestHeader, opts...) + var res chainv1.FullNodeStruct + closer, err := jsonrpc.NewMergeClient( + ctx, + endpoint, + chainv1.MethodNamespace, + api.GetInternalStructs(&res), + requestHeader, + opts...) return &res, closer, err } diff --git a/damocles-manager/pkg/chain/eventbus.go b/damocles-manager/pkg/chain/eventbus.go index ead3099c1..7a3b7855c 100644 --- a/damocles-manager/pkg/chain/eventbus.go +++ b/damocles-manager/pkg/chain/eventbus.go @@ -72,7 +72,12 @@ func (e *EventBus) Stop() { } // exec callback func when receive tipset with epoch >= height + confidential -func (e *EventBus) At(_ context.Context, height abi.ChainEpoch, confidential abi.ChainEpoch, callback func(ts *types.TipSet)) { +func (e *EventBus) At( + _ context.Context, + height abi.ChainEpoch, + confidential abi.ChainEpoch, + callback func(ts *types.TipSet), +) { if callback == nil { return } diff --git a/damocles-manager/pkg/chain/miner_api.go b/damocles-manager/pkg/chain/miner_api.go index 43dede491..c8991fe55 100644 --- a/damocles-manager/pkg/chain/miner_api.go +++ b/damocles-manager/pkg/chain/miner_api.go @@ -70,7 +70,6 @@ func (m *MinerAPI) GetInfo(ctx context.Context, mid abi.ActorID) (mi *core.Miner mi, ok := m.cache[mid] m.cacheMu.RUnlock() if !ok { - maddr, err := address.NewIDAddress(uint64(mid)) if err != nil { return nil, err diff --git a/damocles-manager/pkg/confmgr/conf_mgr.go b/damocles-manager/pkg/confmgr/conf_mgr.go index be486df61..d147b8363 100644 --- a/damocles-manager/pkg/confmgr/conf_mgr.go +++ b/damocles-manager/pkg/confmgr/conf_mgr.go @@ -13,9 +13,7 @@ import ( var log = logging.New("confmgr") -var ( - _ ConfigManager = (*localMgr)(nil) -) +var _ ConfigManager = (*localMgr)(nil) type ConfigUnmarshaller interface { UnmarshalConfig([]byte) error @@ -34,14 +32,14 @@ type WLocker interface { } type ConfigManager interface { - Load(ctx context.Context, key string, c interface{}) error - SetDefault(ctx context.Context, key string, c interface{}) error - Watch(ctx context.Context, key string, c interface{}, wlock WLocker, newfn func() interface{}) error + Load(ctx context.Context, key string, c any) error + SetDefault(ctx context.Context, key string, c any) error + Watch(ctx context.Context, key string, c any, wlock WLocker, newfn func() any) error Run(ctx context.Context) error Close(ctx context.Context) error } -func ConfigComment(t interface{}) ([]byte, error) { +func ConfigComment(t any) ([]byte, error) { buf := new(bytes.Buffer) _, _ = buf.WriteString("# Default config:\n") e := toml.NewEncoder(buf) diff --git a/damocles-manager/pkg/confmgr/local_mgr.go b/damocles-manager/pkg/confmgr/local_mgr.go index 8c69fdd73..f672c8f44 100644 --- a/damocles-manager/pkg/confmgr/local_mgr.go +++ b/damocles-manager/pkg/confmgr/local_mgr.go @@ -16,11 +16,11 @@ import ( ) type cfgItem struct { - c interface{} + c any crv reflect.Value wlock WLocker cancel context.CancelFunc - newfn func() interface{} + newfn func() any } func NewLocal(dir string) (ConfigManager, error) { @@ -40,11 +40,11 @@ type localMgr struct { } func (lm *localMgr) Run(ctx context.Context) error { - go lm.run(ctx) + go lm.runInner(ctx) return nil } -func (lm *localMgr) run(ctx context.Context) { +func (lm *localMgr) runInner(ctx context.Context) { log.Info("local conf mgr start") defer log.Info("local conf mgr stop") @@ -64,12 +64,10 @@ func (lm *localMgr) run(ctx context.Context) { } lm.regmu.Unlock() } - } - } -func (lm *localMgr) Close(context.Context) error { +func (*localMgr) Close(context.Context) error { return nil } @@ -77,7 +75,7 @@ func (lm *localMgr) cfgpath(key string) string { return filepath.Join(lm.dir, fmt.Sprintf("%s.cfg", key)) } -func (lm *localMgr) SetDefault(_ context.Context, key string, c interface{}) error { +func (lm *localMgr) SetDefault(_ context.Context, key string, c any) error { fname := lm.cfgpath(key) _, err := os.Stat(fname) if err == nil { @@ -93,10 +91,10 @@ func (lm *localMgr) SetDefault(_ context.Context, key string, c interface{}) err return fmt.Errorf("marshal default content: %w", err) } - return os.WriteFile(fname, content, 0644) + return os.WriteFile(fname, content, 0644) //nolint } -func (lm *localMgr) Load(_ context.Context, key string, c interface{}) error { +func (lm *localMgr) Load(_ context.Context, key string, c any) error { fname := lm.cfgpath(key) data, err := os.ReadFile(fname) if err != nil { @@ -106,7 +104,7 @@ func (lm *localMgr) Load(_ context.Context, key string, c interface{}) error { return lm.unmarshal(data, c) } -func (lm *localMgr) unmarshal(data []byte, obj interface{}) error { +func (*localMgr) unmarshal(data []byte, obj any) error { if un, ok := obj.(ConfigUnmarshaller); ok { return un.UnmarshalConfig(data) } @@ -114,8 +112,7 @@ func (lm *localMgr) unmarshal(data []byte, obj interface{}) error { return toml.Unmarshal(data, obj) } -func (lm *localMgr) Watch(_ context.Context, key string, c interface{}, wlock WLocker, newfn func() interface{}) error { - +func (lm *localMgr) Watch(_ context.Context, key string, c any, wlock WLocker, newfn func() any) error { maybe := newfn() valC := reflect.ValueOf(c) typC := valC.Type() diff --git a/damocles-manager/pkg/extproc/config.go b/damocles-manager/pkg/extproc/config.go index 873a2a8d3..2dd8387ee 100644 --- a/damocles-manager/pkg/extproc/config.go +++ b/damocles-manager/pkg/extproc/config.go @@ -1,5 +1,6 @@ package extproc +// nolint: flag-parameter func DefaultExtProcessorConfig(example bool) ExtProcessorConfig { pcfg := ExtProcessorConfig{ Args: []string{}, diff --git a/damocles-manager/pkg/extproc/extproc.go b/damocles-manager/pkg/extproc/extproc.go index aca105a47..d749b0a69 100644 --- a/damocles-manager/pkg/extproc/extproc.go +++ b/damocles-manager/pkg/extproc/extproc.go @@ -90,12 +90,22 @@ func (p *Processor) findCandidateExt() (*ExtProcessor, bool, error) { } } - log.Debugw("ext processor selected", "candidates", len(available), "weights-max", totalWeight, "weight-selected", choice, "candidate-index", chosenIdx) + log.Debugw( + "ext processor selected", + "candidates", + len(available), + "weights-max", + totalWeight, + "weight-selected", + choice, + "candidate-index", + chosenIdx, + ) return available[chosenIdx], true, nil } -func (p *Processor) Process(ctx context.Context, data interface{}, res interface{}) error { +func (p *Processor) Process(ctx context.Context, data any, res any) error { ext, ok, err := p.findCandidateExt() if err != nil { return fmt.Errorf("find candidate sub processor: %w", err) @@ -153,7 +163,6 @@ func waitForReady(ctx context.Context, reader *bufio.Reader, stageName string, t ready <- fmt.Errorf("unexpected ready message %q", msg) return } - }() select { @@ -213,7 +222,7 @@ func newExtProcessor(ctx context.Context, stageName string, cfg ExtProcessorConf err = waitForReady(ctx, stdreader, stageName, time.Duration(readySecs)*time.Second) if err != nil { - cmd.Process.Kill() // nolint: errcheck + _ = cmd.Process.Kill() return nil, fmt.Errorf("wait for ready: %w", err) } @@ -237,7 +246,6 @@ func newExtProcessor(ctx context.Context, stageName string, cfg ExtProcessorConf respCh: make(chan Response, 1), reqSeq: 0, }, nil - } type ExtProcessor struct { @@ -269,8 +277,8 @@ func (ep *ExtProcessor) start(ctx context.Context) { func (ep *ExtProcessor) stop() { _ = ep.cmd.Process.Kill() _ = ep.cmd.Wait() - ep.rawStdIn.Close() - ep.rawStdOut.Close() + _ = ep.rawStdIn.Close() + _ = ep.rawStdOut.Close() } func (ep *ExtProcessor) handleResponse(ctx context.Context) { @@ -352,7 +360,7 @@ LOOP: } } -func (ep *ExtProcessor) process(ctx context.Context, data interface{}, res interface{}) error { +func (ep *ExtProcessor) process(ctx context.Context, data any, res any) error { req := Request{ ID: atomic.AddUint64(&ep.reqSeq, 1), } @@ -381,7 +389,6 @@ func (ep *ExtProcessor) process(ctx context.Context, data interface{}, res inter req: req, respCh: respCh, }: - } select { diff --git a/damocles-manager/pkg/extproc/io.go b/damocles-manager/pkg/extproc/io.go index 43d2fc6d3..bd2639b39 100644 --- a/damocles-manager/pkg/extproc/io.go +++ b/damocles-manager/pkg/extproc/io.go @@ -24,7 +24,7 @@ func WriteReadyMessage(w *bufio.Writer, taskName string) error { return nil } -func WriteData(w *bufio.Writer, data interface{}) (int, error) { +func WriteData(w *bufio.Writer, data any) (int, error) { b, err := json.Marshal(data) if err != nil { return 0, fmt.Errorf("marshal data object: %w", err) diff --git a/damocles-manager/pkg/extproc/req_resp.go b/damocles-manager/pkg/extproc/req_resp.go index e70d7d9ba..7d6b18d9a 100644 --- a/damocles-manager/pkg/extproc/req_resp.go +++ b/damocles-manager/pkg/extproc/req_resp.go @@ -10,7 +10,7 @@ type Request struct { Data json.RawMessage `json:"task"` } -func (r *Request) SetData(data interface{}) error { +func (r *Request) SetData(data any) error { b, err := json.Marshal(data) if err != nil { return fmt.Errorf("json marshal: %w", err) @@ -20,7 +20,7 @@ func (r *Request) SetData(data interface{}) error { return nil } -func (r *Request) DecodeInto(v interface{}) error { +func (r *Request) DecodeInto(v any) error { err := json.Unmarshal(r.Data, v) if err != nil { return fmt.Errorf("json unmarshal: %w", err) @@ -35,7 +35,7 @@ type Response struct { Result json.RawMessage `json:"output"` } -func (r *Response) SetResult(res interface{}) { +func (r *Response) SetResult(res any) { b, err := json.Marshal(res) if err != nil { errMsg := err.Error() @@ -46,7 +46,7 @@ func (r *Response) SetResult(res interface{}) { r.Result = b } -func (r *Response) DecodeInto(v interface{}) error { +func (r *Response) DecodeInto(v any) error { err := json.Unmarshal(r.Result, v) if err != nil { return fmt.Errorf("json unmarshal: %w", err) diff --git a/damocles-manager/pkg/extproc/stage/ext_window_post.go b/damocles-manager/pkg/extproc/stage/ext_window_post.go index d99d9976e..7100116c3 100644 --- a/damocles-manager/pkg/extproc/stage/ext_window_post.go +++ b/damocles-manager/pkg/extproc/stage/ext_window_post.go @@ -10,7 +10,6 @@ const NameWindowPoSt = "window_post" func ProofType2String(proofType abi.RegisteredPoStProof) string { switch proofType { - case abi.RegisteredPoStProof_StackedDrgWinning2KiBV1: return "StackedDrgWinning2KiBV1" case abi.RegisteredPoStProof_StackedDrgWinning8MiBV1: @@ -35,6 +34,7 @@ func ProofType2String(proofType abi.RegisteredPoStProof) string { // rust-filecoin-proofs-api WindowPoSt uses api_version // V1_2 to fix the grindability issue, which we map here // as V1_1 for Venus/Lotus/actors compat reasons. + //revive:disable-line:line-length-limit // See: https://github.com/filecoin-project/filecoin-ffi/blob/cec06a79dc858f221f6542cff264b92b4f99c25d/rust/src/proofs/types.rs#L164-L173 case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1_1: return "StackedDrgWindow2KiBV1_2" diff --git a/damocles-manager/pkg/kvstore/badger.go b/damocles-manager/pkg/kvstore/badger.go index 9cb4e4bbb..2df6f11ef 100644 --- a/damocles-manager/pkg/kvstore/badger.go +++ b/damocles-manager/pkg/kvstore/badger.go @@ -27,7 +27,7 @@ type blogger struct { *logging.ZapLogger } -func (bl *blogger) Warningf(format string, args ...interface{}) { +func (bl *blogger) Warningf(format string, args ...any) { bl.ZapLogger.Warnf(format, args...) } @@ -64,7 +64,7 @@ func (b *BadgerKVStore) Update(_ context.Context, f func(Txn) error) error { return err } -func (b *BadgerKVStore) NeedRetryTransactions() bool { +func (*BadgerKVStore) NeedRetryTransactions() bool { return true } @@ -128,7 +128,8 @@ func (b *BadgerKVStore) Scan(_ context.Context, prefix Prefix) (it Iter, err err seeked: false, valid: false, prefix: prefix, - }}, nil + }, + }, nil } func (b *BadgerKVStore) gc(ctx context.Context) { @@ -148,15 +149,19 @@ func (b *BadgerKVStore) gc(ctx context.Context) { // or we're closing. gcTimer.Reset(defaultGCInterval) case nil: - log.Infow("successful value log GC", "name", b.name, "elapsed", time.Since(start).Truncate(time.Microsecond).String()) + log.Infow( + "successful value log GC", + "name", + b.name, + "elapsed", + time.Since(start).Truncate(time.Microsecond).String(), + ) gcTimer.Reset(defaultGCSleep) default: log.Errorw("error duraing a GC cycle", "name", b.name, "err", err) gcTimer.Reset(defaultGCInterval) } - } - } } @@ -205,7 +210,6 @@ func (txn *BadgerTxn) Peek(key Key, f func(Val) error) error { default: return fmt.Errorf("get value from badger: %w", err) } - } func (txn *BadgerTxn) Put(key Key, val Val) error { @@ -293,7 +297,7 @@ type badgerDB struct { mu sync.Mutex } -func (db *badgerDB) Run(context.Context) error { +func (*badgerDB) Run(context.Context) error { return nil } diff --git a/damocles-manager/pkg/kvstore/kvstore.go b/damocles-manager/pkg/kvstore/kvstore.go index f0ee199e1..13e56bbc5 100644 --- a/damocles-manager/pkg/kvstore/kvstore.go +++ b/damocles-manager/pkg/kvstore/kvstore.go @@ -50,16 +50,15 @@ type KVExt struct { } func (kv *KVExt) MustNoConflict(f func() error) error { - if kv.NeedRetryTransactions() { - for { - err := f() - if !errors.Is(err, ErrTransactionConflict) { - return err - } - } - } else { + if !kv.NeedRetryTransactions() { return f() } + for { + err := f() + if !errors.Is(err, ErrTransactionConflict) { + return err + } + } } func (kv *KVExt) UpdateMustNoConflict(ctx context.Context, f func(txn TxnExt) error) error { @@ -93,7 +92,7 @@ func (et TxnExt) PeekAny(f func(Val) error, keys ...Key) (Key, error) { return []byte{}, ErrKeyNotFound } -func (et TxnExt) PutJson(k Key, v any) error { +func (et TxnExt) PutJSON(k Key, v any) error { b, err := json.Marshal(v) if err != nil { return err diff --git a/damocles-manager/pkg/kvstore/mongo.go b/damocles-manager/pkg/kvstore/mongo.go index 9a1c7be7a..e0a5b5bbe 100644 --- a/damocles-manager/pkg/kvstore/mongo.go +++ b/damocles-manager/pkg/kvstore/mongo.go @@ -48,7 +48,7 @@ func (ms MongoStore) View(ctx context.Context, f func(Txn) error) error { } defer sess.EndSession(ctx) - _, err = sess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) { + _, err = sess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (any, error) { txn := &MongoTxn{ sessCtx: sessCtx, coll: ms.coll, @@ -66,7 +66,7 @@ func (ms MongoStore) Update(ctx context.Context, f func(Txn) error) error { } defer sess.EndSession(ctx) - _, err = sess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) { + _, err = sess.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (any, error) { txn := &MongoTxn{ sessCtx: sessCtx, coll: ms.coll, @@ -76,7 +76,7 @@ func (ms MongoStore) Update(ctx context.Context, f func(Txn) error) error { return err } -func (ms MongoStore) NeedRetryTransactions() bool { +func (MongoStore) NeedRetryTransactions() bool { return false } @@ -116,6 +116,7 @@ type MongoTxn struct { func (mt *MongoTxn) Get(key Key) (Val, error) { return get(mt.sessCtx, mt.coll, key) } + func (mt *MongoTxn) Peek(key Key, f func(Val) error) error { v := KvInMongo{} err := mt.coll.FindOne(mt.sessCtx, bson.M{"_id": KeyToString(key)}).Decode(&v) @@ -225,11 +226,11 @@ type mongoDB struct { dbName string } -func (db mongoDB) Run(context.Context) error { +func (mongoDB) Run(context.Context) error { return nil } -func (db mongoDB) Close(context.Context) error { +func (mongoDB) Close(context.Context) error { return nil } diff --git a/damocles-manager/pkg/kvstore/mongo_test.go b/damocles-manager/pkg/kvstore/mongo_test.go index deec1aa7e..0ee6aeade 100644 --- a/damocles-manager/pkg/kvstore/mongo_test.go +++ b/damocles-manager/pkg/kvstore/mongo_test.go @@ -40,13 +40,12 @@ func TestMain(m *testing.M) { func DeleteAll(ctx context.Context, kv kvstore.KVStore) error { iter, err := kv.Scan(ctx, nil) if err != nil { - return fmt.Errorf("Scan all record: %w", err) - + return fmt.Errorf("scan all record: %w", err) } for iter.Next() { k := iter.Key() if err := kv.Del(ctx, k); err != nil { - return fmt.Errorf("Delete key: %s; %w", string(k), err) + return fmt.Errorf("delete key: %s; %w", string(k), err) } } return nil diff --git a/damocles-manager/pkg/logging/log.go b/damocles-manager/pkg/logging/log.go index bc8b4740b..685906f0c 100644 --- a/damocles-manager/pkg/logging/log.go +++ b/damocles-manager/pkg/logging/log.go @@ -7,8 +7,10 @@ import ( "go.uber.org/zap" ) -type ZapLogger = zap.SugaredLogger -type WrappedLogger = logging.ZapEventLogger +type ( + ZapLogger = zap.SugaredLogger + WrappedLogger = logging.ZapEventLogger +) var ( New = logging.Logger @@ -39,7 +41,7 @@ func Setup() { func SetLogLevelIfNotSet(name, level string) { _, ok := logging.GetConfig().SubsystemLevels[name] if !ok { - logging.SetLogLevel(name, level) + _ = logging.SetLogLevel(name, level) } } diff --git a/damocles-manager/pkg/lotusminer/lotus_miner.go b/damocles-manager/pkg/lotusminer/lotus_miner.go index 94397a7a2..3df4ae35f 100644 --- a/damocles-manager/pkg/lotusminer/lotus_miner.go +++ b/damocles-manager/pkg/lotusminer/lotus_miner.go @@ -43,7 +43,14 @@ func New(ctx context.Context, addr string, token string) (StorageMiner, jsonrpc. return nil, nil, fmt.Errorf("get api addr: %w", err) } - closer, err := jsonrpc.NewMergeClient(ctx, apiAddr, "Filecoin", vapi.GetInternalStructs(&a), ainfo.AuthHeader(), jsonrpc.WithRetry(true)) + closer, err := jsonrpc.NewMergeClient( + ctx, + apiAddr, + "Filecoin", + vapi.GetInternalStructs(&a), + ainfo.AuthHeader(), + jsonrpc.WithRetry(true), + ) if err != nil { return nil, nil, fmt.Errorf("dial: %w", err) } diff --git a/damocles-manager/pkg/messager/api.go b/damocles-manager/pkg/messager/api.go index 9e10beca1..752a859d1 100644 --- a/damocles-manager/pkg/messager/api.go +++ b/damocles-manager/pkg/messager/api.go @@ -25,6 +25,7 @@ var MessageState = struct { FillMsg, OnChainMsg, FailedMsg, + //revive:disable-next-line:line-length-limit NonceConflictMsg mtypes.MessageState // Has been on-chain after being replaced by off-chain services, usually by `mpool replace`, eg. `venus mpool replace` }{ mtypes.UnKnown, diff --git a/damocles-manager/pkg/objstore/filestore/store.go b/damocles-manager/pkg/objstore/filestore/store.go index daada9418..274c219a8 100644 --- a/damocles-manager/pkg/objstore/filestore/store.go +++ b/damocles-manager/pkg/objstore/filestore/store.go @@ -92,12 +92,20 @@ func (s *Store) openWithContext(ctx context.Context, p string, r *readRange) rea select { case <-ctx.Done(): if err == nil { - r.Close() + _ = r.Close() r = nil err = ctx.Err() log.Warnw("file object opened, but context has been canceled", "path", p, "elapsed", dur) } else { - log.Warnw("file object opened, but context has been canceled", "path", p, "elapsed", dur, "err", err.Error()) + log.Warnw( + "file object opened, but context has been canceled", + "path", + p, + "elapsed", + dur, + "err", + err.Error(), + ) } default: @@ -112,7 +120,6 @@ func (s *Store) openWithContext(ctx context.Context, p string, r *readRange) rea ReadCloser: r, Err: err, } - }() select { @@ -133,7 +140,7 @@ func (s *Store) open(p string, r *readRange) (io.ReadCloser, error) { hold := false defer func() { if !hold { - file.Close() + _ = file.Close() } }() @@ -144,7 +151,7 @@ func (s *Store) open(p string, r *readRange) (io.ReadCloser, error) { } if !stat.Mode().Type().IsRegular() { - file.Close() + _ = file.Close() return nil, fmt.Errorf("obj %s: %w", p, objstore.ErrNotRegularFile) } } diff --git a/damocles-manager/pkg/objstore/mgr.go b/damocles-manager/pkg/objstore/mgr.go index 8cf6362fc..67041f69c 100644 --- a/damocles-manager/pkg/objstore/mgr.go +++ b/damocles-manager/pkg/objstore/mgr.go @@ -19,8 +19,10 @@ import ( var mgrLog = logging.New("objstore-mgr") -var _ Manager = (*StoreManager)(nil) -var storeReserveSummaryKey = kvstore.Key("StoreReserveSummary") +var ( + _ Manager = (*StoreManager)(nil) + storeReserveSummaryKey = kvstore.Key("StoreReserveSummary") +) // for storage allocator type StoreReserveSummary struct { @@ -91,7 +93,11 @@ func (p StoreSelectPolicy) Allowed(miner abi.ActorID) bool { return true } -func NewStoreManager(stores []Store, policy map[string]StoreSelectPolicy, metadb kvstore.KVStore) (*StoreManager, error) { +func NewStoreManager( + stores []Store, + policy map[string]StoreSelectPolicy, + metadb kvstore.KVStore, +) (*StoreManager, error) { idxes := map[string]int{} for i, st := range stores { idxes[st.Instance(context.Background())] = i @@ -163,7 +169,12 @@ type storeCandidate struct { InstanceInfo } -func (m *StoreManager) ReserveSpace(ctx context.Context, sid abi.SectorID, size uint64, candidates []string) (*Config, error) { +func (m *StoreManager) ReserveSpace( + ctx context.Context, + sid abi.SectorID, + size uint64, + candidates []string, +) (*Config, error) { by := util.FormatSectorID(sid) rlog := mgrLog.With("by", by, "size", size) @@ -189,6 +200,7 @@ func (m *StoreManager) ReserveSpace(ctx context.Context, sid abi.SectorID, size } } + //nolint if len(cand) == 0 || cand[insName] { info, err := st.InstanceInfo(ctx) if err != nil { @@ -237,13 +249,14 @@ func (m *StoreManager) ReserveSpace(ctx context.Context, sid abi.SectorID, size return false, nil } - chosen := selector.PickSource(m.resRand).(storeCandidate) + chosen := selector.PickSource(m.resRand).(storeCandidate) //revive:disable-line:unchecked-type-assertion selected = &chosen.Config resStat, ok := summary.Stats[chosen.InstanceInfo.Config.Name] if !ok { resStat = emptyStoreReserveStat() summary.Stats[chosen.InstanceInfo.Config.Name] = resStat + //nolint changed = true } @@ -260,7 +273,6 @@ func (m *StoreManager) ReserveSpace(ctx context.Context, sid abi.SectorID, size return changed, nil }) - if err != nil { return nil, fmt.Errorf("attempt to select a store: %w", err) } @@ -294,7 +306,6 @@ func (m *StoreManager) ReleaseReserved(ctx context.Context, sid abi.SectorID) (b return changed, nil }) - if err != nil { return false, fmt.Errorf("release reserved: %w", err) } @@ -310,7 +321,6 @@ func (m *StoreManager) modifyReserved(ctx context.Context, modifier func(*StoreR err := m.metadb.Peek(ctx, storeReserveSummaryKey, func(data []byte) error { return json.Unmarshal(data, &summary) }) - if err != nil { if !errors.Is(err, kvstore.ErrKeyNotFound) { return fmt.Errorf("view store reserve summary: %w", err) diff --git a/damocles-manager/pkg/objstore/mgr_test.go b/damocles-manager/pkg/objstore/mgr_test.go index a269e8be1..19b6872f9 100644 --- a/damocles-manager/pkg/objstore/mgr_test.go +++ b/damocles-manager/pkg/objstore/mgr_test.go @@ -56,11 +56,16 @@ func TestStoreManagerReserverSpace(t *testing.T) { }, 1, nil) require.NoErrorf(t, err, "selection cases: reserve space for %d", i) require.NotNilf(t, choice, "selection cases: should not get nil for %d", i) - require.NotEqualf(t, storeNameReadOnly, choice.Name, "selection cases: ro store should not be selected for %d", i) + require.NotEqualf( + t, + storeNameReadOnly, + choice.Name, + "selection cases: ro store should not be selected for %d", + i, + ) if choice.Name == storeName4K { count4K++ } - } if count1M := attempts - count4K; count4K == 0 || count1M == 0 || count4K/count1M >= 2 || count1M/count4K >= 2 { @@ -73,7 +78,6 @@ func TestStoreManagerReserverSpace(t *testing.T) { // single selection { - type reserveRequest struct { num abi.SectorNumber size uint64 @@ -177,7 +181,6 @@ func TestStoreManagerReserverSpace(t *testing.T) { } } } - } func TestStoreManagerReserverSpaceWeighed(t *testing.T) { @@ -218,11 +221,16 @@ func TestStoreManagerReserverSpaceWeighed(t *testing.T) { }, 1, nil) require.NoErrorf(t, err, "selection cases: reserve space for %d", i) require.NotNilf(t, choice, "selection cases: should not get nil for %d", i) - require.NotEqualf(t, storeNameReadOnly, choice.Name, "selection cases: ro store should not be selected for %d", i) + require.NotEqualf( + t, + storeNameReadOnly, + choice.Name, + "selection cases: ro store should not be selected for %d", + i, + ) if choice.Name == storeName1 { count1++ } - } require.Truef(t, count1 <= 20, "store-1 selected %d/%d times", count1, attempts) @@ -335,6 +343,15 @@ func TestStoreSelectPolicy(t *testing.T) { for i := range cases { c := cases[i] got := c.policy.Allowed(c.miner) - require.Equalf(t, c.allow, got, "#%d policy checks for %d with allow: %v, deny: %v", i, c.miner, c.policy.AllowMiners, c.policy.DenyMiners) + require.Equalf( + t, + c.allow, + got, + "#%d policy checks for %d with allow: %v, deny: %v", + i, + c.miner, + c.policy.AllowMiners, + c.policy.DenyMiners, + ) } } diff --git a/damocles-manager/pkg/objstore/mock_store.go b/damocles-manager/pkg/objstore/mock_store.go index b0607213f..3d1a2f715 100644 --- a/damocles-manager/pkg/objstore/mock_store.go +++ b/damocles-manager/pkg/objstore/mock_store.go @@ -31,11 +31,11 @@ type MockStore struct { mu sync.RWMutex } -func (ms *MockStore) Type() string { +func (*MockStore) Type() string { return "mock" } -func (ms *MockStore) Version() string { +func (*MockStore) Version() string { return "mock" } @@ -144,6 +144,6 @@ func (ms *MockStore) Put(_ context.Context, p string, r io.Reader) (int64, error return written, nil } -func (ms *MockStore) FullPath(_ context.Context, p string) string { +func (*MockStore) FullPath(_ context.Context, p string) string { return p } diff --git a/damocles-manager/pkg/objstore/plugin/plugin.go b/damocles-manager/pkg/objstore/plugin/plugin.go index df33e10d5..b6a876f58 100644 --- a/damocles-manager/pkg/objstore/plugin/plugin.go +++ b/damocles-manager/pkg/objstore/plugin/plugin.go @@ -11,15 +11,19 @@ import ( var plog = logging.New("objstore").With("driver", "plugin") -func OpenPluginObjStore(pluginName string, cfg objstore.Config, loadedPlugins *managerplugin.LoadedPlugins) (objstore.Store, error) { +func OpenPluginObjStore( + pluginName string, + cfg objstore.Config, + loadedPlugins *managerplugin.LoadedPlugins, +) (objstore.Store, error) { p := loadedPlugins.Get(managerplugin.ObjStore, pluginName) if p == nil { return nil, fmt.Errorf("objstore plugin not found: %s", pluginName) } - objstore := managerplugin.DeclareObjStoreManifest(p.Manifest) - if objstore.Constructor == nil { + objstoreManifest := managerplugin.DeclareObjStoreManifest(p.Manifest) + if objstoreManifest.Constructor == nil { return nil, fmt.Errorf("objstore plugin Constructor cannot be nil: %s", pluginName) } plog.With("plugin_name", pluginName) - return objstore.Constructor(cfg) + return objstoreManifest.Constructor(cfg) } diff --git a/damocles-manager/pkg/piecestore/proxy.go b/damocles-manager/pkg/piecestore/proxy.go index c0374806c..c17a66afc 100644 --- a/damocles-manager/pkg/piecestore/proxy.go +++ b/damocles-manager/pkg/piecestore/proxy.go @@ -67,11 +67,11 @@ func (p *Proxy) handleGet(rw http.ResponseWriter, req *http.Request) { for _, store := range p.locals { for _, p := range []string{cidStr, cidWithDotCar} { if r, err := store.Get(req.Context(), p); err == nil { - defer r.Close() _, err := io.Copy(rw, r) if err != nil { log.Warnw("transfer piece data for %s: %s", p, err) } + r.Close() return } } diff --git a/damocles-manager/pkg/slices/map.go b/damocles-manager/pkg/slices/map.go index 2a982a5bc..346672844 100644 --- a/damocles-manager/pkg/slices/map.go +++ b/damocles-manager/pkg/slices/map.go @@ -1,7 +1,6 @@ package slices func Map[T, U any](data []T, f func(T) U) []U { - res := make([]U, len(data)) for i, e := range data { diff --git a/damocles-manager/pkg/strings/join.go b/damocles-manager/pkg/strings/join.go index 3981223bd..b8b10262d 100644 --- a/damocles-manager/pkg/strings/join.go +++ b/damocles-manager/pkg/strings/join.go @@ -12,11 +12,11 @@ func Join[T any](data []T, sep string) string { var sb strings.Builder - sb.WriteString(fmt.Sprint(data[0])) + _, _ = sb.WriteString(fmt.Sprint(data[0])) for _, item := range data[1:] { - sb.WriteString(sep) - sb.WriteString(fmt.Sprint(item)) + _, _ = sb.WriteString(sep) + _, _ = sb.WriteString(fmt.Sprint(item)) } return sb.String() diff --git a/damocles-manager/pkg/workercli/client.go b/damocles-manager/pkg/workercli/client.go index c1331e4b3..feca8b8ea 100644 --- a/damocles-manager/pkg/workercli/client.go +++ b/damocles-manager/pkg/workercli/client.go @@ -18,6 +18,6 @@ type Client struct { func Connect(ctx context.Context, endpoint string, opts ...jsonrpc.Option) (*Client, jsonrpc.ClientCloser, error) { var client Client - closer, err := jsonrpc.NewMergeClient(ctx, endpoint, "VenusWorker", []interface{}{&client}, http.Header{}, opts...) + closer, err := jsonrpc.NewMergeClient(ctx, endpoint, "VenusWorker", []any{&client}, http.Header{}, opts...) return &client, closer, err } diff --git a/damocles-manager/testutil/testmodules/modules.go b/damocles-manager/testutil/testmodules/modules.go index f70464185..93bd36585 100644 --- a/damocles-manager/testutil/testmodules/modules.go +++ b/damocles-manager/testutil/testmodules/modules.go @@ -8,9 +8,7 @@ import ( "github.com/ipfs-force-community/damocles/damocles-manager/modules" ) -var ( - TestActorBase abi.ActorID = 10000 -) +var TestActorBase abi.ActorID = 10000 func MockSafeConfig(count int, minerInitializer func(mcfg *modules.MinerConfig)) (*modules.SafeConfig, sync.Locker) { cfg := modules.DefaultConfig(false) diff --git a/damocles-manager/ver/prover_prod.go b/damocles-manager/ver/prover_prod.go index 1d5958202..0d393fef4 100644 --- a/damocles-manager/ver/prover_prod.go +++ b/damocles-manager/ver/prover_prod.go @@ -1,3 +1,4 @@ +//go:build prod // +build prod package ver diff --git a/damocles-worker-util/Makefile b/damocles-worker-util/Makefile index 5d8e1f6de..b13846a60 100644 --- a/damocles-worker-util/Makefile +++ b/damocles-worker-util/Makefile @@ -5,7 +5,8 @@ all: fmt clippy build-all test-all: cargo test --release --workspace -- --nocapture -check-all: check-fmt check-clippy +check: check-fmt check-clippy +fix: fmt clippy build-all: cargo build --release diff --git a/damocles-worker/Makefile b/damocles-worker/Makefile index f93a74af1..3a816ac7a 100644 --- a/damocles-worker/Makefile +++ b/damocles-worker/Makefile @@ -21,7 +21,8 @@ endif all: fmt clippy build-all -check-all: check-fmt check-clippy +fix: fmt clippy +check: check-fmt check-clippy build-all: cargo build --release --workspace $(WORKER_FEATURE_FLAGS) From 888fab59d03c9f6d6d1e737d6800c78a15c86cd9 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 19 Apr 2024 12:29:58 +0000 Subject: [PATCH 2/7] chore(deps): bump golang.org/x/net Bumps [golang.org/x/net](https://github.com/golang/net) from 0.17.0 to 0.23.0. - [Commits](https://github.com/golang/net/compare/v0.17.0...v0.23.0) --- updated-dependencies: - dependency-name: golang.org/x/net dependency-type: indirect ... Signed-off-by: dependabot[bot] --- manager-plugin/examples/concurrent-limiter/go.mod | 4 ++-- manager-plugin/examples/concurrent-limiter/go.sum | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/manager-plugin/examples/concurrent-limiter/go.mod b/manager-plugin/examples/concurrent-limiter/go.mod index 545ea8f95..3a0af4b63 100644 --- a/manager-plugin/examples/concurrent-limiter/go.mod +++ b/manager-plugin/examples/concurrent-limiter/go.mod @@ -24,8 +24,8 @@ require ( github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect go.opencensus.io v0.24.0 // indirect - golang.org/x/net v0.17.0 // indirect - golang.org/x/sys v0.13.0 // indirect + golang.org/x/net v0.23.0 // indirect + golang.org/x/sys v0.18.0 // indirect google.golang.org/protobuf v1.33.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/manager-plugin/examples/concurrent-limiter/go.sum b/manager-plugin/examples/concurrent-limiter/go.sum index 14e059589..405d76b75 100644 --- a/manager-plugin/examples/concurrent-limiter/go.sum +++ b/manager-plugin/examples/concurrent-limiter/go.sum @@ -136,8 +136,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= -golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= +golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= +golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= 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= @@ -152,8 +152,8 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= -golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= +golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= From d5fe0c2d6b67fa1ae7e4281cbd8710f296009a43 Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Thu, 18 Apr 2024 19:46:46 +0800 Subject: [PATCH 3/7] fix(manager): check deal info --- damocles-manager/core/types.go | 2 +- damocles-manager/modules/sealer/sealer.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/damocles-manager/core/types.go b/damocles-manager/core/types.go index f17041b79..8e4aa20db 100644 --- a/damocles-manager/core/types.go +++ b/damocles-manager/core/types.go @@ -151,7 +151,7 @@ func (sp SectorPieceV2) DisplayDealID() string { } func (sp SectorPieceV2) HasDealInfo() bool { - return sp.DealInfo != nil + return sp.DealInfo != nil && (sp.DealInfo.DealID != 0 || sp.DealInfo.AllocationID != 0) } func (sp SectorPieceV2) IsBuiltinMarket() bool { diff --git a/damocles-manager/modules/sealer/sealer.go b/damocles-manager/modules/sealer/sealer.go index 122077d3b..aef988757 100644 --- a/damocles-manager/modules/sealer/sealer.go +++ b/damocles-manager/modules/sealer/sealer.go @@ -736,7 +736,7 @@ func checkPieces(pieces core.SectorPieces) error { // validate deals for pi := range pieces { pinfo := pieces[pi] - if pinfo.IsBuiltinMarket() && !pinfo.HasDealInfo() { + if !pinfo.HasDealInfo() { expected := zerocomm.ZeroPieceCommitment(pinfo.Piece.Size.Unpadded()) if !expected.Equals(pinfo.DealInfo.PieceCID) { return fmt.Errorf( From 440ef292f8f7d53ebdacaea3f51ecd4385bc96fe Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Fri, 19 Apr 2024 14:01:36 +0800 Subject: [PATCH 4/7] fix: use PRU3 after nv22 --- .../modules/impl/commitmgr/commit_processor.go | 2 +- .../modules/impl/sectors/snapup_commit.go | 11 ++++++++++- damocles-manager/modules/util/piece/piece.go | 14 +++++++++----- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/damocles-manager/modules/impl/commitmgr/commit_processor.go b/damocles-manager/modules/impl/commitmgr/commit_processor.go index ebb081599..8ff56b5d6 100644 --- a/damocles-manager/modules/impl/commitmgr/commit_processor.go +++ b/damocles-manager/modules/impl/commitmgr/commit_processor.go @@ -294,7 +294,7 @@ func (c CommitProcessor) ProcessV2( collateral := big.Zero() for i, p := range sectors { - activationManifest, dealIDs, err := piece.ProcessPieces(ctx, §ors[i], c.chain, c.lookupID) + activationManifest, dealIDs, err := piece.ProcessPieces(ctx, §ors[i], c.chain, c.lookupID, false) if err != nil { return err } diff --git a/damocles-manager/modules/impl/sectors/snapup_commit.go b/damocles-manager/modules/impl/sectors/snapup_commit.go index 6e4b1d87e..77b438853 100644 --- a/damocles-manager/modules/impl/sectors/snapup_commit.go +++ b/damocles-manager/modules/impl/sectors/snapup_commit.go @@ -375,8 +375,17 @@ func (h *snapupCommitHandler) submitMessage() error { delayTime, ) } + nv, err := h.committer.chain.StateNetworkVersion(h.committer.ctx, tsk) + if err != nil { + return newTempErr( + fmt.Errorf( + "call StateNetworkVersion. err: %w", err, + ), + mcfg.SnapUp.Retry.APIFailureWait.Std(), + ) + } - pams, deals, err := piece.ProcessPieces(h.committer.ctx, &h.state, h.committer.chain, h.committer.lookupID) + pams, deals, err := piece.ProcessPieces(h.committer.ctx, &h.state, h.committer.chain, h.committer.lookupID, nv >= network.Version22) if err != nil { return newTempErr(fmt.Errorf("failed to process pieces: %w", err), mcfg.SnapUp.Retry.APIFailureWait.Std()) } diff --git a/damocles-manager/modules/util/piece/piece.go b/damocles-manager/modules/util/piece/piece.go index 715e3e68a..6938f379e 100644 --- a/damocles-manager/modules/util/piece/piece.go +++ b/damocles-manager/modules/util/piece/piece.go @@ -24,15 +24,18 @@ func ProcessPieces( sector *core.SectorState, chain chainapi.API, lookupID core.LookupID, + forceDDO bool, ) ([]miner13.PieceActivationManifest, []abi.DealID, error) { pams := make([]miner13.PieceActivationManifest, 0, len(sector.Pieces)) dealIDs := make([]abi.DealID, 0, len(sector.Pieces)) sectorPieces := sector.SectorPiece() - var hasDDO bool - for _, piece := range sectorPieces { - if piece.HasDealInfo() && !piece.IsBuiltinMarket() { - hasDDO = true + hasDDO := forceDDO + if !forceDDO { + for _, piece := range sectorPieces { + if piece.HasDealInfo() && !piece.IsBuiltinMarket() { + hasDDO = true + } } } @@ -85,11 +88,12 @@ func ProcessPieces( } if piece.IsBuiltinMarket() { + // only builtmarket piece dealIDs = append(dealIDs, piece.DealID()) continue } - // ddo + // only ddo piece clid, err := lookupID.StateLookupID(ctx, piece.Client()) if err != nil { return nil, nil, fmt.Errorf("getting client address for deal %d: %w", piece.DealID(), err) From 5b4857a195b75ab2e4ea89b59c8afe163f743f61 Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Fri, 19 Apr 2024 16:01:19 +0800 Subject: [PATCH 5/7] chore(flox): add `openssl` & `glibc` & `libgcc` --- .flox/env/manifest.lock | 96 +++++++++++++++++++++++++++++++++++++++++ .flox/env/manifest.toml | 5 ++- 2 files changed, 100 insertions(+), 1 deletion(-) diff --git a/.flox/env/manifest.lock b/.flox/env/manifest.lock index dcd443162..3b1476301 100644 --- a/.flox/env/manifest.lock +++ b/.flox/env/manifest.lock @@ -3,6 +3,10 @@ "manifest": { "hook": {}, "install": { + "glibc": { + "pkg-path": "glibc", + "version": "~2.38" + }, "go": { "pkg-path": "go", "version": "~1.21.8" @@ -19,6 +23,14 @@ "pkg-path": "golines", "version": "~0.11.0" }, + "libgcc": { + "pkg-path": "libgcc", + "version": "~12.3.0" + }, + "openssl": { + "pkg-path": "openssl", + "version": "~3.0.13" + }, "pkg-config": { "pkg-path": "pkg-config", "version": "~0.29.2" @@ -58,6 +70,34 @@ }, "packages": { "x86_64-linux": { + "glibc": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "glibc" + ], + "info": { + "broken": false, + "description": "The GNU C Library", + "license": "LGPL-2.0-or-later", + "pname": "glibc", + "unfree": false, + "version": "2.38" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, "go": { "attr-path": [ "legacyPackages", @@ -170,6 +210,62 @@ }, "priority": 5 }, + "libgcc": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "libgcc" + ], + "info": { + "broken": false, + "description": "GNU Compiler Collection, version 12.3.0", + "license": "GPL-3.0-or-later", + "pname": "gcc", + "unfree": false, + "version": "12.3.0" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, + "openssl": { + "attr-path": [ + "legacyPackages", + "x86_64-linux", + "openssl" + ], + "info": { + "broken": false, + "description": "A cryptographic library that implements the SSL and TLS protocols", + "license": "Apache-2.0", + "pname": "openssl", + "unfree": false, + "version": "3.0.13" + }, + "input": { + "attrs": { + "lastModified": 1713212762, + "narHash": "sha256-UQwudEVEWUVjCWvGDVyq/FXo4I92hH8QFgmRqOgPN2s=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "69be1d097dd9a8422cfc4e89811304fb40f22626", + "type": "github" + }, + "fingerprint": "618c3cd84c5464ed2402454c5e0fdba45c1b78f986009d0caf0a52fa3681d652", + "url": "github:NixOS/nixpkgs/69be1d097dd9a8422cfc4e89811304fb40f22626" + }, + "priority": 5 + }, "pkg-config": { "attr-path": [ "legacyPackages", diff --git a/.flox/env/manifest.toml b/.flox/env/manifest.toml index 37e389050..0e610a214 100644 --- a/.flox/env/manifest.toml +++ b/.flox/env/manifest.toml @@ -13,7 +13,10 @@ golangci-lint = { version = "~1.55.2", pkg-path = "golangci-lint" } golines = { version = "~0.11.0", pkg-path = "golines" } gofumpt = { version = "~0.3.1", pkg-path = "gofumpt" } pkg-config = { version = "~0.29.2", pkg-path = "pkg-config" } -rustup = { version="~1.26.0", pkg-path = "rustup" } +rustup = { version = "~1.26.0", pkg-path = "rustup" } +openssl = { version = "~3.0.13", pkg-path = "openssl" } +glibc = { version = "~2.38", pkg-path = "glibc" } +libgcc = { version = "~12.3.0", pkg-path = "libgcc" } # pre-commit = { version = "~3.3.3", pkg-path = "pre-commit" } # Set an environment variable. From f22738174c7c24ab63bc8a80db331836ef67d7f6 Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Tue, 23 Apr 2024 13:19:18 +0800 Subject: [PATCH 6/7] chore: update go-multiaddr to v0.12.3 --- damocles-manager/go.mod | 2 +- damocles-manager/go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/damocles-manager/go.mod b/damocles-manager/go.mod index 69d9ec5fb..685ba85f9 100644 --- a/damocles-manager/go.mod +++ b/damocles-manager/go.mod @@ -41,7 +41,7 @@ require ( github.com/mitchellh/go-homedir v1.1.0 github.com/mr-tron/base58 v1.2.0 github.com/mroth/weightedrand v0.4.1 - github.com/multiformats/go-multiaddr v0.12.2 + github.com/multiformats/go-multiaddr v0.12.3 github.com/multiformats/go-multihash v0.2.3 github.com/patrickmn/go-cache v2.1.0+incompatible github.com/samber/lo v1.39.0 diff --git a/damocles-manager/go.sum b/damocles-manager/go.sum index 57035770a..c153dfb65 100644 --- a/damocles-manager/go.sum +++ b/damocles-manager/go.sum @@ -1525,8 +1525,8 @@ github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4 github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc= github.com/multiformats/go-multiaddr v0.3.3/go.mod h1:lCKNGP1EQ1eZ35Za2wlqnabm9xQkib3fyB+nZXHLag0= github.com/multiformats/go-multiaddr v0.8.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= -github.com/multiformats/go-multiaddr v0.12.2 h1:9G9sTY/wCYajKa9lyfWPmpZAwe6oV+Wb1zcmMS1HG24= -github.com/multiformats/go-multiaddr v0.12.2/go.mod h1:GKyaTYjZRdcUhyOetrxTk9z0cW+jA/YrnqTOvKgi44M= +github.com/multiformats/go-multiaddr v0.12.3 h1:hVBXvPRcKG0w80VinQ23P5t7czWgg65BmIvQKjDydU8= +github.com/multiformats/go-multiaddr v0.12.3/go.mod h1:sBXrNzucqkFJhvKOiwwLyqamGa/P5EIXNPLovyhQCII= github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= github.com/multiformats/go-multiaddr-dns v0.2.0/go.mod h1:TJ5pr5bBO7Y1B18djPuRsVkduhQH2YqYSbxWJzYGdK0= From 0f1d5bcefb22698bdac40351e626cc171fcbefb4 Mon Sep 17 00:00:00 2001 From: 0x5459 <0x5459@protonmail.com> Date: Tue, 23 Apr 2024 15:47:19 +0800 Subject: [PATCH 7/7] make lint happy --- damocles-manager/modules/impl/sectors/snapup_commit.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/damocles-manager/modules/impl/sectors/snapup_commit.go b/damocles-manager/modules/impl/sectors/snapup_commit.go index 77b438853..e773dd479 100644 --- a/damocles-manager/modules/impl/sectors/snapup_commit.go +++ b/damocles-manager/modules/impl/sectors/snapup_commit.go @@ -385,7 +385,13 @@ func (h *snapupCommitHandler) submitMessage() error { ) } - pams, deals, err := piece.ProcessPieces(h.committer.ctx, &h.state, h.committer.chain, h.committer.lookupID, nv >= network.Version22) + pams, deals, err := piece.ProcessPieces( + h.committer.ctx, + &h.state, + h.committer.chain, + h.committer.lookupID, + nv >= network.Version22, + ) if err != nil { return newTempErr(fmt.Errorf("failed to process pieces: %w", err), mcfg.SnapUp.Retry.APIFailureWait.Std()) }