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,