func MockCmdsCtx() (commands.Context, error) { // Generate Identity ident, err := testutil.RandIdentity() if err != nil { return commands.Context{}, err } p := ident.ID() conf := config.Config{ Identity: config.Identity{ PeerID: p.String(), }, } r := &repo.Mock{ D: ds2.CloserWrap(syncds.MutexWrap(datastore.NewMapDatastore())), C: conf, } node, err := core.NewNode(context.Background(), &core.BuildCfg{ Repo: r, }) return commands.Context{ Online: true, ConfigRoot: "/tmp/.mockipfsconfig", LoadConfig: func(path string) (*config.Config, error) { return &conf, nil }, ConstructNode: func() (*core.IpfsNode, error) { return node, nil }, }, nil }
// NewMockNode constructs an IpfsNode for use in tests. func NewMockNode() (*core.IpfsNode, error) { ctx := context.Background() // effectively offline, only peer in its network return core.NewNode(ctx, &core.BuildCfg{ Online: true, Host: MockHostOption(mocknet.New(ctx)), }) }
func get(path, outFile string) error { start := time.Now() ctx, cancel := context.WithCancel(context.Background()) node, err := core.NewNode(ctx, &core.BuildCfg{ Online: true, }) if err != nil { return fmt.Errorf("ipfs NewNode() failed: %s", err) } err = node.Bootstrap(core.DefaultBootstrapConfig) if err != nil { return fmt.Errorf("node Bootstrap() failed: %s", err) } fmt.Fprintf(os.Stderr, "IPFS Node bootstrapping (took %v)\n", time.Since(start)) // Cancel the ipfs node context if the process gets interrupted or killed. go func() { interrupts := make(chan os.Signal, 1) signal.Notify(interrupts, os.Interrupt, os.Kill) <-interrupts cancel() }() reader, length, err := cat(node.Context(), node, path) if err != nil { return fmt.Errorf("cat failed: %s", err) } file, err := os.Create(outFile) if err != nil { return fmt.Errorf("Creating output file %q failed: %s", outFile, err) } bar := pb.New(int(length)).SetUnits(pb.U_BYTES) bar.Output = os.Stderr bar.ShowSpeed = false bar.Start() writer := io.MultiWriter(file, bar) if _, err := io.Copy(writer, reader); err != nil { return fmt.Errorf("copy failed: %s", err) } bar.Finish() fmt.Fprintf(os.Stderr, "Wrote %q to %q (%s) (took %v)\n", path, outFile, humanize.Bytes(length), time.Since(start)) return nil }
res.SetError(err, cmds.ErrNormal) return } progress, _, _ := req.Option(progressOptionName).Bool() trickle, _, _ := req.Option(trickleOptionName).Bool() wrap, _, _ := req.Option(wrapOptionName).Bool() hash, _, _ := req.Option(onlyHashOptionName).Bool() hidden, _, _ := req.Option(hiddenOptionName).Bool() chunker, _, _ := req.Option(chunkerOptionName).String() e := dagutils.NewDagEditor(NewMemoryDagService(), newDirNode()) if hash { nilnode, err := core.NewNode(n.Context(), &core.BuildCfg{ //TODO: need this to be true or all files // hashed will be stored in memory! NilRepo: true, }) if err != nil { res.SetError(err, cmds.ErrNormal) return } n = nilnode } outChan := make(chan interface{}, 8) res.SetOutput((<-chan interface{})(outChan)) fileAdder := adder{ ctx: req.Context(), node: n,