diff --git a/api/docgen/docgen.go b/api/docgen/docgen.go index 571599935..61ced4405 100644 --- a/api/docgen/docgen.go +++ b/api/docgen/docgen.go @@ -300,6 +300,8 @@ func init() { Error: "", }) addExample(storiface.ResourceTable) + + addExample(map[abi.SectorNumber][]uint64{}) } func GetAPIType(name, pkg string) (i interface{}, t reflect.Type, permStruct []reflect.Type) { diff --git a/build/openrpc/full.json.gz b/build/openrpc/full.json.gz index 7ca7301ff..45d4e4964 100644 Binary files a/build/openrpc/full.json.gz and b/build/openrpc/full.json.gz differ diff --git a/build/openrpc/miner.json.gz b/build/openrpc/miner.json.gz index e7083de24..f5e65e460 100644 Binary files a/build/openrpc/miner.json.gz and b/build/openrpc/miner.json.gz differ diff --git a/build/openrpc/worker.json.gz b/build/openrpc/worker.json.gz index 717eeaacb..59680d817 100644 Binary files a/build/openrpc/worker.json.gz and b/build/openrpc/worker.json.gz differ diff --git a/documentation/en/api-v0-methods-miner.md b/documentation/en/api-v0-methods-miner.md index 013aed641..a879b6eed 100644 --- a/documentation/en/api-v0-methods-miner.md +++ b/documentation/en/api-v0-methods-miner.md @@ -144,6 +144,7 @@ * [StorageDropSector](#StorageDropSector) * [StorageFindSector](#StorageFindSector) * [StorageGetLocks](#StorageGetLocks) + * [StorageGetUrl](#StorageGetUrl) * [StorageInfo](#StorageInfo) * [StorageList](#StorageList) * [StorageLocal](#StorageLocal) @@ -2876,7 +2877,8 @@ Inputs: ], "AllowTo": [ "string value" - ] + ], + "Path": "string value" }, { "Capacity": 9, @@ -2922,7 +2924,8 @@ Response: ], "AllowTo": [ "string value" - ] + ], + "Path": "string value" } ] ``` @@ -2995,7 +2998,8 @@ Response: "Weight": 42, "CanSeal": true, "CanStore": true, - "Primary": true + "Primary": true, + "Path": "string value" } ] ``` @@ -3035,6 +3039,24 @@ Response: } ``` +### StorageGetUrl + + +Perms: admin + +Inputs: +```json +[ + { + "Miner": 1000, + "Number": 9 + }, + 1 +] +``` + +Response: `"string value"` + ### StorageInfo @@ -3063,7 +3085,8 @@ Response: ], "AllowTo": [ "string value" - ] + ], + "Path": "string value" } ``` diff --git a/documentation/en/api-v0-methods-worker.md b/documentation/en/api-v0-methods-worker.md index 566a650fa..9a6b4e6c2 100644 --- a/documentation/en/api-v0-methods-worker.md +++ b/documentation/en/api-v0-methods-worker.md @@ -13,6 +13,8 @@ * [FinalizeSector](#FinalizeSector) * [Generate](#Generate) * [GenerateSectorKeyFromData](#GenerateSectorKeyFromData) + * [GenerateWindowPoSt](#GenerateWindowPoSt) + * [GenerateWinningPoSt](#GenerateWinningPoSt) * [Move](#Move) * [MoveStorage](#MoveStorage) * [Process](#Process) @@ -854,6 +856,84 @@ Response: } ``` +### GenerateWindowPoSt + + +Perms: admin + +Inputs: +```json +[ + 1000, + { + "Spsi": null + }, + 123, + 123, + "Bw==", + { + "Fc": { + "Sectors": [ + 123, + 124 + ], + "Challenges": {} + } + } +] +``` + +Response: +```json +{ + "PoStProofs": { + "PoStProof": 8, + "ProofBytes": "Ynl0ZSBhcnJheQ==" + }, + "Skipped": [ + { + "Miner": 1000, + "Number": 9 + } + ] +} +``` + +### GenerateWinningPoSt + + +Perms: admin + +Inputs: +```json +[ + 1000, + { + "Spsi": null + }, + "Bw==", + { + "Fc": { + "Sectors": [ + 123, + 124 + ], + "Challenges": {} + } + } +] +``` + +Response: +```json +[ + { + "PoStProof": 8, + "ProofBytes": "Ynl0ZSBhcnJheQ==" + } +] +``` + ## Move diff --git a/documentation/en/cli-lotus-worker.md b/documentation/en/cli-lotus-worker.md index ac133f908..c295a6290 100644 --- a/documentation/en/cli-lotus-worker.md +++ b/documentation/en/cli-lotus-worker.md @@ -46,6 +46,8 @@ OPTIONS: --commit enable commit (32G sectors: all cores or GPUs, 128GiB Memory + 64GiB swap) (default: true) --parallel-fetch-limit value maximum fetch operations to run in parallel (default: 5) --timeout value used when 'listen' is unspecified. must be a valid duration recognized by golang's time.ParseDuration function (default: "30m") + --windowpost enable window post (default: false) + --winningpost enable winning post (default: false) --help, -h show help (default: false) ``` diff --git a/extern/sector-storage/stores/mocks/index.go b/extern/sector-storage/stores/mocks/index.go index 1eb29db5b..274052393 100644 --- a/extern/sector-storage/stores/mocks/index.go +++ b/extern/sector-storage/stores/mocks/index.go @@ -125,6 +125,21 @@ func (mr *MockSectorIndexMockRecorder) StorageGetLocks(arg0 interface{}) *gomock return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageGetLocks", reflect.TypeOf((*MockSectorIndex)(nil).StorageGetLocks), arg0) } +// StorageGetUrl mocks base method. +func (m *MockSectorIndex) StorageGetUrl(arg0 context.Context, arg1 abi.SectorID, arg2 storiface.SectorFileType) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StorageGetUrl", arg0, arg1, arg2) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StorageGetUrl indicates an expected call of StorageGetUrl. +func (mr *MockSectorIndexMockRecorder) StorageGetUrl(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageGetUrl", reflect.TypeOf((*MockSectorIndex)(nil).StorageGetUrl), arg0, arg1, arg2) +} + // StorageInfo mocks base method. func (m *MockSectorIndex) StorageInfo(arg0 context.Context, arg1 stores.ID) (stores.StorageInfo, error) { m.ctrl.T.Helper() @@ -197,18 +212,3 @@ func (mr *MockSectorIndexMockRecorder) StorageTryLock(arg0, arg1, arg2, arg3 int mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageTryLock", reflect.TypeOf((*MockSectorIndex)(nil).StorageTryLock), arg0, arg1, arg2, arg3) } - -// StorageGetUrl mocks base method. -func (m *MockSectorIndex) StorageGetUrl(ctx context.Context, s abi.SectorID, ft storiface.SectorFileType) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StorageGetUrl", ctx, s, ft) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StorageGetUrl indicates an expected call of StorageGetUrl. -func (mr *MockSectorIndexMockRecorder) StorageGetUrl(ctx, s, ft interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageGetUrl", reflect.TypeOf((*MockSectorIndex)(nil).StorageGetUrl), ctx, s, ft) -} diff --git a/extern/sector-storage/stores/mocks/store.go b/extern/sector-storage/stores/mocks/store.go index 3786e2a2e..4f0aa6827 100644 --- a/extern/sector-storage/stores/mocks/store.go +++ b/extern/sector-storage/stores/mocks/store.go @@ -8,9 +8,8 @@ import ( context "context" reflect "reflect" - ffi "github.com/filecoin-project/filecoin-ffi" abi "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" + ffiwrapper "github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper" fsutil "github.com/filecoin-project/lotus/extern/sector-storage/fsutil" stores "github.com/filecoin-project/lotus/extern/sector-storage/stores" storiface "github.com/filecoin-project/lotus/extern/sector-storage/storiface" @@ -57,6 +56,22 @@ func (mr *MockStoreMockRecorder) AcquireSector(arg0, arg1, arg2, arg3, arg4, arg return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireSector", reflect.TypeOf((*MockStore)(nil).AcquireSector), arg0, arg1, arg2, arg3, arg4, arg5) } +// AcquireSectorPaths mocks base method. +func (m *MockStore) AcquireSectorPaths(arg0 context.Context, arg1 storage.SectorRef, arg2, arg3 storiface.SectorFileType, arg4 storiface.PathType) (storiface.SectorPaths, storiface.SectorPaths, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AcquireSectorPaths", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(storiface.SectorPaths) + ret1, _ := ret[1].(storiface.SectorPaths) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// AcquireSectorPaths indicates an expected call of AcquireSectorPaths. +func (mr *MockStoreMockRecorder) AcquireSectorPaths(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireSectorPaths", reflect.TypeOf((*MockStore)(nil).AcquireSectorPaths), arg0, arg1, arg2, arg3, arg4) +} + // FsStat mocks base method. func (m *MockStore) FsStat(arg0 context.Context, arg1 stores.ID) (fsutil.FsStat, error) { m.ctrl.T.Helper() @@ -72,6 +87,21 @@ func (mr *MockStoreMockRecorder) FsStat(arg0, arg1 interface{}) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FsStat", reflect.TypeOf((*MockStore)(nil).FsStat), arg0, arg1) } +// GenerateSingleVanillaProof mocks base method. +func (m *MockStore) GenerateSingleVanillaProof(arg0 context.Context, arg1 abi.ActorID, arg2 *ffiwrapper.PrivateSectorInfo, arg3 []uint64) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateSingleVanillaProof", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateSingleVanillaProof indicates an expected call of GenerateSingleVanillaProof. +func (mr *MockStoreMockRecorder) GenerateSingleVanillaProof(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateSingleVanillaProof", reflect.TypeOf((*MockStore)(nil).GenerateSingleVanillaProof), arg0, arg1, arg2, arg3) +} + // MoveStorage mocks base method. func (m *MockStore) MoveStorage(arg0 context.Context, arg1 storage.SectorRef, arg2 storiface.SectorFileType) error { m.ctrl.T.Helper() @@ -128,64 +158,3 @@ func (mr *MockStoreMockRecorder) Reserve(arg0, arg1, arg2, arg3, arg4 interface{ mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reserve", reflect.TypeOf((*MockStore)(nil).Reserve), arg0, arg1, arg2, arg3, arg4) } - -// GenerateWindowPoStVanilla mocks base method. -func (m *MockStore) GenerateWindowPoStVanilla(ctx context.Context, minerID abi.ActorID, privsector *ffi.PrivateSectorInfo, vanillaParams string, randomness abi.PoStRandomness) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenerateWindowPoStVanilla", ctx, minerID, privsector, vanillaParams, randomness) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GenerateWindowPoStVanilla indicates an expected call of GenerateWindowPoStVanilla. -func (mr *MockStoreMockRecorder) GenerateWindowPoStVanilla(ctx, minerID, privsector, vanillaParams, randomness interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateWindowPoStVanilla", reflect.TypeOf((*MockStore)(nil).GenerateWindowPoStVanilla), ctx, minerID, privsector, vanillaParams, randomness) -} - -// GenerateWinningPoStVanilla mocks base method. -func (m *MockStore) GenerateWinningPoStVanilla(ctx context.Context, minerID abi.ActorID, privsector *ffi.PrivateSectorInfo, randomness abi.PoStRandomness) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenerateWinningPoStVanilla", ctx, minerID, privsector, randomness) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GenerateWinningPoStVanilla indicates an expected call of GenerateWinningPoStVanilla. -func (mr *MockStoreMockRecorder) GenerateWinningPoStVanilla(ctx, minerID, privsector, randomness interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateWinningPoStVanilla", reflect.TypeOf((*MockStore)(nil).GenerateWinningPoStVanilla), ctx, minerID, privsector, randomness) -} - -// AcquireSectorPaths mocks base method. -func (m *MockStore) AcquireSectorPaths(ctx context.Context, s storage.SectorRef, existing storiface.SectorFileType, allocate storiface.SectorFileType, sealing storiface.PathType) (storiface.SectorPaths, storiface.SectorPaths, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcquireSectorPaths", ctx, s, existing, allocate, sealing) - ret0, _ := ret[0].(storiface.SectorPaths) - ret1, _ := ret[1].(storiface.SectorPaths) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// AcquireSectorPaths indicates an expected call of AcquireSectorPaths. -func (mr *MockStoreMockRecorder) AcquireSectorPaths(ctx, s, existing, allocate, sealing interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireSectorPaths", reflect.TypeOf((*MockStore)(nil).AcquireSectorPaths), ctx, s, existing, allocate, sealing) -} - -// GenerateSingleVanillaProof mocks base method. -func (m *MockStore) GenerateSingleVanillaProof(ctx context.Context, minerID abi.ActorID, privsector *ffiwrapper.PrivateSectorInfo, challange []uint64) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GenerateSingleVanillaProof", ctx, minerID, privsector, challange) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GenerateSingleVanillaProof indicates an expected call of GenerateSingleVanillaProof. -func (mr *MockStoreMockRecorder) GenerateSingleVanillaProof(ctx, minerID, privsector, challange interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateSingleVanillaProof", reflect.TypeOf((*MockStore)(nil).GenerateSingleVanillaProof), ctx, minerID, privsector, challange) -}