func GetDAGServ(t testing.TB) dag.DAGService { dstore := ds.NewMapDatastore() bserv, err := bsrv.NewBlockService(dstore, nil) if err != nil { t.Fatal(err) } return dag.NewDAGService(bserv) }
func getMockDagServ(t *testing.T) mdag.DAGService { dstore := ds.NewMapDatastore() bserv, err := bs.NewBlockService(dstore, nil) if err != nil { t.Fatal(err) } return mdag.NewDAGService(bserv) }
// NewMockNode constructs an IpfsNode for use in tests. func NewMockNode() (*IpfsNode, error) { nd := new(IpfsNode) // Generate Identity sk, pk, err := ci.GenerateKeyPair(ci.RSA, 1024) if err != nil { return nil, err } p, err := peer.WithKeyPair(sk, pk) if err != nil { return nil, err } nd.Peerstore = peer.NewPeerstore() nd.Identity, err = nd.Peerstore.Add(p) if err != nil { return nil, err } // Temp Datastore dstore := ds.NewMapDatastore() nd.Datastore = util.CloserWrap(syncds.MutexWrap(dstore)) // Routing dht := mdht.NewMockRouter(nd.Identity, nd.Datastore) nd.Routing = dht // Bitswap //?? bserv, err := bs.NewBlockService(nd.Datastore, nil) if err != nil { return nil, err } nd.DAG = mdag.NewDAGService(bserv) // Namespace resolver nd.Namesys = nsys.NewNameSystem(dht) // Path resolver nd.Resolver = &path.Resolver{DAG: nd.DAG} return nd, nil }
func TestPinnerBasic(t *testing.T) { dstore := ds.NewMapDatastore() bserv, err := bs.NewBlockService(dstore, nil) if err != nil { t.Fatal(err) } dserv := mdag.NewDAGService(bserv) p := NewPinner(dstore, dserv) a, ak := randNode() // Pin A{} err = p.Pin(a, false) if err != nil { t.Fatal(err) } if !p.IsPinned(ak) { t.Fatal("Failed to find key") } b, _ := randNode() err = b.AddNodeLink("child", a) if err != nil { t.Fatal(err) } c, ck := randNode() err = b.AddNodeLink("otherchild", c) if err != nil { t.Fatal(err) } // recursively pin B{A,C} err = p.Pin(b, true) if err != nil { t.Fatal(err) } if !p.IsPinned(ck) { t.Fatal("Child of recursively pinned node not found") } bk, _ := b.Key() if !p.IsPinned(bk) { t.Fatal("Recursively pinned node not found..") } d, _ := randNode() d.AddNodeLink("a", a) d.AddNodeLink("c", c) e, ek := randNode() d.AddNodeLink("e", e) // Must be in dagserv for unpin to work err = dserv.AddRecursive(d) if err != nil { t.Fatal(err) } // Add D{A,C,E} err = p.Pin(d, true) if err != nil { t.Fatal(err) } if !p.IsPinned(ek) { t.Fatal(err) } dk, _ := d.Key() if !p.IsPinned(dk) { t.Fatal("pinned node not found.") } // Test recursive unpin err = p.Unpin(dk, true) if err != nil { t.Fatal(err) } // c should still be pinned under b if !p.IsPinned(ck) { t.Fatal("Recursive / indirect unpin fail.") } err = p.Flush() if err != nil { t.Fatal(err) } np, err := LoadPinner(dstore, dserv) if err != nil { t.Fatal(err) } // Test directly pinned if !np.IsPinned(ak) { t.Fatal("Could not find pinned node!") } // Test indirectly pinned if !np.IsPinned(ck) { t.Fatal("could not find indirectly pinned node") } // Test recursively pinned if !np.IsPinned(bk) { t.Fatal("could not find recursively pinned node") } }
// NewIpfsNode constructs a new IpfsNode based on the given config. func NewIpfsNode(cfg *config.Config, online bool) (n *IpfsNode, err error) { success := false // flip to true after all sub-system inits succeed defer func() { if !success && n != nil { n.Close() } }() if cfg == nil { return nil, debugerror.Errorf("configuration required") } // derive this from a higher context. ctx := context.TODO() n = &IpfsNode{ onlineMode: online, Config: cfg, } n.ContextCloser = ctxc.NewContextCloser(ctx, n.teardown) // setup datastore. if n.Datastore, err = makeDatastore(cfg.Datastore); err != nil { return nil, debugerror.Wrap(err) } // setup peerstore + local peer identity n.Peerstore = peer.NewPeerstore() n.Identity, err = initIdentity(&n.Config.Identity, n.Peerstore, online) if err != nil { return nil, debugerror.Wrap(err) } // setup online services if online { dhtService := netservice.NewService(ctx, nil) // nil handler for now, need to patch it exchangeService := netservice.NewService(ctx, nil) // nil handler for now, need to patch it diagService := netservice.NewService(ctx, nil) // nil handler for now, need to patch it muxMap := &mux.ProtocolMap{ mux.ProtocolID_Routing: dhtService, mux.ProtocolID_Exchange: exchangeService, mux.ProtocolID_Diagnostic: diagService, // add protocol services here. } // setup the network listenAddrs, err := listenAddresses(cfg) if err != nil { return nil, debugerror.Wrap(err) } n.Network, err = inet.NewIpfsNetwork(ctx, listenAddrs, n.Identity, n.Peerstore, muxMap) if err != nil { return nil, debugerror.Wrap(err) } n.AddCloserChild(n.Network) // setup diagnostics service n.Diagnostics = diag.NewDiagnostics(n.Identity, n.Network, diagService) diagService.SetHandler(n.Diagnostics) // setup routing service dhtRouting := dht.NewDHT(ctx, n.Identity, n.Peerstore, n.Network, dhtService, n.Datastore) dhtRouting.Validators[IpnsValidatorTag] = namesys.ValidateIpnsRecord // TODO(brian): perform this inside NewDHT factory method dhtService.SetHandler(dhtRouting) // wire the handler to the service. n.Routing = dhtRouting n.AddCloserChild(dhtRouting) // setup exchange service const alwaysSendToPeer = true // use YesManStrategy bitswapNetwork := bsnet.NewFromIpfsNetwork(exchangeService, n.Network) n.Exchange = bitswap.New(ctx, n.Identity, bitswapNetwork, n.Routing, n.Datastore, alwaysSendToPeer) go initConnections(ctx, n.Config, n.Peerstore, dhtRouting) } // TODO(brian): when offline instantiate the BlockService with a bitswap // session that simply doesn't return blocks n.Blocks, err = bserv.NewBlockService(n.Datastore, n.Exchange) if err != nil { return nil, debugerror.Wrap(err) } n.DAG = merkledag.NewDAGService(n.Blocks) n.Namesys = namesys.NewNameSystem(n.Routing) n.Pinning, err = pin.LoadPinner(n.Datastore, n.DAG) if err != nil { n.Pinning = pin.NewPinner(n.Datastore, n.DAG) } n.Resolver = &path.Resolver{DAG: n.DAG} success = true return n, nil }