791 lines
22 KiB
Go
791 lines
22 KiB
Go
package processor
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/lotus/chain/events/state"
|
|
"github.com/filecoin-project/specs-actors/actors/abi"
|
|
"golang.org/x/sync/errgroup"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
|
|
|
"github.com/filecoin-project/specs-actors/actors/abi/big"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin/miner"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin/power"
|
|
"github.com/filecoin-project/specs-actors/actors/util/adt"
|
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
|
|
)
|
|
|
|
func (p *Processor) setupMiners() error {
|
|
tx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`
|
|
|
|
create table if not exists miner_info
|
|
(
|
|
miner_id text not null,
|
|
owner_addr text not null,
|
|
worker_addr text not null,
|
|
peer_id text,
|
|
sector_size text not null,
|
|
|
|
precommit_deposits text not null,
|
|
locked_funds text not null,
|
|
next_deadline_process_faults bigint not null,
|
|
constraint miner_info_pk
|
|
primary key (miner_id)
|
|
);
|
|
|
|
/*
|
|
* captures miner-specific power state for any given stateroot
|
|
*/
|
|
create table if not exists miner_power
|
|
(
|
|
miner_id text not null,
|
|
state_root text not null,
|
|
raw_bytes_power text not null,
|
|
quality_adjusted_power text not null,
|
|
constraint miner_power_pk
|
|
primary key (miner_id, state_root)
|
|
);
|
|
|
|
create table if not exists miner_precommits
|
|
(
|
|
miner_id text not null,
|
|
sector_id bigint not null,
|
|
|
|
precommit_deposit text not null,
|
|
precommit_epoch text not null,
|
|
constraint miner_precommits_pk
|
|
primary key (miner_id, sector_id)
|
|
|
|
);
|
|
|
|
create table if not exists miner_sectors
|
|
(
|
|
miner_id text not null,
|
|
sector_id bigint not null,
|
|
|
|
activation_epoch bigint not null,
|
|
expiration_epoch bigint not null,
|
|
termination_epoch bigint,
|
|
|
|
deal_weight text not null,
|
|
verified_deal_weight text not null,
|
|
seal_cid text not null,
|
|
seal_rand_epoch bigint not null,
|
|
constraint miner_sectors_pk
|
|
primary key (miner_id, sector_id)
|
|
);
|
|
|
|
/* used to tell when a miners sectors (proven-not-yet-expired) changed if the miner_sectors_cid's are different a new sector was added or removed (terminated/expired) */
|
|
create table if not exists miner_sectors_heads
|
|
(
|
|
miner_id text not null,
|
|
miner_sectors_cid text not null,
|
|
|
|
state_root text not null,
|
|
|
|
constraint miner_sectors_heads_pk
|
|
primary key (miner_id,miner_sectors_cid)
|
|
|
|
);
|
|
|
|
|
|
DO $$
|
|
BEGIN
|
|
IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'miner_sector_event_type') THEN
|
|
CREATE TYPE miner_sector_event_type AS ENUM
|
|
(
|
|
'PRECOMMIT', 'COMMIT', 'EXTENDED', 'EXPIRED', 'TERMINATED'
|
|
);
|
|
END IF;
|
|
END$$;
|
|
|
|
create table if not exists miner_sector_events
|
|
(
|
|
miner_id text not null,
|
|
sector_id bigint not null,
|
|
state_root text not null,
|
|
event miner_sector_event_type not null,
|
|
|
|
constraint miner_sector_events_pk
|
|
primary key (sector_id, event, miner_id, state_root)
|
|
);
|
|
|
|
create materialized view if not exists miner_sectors_view as
|
|
select ms.miner_id, ms.sector_id, mp.precommit_epoch, ms.activation_epoch, ms.expiration_epoch, ms.termination_epoch, ms.deal_weight, ms.verified_deal_weight
|
|
from miner_sectors ms
|
|
left join miner_precommits mp on ms.sector_id = mp.sector_id and ms.miner_id = mp.miner_id
|
|
|
|
`); err != nil {
|
|
return err
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
type minerActorInfo struct {
|
|
common actorInfo
|
|
|
|
state miner.State
|
|
|
|
// tracked by power actor
|
|
rawPower big.Int
|
|
qalPower big.Int
|
|
}
|
|
|
|
type sectorUpdate struct {
|
|
terminationEpoch abi.ChainEpoch
|
|
terminated bool
|
|
|
|
expirationEpoch abi.ChainEpoch
|
|
|
|
sectorID abi.SectorNumber
|
|
minerID address.Address
|
|
}
|
|
|
|
func (p *Processor) HandleMinerChanges(ctx context.Context, minerTips ActorTips) error {
|
|
minerChanges, err := p.processMiners(ctx, minerTips)
|
|
if err != nil {
|
|
log.Fatalw("Failed to process miner actors", "error", err)
|
|
}
|
|
|
|
if err := p.persistMiners(ctx, minerChanges); err != nil {
|
|
log.Fatalw("Failed to persist miner actors", "error", err)
|
|
}
|
|
|
|
if err := p.updateMiners(ctx, minerChanges); err != nil {
|
|
log.Fatalw("Failed to update miner actors", "error", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Processor) processMiners(ctx context.Context, minerTips map[types.TipSetKey][]actorInfo) ([]minerActorInfo, error) {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Processed Miners", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
var out []minerActorInfo
|
|
// TODO add parallel calls if this becomes slow
|
|
for tipset, miners := range minerTips {
|
|
// get the power actors claims map
|
|
minersClaims, err := getPowerActorClaimsMap(ctx, p.node, tipset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Get miner raw and quality power
|
|
for _, act := range miners {
|
|
var mi minerActorInfo
|
|
mi.common = act
|
|
|
|
var claim power.Claim
|
|
// get miner claim from power actors claim map and store if found, else the miner had no claim at
|
|
// this tipset
|
|
found, err := minersClaims.Get(adt.AddrKey(act.addr), &claim)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if found {
|
|
mi.qalPower = claim.QualityAdjPower
|
|
mi.rawPower = claim.RawBytePower
|
|
}
|
|
|
|
// Get the miner state info
|
|
astb, err := p.node.ChainReadObj(ctx, act.act.Head)
|
|
if err != nil {
|
|
log.Warnw("failed to find miner actor state", "address", act.addr, "error", err)
|
|
continue
|
|
}
|
|
if err := mi.state.UnmarshalCBOR(bytes.NewReader(astb)); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, mi)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (p *Processor) persistMiners(ctx context.Context, miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Persisted Miners", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
grp, _ := errgroup.WithContext(ctx)
|
|
|
|
grp.Go(func() error {
|
|
if err := p.storeMinersActorState(miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
grp.Go(func() error {
|
|
if err := p.storeMinersPower(miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
grp.Go(func() error {
|
|
if err := p.storeMinersSectorState(ctx, miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
grp.Go(func() error {
|
|
if err := p.storeMinersSectorHeads(miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
grp.Go(func() error {
|
|
if err := p.storeMinersPreCommitState(ctx, miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
return grp.Wait()
|
|
}
|
|
|
|
func (p *Processor) storeMinersActorState(miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Stored Miners Actor State", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
tx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`create temp table mi (like miner_info excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
stmt, err := tx.Prepare(`copy mi (miner_id, owner_addr, worker_addr, peer_id, sector_size, precommit_deposits, locked_funds, next_deadline_process_faults) from STDIN`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, m := range miners {
|
|
var pid string
|
|
if len(m.state.Info.PeerId) != 0 {
|
|
peerid, err := peer.IDFromBytes(m.state.Info.PeerId)
|
|
if err != nil {
|
|
// this should "never happen", but if it does we should still store info about the miner.
|
|
log.Warnw("failed to decode peerID", "peerID (bytes)", m.state.Info.PeerId, "miner", m.common.addr, "tipset", m.common.tsKey.String())
|
|
} else {
|
|
pid = peerid.String()
|
|
}
|
|
}
|
|
if _, err := stmt.Exec(
|
|
m.common.addr.String(),
|
|
m.state.Info.Owner.String(),
|
|
m.state.Info.Worker.String(),
|
|
pid,
|
|
m.state.Info.SectorSize.ShortString(),
|
|
m.state.PreCommitDeposits.String(),
|
|
m.state.LockedFunds.String(),
|
|
m.state.NextDeadlineToProcessFaults,
|
|
); err != nil {
|
|
log.Errorw("failed to store miner state", "state", m.state, "info", m.state.Info, "error", err)
|
|
return xerrors.Errorf("failed to store miner state: %w", err)
|
|
}
|
|
|
|
}
|
|
if err := stmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`insert into miner_info select * from mi on conflict do nothing `); err != nil {
|
|
return xerrors.Errorf("actor put: %w", err)
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (p *Processor) storeMinersPower(miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Stored Miners Power", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
tx, err := p.db.Begin()
|
|
if err != nil {
|
|
return xerrors.Errorf("begin miner_power tx: %w", err)
|
|
}
|
|
|
|
if _, err := tx.Exec(`create temp table mp (like miner_power excluding constraints) on commit drop`); err != nil {
|
|
return xerrors.Errorf("prep miner_power temp: %w", err)
|
|
}
|
|
|
|
stmt, err := tx.Prepare(`copy mp (miner_id, state_root, raw_bytes_power, quality_adjusted_power) from STDIN`)
|
|
if err != nil {
|
|
return xerrors.Errorf("prepare tmp miner_power: %w", err)
|
|
}
|
|
|
|
for _, m := range miners {
|
|
if _, err := stmt.Exec(
|
|
m.common.addr.String(),
|
|
m.common.stateroot.String(),
|
|
m.rawPower.String(),
|
|
m.qalPower.String(),
|
|
); err != nil {
|
|
log.Errorw("failed to store miner power", "miner", m.common.addr, "stateroot", m.common.stateroot, "error", err)
|
|
}
|
|
}
|
|
|
|
if err := stmt.Close(); err != nil {
|
|
return xerrors.Errorf("close prepared miner_power: %w", err)
|
|
}
|
|
|
|
if _, err := tx.Exec(`insert into miner_power select * from mp on conflict do nothing`); err != nil {
|
|
return xerrors.Errorf("insert miner_power from tmp: %w", err)
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return xerrors.Errorf("commit miner_power tx: %w", err)
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (p *Processor) storeMinersSectorState(ctx context.Context, miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Stored Miners Sector State", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
tx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`create temp table ms (like miner_sectors excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
stmt, err := tx.Prepare(`copy ms (miner_id, sector_id, activation_epoch, expiration_epoch, deal_weight, verified_deal_weight, seal_cid, seal_rand_epoch) from STDIN`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
grp, ctx := errgroup.WithContext(ctx)
|
|
for _, m := range miners {
|
|
m := m
|
|
grp.Go(func() error {
|
|
sectors, err := p.node.StateMinerSectors(ctx, m.common.addr, nil, true, m.common.tsKey)
|
|
if err != nil {
|
|
log.Debugw("Failed to load sectors", "tipset", m.common.tsKey.String(), "miner", m.common.addr.String(), "error", err)
|
|
}
|
|
|
|
for _, sector := range sectors {
|
|
if _, err := stmt.Exec(
|
|
m.common.addr.String(),
|
|
uint64(sector.ID),
|
|
int64(sector.Info.ActivationEpoch),
|
|
int64(sector.Info.Info.Expiration),
|
|
sector.Info.DealWeight.String(),
|
|
sector.Info.VerifiedDealWeight.String(),
|
|
sector.Info.Info.SealedCID.String(),
|
|
int64(sector.Info.Info.SealRandEpoch),
|
|
); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
if err := grp.Wait(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := stmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`insert into miner_sectors select * from ms on conflict do nothing `); err != nil {
|
|
return xerrors.Errorf("actor put: %w", err)
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (p *Processor) storeMinersSectorHeads(miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Stored Miners Sector Heads", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
tx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`create temp table msh (like miner_sectors_heads excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
stmt, err := tx.Prepare(`copy msh (miner_id, miner_sectors_cid, state_root) from STDIN`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, m := range miners {
|
|
if _, err := stmt.Exec(
|
|
m.common.addr.String(),
|
|
m.state.Sectors.String(),
|
|
m.common.stateroot.String(),
|
|
); err != nil {
|
|
log.Errorw("failed to store miners sectors head", "state", m.state, "info", m.state.Info, "error", err)
|
|
return err
|
|
}
|
|
|
|
}
|
|
if err := stmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := tx.Exec(`insert into miner_sectors_heads select * from msh on conflict do nothing `); err != nil {
|
|
return xerrors.Errorf("actor put: %w", err)
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (p *Processor) storeMinersPreCommitState(ctx context.Context, miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Infow("Stored Miners Precommit State", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
precommitTx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := precommitTx.Exec(`create temp table mp (like miner_precommits excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
precommitStmt, err := precommitTx.Prepare(`copy mp (miner_id, sector_id, precommit_deposit, precommit_epoch) from STDIN`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, m := range miners {
|
|
m := m
|
|
pcMap, err := adt.AsMap(cw_util.NewAPIIpldStore(ctx, p.node), m.state.PreCommittedSectors)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
precommit := new(miner.SectorPreCommitOnChainInfo)
|
|
if err := pcMap.ForEach(precommit, func(key string) error {
|
|
if _, err := precommitStmt.Exec(
|
|
m.common.addr.String(),
|
|
precommit.Info.SectorNumber,
|
|
precommit.PreCommitDeposit.String(),
|
|
precommit.PreCommitEpoch,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := precommitStmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
if _, err := precommitTx.Exec(`insert into miner_precommits select * from mp on conflict do nothing`); err != nil {
|
|
return err
|
|
}
|
|
|
|
return precommitTx.Commit()
|
|
}
|
|
|
|
func (p *Processor) updateMiners(ctx context.Context, miners []minerActorInfo) error {
|
|
// TODO when/if there is more than one update operation here use an errgroup as is done in persistMiners
|
|
if err := p.updateMinersSectors(ctx, miners); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := p.updateMinersPrecommits(ctx, miners); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Processor) updateMinersPrecommits(ctx context.Context, miners []minerActorInfo) error {
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Infow("Updated Miner Precommits", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
pred := state.NewStatePredicates(p.node)
|
|
|
|
eventTx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := eventTx.Exec(`create temp table mse (like miner_sector_events excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
eventStmt, err := eventTx.Prepare(`copy mse (sector_id, event, miner_id, state_root) from STDIN `)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, m := range miners {
|
|
pcDiffFn := pred.OnMinerActorChange(m.common.addr, pred.OnMinerPreCommitChange())
|
|
changed, val, err := pcDiffFn(ctx, m.common.parentTsKey, m.common.tsKey)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "address not found") {
|
|
continue
|
|
}
|
|
log.Errorw("error getting miner precommit diff", "miner", m.common.addr, "error", err)
|
|
return err
|
|
}
|
|
if !changed {
|
|
continue
|
|
}
|
|
changes, ok := val.(*state.MinerPreCommitChanges)
|
|
if !ok {
|
|
log.Fatal("Developer Error")
|
|
}
|
|
for _, added := range changes.Added {
|
|
if _, err := eventStmt.Exec(added.Info.SectorNumber, "PRECOMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := eventStmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := eventTx.Exec(`insert into miner_sector_events select * from mse on conflict do nothing `); err != nil {
|
|
return xerrors.Errorf("actor put: %w", err)
|
|
}
|
|
|
|
return eventTx.Commit()
|
|
}
|
|
|
|
func (p *Processor) updateMinersSectors(ctx context.Context, miners []minerActorInfo) error {
|
|
log.Debugw("Updating Miners Sectors", "#miners", len(miners))
|
|
start := time.Now()
|
|
defer func() {
|
|
log.Debugw("Updated Miners Sectors", "duration", time.Since(start).String())
|
|
}()
|
|
|
|
pred := state.NewStatePredicates(p.node)
|
|
|
|
eventTx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := eventTx.Exec(`create temp table mse (like miner_sector_events excluding constraints) on commit drop;`); err != nil {
|
|
return xerrors.Errorf("prep temp: %w", err)
|
|
}
|
|
|
|
eventStmt, err := eventTx.Prepare(`copy mse (sector_id, event, miner_id, state_root) from STDIN `)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var updateWg sync.WaitGroup
|
|
updateWg.Add(1)
|
|
sectorUpdatesCh := make(chan sectorUpdate)
|
|
var sectorUpdates []sectorUpdate
|
|
go func() {
|
|
for u := range sectorUpdatesCh {
|
|
sectorUpdates = append(sectorUpdates, u)
|
|
}
|
|
updateWg.Done()
|
|
}()
|
|
|
|
minerGrp, ctx := errgroup.WithContext(ctx)
|
|
complete := 0
|
|
for _, m := range miners {
|
|
m := m
|
|
if m.common.tsKey == p.genesisTs.Key() {
|
|
genSectors, err := p.node.StateMinerSectors(ctx, m.common.addr, nil, true, p.genesisTs.Key())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, sector := range genSectors {
|
|
if _, err := eventStmt.Exec(sector.ID, "COMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
complete++
|
|
continue
|
|
}
|
|
minerGrp.Go(func() error {
|
|
// special case genesis miners
|
|
sectorDiffFn := pred.OnMinerActorChange(m.common.addr, pred.OnMinerSectorChange())
|
|
changed, val, err := sectorDiffFn(ctx, m.common.parentTsKey, m.common.tsKey)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "address not found") {
|
|
return nil
|
|
}
|
|
log.Errorw("error getting miner sector diff", "miner", m.common.addr, "error", err)
|
|
return err
|
|
}
|
|
if !changed {
|
|
complete++
|
|
return nil
|
|
}
|
|
changes, ok := val.(*state.MinerSectorChanges)
|
|
if !ok {
|
|
log.Fatalw("Developer Error")
|
|
}
|
|
log.Debugw("sector changes for miner", "miner", m.common.addr.String(), "Added", len(changes.Added), "Extended", len(changes.Extended), "Removed", len(changes.Removed), "oldState", m.common.parentTsKey, "newState", m.common.tsKey)
|
|
|
|
for _, extended := range changes.Extended {
|
|
if _, err := eventStmt.Exec(extended.To.Info.SectorNumber, "EXTENDED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
sectorUpdatesCh <- sectorUpdate{
|
|
terminationEpoch: 0,
|
|
terminated: false,
|
|
expirationEpoch: extended.To.Info.Expiration,
|
|
sectorID: extended.From.Info.SectorNumber,
|
|
minerID: m.common.addr,
|
|
}
|
|
|
|
log.Debugw("sector extended", "miner", m.common.addr.String(), "sector", extended.To.Info.SectorNumber, "old", extended.To.Info.Expiration, "new", extended.From.Info.Expiration)
|
|
}
|
|
curTs, err := p.node.ChainGetTipSet(ctx, m.common.tsKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, removed := range changes.Removed {
|
|
log.Debugw("removed", "miner", m.common.addr)
|
|
// decide if they were terminated or extended
|
|
if removed.Info.Expiration > curTs.Height() {
|
|
if _, err := eventStmt.Exec(removed.Info.SectorNumber, "TERMINATED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
log.Debugw("sector terminated", "miner", m.common.addr.String(), "sector", removed.Info.SectorNumber, "old", "sectorExpiration", removed.Info.Expiration, "terminationEpoch", curTs.Height())
|
|
sectorUpdatesCh <- sectorUpdate{
|
|
terminationEpoch: curTs.Height(),
|
|
terminated: true,
|
|
expirationEpoch: removed.Info.Expiration,
|
|
sectorID: removed.Info.SectorNumber,
|
|
minerID: m.common.addr,
|
|
}
|
|
|
|
}
|
|
if _, err := eventStmt.Exec(removed.Info.SectorNumber, "EXPIRED", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
log.Debugw("sector removed", "miner", m.common.addr.String(), "sector", removed.Info.SectorNumber, "old", "sectorExpiration", removed.Info.Expiration, "currEpoch", curTs.Height())
|
|
}
|
|
|
|
for _, added := range changes.Added {
|
|
if _, err := eventStmt.Exec(added.Info.SectorNumber, "COMMIT", m.common.addr.String(), m.common.stateroot.String()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
complete++
|
|
log.Debugw("Update Done", "complete", complete, "added", len(changes.Added), "removed", len(changes.Removed), "modified", len(changes.Extended))
|
|
return nil
|
|
})
|
|
}
|
|
if err := minerGrp.Wait(); err != nil {
|
|
return err
|
|
}
|
|
close(sectorUpdatesCh)
|
|
// wait for the update channel to be drained
|
|
updateWg.Wait()
|
|
|
|
if err := eventStmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := eventTx.Exec(`insert into miner_sector_events select * from mse on conflict do nothing `); err != nil {
|
|
return xerrors.Errorf("actor put: %w", err)
|
|
}
|
|
|
|
if err := eventTx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
updateTx, err := p.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
updateStmt, err := updateTx.Prepare(`UPDATE miner_sectors SET termination_epoch=$1, expiration_epoch=$2 WHERE miner_id=$3 AND sector_id=$4`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, update := range sectorUpdates {
|
|
if update.terminated {
|
|
if _, err := updateStmt.Exec(update.terminationEpoch, update.expirationEpoch, update.minerID.String(), update.sectorID); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if _, err := updateStmt.Exec(nil, update.expirationEpoch, update.minerID.String(), update.sectorID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := updateStmt.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return updateTx.Commit()
|
|
}
|
|
|
|
// load the power actor state clam as an adt.Map at the tipset `ts`.
|
|
func getPowerActorClaimsMap(ctx context.Context, api api.FullNode, ts types.TipSetKey) (*adt.Map, error) {
|
|
powerActor, err := api.StateGetActor(ctx, builtin.StoragePowerActorAddr, ts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
powerRaw, err := api.ChainReadObj(ctx, powerActor.Head)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var powerActorState power.State
|
|
if err := powerActorState.UnmarshalCBOR(bytes.NewReader(powerRaw)); err != nil {
|
|
return nil, fmt.Errorf("failed to unmarshal power actor state: %w", err)
|
|
}
|
|
|
|
s := cw_util.NewAPIIpldStore(ctx, api)
|
|
return adt.AsMap(s, powerActorState.Claims)
|
|
}
|