From 58416d0881f8e4c91d1ded12d23e5fc45cc6b44a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Fri, 17 Jun 2022 13:31:05 +0200 Subject: [PATCH] storage: Don't depend on specs-storage, move to storiface --- api/api_storage.go | 43 +++--- api/api_worker.go | 33 +++-- api/proxy_gen.go | 163 +++++++++++----------- build/openrpc/full.json.gz | Bin 27931 -> 27931 bytes build/openrpc/gateway.json.gz | Bin 4895 -> 4895 bytes build/openrpc/miner.json.gz | Bin 13812 -> 13807 bytes build/openrpc/worker.json.gz | Bin 4773 -> 4762 bytes cmd/lotus-bench/main.go | 9 +- cmd/lotus-bench/simple.go | 23 ++- cmd/lotus-miner/proving.go | 5 +- cmd/lotus-seed/seed/seed.go | 9 +- go.mod | 1 - go.sum | 3 - itests/wdpost_test.go | 8 +- itests/worker_test.go | 3 +- markets/sectoraccessor/sectoraccessor.go | 5 +- node/builder_miner.go | 3 +- node/impl/storminer.go | 9 +- storage/miner.go | 6 +- storage/miner_sealing.go | 6 +- storage/paths/http_handler.go | 5 +- storage/paths/http_handler_test.go | 5 +- storage/paths/interface.go | 7 +- storage/paths/local.go | 9 +- storage/paths/mocks/store.go | 7 +- storage/paths/remote.go | 11 +- storage/paths/remote_test.go | 9 +- storage/pipeline/cbor_gen.go | 8 +- storage/pipeline/fsm_events.go | 8 +- storage/pipeline/garbage.go | 12 +- storage/pipeline/input.go | 6 +- storage/pipeline/sealing.go | 8 +- storage/pipeline/states_sealing.go | 6 +- storage/pipeline/types.go | 12 +- storage/sealer/faults.go | 7 +- storage/sealer/ffiwrapper/basicfs/fs.go | 3 +- storage/sealer/ffiwrapper/sealer_cgo.go | 67 +++++---- storage/sealer/ffiwrapper/sealer_test.go | 33 +++-- storage/sealer/ffiwrapper/types.go | 13 +- storage/sealer/ffiwrapper/verifier_cgo.go | 3 +- storage/sealer/manager.go | 93 ++++++------ storage/sealer/manager_test.go | 21 ++- storage/sealer/mock/mock.go | 79 ++++++----- storage/sealer/piece_provider.go | 13 +- storage/sealer/piece_provider_test.go | 11 +- storage/sealer/roprov.go | 4 +- storage/sealer/sched.go | 5 +- storage/sealer/sched_test.go | 43 +++--- storage/sealer/storiface/paths.go | 31 ++++ storage/sealer/storiface/storage.go | 101 +++++++++++--- storage/sealer/storiface/worker.go | 47 +++---- storage/sealer/teststorage_test.go | 41 +++--- storage/sealer/testworker_test.go | 15 +- storage/sealer/worker_local.go | 41 +++--- storage/sealer/worker_tracked.go | 31 ++-- storage/sectorblocks/blocks.go | 4 +- storage/wdpost/wdpost_run.go | 6 +- storage/wdpost/wdpost_run_test.go | 3 +- storage/wdpost/wdpost_sched.go | 6 +- 59 files changed, 607 insertions(+), 556 deletions(-) create mode 100644 storage/sealer/storiface/paths.go diff --git a/api/api_storage.go b/api/api_storage.go index 0584f85fd..e9e409a7f 100644 --- a/api/api_storage.go +++ b/api/api_storage.go @@ -18,7 +18,6 @@ import ( "github.com/filecoin-project/go-state-types/builtin/v8/market" "github.com/filecoin-project/go-state-types/builtin/v8/miner" abinetwork "github.com/filecoin-project/go-state-types/network" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/chain/actors/builtin" "github.com/filecoin-project/lotus/chain/types" @@ -52,7 +51,7 @@ type StorageMiner interface { ComputeWindowPoSt(ctx context.Context, dlIdx uint64, tsk types.TipSetKey) ([]miner.SubmitWindowedPoStParams, error) //perm:admin - ComputeDataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) //perm:admin + ComputeDataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) //perm:admin // Temp api for testing PledgeSector(context.Context) (abi.SectorID, error) //perm:write @@ -63,9 +62,9 @@ type StorageMiner interface { // Add piece to an open sector. If no sectors with enough space are open, // either a new sector will be created, or this call will block until more // sectors can be created. - SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storage.Data, d PieceDealInfo) (SectorOffset, error) //perm:admin + SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storiface.Data, d PieceDealInfo) (SectorOffset, error) //perm:admin - SectorsUnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error //perm:admin + SectorsUnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error //perm:admin // List all staged sectors SectorsList(context.Context) ([]abi.SectorNumber, error) //perm:read @@ -124,23 +123,23 @@ type StorageMiner interface { WorkerJobs(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error) //perm:admin //storiface.WorkerReturn - ReturnDataCid(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error //perm:admin retry:true - ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error //perm:admin retry:true - ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error //perm:admin retry:true - ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error //perm:admin retry:true - ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error //perm:admin retry:true - ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error //perm:admin retry:true - ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storage.ReplicaUpdateOut, err *storiface.CallError) error //perm:admin retry:true - ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, vanillaProofs storage.ReplicaVanillaProofs, err *storiface.CallError) error //perm:admin retry:true - ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storage.ReplicaUpdateProof, err *storiface.CallError) error //perm:admin retry:true - ReturnGenerateSectorKeyFromData(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnFinalizeReplicaUpdate(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true - ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error //perm:admin retry:true - ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnDataCid(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error //perm:admin retry:true + ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error //perm:admin retry:true + ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storiface.PreCommit1Out, err *storiface.CallError) error //perm:admin retry:true + ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storiface.SectorCids, err *storiface.CallError) error //perm:admin retry:true + ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storiface.Commit1Out, err *storiface.CallError) error //perm:admin retry:true + ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storiface.Proof, err *storiface.CallError) error //perm:admin retry:true + ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storiface.ReplicaUpdateOut, err *storiface.CallError) error //perm:admin retry:true + ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, vanillaProofs storiface.ReplicaVanillaProofs, err *storiface.CallError) error //perm:admin retry:true + ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storiface.ReplicaUpdateProof, err *storiface.CallError) error //perm:admin retry:true + ReturnGenerateSectorKeyFromData(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnFinalizeReplicaUpdate(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true + ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error //perm:admin retry:true + ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error //perm:admin retry:true // SealingSchedDiag dumps internal sealing scheduler state SealingSchedDiag(ctx context.Context, doSched bool) (interface{}, error) //perm:admin @@ -272,7 +271,7 @@ type StorageMiner interface { // the path specified when calling CreateBackup is within the base path CreateBackup(ctx context.Context, fpath string) error //perm:admin - CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) //perm:admin + CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) //perm:admin ComputeProof(ctx context.Context, ssi []builtin.ExtendedSectorInfo, rand abi.PoStRandomness, poStEpoch abi.ChainEpoch, nv abinetwork.Version) ([]builtin.PoStProof, error) //perm:read } diff --git a/api/api_worker.go b/api/api_worker.go index 688151a8c..17dac8e3d 100644 --- a/api/api_worker.go +++ b/api/api_worker.go @@ -8,7 +8,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/sealtasks" "github.com/filecoin-project/lotus/storage/sealer/storiface" @@ -34,22 +33,22 @@ type Worker interface { Info(context.Context) (storiface.WorkerInfo, error) //perm:admin // storiface.WorkerCalls - DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) //perm:admin - AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) //perm:admin - SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) //perm:admin - SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) //perm:admin - SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) //perm:admin - SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) //perm:admin - FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) //perm:admin - FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) //perm:admin - ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) //perm:admin - ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) //perm:admin - ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error) //perm:admin - GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) (storiface.CallID, error) //perm:admin - ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) //perm:admin - MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) //perm:admin - UnsealPiece(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error) //perm:admin - Fetch(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error) //perm:admin + DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) //perm:admin + AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) //perm:admin + SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) //perm:admin + SealPreCommit2(ctx context.Context, sector storiface.SectorRef, pc1o storiface.PreCommit1Out) (storiface.CallID, error) //perm:admin + SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) //perm:admin + SealCommit2(ctx context.Context, sector storiface.SectorRef, c1o storiface.Commit1Out) (storiface.CallID, error) //perm:admin + FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) //perm:admin + FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) //perm:admin + ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) //perm:admin + ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) //perm:admin + ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) //perm:admin + GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) (storiface.CallID, error) //perm:admin + ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) (storiface.CallID, error) //perm:admin + MoveStorage(ctx context.Context, sector storiface.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) //perm:admin + UnsealPiece(context.Context, storiface.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error) //perm:admin + Fetch(context.Context, storiface.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error) //perm:admin GenerateWinningPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, randomness abi.PoStRandomness) ([]proof.PoStProof, error) //perm:admin GenerateWindowPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []storiface.PostSectorChallenge, partitionIdx int, randomness abi.PoStRandomness) (storiface.WindowPoStResult, error) //perm:admin diff --git a/api/proxy_gen.go b/api/proxy_gen.go index 731c8b445..e0cf7ce37 100644 --- a/api/proxy_gen.go +++ b/api/proxy_gen.go @@ -30,7 +30,6 @@ import ( "github.com/filecoin-project/go-state-types/dline" abinetwork "github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" apitypes "github.com/filecoin-project/lotus/api/types" "github.com/filecoin-project/lotus/chain/actors/builtin" @@ -655,9 +654,9 @@ type StorageMinerStruct struct { ActorSectorSize func(p0 context.Context, p1 address.Address) (abi.SectorSize, error) `perm:"read"` - CheckProvable func(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storage.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) `perm:"admin"` + CheckProvable func(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storiface.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) `perm:"admin"` - ComputeDataCid func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (abi.PieceInfo, error) `perm:"admin"` + ComputeDataCid func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (abi.PieceInfo, error) `perm:"admin"` ComputeProof func(p0 context.Context, p1 []builtin.ExtendedSectorInfo, p2 abi.PoStRandomness, p3 abi.ChainEpoch, p4 abinetwork.Version) ([]builtin.PoStProof, error) `perm:"read"` @@ -775,23 +774,23 @@ type StorageMinerStruct struct { ReturnMoveStorage func(p0 context.Context, p1 storiface.CallID, p2 *storiface.CallError) error `perm:"admin"` - ReturnProveReplicaUpdate1 func(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaVanillaProofs, p3 *storiface.CallError) error `perm:"admin"` + ReturnProveReplicaUpdate1 func(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaVanillaProofs, p3 *storiface.CallError) error `perm:"admin"` - ReturnProveReplicaUpdate2 func(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateProof, p3 *storiface.CallError) error `perm:"admin"` + ReturnProveReplicaUpdate2 func(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateProof, p3 *storiface.CallError) error `perm:"admin"` ReturnReadPiece func(p0 context.Context, p1 storiface.CallID, p2 bool, p3 *storiface.CallError) error `perm:"admin"` ReturnReleaseUnsealed func(p0 context.Context, p1 storiface.CallID, p2 *storiface.CallError) error `perm:"admin"` - ReturnReplicaUpdate func(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateOut, p3 *storiface.CallError) error `perm:"admin"` + ReturnReplicaUpdate func(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateOut, p3 *storiface.CallError) error `perm:"admin"` - ReturnSealCommit1 func(p0 context.Context, p1 storiface.CallID, p2 storage.Commit1Out, p3 *storiface.CallError) error `perm:"admin"` + ReturnSealCommit1 func(p0 context.Context, p1 storiface.CallID, p2 storiface.Commit1Out, p3 *storiface.CallError) error `perm:"admin"` - ReturnSealCommit2 func(p0 context.Context, p1 storiface.CallID, p2 storage.Proof, p3 *storiface.CallError) error `perm:"admin"` + ReturnSealCommit2 func(p0 context.Context, p1 storiface.CallID, p2 storiface.Proof, p3 *storiface.CallError) error `perm:"admin"` - ReturnSealPreCommit1 func(p0 context.Context, p1 storiface.CallID, p2 storage.PreCommit1Out, p3 *storiface.CallError) error `perm:"admin"` + ReturnSealPreCommit1 func(p0 context.Context, p1 storiface.CallID, p2 storiface.PreCommit1Out, p3 *storiface.CallError) error `perm:"admin"` - ReturnSealPreCommit2 func(p0 context.Context, p1 storiface.CallID, p2 storage.SectorCids, p3 *storiface.CallError) error `perm:"admin"` + ReturnSealPreCommit2 func(p0 context.Context, p1 storiface.CallID, p2 storiface.SectorCids, p3 *storiface.CallError) error `perm:"admin"` ReturnUnsealPiece func(p0 context.Context, p1 storiface.CallID, p2 *storiface.CallError) error `perm:"admin"` @@ -803,7 +802,7 @@ type StorageMinerStruct struct { SectorAbortUpgrade func(p0 context.Context, p1 abi.SectorNumber) error `perm:"admin"` - SectorAddPieceToAny func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data, p3 PieceDealInfo) (SectorOffset, error) `perm:"admin"` + SectorAddPieceToAny func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data, p3 PieceDealInfo) (SectorOffset, error) `perm:"admin"` SectorCommitFlush func(p0 context.Context) ([]sealiface.CommitBatchRes, error) `perm:"admin"` @@ -845,7 +844,7 @@ type StorageMinerStruct struct { SectorsSummary func(p0 context.Context) (map[SectorState]int, error) `perm:"read"` - SectorsUnsealPiece func(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error `perm:"admin"` + SectorsUnsealPiece func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error `perm:"admin"` SectorsUpdate func(p0 context.Context, p1 abi.SectorNumber, p2 SectorState) error `perm:"admin"` @@ -914,19 +913,19 @@ type WalletStub struct { type WorkerStruct struct { Internal struct { - AddPiece func(p0 context.Context, p1 storage.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storage.Data) (storiface.CallID, error) `perm:"admin"` + AddPiece func(p0 context.Context, p1 storiface.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storiface.Data) (storiface.CallID, error) `perm:"admin"` - DataCid func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (storiface.CallID, error) `perm:"admin"` + DataCid func(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (storiface.CallID, error) `perm:"admin"` Enabled func(p0 context.Context) (bool, error) `perm:"admin"` - Fetch func(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) `perm:"admin"` + Fetch func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) `perm:"admin"` - FinalizeReplicaUpdate func(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) `perm:"admin"` + FinalizeReplicaUpdate func(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) `perm:"admin"` - FinalizeSector func(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) `perm:"admin"` + FinalizeSector func(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) `perm:"admin"` - GenerateSectorKeyFromData func(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid) (storiface.CallID, error) `perm:"admin"` + GenerateSectorKeyFromData func(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid) (storiface.CallID, error) `perm:"admin"` GenerateWindowPoSt func(p0 context.Context, p1 abi.RegisteredPoStProof, p2 abi.ActorID, p3 []storiface.PostSectorChallenge, p4 int, p5 abi.PoStRandomness) (storiface.WindowPoStResult, error) `perm:"admin"` @@ -934,29 +933,29 @@ type WorkerStruct struct { Info func(p0 context.Context) (storiface.WorkerInfo, error) `perm:"admin"` - MoveStorage func(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) `perm:"admin"` + MoveStorage func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) `perm:"admin"` Paths func(p0 context.Context) ([]storiface.StoragePath, error) `perm:"admin"` ProcessSession func(p0 context.Context) (uuid.UUID, error) `perm:"admin"` - ProveReplicaUpdate1 func(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) `perm:"admin"` + ProveReplicaUpdate1 func(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) `perm:"admin"` - ProveReplicaUpdate2 func(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storage.ReplicaVanillaProofs) (storiface.CallID, error) `perm:"admin"` + ProveReplicaUpdate2 func(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storiface.ReplicaVanillaProofs) (storiface.CallID, error) `perm:"admin"` - ReleaseUnsealed func(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) `perm:"admin"` + ReleaseUnsealed func(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) `perm:"admin"` Remove func(p0 context.Context, p1 abi.SectorID) error `perm:"admin"` - ReplicaUpdate func(p0 context.Context, p1 storage.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) `perm:"admin"` + ReplicaUpdate func(p0 context.Context, p1 storiface.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) `perm:"admin"` - SealCommit1 func(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storage.SectorCids) (storiface.CallID, error) `perm:"admin"` + SealCommit1 func(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storiface.SectorCids) (storiface.CallID, error) `perm:"admin"` - SealCommit2 func(p0 context.Context, p1 storage.SectorRef, p2 storage.Commit1Out) (storiface.CallID, error) `perm:"admin"` + SealCommit2 func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.Commit1Out) (storiface.CallID, error) `perm:"admin"` - SealPreCommit1 func(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) `perm:"admin"` + SealPreCommit1 func(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) `perm:"admin"` - SealPreCommit2 func(p0 context.Context, p1 storage.SectorRef, p2 storage.PreCommit1Out) (storiface.CallID, error) `perm:"admin"` + SealPreCommit2 func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.PreCommit1Out) (storiface.CallID, error) `perm:"admin"` Session func(p0 context.Context) (uuid.UUID, error) `perm:"admin"` @@ -970,7 +969,7 @@ type WorkerStruct struct { TaskTypes func(p0 context.Context) (map[sealtasks.TaskType]struct{}, error) `perm:"admin"` - UnsealPiece func(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) `perm:"admin"` + UnsealPiece func(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) `perm:"admin"` Version func(p0 context.Context) (Version, error) `perm:"admin"` @@ -3940,25 +3939,25 @@ func (s *StorageMinerStub) ActorSectorSize(p0 context.Context, p1 address.Addres return *new(abi.SectorSize), ErrNotSupported } -func (s *StorageMinerStruct) CheckProvable(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storage.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) { +func (s *StorageMinerStruct) CheckProvable(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storiface.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) { if s.Internal.CheckProvable == nil { return *new(map[abi.SectorNumber]string), ErrNotSupported } return s.Internal.CheckProvable(p0, p1, p2, p3) } -func (s *StorageMinerStub) CheckProvable(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storage.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) { +func (s *StorageMinerStub) CheckProvable(p0 context.Context, p1 abi.RegisteredPoStProof, p2 []storiface.SectorRef, p3 bool) (map[abi.SectorNumber]string, error) { return *new(map[abi.SectorNumber]string), ErrNotSupported } -func (s *StorageMinerStruct) ComputeDataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (abi.PieceInfo, error) { +func (s *StorageMinerStruct) ComputeDataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (abi.PieceInfo, error) { if s.Internal.ComputeDataCid == nil { return *new(abi.PieceInfo), ErrNotSupported } return s.Internal.ComputeDataCid(p0, p1, p2) } -func (s *StorageMinerStub) ComputeDataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (abi.PieceInfo, error) { +func (s *StorageMinerStub) ComputeDataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (abi.PieceInfo, error) { return *new(abi.PieceInfo), ErrNotSupported } @@ -4600,25 +4599,25 @@ func (s *StorageMinerStub) ReturnMoveStorage(p0 context.Context, p1 storiface.Ca return ErrNotSupported } -func (s *StorageMinerStruct) ReturnProveReplicaUpdate1(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaVanillaProofs, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnProveReplicaUpdate1(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaVanillaProofs, p3 *storiface.CallError) error { if s.Internal.ReturnProveReplicaUpdate1 == nil { return ErrNotSupported } return s.Internal.ReturnProveReplicaUpdate1(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnProveReplicaUpdate1(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaVanillaProofs, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnProveReplicaUpdate1(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaVanillaProofs, p3 *storiface.CallError) error { return ErrNotSupported } -func (s *StorageMinerStruct) ReturnProveReplicaUpdate2(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateProof, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnProveReplicaUpdate2(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateProof, p3 *storiface.CallError) error { if s.Internal.ReturnProveReplicaUpdate2 == nil { return ErrNotSupported } return s.Internal.ReturnProveReplicaUpdate2(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnProveReplicaUpdate2(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateProof, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnProveReplicaUpdate2(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateProof, p3 *storiface.CallError) error { return ErrNotSupported } @@ -4644,58 +4643,58 @@ func (s *StorageMinerStub) ReturnReleaseUnsealed(p0 context.Context, p1 storifac return ErrNotSupported } -func (s *StorageMinerStruct) ReturnReplicaUpdate(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateOut, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnReplicaUpdate(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateOut, p3 *storiface.CallError) error { if s.Internal.ReturnReplicaUpdate == nil { return ErrNotSupported } return s.Internal.ReturnReplicaUpdate(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnReplicaUpdate(p0 context.Context, p1 storiface.CallID, p2 storage.ReplicaUpdateOut, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnReplicaUpdate(p0 context.Context, p1 storiface.CallID, p2 storiface.ReplicaUpdateOut, p3 *storiface.CallError) error { return ErrNotSupported } -func (s *StorageMinerStruct) ReturnSealCommit1(p0 context.Context, p1 storiface.CallID, p2 storage.Commit1Out, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnSealCommit1(p0 context.Context, p1 storiface.CallID, p2 storiface.Commit1Out, p3 *storiface.CallError) error { if s.Internal.ReturnSealCommit1 == nil { return ErrNotSupported } return s.Internal.ReturnSealCommit1(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnSealCommit1(p0 context.Context, p1 storiface.CallID, p2 storage.Commit1Out, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnSealCommit1(p0 context.Context, p1 storiface.CallID, p2 storiface.Commit1Out, p3 *storiface.CallError) error { return ErrNotSupported } -func (s *StorageMinerStruct) ReturnSealCommit2(p0 context.Context, p1 storiface.CallID, p2 storage.Proof, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnSealCommit2(p0 context.Context, p1 storiface.CallID, p2 storiface.Proof, p3 *storiface.CallError) error { if s.Internal.ReturnSealCommit2 == nil { return ErrNotSupported } return s.Internal.ReturnSealCommit2(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnSealCommit2(p0 context.Context, p1 storiface.CallID, p2 storage.Proof, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnSealCommit2(p0 context.Context, p1 storiface.CallID, p2 storiface.Proof, p3 *storiface.CallError) error { return ErrNotSupported } -func (s *StorageMinerStruct) ReturnSealPreCommit1(p0 context.Context, p1 storiface.CallID, p2 storage.PreCommit1Out, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnSealPreCommit1(p0 context.Context, p1 storiface.CallID, p2 storiface.PreCommit1Out, p3 *storiface.CallError) error { if s.Internal.ReturnSealPreCommit1 == nil { return ErrNotSupported } return s.Internal.ReturnSealPreCommit1(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnSealPreCommit1(p0 context.Context, p1 storiface.CallID, p2 storage.PreCommit1Out, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnSealPreCommit1(p0 context.Context, p1 storiface.CallID, p2 storiface.PreCommit1Out, p3 *storiface.CallError) error { return ErrNotSupported } -func (s *StorageMinerStruct) ReturnSealPreCommit2(p0 context.Context, p1 storiface.CallID, p2 storage.SectorCids, p3 *storiface.CallError) error { +func (s *StorageMinerStruct) ReturnSealPreCommit2(p0 context.Context, p1 storiface.CallID, p2 storiface.SectorCids, p3 *storiface.CallError) error { if s.Internal.ReturnSealPreCommit2 == nil { return ErrNotSupported } return s.Internal.ReturnSealPreCommit2(p0, p1, p2, p3) } -func (s *StorageMinerStub) ReturnSealPreCommit2(p0 context.Context, p1 storiface.CallID, p2 storage.SectorCids, p3 *storiface.CallError) error { +func (s *StorageMinerStub) ReturnSealPreCommit2(p0 context.Context, p1 storiface.CallID, p2 storiface.SectorCids, p3 *storiface.CallError) error { return ErrNotSupported } @@ -4754,14 +4753,14 @@ func (s *StorageMinerStub) SectorAbortUpgrade(p0 context.Context, p1 abi.SectorN return ErrNotSupported } -func (s *StorageMinerStruct) SectorAddPieceToAny(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data, p3 PieceDealInfo) (SectorOffset, error) { +func (s *StorageMinerStruct) SectorAddPieceToAny(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data, p3 PieceDealInfo) (SectorOffset, error) { if s.Internal.SectorAddPieceToAny == nil { return *new(SectorOffset), ErrNotSupported } return s.Internal.SectorAddPieceToAny(p0, p1, p2, p3) } -func (s *StorageMinerStub) SectorAddPieceToAny(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data, p3 PieceDealInfo) (SectorOffset, error) { +func (s *StorageMinerStub) SectorAddPieceToAny(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data, p3 PieceDealInfo) (SectorOffset, error) { return *new(SectorOffset), ErrNotSupported } @@ -4985,14 +4984,14 @@ func (s *StorageMinerStub) SectorsSummary(p0 context.Context) (map[SectorState]i return *new(map[SectorState]int), ErrNotSupported } -func (s *StorageMinerStruct) SectorsUnsealPiece(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error { +func (s *StorageMinerStruct) SectorsUnsealPiece(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error { if s.Internal.SectorsUnsealPiece == nil { return ErrNotSupported } return s.Internal.SectorsUnsealPiece(p0, p1, p2, p3, p4, p5) } -func (s *StorageMinerStub) SectorsUnsealPiece(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error { +func (s *StorageMinerStub) SectorsUnsealPiece(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 *cid.Cid) error { return ErrNotSupported } @@ -5271,25 +5270,25 @@ func (s *WalletStub) WalletSign(p0 context.Context, p1 address.Address, p2 []byt return nil, ErrNotSupported } -func (s *WorkerStruct) AddPiece(p0 context.Context, p1 storage.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storage.Data) (storiface.CallID, error) { +func (s *WorkerStruct) AddPiece(p0 context.Context, p1 storiface.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storiface.Data) (storiface.CallID, error) { if s.Internal.AddPiece == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.AddPiece(p0, p1, p2, p3, p4) } -func (s *WorkerStub) AddPiece(p0 context.Context, p1 storage.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storage.Data) (storiface.CallID, error) { +func (s *WorkerStub) AddPiece(p0 context.Context, p1 storiface.SectorRef, p2 []abi.UnpaddedPieceSize, p3 abi.UnpaddedPieceSize, p4 storiface.Data) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) DataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (storiface.CallID, error) { +func (s *WorkerStruct) DataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (storiface.CallID, error) { if s.Internal.DataCid == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.DataCid(p0, p1, p2) } -func (s *WorkerStub) DataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storage.Data) (storiface.CallID, error) { +func (s *WorkerStub) DataCid(p0 context.Context, p1 abi.UnpaddedPieceSize, p2 storiface.Data) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } @@ -5304,47 +5303,47 @@ func (s *WorkerStub) Enabled(p0 context.Context) (bool, error) { return false, ErrNotSupported } -func (s *WorkerStruct) Fetch(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) { +func (s *WorkerStruct) Fetch(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) { if s.Internal.Fetch == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.Fetch(p0, p1, p2, p3, p4) } -func (s *WorkerStub) Fetch(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) { +func (s *WorkerStub) Fetch(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType, p3 storiface.PathType, p4 storiface.AcquireMode) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) FinalizeReplicaUpdate(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStruct) FinalizeReplicaUpdate(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { if s.Internal.FinalizeReplicaUpdate == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.FinalizeReplicaUpdate(p0, p1, p2) } -func (s *WorkerStub) FinalizeReplicaUpdate(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStub) FinalizeReplicaUpdate(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) FinalizeSector(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStruct) FinalizeSector(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { if s.Internal.FinalizeSector == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.FinalizeSector(p0, p1, p2) } -func (s *WorkerStub) FinalizeSector(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStub) FinalizeSector(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) GenerateSectorKeyFromData(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStruct) GenerateSectorKeyFromData(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid) (storiface.CallID, error) { if s.Internal.GenerateSectorKeyFromData == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.GenerateSectorKeyFromData(p0, p1, p2) } -func (s *WorkerStub) GenerateSectorKeyFromData(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStub) GenerateSectorKeyFromData(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } @@ -5381,14 +5380,14 @@ func (s *WorkerStub) Info(p0 context.Context) (storiface.WorkerInfo, error) { return *new(storiface.WorkerInfo), ErrNotSupported } -func (s *WorkerStruct) MoveStorage(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) { +func (s *WorkerStruct) MoveStorage(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) { if s.Internal.MoveStorage == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.MoveStorage(p0, p1, p2) } -func (s *WorkerStub) MoveStorage(p0 context.Context, p1 storage.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) { +func (s *WorkerStub) MoveStorage(p0 context.Context, p1 storiface.SectorRef, p2 storiface.SectorFileType) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } @@ -5414,36 +5413,36 @@ func (s *WorkerStub) ProcessSession(p0 context.Context) (uuid.UUID, error) { return *new(uuid.UUID), ErrNotSupported } -func (s *WorkerStruct) ProveReplicaUpdate1(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStruct) ProveReplicaUpdate1(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) { if s.Internal.ProveReplicaUpdate1 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.ProveReplicaUpdate1(p0, p1, p2, p3, p4) } -func (s *WorkerStub) ProveReplicaUpdate1(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStub) ProveReplicaUpdate1(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) ProveReplicaUpdate2(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (s *WorkerStruct) ProveReplicaUpdate2(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storiface.ReplicaVanillaProofs) (storiface.CallID, error) { if s.Internal.ProveReplicaUpdate2 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.ProveReplicaUpdate2(p0, p1, p2, p3, p4, p5) } -func (s *WorkerStub) ProveReplicaUpdate2(p0 context.Context, p1 storage.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (s *WorkerStub) ProveReplicaUpdate2(p0 context.Context, p1 storiface.SectorRef, p2 cid.Cid, p3 cid.Cid, p4 cid.Cid, p5 storiface.ReplicaVanillaProofs) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) ReleaseUnsealed(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStruct) ReleaseUnsealed(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { if s.Internal.ReleaseUnsealed == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.ReleaseUnsealed(p0, p1, p2) } -func (s *WorkerStub) ReleaseUnsealed(p0 context.Context, p1 storage.SectorRef, p2 []storage.Range) (storiface.CallID, error) { +func (s *WorkerStub) ReleaseUnsealed(p0 context.Context, p1 storiface.SectorRef, p2 []storiface.Range) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } @@ -5458,58 +5457,58 @@ func (s *WorkerStub) Remove(p0 context.Context, p1 abi.SectorID) error { return ErrNotSupported } -func (s *WorkerStruct) ReplicaUpdate(p0 context.Context, p1 storage.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) { +func (s *WorkerStruct) ReplicaUpdate(p0 context.Context, p1 storiface.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) { if s.Internal.ReplicaUpdate == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.ReplicaUpdate(p0, p1, p2) } -func (s *WorkerStub) ReplicaUpdate(p0 context.Context, p1 storage.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) { +func (s *WorkerStub) ReplicaUpdate(p0 context.Context, p1 storiface.SectorRef, p2 []abi.PieceInfo) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) SealCommit1(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storage.SectorCids) (storiface.CallID, error) { +func (s *WorkerStruct) SealCommit1(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storiface.SectorCids) (storiface.CallID, error) { if s.Internal.SealCommit1 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.SealCommit1(p0, p1, p2, p3, p4, p5) } -func (s *WorkerStub) SealCommit1(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storage.SectorCids) (storiface.CallID, error) { +func (s *WorkerStub) SealCommit1(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 abi.InteractiveSealRandomness, p4 []abi.PieceInfo, p5 storiface.SectorCids) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) SealCommit2(p0 context.Context, p1 storage.SectorRef, p2 storage.Commit1Out) (storiface.CallID, error) { +func (s *WorkerStruct) SealCommit2(p0 context.Context, p1 storiface.SectorRef, p2 storiface.Commit1Out) (storiface.CallID, error) { if s.Internal.SealCommit2 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.SealCommit2(p0, p1, p2) } -func (s *WorkerStub) SealCommit2(p0 context.Context, p1 storage.SectorRef, p2 storage.Commit1Out) (storiface.CallID, error) { +func (s *WorkerStub) SealCommit2(p0 context.Context, p1 storiface.SectorRef, p2 storiface.Commit1Out) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) SealPreCommit1(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) { +func (s *WorkerStruct) SealPreCommit1(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) { if s.Internal.SealPreCommit1 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.SealPreCommit1(p0, p1, p2, p3) } -func (s *WorkerStub) SealPreCommit1(p0 context.Context, p1 storage.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) { +func (s *WorkerStub) SealPreCommit1(p0 context.Context, p1 storiface.SectorRef, p2 abi.SealRandomness, p3 []abi.PieceInfo) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } -func (s *WorkerStruct) SealPreCommit2(p0 context.Context, p1 storage.SectorRef, p2 storage.PreCommit1Out) (storiface.CallID, error) { +func (s *WorkerStruct) SealPreCommit2(p0 context.Context, p1 storiface.SectorRef, p2 storiface.PreCommit1Out) (storiface.CallID, error) { if s.Internal.SealPreCommit2 == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.SealPreCommit2(p0, p1, p2) } -func (s *WorkerStub) SealPreCommit2(p0 context.Context, p1 storage.SectorRef, p2 storage.PreCommit1Out) (storiface.CallID, error) { +func (s *WorkerStub) SealPreCommit2(p0 context.Context, p1 storiface.SectorRef, p2 storiface.PreCommit1Out) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } @@ -5579,14 +5578,14 @@ func (s *WorkerStub) TaskTypes(p0 context.Context) (map[sealtasks.TaskType]struc return *new(map[sealtasks.TaskType]struct{}), ErrNotSupported } -func (s *WorkerStruct) UnsealPiece(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStruct) UnsealPiece(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) { if s.Internal.UnsealPiece == nil { return *new(storiface.CallID), ErrNotSupported } return s.Internal.UnsealPiece(p0, p1, p2, p3, p4, p5) } -func (s *WorkerStub) UnsealPiece(p0 context.Context, p1 storage.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) { +func (s *WorkerStub) UnsealPiece(p0 context.Context, p1 storiface.SectorRef, p2 storiface.UnpaddedByteIndex, p3 abi.UnpaddedPieceSize, p4 abi.SealRandomness, p5 cid.Cid) (storiface.CallID, error) { return *new(storiface.CallID), ErrNotSupported } diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index a7ef3c09b334167b03d1bd533ed9e1b045f20e08..fbed500be18c8ef51c75da52a5f213773ea0ff49 100644 GIT binary patch delta 26174 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ⅆ?QNHF{v^n*0zVylo^$(Cy|(riO^ z9BsC}yA3$oy4`<1m9g8MOOSI3>gW<=RL`-~AH_4$XnU;*wqYV&!`dYuu=yCD3aSz&xz4^I0|C+hE}L2>NP`R^&>y#hd~1 z1QDm*q30XIBis&qe#T@KbkjfDPn-OV@N~vCG<~msXqbPdO2|06JqMDN4Qr`PNw0LlGzCWEtXetyoO9Wj2xjHcG)VBIt8eK^-6Ud#dlJ1FVJAe$O7XU=N zET`G@v^vg_7hd(>a9f;i4$fe-_tQSrF34_CKxf>q%>)(}?)qbu5|_R2+L^iW@5A($ zB;b;|O)Rj&}VEyIwPfk2lAKBqI?S;u(P65#%- zOb=OIGR*>c(DbO6>jS$<^=h*wAhKla?~vrt$7Djgot+sCv~sB!*6YW zzyy%r02e9tXWs(P@8XJR0>$^%$I7SlMq1N02gAWf#BXSHWj;EWIqg;XbD4KM zv0JG(YW+z2nR*~TrA`qf$|Jw>FtOWrlh!mET_M#=W&u=PtIRi}ozaWeFGsINyVAIZ zt}}m?av=z@vD&R*?Ryj8DIN#tEsfMi>6B>bfvLe2lTwqECtZ+j^@RM|ZJ(g0v`+5D zM4JoW1{rn8Qulnrh98U@IwX*dTJo$g})y8=^*GGf%aN1fs_u=9Y8t#tfDH)5u zKp3-`)YX_A95BLM&e2@d=r3qx^+ei2Fy}w@BmJko4ii@W#reHBzZd8C($??Aki3Q> zt3-Qul`It!70h+1|9$@|ZJtd$K>z-dFMh{wxvs!!yCzB-2GsBg(1z7*D=@{qj{mmaUv~$YZt?oaK6K#AQ{@w+Cs(5iY@JdGbOO ziABsnK&RM)0r13Y1}Fhg<2IV6$nGzkY{i5-6jqJG{(u4YHTlX_&mkj+jMjew8JSD7 z>@a!fK%|O&R&bh{ViwHi%QpcN%6qx%Rc(O_278;s!KdGnvA&6-^y8}>jDz9eJyy32 z;n*AOZEcT)Hk8}+owmOoN;_{wMY2`+o+vU_LDoVtm=JOywN7(1Z9J=Av}%It(5{h;ZkczVW-+U%;PZ6kHLRDujfW8ObSoq*$KVTkF+jwuy~8m8RVFX=NqHp;53Q}I;1r4=?xj|?QW+3%V6fG zYZM{I@f@mwh?*_EyX%_zR)G!kgSEZ%Uy_pgL3$m&Fj5;4Uon4c6$BSPfmM)!+!uOu zS^i&d*5!548(66lU0Io|ZEtvvG2y#AHXKbhT+PrnyRfr_&?S;R?OA4PCg_#}B7Y}| zm|2KCfoOfe5b;s8aY;UkuP2i@8&Rjg94=&dsxbnP(>eAw!0!yHi8C*aVZu0qet$le z_rj{I7D9>k^znb)M624_?i{LWO?UTJUF12r%oH;1wz+lXy1mUyq2xMV_tgFTfLor~ zh?X#cgro%2WC&lum;~wfw`aKvcINJmIahP%P~~jM&eh!A9WwyVc2hvH?yl#2A2~;FuAH9DxZ!mqai`A5fAWzIii-Ois+`+%?Q9!+RSj(X% zhniM7cyzJFs=Nc5t;0@hby} z4OCtJ0N22DY!>!oO;q9>2tj}u2Xs<#5r{?r6EBFxMgW*d2V&_{JPxRL<-7;)*n6uV2+g)na(M@B8~<7}4tvu1~q@mbX=<23vkM0?8fLaHrz+i;8Evlh!LJe~oF( zf&~!FgfirVeczXAOO!cH9dp3p6;iByLW6+b2z^;`#z3oY8TJ{@tKLr;r!jXrnA@Frx^bC7vXPjZq`NCQrPkk5)YMi9!r3)YTq%wUjfT2 z`uc?O>4>Y4d?Sk2w0QELb-?h7k}eS5fpiDb9Z0`JknUiwgS`&+I@s%All&|S4^xG4 zy5e44eO2IFezvm;lNBu=e|Ly-H3F=L5Bw&9_)$-x9h_8 z3c#|8mqU9Oht%9z0)U-xU*GNumA(oMXs^jR;dy3DOrTq0R2(k=k04>t6SEDDk9xs? zX@7;bWuXKoDhQgZ|41?0eX!--1MKF2lLJl;I62_-5P{REE*x+sfBP?P$$Qu(E^w)d zeqdDXNwV@WKfu#t!lj#NxzNk3-B;kt*YSd*6;PQTR^Q+(o2@#3QZW)Sgr&GGp|B-< z8=7JCVkThPnDSWxcIoTHGtog}juTu0aTGBXwNDuWFNx|21{>hQNa;c+nlLC2&cPU| zTATtzSR5g+ps|VpGN=b|Nzg6yc(9PYndFF)e1^%D{0l~CqhG{XIxPn_{;m=7aEOg- z-uc%uiKG~=9LXe;WG*CseMeT%b*8p_hHnZRJ5o1)f`jck&*{s1xyxQv+$t9^!ft9y z+EmwQ8BQm4I;qo1olg1?b<&->knIdlS8!-<@6Ft=DZgiL*AV^SKf947lu! z^Y;#i-KoL4?kbwIS33}SU*@=MuU3GDz)rz&3XW57oPyJng7dO2 z=DGmT5rVv%H@B)dowR8naL*bw-lipB|IULi=cS zni5a`lO`Mx8pjQP3KaONj%>?qR zmzZFVVF1Q35c-Ez%nUWYlA|<+|EeyKKf}{^i0@xR9Kdma z4itjxg!wDlX>+E*^QnNIf+u;%-;CTVI&Vn6l+zR1qWbD_E=j*sLt>JONt)GZBo7Mc z#DM$1umn{DK7%}Q-oL?o=11^`02%=nBElc3`JKB2Qr2LmfV9>WhOH|Lecce@{~h9| zDur5C&Z(<^uf{OHe0?UGyU0!*E!d{+xj9u`q1i4xGaI25t4zpBIAoHd&Nxz4Y3c;) zoZ@Rlj37wLMzR4u3BFlb6GjM3;vl>4=uhia5jsgebz)@8{Mp<1pd?h18qnUm)U}kDcgsqSyAA!A+Xe34e?r z+iJ*v385J-Cew3ohWt3_Y*i~Xvzm@5+SCnNN-?AB261Mz+f|z7$7rP`7U?r(+qHTJ ze8eFRn6j(oHASb`drHphO)%2gt#SVfxeF6HRD%7g7FhG6NdL`v@|OnSkGsyen)>YTN^!o85b zBdFJhPhajzRgR&4H@80SlPEGNf2bkU{TZ6mYot<4c7pU~1M8Ij$fT<`_+A*SeF~%; zH7S4>kX3y8YZxf2jt*)wiRe6+4oRI+K+i)VXSp{51kd3WQkM~CkW3MvWN4z{42yGm zNd!DsE$Hy1qBB)KD+b1zFys$)%vQZSE(s<+_Mo&#C5e$}1PJA_4KV`gN2D-|5S!7! zH_{>n^ae%92jc~x1YHssP|*nHvt0LjMjoq8Yn`dR?-#IL+9Zc19hP)h(qYN2SaPQ! z`v3V23|C2=WYoXolNU1{fAtR2Z`OvQU!G;YIdHzjnibhQi&;G#tXw;4T~7I*VI5v) zYVSc@dWZ5I%6BN=q5Ox4@?SK>Qx_<4g_!DD^&gAzyW;ttW3cCjUxntIk$gie&?+3? zt6xaFNS({!yaVhGusgthp8>mrzzzaC2<#y6LxjM)4H5GNz*@x(f7+;j7cLV$A>Y1z zpYx-(_nk0lNnIz{4GcqpV7E0^WQh-O7Cqt4FmKtJ*qd{q-}Tp>NkW7ZlNW>xDjp>~DM3O1p*tW?8g=d4hxyUsaM1!>jb?P7)^BqLN2 z%E1D00LcP)bUsIfYbQak(%k+VJt3l>=i}G#@pG?i#M$|Rc)G&gw}HOAD#X+QnqlIL zzXf+eD9TESU+jXO#^V69*#|adgT1Zo(XjC1AfVordi8xcka4WDHq^^g6kXtuA$|fG z-`d<1g*QgSs<&@3fdS?Vlb$p^3c`gq+YbUNC_aIcRQ(fcgewrXOF zR&eu!g;?qrv=0H7w6(&yRA0g`A?2=wpfS|u7;O(#Al|Q|8YjM;_;%vkiSPR%zPD>4 zs!BO@NP|EOv6H;kmF+cA5BnR3*k3Arb;AwE1-hkHX9WeCo!Tkr))QGGe?EJ@#Qsys z2J&qkVjo0;8YWL$AYdq%JXdALm`v5`$)fxrAKmS;3`6|n;XeLy$_5FAn; zdEm*-40|)61A=4$2|e-lc?i8LHW{}M`^5&_2BC~c40k*EJWKH*WV-PYQM1oLoCfSaTqYB`l--E_`-Ap+G|O`cWPMK&XMjdVZsHIw=3=dSY8YUQ z_zglNb^i(>jy5jI#S8%!B2VlTKS@0x^X-gf6dNSNStbE_L_>TQ(Rexolsxxl5EGfa zSRQ~*Vv`s*B?l^y`k}$oos&d2Do2+DG|HGrYq(N^#0+hKW9gWzylu!Y93Ud)4WZ9RWa1E@LhM|yr%4CwPETlSV@v^mARl*`=Sh`&8a|@SN?!(G`yZy4}et)$5$RE+o zsnT=1E$OWOs`i90U-jYSd5FBH;K?)Hu9f{DBcnevLT+fw&DBobTQh3Q>RxV%+3}Na zgMDey(T*Ayc#ck}cl802G;v<~4Bn>CK45Z=xI{nt$(vgq$=3HhP9sxCF)pPZK@O{~ zq<&u^SGp#@t@e@9+omryw12i;sZn>lcWHkcwCcu<@tth$&g4FIs|vVtcEXO*s8ZoJ zSZZ0}&c9qEg*$ay$@MB&PR^gpa%-L=FGBo1WV7na->YrZ;XvLOk{1AtE9*HXk}kUU z2v27`V;U%$>Y1%*M10Y6JS9-cmT!X#xhl3BxyFyORb(INTf(M(2!EH#tp&&8s#u&_ zN;b?YS%2L=p?yErm-4HIqaP?%_`PB?^&A$!WEUO3UvAg7n9-FMjp7d7=J%?#o1Y$oqy%g*;)EML=%GAPWF`e zRcDo|$v<*!yf~}yb%D4wrF>lx>~>RZ4UH)dXUMxc4-xUmcpVfwVt`qAK{RV|4$Fz}@SLNk>fq zV@yyb1MRPlM-gQ+t76fo`u3y^+LRquBh3|)emf~0G=;rNAbECMtlN;pi2;7qjJYv9Bl!pL&^>*JEZ*Bkn%$f z2t9hy6md_p$nG&9j0Wr-roVixK3}#2tV=^hR2mGs;#fU0=Ut7Y9lyr5S2Xu`HUT;t zU@IHokG@9lK#l`B4&>Zhkn>=p0*!W?BI+e!QsVI(uZD9}6MuK+NoRW@HAl@|+)FJE z*E!L-(@uBV>EMlnHxAz13wYz4=^EH*O^M{LF;vNO7RIUU6$LjFH5C%0s0 z`qzum$RE+25&xTPhub*3y`4qZ-s~C;q=oRu*oIxS?w&a2tC|4EYL5rO2TV}(7RCW@ zAK#{;jatq*#v3wk#+#6Ovl_$CazMt_#+z%Gl!vSFEdvJ$olWdb4c z9NmUu4FUaHCgh=>7e_L)4<;a>^lA*fD}cl#6&NeWAw#@B)|vYtcjl8LRrs!MIgXq5 zchV*oUDerI^1^EN=_eMzMytir;3r)%=u`W69OU zP|{>c21$!bqrwOjOzc7c+E8 zlA@T&{Bx=mA5ij~)9|?#4rwkrOcXwcLVbOX$$uqLZTFXKE&si3-5iystcGXpZA~Vnoi2(WiP)Ro3jo0nyg0M z)_+E8jJrcsJ%2X*)tu0_J=xoWTUj}i@7UGYNIN)ts`b~pTC&)Gh?&u0qLpGh8iJ|J z>hdpb7~KapJ;Z*QsdNqN|A9?KV~>D;%CVk#^5eX@#r%-^Xt1|A9Gpq9TTQ?_$bM(y z3%^!O>yR?pKq8%b`wnSGa(WIRLvIl}P=9oZC!elS^oDUfm$^-i7ZRzSA_4=xFdtpu zWb)6@BqmAA7nH+5jbgB=P5_Y?i#9JJs92?2681~tjX;{I901pH^uxhXta8u}_I5YZ z|EUEugXuBzN5vuvbpz_jw*p(2-=1KC276oEqv7CfOmtY)d?BfGOy#6|>K~^5xqsGA zul3_={hadxo#=M3_e~;>^LXsRAV_(STNrL(6cz@FgW&tumP2ldX0tYIkenvuTN$L4 zncYty!u;6X{0!9ksA$@o+7TzeV@;0=-IPG5Tz%chRSUL)+-#v%yi^Oi9}fv;IWOF{ zoTZv`ZTms4Z7ICABhkujMD^*EN`I$Rc2p|O`Ag+x8-r{rS}i}XlCL&}6G7c+;;ROj z3A~I6mNr#YMMG<7F*P|2pu@IFW~%KjNY$D)$$pAjNb7D>g{5uHDz&I>8;O3@ww|F% zbv!4??;ppE9W(BY8EYd^%U%4infL>{CA+g#lT1h*3CS}eUpi}d^ts42QGa(lmtOw} zx0Ao0f+uqreo-IdtFji$MwXwj({4b|s=vJ5ypK4O>T;?vQmJ#apwao__!!whhEl^ouIE3{w$6UGtr z|Nq`j+noRF&-8z7I%RQR=6@%CnX03lYNk_~>)K*A$2)v;YkRaikSVwP9*-B^BiQ4i zkzv+7fB}?02Ak@PI)q$s*wY+F*m%}j{n5>~z717CB6h$hnVxpFR=C9T(4fe6O`0<$ zGI8X^0pyrWg=7voI?k7xse>dHzVc(daY3&TQJ3tN-Qsb8fJf(Z z!C<5lyXoJUbDk93r<$1=j*BotAc_fqq5&FDXR^j0AHa>^Zkij05xvGf^1)2rq?Hbq zpJ#{w4+a79hq+G&Zg3FnU6SYEghD@GU(qlGG!kr7zVqTp`hQ+};;VugfW zqN$|q%xhDth}sde(1RQ~4b!)Vd*_v$RZv{f+NN;{?$%gv3m)9vT>}IS)=01h0yOU0 zxVyW%y9al7cLJ(}Am2G;4X+a}6J<}>o>pde&EYh;?x+AV1^_pyX(=!=L^MY2uK57^%Sa1}S@yfv| zm`SOI1#!B_eRD*)A(HHdqpTHm`W{BJrO6s)4s$D1G#AHO;ifJhjXMtx%|~JzNL>~` z5tlom6uzc_HY-qtEB4)K6{QO9|EZ0Fv%NP8H%f{1AIb_}l^8zy_0;kZGV-^KR<<)| zFm1F8m+7mBSTZ#&pnN(JUF+PD9Z9O}K75Lnc16tTcJQ-o(G|p;G*#RyZyH(^)Nk0cm{7G3D&LE#Z&YqN;mC1aj`@YThrz?N=(^EqDb`L(02#jUb)Kkzpa=L)Y86UQu2KXMmc&*8?oRx{s;_79L zEr@RMvQT@X9IO8evuFHAzdoj(8yH~@<`WvA)|5dZgmdd_$`(9&0vFi;VhzDUk z3L0eAvq9*{c&}gj`*O&)oqgLLwS@#Wny8wT(~Sp#c>Uf+Y(~O)f30-1!hv5HAch{) z*A>1MVV|!AMl#?XBC)gzhrbvRk#Q=V2~$?2+$5tU1dxy3<63kRMhN2J!98Y_82?xxqpuvlU%Wb9J^1>8SSP-L4G3$f|T~&(9?g z$iH}7u}t<$l&*W3(cx3<5O{HlJHLAHj&sF3Vzs#i_bKQ(73l78KdOBU%1}`=k~)N&vxz1f;Y$ODj7=^lv)&RAC-@Tjvzw>py9NpZOvAVe zpS&RVQlEJE!qS?b=mRb@ozkm{+T#;J1+!J(+BoQVE)I%%Q{?Ybz?PIWXHt152G^o+ zbK_|p-4IK8i3fTAQD85vje;J<`yl-aZvfAWqsrlg+Gm?ED2{gfiDW8g#O5T)pg6Fe zjS^p;B1538-lwo!TeXCBe|1Ep*}BudDnTT(NeR4?Aa7eby@T+WZ6zmLV9i(By;Fb$ zF=qvAg09B%Z5f02fxtld-lFbkQo*B5DO2_hK6@|Z%d3V}q?j(;oBS&e8W5Rje#skb za+;PmCRS>?B&Z!VU~-JVl;SQyQTnm}<@;|>Y*v~AX3MZ>s1KrC=}Su1qFa^Zk~%kV0raM5ZD(&vPOzwm^gv6zt`G;{iK#m$}p6wjZ-m~u^XsJB!$#iP9zU&Q?-G*4JLXp0R2DgvEP>q~^)aL~G32b_}2f)w(#ACIM zeh1@yrL*?B&<#7y6Cfku5!Qaq>0k9V7vj3qXyvH144L6|BOv!dmsiLi8N3#Ayg8-X z#7_uxEqYavXmsOR$BD^!qjrbp9{eula?I(}*Ab?;mAdi=Nx;8kg-c(*sV&XuyzSQ! zp&}ysE0EcgQMY4vn9{b~@ zZ?LO)9lzoi*(c#(ZA!1R?~r&y#m=5WHa-6k49IVsRiJ5dgSCGZk+6s>^F$v5Or4_P zc$554wz-53C#4b$cipM0l?pc2tcbJ*z9460YFUGc4Mc=k3=&R9hL|G^81SIxb~$pf zLTB~giC)gSw=?y`FNfeCg;RcJ*v< zMTc#5oOeeAO?`5$9dv&8P78a7NA@j+08eAVBPk6@FhQ*|WB_%eRe4sNbjza%#mm>= zh=UP`AJ(j3B=Eg!bqL5FW@WCB`4Msnw)S|SkkJu6!GkqBHk9L0<8%e4)$AeM5&0T_ zp_M;O%=MM#FHz{rAu2YZH#$^rDI|*UG_`DX_~9YAiL26baAVr6YjFW<@7km+K(L%h zTUntFUPsI<(N9{CGH2gAr3--5h-Z%Fk4aT-b}z9r+`3RQbM#W0$>9l?i6LPO z?D@xkcFAE5f@S7!Bux1%iRt{>+)cJ?NgFy;m5@(39KJ12^FIxTT}hYT*$tjtHK+qH zz#nB&!B))mu&u*1-Ke?4H2pD4=Ry)*V3onIzxse|c*{wRBH-drdc7l(L#cb|RdeMM zuEk?j#D#0FnZ#+=3AKefv+QW^FDBWOB<+6|4~@ku4ZL5KD>uIMB0_$wk||IN37@)W zw5KceLeJ|6iL)IeWkw;KE2aNu*l^niS5Ma=Ft;|Jm-~Tqcs3Km=%~J#9&*VkK(W)} z5SMz%Kt)?mH0EjqyLWw~y;#l?S}QkVEo7)<`O%N`eE4{21)|Q1$W=vvedduSE1T$D z)gPCgFA|}3(*x~4S|*pOt&18b8)^~K?dZDMxAE#hnC;7{mL<4#gZUc5*^y>i}&H z)2X&u#o5VXPj4Kh;;`9PjV1MJvDR6BZmucloM~lUeeQdQ9o-?LJweT|Zl$($@2u8p z+CVtoaub>}p8m#j`8p;kb|ew_m8UZ~1+KDs$~Og=jc?n~ky|mOyPB=t7%8-RQ1_!h z9?^fLDcv-S{>1qcRkRR5eD;A+rZrO;sVV}&-pvN_z;k8<#jLT1Sn`OOzRgO`L zmRqO;Dc1M;sWsIan$z-yz*ks05jh2)8bSAYmmLEZ#Li@x>ynM4253kEzHOXUM4m*7n4wi6zVak6Vjy_e=YNGGQEAsTQiSt4?N!D~i>V zl*Tc3kRt?$2`+Cn*XC{{Uer`UzrIg#RB+Kd?uIr_ivk5D9L(tFkA2SNqjM*gbEe6J zDv8}^W#%JMXPXOvi;Rop-~Km(&Kw;B^$49QA89B=3fOl7Ix{aWXH5Hd!X+y@Z2=;(wg$7SOM_40AHf#j&5>EZ0fNDGferY-Wz$2n|0~T-q$! z%icvrJ?FV7nyA0__BZ1DH|r+@wZp!Qehm-lY;j_KwrjLj^Ej{wJUd&Jst|LB9mzka%a z9Z`fr9F+F2BhQwKUY^eK(;jJda@j$0%^!yY$0|{$`@7SD~@H&ajAimT%gLeq~w2vN#A{MbIU>PYtOzdE}K_i#ILauX&8i zqiqzvJP+PhCVzq@b^dm5N~_NjH&(k~v?*#Aupb(v`{zkdCg zDiBek?;Si$z=z#tgvK8s$$w*6V_wDp1k%&akaJktmpDQAr zmQL|CHWi7xxLaFsf;IIa$@xPghEC5k!HZPX&yU~Q+Wu5nJ9R3PpO$p2?S%xlp1i(^ zRmiO1U2A>6T<^^kXmLgaU2ad2W>}A93RFPzuUSW)fQz^NJ7P6|r5B*lk2f~txk@zE znq0l>Rpq1cq4s@e_+Vsf#KQ88J@uF+v5NlEu+Mp< zCuYmg$7;tH{8U7Cj{631Hnb5Mb<pHeoaR? zf}2%^zLQwuicw_%>lUUY)+jowX|r|(vr^D>;Y}BB(i9z zcIX10m~*KfU*@9M$)jsLjk#fcgXx9sq0W8&9oWtL+0+`)wjXI*C~%=iC34VZw)l?G za+g9<&QixtZ{YL9E+0d>@h%ghyZ%0$JuMANM$n)2YxnnM+-<*`6<4q$WCZM?%~@%f zWs+;yU?Fz-C)r$<32V?9>66)#)c=a(cL?raLb!$#o#buw#x_Ryj|D^6cQ!yt%e_J$ z{QYO@dTR5k?NP;Jy%bd8L4?A~&aEDf5K%T;ZT*&m(O)O)1iD5Z&5lH^=N4dLNczPp zbS2tak|AsRUe($~XwaQm1AITNM^TtEr!Bvn2`jC1g5cyV(Jn`|y6Lsq7jUgvpc`oS zEU%KlXm$BY`MOa!POGc-)Zw6_tWUTR%wbOxrMm{fce7Ao{^o7v7NeuECs0Y|(Je9Y zZi$Bwot92r9<=)pS?tgF&eH|Em&NtFe=k)c6c84`@3F0iCSaLxbZu3RiXsXf=oVlG>x4Gfg&L*Uqp4F?DDlq@1+gx zmFtvkpcSK#q-F!Z&AorB)Y`WBj%Y6JHovmyn$8mGg^|FDPCG&S`^=8}_amf(@gSE~3$W49AwBaH zfaBBc%{Jt0P8Ic#03n6`PFG1XnxN?#ZYl}9GN1Iz(iswKemKilR~q99?no_~Luj51 z&zzm-?{1{+E|gx%*wFP(5Ao*tv*4xyKr5YLZM*eSTf%me55D@ZW72?E z_e4s@yUs(Y1urJqTjrKLsqj?lLrzExGomXvZ2pN2ktep04(2q_1E6|U1{jm?os3d& zl8dH;I^Ej-!~#c#tObT~0@JJH=bopG+@J$c4iL)x9A+2M%=ZbZR_EZb^cCVtkR@u1shHuizl0DW(RYdqhe}9&&7!6* z-0)>EpQgf4!xBQ^kw+ z;=Vw+-g&x1IiN1mFUdjS^!*!cLcy<~p&I7u6#5>ea7%QT%AeM!*vwVrrJWf?A<5sXd|``j4JSU3@N#%s-vz@kbrxk10iu4wC5hoI4=rh*@$V z`OK-?b46@V;U={tlnw_MS=r0oi(2>{<~OoCB2i1QSY(O;S~4}$&~<_+v`?@xzTt~n; zD7AR!0rb50LEm~12mN0EAN=+|=v&8|Vc8|UhX5gZ^zOduPcVq{JzHOtlThiw=x>RxWUjra(6cr@ z@n-+ZcjtP zQ%leezO;!6{lDN3=tj~^Yws*uja)hcqw&K{#1HAtY>oDIR3mRuMrv+zKAP9{pe0C5 z8eH9Fzh4IbP0YSYmB}be7vZTiJWj_&+a&3(&u(0Av%IV6onom8*Jv%yijyHNv-vp| z(%H;SLX6rap~XTEJRC{@e8?07Bb7w-%k(w|mSD=wU*PnrOE>L)THMwR zdX7n!9~`}J@LTGCE)h`jT7cs8OJ?t#1s9c-Sy`b~M&1V_{5Dym=3Hg3`#K9y*^sI7ShGd6l^>in0`#s6PICn2DYpf3HR;9r6xuD z%CU*QTBw(OGj<8ne7}$q3DlD^D>`&$Ifo-(z3X^VY9=oQMvOTG_e``a`u7EMjzmIy zXFtM-zuRGcBJsle8HY0(7^ZQ^WR{d}yRPsRVl|?VOFonJ<+fcjGM)rsy|x?k8VBmo%SSlynge3wD>uqTB)RP#W4Q_=WG?0bhZ zrXKP(D)lZKtCEX5pR5MXgo zSO!ZX_l_VH#vjA&QHG-UR1d!!(=MS_zcH>`(v^e8@gn)l^F{9*QSAJteJ93PM%Jp*vW^rkD65aIaq6~$cbzwE9i1WV6TNn{8x%)DP z198`)tIOFD;Bgg;q_yRRk`y2RF9OvdIV-vXr-am@{QIcFhhs>=Ar(ND4pH1S14VFD zFRlQZK`E}<>CONWW2#h?%XZ7)edtJOCu{wfolb;~iX8(^G?BmWfc}z@PLiR=CDL5JtO)ywR<*xMV_}LS@SG>q_YI69K|@=W ziTJ`@tBGNK+(c>RQmXvwI5W9th%L|-cFNVrp*C}6|4=v$=l)AismEOFhW5EltG0;e zOV~VVjk@ptBrGN+w=&zJj-+Yd4FHw?|XI#tsEo<6yz z*Vo}E_&TKHYku7LH-J~qz?%oAOrWKRN(soK>nr~hSr%n*o~=vZ3U4%oSA}IpWzqFp zt6D*s#JhO{Y1!$?nQFbDEh({F*I_=sXEjecwl6i|4qH#C;|={~ia>Q)Azpu+!sPdC zs5uf`76NZPu6xUXa-v)*!ZrCeMU)H-J~*-o@TEDUN#caY=5`Sf7}sGWLoXUA6R}@q zv5Fb82Sqb!2&pKPv6gUxX$rzBYPlGbP7cS${|>&37Jf^+-KZ>r<3g6 zWSzj%b;zy7XRr=`TZT;I^8?4^;;(W8oYVw{EW!slHp}G{62b}uWj$Yl{6f`WRmuWbnJN>H8Qew+=SD$ToMM}t0OWJQH# z-{BpxF!NIjtj6MmVG!F5U{KEuqy~W}ZzDVs6l-EaLwsYzh1VSY(hPEF2}-OdVYypV zB+js$OHkJn-r6{?sxmJGeqK4nK@1A02^dDDWRfQz3BFCEV+!Z?hx9MiT3uG-0c0>d2pOnNZ7ml zK|&;^dBVM=ky9ve5_{27#xT)sfJ~p(gbcF4gz1tZ~JY+}!y!CC2;@7j=n_4)z|E%~ zk`}1=&?)G{se?<)lrWJYG4Kk!wg}gsg;6OXw4{bmmQ9RXeUS*QND_ zEIA2(ez6A+oncaQog@mHfO`iNP)yL{*9EA^PT@F7Ms_F&awv{SL&luo?vky0W1~dM|<{ts3)e_lD%LmI`m?9<4mK9IGt*EC|#<|VKR*w5P zNfO)c)JioG+SxA};^ItDeTcV`)0;>*r%#uldoAS!;w*$~POwF-xRw#=C+3z=Q75Z} zWP1qxbSWs6q2sHe;NUjk{>60WpV?`I{QZPCU;L|j)<&*5}LQypt-`b=OG!6h~D%qetok@m7Pe=aV*)RIHhOl$Klt!2v>mbQaACGHP> zz;D(zwn8r8-Aa}-X{GS#tI?vG!R<_WMbx1SP&=1w5$ufid&%;j7p9(MGQ; z2X3`7?f1x1^t3S}cw3|x+zwL+LSqSSP~dNlS4uky%Ssw{Ei-c(kX<~Ha5ljK-EMBs z+Hg*;Hy(05O;NC_?#)@DPTrNrT@1^6I2=OuKH_cgcU+1xe6kAoR78Vck$ZnsHe)1S z1@!uihitNGSXAzCf~77abIPY@@IUFH+9Nk3m;jxsajvf(gp*lwqoARa3ENW$I3<*Q zszx$M>|5^tutF|_3&6s>KiyeHOA;*7MSg88>GXQ@GH_}ZxFH?#VPIde5JI|23%;ZSc0IE-c!AEq(x9MW|)UJhi z`1DvE1-4QXGkb@Aaq*NkO2Vf1Z-ZX+?;eDv)5AC1ey-Q*Ip#z=ypC!qXyp7Mx5shL z#~E2ME6D8>BIBDn%d$e;{RvHzNWn$~`ViRR_zD{iI1#ce`uJTNGw|II5<^p=o;9j- zD*|R)C{GPZ??|8BP>%^l*J8Yjo|=0*Oto%&)%y5#NqBb!?k`rTGv*NZhm%m;&>MV@ z3mnE|C*BBaYH(N1K#=zHmb)52t$dqGeky<-)0IRxZy$9JWTp1zPP9j_D}6n<)sYTc zz3PnoO;v}PI4w@64=h)Vg7MmX^V4y67Or}Bh5sgdYw`;J-(QOS1&pU|f|&~|{27n7 zG*6JT3kU*uJ6%;us&2FWQP5x?kbC`?%a;9!wc$*0rF|(C@#{CHVT{Ka&6wYpOwcc9 zg3MHpuXFlno0kx3?Vk=0xzPt3PrjLmh=a9q^?}3vayZtup14Hw;}jA^)Rtez8@lUd Y-s$ue|GCHO06UP#R$fq}9pRz=7m*&DQvd(} delta 26199 zcmb4~Q+sAj7p;?Y)E(QlZQHhO+j(N!9ouFHPt1;O+qQPU-`;;Il1|&bPuksT;XEDbaxF+oY9tGa3)WmCb=dh010&^#CaDx@ zyT7myDQ0XHAoyH|6MN-_ihV;J}1u#G3E>Y6BhN6%79DqdH{zacm*6 zvvXm}h`W&=VI*xDTa%8XGwtWf^1_chftaV92lv$D3&26-L{Zz`1MxyljxC}ZJYdY< zV%ujGrYMZw?Uk5_b{ti+0ern4hv+9d$@1QW1X?)k6TV3Lx%L&U>?;U~;VAUW?I`un z;%##(fAd2qm@|I#dxnf1(2(PbnVb|jY=?u0A;snfIcOY2?K2tTQ0&nK3ZZ%J7<_|) zLsdSY0pbzkNx*WETy^HZ=7~H}#0aQ*A_fw~abF9MJZ=FU&Mx5!{gY)H2k&UF_tOGU z1EA3sESQr}@4?i2s?o5F+#-hHSWf{jwzIHNW8jXWCh#w)flAufQLtgbh~kc=_EWkR12G7t1 zAcO^T{(^iDraC5C|9)JKq;1@tU9B?#a^!|1p}BryNBBLRQ|1>LSR^>1e*O~qu)&<| zeEpU~T+NvIzIL^-c@M=@nS|%bB);a>q26rOEJ*yzN8YAnxEJ zj392{!VCcC4YZZ-vJ(9nyQ;z{#<-&b*onjrKyJ6+*A6VlT2i-fFKdG~?;;zwe z$PFjl0K=G6N1G7zM;_c^nc4LfKdc2!^5Rz&)s-=21Z&b&zWZTo;wS~DELDC9=|G{b3p@B#Njr5j9<+FzUq+R10LWF6J(Wt{6qsn6I02=xjdM8c^Z zVOpLvu60GFD_21rq%I}DR@W~vY) z5ZM0v{PWw$($Uh9y7Hdz&YX+%;l0n4i%?ZhkAsHE;5N%246C(4xyg;Ck}Q~d8-pZtaeo5?<_wjRx}tA7^861 zX^4<9J9-Pz4yS1Z0_af>BjSz?Ds%~svzNDv*c`rt6Jh`om_IILQtWHc^JhN@EG7hz z8EiZlDW;LweSivMD91_EizlsI5HHR+XCVt4ET>2S(Owa>U@jkVil^ld-(2EC$*g`x z(Ga*gXtF>+BT|gh;2e7&%4!=k#fC9I1Sn7}<_CTI&b%ulJ{jygB{G4MV%${%Mzk4~ z#m)R-mY?J6*8!NXr_1ZtJkuY~@6+dblbh51)1JOvoSXNdER&n3c`ncAqr1C*|RP`4>PPZY-dvS@xgejB&S zoL*syeoI$BaT`mzO<112iAWJlJWe`~93);G>8_FLR_X5W;3gaIFmO#N)64F(CHC`x z(Gbh?^Um%@!g-i}VM4}QTYXF1)%@#=vbC1_1q#-sd}O`05Zzb}jsPV=F=B@2&-%-cwLQ}Prd9&0<8YoUtLsl^H_SJF z^5uHN^Yqq*xes^I@`wAuw%$Oe9{US@=@XdOuABYFTezq=0^nEJj|y0-EkldYlUEpA zqn;7DrKL9``ZxPtm70)N?C1t`Zq-GbzmO+@%;;)6g)#5uQwawUnv0rcca3=nI{{=M zg^q>{rl3F=e#-(udz|*ppH23hzT!=FHyyXvn#|;&bB7Q=-=%PktjVQtj|jrB&UHN3 zPiqf(KT5C20hj_Y26pC?C2uwcQ&e^ww50Aymgh+SQq;%8&wghVWsk6|?iMA16kAe& z6XMB_#0L#y|83ofOZgb}xSz6tNneU!)BG2hk4 zWnEgl3B{QzaJjLc+pb*RI;;1bgB1YymFxSurtes`$+{sZy>16ME%)YKGUh9)bu=uU z8b3%(!H~Fnk=otd3h^-Vt|=B$Aa>B)Ti=Dxx{J8D((TE<7$g<`5?~ndF!i`wj?TdY zgkN3V^o+Uxi5=+dv~t~-bC}tAUrseVp>EHlPne_4bf`X3*eU7e10{&`Gw=sE+8Mpi z{cS9u0G6PrP;_o2>9MU!#Dv-gh?|kLZ#P=llxaOdGtFsjMOe5oi~E5UVCIGdeoM*M z#X2I{JyjxG6Q4s!DCip0ap9Pkj0fS2k$9`AG>*}qQ?`4gEv0>No|VlSIAgS`{N%Rt zUR)&U_U!}$*Sjw7t&dG*(BDnP)Kb zYG7qgWlarJcroWGQ6kWiZlYAZXoAP7{;ti?PlB39qDeqwK~f4$bNK<}e=6exmCL8@ z_Ba!{@nOMwt>8?h&S|cVr3R6nazy=mk=vcuRY#9IoYm*vCh?Ap<)PlQ2Kw4{6BnJY z@JxGHgznC-l&Q}r?l46jEmb&){My$U5Hvt8*~NkqFTxbk5qW&Atp*5!96RS~zc2WL zzGhL8bxNWYvO?vT^d$gFBqOB5gqHfGrZ22$bV1uvc+|oilzTn>jIc+77eBn>13`ll z;(hxrC?dv9-e`zTMcuE#k^h!aVuQK$iP*3Bt$w0`o&mB;0YTqD;=6hR5PwHP{BMW5 z3^JMKCuWw&phC?VLh9|1nL z2O-!0a~@B;`h}5ry=k{KtN9SzdKkHK(DJHgkyk&{SX4)<$M#`kRb5Ir-5)oDfT?C21Ir7GQL5_$FMR9n9EVj%CJ=6dR+=rnx@9)6hGJSRF==F zzP$Ex;TGKnMR6B)lnFDl_?{~@92_Dx>A)eLFralkA7Ok*hg+P5ln z#jFQfvJ4xO??Gqe;vLV^o|e-{O?qUpA9X;ViITYiT1PLyT5F3Uof}Ox${j!$fGbvc zf+lrkO+lXfwPN^1!oa>%t%^&9+J$rc>*xP5o2mw`U z^5MJ=jii|TfQ8R}0D?W)!B)Xt%TsBy?X%;AfD>XutlV0URN>Wi8+5(7&6kWlC%D0z z)t=Gw)8i>&(;ob(Y_MjpI%=dVk{i>>uQ<;&JMe?N!R)1lWfJtrFq25V5??9el0=Pe zWo>%fH3qPgdNY?JJtC4mXC+?Pvg?Wa#piD)#uA=9JMC*X&lAYbtFqm~&E{Ec$XsQ~ z4#6D4mUD)6TKgfWKdaBP)iz~#peI+_=VYk%i-vL=q}+?NEXef7r<6nVD|uiID<@F4 zm-BP~LXeJ_FU&abP0`GRp#x}RH^rh-6?J%B5JA32ibug>zpVq+ zajVWp(9>h3Q&Db)MjS%1G3AL+*3b2Epr@nKkI4Z2D#(8J%I6 zL&s;#6hiXiu9DTM&;eQs#Ad<;#*ggNFav}?&`*;-(yY;XiIT$uWw8}lHqy0NCdyak zt(=>V*`M-YKH|I2J)*|gPynr6oi*pHx-5!0d>u1_JU((?$-n6R^!GwGZ2PvNmHD^^ zlTjKqe`V^iMhG`eKHb$b#z7=-NF+&E7|}kx*1YkRDhaJ$Az#iJZTi>Ow$oaZGbew* zBcVz#-o%~Qx-aE=9Go-2-x5dXFmNUlA#efgBAGkPl6a<}jXMf#WyZkU5Y zVrdXN=&mW*RYyd9M~Rlr*pvDxMwBTKkfPWRws{Oit!7LOt4`gmOmsdSkr#CnmM5I0 zMZNA4XZQwhgqXiB*gLo-Wb*QGWynPJ^;4SWa1<(kf2DFQURDnl$TOhwEOoT_b=?DS zO7gZpU7n{MzF(i=yuSr_ecL>G3%9?|XWo6Eziuvvo_wCdx;wj~`Lnk^o&V%f2`t~MS`QzMfrg~t&Rn47&jn02wXNh62e zC&^=IQU921Zm6FCPcNtXn;jA;*!y7sI};#aDS^pxlN8E!+*Uh;FQr)l`|%JKB*MID__*t%}xF7=5xOMoFE5K>v3;8tm{*p{{R(R2IY>X#Is3%tfLmauE^*t z3chz9C9V0o>aiSyLjAp&RC^?$jwDrK%xYCJ*l3nY$$^yvSM+yU1p=U^7l*{n(oC*X zx;3@*k*6@e{TVW5L>^r{v^>u?PGDNzNiCZgH##E-rVbyOO#l8TkiZxo1%u2~eb!GN4?FY#dhA+K=1cl~B zb&7~gp&Qt!iHcE&%mpY036@Xm=5kvMLxGOqv|l$#d|81jTt0tEx8_mXHyr4%L8!+S zHg=t36ibzmw_jwo3;FjR(Dv`ePMF;A7)e4eTtt4n!-|EwX(TI@2*Pkd0UlH2@WYYOC2T@);FJ1u8A3 zt=h1JIV-Jr)*#we7#D_0)&0N{G1GLcX7fa?sz1z76X8E(!MoFc!ampmNh8AI4R=_lpbDJS-;9>8uc z6j+l;M>JF2UW3NLlis%>#|-{8!u*v)X;JB1UT=4kdVmPtxQ~5JvwO;P&ZvZpc^TUE zt&NQhZ~E`fe?$8Brv#;0LC>EVsvJsgh124Vcrldi9{+FZU3y@jzrGGn8164B;J00Z z=e)WFi)P?oYK(w6ZI_XN_0EAluCCMqXJof0pKp2W(%NiGFlynlxzHvB8tGyQlun-Y zw|!%2K&HS30cFxC^{UkvEP)&mkz^i3HsS=6>IgO7;-1T(u=GOuR^fLIne` zf%3qoWzv{DnFwEa>3W&dXjrxUCyx<^WUS2RSMcx_sv4%M_45Y>zud!ltxB?Npy_X8 zs)r$wrC5>XDYxu(@NLLnSdCHM+r!zOA)$#{g*cIPcf z13QWvS#+h-E7g~y6Lx>8?Wora)f{3M3QJ03YqW0J*G=ideyg21BWJJ2+tmoQ=jb!x zw}^Ejk$bp_Wwpm{&I&I$>epzl#b32miW0lqwiZz}tfj=;s=$^CkJ`_-az0G|SO{;p z0*ni;+Qs>ENZ6ZW)HaaEb%p3S;S03si9)2-+igc`&$sIMVAU;-vwx66-K}fV)BP4p z)n(rZW=`#mk~6E64tALTaU1Nrh#4k`)7w0%^;fWbt(*mEIO7JmS+*1TM!$3(PxMboZU zGrwT)eqe%I9U$bUm6&)nxt;2A08&Zn9O-N6&C&z6@aFk)O**FZr>{^?EOZ8P3f_@& z!1y$e&oLOV9g<{z#v0b6nj<~hG(@#Xn60U@FwS1OiIHS3iBXCoB@rexQk3+PcGI#1 z^GnasR%9LJ+M2y~`K%gNfk@&=@E?yI^S)+N}Y zRfeR1uuL^q1;8Wr7B|7>5#t6%D8v6d5-kMt3Ty-5-L@xf9l7irpo zf^Wb7t1!2Np4%Dr~V002tt?o!pke6 z^`}KNIC%#lt8o^_fSR`G|a=ZMCIp; zS@(5>^Vw`Zv8~)XssHN|ERAKP8%Aux@B%MuTxZ)VCfzaaCuV>W zLpJ{&ow`M}E!lU}2-(<>geNQ^gM5JFze3TlVOjd~spYT|($r?AiWtT@&YZ|1Kn1bl z8KiPzcg!_FXQB-GvK-U-^gh|d$|j%rEH$HetJQIGS##BY>$D>Wr*8(>>u3hE8vj%C z5EHO_y0kT=&O(whC3kpm)w-deR%hZ>alKGBDv>y|03NIuUmavdhWAijjm63^jMCvz z9e0=zg`fOZG6updWvp&)Y0a(1iB@!_U^G5`q!5Xc+GN-I7d975_>jpKh}PUPrs7wX zG-oleJFL-Rx(rt?f@xe+UwPTGpN zO&ZDs7ZUVNj>AWKuGqg|574WEub?5CgFFBYI&5-{{lbJ?V^qYzh@Qiz3xF+C%m&zB z0xe_of71?6BYLz+o69ZOow`m=8M?;4gzb$i@#wH_UZXD!u3f1~_0kRMzL{fULzEeY z1V{{dAAO3=*5%eMVlm`gI!EHQE@PTp3S+M*9y7jLeRcpJY3ZEE)6*2!RV)U@e)(v( zNyKgzd(J|Rzabowxt>lPL~qXxLId9UMd{?z=&nL=;je_cYNx@7S zFvN9In{IAtuHjSDe=lA}*t;iIF0Qx6e(cp?t2A!<7bfMr)^e9Eb!TfYqX8_tY+;j$ zf{Vc;8V-BKmxe1rB$h;a@<}AxA#NB?F!!PP!UqBTrL*9-$5@y|0dXUs7L{9WZjC}HqRcl2k zt)DU{qQyyMaM16;*+38gO)3gsh5?EMfr;MYG)X>E9+FIfI6KZ!wWF}NRA^N?^uHiq zP@VD2!$)9W5GN^-#yO&XBFXSMEp`x><T-O0(%IU1GH+*JPG zXPad342a)wlX*cDXJbUU*$KmxfRZm9d!sD7){byJw$UN_EVH?Uud!ZmW=3&nPsR&{ z=h4aflA{7LvpoQ}De-F?QqJ!l0p&fbynKO!G*!<}Jkv7Iuvf$HmX87q<+nRpVHVtJ zWIMq-5v&O*8_D-zK(gVz07ke<{Kqot=X1{&8zww;FmJ4QK|DFfEd16ZrAV7Ew?#6B z$Fj%nwn?KO&(qgx)~2n3#Y5(H+()O4XWKZW9bec&`8vRu%VYzu^6a&#uj(kI)t!IN z#bG}FYsI~m_l(CMXCfi~5E;h^tmqYIPsza1`W6XmZJo_N1M>{(5+rBw?L6Sm?-KKw z)w<%b9M6{aR)gmqFuf--`g-$qXg}Zzr8F$zhLH+>;%3fydU8&N=;-(H;Y-|w{Fiq_ z)Bg3$CLZ96V->#5$?M4v@;QG?i2^z zL=^a8L@3xDCv8c-9n^fDgQ2bwO(ytpPTKwY32uN1RyfRslTgt66%@9vif6r=iyjZd zHgZ@auHa0~f=~!&gKkQpnWT;QoqHQWr?~iZlpRicVAc~H6FQD#V#4pf=yj?CWRno2 zCqzRPY$$$AqEN13ReTbUZ_JtF7i&Lx%b>q8rP@?bbo&fjwVAx3 z*0-N4Y)e9!KV-lE2oCl@Cu*4VGAuPCyI~0d|6nh|wWMBdXmaAB48J`EEW%Fa>YN*3ZC)AlFEh%Nqj@tCe;lhwOrhA>c}DNwq|9 zcNeGbX%Sm;dowei-(-WL4AS>VzUa5gy4%LYUn z%Z2tuXG$_f*#Jd8aG6jy^Y5G+lOe@nmJ$uB<2j`Ds`o65tZ^T&w#<^qBdQ`?9mP%h zLGdUi0KeK{7x#vgLZA_j2&JjXPF){1cy$YQF1r1$Pk@;-4Ay43MIb_99S~mB9J7#n zhr7C$bg|A9<6Dd6q@Amq6+sb_p8&~xoenjLdsqE~ zM7G1jwcjYFav!v2)5S()XZl77t-lQ7=qG8Bw}|-A4;Jqv{!%Rc)-Jo`vb!#@_NlWr zj-*U`#JaB_=v$AQBdqvpA{CnZmM#up;?((>Fy~VBZAeHCnku6;9!Tn!!U6!PWowZq z9fDCOByF17}%hZsQ|Bt+?g?}=4$9uop-C!k?V51z$ z*5@z%hgk0@Ii<>x04N4rl;u0JXp7zOP-{ZM3T01eD*)75#DPADT*UIUi?+aD>kF)U zKp*1+5*MuBa6`KO!^{a|SiqgP0l+IeqdzcdHu>bmaZ2gX*3Thpo3SS><{=CZEYR)F zf5xUYR3vD3I-j7J3PUG!LAq5pI?)`bao@7(a?`GNb?Nd6P!Y3vr5ltjqbQM1SmYg- z^F^7PD86nZR}Y7BioHZ1NMuK2PPsecR9NZ7Xqq^Q%rIVQPfN8NFf_${VBjD!%@C*` z402@Tmor^?y9N29M`A|9rkPlyk?sgKfg*zQ9G-6*5r5Zx<(`FnJU{De)_?7Pkhr$s z)aO%VfEA!7JUn~Jl~8S~DRcNA7p6v^Q@AJBJt-R+n2!z~BNav|sMjJs0UKQm)S_rz z+@3qpj`}TlWt-}%AiGXvN(lrZTr=aEEG=7f3hcV+_zqj&b9HfqECS{|Rk#beM}u+i z``eM%*E=o~RHgj6@LQgmhy@Uo_K*@?CzopO05aKUsFA$Y8}i`H7wkD0AnH`owrjjY z^X;(0x?sUOSZ}y;PN%qsi_$=zHO#z6&yuXrM}tcxfVu=La+MlcY@mr`CV+6#czz<2 zwabeM%luTCA!r9&IU@2oa9s?I-5=x`vPn-ExeZv&4<5s51UtrUQR7rm2@e?*DZyNO z0FWfEn-g2|wwSx$Be3O`r#SKRvBb}h8tAwZ+COxQSMvN|czdF03V)(*>k!c7&FWam zt>eN%5g_%H%(lFq2p=_T95R@0-45E9Y?VKfTw0t3zNB!AB~ZqH{2dsy-TzGEIH9UZ_FTl~CK6SrpErf+PT+ZqPS=*Hg{_R?o$yn-- zUf<{DuLzRLCf2XRrqm`7k^&i?;4|NpA-BH2qx;B>`f*sr&(qP1669NB%Lk#*4e)Jo z!k>Da-Qmq{U7GUy!x<9RS>z=xzQ=$#Y)kFNMh*oP!q6TpCXPCMkdIdH=`Y@5!6^v5PZt0Q9go;AA=$!zzd!(~0P!MK%dj6Gqw>q^n z^=q|}8o49C+?;mSc4;>M3TG^$0!GvdYpGF<5c*t0#YxqFzH|&U+8)64gQ+5GgIF`Y zCMwpDN&0|~RJ!;3sS)&;QG+2%l=HR~txTbGr!lHVi ze)8-pO?ak52QOZJK(jcltwvoA9p&4?jbPceqMM>c5X+x4VN2kjG2tYk08Zrdc>=G% zJ5Wxh>Mvl&Z9u2=7tBBr19mK zTsU7IbeNYolv4bCQ-hrtal1y&(ui=qf%!-zbd(Zp(Yh(3V$>2^ z5@5+gbR}z=aOH5O&oF8-^SNDZXhoQ^a?-bd1grSCd9fUD80788EmBKPlUTkTg z>Y?%g)NbndMM!hB$QltHW<(Ff0L4^=+cf3~A;vzA2;M1D+_*^|_Ujej#L1p&ncAer zTo+Wx84q0QDTsz!)Fq?xcQU*tpn=4!DFYyEs&%@w% z6LyZ0`8}eUPcVuxd9`P>rpEA`jCzeshBc&SdwEEMeR^h}|2AX1pNES=-1mfB6cn9I+uC%K^Q-C&d+l4(e`Ao6`XmIx z8(>z%M$}~hT7Ct=aI3SPnRb)K^?CCIu+3JwxABBmYR_*1)iAu|=~+T$ zJMHZC+U*_gl_}ffmigQS1a{Ia*b5Gx0-tO(u2oF%Qv_fI46M5P#^8dmiFbvA<3tNxRs2$&|QFR;DP zi3XnL3f;sS2TkQEEyIWy33e`;t=QXpgdoWPOeRP}N>1|-A_>Eo88jr=S*VoaaEC2a zV`Bc+y^c>VMvof@A5_IUyd~%Iv4T=FcziwE2I}ho^Yi+7?VP2vm%9BPc^f?ovlB6u zoqBxZFs)FS^FCZ#6f#??PRHmQLoe?oLh=lhA$e3Dr3=vpl%c7B3)oQ^lTu)*r#=RN z5>ciBMN`?0?h~|R(-T*5^x3`h9kP-h5MX1-%?|V4Ku+xhA41q0^Mkwg540#rKqSVX zF$sul@sEZFDtw5APWP=~nkRhQ=9tqVD>f~ibsQc&zVIBF{UVT&snFS7)9~aR7!wF$ zpH)=k3*+|nVhp%8DVLGgRk2aAwh9Kl%(~=OadoUf7+Mvr5m=|R&HSZhanQ1o^AcM4 z0T3Es!R4fKR*h0zALF z(}ABOnuGn7=N$Rq4QXsEWo}`Ce--^E`E|$=-P&An09MvPblC#wF*e0WM=#n~YD8rx z$%%SSjOgoeo62CB}zFCIKXGMP3c(Q!rJ3% z*6bkW><;bBEq5Q|Icg2a_Nz|?t)^#fzDkexd&GjAI{e<_ICDzhCC~U}+aRO|*sg`4 zC1W&BBFU?|8XLWlZa2~LWMy5yD_2U%2m?xoI zIN{2$E*J>^#JzHEnEX!r3&0ZU)Ul_p=cl!!$MzlQ>{KpYD>bc^Dwu+8;9XtXz@5xR6KrlRl`%v(@n~@KMq1Nzt z0Wey``id5`SN>0(gGZ>eK`3PN@_17+);o;0^>>KDgcsV1ZddX+#|f+ zs2GHT20pn6D9*U#U%9&ib$96<1Eqk<#&z_L=(Q@N$8{usXSg2qSs|l$tcdhCRK1jH zykiphhl=}4vMk$Y#;Z3qcE*=yvx~?Sf8(of@6cw|a08T?keNb4|IiiGllkIg8a)`3 z8?Hs%S%JEro)4VvM(&IS|J z#3f=ZYls3ZhjJ8~!F%vzOb7lxh)D8{8f*E05w|Qd7}VmXgJS=xMY?m0h_%^zU1p9f z#;nC1<4iW8Cj|hBX->FRbod82LSykNvIP42+;ff}4uKnHb=3B$FqlRhEo63;HqEeQ z$=o>$r^WIVei7WK_Iji4VH7f)tZmQcSIa5eO>NF4Rn9=+m7P4@Iw6V$Iv2MfMy10vkR=}pOGCOCAl$+U z9`{G;YUiq%s*fv>2Homg$2hzHGkVKO0xN*>Cg^9yQ<9DE^Cn4JmIO8ODtlvqxsV^i z`+q_KLIHnDa+CC1$FH`jh6?iSC?znwniMIdC{ZJ%1c5d?BZ;t;zXkmtkx?d?{{0mp zg}>{geisaDD65hu1TyyPZ%YsP1@M?17B=%-5SN#g&+#{VL{_-Pnr@W49kf3FEV>i+;}xCMS-<#vgD>_F~;#DTe%BkEF27|hCN zvB2djKs=!Gj){DkAL!3|iQJWB=gy!nYQ(z;y_H}iC#%ZNRm+ojDGH82ZhVK5m1Eyf z9Yo%L(H*G>1hs+BK-VK8eMwGUZ;&N4Lb5;S>*vhe3Z|BMPWcEp#}`>-hn= z!d?&0S!OrP+|Mlg*xjZlE6#pRy6^s8g|5*w6ISmhN=9`XPOOwxq0l`3XJ$4A7gAR|;FO}SKapqmRT@ib|{pC|a z&7t2Ou^96!^ukR^jP+4aW>Vfj>tPb0w#bK|yQJ-4<(hKTuBl^H1ipzedDK^iw!XEt zVTW1*$hY^pom`WFR`vpGXl5@Q)hvKdikqLJ;UgJa;M$297A+0%^Kq_Zjlog-g>pY5 z^mV5=NJLI3id5<^(B_X7js!(nyv6zrhP3T_AzFt5Y#o8MpUakiF#%sy7m)`*PdYOF z*7a057!k6l(k}RY=qfr}YCoeKg{8+4!BVtYJ4Y)ZPD9rqnMbv5zreFY0`JtDqDNOp z#T`54G%AKWr@2z%HPO?=^~9r8iyWDwS7C<%242B(>*wXkhxf88zQgCAqAXK^O?DULH6Y z71i`IAQ zRQjsJ#;_WV5}ak!czfs~$@*RhStUv%lgvUR{x!of2A`9VGQuWeF9~!g7W;KV7nOh@ z?jrcJgP1YD5NV>U{pvA>S3PTqTg7La!LYMg3SNer_O!luAW5&`z+U9xJ6Z>mKAC&0 zyk{>Ng9RVp7JABIBQnb{#k`HnX<$4Vb&)evoeQsCi`PP5_Ay-#U&qq&Oh^wDd4)gZ zNx4@15)pl6z}~BXN%pRV~;xbStd_O7KO@wZV7I(eKP^?!xHRQMj z>JGJnXV^0xuqk8+6^IA!j`%_(yps-xbPv(1Jq!m}EARQ09+{iqu-!fVsSXxkH_tLGE*=R9szH#7=oiA ziEx+E0vV>Y$Sqs0XVerVM@dh!=(x&7vv5}H5~nJp&F0yeT?jn}trp_UD1j@;427RF ziMVScHB-gf_ARauadQ0n!sh$2L4)Ju&P0)0TmNmB&rtV^$t|KZ<7LmGPY*GwQF#xe zv)JO6ve))4P;SK#VB=$<>FI>2c&!b5;TfoG zb6^StJ#tCTW##+T*UrHQ4Mt7LADVo~Dhe&3A_@KL?hzxIi48~MGcXRC1LjrtHz*A) zvX{>g5}66^WCDP3e{C)Q$6s>t&@_lx=xmp4-d8=TF4#bv7im5?t;=A;Pc~ zDgE=mPnqT6pRptt3@P0myJ7oao61#9L12^em#D7ik+evFJU#=%?+Vi&udQ+Q2*g5g z$z^nijHoerRm>!^Gj%#a>oVy_7ESbNfRzL&!330)od0pjBJdx%pO#x>s7n1&%Qbi$-=-@l0B z*lR}*Q9;p(6)sQ(r1%K$FJnwmaYzTW$U(hCMSQVmJ((d=c%MrVQGR!6;s?Z;Bx7=r zK`|%174*$-CW~@VOK5_lI`J)^(2x}LBa+*=yWjD%zOGtbOS8(8^&PmSSNelv# zVOcKnSWns2+#E!TqWOltJ&XoA-FHky91xam=ZhU*lH9^U0kB9gQJBk|NX{0L9jl8n zZg?C!uwr&5Z0+$y;H4xt4EYzXfirMm%A3oOsh~+5r6-L;Wh+ zWuTs8JXcgI&P_Jl1;tu#C8o93OKqp4zKVO328x=PeUr)rx3ylOIfPH5SMxeE+N`<> zHekJWp`2%{v$+RO+iidNMV{Tm!a1))4Pt|f$4J6TwZajHwx!zf*q}DC zKc}PSz#HwKJ$l-#osA&@gXjyt(dzN=`jGw1k?wW1lzE zO>i#rsx~l-fJ*bB-|*WT9>%aSI&Pbx%|>V9L^)dADcs)WV_;Bsz{726S~l264`o2G zk_x-Wb#6;_^9v7Et+VPzL6*w>Dsqa?NlvcG=C8Ordsc0yM@*>kf}PX;Qh7^8I%|md zsqs<+06P3GgLAa0w9dfOssu&3pG13ZD$Xf{ckxVJr)1E!f$e7M?XuK=`xvfg(e+Tj z$`;CBqVAyDA7}i!NpWE_L1@}(qA{q>d27}dv~9H9T9BX}UYjLhqxZ6F z0-svMsu@nh@60`n%wn&B@wR!dWNK>ff_7>OaCdS+`-xxpQ^=0ONBX0(NqX^spq*Vm zTkWMoa3fQ>yB6BLld3gr7*#^$K+hl~;>B@c5m9|rb^DL{=PN2NmJ;>~@hY#>V!pax zT^wgCt2vYvUa?!kl92ZQoje^2uH^|Uq4_Q{bpXV7uH1%-dE`J%WEIJNTr$KPrQoTPOp+!0^HAZjhXSPu17NEfa50nQnn8tMllNJXUjJQ5t=dVK;*XVtI}tc&;C&(0UaooKrimaX z+zO8@;8okN+ZIX_BP^<%71MpF!P|7I6I+VMKi00!^6J_a%$2=YoxPX9FLo;s7s?rT zw7re+xKA8nZPg~KJUv7zQi7!mcS=bPP(6`6^(1T^m#MZPLkGXiHQPQf@3D5e6C2C{ zzqJA5xu1Qaek^)i$ohv8ZmIXfOzvV82A+%ihL@-uAaeOb596#&K%!@G7Xn#rJ+znp zp|cQV<#3km9SglenU48)0db53=u0nm@T9=$rK!{Fihg5TWS1tecO z;)Hv6%%2QrZRH0xBYt77*GDgHqKx?Jq3md0-V(k9{EXV_=iIs6Usr8b8t0Pm6giso zL{WCo9^mZp^&{8OnqYGAV<*@Kj56b`m^o>()3PY2_p=ws5{l*)bt+a9$$LD*%C1ezXnH>HLK0S|cyAYU~@pCDMUZ17y|FHs4*g4Ot<I~gxFNzgrn;7% zDw5<8cDji)NiDDgjJ=XZlxg3Bl1+2L z<=N~e92E|T?z&JeEFWh8bdeU_0b@&d+v`h{N>+dWTKY)IZ51f*TlBzn-ViWGB(lTw z1Ye*|Gyd}-r3q{iyMhl~9BPG_bLNtXA538Sl|reRP4aVd;inKg#{d5SX>Fb4#eY0{ z%`(=>qrCEXI;DdQEc1ELVbMU;IgUXFPjk298$cD%0;T)rBOoV2&ykFIC#*OWA96m@q3!eSEs=ph|96RM8{zr4rN}jKL(R zL{3d@b_QEpR!;uMNxfatZ|hDN<(5*p#=JuGxsG*JBP*RIX*%n5@j`-@8jEseyy>5J z?;}hmBQZWE!)uZY&KLr=dnnIl97iNaIgzA|XR#}{{LEafs=*}SDd zq`fxiihUM;na9^W+8_VSbE|0WAFdx(1iG?TxGw<;Oh0h-DZ)K=uqUy4L!7`rzkAx| z*^j^9SUwH1JzD~?_w!^3ik$85JWfeNLWpwwvEEP>V$tQm!|K_~g z196rm7iNaS!#kFlTo6k7W$=o$^{03_qFly3+DWpZiah<*7qE^eC^_`!OvGbh#)5mg zi08y<$IJ{wCG-T7)BsXY|L$$$4{5X)=my9>N?Efih$`aMk390$ku7FiF~T}w{p0f#lloED}>M7fo^ z{qES;q0JbYGob7*nsOVh&nxOZW9yDbrF6V};^_%`_}qjNp_T-Q9&o(3Yet<-W&5iGT;-!=MI)3bQj! z`tRjZb)*&&^8zR?XY5i3xaTPvuwIv&5XIF@Ttf5zQ^{LJ#nA>_*0{U7OXCvUU4lEo z-DwE!jk`B4K^rHyJHZ>*5G=SuAP_tm-tV9J*WAustyQ;G>!~{X>=XK#fR%a~muv|o zEI*g5w!r`LrMgc+%fskdw+*7M(PoCe=Z+^$9VactYp?|Hi>5}F0al^PJKZlTOB)A~wpJ@4Hqw@w%skg=(tJ5eEke@~Nsjgp(o^)xyc7@eG1b4latY zHQeLe6W3lE%`jCUI|WhOl<|puM^A(DJ!>%olDaA57Y*gTqP;*=3Bbv`C+m|D0+4oB z6~x%YE*62VTpGPzz-?PZM!QZ?X<)M(1Wf}~(Xx^cvD;Co?j{{&^Tnr*!{Qnd={P&V ztrMmtGh*DGd4*hGvk(r2aqxy9%$gKlqj%v8_ztgnGBkrKPAJtoTzB=&^*yGx?=x*( z>KczTZvWOneyq(4UyB|GANLNZtL)u8I=o+Za6fx(yPftIO)UA0JF{qvkM65Khi*92OrC<3v*<8#TB@PgtJarrb2j#{8?F1E`+t@?+L!! z)>M_MQ!n$TijgRKF}?K&7h6kBdL9Dz=t;y@Lp%A;?QCOu8v=xW*2iCdsdw)wD%?*FV)59ho|leGNQsGCX}$E6!TpNa0ap%*3iJ9H zZH^#}UCzWMZ-nol3VM9-v?Bs@HMyggyqFS<9lL_ZhKFChxC^2c4934Q8Sr+olCT#K z7RY}Z#wK@%=zI;cwvkBxB%y6d7#v8yjf1}SF+6S+6HQJWA!>j&OwrK?EIvkDc+rBhcc3~8%%x-^)sJEws2W}+W8O;aZKJYNV~ShH*? zi9BpD#P2S9qGF*+XV;vHmc<+yD-`0Xo*+K-%={)U^8+qE04xsz{RFS#If}o~2%h7| z>nDcO1OlK39>3eQ7SfjJp@6AcEjW`++i{JT33XzO6f3Yg1xPR zLaTy6rkp)$WWEjX5hz^^kKp*p+tPq4vgxP)YIlqJ)3+3!L7QQhWcDNA8TRu{IB;nb4{{XkQ zn$}^lZj&=rt->C+SAw%@FKsGFcNe1P@i&l!ucnaaA`B@yfFy4wVWxtw_&w>Bn=d=S z+|?Q<(R>oP2(Pq(8?SPr_etFALo0ekA&LxOowr0QNejYC4N4oy)a21jzplJGbPEMH z^;d8~)l1OW-czeY96Fh|8*A*RZ+w7ItYDgNrZ!=?Hur42GE{}A{69he6J6g`UF`~T z-&Wk4ej2$FsPPgYO#DsaVdxF2b``-~S5>T3P@CPi1{$k%aqZCl)k5U_H1_@wLc)ho zfmv+U-zGf>0}gHFJ@SP=eZkst!h^CFMHn+N_M#*eH$wI znLZ8({f*9`U-`XS5tP9#XE}(wjyf|oKU~jp*?Tth3Mj^^IuA|Iaa|_r)WFj63FLWi@r*ZWa~w5FkfP7D!g=7G`~d_){f}|Ka5AyDjvyWHViNyuohfEt-H&6}-~Koe({c9g>-gkj_taQn1s@Kheqdam z^GHuVXo}Uihj~#;=Y@XMT0j~)F&_EL3AP%TFYmk@a}Oik%gJC#%C*@u=p zPoHftD?Hz}9W=E`rQ7!Li98bJxpMV;lznnn0M6TdNn!r`6=R-9N)V8DZp@IAbBbx= zR7yP?`tiJsbyFI-p=0`TM&c;YQ4>4yxYr>bbVBE&o}N=8x~6PYwJ$p76^5O9ZlVx1 zLwDmd>3j?|*vR2v!cB6i_MFZd=H_UiIygZC^x0V;^f{k0IaMU9;rskIN`W&yA~)H~ zOE9m5?5#|~x6g+$3N=CN;Ir1!xL|*nVNV&)-$U&XGrJ(FtqUHkpIvo4hU-}_&(s6O zzZB!^L7Tf{*^lz6+hJ7Aq0WUri~oI0?3 zA*e0EQCc#6tfny4nFuA8Vqf)Aa?`32Q5q+7FV^l8MjU3r!8Q!@TPIN5&saPcx*)^g zt?t|OZeG1me)wS%WS+-wOW)FIouv&Tprx|(DzoM;q^N}D^0E_;y1$q89h$zGl+W5m zH1T-rf6e0^GEn0oU;ZOrS(bCtoeLbo_QZU{Sk0lgxHoAQGINg3tz3%qwiH8aME<(a zn-@V=;H^q81@OlbPZ^62c<-N77jlb{vZ_wN>}~6edsD7?n>>uWZ>_1NVMu@m-!;<% z8F%K8d}k|R^?YY1+M=0E;LpY`kIN_L&p|{5{2IBU$e*szU;(#_J>&cc)HaX%OVKu;9t3KoJjX!xw7bWu{m)mf{D{b! z=JzB+#q?eRWQ~HZvlfr?>uI0?2`E|P!FF>4(zfZAp8?aCM3=DKB?b=Ik(@-w@>@z+ zp;Df;Xm!#(|2EYhP2z#=27P89b&QOsqj7I%F8d1mC~r(KqIgLr26%2YZLwCrE|@hx zZoL@ii*E2rrzO&G#;yGJAh3|@^tUUJ6BH~e9L7akuHqC*>=dC^1-63vX+!>onN8kS z{2-0LQ<;2%HZ9$w%PZ~PJe2&{)q$Lh~ zVP`fF_|n!p=oHdJw37Y=q!g{>6L&S9=ue;F;C~z4@Ui;3=K~v7NfrB%cBCMXjnVvFnfdxYjF@ z_x&Nxt8tQAUDW`W1~7_HBkKc}`l5%7GtS(UC6#h1-3fg+3Sb;?1sbL2+!{7Tlm03? z-(60Rt2_G|^(_5ZQ*;K=Ji2$VoP>M%OZ*b*mv(CJIXi*)WQlVAyS>l7t6tZv52m|4 z8-MpSN2{9TK9+&9{Y@n)y&h_W8(}kT!_{=FcNvx%%J+qr6;G##O+$q~iRaX+^4sh+ zqYHU;eOK-WUK;p81qs^nEcLV;DI?z2!n>H`Rv*l(%_pu2Q&|xw=WP#&pyNTop2T}H zB!*g-Ey?rDC8aF%o?PlEMWHH?PsWs#=&F9W4qcl``XmP#q`quI7{%K{W-e)-0MXBBj2HJBbR%a{~$dxCP z4TuEWM1Txu8CzJ|#%dr1HtUiXE&L7fwIdZ<{#i^Pb1^u2;JY4VZSR=@k2VPnuyupCK ze*Sdp%3fQ?jJe)4*SeuFD#o&s=A35@YO&2GwY0m-@XTBQ@h;Wnlp`@>c2?&TJe21N_sBXC4z!Q+yJHVq)U2T!XmJPe5xoVycqO(^ zo9SeE1f*)F7yN+280#R6mHrgtA3VC^74E-&?8n^Us=r-y(a&tm(HOd+CgcrSAppt& zFFvBTi?!45$xl{@eo@X%PSi>n&*J###5!Aad!?FuE!=PKZP4N)o9E`z zn=P@G-kUvdPiA^t6eQPi7-I!`QQ#9&8WuRnPG)_77i_|Buf*(8ZB#9Z+$MLUOMYmV70mA0hv>t8XPHh4FoAFKubwN@evKK7&u?F9MR}ET9nH}JL^y$+RVk7 zzQkY&=W!Kc3gaRJ@s1H8O-shCZ754s!YlWm*|GHX&1V zX^t~4U!gm8=Lv0Ys0rTNR*>Mk!2~FGm=H~gXMSeiEJPQcT=`=c_~!Fo7-+gCA^bCd zIlFtgTR{J2Y?cFhx+Xz-Z%@7sG*|Lclf+2J1YFa;gvNz1L~kt?r`MX>woG7G$wL{# zjiI@l4D9625TVfrUk2=pi`_$Y>jTcNS3KEsp7fv>4pXzBRlY8>N^Ec4uYVp(EP>Aw zAe?h8AH<-QY*AnLW2~#qp+eD4Ph|T%k7F$7&{-dH>t_&4Ck+?F$~KcD{FDa=hvQbN ztIK!M0iuBGjaejU0NPgOD z+wSlf7p;7S!I45|*yMm{+=SRjquEry{ma4jdhv3ZP(04A{DVQ0kL^YM-8$;cLgBD) zkxYj4co`_PncZP>fdC1XPJsm9QBX2om@;L_z6jD%a>39u$(sMSZVP9WNE`7sbMa5+ zlGO}U=VOE7e9tWY=fqwZ*7EGK%6eZH0Xeo5Lw-qpdC#5U3I(7?J)5p-q^TEP7o1Cc z4WX5{{Je>izIr9Ud3W%Z4eF;g_IksYyeGo9lU|UidA}h^45#qE(V2SS>V!tub&mHx z_$#raF{cC<3^d}M;KW61Mc;o5v_!uDZjM_P`l7TR9ZCXYr_^!vv5 zW7+UnF~evitf3f^*HbgM9G9In{$uRItb8_~?m7=v3`z5Yx@!?aP8ez8*EHukKZ`SqgOwibKl>c+`3sPd5h z+BdfAU)}JamM7SzOY>Ed76l~y+Akj6fYEQx?N^Q$`c9s0u}Jqr%O)DjxV@baBWMU| zxn*GRxnkeO(I27ES#^DvuS!tglWj(P_elg3Uf68a;yLSJ;2xwXs0-i?b5j71qcu-;{+BQ5K^qD<02;{@boC-g~%h#RtyX8X~ zHX1d`uw)BfG`nFpTuTxJFB0>xMBG3rE|KWzmBfH)SAsra;GL+$Sr|o3u+d9Fjb($= za$RP#m5DKsUs2UKuy8JCHG|rfKT1;gT^;F?5^XANeNM+3M;1{8n6sBJalZWK6;QPN ze3Yt{nu45dQWR~)J-|IEmpkr6=h533#q8ex3ax106wL=mGJMFMO;ZbA-UrR_6$*5^ z>R)73tUlHAKXLGPA6<-{ZHQg;3^n-V?KvnVg=}XYCv;~u>hK0(zmO|_Cr1UMFCj|*VEN)zm$yaX-M?rla5Z?j3HLh!r1(?2W zTpfV?VWO{^os&vss3wN_%R9`_{4YVoa7V+j{9OL~phWcK#^P(wv#5gVm<$h6`1^RD z=RvJwQ3UpYxd|&X&x#D9X%6h2F9!U=r@Ziwbzu67cdc(OM`LAyz^)sDd$d6MJ!akAw(A(A5>bz!F^ zup7qgM9<)0%6a*JW zY_dZ}889H8Nz2vV?i(G^!E?h$KS`MW>P*MHrSp&bel95_pp1IwurA-F+C{96L9#K4 z%^m3MT;Z!xBjJG^dfVP%wXJ(m4T-IP0!`&y?lYm2R$z(<F+%I61hzRcx{`b*!gjitvaJy6|vulQ53dy z8#C3B6CCfc>=SN(;8W~k`eRBfn309M6DI;NZF)llgduk#Sj1mMDs=CBe>q@*rhB0b z02iT%X#nc~PDgNJ-bV^hDyoK8AS|BCad~KF*@Ze}TIY?b8P~KFHRuhc=@Jt?g{3Hr z_PLX%3xr*C)RLzC>&UmQi$`MGls1`j^bIHor_4(5gxSVHoJEz4f)WI?$Vm~EY#v@7 z7>@*a!Q~DVUr$M&M!)?9ah+8;IPe90J(dz+T_x2$Y>4HBFo(1O7B<1ii~)lBKCMCt zq=G3#P#x{SW`LqN!n0iq#aa?X}%X>yypIFr3kL@B$NiQ)c&jt#X& zQM;>!65X9D4S(|X)M_;zv2LbN7&#EqfL4UyO*2v?A_&a}%rW@Ii~{u2MC5M@PUsh6 z#Z>x*uhYl0WcIQ+A9OKAVJa=c{futni!TZZ>ebyvhMooyD_ut_A$#Io?iy^^56cn~ zs8<7b&Hj14IH+Oy)GF>ahc&A;76iM3B#-ztI%vA#=hjKjOK3BJH3q-sqgtsb?o9OD5xG%_~ndfaP!2eH-g z`kX#?X%?RL^ziYL8?{9NF6;WL0gCq5a5dbhmyx>3yi0x={Y|Y@rfJJTk?^MnQdP;G zVdKJV>3lR0mRmjG7q(lix=B6)1qsL;#w-MrW#+G^=xCVqUL1&5HSUYxAjHEn!h<3e zJ`$p#sV|J%RPz}LsP(=FVNXl&W0d=T0J`Lk&h{G(Ruv{G=n8G{#e8ZV`KEL zglkQKVYU{r>x8Tpl7t1P29$-N-_s&_>qQ8;+>4F}mJqe&w1y{#@I28(Xpb%jG4Xw~Dj; zDx3BAD^5iAo33t`OlF7X2EWOs>#WzRyrutEhQvtBr)Swyc(<9XLxkl{^Hru)r#X<0iu;q7bL-C3pRkZ-jQ%}eta5N zMirQ!h0rt?Hwh<=0x|>`m@SM+EaNx6x_DIsEN|`w4eoZ=GOmIAjK#`A!@_wMV`Wdm zkN`{0p#b!xHYMfvvU*lf`@E%&dR`DVWk$je9!_m`q8l?cqf%9dL+QmOE)2PhDTht0 zU!Z@91pJK3Em!FdYNU%kI!I)F7iCm57I!*B=B;$!iM?Th(jo$|&gyxby)_%CXS+8t z4h}zz^m=kLnRX>-+gWC}ODCf4Y+Q1|fv>tH74niG@^_HP_^(ab0$%Eb!6}X?+y?%Z zB(bRD(wyYziF82`Ik-xwc+{$?Xp9V9&Y&#w=`x$dU^y{_AcEV|X!PX+IQ}jvHD{`- z$x#ZUlpI;xpA`pdQ@uSt9R_>bhjffxO3Iwt=?NJJbc}Ce_viAae4D~I$q2lnks*Qi z(5hakw*a&+RdX9vI;5BH#)m;ftuz~iRl_oZa`VDSMi1$ikXmZ4uP?Q<@}q_a_J1>9jq1t6zlKi~*+(_?r7dvS zT#8KMB7V_}%{bajm+MHBXt6nuyLg6NU9r%n)#MA~b&9 z&9>mVH~BkJJxF%7?kAbX5ZM0oMSd!VeR<9?Sz23sN%JjNamS2;MYc(V5VTf_;9

z4dXH^l-IV8oS6lAKAr7rZepLrQBzvh9*|r*A(LkwKU>|TwOJf-j|?uv@e~ru*yMT2 z{H`Pr)s0mar@eMLW$y0Cv(9Shc#xnZQtAc-if8{b1p=?2|Ned;!P>4WA6VhikyRCz zKcS|^8s;9fQfW)hPtC6cg4XH4lP;tO%C^7o>WJcnZ)g?gguj%qT5B65=$-15#H=>u zE_XCTxQ*#AD`<_g-wtB=R)?(-j?iOOId`7Ab_N+7E|=<3;`|`6u~nhZ^Ox0h(sfRo};2$a;55 zONMP1tcl`Wbj>Y{^WI-sI)b^K=#uJhDoC2n13*5Pi85D10oLzTGh~oBV(9nr%_YP! zbmFcLV(xT&_OJNmv*Aq2+?f8sB*1a?>e%b!drCL>Zq;FL;SoD${D$ShyrrRJaz8TT9Qc#BU39)I8Hd*_V3$*bZF~M(v@(_x&I3rULt~f+hOM0{}4oR#b z`0_C_^s~bSPTrpqV{Dvm#C1ySwA-fIy`NEFHV0Es5r9_$!L@%}a-LUJ57GM0unVJH z;;}|{t6Ze`L6=K841_Oe@T-O`Mc2e!{Kh?tzkd&>9s9@G`KzH-a(4V{q)V-=3r;iu zdsW|U>ZKXOb>rLvu|;4M5ghO;sii{#C^#m`(Y`A)Pzv= zu9O1BYCVUqxfVv-JnCEdv!Qf+#-3(pi2oJN;Z!f1;M_q)5$-PYFAHM(h0 z*ZhGXA|8o)JuqZ0+5^J|*VX;l%V4oF1`Fsl){yJ!*Z0~XxVS;hr4p2+-3s?7t0+gF=vqU4dhN>i*PABBjGD{lR%wh_f1iTU}`^qj#QWpsI64U5THP00FU7gqdlqkp`Wz`l% z_+5Y;SDk1ndp;v)AXtcq2ER(9E2C|DI%Fvnyczvk}?+T)Ddr&}$lIP^WBgW$ULqYOWvO zM;z*%^)39_OAc+sFQNAjYNm>C!6;w4q`BsvOzo>%FCe)}?-wrPu{1$!Hzu`~NA!(o zDDqK8NwvqL2F)G*XZJ)_fLVK=ZMX|Bst-*GvDKTKC#nn3k m-l}ZrXkMjRmn=t+eaf>&YtCN>uz^c2$~E#hL$W&}%>M#)P^WkR diff --git a/build/openrpc/gateway.json.gz b/build/openrpc/gateway.json.gz index 5a978a54fd3930b5e7428dd8e1437f1d2f5d654a..5cc7832a405fc71fdbec2a9dba97e59ce934efdd 100644 GIT binary patch delta 2142 zcmV-k2%-0%CZ8s-OauaT`IAlrO@Djk6d&uriWDDpSBR8|j~TUBA^)i9R>^-g-6lHn z=S{$RM@JF_TO^!TuT`Ye69@(9dCrY3-PqFf@tK*Oy>g{H02E@j>0U(=%6b+2^}B}l zO#;tX!Y?qqSwVeXMImR_(CFnxFPG}&CB0?PE5BKGY|h>)%q{;L+L+i<9|h>4`AB;poPlZUOly89}+>k`@!d2B=76+=Zz{D z;-N}4S?(Ac=rw75jb3Z?+8Vu=DI0OD?pHKOq zx~yLfrs!>n5mg$;Q?KL)J%0f)-g~u9jI(KV;mxK+B3q8xzJm+P@H**dLY%*az&V}* ztm=-iX}RcL!K)~+!!_|W@Hy8>RHx9V%IRA%YcuAe*Y&52;$HXa)ubC>3Y}lC#&g`8 z{M_qyoi6Eh*+01Bb&xloPwBNiy@qBeK<*&qzCv23LE2`jXT?2v3V$c@Rtb-vWPxj3 zhptWN;zV}&+D)43N@uwrnzrnt(RHF&Pe4)Zy)IW21)FnNkz-8ZW1l$ zTsND&k!jl7H_g`a-ARu90~N_}IA)MW7}`jPNPvpu2^b+U`l(0kX@TuoQN&2Y-+{DA zF0PJNXcD*U;|5FDEq@8-L-?3G{J>Z?k@&3LYPZ^wijCSd7GWbjAD8re-BOXBM~iKU z&KSy{kel(?cOW#SWi=ABk(iCdeB2WApj{#{-va;R=w~G{DY~xTgBlUyu9bTNSiZ0m zsMHmA%jwn49c{LdYPN;M2{eP*=;3;a!$*>4!}~#iAGXZswtqThG6Mpqn#6#>*+!B- zhqFDqD4JE1*#8u?VYgj&lw}aGs@hO=Ez*Xg5cNCZ7kDnnyO6pCqZSu_ ze5g@!F_m%(tStLK1a4OLM-L^9yz~)V_kq)Yw=Bo@5(1|x14MmQa*{?1wtn|If>*kG z%>n6eTd!tXH-ENhOv9R)hJwU$_I9Jk>jhUfN2u!j>MBus1(}a0$hXOL4rQ*9CUL)f zOA&ZTm_Z*sh%X1nC&UgoPnOA(7-ESmDFUk{U8I@U!I~^uQ#RsO+)%~F)TvI@*=g@i zAcmAv@n4-*r}eVke%a}KYQ64vI{jYfWoy6RY9)(TeSfzyHL*CidVq1n4-#n%J1>fp z6$ED~{4;H@Oqqif>r7)Hr0$r(P%9p*dOEoUCk4R{rUem1X-vY2l~HqZeTQ1`2l5B<8s1 z=E-}SYk%)Hdt%KI`bN+&huPi&RvGRv#f}sT2%1DmY7V;iJhJWQW%PxnShNBj5rqWq)*ypL{Td`M`o&b`Hhgf`nl4>NkO{Z|k;|6~-@J84pSz~Q@Sxym zM8w?#h(jBonhcD3ZzlS_et*HieWC#Sz-FPwTq^*hk;}^%q`+2@eybHWLaz~e_gY3E zMSs0{wFI(FlrYL&;)8UIKn?^by7q^jN69r`$cn0}*BV$sQ@w#8;~}xs%?85vU++Td zc%~1<-F*Dz7J99MLoAW({u}yy!qrrp=)8euE68HdH1x$Z?$EqnuCuNw42_O^3_7ma z2X4Hf8fc7m!4W1&7$Q6w+EeHRZq>+83V+IG-Vuix0aR2M($FP(LxNjXZ6w#&_(zTI zxIZx{k#7c%$#*KdsOK0l1l%|vES#Vr1C)t!1O2crfMtHhF0rpp0t&=X;bYBh!Sqr`(CZYO?i(_|;Gu1k07v|$CGAt)Hxu)jR>h(|HE!AYg(OfdIe(vB zT_fNd0e^o2KKo_s{^e^b{kjF0mW2#{0z(8`BL~uB;<|uA3fv#Y;Gk|G;b_@QMv{(wT-@Hzs(&MU+Q-5r1sK1 zmF;Lk9NQ87c?_39Xh9>ToJoY^eSZ!xuXu!_LiQWN_jc%_rmCn{P-Y+$kY|t`+KgzQ z3{G_3%m|P2a6?FIwMjhWR?Zcs7tz?-jjes}XN&ULFZEKXzEE^c$#yOS3oA=)4Vskt zE{A(GH9+O)P5K5GwR^N;6zKI*&Y^y6dSU_VkV08WHc*Lh2P<>sq zEeuNrf1S*;gM#XT6;rv3)3=`+&khIY3fbA~GqP83w34t_bGvV&Do=v17Lmbm;+2X7 zk6XvAVq60^fTkrw>bJY?*S(fy9)(wdLKiH|ey^h&7L@?1@Vh*iVo+%byny*12jlIx z3#v7J0j^uQigKc}Vo>P0@r+4VhL^Es0(=RBD9Z4(STsHVx}A`yUAU*Y9e&$<*=d`% Ux8HC7F8~1l|Aw8PEN$@s0PT4+fB*mh delta 2142 zcmV-k2%-0%CZ8s-Oaub;_>)cqO@H^wDL&SL6)8UIt`I2^A2VvNLjFvs+9 zn*^S(gkNBIvx54(ibBq;q0!5YUM|(kOM1(oSAMfz8w+P4tM{s{(0XDK|9{)>->o?2 z_Ejs^5g}bK{8uefx8YD_5fe#KNyIIpCJ$S8bziCIu1jb`au<{n4-5OMpS7WPrZ^K^nV1zc<=Q(G0vvdg*TfPiEKG$`wlKF!|SA<332`w0_S)N zu&O)4rsbl01+SvO4%fujz~@{iQJq4cDyMJ7tj(B0J(#Z`wD5D25FnAo)!1xDSw>ATO~Yxk_E1D z9lAE5ixb)9Yd2}CE1l(jXxg%mM%RgAJpo0rcTlb<3O45yRfXuSs4S{%l8TmF-6UGh zxo$RlBh$3EZ5J}&9`x~(ETj~3ey zoiUU@Avfc(??7lu%W5QMBQYC^`M4$KL8nAwz6Jir(a%a^QgmIv2Q?zZT`TtluzX=B zP^l~KmeZ@7JKAg^)ocri6KDpr(Zlr;hmR!9hWCR2KWv%NZGUykWCjFIHHiU%vyCKw z4rhCIQ8cS2vHvM(!*09mD9a#VRkfk$TBHp}A?kO+FYsKDcOi8PNcr@wN!rUv)lCP= z_)w$dVk+enSXuUe2;8jfj~+@IdFdm#?gOX)Zds1)B?L}Y28jBq}a zW9ACyZgMBI72mLEsd31hPrXjILvymSIa%49to+j_E6etU(!x)XM=!wq4HWFANz8H2 z&6D>u*MHt^_QaYa^o^iz1pVU`^fk5q_Y2aJFFZorLEvj2URicrW91Lg1Vbl2({4PA zLRn?D`x11CUmk}Ibu4#z%5{tI0rT=_w)TSb0qk@`>h2-jN5BPK%75q@Klxw^^MM7m>>P@}1qs38$q|~I zm+x8>3|?X^$&mFdrowgBGC??rX0>g&$RKJ?)YdujAro)`B9|`}zIp48K6g!p;X%RC zh={uf5QjEEH5nN7-c0m;{r-Z3`$Pfufz3jVxmEy1BbS#kNP(>){Z=b%gkB@`?zN0S zihp|ZY6)bUC}EVl#0TjZfgA`>bnOp4kCJP?kQG%`uQjlOrg{TG#zSJMn+=5Tzutw^ z@k}3zyZQLbE%aIihgc%n{WtXagsZ7G(Rl;SR*=P@Y3Pe-+@X2DTxVTV7#bb-7<62- z58QY|HP9ICf+I|lFhqDVw5QMs+^UhG6n~V>ydw@X0;s4iq@hdnh6J~&+DNXk@sAqa zaerb^BHs)ilkZe^QO_}A2)J=TSU5pL1}GEd2Kr%L0L%Q0U1DFI1Qdv&!pEB1g6Xkz zodJ1TD*j4(&QC7=q1P!m-8W=_!9&|70gm`hOWLQpZzkq5t%^l`YTUB(3rV0_a(_O% zx<`gIE~Eejd^1cnH>Mh>LM#B~9K6u3tuz>fAYkhK8IDkcqp z<3MMCpbdxUmpB(9YJ}uQQTQ-v@M~pe+1yH`Xx>=*qI3;nY8!pYew#ZizSQm9N$sV3 zD%;V7IJP7D^B69J(1J!vIg<#-`+po@UhxP;h3q$k@9oev>DMp z8Jy_6nGqi4;f9dbYLj@#t(+@NFQT!v8(aI{&lcsgU+Se&eWB=@lI>gu7FL$p8Z;^O zT@LqXYJkeooAeDXYWHZxDA4ProJ0NC^vqsC@rh8%zDGX0Kp4_$4$i8(dVeAQuitgU zJF8JjGn_UK@FZ4Kw_`Dl2-nFMS{E?MYoUP8r3P0|>v`;HC;J7(Gz3Qxaus;zC)I>Y z)cJm6$?>Rn8A+B_*4VaKsz>2Bd#p&D6jc130bA{~e^%>bKI9f^AtGV5`QI#jbSBuEtIPpqF zg2%06Rxz%D8$i>NA@$qc_Um5DGLOQmK%om3X1~|b4U0+uRrp;VOfjgm1YW@WkA(5s z1=X6q0N1TtMLE$~F(~xhc*dkF!^>DR0ltJmC}ntBESjEw-A+i=_>~zfA U+wZsk7XSeN|DonQ3vKZL06!8ovH$=8 diff --git a/build/openrpc/miner.json.gz b/build/openrpc/miner.json.gz index fcb97b535d30b09f405debdbf7fe24996443c968..ae3fb031909bf12aa87efb8c473870cede62503d 100644 GIT binary patch delta 13603 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 delta 13642 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 diff --git a/build/openrpc/worker.json.gz b/build/openrpc/worker.json.gz index 2aa22fe66c2c82e6ae0c3121525637384f91619b..406cab94cb501f47e0f5984e0862f6747048467a 100644 GIT binary patch literal 4762 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 delta 4766 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 cbg.MaxLength { return xerrors.Errorf("Value in field \"PreCommit1Out\" was too long") } @@ -659,7 +659,7 @@ func (t *SectorInfo) MarshalCBOR(w io.Writer) error { } } - // t.ReplicaUpdateProof (storage.ReplicaUpdateProof) (slice) + // t.ReplicaUpdateProof (storiface.ReplicaUpdateProof) (slice) if len("ReplicaUpdateProof") > cbg.MaxLength { return xerrors.Errorf("Value in field \"ReplicaUpdateProof\" was too long") } @@ -1038,7 +1038,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) (err error) { t.TicketEpoch = abi.ChainEpoch(extraI) } - // t.PreCommit1Out (storage.PreCommit1Out) (slice) + // t.PreCommit1Out (storiface.PreCommit1Out) (slice) case "PreCommit1Out": maj, extra, err = cr.ReadHeader() @@ -1386,7 +1386,7 @@ func (t *SectorInfo) UnmarshalCBOR(r io.Reader) (err error) { } } - // t.ReplicaUpdateProof (storage.ReplicaUpdateProof) (slice) + // t.ReplicaUpdateProof (storiface.ReplicaUpdateProof) (slice) case "ReplicaUpdateProof": maj, extra, err = cr.ReadHeader() diff --git a/storage/pipeline/fsm_events.go b/storage/pipeline/fsm_events.go index f8b721f1e..eb1087151 100644 --- a/storage/pipeline/fsm_events.go +++ b/storage/pipeline/fsm_events.go @@ -9,9 +9,9 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/builtin/v8/miner" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/chain/types" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) type mutator interface { @@ -135,7 +135,7 @@ type SectorOldTicket struct{} func (evt SectorOldTicket) apply(*SectorInfo) {} type SectorPreCommit1 struct { - PreCommit1Out storage.PreCommit1Out + PreCommit1Out storiface.PreCommit1Out } func (evt SectorPreCommit1) apply(state *SectorInfo) { @@ -316,7 +316,7 @@ func (evt SectorStartCCUpdate) apply(state *SectorInfo) { } type SectorReplicaUpdate struct { - Out storage.ReplicaUpdateOut + Out storiface.ReplicaUpdateOut } func (evt SectorReplicaUpdate) apply(state *SectorInfo) { @@ -325,7 +325,7 @@ func (evt SectorReplicaUpdate) apply(state *SectorInfo) { } type SectorProveReplicaUpdate struct { - Proof storage.ReplicaUpdateProof + Proof storiface.ReplicaUpdateProof } func (evt SectorProveReplicaUpdate) apply(state *SectorInfo) { diff --git a/storage/pipeline/garbage.go b/storage/pipeline/garbage.go index d429b5b43..6c4c20743 100644 --- a/storage/pipeline/garbage.go +++ b/storage/pipeline/garbage.go @@ -5,10 +5,10 @@ import ( "golang.org/x/xerrors" - "github.com/filecoin-project/specs-storage/storage" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) -func (m *Sealing) PledgeSector(ctx context.Context) (storage.SectorRef, error) { +func (m *Sealing) PledgeSector(ctx context.Context) (storiface.SectorRef, error) { m.startupWait.Wait() m.inputLk.Lock() @@ -16,23 +16,23 @@ func (m *Sealing) PledgeSector(ctx context.Context) (storage.SectorRef, error) { cfg, err := m.getConfig() if err != nil { - return storage.SectorRef{}, xerrors.Errorf("getting config: %w", err) + return storiface.SectorRef{}, xerrors.Errorf("getting config: %w", err) } if cfg.MaxSealingSectors > 0 { if m.stats.curSealing() >= cfg.MaxSealingSectors { - return storage.SectorRef{}, xerrors.Errorf("too many sectors sealing (curSealing: %d, max: %d)", m.stats.curSealing(), cfg.MaxSealingSectors) + return storiface.SectorRef{}, xerrors.Errorf("too many sectors sealing (curSealing: %d, max: %d)", m.stats.curSealing(), cfg.MaxSealingSectors) } } spt, err := m.currentSealProof(ctx) if err != nil { - return storage.SectorRef{}, xerrors.Errorf("getting seal proof type: %w", err) + return storiface.SectorRef{}, xerrors.Errorf("getting seal proof type: %w", err) } sid, err := m.createSector(ctx, cfg, spt) if err != nil { - return storage.SectorRef{}, err + return storiface.SectorRef{}, err } log.Infof("Creating CC sector %d", sid) diff --git a/storage/pipeline/input.go b/storage/pipeline/input.go index 87270af39..d59630e84 100644 --- a/storage/pipeline/input.go +++ b/storage/pipeline/input.go @@ -13,7 +13,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-statemachine" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/build" @@ -23,6 +22,7 @@ import ( "github.com/filecoin-project/lotus/storage/pipeline/sealiface" "github.com/filecoin-project/lotus/storage/sealer" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) func (m *Sealing) handleWaitDeals(ctx statemachine.Context, sector SectorInfo) error { @@ -274,7 +274,7 @@ func (m *Sealing) handleAddPieceFailed(ctx statemachine.Context, sector SectorIn return ctx.Send(SectorRetryWaitDeals{}) } -func (m *Sealing) SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, data storage.Data, deal api.PieceDealInfo) (api.SectorOffset, error) { +func (m *Sealing) SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, data storiface.Data, deal api.PieceDealInfo) (api.SectorOffset, error) { log.Infof("Adding piece for deal %d (publish msg: %s)", deal.DealID, deal.PublishCid) if (padreader.PaddedSize(uint64(size))) != size { return api.SectorOffset{}, xerrors.Errorf("cannot allocate unpadded piece") @@ -341,7 +341,7 @@ func (m *Sealing) SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPiec } // called with m.inputLk; transfers the lock to another goroutine! -func (m *Sealing) addPendingPiece(ctx context.Context, size abi.UnpaddedPieceSize, data storage.Data, deal api.PieceDealInfo, sp abi.RegisteredSealProof) *pendingPiece { +func (m *Sealing) addPendingPiece(ctx context.Context, size abi.UnpaddedPieceSize, data storiface.Data, deal api.PieceDealInfo, sp abi.RegisteredSealProof) *pendingPiece { doneCh := make(chan struct{}) pp := &pendingPiece{ doneCh: doneCh, diff --git a/storage/pipeline/sealing.go b/storage/pipeline/sealing.go index 402e46250..ac8316740 100644 --- a/storage/pipeline/sealing.go +++ b/storage/pipeline/sealing.go @@ -19,7 +19,6 @@ import ( "github.com/filecoin-project/go-state-types/dline" "github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-statemachine" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner" @@ -29,6 +28,7 @@ import ( "github.com/filecoin-project/lotus/storage/pipeline/sealiface" "github.com/filecoin-project/lotus/storage/sealer" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) const SectorStorePrefix = "/sectors" @@ -144,7 +144,7 @@ type pendingPiece struct { size abi.UnpaddedPieceSize deal api.PieceDealInfo - data storage.Data + data storiface.Data assigned bool // assigned to a sector? accepted func(abi.SectorNumber, abi.UnpaddedPieceSize, error) @@ -262,8 +262,8 @@ func (m *Sealing) currentSealProof(ctx context.Context) (abi.RegisteredSealProof return lminer.PreferredSealProofTypeFromWindowPoStType(ver, mi.WindowPoStProofType) } -func (m *Sealing) minerSector(spt abi.RegisteredSealProof, num abi.SectorNumber) storage.SectorRef { - return storage.SectorRef{ +func (m *Sealing) minerSector(spt abi.RegisteredSealProof, num abi.SectorNumber) storiface.SectorRef { + return storiface.SectorRef{ ID: m.minerSectorID(num), ProofType: spt, } diff --git a/storage/pipeline/states_sealing.go b/storage/pipeline/states_sealing.go index ae0d31017..cc248a078 100644 --- a/storage/pipeline/states_sealing.go +++ b/storage/pipeline/states_sealing.go @@ -17,7 +17,6 @@ import ( "github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/proof" "github.com/filecoin-project/go-statemachine" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/build" @@ -25,6 +24,7 @@ import ( "github.com/filecoin-project/lotus/chain/actors/policy" "github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/storage/pipeline/lib/nullreader" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) var DealSectorPriority = 1024 @@ -84,7 +84,7 @@ func (m *Sealing) handlePacking(ctx statemachine.Context, sector SectorInfo) err return ctx.Send(SectorPacked{FillerPieces: fillerPieces}) } -func (m *Sealing) padSector(ctx context.Context, sectorID storage.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, sizes ...abi.UnpaddedPieceSize) ([]abi.PieceInfo, error) { +func (m *Sealing) padSector(ctx context.Context, sectorID storiface.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, sizes ...abi.UnpaddedPieceSize) ([]abi.PieceInfo, error) { if len(sizes) == 0 { return nil, nil } @@ -562,7 +562,7 @@ func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) return ctx.Send(SectorCommitFailed{xerrors.Errorf("sector had nil commR or commD")}) } - cids := storage.SectorCids{ + cids := storiface.SectorCids{ Unsealed: *sector.CommD, Sealed: *sector.CommR, } diff --git a/storage/pipeline/types.go b/storage/pipeline/types.go index aa0ee8c3c..105a1a64a 100644 --- a/storage/pipeline/types.go +++ b/storage/pipeline/types.go @@ -8,12 +8,12 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/builtin/v8/miner" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/storage/pipeline/sealiface" "github.com/filecoin-project/lotus/storage/sealer" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) //go:generate go run github.com/golang/mock/mockgen -destination=mocks/statemachine.go -package=mocks . Context @@ -68,7 +68,7 @@ type SectorInfo struct { // PreCommit1 TicketValue abi.SealRandomness TicketEpoch abi.ChainEpoch - PreCommit1Out storage.PreCommit1Out + PreCommit1Out storiface.PreCommit1Out // PreCommit2 CommD *cid.Cid @@ -95,7 +95,7 @@ type SectorInfo struct { CCPieces []Piece UpdateSealed *cid.Cid UpdateUnsealed *cid.Cid - ReplicaUpdateProof storage.ReplicaUpdateProof + ReplicaUpdateProof storiface.ReplicaUpdateProof ReplicaUpdateMessage *cid.Cid // Faults @@ -164,8 +164,8 @@ func (t *SectorInfo) sealingCtx(ctx context.Context) context.Context { // Returns list of offset/length tuples of sector data ranges which clients // requested to keep unsealed -func (t *SectorInfo) keepUnsealedRanges(pieces []Piece, invert, alwaysKeep bool) []storage.Range { - var out []storage.Range +func (t *SectorInfo) keepUnsealedRanges(pieces []Piece, invert, alwaysKeep bool) []storiface.Range { + var out []storiface.Range var at abi.UnpaddedPieceSize for _, piece := range pieces { @@ -182,7 +182,7 @@ func (t *SectorInfo) keepUnsealedRanges(pieces []Piece, invert, alwaysKeep bool) continue } - out = append(out, storage.Range{ + out = append(out, storiface.Range{ Offset: at - psize, Size: psize, }) diff --git a/storage/sealer/faults.go b/storage/sealer/faults.go index 6100dbb87..e05bbb7b8 100644 --- a/storage/sealer/faults.go +++ b/storage/sealer/faults.go @@ -11,7 +11,6 @@ import ( ffi "github.com/filecoin-project/filecoin-ffi" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/storiface" ) @@ -20,11 +19,11 @@ var PostCheckTimeout = 160 * time.Second // FaultTracker TODO: Track things more actively type FaultTracker interface { - CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) + CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) } // CheckProvable returns unprovable sectors -func (m *Manager) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { +func (m *Manager) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -61,7 +60,7 @@ func (m *Manager) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, return nil, ctx.Err() } - go func(sector storage.SectorRef) { + go func(sector storiface.SectorRef) { defer wg.Done() defer func() { <-throttle diff --git a/storage/sealer/ffiwrapper/basicfs/fs.go b/storage/sealer/ffiwrapper/basicfs/fs.go index 5cd48bb82..7a9f70d59 100644 --- a/storage/sealer/ffiwrapper/basicfs/fs.go +++ b/storage/sealer/ffiwrapper/basicfs/fs.go @@ -7,7 +7,6 @@ import ( "sync" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/storiface" ) @@ -24,7 +23,7 @@ type Provider struct { waitSector map[sectorFile]chan struct{} } -func (b *Provider) AcquireSector(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) { +func (b *Provider) AcquireSector(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) { if err := os.Mkdir(filepath.Join(b.Root, storiface.FTUnsealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint return storiface.SectorPaths{}, nil, err } diff --git a/storage/sealer/ffiwrapper/sealer_cgo.go b/storage/sealer/ffiwrapper/sealer_cgo.go index e2c2d03af..0f89a6e8c 100644 --- a/storage/sealer/ffiwrapper/sealer_cgo.go +++ b/storage/sealer/ffiwrapper/sealer_cgo.go @@ -26,7 +26,6 @@ import ( commcid "github.com/filecoin-project/go-fil-commcid" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/lib/nullreader" nr "github.com/filecoin-project/lotus/storage/pipeline/lib/nullreader" @@ -47,13 +46,13 @@ func New(sectors SectorProvider) (*Sealer, error) { return sb, nil } -func (sb *Sealer) NewSector(ctx context.Context, sector storage.SectorRef) error { +func (sb *Sealer) NewSector(ctx context.Context, sector storiface.SectorRef) error { // TODO: Allocate the sector here instead of in addpiece return nil } -func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) { +func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) { pieceData = io.LimitReader(io.MultiReader( pieceData, nullreader.Reader{}, @@ -173,7 +172,7 @@ func (sb *Sealer) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, }, nil } -func (sb *Sealer) AddPiece(ctx context.Context, sector storage.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storage.Data) (abi.PieceInfo, error) { +func (sb *Sealer) AddPiece(ctx context.Context, sector storiface.SectorRef, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storiface.Data) (abi.PieceInfo, error) { // TODO: allow tuning those: chunk := abi.PaddedPieceSize(4 << 20) parallel := runtime.NumCPU() @@ -377,7 +376,7 @@ func (sb *Sealer) pieceCid(spt abi.RegisteredSealProof, in []byte) (cid.Cid, err return pieceCID, werr() } -func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.SectorRef, commD cid.Cid, unsealedPath string, randomness abi.SealRandomness) (bool, error) { +func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storiface.SectorRef, commD cid.Cid, unsealedPath string, randomness abi.SealRandomness) (bool, error) { replicaPath, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUpdate|storiface.FTUpdateCache, storiface.FTNone, storiface.PathStorage) if xerrors.Is(err, storiface.ErrSectorNotFound) { return false, nil @@ -400,7 +399,7 @@ func (sb *Sealer) tryDecodeUpdatedReplica(ctx context.Context, sector storage.Se return true, ffi.SectorUpdate.DecodeFrom(updateProof, unsealedPath, replicaPath.Update, sealedPaths.Sealed, sealedPaths.Cache, commD) } -func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector storage.SectorRef, randomness abi.SealRandomness) (storiface.SectorPaths, func(), error) { +func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector storiface.SectorRef, randomness abi.SealRandomness) (storiface.SectorPaths, func(), error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) if err == nil { return paths, done, err @@ -429,7 +428,7 @@ func (sb *Sealer) AcquireSectorKeyOrRegenerate(ctx context.Context, sector stora return sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, storiface.FTNone, storiface.PathStorage) } -func (sb *Sealer) UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error { +func (sb *Sealer) UnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error { ssize, err := sector.ProofType.SectorSize() if err != nil { return err @@ -605,7 +604,7 @@ func (sb *Sealer) UnsealPiece(ctx context.Context, sector storage.SectorRef, off return nil } -func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { +func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { path, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed, storiface.FTNone, storiface.PathStorage) if err != nil { return false, xerrors.Errorf("acquire unsealed sector path: %w", err) @@ -661,7 +660,7 @@ func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector storag return true, nil } -func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) error { +func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) error { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed|storiface.FTCache, storiface.FTSealed, storiface.PathSealing) if err != nil { return xerrors.Errorf("acquiring sector paths: %w", err) @@ -706,7 +705,7 @@ func (sb *Sealer) RegenerateSectorKey(ctx context.Context, sector storage.Sector return nil } -func (sb *Sealer) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) { +func (sb *Sealer) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storiface.PreCommit1Out, err error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed, storiface.FTSealed|storiface.FTCache, storiface.PathSealing) if err != nil { return nil, xerrors.Errorf("acquiring sector paths: %w", err) @@ -777,26 +776,26 @@ func (sb *Sealer) SealPreCommit1(ctx context.Context, sector storage.SectorRef, var PC2CheckRounds = 3 -func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.PreCommit1Out) (storage.SectorCids, error) { +func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.PreCommit1Out) (storiface.SectorCids, error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, 0, storiface.PathSealing) if err != nil { - return storage.SectorCids{}, xerrors.Errorf("acquiring sector paths: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("acquiring sector paths: %w", err) } defer done() sealedCID, unsealedCID, err := ffi.SealPreCommitPhase2(phase1Out, paths.Cache, paths.Sealed) if err != nil { - return storage.SectorCids{}, xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err) + return storiface.SectorCids{}, xerrors.Errorf("presealing sector %d (%s): %w", sector.ID.Number, paths.Unsealed, err) } ssize, err := sector.ProofType.SectorSize() if err != nil { - return storage.SectorCids{}, xerrors.Errorf("get ssize: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("get ssize: %w", err) } p1odec := map[string]interface{}{} if err := json.Unmarshal(phase1Out, &p1odec); err != nil { - return storage.SectorCids{}, xerrors.Errorf("unmarshaling pc1 output: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("unmarshaling pc1 output: %w", err) } var ticket abi.SealRandomness @@ -805,7 +804,7 @@ func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storage.SectorRef, if found { ticket, err = base64.StdEncoding.DecodeString(ti.(string)) if err != nil { - return storage.SectorCids{}, xerrors.Errorf("decoding ticket: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("decoding ticket: %w", err) } for i := 0; i < PC2CheckRounds; i++ { @@ -828,18 +827,18 @@ func (sb *Sealer) SealPreCommit2(ctx context.Context, sector storage.SectorRef, log.Warn("checking PreCommit failed: ", err) log.Warnf("num:%d tkt:%v seed:%v sealedCID:%v, unsealedCID:%v", sector.ID.Number, ticket, sd[:], sealedCID, unsealedCID) - return storage.SectorCids{}, xerrors.Errorf("checking PreCommit failed: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("checking PreCommit failed: %w", err) } } } - return storage.SectorCids{ + return storiface.SectorCids{ Unsealed: unsealedCID, Sealed: sealedCID, }, nil } -func (sb *Sealer) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) { +func (sb *Sealer) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.Commit1Out, error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache, 0, storiface.PathSealing) if err != nil { return nil, xerrors.Errorf("acquire sector paths: %w", err) @@ -866,12 +865,12 @@ func (sb *Sealer) SealCommit1(ctx context.Context, sector storage.SectorRef, tic return output, nil } -func (sb *Sealer) SealCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.Commit1Out) (storage.Proof, error) { +func (sb *Sealer) SealCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.Commit1Out) (storiface.Proof, error) { return ffi.SealCommitPhase2(phase1Out, sector.ID.Number, sector.ID.Miner) } -func (sb *Sealer) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storage.ReplicaUpdateOut, error) { - empty := storage.ReplicaUpdateOut{} +func (sb *Sealer) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.ReplicaUpdateOut, error) { + empty := storiface.ReplicaUpdateOut{} paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed|storiface.FTSealed|storiface.FTCache, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing) if err != nil { return empty, xerrors.Errorf("failed to acquire sector paths: %w", err) @@ -917,10 +916,10 @@ func (sb *Sealer) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, p if err != nil { return empty, xerrors.Errorf("failed to update replica %d with new deal data: %w", sector.ID.Number, err) } - return storage.ReplicaUpdateOut{NewSealed: sealed, NewUnsealed: unsealed}, nil + return storiface.ReplicaUpdateOut{NewSealed: sealed, NewUnsealed: unsealed}, nil } -func (sb *Sealer) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storage.ReplicaVanillaProofs, error) { +func (sb *Sealer) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.ReplicaVanillaProofs, error) { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTSealed|storiface.FTCache|storiface.FTUpdate|storiface.FTUpdateCache, storiface.FTNone, storiface.PathSealing) if err != nil { return nil, xerrors.Errorf("failed to acquire sector paths: %w", err) @@ -936,12 +935,12 @@ func (sb *Sealer) ProveReplicaUpdate1(ctx context.Context, sector storage.Sector return vanillaProofs, nil } -func (sb *Sealer) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storage.ReplicaUpdateProof, error) { +func (sb *Sealer) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.ReplicaUpdateProof, error) { updateProofType := abi.SealProofInfos[sector.ProofType].UpdateProof return ffi.SectorUpdate.GenerateUpdateProofWithVanilla(updateProofType, sectorKey, newSealed, newUnsealed, vanillaProofs) } -func (sb *Sealer) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) error { +func (sb *Sealer) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) error { paths, done, err := sb.sectors.AcquireSector(ctx, sector, storiface.FTUnsealed|storiface.FTCache|storiface.FTUpdate|storiface.FTUpdateCache, storiface.FTSealed, storiface.PathSealing) defer done() if err != nil { @@ -968,11 +967,11 @@ func (sb *Sealer) GenerateSectorKeyFromData(ctx context.Context, sector storage. return ffi.SectorUpdate.RemoveData(updateProofType, paths.Sealed, paths.Cache, paths.Update, paths.UpdateCache, paths.Unsealed, commD) } -func (sb *Sealer) ReleaseSealed(ctx context.Context, sector storage.SectorRef) error { +func (sb *Sealer) ReleaseSealed(ctx context.Context, sector storiface.SectorRef) error { return xerrors.Errorf("not supported at this layer") } -func (sb *Sealer) freeUnsealed(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (sb *Sealer) freeUnsealed(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { ssize, err := sector.ProofType.SectorSize() if err != nil { return err @@ -1040,7 +1039,7 @@ func (sb *Sealer) freeUnsealed(ctx context.Context, sector storage.SectorRef, ke return nil } -func (sb *Sealer) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (sb *Sealer) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { ssize, err := sector.ProofType.SectorSize() if err != nil { return err @@ -1059,7 +1058,7 @@ func (sb *Sealer) FinalizeSector(ctx context.Context, sector storage.SectorRef, return ffi.ClearCache(uint64(ssize), paths.Cache) } -func (sb *Sealer) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (sb *Sealer) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { ssize, err := sector.ProofType.SectorSize() if err != nil { return err @@ -1096,7 +1095,7 @@ func (sb *Sealer) FinalizeReplicaUpdate(ctx context.Context, sector storage.Sect return nil } -func (sb *Sealer) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) error { +func (sb *Sealer) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) error { // This call is meant to mark storage as 'freeable'. Given that unsealing is // very expensive, we don't remove data as soon as we can - instead we only // do that when we don't have free space for data that really needs it @@ -1106,15 +1105,15 @@ func (sb *Sealer) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, return xerrors.Errorf("not supported at this layer") } -func (sb *Sealer) ReleaseReplicaUpgrade(ctx context.Context, sector storage.SectorRef) error { +func (sb *Sealer) ReleaseReplicaUpgrade(ctx context.Context, sector storiface.SectorRef) error { return xerrors.Errorf("not supported at this layer") } -func (sb *Sealer) ReleaseSectorKey(ctx context.Context, sector storage.SectorRef) error { +func (sb *Sealer) ReleaseSectorKey(ctx context.Context, sector storiface.SectorRef) error { return xerrors.Errorf("not supported at this layer") } -func (sb *Sealer) Remove(ctx context.Context, sector storage.SectorRef) error { +func (sb *Sealer) Remove(ctx context.Context, sector storiface.SectorRef) error { return xerrors.Errorf("not supported at this layer") // happens in localworker } diff --git a/storage/sealer/ffiwrapper/sealer_test.go b/storage/sealer/ffiwrapper/sealer_test.go index f539209f9..829190015 100644 --- a/storage/sealer/ffiwrapper/sealer_test.go +++ b/storage/sealer/ffiwrapper/sealer_test.go @@ -26,7 +26,6 @@ import ( "github.com/filecoin-project/go-paramfetch" "github.com/filecoin-project/go-state-types/abi" prooftypes "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/chain/actors/policy" "github.com/filecoin-project/lotus/storage/pipeline/lib/nullreader" @@ -44,8 +43,8 @@ var sectorSize, _ = sealProofType.SectorSize() var sealRand = abi.SealRandomness{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2} type seal struct { - ref storage.SectorRef - cids storage.SectorCids + ref storiface.SectorRef + cids storiface.SectorCids pi abi.PieceInfo ticket abi.SealRandomness } @@ -57,7 +56,7 @@ func data(sn abi.SectorNumber, dlen abi.UnpaddedPieceSize) io.Reader { ) } -func (s *seal) precommit(t *testing.T, sb *Sealer, id storage.SectorRef, done func()) { +func (s *seal) precommit(t *testing.T, sb *Sealer, id storiface.SectorRef, done func()) { defer done() dlen := abi.PaddedPieceSize(sectorSize).Unpadded() @@ -86,7 +85,7 @@ func (s *seal) precommit(t *testing.T, sb *Sealer, id storage.SectorRef, done fu var seed = abi.InteractiveSealRandomness{0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 45, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9} -func (s *seal) commit(t *testing.T, sb *Sealer, done func()) storage.Proof { +func (s *seal) commit(t *testing.T, sb *Sealer, done func()) storiface.Proof { defer done() pc1, err := sb.SealCommit1(context.TODO(), s.ref, s.ticket, seed, []abi.PieceInfo{s.pi}, s.cids) @@ -122,7 +121,7 @@ func (s *seal) commit(t *testing.T, sb *Sealer, done func()) storage.Proof { return proof } -func (s *seal) unseal(t *testing.T, sb *Sealer, sp *basicfs.Provider, si storage.SectorRef, done func()) { +func (s *seal) unseal(t *testing.T, sb *Sealer, sp *basicfs.Provider, si storiface.SectorRef, done func()) { defer done() var b bytes.Buffer @@ -225,7 +224,7 @@ func post(t *testing.T, sealer *Sealer, skipped []abi.SectorID, seals ...seal) { } } -func corrupt(t *testing.T, sealer *Sealer, id storage.SectorRef) { +func corrupt(t *testing.T, sealer *Sealer, id storiface.SectorRef) { paths, done, err := sealer.sectors.AcquireSector(context.Background(), id, storiface.FTSealed, 0, storiface.PathStorage) require.NoError(t, err) defer done() @@ -306,7 +305,7 @@ func TestSealAndVerify(t *testing.T) { } }) - si := storage.SectorRef{ + si := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 1}, ProofType: sealProofType, } @@ -379,7 +378,7 @@ func TestSealPoStNoCommit(t *testing.T) { } }) - si := storage.SectorRef{ + si := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 1}, ProofType: sealProofType, } @@ -441,15 +440,15 @@ func TestSealAndVerify3(t *testing.T) { var wg sync.WaitGroup - si1 := storage.SectorRef{ + si1 := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 1}, ProofType: sealProofType, } - si2 := storage.SectorRef{ + si2 := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 2}, ProofType: sealProofType, } - si3 := storage.SectorRef{ + si3 := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 3}, ProofType: sealProofType, } @@ -529,7 +528,7 @@ func TestSealAndVerifyAggregate(t *testing.T) { toAggregate := make([][]byte, numAgg) for i := 0; i < numAgg; i++ { - si := storage.SectorRef{ + si := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: abi.SectorNumber(i + 1)}, ProofType: sealProofType, } @@ -763,7 +762,7 @@ func TestAddPiece512M(t *testing.T) { r := rand.New(rand.NewSource(0x7e5)) - c, err := sb.AddPiece(context.TODO(), storage.SectorRef{ + c, err := sb.AddPiece(context.TODO(), storiface.SectorRef{ ID: abi.SectorID{ Miner: miner, Number: 0, @@ -806,7 +805,7 @@ func BenchmarkAddPiece512M(b *testing.B) { b.Cleanup(cleanup) for i := 0; i < b.N; i++ { - c, err := sb.AddPiece(context.TODO(), storage.SectorRef{ + c, err := sb.AddPiece(context.TODO(), storiface.SectorRef{ ID: abi.SectorID{ Miner: miner, Number: abi.SectorNumber(i), @@ -849,7 +848,7 @@ func TestAddPiece512MPadded(t *testing.T) { r := rand.New(rand.NewSource(0x7e5)) - c, err := sb.AddPiece(context.TODO(), storage.SectorRef{ + c, err := sb.AddPiece(context.TODO(), storiface.SectorRef{ ID: abi.SectorID{ Miner: miner, Number: 0, @@ -917,7 +916,7 @@ func TestMulticoreSDR(t *testing.T) { } }) - si := storage.SectorRef{ + si := storiface.SectorRef{ ID: abi.SectorID{Miner: miner, Number: 1}, ProofType: sealProofType, } diff --git a/storage/sealer/ffiwrapper/types.go b/storage/sealer/ffiwrapper/types.go index fcf71ab82..b32a3cc82 100644 --- a/storage/sealer/ffiwrapper/types.go +++ b/storage/sealer/ffiwrapper/types.go @@ -8,7 +8,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper/basicfs" "github.com/filecoin-project/lotus/storage/sealer/storiface" @@ -20,16 +19,16 @@ type Validator interface { } type StorageSealer interface { - storage.Sealer - storage.Storage + storiface.Sealer + storiface.Storage } type Storage interface { - storage.Prover + storiface.Prover StorageSealer - UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error - ReadPiece(ctx context.Context, writer io.Writer, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) + UnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error + ReadPiece(ctx context.Context, writer io.Writer, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) } type Verifier interface { @@ -52,7 +51,7 @@ type Prover interface { type SectorProvider interface { // * returns storiface.ErrSectorNotFound if a requested existing sector doesn't exist // * returns an error when allocate is set, and existing isn't, and the sector exists - AcquireSector(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) + AcquireSector(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, ptype storiface.PathType) (storiface.SectorPaths, func(), error) } var _ SectorProvider = &basicfs.Provider{} diff --git a/storage/sealer/ffiwrapper/verifier_cgo.go b/storage/sealer/ffiwrapper/verifier_cgo.go index 2c21ebce6..2ff5bc91a 100644 --- a/storage/sealer/ffiwrapper/verifier_cgo.go +++ b/storage/sealer/ffiwrapper/verifier_cgo.go @@ -12,7 +12,6 @@ import ( ffi "github.com/filecoin-project/filecoin-ffi" "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/storiface" ) @@ -76,7 +75,7 @@ func (sb *Sealer) pubExtendedSectorToPriv(ctx context.Context, mid abi.ActorID, continue } - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: mid, Number: s.SectorNumber}, ProofType: s.SealProof, } diff --git a/storage/sealer/manager.go b/storage/sealer/manager.go index cbfcfec79..d1908d9f7 100644 --- a/storage/sealer/manager.go +++ b/storage/sealer/manager.go @@ -17,7 +17,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-statestore" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" @@ -47,7 +46,7 @@ type Worker interface { type SectorManager interface { ffiwrapper.StorageSealer - storage.Prover + storiface.Prover storiface.WorkerReturn FaultTracker } @@ -65,7 +64,7 @@ type Manager struct { windowPoStSched *poStScheduler winningPoStSched *poStScheduler - localProver storage.Prover + localProver storiface.Prover workLk sync.Mutex work *statestore.StateStore @@ -81,7 +80,7 @@ type Manager struct { waitRes map[WorkID]chan struct{} } -var _ storage.Prover = &Manager{} +var _ storiface.Prover = &Manager{} type result struct { r interface{} @@ -267,7 +266,7 @@ func schedNop(context.Context, Worker) error { return nil } -func (m *Manager) schedFetch(sector storage.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) func(context.Context, Worker) error { +func (m *Manager) schedFetch(sector storiface.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) func(context.Context, Worker) error { return func(ctx context.Context, worker Worker) error { _, err := m.waitSimpleCall(ctx)(worker.Fetch(ctx, sector, ft, ptype, am)) return err @@ -278,7 +277,7 @@ func (m *Manager) schedFetch(sector storage.SectorRef, ft storiface.SectorFileTy // It will schedule the Unsealing task on a worker that either already has the sealed sector files or has space in // one of it's sealing scratch spaces to store them after fetching them from another worker. // If the chosen worker already has the Unsealed sector file, we will NOT Unseal the sealed sector file again. -func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed *cid.Cid) error { +func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed *cid.Cid) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -335,19 +334,19 @@ func (m *Manager) SectorsUnsealPiece(ctx context.Context, sector storage.SectorR return nil } -func (m *Manager) NewSector(ctx context.Context, sector storage.SectorRef) error { +func (m *Manager) NewSector(ctx context.Context, sector storiface.SectorRef) error { log.Warnf("stub NewSector") return nil } -func (m *Manager) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) { +func (m *Manager) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() selector := newTaskSelector() var out abi.PieceInfo - err := m.sched.Schedule(ctx, storage.NoSectorRef, sealtasks.TTDataCid, selector, schedNop, func(ctx context.Context, w Worker) error { + err := m.sched.Schedule(ctx, storiface.NoSectorRef, sealtasks.TTDataCid, selector, schedNop, func(ctx context.Context, w Worker) error { p, err := m.waitSimpleCall(ctx)(w.DataCid(ctx, pieceSize, pieceData)) if err != nil { return err @@ -361,7 +360,7 @@ func (m *Manager) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, return out, err } -func (m *Manager) AddPiece(ctx context.Context, sector storage.SectorRef, existingPieces []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) { +func (m *Manager) AddPiece(ctx context.Context, sector storiface.SectorRef, existingPieces []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -392,7 +391,7 @@ func (m *Manager) AddPiece(ctx context.Context, sector storage.SectorRef, existi return out, err } -func (m *Manager) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) { +func (m *Manager) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storiface.PreCommit1Out, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -410,7 +409,7 @@ func (m *Manager) SealPreCommit1(ctx context.Context, sector storage.SectorRef, return } if p != nil { - out = p.(storage.PreCommit1Out) + out = p.(storiface.PreCommit1Out) } } @@ -443,13 +442,13 @@ func (m *Manager) SealPreCommit1(ctx context.Context, sector storage.SectorRef, return out, waitErr } -func (m *Manager) SealPreCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.PreCommit1Out) (out storage.SectorCids, err error) { +func (m *Manager) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.PreCommit1Out) (out storiface.SectorCids, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() wk, wait, cancel, err := m.getWork(ctx, sealtasks.TTPreCommit2, sector, phase1Out) if err != nil { - return storage.SectorCids{}, xerrors.Errorf("getWork: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("getWork: %w", err) } defer cancel() @@ -461,7 +460,7 @@ func (m *Manager) SealPreCommit2(ctx context.Context, sector storage.SectorRef, return } if p != nil { - out = p.(storage.SectorCids) + out = p.(storiface.SectorCids) } } @@ -471,7 +470,7 @@ func (m *Manager) SealPreCommit2(ctx context.Context, sector storage.SectorRef, } if err := m.index.StorageLock(ctx, sector.ID, storiface.FTSealed, storiface.FTCache); err != nil { - return storage.SectorCids{}, xerrors.Errorf("acquiring sector lock: %w", err) + return storiface.SectorCids{}, xerrors.Errorf("acquiring sector lock: %w", err) } selector := newExistingSelector(m.index, sector.ID, storiface.FTCache|storiface.FTSealed, true) @@ -486,19 +485,19 @@ func (m *Manager) SealPreCommit2(ctx context.Context, sector storage.SectorRef, return nil }) if err != nil { - return storage.SectorCids{}, err + return storiface.SectorCids{}, err } return out, waitErr } -func (m *Manager) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (out storage.Commit1Out, err error) { +func (m *Manager) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (out storiface.Commit1Out, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() wk, wait, cancel, err := m.getWork(ctx, sealtasks.TTCommit1, sector, ticket, seed, pieces, cids) if err != nil { - return storage.Commit1Out{}, xerrors.Errorf("getWork: %w", err) + return storiface.Commit1Out{}, xerrors.Errorf("getWork: %w", err) } defer cancel() @@ -510,7 +509,7 @@ func (m *Manager) SealCommit1(ctx context.Context, sector storage.SectorRef, tic return } if p != nil { - out = p.(storage.Commit1Out) + out = p.(storiface.Commit1Out) } } @@ -520,7 +519,7 @@ func (m *Manager) SealCommit1(ctx context.Context, sector storage.SectorRef, tic } if err := m.index.StorageLock(ctx, sector.ID, storiface.FTSealed, storiface.FTCache); err != nil { - return storage.Commit1Out{}, xerrors.Errorf("acquiring sector lock: %w", err) + return storiface.Commit1Out{}, xerrors.Errorf("acquiring sector lock: %w", err) } // NOTE: We set allowFetch to false in so that we always execute on a worker @@ -544,10 +543,10 @@ func (m *Manager) SealCommit1(ctx context.Context, sector storage.SectorRef, tic return out, waitErr } -func (m *Manager) SealCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.Commit1Out) (out storage.Proof, err error) { +func (m *Manager) SealCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.Commit1Out) (out storiface.Proof, err error) { wk, wait, cancel, err := m.getWork(ctx, sealtasks.TTCommit2, sector, phase1Out) if err != nil { - return storage.Proof{}, xerrors.Errorf("getWork: %w", err) + return storiface.Proof{}, xerrors.Errorf("getWork: %w", err) } defer cancel() @@ -559,7 +558,7 @@ func (m *Manager) SealCommit2(ctx context.Context, sector storage.SectorRef, pha return } if p != nil { - out = p.(storage.Proof) + out = p.(storiface.Proof) } } @@ -587,7 +586,7 @@ func (m *Manager) SealCommit2(ctx context.Context, sector storage.SectorRef, pha return out, waitErr } -func (m *Manager) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (m *Manager) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -664,7 +663,7 @@ func (m *Manager) FinalizeSector(ctx context.Context, sector storage.SectorRef, return nil } -func (m *Manager) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (m *Manager) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -750,7 +749,7 @@ func (m *Manager) FinalizeReplicaUpdate(ctx context.Context, sector storage.Sect return nil } -func (m *Manager) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) error { +func (m *Manager) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) error { ssize, err := sector.ProofType.SectorSize() if err != nil { return err @@ -770,7 +769,7 @@ func (m *Manager) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, return m.storage.Remove(ctx, sector.ID, storiface.FTUnsealed, true, nil) } -func (m *Manager) ReleaseSectorKey(ctx context.Context, sector storage.SectorRef) error { +func (m *Manager) ReleaseSectorKey(ctx context.Context, sector storiface.SectorRef) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -781,7 +780,7 @@ func (m *Manager) ReleaseSectorKey(ctx context.Context, sector storage.SectorRef return m.storage.Remove(ctx, sector.ID, storiface.FTSealed, true, nil) } -func (m *Manager) ReleaseReplicaUpgrade(ctx context.Context, sector storage.SectorRef) error { +func (m *Manager) ReleaseReplicaUpgrade(ctx context.Context, sector storiface.SectorRef) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -798,7 +797,7 @@ func (m *Manager) ReleaseReplicaUpgrade(ctx context.Context, sector storage.Sect return nil } -func (m *Manager) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) error { +func (m *Manager) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -848,7 +847,7 @@ func (m *Manager) GenerateSectorKeyFromData(ctx context.Context, sector storage. return waitErr } -func (m *Manager) Remove(ctx context.Context, sector storage.SectorRef) error { +func (m *Manager) Remove(ctx context.Context, sector storiface.SectorRef) error { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -877,13 +876,13 @@ func (m *Manager) Remove(ctx context.Context, sector storage.SectorRef) error { return err } -func (m *Manager) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (out storage.ReplicaUpdateOut, err error) { +func (m *Manager) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (out storiface.ReplicaUpdateOut, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() log.Debugf("manager is doing replica update") wk, wait, cancel, err := m.getWork(ctx, sealtasks.TTReplicaUpdate, sector, pieces) if err != nil { - return storage.ReplicaUpdateOut{}, xerrors.Errorf("getWork: %w", err) + return storiface.ReplicaUpdateOut{}, xerrors.Errorf("getWork: %w", err) } defer cancel() @@ -895,7 +894,7 @@ func (m *Manager) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, p return } if p != nil { - out = p.(storage.ReplicaUpdateOut) + out = p.(storiface.ReplicaUpdateOut) } } @@ -905,7 +904,7 @@ func (m *Manager) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, p } if err := m.index.StorageLock(ctx, sector.ID, storiface.FTUnsealed|storiface.FTSealed|storiface.FTCache, storiface.FTUpdate|storiface.FTUpdateCache); err != nil { - return storage.ReplicaUpdateOut{}, xerrors.Errorf("acquiring sector lock: %w", err) + return storiface.ReplicaUpdateOut{}, xerrors.Errorf("acquiring sector lock: %w", err) } selector := newAllocSelector(m.index, storiface.FTUpdate|storiface.FTUpdateCache, storiface.PathSealing) @@ -920,12 +919,12 @@ func (m *Manager) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, p return nil }) if err != nil { - return storage.ReplicaUpdateOut{}, xerrors.Errorf("Schedule: %w", err) + return storiface.ReplicaUpdateOut{}, xerrors.Errorf("Schedule: %w", err) } return out, waitErr } -func (m *Manager) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (out storage.ReplicaVanillaProofs, err error) { +func (m *Manager) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (out storiface.ReplicaVanillaProofs, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -943,7 +942,7 @@ func (m *Manager) ProveReplicaUpdate1(ctx context.Context, sector storage.Sector return } if p != nil { - out = p.(storage.ReplicaVanillaProofs) + out = p.(storiface.ReplicaVanillaProofs) } } @@ -978,7 +977,7 @@ func (m *Manager) ProveReplicaUpdate1(ctx context.Context, sector storage.Sector return out, waitErr } -func (m *Manager) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (out storage.ReplicaUpdateProof, err error) { +func (m *Manager) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (out storiface.ReplicaUpdateProof, err error) { ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -996,7 +995,7 @@ func (m *Manager) ProveReplicaUpdate2(ctx context.Context, sector storage.Sector return } if p != nil { - out = p.(storage.ReplicaUpdateProof) + out = p.(storiface.ReplicaUpdateProof) } } @@ -1032,19 +1031,19 @@ func (m *Manager) ReturnAddPiece(ctx context.Context, callID storiface.CallID, p return m.returnResult(ctx, callID, pi, err) } -func (m *Manager) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error { +func (m *Manager) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storiface.PreCommit1Out, err *storiface.CallError) error { return m.returnResult(ctx, callID, p1o, err) } -func (m *Manager) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error { +func (m *Manager) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storiface.SectorCids, err *storiface.CallError) error { return m.returnResult(ctx, callID, sealed, err) } -func (m *Manager) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error { +func (m *Manager) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storiface.Commit1Out, err *storiface.CallError) error { return m.returnResult(ctx, callID, out, err) } -func (m *Manager) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error { +func (m *Manager) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storiface.Proof, err *storiface.CallError) error { return m.returnResult(ctx, callID, proof, err) } @@ -1056,15 +1055,15 @@ func (m *Manager) ReturnReleaseUnsealed(ctx context.Context, callID storiface.Ca return m.returnResult(ctx, callID, nil, err) } -func (m *Manager) ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storage.ReplicaUpdateOut, err *storiface.CallError) error { +func (m *Manager) ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storiface.ReplicaUpdateOut, err *storiface.CallError) error { return m.returnResult(ctx, callID, out, err) } -func (m *Manager) ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, out storage.ReplicaVanillaProofs, err *storiface.CallError) error { +func (m *Manager) ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, out storiface.ReplicaVanillaProofs, err *storiface.CallError) error { return m.returnResult(ctx, callID, out, err) } -func (m *Manager) ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storage.ReplicaUpdateProof, err *storiface.CallError) error { +func (m *Manager) ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, proof storiface.ReplicaUpdateProof, err *storiface.CallError) error { return m.returnResult(ctx, callID, proof, err) } diff --git a/storage/sealer/manager_test.go b/storage/sealer/manager_test.go index f5695fc11..f71452b5e 100644 --- a/storage/sealer/manager_test.go +++ b/storage/sealer/manager_test.go @@ -27,7 +27,6 @@ import ( "github.com/filecoin-project/go-state-types/proof" "github.com/filecoin-project/go-statestore" proof7 "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" @@ -157,7 +156,7 @@ func TestSimple(t *testing.T) { }, lstor, m)) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } @@ -233,7 +232,7 @@ func TestSnapDeals(t *testing.T) { log.Warn("Continuing test with 2k sectors") } - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: proofType, } @@ -311,7 +310,7 @@ func TestSnapDeals(t *testing.T) { fmt.Printf("Decode duration (%s): %s\n", ss.ShortString(), time.Since(startDecode)) // Remove just the first piece and decode for retrieval - require.NoError(t, m.FinalizeSector(ctx, sid, []storage.Range{{Offset: p1.Size.Unpadded(), Size: p2.Size.Unpadded()}})) + require.NoError(t, m.FinalizeSector(ctx, sid, []storiface.Range{{Offset: p1.Size.Unpadded(), Size: p2.Size.Unpadded()}})) require.NoError(t, m.SectorsUnsealPiece(ctx, sid, 0, p1.Size.Unpadded(), ticket, &out.NewUnsealed)) fmt.Printf("GSK\n") @@ -364,12 +363,12 @@ func TestSnarkPackV2(t *testing.T) { mid := abi.ActorID(1000) - sid1 := storage.SectorRef{ + sid1 := storiface.SectorRef{ ID: abi.SectorID{Miner: mid, Number: 1}, ProofType: proofType, } - sid2 := storage.SectorRef{ + sid2 := storiface.SectorRef{ ID: abi.SectorID{Miner: mid, Number: 2}, ProofType: proofType, } @@ -487,7 +486,7 @@ func TestRedoPC1(t *testing.T) { err := m.AddWorker(ctx, tw) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } @@ -542,7 +541,7 @@ func TestRestartManager(t *testing.T) { err := m.AddWorker(ctx, tw) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } @@ -645,7 +644,7 @@ func TestRestartWorker(t *testing.T) { err := m.AddWorker(ctx, w) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } @@ -793,7 +792,7 @@ func TestResUse(t *testing.T) { err := m.AddWorker(ctx, w) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } @@ -855,7 +854,7 @@ func TestResOverride(t *testing.T) { err := m.AddWorker(ctx, w) require.NoError(t, err) - sid := storage.SectorRef{ + sid := storiface.SectorRef{ ID: abi.SectorID{Miner: 1000, Number: 1}, ProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, } diff --git a/storage/sealer/mock/mock.go b/storage/sealer/mock/mock.go index ae35f9695..42ce75501 100644 --- a/storage/sealer/mock/mock.go +++ b/storage/sealer/mock/mock.go @@ -19,7 +19,6 @@ import ( commcid "github.com/filecoin-project/go-fil-commcid" "github.com/filecoin-project/go-state-types/abi" prooftypes "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" "github.com/filecoin-project/lotus/storage/sealer/storiface" @@ -72,11 +71,11 @@ type sectorState struct { lk sync.Mutex } -func (mgr *SectorMgr) NewSector(ctx context.Context, sector storage.SectorRef) error { +func (mgr *SectorMgr) NewSector(ctx context.Context, sector storiface.SectorRef) error { return nil } -func (mgr *SectorMgr) SectorsUnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error { +func (mgr *SectorMgr) SectorsUnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error { panic("SectorMgr: unsealing piece: implement me") } @@ -84,7 +83,7 @@ func (mgr *SectorMgr) DataCid(ctx context.Context, size abi.UnpaddedPieceSize, r panic("todo") } -func (mgr *SectorMgr) AddPiece(ctx context.Context, sectorID storage.SectorRef, existingPieces []abi.UnpaddedPieceSize, size abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) { +func (mgr *SectorMgr) AddPiece(ctx context.Context, sectorID storiface.SectorRef, existingPieces []abi.UnpaddedPieceSize, size abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) { log.Warn("Add piece: ", sectorID, size, sectorID.ProofType) var b bytes.Buffer @@ -128,11 +127,11 @@ func (mgr *SectorMgr) AcquireSectorNumber() (abi.SectorNumber, error) { return id, nil } -func (mgr *SectorMgr) IsUnsealed(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { +func (mgr *SectorMgr) IsUnsealed(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { return false, nil } -func (mgr *SectorMgr) ForceState(sid storage.SectorRef, st int) error { +func (mgr *SectorMgr) ForceState(sid storiface.SectorRef, st int) error { mgr.lk.Lock() ss, ok := mgr.sectors[sid.ID] mgr.lk.Unlock() @@ -145,7 +144,7 @@ func (mgr *SectorMgr) ForceState(sid storage.SectorRef, st int) error { return nil } -func (mgr *SectorMgr) SealPreCommit1(ctx context.Context, sid storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) { +func (mgr *SectorMgr) SealPreCommit1(ctx context.Context, sid storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storiface.PreCommit1Out, err error) { mgr.lk.Lock() ss, ok := mgr.sectors[sid.ID] mgr.lk.Unlock() @@ -205,7 +204,7 @@ func (mgr *SectorMgr) SealPreCommit1(ctx context.Context, sid storage.SectorRef, return cc, nil } -func (mgr *SectorMgr) SealPreCommit2(ctx context.Context, sid storage.SectorRef, phase1Out storage.PreCommit1Out) (cids storage.SectorCids, err error) { +func (mgr *SectorMgr) SealPreCommit2(ctx context.Context, sid storiface.SectorRef, phase1Out storiface.PreCommit1Out) (cids storiface.SectorCids, err error) { db := []byte(string(phase1Out)) db[0] ^= 'd' @@ -218,13 +217,13 @@ func (mgr *SectorMgr) SealPreCommit2(ctx context.Context, sid storage.SectorRef, commR, _ := commcid.ReplicaCommitmentV1ToCID(commr) - return storage.SectorCids{ + return storiface.SectorCids{ Unsealed: d, Sealed: commR, }, nil } -func (mgr *SectorMgr) SealCommit1(ctx context.Context, sid storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (output storage.Commit1Out, err error) { +func (mgr *SectorMgr) SealCommit1(ctx context.Context, sid storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (output storiface.Commit1Out, err error) { mgr.lk.Lock() ss, ok := mgr.sectors[sid.ID] mgr.lk.Unlock() @@ -252,7 +251,7 @@ func (mgr *SectorMgr) SealCommit1(ctx context.Context, sid storage.SectorRef, ti return out[:], nil } -func (mgr *SectorMgr) SealCommit2(ctx context.Context, sid storage.SectorRef, phase1Out storage.Commit1Out) (proof storage.Proof, err error) { +func (mgr *SectorMgr) SealCommit2(ctx context.Context, sid storiface.SectorRef, phase1Out storiface.Commit1Out) (proof storiface.Proof, err error) { plen, err := sid.ProofType.ProofSize() if err != nil { return nil, err @@ -266,31 +265,31 @@ func (mgr *SectorMgr) SealCommit2(ctx context.Context, sid storage.SectorRef, ph return out[:], nil } -func (mgr *SectorMgr) ReplicaUpdate(ctx context.Context, sid storage.SectorRef, pieces []abi.PieceInfo) (storage.ReplicaUpdateOut, error) { - out := storage.ReplicaUpdateOut{} +func (mgr *SectorMgr) ReplicaUpdate(ctx context.Context, sid storiface.SectorRef, pieces []abi.PieceInfo) (storiface.ReplicaUpdateOut, error) { + out := storiface.ReplicaUpdateOut{} return out, nil } -func (mgr *SectorMgr) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storage.ReplicaVanillaProofs, error) { +func (mgr *SectorMgr) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.ReplicaVanillaProofs, error) { out := make([][]byte, 0) return out, nil } -func (mgr *SectorMgr) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storage.ReplicaUpdateProof, error) { +func (mgr *SectorMgr) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.ReplicaUpdateProof, error) { return make([]byte, 0), nil } -func (mgr *SectorMgr) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) error { +func (mgr *SectorMgr) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) error { return nil } -func (mgr *SectorMgr) ReleaseSealed(ctx context.Context, sid storage.SectorRef) error { +func (mgr *SectorMgr) ReleaseSealed(ctx context.Context, sid storiface.SectorRef) error { return nil } // Test Instrumentation Methods -func (mgr *SectorMgr) MarkFailed(sid storage.SectorRef, failed bool) error { +func (mgr *SectorMgr) MarkFailed(sid storiface.SectorRef, failed bool) error { mgr.lk.Lock() defer mgr.lk.Unlock() ss, ok := mgr.sectors[sid.ID] @@ -310,7 +309,7 @@ func (mgr *SectorMgr) Fail() { return } -func (mgr *SectorMgr) MarkCorrupted(sid storage.SectorRef, corrupted bool) error { +func (mgr *SectorMgr) MarkCorrupted(sid storiface.SectorRef, corrupted bool) error { mgr.lk.Lock() defer mgr.lk.Unlock() ss, ok := mgr.sectors[sid.ID] @@ -437,7 +436,7 @@ func (mgr *SectorMgr) GenerateWindowPoStWithVanilla(ctx context.Context, proofTy panic("implement me") } -func (mgr *SectorMgr) ReadPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) { +func (mgr *SectorMgr) ReadPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) { off := storiface.UnpaddedByteIndex(0) var piece cid.Cid for _, c := range mgr.sectors[sector.ID].pieces { @@ -463,21 +462,21 @@ func (mgr *SectorMgr) ReadPiece(ctx context.Context, sector storage.SectorRef, o }, false, nil } -func (mgr *SectorMgr) StageFakeData(mid abi.ActorID, spt abi.RegisteredSealProof) (storage.SectorRef, []abi.PieceInfo, error) { +func (mgr *SectorMgr) StageFakeData(mid abi.ActorID, spt abi.RegisteredSealProof) (storiface.SectorRef, []abi.PieceInfo, error) { psize, err := spt.SectorSize() if err != nil { - return storage.SectorRef{}, nil, err + return storiface.SectorRef{}, nil, err } usize := abi.PaddedPieceSize(psize).Unpadded() sid, err := mgr.AcquireSectorNumber() if err != nil { - return storage.SectorRef{}, nil, err + return storiface.SectorRef{}, nil, err } buf := make([]byte, usize) _, _ = rand.Read(buf) // nolint:gosec - id := storage.SectorRef{ + id := storiface.SectorRef{ ID: abi.SectorID{ Miner: mid, Number: sid, @@ -487,33 +486,33 @@ func (mgr *SectorMgr) StageFakeData(mid abi.ActorID, spt abi.RegisteredSealProof pi, err := mgr.AddPiece(context.TODO(), id, nil, usize, bytes.NewReader(buf)) if err != nil { - return storage.SectorRef{}, nil, err + return storiface.SectorRef{}, nil, err } return id, []abi.PieceInfo{pi}, nil } -func (mgr *SectorMgr) FinalizeSector(context.Context, storage.SectorRef, []storage.Range) error { +func (mgr *SectorMgr) FinalizeSector(context.Context, storiface.SectorRef, []storiface.Range) error { return nil } -func (mgr *SectorMgr) FinalizeReplicaUpdate(context.Context, storage.SectorRef, []storage.Range) error { +func (mgr *SectorMgr) FinalizeReplicaUpdate(context.Context, storiface.SectorRef, []storiface.Range) error { return nil } -func (mgr *SectorMgr) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) error { +func (mgr *SectorMgr) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) error { return nil } -func (mgr *SectorMgr) ReleaseReplicaUpgrade(ctx context.Context, sector storage.SectorRef) error { +func (mgr *SectorMgr) ReleaseReplicaUpgrade(ctx context.Context, sector storiface.SectorRef) error { return nil } -func (mgr *SectorMgr) ReleaseSectorKey(ctx context.Context, sector storage.SectorRef) error { +func (mgr *SectorMgr) ReleaseSectorKey(ctx context.Context, sector storiface.SectorRef) error { return nil } -func (mgr *SectorMgr) Remove(ctx context.Context, sector storage.SectorRef) error { +func (mgr *SectorMgr) Remove(ctx context.Context, sector storiface.SectorRef) error { mgr.lk.Lock() defer mgr.lk.Unlock() @@ -525,7 +524,7 @@ func (mgr *SectorMgr) Remove(ctx context.Context, sector storage.SectorRef) erro return nil } -func (mgr *SectorMgr) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, ids []storage.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { +func (mgr *SectorMgr) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, ids []storiface.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { bad := map[abi.SectorID]string{} for _, sid := range ids { @@ -549,19 +548,19 @@ func (mgr *SectorMgr) ReturnAddPiece(ctx context.Context, callID storiface.CallI panic("not supported") } -func (mgr *SectorMgr) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storiface.PreCommit1Out, err *storiface.CallError) error { panic("not supported") } -func (mgr *SectorMgr) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storiface.SectorCids, err *storiface.CallError) error { panic("not supported") } -func (mgr *SectorMgr) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storiface.Commit1Out, err *storiface.CallError) error { panic("not supported") } -func (mgr *SectorMgr) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storiface.Proof, err *storiface.CallError) error { panic("not supported") } @@ -589,15 +588,15 @@ func (mgr *SectorMgr) ReturnFetch(ctx context.Context, callID storiface.CallID, panic("not supported") } -func (mgr *SectorMgr) ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storage.ReplicaUpdateOut, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnReplicaUpdate(ctx context.Context, callID storiface.CallID, out storiface.ReplicaUpdateOut, err *storiface.CallError) error { panic("not supported") } -func (mgr *SectorMgr) ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, out storage.ReplicaVanillaProofs, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnProveReplicaUpdate1(ctx context.Context, callID storiface.CallID, out storiface.ReplicaVanillaProofs, err *storiface.CallError) error { panic("not supported") } -func (mgr *SectorMgr) ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, out storage.ReplicaUpdateProof, err *storiface.CallError) error { +func (mgr *SectorMgr) ReturnProveReplicaUpdate2(ctx context.Context, callID storiface.CallID, out storiface.ReplicaUpdateProof, err *storiface.CallError) error { panic("not supported") } @@ -735,6 +734,6 @@ var MockVerifier = mockVerifProver{ var MockProver = MockVerifier -var _ storage.Sealer = &SectorMgr{} +var _ storiface.Sealer = &SectorMgr{} var _ ffiwrapper.Verifier = MockVerifier var _ ffiwrapper.Prover = MockProver diff --git a/storage/sealer/piece_provider.go b/storage/sealer/piece_provider.go index e3e1ca23a..f49b8b0c7 100644 --- a/storage/sealer/piece_provider.go +++ b/storage/sealer/piece_provider.go @@ -10,7 +10,6 @@ import ( "github.com/filecoin-project/dagstore/mount" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/fr32" @@ -19,7 +18,7 @@ import ( type Unsealer interface { // SectorsUnsealPiece will Unseal a Sealed sector file for the given sector. - SectorsUnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error + SectorsUnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd *cid.Cid) error } type PieceProvider interface { @@ -28,8 +27,8 @@ type PieceProvider interface { // default in most cases, but this might matter with future PoRep) // startOffset is added to the pieceOffset to get the starting reader offset. // The number of bytes that can be read is pieceSize-startOffset - ReadPiece(ctx context.Context, sector storage.SectorRef, pieceOffset storiface.UnpaddedByteIndex, pieceSize abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) - IsUnsealed(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) + ReadPiece(ctx context.Context, sector storiface.SectorRef, pieceOffset storiface.UnpaddedByteIndex, pieceSize abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) + IsUnsealed(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) } var _ PieceProvider = &pieceProvider{} @@ -50,7 +49,7 @@ func NewPieceProvider(storage *paths.Remote, index paths.SectorIndex, uns Unseal // IsUnsealed checks if we have the unsealed piece at the given offset in an already // existing unsealed file either locally or on any of the workers. -func (p *pieceProvider) IsUnsealed(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { +func (p *pieceProvider) IsUnsealed(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { if err := offset.Valid(); err != nil { return false, xerrors.Errorf("offset is not valid: %w", err) } @@ -72,7 +71,7 @@ func (p *pieceProvider) IsUnsealed(ctx context.Context, sector storage.SectorRef // It will NOT try to schedule an Unseal of a sealed sector file for the read. // // Returns a nil reader if the piece does NOT exist in any unsealed file or there is no unsealed file for the given sector on any of the workers. -func (p *pieceProvider) tryReadUnsealedPiece(ctx context.Context, pc cid.Cid, sector storage.SectorRef, pieceOffset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (mount.Reader, error) { +func (p *pieceProvider) tryReadUnsealedPiece(ctx context.Context, pc cid.Cid, sector storiface.SectorRef, pieceOffset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (mount.Reader, error) { // acquire a lock purely for reading unsealed sectors ctx, cancel := context.WithCancel(ctx) if err := p.index.StorageLock(ctx, sector.ID, storiface.FTUnsealed, storiface.FTNone); err != nil { @@ -156,7 +155,7 @@ var _ io.Closer = funcCloser(nil) // If we do NOT have an existing unsealed file containing the given piece thus causing us to schedule an Unseal, // the returned boolean parameter will be set to true. // If we have an existing unsealed file containing the given piece, the returned boolean will be set to false. -func (p *pieceProvider) ReadPiece(ctx context.Context, sector storage.SectorRef, pieceOffset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) { +func (p *pieceProvider) ReadPiece(ctx context.Context, sector storiface.SectorRef, pieceOffset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) (mount.Reader, bool, error) { if err := pieceOffset.Valid(); err != nil { return nil, false, xerrors.Errorf("pieceOffset is not valid: %w", err) } diff --git a/storage/sealer/piece_provider_test.go b/storage/sealer/piece_provider_test.go index 6d9525b0a..8da155604 100644 --- a/storage/sealer/piece_provider_test.go +++ b/storage/sealer/piece_provider_test.go @@ -20,7 +20,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-statestore" - specstorage "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/sealtasks" @@ -182,7 +181,7 @@ type pieceProviderTestHarness struct { ctx context.Context index *paths.Index pp PieceProvider - sector specstorage.SectorRef + sector storiface.SectorRef mgr *Manager ticket abi.SealRandomness commD cid.Cid @@ -232,7 +231,7 @@ func newPieceProviderTestHarness(t *testing.T, mgrConfig Config, sectorProofType pp := NewPieceProvider(remoteStore, index, mgr) - sector := specstorage.SectorRef{ + sector := storiface.SectorRef{ ID: abi.SectorID{ Miner: 100, Number: 10, @@ -318,13 +317,13 @@ func (p *pieceProviderTestHarness) addPiece(t *testing.T, pieceData []byte) abi. return pieceInfo } -func (p *pieceProviderTestHarness) preCommit1(t *testing.T) specstorage.PreCommit1Out { +func (p *pieceProviderTestHarness) preCommit1(t *testing.T) storiface.PreCommit1Out { preCommit1, err := p.mgr.SealPreCommit1(p.ctx, p.sector, p.ticket, p.addedPieces) require.NoError(t, err) return preCommit1 } -func (p *pieceProviderTestHarness) preCommit2(t *testing.T, pc1 specstorage.PreCommit1Out) { +func (p *pieceProviderTestHarness) preCommit2(t *testing.T, pc1 storiface.PreCommit1Out) { sectorCids, err := p.mgr.SealPreCommit2(p.ctx, p.sector, pc1) require.NoError(t, err) commD := sectorCids.Unsealed @@ -351,7 +350,7 @@ func (p *pieceProviderTestHarness) readPiece(t *testing.T, offset storiface.Unpa require.Equal(t, expectedBytes, readData) } -func (p *pieceProviderTestHarness) finalizeSector(t *testing.T, keepUnseal []specstorage.Range) { +func (p *pieceProviderTestHarness) finalizeSector(t *testing.T, keepUnseal []storiface.Range) { require.NoError(t, p.mgr.FinalizeSector(p.ctx, p.sector, keepUnseal)) } diff --git a/storage/sealer/roprov.go b/storage/sealer/roprov.go index e57f6a2c1..c225fda78 100644 --- a/storage/sealer/roprov.go +++ b/storage/sealer/roprov.go @@ -5,8 +5,6 @@ import ( "golang.org/x/xerrors" - "github.com/filecoin-project/specs-storage/storage" - "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/storiface" ) @@ -16,7 +14,7 @@ type readonlyProvider struct { stor *paths.Local } -func (l *readonlyProvider) AcquireSector(ctx context.Context, id storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, func(), error) { +func (l *readonlyProvider) AcquireSector(ctx context.Context, id storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, func(), error) { if allocate != storiface.FTNone { return storiface.SectorPaths{}, nil, xerrors.New("read-only storage") } diff --git a/storage/sealer/sched.go b/storage/sealer/sched.go index 192e415c8..323def986 100644 --- a/storage/sealer/sched.go +++ b/storage/sealer/sched.go @@ -9,7 +9,6 @@ import ( "golang.org/x/xerrors" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/sealtasks" "github.com/filecoin-project/lotus/storage/sealer/storiface" @@ -119,7 +118,7 @@ type workerDisableReq struct { } type WorkerRequest struct { - Sector storage.SectorRef + Sector storiface.SectorRef TaskType sealtasks.TaskType Priority int // larger values more important Sel WorkerSelector @@ -176,7 +175,7 @@ func newScheduler(assigner string) (*Scheduler, error) { }, nil } -func (sh *Scheduler) Schedule(ctx context.Context, sector storage.SectorRef, taskType sealtasks.TaskType, sel WorkerSelector, prepare WorkerAction, work WorkerAction) error { +func (sh *Scheduler) Schedule(ctx context.Context, sector storiface.SectorRef, taskType sealtasks.TaskType, sel WorkerSelector, prepare WorkerAction, work WorkerAction) error { ret := make(chan workerResponse) select { diff --git a/storage/sealer/sched_test.go b/storage/sealer/sched_test.go index 8ebaa317a..258383e90 100644 --- a/storage/sealer/sched_test.go +++ b/storage/sealer/sched_test.go @@ -18,7 +18,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" prooftypes "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/fsutil" @@ -68,79 +67,79 @@ type schedTestWorker struct { ignoreResources bool } -func (s *schedTestWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { +func (s *schedTestWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (s *schedTestWorker) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) { +func (s *schedTestWorker) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, pc1o storiface.PreCommit1Out) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) { +func (s *schedTestWorker) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) { +func (s *schedTestWorker) SealCommit2(ctx context.Context, sector storiface.SectorRef, c1o storiface.Commit1Out) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (s *schedTestWorker) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) { +func (s *schedTestWorker) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) Remove(ctx context.Context, sector storage.SectorRef) (storiface.CallID, error) { +func (s *schedTestWorker) Remove(ctx context.Context, sector storiface.SectorRef) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) NewSector(ctx context.Context, sector storage.SectorRef) (storiface.CallID, error) { +func (s *schedTestWorker) NewSector(ctx context.Context, sector storiface.SectorRef) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { +func (s *schedTestWorker) AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, peices []abi.PieceInfo) (storiface.CallID, error) { +func (s *schedTestWorker) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, peices []abi.PieceInfo) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { +func (s *schedTestWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (s *schedTestWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) (storiface.CallID, error) { +func (s *schedTestWorker) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (s *schedTestWorker) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) { +func (s *schedTestWorker) MoveStorage(ctx context.Context, sector storiface.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) Fetch(ctx context.Context, id storage.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { +func (s *schedTestWorker) Fetch(ctx context.Context, id storiface.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) UnsealPiece(ctx context.Context, id storage.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { +func (s *schedTestWorker) UnsealPiece(ctx context.Context, id storiface.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { panic("implement me") } -func (s *schedTestWorker) ReadPiece(ctx context.Context, writer io.Writer, id storage.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (storiface.CallID, error) { +func (s *schedTestWorker) ReadPiece(ctx context.Context, writer io.Writer, id storiface.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (storiface.CallID, error) { panic("implement me") } @@ -276,7 +275,7 @@ func TestSched(t *testing.T) { go func() { defer rm.wg.Done() - sectorRef := storage.SectorRef{ + sectorRef := storiface.SectorRef{ ID: abi.SectorID{ Miner: 8, Number: sid, @@ -666,7 +665,7 @@ func TestWindowCompact(t *testing.T) { for _, task := range windowTasks { window.Todo = append(window.Todo, &WorkerRequest{ TaskType: task, - Sector: storage.SectorRef{ProofType: spt}, + Sector: storiface.SectorRef{ProofType: spt}, }) window.Allocated.Add(task.SealTask(spt), wh.Info.Resources, storiface.ResourceTable[task][spt]) } diff --git a/storage/sealer/storiface/paths.go b/storage/sealer/storiface/paths.go new file mode 100644 index 000000000..624b71d77 --- /dev/null +++ b/storage/sealer/storiface/paths.go @@ -0,0 +1,31 @@ +package storiface + +import "github.com/filecoin-project/go-state-types/abi" + +type PathType string + +const ( + PathStorage PathType = "storage" + PathSealing PathType = "sealing" +) + +type AcquireMode string + +const ( + AcquireMove AcquireMode = "move" + AcquireCopy AcquireMode = "copy" +) + +type Refs struct { + RefCount [FileTypes]uint +} + +type SectorLock struct { + Sector abi.SectorID + Write [FileTypes]uint + Read [FileTypes]uint +} + +type SectorLocks struct { + Locks []SectorLock +} diff --git a/storage/sealer/storiface/storage.go b/storage/sealer/storiface/storage.go index 624b71d77..2872b76ac 100644 --- a/storage/sealer/storiface/storage.go +++ b/storage/sealer/storiface/storage.go @@ -1,31 +1,94 @@ package storiface -import "github.com/filecoin-project/go-state-types/abi" +import ( + "context" + "io" -type PathType string + "github.com/ipfs/go-cid" -const ( - PathStorage PathType = "storage" - PathSealing PathType = "sealing" + "github.com/filecoin-project/go-state-types/abi" + "github.com/filecoin-project/go-state-types/proof" ) -type AcquireMode string +type Data = io.Reader -const ( - AcquireMove AcquireMode = "move" - AcquireCopy AcquireMode = "copy" -) - -type Refs struct { - RefCount [FileTypes]uint +type SectorRef struct { + ID abi.SectorID + ProofType abi.RegisteredSealProof } -type SectorLock struct { - Sector abi.SectorID - Write [FileTypes]uint - Read [FileTypes]uint +var NoSectorRef = SectorRef{} + +type Storage interface { + // Creates a new empty sector (only allocate on disk. Layers above + // storage are responsible for assigning sector IDs) + NewSector(ctx context.Context, sector SectorRef) error + // Compute Data CID + DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData Data) (abi.PieceInfo, error) + // Add a piece to an existing *unsealed* sector + AddPiece(ctx context.Context, sector SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData Data) (abi.PieceInfo, error) } -type SectorLocks struct { - Locks []SectorLock +type Prover interface { + GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.ExtendedSectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) + GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.ExtendedSectorInfo, randomness abi.PoStRandomness) (proof []proof.PoStProof, skipped []abi.SectorID, err error) + + GenerateWinningPoStWithVanilla(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte) ([]proof.PoStProof, error) + GenerateWindowPoStWithVanilla(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, proofs [][]byte, partitionIdx int) (proof.PoStProof, error) +} + +type PreCommit1Out []byte + +type Commit1Out []byte + +type Proof []byte + +type SectorCids struct { + Unsealed cid.Cid + Sealed cid.Cid +} + +type Range struct { + Offset abi.UnpaddedPieceSize + Size abi.UnpaddedPieceSize +} + +type ReplicaUpdateProof []byte +type ReplicaVanillaProofs [][]byte + +type ReplicaUpdateOut struct { + NewSealed cid.Cid + NewUnsealed cid.Cid +} + +type Sealer interface { + SealPreCommit1(ctx context.Context, sector SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (PreCommit1Out, error) + SealPreCommit2(ctx context.Context, sector SectorRef, pc1o PreCommit1Out) (SectorCids, error) + + SealCommit1(ctx context.Context, sector SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids SectorCids) (Commit1Out, error) + SealCommit2(ctx context.Context, sector SectorRef, c1o Commit1Out) (Proof, error) + + FinalizeSector(ctx context.Context, sector SectorRef, keepUnsealed []Range) error + + // ReleaseUnsealed marks parts of the unsealed sector file as safe to drop + // (called by the fsm on restart, allows storage to keep no persistent + // state about unsealed fast-retrieval copies) + ReleaseUnsealed(ctx context.Context, sector SectorRef, safeToFree []Range) error + ReleaseSectorKey(ctx context.Context, sector SectorRef) error + ReleaseReplicaUpgrade(ctx context.Context, sector SectorRef) error + + // Removes all data associated with the specified sector + Remove(ctx context.Context, sector SectorRef) error + + // Generate snap deals replica update + ReplicaUpdate(ctx context.Context, sector SectorRef, pieces []abi.PieceInfo) (ReplicaUpdateOut, error) + + // Prove that snap deals replica was done correctly + ProveReplicaUpdate1(ctx context.Context, sector SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (ReplicaVanillaProofs, error) + ProveReplicaUpdate2(ctx context.Context, sector SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs ReplicaVanillaProofs) (ReplicaUpdateProof, error) + + // GenerateSectorKeyFromData computes sector key given unsealed data and updated replica + GenerateSectorKeyFromData(ctx context.Context, sector SectorRef, unsealed cid.Cid) error + + FinalizeReplicaUpdate(ctx context.Context, sector SectorRef, keepUnsealed []Range) error } diff --git a/storage/sealer/storiface/worker.go b/storage/sealer/storiface/worker.go index e03c546ec..5d2781ec8 100644 --- a/storage/sealer/storiface/worker.go +++ b/storage/sealer/storiface/worker.go @@ -11,7 +11,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/sealtasks" ) @@ -119,22 +118,22 @@ var UndefCall CallID type WorkerCalls interface { // async - DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (CallID, error) - AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (CallID, error) - SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (CallID, error) - SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (CallID, error) - SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (CallID, error) - SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (CallID, error) - FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (CallID, error) - FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (CallID, error) - ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (CallID, error) - ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (CallID, error) - ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (CallID, error) - ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (CallID, error) - GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) (CallID, error) - MoveStorage(ctx context.Context, sector storage.SectorRef, types SectorFileType) (CallID, error) - UnsealPiece(context.Context, storage.SectorRef, UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (CallID, error) - Fetch(context.Context, storage.SectorRef, SectorFileType, PathType, AcquireMode) (CallID, error) + DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData Data) (CallID, error) + AddPiece(ctx context.Context, sector SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData Data) (CallID, error) + SealPreCommit1(ctx context.Context, sector SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (CallID, error) + SealPreCommit2(ctx context.Context, sector SectorRef, pc1o PreCommit1Out) (CallID, error) + SealCommit1(ctx context.Context, sector SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids SectorCids) (CallID, error) + SealCommit2(ctx context.Context, sector SectorRef, c1o Commit1Out) (CallID, error) + FinalizeSector(ctx context.Context, sector SectorRef, keepUnsealed []Range) (CallID, error) + FinalizeReplicaUpdate(ctx context.Context, sector SectorRef, keepUnsealed []Range) (CallID, error) + ReleaseUnsealed(ctx context.Context, sector SectorRef, safeToFree []Range) (CallID, error) + ReplicaUpdate(ctx context.Context, sector SectorRef, pieces []abi.PieceInfo) (CallID, error) + ProveReplicaUpdate1(ctx context.Context, sector SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (CallID, error) + ProveReplicaUpdate2(ctx context.Context, sector SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs ReplicaVanillaProofs) (CallID, error) + GenerateSectorKeyFromData(ctx context.Context, sector SectorRef, commD cid.Cid) (CallID, error) + MoveStorage(ctx context.Context, sector SectorRef, types SectorFileType) (CallID, error) + UnsealPiece(context.Context, SectorRef, UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (CallID, error) + Fetch(context.Context, SectorRef, SectorFileType, PathType, AcquireMode) (CallID, error) // sync GenerateWinningPoSt(ctx context.Context, ppt abi.RegisteredPoStProof, mid abi.ActorID, sectors []PostSectorChallenge, randomness abi.PoStRandomness) ([]proof.PoStProof, error) @@ -202,15 +201,15 @@ func Err(code ErrorCode, sub error) *CallError { type WorkerReturn interface { ReturnDataCid(ctx context.Context, callID CallID, pi abi.PieceInfo, err *CallError) error ReturnAddPiece(ctx context.Context, callID CallID, pi abi.PieceInfo, err *CallError) error - ReturnSealPreCommit1(ctx context.Context, callID CallID, p1o storage.PreCommit1Out, err *CallError) error - ReturnSealPreCommit2(ctx context.Context, callID CallID, sealed storage.SectorCids, err *CallError) error - ReturnSealCommit1(ctx context.Context, callID CallID, out storage.Commit1Out, err *CallError) error - ReturnSealCommit2(ctx context.Context, callID CallID, proof storage.Proof, err *CallError) error + ReturnSealPreCommit1(ctx context.Context, callID CallID, p1o PreCommit1Out, err *CallError) error + ReturnSealPreCommit2(ctx context.Context, callID CallID, sealed SectorCids, err *CallError) error + ReturnSealCommit1(ctx context.Context, callID CallID, out Commit1Out, err *CallError) error + ReturnSealCommit2(ctx context.Context, callID CallID, proof Proof, err *CallError) error ReturnFinalizeSector(ctx context.Context, callID CallID, err *CallError) error ReturnReleaseUnsealed(ctx context.Context, callID CallID, err *CallError) error - ReturnReplicaUpdate(ctx context.Context, callID CallID, out storage.ReplicaUpdateOut, err *CallError) error - ReturnProveReplicaUpdate1(ctx context.Context, callID CallID, proofs storage.ReplicaVanillaProofs, err *CallError) error - ReturnProveReplicaUpdate2(ctx context.Context, callID CallID, proof storage.ReplicaUpdateProof, err *CallError) error + ReturnReplicaUpdate(ctx context.Context, callID CallID, out ReplicaUpdateOut, err *CallError) error + ReturnProveReplicaUpdate1(ctx context.Context, callID CallID, proofs ReplicaVanillaProofs, err *CallError) error + ReturnProveReplicaUpdate2(ctx context.Context, callID CallID, proof ReplicaUpdateProof, err *CallError) error ReturnGenerateSectorKeyFromData(ctx context.Context, callID CallID, err *CallError) error ReturnFinalizeReplicaUpdate(ctx context.Context, callID CallID, err *CallError) error ReturnMoveStorage(ctx context.Context, callID CallID, err *CallError) error diff --git a/storage/sealer/teststorage_test.go b/storage/sealer/teststorage_test.go index e1e59c0b0..9fbe1bd6b 100644 --- a/storage/sealer/teststorage_test.go +++ b/storage/sealer/teststorage_test.go @@ -8,7 +8,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" "github.com/filecoin-project/lotus/storage/sealer/storiface" @@ -23,7 +22,7 @@ type testExec struct { apch chan chan apres } -func (t *testExec) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) { +func (t *testExec) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) { panic("implement me") } @@ -43,82 +42,82 @@ func (t *testExec) GenerateWindowPoStWithVanilla(ctx context.Context, proofType panic("implement me") } -func (t *testExec) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) { +func (t *testExec) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.PreCommit1Out, error) { panic("implement me") } -func (t *testExec) SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storage.SectorCids, error) { +func (t *testExec) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, pc1o storiface.PreCommit1Out) (storiface.SectorCids, error) { panic("implement me") } -func (t *testExec) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) { +func (t *testExec) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.Commit1Out, error) { panic("implement me") } -func (t *testExec) SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storage.Proof, error) { +func (t *testExec) SealCommit2(ctx context.Context, sector storiface.SectorRef, c1o storiface.Commit1Out) (storiface.Proof, error) { panic("implement me") } -func (t *testExec) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (t *testExec) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { panic("implement me") } -func (t *testExec) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) error { +func (t *testExec) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) error { panic("implement me") } -func (t *testExec) ReleaseSealed(ctx context.Context, sector storage.SectorRef) error { +func (t *testExec) ReleaseSealed(ctx context.Context, sector storiface.SectorRef) error { panic("implement me") } -func (t *testExec) ReleaseSectorKey(ctx context.Context, sector storage.SectorRef) error { +func (t *testExec) ReleaseSectorKey(ctx context.Context, sector storiface.SectorRef) error { panic("implement me") } -func (t *testExec) ReleaseReplicaUpgrade(ctx context.Context, sector storage.SectorRef) error { +func (t *testExec) ReleaseReplicaUpgrade(ctx context.Context, sector storiface.SectorRef) error { panic("implement me") } -func (t *testExec) Remove(ctx context.Context, sector storage.SectorRef) error { +func (t *testExec) Remove(ctx context.Context, sector storiface.SectorRef) error { panic("implement me") } -func (t *testExec) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storage.ReplicaUpdateOut, error) { +func (t *testExec) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.ReplicaUpdateOut, error) { panic("implement me") } -func (t *testExec) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storage.ReplicaVanillaProofs, error) { +func (t *testExec) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.ReplicaVanillaProofs, error) { panic("implement me") } -func (t *testExec) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storage.ReplicaUpdateProof, error) { +func (t *testExec) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.ReplicaUpdateProof, error) { panic("implement me") } -func (t *testExec) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) error { +func (t *testExec) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) error { panic("implement me") } -func (t *testExec) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) error { +func (t *testExec) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) error { panic("implement me") } -func (t *testExec) NewSector(ctx context.Context, sector storage.SectorRef) error { +func (t *testExec) NewSector(ctx context.Context, sector storiface.SectorRef) error { panic("implement me") } -func (t *testExec) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) { +func (t *testExec) AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (abi.PieceInfo, error) { resp := make(chan apres) t.apch <- resp ar := <-resp return ar.pi, ar.err } -func (t *testExec) UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error { +func (t *testExec) UnsealPiece(ctx context.Context, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error { panic("implement me") } -func (t *testExec) ReadPiece(ctx context.Context, writer io.Writer, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { +func (t *testExec) ReadPiece(ctx context.Context, writer io.Writer, sector storiface.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) { panic("implement me") } diff --git a/storage/sealer/testworker_test.go b/storage/sealer/testworker_test.go index 35169b845..6ea57b78d 100644 --- a/storage/sealer/testworker_test.go +++ b/storage/sealer/testworker_test.go @@ -8,7 +8,6 @@ import ( "github.com/ipfs/go-cid" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/mock" @@ -49,7 +48,7 @@ func newTestWorker(wcfg WorkerConfig, lstor *paths.Local, ret storiface.WorkerRe } } -func (t *testWorker) asyncCall(sector storage.SectorRef, work func(ci storiface.CallID)) (storiface.CallID, error) { +func (t *testWorker) asyncCall(sector storiface.SectorRef, work func(ci storiface.CallID)) (storiface.CallID, error) { ci := storiface.CallID{ Sector: sector.ID, ID: uuid.New(), @@ -60,7 +59,7 @@ func (t *testWorker) asyncCall(sector storage.SectorRef, work func(ci storiface. return ci, nil } -func (t *testWorker) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { +func (t *testWorker) AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { p, err := t.mockSeal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData) if err := t.ret.ReturnAddPiece(ctx, ci, p, toCallError(err)); err != nil { @@ -69,7 +68,7 @@ func (t *testWorker) AddPiece(ctx context.Context, sector storage.SectorRef, pie }) } -func (t *testWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (t *testWorker) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { out, err := t.mockSeal.ReplicaUpdate(ctx, sector, pieces) if err := t.ret.ReturnReplicaUpdate(ctx, ci, out, toCallError(err)); err != nil { @@ -78,7 +77,7 @@ func (t *testWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRef }) } -func (t *testWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { +func (t *testWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { vanillaProofs, err := t.mockSeal.ProveReplicaUpdate1(ctx, sector, sectorKey, newSealed, newUnsealed) if err := t.ret.ReturnProveReplicaUpdate1(ctx, ci, vanillaProofs, toCallError(err)); err != nil { @@ -87,7 +86,7 @@ func (t *testWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.Sec }) } -func (t *testWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (t *testWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { proof, err := t.mockSeal.ProveReplicaUpdate2(ctx, sector, sectorKey, newSealed, newUnsealed, vanillaProofs) if err := t.ret.ReturnProveReplicaUpdate2(ctx, ci, proof, toCallError(err)); err != nil { @@ -96,7 +95,7 @@ func (t *testWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.Sec }) } -func (t *testWorker) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (t *testWorker) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { t.pc1s++ @@ -114,7 +113,7 @@ func (t *testWorker) SealPreCommit1(ctx context.Context, sector storage.SectorRe }) } -func (t *testWorker) Fetch(ctx context.Context, sector storage.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { +func (t *testWorker) Fetch(ctx context.Context, sector storiface.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { return t.asyncCall(sector, func(ci storiface.CallID) { if err := t.ret.ReturnFetch(ctx, ci, nil); err != nil { log.Error(err) diff --git a/storage/sealer/worker_local.go b/storage/sealer/worker_local.go index b2691b6dd..f2a2f5cc1 100644 --- a/storage/sealer/worker_local.go +++ b/storage/sealer/worker_local.go @@ -21,7 +21,6 @@ import ( "github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/proof" "github.com/filecoin-project/go-statestore" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/storage/paths" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" @@ -144,7 +143,7 @@ type localWorkerPathProvider struct { op storiface.AcquireMode } -func (l *localWorkerPathProvider) AcquireSector(ctx context.Context, sector storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, func(), error) { +func (l *localWorkerPathProvider) AcquireSector(ctx context.Context, sector storiface.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, func(), error) { paths, storageIDs, err := l.w.storage.AcquireSector(ctx, sector, existing, allocate, sealing, l.op) if err != nil { return storiface.SectorPaths{}, nil, err @@ -251,7 +250,7 @@ var returnFunc = map[ReturnType]func(context.Context, storiface.CallID, storifac Fetch: rfunc(storiface.WorkerReturn.ReturnFetch), } -func (l *LocalWorker) asyncCall(ctx context.Context, sector storage.SectorRef, rt ReturnType, work func(ctx context.Context, ci storiface.CallID) (interface{}, error)) (storiface.CallID, error) { +func (l *LocalWorker) asyncCall(ctx context.Context, sector storiface.SectorRef, rt ReturnType, work func(ctx context.Context, ci storiface.CallID) (interface{}, error)) (storiface.CallID, error) { ci := storiface.CallID{ Sector: sector.ID, ID: uuid.New(), @@ -334,7 +333,7 @@ func doReturn(ctx context.Context, rt ReturnType, ci storiface.CallID, ret stori return true } -func (l *LocalWorker) NewSector(ctx context.Context, sector storage.SectorRef) error { +func (l *LocalWorker) NewSector(ctx context.Context, sector storiface.SectorRef) error { sb, err := l.executor() if err != nil { return err @@ -343,18 +342,18 @@ func (l *LocalWorker) NewSector(ctx context.Context, sector storage.SectorRef) e return sb.NewSector(ctx, sector) } -func (l *LocalWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { +func (l *LocalWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err } - return l.asyncCall(ctx, storage.NoSectorRef, DataCid, func(ctx context.Context, ci storiface.CallID) (interface{}, error) { + return l.asyncCall(ctx, storiface.NoSectorRef, DataCid, func(ctx context.Context, ci storiface.CallID) (interface{}, error) { return sb.DataCid(ctx, pieceSize, pieceData) }) } -func (l *LocalWorker) AddPiece(ctx context.Context, sector storage.SectorRef, epcs []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (storiface.CallID, error) { +func (l *LocalWorker) AddPiece(ctx context.Context, sector storiface.SectorRef, epcs []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -365,7 +364,7 @@ func (l *LocalWorker) AddPiece(ctx context.Context, sector storage.SectorRef, ep }) } -func (l *LocalWorker) Fetch(ctx context.Context, sector storage.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { +func (l *LocalWorker) Fetch(ctx context.Context, sector storiface.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { return l.asyncCall(ctx, sector, Fetch, func(ctx context.Context, ci storiface.CallID) (interface{}, error) { _, done, err := (&localWorkerPathProvider{w: l, op: am}).AcquireSector(ctx, sector, fileType, storiface.FTNone, ptype) if err == nil { @@ -376,7 +375,7 @@ func (l *LocalWorker) Fetch(ctx context.Context, sector storage.SectorRef, fileT }) } -func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { return l.asyncCall(ctx, sector, SealPreCommit1, func(ctx context.Context, ci storiface.CallID) (interface{}, error) { { @@ -399,7 +398,7 @@ func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector storage.SectorR }) } -func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.PreCommit1Out) (storiface.CallID, error) { +func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.PreCommit1Out) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -410,7 +409,7 @@ func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector storage.SectorR }) } -func (l *LocalWorker) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) { +func (l *LocalWorker) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -421,7 +420,7 @@ func (l *LocalWorker) SealCommit1(ctx context.Context, sector storage.SectorRef, }) } -func (l *LocalWorker) SealCommit2(ctx context.Context, sector storage.SectorRef, phase1Out storage.Commit1Out) (storiface.CallID, error) { +func (l *LocalWorker) SealCommit2(ctx context.Context, sector storiface.SectorRef, phase1Out storiface.Commit1Out) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -432,7 +431,7 @@ func (l *LocalWorker) SealCommit2(ctx context.Context, sector storage.SectorRef, }) } -func (l *LocalWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (l *LocalWorker) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -444,7 +443,7 @@ func (l *LocalWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRe }) } -func (l *LocalWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { +func (l *LocalWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -455,7 +454,7 @@ func (l *LocalWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.Se }) } -func (l *LocalWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (l *LocalWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -466,7 +465,7 @@ func (l *LocalWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.Se }) } -func (l *LocalWorker) GenerateSectorKeyFromData(ctx context.Context, sector storage.SectorRef, commD cid.Cid) (storiface.CallID, error) { +func (l *LocalWorker) GenerateSectorKeyFromData(ctx context.Context, sector storiface.SectorRef, commD cid.Cid) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -477,7 +476,7 @@ func (l *LocalWorker) GenerateSectorKeyFromData(ctx context.Context, sector stor }) } -func (l *LocalWorker) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (l *LocalWorker) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -498,7 +497,7 @@ func (l *LocalWorker) FinalizeSector(ctx context.Context, sector storage.SectorR }) } -func (l *LocalWorker) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (l *LocalWorker) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err @@ -519,7 +518,7 @@ func (l *LocalWorker) FinalizeReplicaUpdate(ctx context.Context, sector storage. }) } -func (l *LocalWorker) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) { +func (l *LocalWorker) ReleaseUnsealed(ctx context.Context, sector storiface.SectorRef, safeToFree []storiface.Range) (storiface.CallID, error) { return storiface.UndefCall, xerrors.Errorf("implement me") } @@ -539,7 +538,7 @@ func (l *LocalWorker) Remove(ctx context.Context, sector abi.SectorID) error { return err } -func (l *LocalWorker) MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) { +func (l *LocalWorker) MoveStorage(ctx context.Context, sector storiface.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) { return l.asyncCall(ctx, sector, MoveStorage, func(ctx context.Context, ci storiface.CallID) (interface{}, error) { if err := l.storage.MoveStorage(ctx, sector, types); err != nil { return nil, xerrors.Errorf("move to storage: %w", err) @@ -558,7 +557,7 @@ func (l *LocalWorker) MoveStorage(ctx context.Context, sector storage.SectorRef, }) } -func (l *LocalWorker) UnsealPiece(ctx context.Context, sector storage.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { +func (l *LocalWorker) UnsealPiece(ctx context.Context, sector storiface.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { sb, err := l.executor() if err != nil { return storiface.UndefCall, err diff --git a/storage/sealer/worker_tracked.go b/storage/sealer/worker_tracked.go index e051b1454..970ba9a69 100644 --- a/storage/sealer/worker_tracked.go +++ b/storage/sealer/worker_tracked.go @@ -11,7 +11,6 @@ import ( "go.opencensus.io/tag" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/metrics" "github.com/filecoin-project/lotus/storage/sealer/sealtasks" @@ -58,7 +57,7 @@ func (wt *workTracker) onDone(ctx context.Context, callID storiface.CallID) { delete(wt.running, callID) } -func (wt *workTracker) track(ctx context.Context, ready chan struct{}, wid storiface.WorkerID, wi storiface.WorkerInfo, sid storage.SectorRef, task sealtasks.TaskType, cb func() (storiface.CallID, error)) (storiface.CallID, error) { +func (wt *workTracker) track(ctx context.Context, ready chan struct{}, wid storiface.WorkerID, wi storiface.WorkerInfo, sid storiface.SectorRef, task sealtasks.TaskType, cb func() (storiface.CallID, error)) (storiface.CallID, error) { tracked := func(rw int, callID storiface.CallID) trackedWork { return trackedWork{ job: storiface.WorkerJob{ @@ -166,67 +165,67 @@ func (t *trackedWorker) start() { close(t.execute) } -func (t *trackedWorker) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (t *trackedWorker) SealPreCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTPreCommit1, func() (storiface.CallID, error) { return t.Worker.SealPreCommit1(ctx, sector, ticket, pieces) }) } -func (t *trackedWorker) SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) { +func (t *trackedWorker) SealPreCommit2(ctx context.Context, sector storiface.SectorRef, pc1o storiface.PreCommit1Out) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTPreCommit2, func() (storiface.CallID, error) { return t.Worker.SealPreCommit2(ctx, sector, pc1o) }) } -func (t *trackedWorker) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) { +func (t *trackedWorker) SealCommit1(ctx context.Context, sector storiface.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storiface.SectorCids) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTCommit1, func() (storiface.CallID, error) { return t.Worker.SealCommit1(ctx, sector, ticket, seed, pieces, cids) }) } -func (t *trackedWorker) SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) { +func (t *trackedWorker) SealCommit2(ctx context.Context, sector storiface.SectorRef, c1o storiface.Commit1Out) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTCommit2, func() (storiface.CallID, error) { return t.Worker.SealCommit2(ctx, sector, c1o) }) } -func (t *trackedWorker) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (t *trackedWorker) FinalizeSector(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTFinalize, func() (storiface.CallID, error) { return t.Worker.FinalizeSector(ctx, sector, keepUnsealed) }) } -func (t *trackedWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { - return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, storage.NoSectorRef, sealtasks.TTDataCid, func() (storiface.CallID, error) { +func (t *trackedWorker) DataCid(ctx context.Context, pieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { + return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, storiface.NoSectorRef, sealtasks.TTDataCid, func() (storiface.CallID, error) { return t.Worker.DataCid(ctx, pieceSize, pieceData) }) } -func (t *trackedWorker) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) { +func (t *trackedWorker) AddPiece(ctx context.Context, sector storiface.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storiface.Data) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTAddPiece, func() (storiface.CallID, error) { return t.Worker.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData) }) } -func (t *trackedWorker) Fetch(ctx context.Context, s storage.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { +func (t *trackedWorker) Fetch(ctx context.Context, s storiface.SectorRef, ft storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, s, sealtasks.TTFetch, func() (storiface.CallID, error) { return t.Worker.Fetch(ctx, s, ft, ptype, am) }) } -func (t *trackedWorker) UnsealPiece(ctx context.Context, id storage.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { +func (t *trackedWorker) UnsealPiece(ctx context.Context, id storiface.SectorRef, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, id, sealtasks.TTUnseal, func() (storiface.CallID, error) { return t.Worker.UnsealPiece(ctx, id, index, size, randomness, cid) }) } -func (t *trackedWorker) ReplicaUpdate(ctx context.Context, sector storage.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { +func (t *trackedWorker) ReplicaUpdate(ctx context.Context, sector storiface.SectorRef, pieces []abi.PieceInfo) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTReplicaUpdate, func() (storiface.CallID, error) { return t.Worker.ReplicaUpdate(ctx, sector, pieces) }) } -func (t *trackedWorker) ProveReplicaUpdate1(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { +func (t *trackedWorker) ProveReplicaUpdate1(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTProveReplicaUpdate1, func() (storiface.CallID, error) { return t.Worker.ProveReplicaUpdate1(ctx, sector, sectorKey, newSealed, newUnsealed) }) } -func (t *trackedWorker) ProveReplicaUpdate2(ctx context.Context, sector storage.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storage.ReplicaVanillaProofs) (storiface.CallID, error) { +func (t *trackedWorker) ProveReplicaUpdate2(ctx context.Context, sector storiface.SectorRef, sectorKey, newSealed, newUnsealed cid.Cid, vanillaProofs storiface.ReplicaVanillaProofs) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTProveReplicaUpdate2, func() (storiface.CallID, error) { return t.Worker.ProveReplicaUpdate2(ctx, sector, sectorKey, newSealed, newUnsealed, vanillaProofs) }) } -func (t *trackedWorker) FinalizeReplicaUpdate(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) { +func (t *trackedWorker) FinalizeReplicaUpdate(ctx context.Context, sector storiface.SectorRef, keepUnsealed []storiface.Range) (storiface.CallID, error) { return t.tracker.track(ctx, t.execute, t.wid, t.workerInfo, sector, sealtasks.TTFinalizeReplicaUpdate, func() (storiface.CallID, error) { return t.Worker.FinalizeReplicaUpdate(ctx, sector, keepUnsealed) }) } diff --git a/storage/sectorblocks/blocks.go b/storage/sectorblocks/blocks.go index 231809a9f..efaf3ebbe 100644 --- a/storage/sectorblocks/blocks.go +++ b/storage/sectorblocks/blocks.go @@ -16,10 +16,10 @@ import ( cborutil "github.com/filecoin-project/go-cbor-util" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/node/modules/dtypes" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) type SealSerialization uint8 @@ -48,7 +48,7 @@ func DsKeyToDealID(key datastore.Key) (uint64, error) { } type SectorBuilder interface { - SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storage.Data, d api.PieceDealInfo) (api.SectorOffset, error) + SectorAddPieceToAny(ctx context.Context, size abi.UnpaddedPieceSize, r storiface.Data, d api.PieceDealInfo) (api.SectorOffset, error) SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) } diff --git a/storage/wdpost/wdpost_run.go b/storage/wdpost/wdpost_run.go index 5f3154151..d77181f4b 100644 --- a/storage/wdpost/wdpost_run.go +++ b/storage/wdpost/wdpost_run.go @@ -20,7 +20,6 @@ import ( "github.com/filecoin-project/go-state-types/network" "github.com/filecoin-project/go-state-types/proof" proof7 "github.com/filecoin-project/specs-actors/v7/actors/runtime/proof" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/build" @@ -28,6 +27,7 @@ import ( "github.com/filecoin-project/lotus/chain/actors/policy" "github.com/filecoin-project/lotus/chain/messagepool" "github.com/filecoin-project/lotus/chain/types" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) // recordPoStFailure records a failure in the journal. @@ -202,13 +202,13 @@ func (s *WindowPoStScheduler) checkSectors(ctx context.Context, check bitfield.B } sectors := make(map[abi.SectorNumber]checkSector) - var tocheck []storage.SectorRef + var tocheck []storiface.SectorRef for _, info := range sectorInfos { sectors[info.SectorNumber] = checkSector{ sealed: info.SealedCID, update: info.SectorKeyCID != nil, } - tocheck = append(tocheck, storage.SectorRef{ + tocheck = append(tocheck, storiface.SectorRef{ ProofType: info.SealProof, ID: abi.SectorID{ Miner: abi.ActorID(mid), diff --git a/storage/wdpost/wdpost_run_test.go b/storage/wdpost/wdpost_run_test.go index db3e535dd..a7846b32b 100644 --- a/storage/wdpost/wdpost_run_test.go +++ b/storage/wdpost/wdpost_run_test.go @@ -21,7 +21,6 @@ import ( "github.com/filecoin-project/go-state-types/network" prooftypes "github.com/filecoin-project/go-state-types/proof" tutils "github.com/filecoin-project/specs-actors/v2/support/testing" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/build" @@ -173,7 +172,7 @@ func (m mockVerif) GenerateWinningPoStSectorChallenge(context.Context, abi.Regis type mockFaultTracker struct { } -func (m mockFaultTracker) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { +func (m mockFaultTracker) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storiface.SectorRef, rg storiface.RGetter) (map[abi.SectorID]string, error) { // Returns "bad" sectors so just return empty map meaning all sectors are good return map[abi.SectorID]string{}, nil } diff --git a/storage/wdpost/wdpost_sched.go b/storage/wdpost/wdpost_sched.go index 99f14c691..65cc8ba45 100644 --- a/storage/wdpost/wdpost_sched.go +++ b/storage/wdpost/wdpost_sched.go @@ -16,7 +16,6 @@ import ( "github.com/filecoin-project/go-state-types/crypto" "github.com/filecoin-project/go-state-types/dline" "github.com/filecoin-project/go-state-types/network" - "github.com/filecoin-project/specs-storage/storage" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/build" @@ -27,6 +26,7 @@ import ( "github.com/filecoin-project/lotus/storage/ctladdr" "github.com/filecoin-project/lotus/storage/sealer" "github.com/filecoin-project/lotus/storage/sealer/ffiwrapper" + "github.com/filecoin-project/lotus/storage/sealer/storiface" ) var log = logging.Logger("wdpost") @@ -66,7 +66,7 @@ type WindowPoStScheduler struct { api NodeAPI feeCfg config.MinerFeeConfig addrSel *ctladdr.AddressSelector - prover storage.Prover + prover storiface.Prover verifier ffiwrapper.Verifier faultTracker sealer.FaultTracker proofType abi.RegisteredPoStProof @@ -86,7 +86,7 @@ type WindowPoStScheduler struct { func NewWindowedPoStScheduler(api NodeAPI, cfg config.MinerFeeConfig, as *ctladdr.AddressSelector, - sp storage.Prover, + sp storiface.Prover, verif ffiwrapper.Verifier, ft sealer.FaultTracker, j journal.Journal,