197 lines
5.6 KiB
Go
197 lines
5.6 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"math/rand"
|
|
"time"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/go-fil-markets/storagemarket"
|
|
"github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/node/impl"
|
|
"github.com/ipfs/go-cid"
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
|
)
|
|
|
|
// This is the basline test; Filecoin 101.
|
|
//
|
|
// A network with a bootstrapper, a number of miners, and a number of clients/full nodes
|
|
// is constructed and connected through the bootstrapper.
|
|
// Some funds are allocated to each node and a number of sectors are presealed in the genesis block.
|
|
//
|
|
// The test plan:
|
|
// One or more clients store content to one or more miners, testing storage deals.
|
|
// The plan ensures that the storage deals hit the blockchain and measure the time it took.
|
|
// Verification: one or more clients retrieve and verify the hashes of stored content.
|
|
// The plan ensures that all (previously) published content can be correctly retrieved
|
|
// and measures the time it took.
|
|
//
|
|
// Preparation of the genesis block: this is the responsibility of the bootstrapper.
|
|
// In order to compute the genesis block, we need to collect identities and presealed
|
|
// sectors from each node.
|
|
// The we create a genesis block that allocates some funds to each node and collects
|
|
// the presealed sectors.
|
|
var baselineRoles = map[string]func(*TestEnvironment) error{
|
|
"bootstrapper": runBaselineBootstrapper,
|
|
"miner": runBaselineMiner,
|
|
"client": runBaselineClient,
|
|
}
|
|
|
|
func runBaselineBootstrapper(t *TestEnvironment) error {
|
|
t.RecordMessage("running bootstrapper")
|
|
_, err := prepareBootstrapper(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ctx := context.Background()
|
|
t.SyncClient.MustSignalAndWait(ctx, stateDone, t.TestInstanceCount)
|
|
return nil
|
|
}
|
|
|
|
func runBaselineMiner(t *TestEnvironment) error {
|
|
t.RecordMessage("running miner")
|
|
_, err := prepareMiner(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ctx := context.Background()
|
|
addrs, err := collectClientsAddrs(t, ctx, t.IntParam("clients"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
t.RecordMessage("got %v client addrs", len(addrs))
|
|
|
|
// mine / stop mining
|
|
//mine := true
|
|
//done := make(chan struct{})
|
|
//go func() {
|
|
//defer close(done)
|
|
//for mine {
|
|
//time.Sleep(blocktime)
|
|
//if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
|
|
//t.Error(err)
|
|
//}
|
|
//}
|
|
//}()
|
|
//makeDeal(t, ctx, 6, client, miner, carExport)
|
|
//mine = false
|
|
//fmt.Println("shutting down mining")
|
|
//<-done
|
|
|
|
// TODO wait a bit for network to bootstrap
|
|
// TODO just wait until completion of test, serving requests -- the client does all the job
|
|
|
|
t.SyncClient.MustSignalAndWait(ctx, stateDone, t.TestInstanceCount)
|
|
return nil
|
|
}
|
|
|
|
func runBaselineClient(t *TestEnvironment) error {
|
|
t.RecordMessage("running client")
|
|
cl, err := prepareClient(t)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ctx := context.Background()
|
|
addrs, err := collectMinersAddrs(t, ctx, t.IntParam("miners"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
client := cl.fullApi.(*impl.FullNodeAPI)
|
|
|
|
t.RecordMessage("got %v miner addrs", len(addrs))
|
|
|
|
if err := client.NetConnect(ctx, addrs[0].PeerAddr); err != nil {
|
|
return err
|
|
}
|
|
|
|
t.RecordMessage("client connected to miner")
|
|
|
|
// generate a number of random "files" and publish them to one or more miners
|
|
data := make([]byte, 1600)
|
|
rand.New(rand.NewSource(time.Now().UnixNano())).Read(data)
|
|
|
|
r := bytes.NewReader(data)
|
|
fcid, err := client.ClientImportLocal(ctx, r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
t.RecordMessage("file cid: %s", fcid)
|
|
|
|
// start deal
|
|
deal := startDeal(ctx, addrs[0].ActorAddr, client, fcid)
|
|
spew.Dump(deal)
|
|
|
|
// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
|
|
time.Sleep(time.Second)
|
|
|
|
//waitDealSealed(t, ctx, client, deal)
|
|
//testRetrieval(t, ctx, err, client, fcid, carExport, data)
|
|
|
|
// TODO broadcast published content CIDs to other clients
|
|
// TODO select a random piece of content published by some other client and retrieve it
|
|
|
|
t.SyncClient.MustSignalAndWait(ctx, stateDone, t.TestInstanceCount)
|
|
return nil
|
|
}
|
|
|
|
func collectMinersAddrs(t *TestEnvironment, ctx context.Context, miners int) ([]MinerAddresses, error) {
|
|
ch := make(chan MinerAddresses)
|
|
sub := t.SyncClient.MustSubscribe(ctx, minersAddrsTopic, ch)
|
|
|
|
addrs := make([]MinerAddresses, 0, miners)
|
|
for i := 0; i < miners; i++ {
|
|
select {
|
|
case a := <-ch:
|
|
addrs = append(addrs, a)
|
|
case err := <-sub.Done():
|
|
return nil, fmt.Errorf("got error while waiting for miners addrs: %w", err)
|
|
}
|
|
}
|
|
|
|
return addrs, nil
|
|
}
|
|
|
|
func collectClientsAddrs(t *TestEnvironment, ctx context.Context, clients int) ([]peer.AddrInfo, error) {
|
|
ch := make(chan peer.AddrInfo)
|
|
sub := t.SyncClient.MustSubscribe(ctx, clientsAddrsTopic, ch)
|
|
|
|
addrs := make([]peer.AddrInfo, 0, clients)
|
|
for i := 0; i < clients; i++ {
|
|
select {
|
|
case a := <-ch:
|
|
addrs = append(addrs, a)
|
|
case err := <-sub.Done():
|
|
return nil, fmt.Errorf("got error while waiting for clients addrs: %w", err)
|
|
}
|
|
}
|
|
|
|
return addrs, nil
|
|
}
|
|
|
|
func startDeal(ctx context.Context, minerActorAddr address.Address, client *impl.FullNodeAPI, fcid cid.Cid) *cid.Cid {
|
|
//func startDeal(ctx context.Context, minerActorAddr address.Address, client api.FullNodeAPI, fcid cid.Cid) *cid.Cid {
|
|
addr, _ := client.WalletDefaultAddress(ctx)
|
|
|
|
deal, err := client.ClientStartDeal(ctx, &api.StartDealParams{
|
|
Data: &storagemarket.DataRef{Root: fcid},
|
|
Wallet: addr,
|
|
Miner: minerActorAddr,
|
|
EpochPrice: types.NewInt(1000000),
|
|
MinBlocksDuration: 100,
|
|
})
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return deal
|
|
}
|