139 lines
2.5 KiB
Go
139 lines
2.5 KiB
Go
package stores
|
|
|
|
import (
|
|
"fmt"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/specs-actors/actors/abi"
|
|
)
|
|
|
|
const (
|
|
FTUnsealed SectorFileType = 1 << iota
|
|
FTSealed
|
|
FTCache
|
|
|
|
FileTypes = iota
|
|
)
|
|
|
|
const (
|
|
FTNone SectorFileType = 0
|
|
)
|
|
|
|
var FSOverheadSeal = map[SectorFileType]int{ // 10x overheads
|
|
FTUnsealed: 10,
|
|
FTSealed: 10,
|
|
FTCache: 141, // 11 layers + D(2x ssize) + C + R
|
|
}
|
|
|
|
var FsOverheadFinalized = map[SectorFileType]int{
|
|
FTUnsealed: 10,
|
|
FTSealed: 10,
|
|
FTCache: 2,
|
|
}
|
|
|
|
type SectorFileType int
|
|
|
|
func (t SectorFileType) String() string {
|
|
switch t {
|
|
case FTUnsealed:
|
|
return "unsealed"
|
|
case FTSealed:
|
|
return "sealed"
|
|
case FTCache:
|
|
return "cache"
|
|
default:
|
|
return fmt.Sprintf("<unknown %d>", t)
|
|
}
|
|
}
|
|
|
|
func (t SectorFileType) Has(singleType SectorFileType) bool {
|
|
return t&singleType == singleType
|
|
}
|
|
|
|
func (t SectorFileType) SealSpaceUse(spt abi.RegisteredSealProof) (uint64, error) {
|
|
ssize, err := spt.SectorSize()
|
|
if err != nil {
|
|
return 0, xerrors.Errorf("getting sector size: %w", err)
|
|
}
|
|
|
|
var need uint64
|
|
for _, pathType := range PathTypes {
|
|
if !t.Has(pathType) {
|
|
continue
|
|
}
|
|
|
|
oh, ok := FSOverheadSeal[pathType]
|
|
if !ok {
|
|
return 0, xerrors.Errorf("no seal overhead info for %s", pathType)
|
|
}
|
|
|
|
need += uint64(oh) * uint64(ssize) / 10
|
|
}
|
|
|
|
return need, nil
|
|
}
|
|
|
|
func (t SectorFileType) All() [FileTypes]bool {
|
|
var out [FileTypes]bool
|
|
|
|
for i := range out {
|
|
out[i] = t&(1<<i) > 0
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
type SectorPaths struct {
|
|
Id abi.SectorID
|
|
|
|
Unsealed string
|
|
Sealed string
|
|
Cache string
|
|
}
|
|
|
|
func ParseSectorID(baseName string) (abi.SectorID, error) {
|
|
var n abi.SectorNumber
|
|
var mid abi.ActorID
|
|
read, err := fmt.Sscanf(baseName, "s-t0%d-%d", &mid, &n)
|
|
if err != nil {
|
|
return abi.SectorID{}, xerrors.Errorf("sscanf sector name ('%s'): %w", baseName, err)
|
|
}
|
|
|
|
if read != 2 {
|
|
return abi.SectorID{}, xerrors.Errorf("parseSectorID expected to scan 2 values, got %d", read)
|
|
}
|
|
|
|
return abi.SectorID{
|
|
Miner: mid,
|
|
Number: n,
|
|
}, nil
|
|
}
|
|
|
|
func SectorName(sid abi.SectorID) string {
|
|
return fmt.Sprintf("s-t0%d-%d", sid.Miner, sid.Number)
|
|
}
|
|
|
|
func PathByType(sps SectorPaths, fileType SectorFileType) string {
|
|
switch fileType {
|
|
case FTUnsealed:
|
|
return sps.Unsealed
|
|
case FTSealed:
|
|
return sps.Sealed
|
|
case FTCache:
|
|
return sps.Cache
|
|
}
|
|
|
|
panic("requested unknown path type")
|
|
}
|
|
|
|
func SetPathByType(sps *SectorPaths, fileType SectorFileType, p string) {
|
|
switch fileType {
|
|
case FTUnsealed:
|
|
sps.Unsealed = p
|
|
case FTSealed:
|
|
sps.Sealed = p
|
|
case FTCache:
|
|
sps.Cache = p
|
|
}
|
|
}
|