146 lines
3.2 KiB
Go
146 lines
3.2 KiB
Go
package lpmessage
|
|
|
|
import (
|
|
"context"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/lib/harmony/harmonydb"
|
|
"github.com/filecoin-project/lotus/lib/harmony/harmonytask"
|
|
"github.com/filecoin-project/lotus/provider/chainsched"
|
|
"sync/atomic"
|
|
)
|
|
|
|
/*
|
|
create table message_waits (
|
|
|
|
signed_message_cid text primary key references message_sends (signed_cid),
|
|
waiter_machine_id int references harmony_machines (id) on delete set null,
|
|
|
|
executed_tsk_cid text,
|
|
executed_tsk_epoch bigint,
|
|
executed_msg_cid text,
|
|
executed_msg_data jsonb,
|
|
|
|
executed_rcpt_exitcode bigint,
|
|
executed_rcpt_return bytea,
|
|
executed_rcpt_gas_used bigint
|
|
|
|
)
|
|
|
|
create table message_sends
|
|
(
|
|
|
|
from_key text not null,
|
|
to_addr text not null,
|
|
send_reason text not null,
|
|
send_task_id bigint not null,
|
|
|
|
unsigned_data bytea not null,
|
|
unsigned_cid text not null,
|
|
|
|
nonce bigint,
|
|
signed_data bytea,
|
|
signed_json jsonb,
|
|
signed_cid text,
|
|
|
|
send_time timestamp default null,
|
|
send_success boolean default null,
|
|
send_error text,
|
|
|
|
constraint message_sends_pk
|
|
primary key (send_task_id, from_key)
|
|
|
|
);
|
|
*/
|
|
type MessageWaiter struct {
|
|
db *harmonydb.DB
|
|
ht *harmonytask.TaskEngine
|
|
|
|
stopping, stopped chan struct{}
|
|
|
|
updateCh chan struct{}
|
|
bestTs atomic.Pointer[types.TipSetKey]
|
|
}
|
|
|
|
func NewMessageWaiter(db *harmonydb.DB, ht *harmonytask.TaskEngine, pcs *chainsched.ProviderChainSched) (*MessageWaiter, error) {
|
|
mw := &MessageWaiter{
|
|
db: db,
|
|
ht: ht,
|
|
stopping: make(chan struct{}),
|
|
stopped: make(chan struct{}),
|
|
updateCh: make(chan struct{}),
|
|
}
|
|
mw.run()
|
|
if err := pcs.AddHandler(mw.processHeadChange); err != nil {
|
|
return nil, err
|
|
}
|
|
return mw, nil
|
|
}
|
|
|
|
func (mw *MessageWaiter) run() {
|
|
defer close(mw.stopped)
|
|
|
|
for {
|
|
select {
|
|
case <-mw.stopping:
|
|
// todo cleanup assignments
|
|
return
|
|
case <-mw.updateCh:
|
|
mw.update()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (mw *MessageWaiter) update() {
|
|
ctx := context.Background()
|
|
|
|
tsk := *mw.bestTs.Load()
|
|
|
|
machineID := mw.ht.ResourcesAvailable().MachineID
|
|
|
|
// first if we see pending messages with null owner, assign them to ourselves
|
|
{
|
|
n, err := mw.db.Exec(ctx, `UPDATE message_waits SET owner_machine_id = $1 WHERE owner_machine_id IS NULL AND executed_tsk_cid IS NULL`, machineID)
|
|
if err != nil {
|
|
log.Errorf("failed to assign pending messages: %+v", err)
|
|
return
|
|
}
|
|
if n > 0 {
|
|
log.Debugw("assigned pending messages to ourselves", "assigned", n)
|
|
}
|
|
}
|
|
|
|
// get messages assigned to us
|
|
var msgs []struct {
|
|
Cid string
|
|
Nonce uint64
|
|
}
|
|
|
|
// really large limit in case of things getting stuck and backlogging severely
|
|
err := mw.db.Select(ctx, &msgs, `SELECT signed_message_cid FROM message_waits WHERE owner_machine_id = $1 LIMIT 10000`, machineID)
|
|
if err != nil {
|
|
log.Errorf("failed to get assigned messages: %+v", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (mw *MessageWaiter) Stop(ctx context.Context) error {
|
|
close(mw.stopping)
|
|
select {
|
|
case <-mw.stopped:
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (mw *MessageWaiter) processHeadChange(ctx context.Context, revert *types.TipSet, apply *types.TipSet) error {
|
|
best := apply.Key()
|
|
mw.bestTs.Store(&best)
|
|
select {
|
|
case mw.updateCh <- struct{}{}:
|
|
default:
|
|
}
|
|
return nil
|
|
}
|