func MocknetTestRepo(p peer.ID, h host.Host, conf testutil.LatencyConfig, routing core.RoutingOption) core.ConfigOption { return func(ctx context.Context) (*core.IpfsNode, error) { const kWriteCacheElems = 100 const alwaysSendToPeer = true dsDelay := delay.Fixed(conf.BlockstoreLatency) r := &repo.Mock{ D: ds2.CloserWrap(syncds.MutexWrap(ds2.WithDelay(datastore.NewMapDatastore(), dsDelay))), } ds := r.Datastore() n := &core.IpfsNode{ Peerstore: h.Peerstore(), Repo: r, PeerHost: h, Identity: p, } dhtt, err := routing(ctx, n.PeerHost, n.Repo.Datastore()) if err != nil { return nil, err } bsn := bsnet.NewFromIpfsHost(h, dhtt) bstore, err := blockstore.WriteCached(blockstore.NewBlockstore(ds), kWriteCacheElems) if err != nil { return nil, err } exch := bitswap.New(ctx, p, bsn, bstore, alwaysSendToPeer) n.Blockstore = bstore n.Exchange = exch n.Routing = dhtt return n, nil } }
// session creates a test bitswap session. // // NB: It's easy make mistakes by providing the same peer ID to two different // sessions. To safeguard, use the SessionGenerator to generate sessions. It's // just a much better idea. func session(ctx context.Context, net tn.Network, p testutil.Identity) Instance { bsdelay := delay.Fixed(0) const writeCacheElems = 100 adapter := net.Adapter(p) dstore := ds_sync.MutexWrap(datastore2.WithDelay(ds.NewMapDatastore(), bsdelay)) bstore, err := blockstore.WriteCached(blockstore.NewBlockstore(ds_sync.MutexWrap(dstore)), writeCacheElems) if err != nil { panic(err.Error()) // FIXME perhaps change signature and return error. } const alwaysSendToPeer = true bs := New(ctx, p.ID(), adapter, bstore, alwaysSendToPeer).(*Bitswap) return Instance{ Peer: p.ID(), Exchange: bs, blockstore: bstore, blockstoreDelay: bsdelay, } }
func BenchmarkWithConfig(c worker.Config) func(b *testing.B) { return func(b *testing.B) { routingDelay := delay.Fixed(0) // during setup dstore := ds_sync.MutexWrap(datastore2.WithDelay(ds.NewMapDatastore(), routingDelay)) bstore := blockstore.NewBlockstore(dstore) var testdata []*blocks.Block var i int64 for i = 0; i < kBlocksPerOp; i++ { testdata = append(testdata, blocks.NewBlock([]byte(string(i)))) } b.ResetTimer() b.SetBytes(kBlocksPerOp) for i := 0; i < b.N; i++ { b.StopTimer() w := worker.NewWorker(offline.Exchange(bstore), c) b.StartTimer() prev := routingDelay.Set(kEstRoutingDelay) // during measured section for _, block := range testdata { if err := w.HasBlock(block); err != nil { b.Fatal(err) } } routingDelay.Set(prev) // to hasten the unmeasured close period b.StopTimer() w.Close() b.StartTimer() } } }