139 lines
4.0 KiB
Go
139 lines
4.0 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"github.com/filecoin-project/lotus/lib/statestore"
|
|
"github.com/ipfs/go-datastore/namespace"
|
|
"sync"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
"github.com/ipfs/go-datastore"
|
|
logging "github.com/ipfs/go-log"
|
|
"github.com/libp2p/go-libp2p-core/host"
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/chain/address"
|
|
"github.com/filecoin-project/lotus/chain/events"
|
|
"github.com/filecoin-project/lotus/chain/store"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/storage/sector"
|
|
)
|
|
|
|
var log = logging.Logger("storageminer")
|
|
|
|
const PoStConfidence = 3
|
|
|
|
type Miner struct {
|
|
api storageMinerApi
|
|
events *events.Events
|
|
h host.Host
|
|
secst *sector.Store
|
|
|
|
maddr address.Address
|
|
worker address.Address
|
|
|
|
// PoSt
|
|
postLk sync.Mutex
|
|
schedPost uint64
|
|
|
|
// Sealing
|
|
sectors *statestore.StateStore
|
|
|
|
sectorIncoming chan *SectorInfo
|
|
sectorUpdated chan sectorUpdate
|
|
stop chan struct{}
|
|
stopped chan struct{}
|
|
}
|
|
|
|
type storageMinerApi interface {
|
|
// I think I want this... but this is tricky
|
|
//ReadState(ctx context.Context, addr address.Address) (????, error)
|
|
|
|
// Call a read only method on actors (no interaction with the chain required)
|
|
StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error)
|
|
StateMinerWorker(context.Context, address.Address, *types.TipSet) (address.Address, error)
|
|
StateMinerProvingPeriodEnd(context.Context, address.Address, *types.TipSet) (uint64, error)
|
|
StateMinerSectors(context.Context, address.Address, *types.TipSet) ([]*api.SectorInfo, error)
|
|
StateMinerProvingSet(context.Context, address.Address, *types.TipSet) ([]*api.SectorInfo, error)
|
|
StateMinerSectorSize(context.Context, address.Address, *types.TipSet) (uint64, error)
|
|
StateWaitMsg(context.Context, cid.Cid) (*api.MsgWait, error)
|
|
|
|
MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
|
|
|
|
ChainHead(context.Context) (*types.TipSet, error)
|
|
ChainNotify(context.Context) (<-chan []*store.HeadChange, error)
|
|
ChainGetRandomness(context.Context, *types.TipSet, []*types.Ticket, int) ([]byte, error)
|
|
ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
|
|
ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
|
|
|
|
WalletSign(context.Context, address.Address, []byte) (*types.Signature, error)
|
|
WalletBalance(context.Context, address.Address) (types.BigInt, error)
|
|
WalletHas(context.Context, address.Address) (bool, error)
|
|
}
|
|
|
|
func NewMiner(api storageMinerApi, addr address.Address, h host.Host, ds datastore.Batching, secst *sector.Store) (*Miner, error) {
|
|
return &Miner{
|
|
api: api,
|
|
|
|
maddr: addr,
|
|
h: h,
|
|
secst: secst,
|
|
|
|
sectors: statestore.New(namespace.Wrap(ds, datastore.NewKey("/sectors"))),
|
|
|
|
sectorIncoming: make(chan *SectorInfo),
|
|
sectorUpdated: make(chan sectorUpdate),
|
|
stop: make(chan struct{}),
|
|
stopped: make(chan struct{}),
|
|
}, nil
|
|
}
|
|
|
|
func (m *Miner) Run(ctx context.Context) error {
|
|
if err := m.runPreflightChecks(ctx); err != nil {
|
|
return errors.Wrap(err, "miner preflight checks failed")
|
|
}
|
|
|
|
m.events = events.NewEvents(ctx, m.api)
|
|
|
|
go m.beginPosting(ctx)
|
|
go m.sectorStateLoop(ctx)
|
|
return nil
|
|
}
|
|
|
|
func (m *Miner) Stop(ctx context.Context) error {
|
|
close(m.stop)
|
|
select {
|
|
case <-m.stopped:
|
|
return nil
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
}
|
|
}
|
|
|
|
func (m *Miner) runPreflightChecks(ctx context.Context) error {
|
|
worker, err := m.api.StateMinerWorker(ctx, m.maddr, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
m.worker = worker
|
|
|
|
has, err := m.api.WalletHas(ctx, worker)
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to check wallet for worker key")
|
|
}
|
|
|
|
if !has {
|
|
return errors.New("key for worker not found in local wallet")
|
|
}
|
|
|
|
log.Infof("starting up miner %s, worker addr %s", m.maddr, m.worker)
|
|
return nil
|
|
}
|
|
|
|
func (m *Miner) SectorSize(ctx context.Context) (uint64, error) {
|
|
// TODO: cache this
|
|
return m.api.StateMinerSectorSize(ctx, m.maddr, nil)
|
|
}
|