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)), }) }
// NewFile returns a NewFile object with the given parameters func NewFile(name string, node *dag.Node, parent childCloser, fs *Filesystem) (*File, error) { dmod, err := mod.NewDagModifier(context.Background(), node, fs.dserv, fs.pins.GetManual(), chunk.DefaultSplitter) if err != nil { return nil, err } return &File{ fs: fs, parent: parent, name: name, mod: dmod, }, nil }
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 }
// HandleSync reads the next name off the Stream, and calls a handler function // This is done synchronously. The handler function will return before // HandleSync returns. func (m *Mux) HandleSync(s inet.Stream) { ctx := context.Background() name, handler, err := m.ReadHeader(s) if err != nil { err = fmt.Errorf("protocol mux error: %s", err) log.Event(ctx, "muxError", lgbl.Error(err)) s.Close() return } log.Debugf("muxer handle protocol %s: %s", s.Conn().RemotePeer(), name) handler(s) }
func getRoutingProviders(ds datastore.Datastore, k key.Key) ([]*dhtpb.Message_Peer, error) { e := log.EventBegin(context.Background(), "getProviders", &k) defer e.Done() var providers []*dhtpb.Message_Peer if v, err := ds.Get(providerKey(k)); err == nil { if data, ok := v.([]byte); ok { var msg dhtpb.Message if err := proto.Unmarshal(data, &msg); err != nil { return nil, err } providers = append(providers, msg.GetProviderPeers()...) } } return providers, nil }
func GarbageCollect(n *core.IpfsNode, ctx context.Context) error { ctx, cancel := context.WithCancel(context.Background()) defer cancel() // in case error occurs during operation keychan, err := n.Blockstore.AllKeysChan(ctx) if err != nil { return err } for k := range keychan { // rely on AllKeysChan to close chan if !n.Pinning.IsPinned(k) { err := n.Blockstore.DeleteBlock(k) if err != nil { return err } } } return nil }
// connHandler is called by the StreamSwarm whenever a new connection is added // here we configure it slightly. Note that this is sequential, so if anything // will take a while do it in a goroutine. // See https://godoc.org/github.com/jbenet/go-peerstream for more information func (s *Swarm) connHandler(c *ps.Conn) *Conn { ctx := context.Background() // this context is for running the handshake, which -- when receiveing connections // -- we have no bound on beyond what the transport protocol bounds it at. // note that setup + the handshake are bounded by underlying io. // (i.e. if TCP or UDP disconnects (or the swarm closes), we're done. // Q: why not have a shorter handshake? think about an HTTP server on really slow conns. // as long as the conn is live (TCP says its online), it tries its best. we follow suit.) sc, err := s.newConnSetup(ctx, c) if err != nil { log.Debug(err) log.Event(ctx, "newConnHandlerDisconnect", lgbl.NetConn(c.NetConn()), lgbl.Error(err)) c.Close() // boom. close it. return nil } return sc }
// handleNewStream receives a new stream from the network. func (bsnet *impl) handleNewStream(s inet.Stream) { defer s.Close() if bsnet.receiver == nil { return } received, err := bsmsg.FromNet(s) if err != nil { go bsnet.receiver.ReceiveError(err) log.Debugf("bitswap net handleNewStream from %s error: %s", s.Conn().RemotePeer(), err) return } p := s.Conn().RemotePeer() ctx := context.Background() log.Debugf("bitswap net handleNewStream from %s", s.Conn().RemotePeer()) bsnet.receiver.ReceiveMessage(ctx, p, received) }
func putRoutingProviders(ds datastore.Datastore, k key.Key, newRecords []*dhtpb.Message_Peer) error { log.Event(context.Background(), "putRoutingProviders", &k) oldRecords, err := getRoutingProviders(ds, k) if err != nil { return err } mergedRecords := make(map[string]*dhtpb.Message_Peer) for _, provider := range oldRecords { mergedRecords[provider.GetId()] = provider // add original records } for _, provider := range newRecords { mergedRecords[provider.GetId()] = provider // overwrite old record if new exists } var protomsg dhtpb.Message protomsg.ProviderPeers = make([]*dhtpb.Message_Peer, 0, len(mergedRecords)) for _, provider := range mergedRecords { protomsg.ProviderPeers = append(protomsg.ProviderPeers, provider) } data, err := proto.Marshal(&protomsg) if err != nil { return err } return ds.Put(providerKey(k), data) }
func copyDag(nd *dag.Node, from, to dag.DAGService) error { _, err := to.Add(nd) if err != nil { return err } for _, lnk := range nd.Links { child, err := lnk.GetNode(context.Background(), from) if err != nil { if err == dag.ErrNotFound { // not found means we didnt modify it, and it should // already be in the target datastore continue } return err } err = copyDag(child, from, to) if err != nil { return err } } return nil }
// Accept waits for and returns the next connection to the listener. // Note that unfortunately this func (l *listener) Accept() (net.Conn, error) { // listeners dont have contexts. given changes dont make sense here anymore // note that the parent of listener will Close, which will interrupt all io. // Contexts and io don't mix. ctx := context.Background() var catcher tec.TempErrCatcher catcher.IsTemp = func(e error) bool { // ignore connection breakages up to this point. but log them if e == io.EOF { log.Debugf("listener ignoring conn with EOF: %s", e) return true } te, ok := e.(tec.Temporary) if ok { log.Debugf("listener ignoring conn with temporary err: %s", e) return te.Temporary() } return false } for { maconn, err := l.Listener.Accept() if err != nil { if catcher.IsTemporary(err) { continue } return nil, err } log.Debugf("listener %s got connection: %s <---> %s", l, maconn.LocalMultiaddr(), maconn.RemoteMultiaddr()) if l.filters != nil && l.filters.AddrBlocked(maconn.RemoteMultiaddr()) { log.Debugf("blocked connection from %s", maconn.RemoteMultiaddr()) maconn.Close() continue } // If we have a wrapper func, wrap this conn if l.wrapper != nil { maconn = l.wrapper(maconn) } c, err := newSingleConn(ctx, l.local, "", maconn) if err != nil { if catcher.IsTemporary(err) { continue } return nil, err } if l.privk == nil || EncryptConnections == false { log.Warning("listener %s listening INSECURELY!", l) return c, nil } sc, err := newSecureConn(ctx, l.privk, c) if err != nil { log.Infof("ignoring conn we failed to secure: %s %s", err, c) continue } return sc, nil } }
func (d *Diagnostics) handleNewStream(s inet.Stream) { d.HandleMessage(context.Background(), s) s.Close() }
func (c *serveConn) serve(r fuse.Request) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() req := &serveRequest{Request: r, cancel: cancel} c.debug(request{ Op: opName(r), Request: r.Hdr(), In: r, }) var node Node var snode *serveNode c.meta.Lock() hdr := r.Hdr() if id := hdr.Node; id != 0 { if id < fuse.NodeID(len(c.node)) { snode = c.node[uint(id)] } if snode == nil { c.meta.Unlock() c.debug(response{ Op: opName(r), Request: logResponseHeader{ID: hdr.ID}, Error: fuse.ESTALE.ErrnoName(), // this is the only place that sets both Error and // Out; not sure if i want to do that; might get rid // of len(c.node) things altogether Out: logMissingNode{ MaxNode: fuse.NodeID(len(c.node)), }, }) r.RespondError(fuse.ESTALE) return } node = snode.node } if c.req[hdr.ID] != nil { // This happens with OSXFUSE. Assume it's okay and // that we'll never see an interrupt for this one. // Otherwise everything wedges. TODO: Report to OSXFUSE? // // TODO this might have been because of missing done() calls } else { c.req[hdr.ID] = req } c.meta.Unlock() // Call this before responding. // After responding is too late: we might get another request // with the same ID and be very confused. done := func(resp interface{}) { msg := response{ Op: opName(r), Request: logResponseHeader{ID: hdr.ID}, } if err, ok := resp.(error); ok { msg.Error = err.Error() if ferr, ok := err.(fuse.ErrorNumber); ok { errno := ferr.Errno() msg.Errno = errno.ErrnoName() if errno == err { // it's just a fuse.Errno with no extra detail; // skip the textual message for log readability msg.Error = "" } } else { msg.Errno = fuse.DefaultErrno.ErrnoName() } } else { msg.Out = resp } c.debug(msg) c.meta.Lock() delete(c.req, hdr.ID) c.meta.Unlock() } defer func() { if rec := recover(); rec != nil { const size = 1 << 16 buf := make([]byte, size) n := runtime.Stack(buf, false) buf = buf[:n] log.Printf("fuse: panic in handler for %v: %v\n%s", r, rec, buf) err := handlerPanickedError{ Request: r, Err: rec, } done(err) r.RespondError(err) } }() switch r := r.(type) { default: // Note: To FUSE, ENOSYS means "this server never implements this request." // It would be inappropriate to return ENOSYS for other operations in this // switch that might only be unavailable in some contexts, not all. done(fuse.ENOSYS) r.RespondError(fuse.ENOSYS) // FS operations. case *fuse.InitRequest: s := &fuse.InitResponse{ MaxWrite: 128 * 1024, Flags: fuse.InitBigWrites, } if fs, ok := c.fs.(FSIniter); ok { if err := fs.Init(ctx, r, s); err != nil { done(err) r.RespondError(err) break } } done(s) r.Respond(s) case *fuse.StatfsRequest: s := &fuse.StatfsResponse{} if fs, ok := c.fs.(FSStatfser); ok { if err := fs.Statfs(ctx, r, s); err != nil { done(err) r.RespondError(err) break } } done(s) r.Respond(s) // Node operations. case *fuse.GetattrRequest: s := &fuse.GetattrResponse{} if n, ok := node.(NodeGetattrer); ok { if err := n.Getattr(ctx, r, s); err != nil { done(err) r.RespondError(err) break } } else { if err := snode.attr(ctx, &s.Attr); err != nil { done(err) r.RespondError(err) break } } done(s) r.Respond(s) case *fuse.SetattrRequest: s := &fuse.SetattrResponse{} if n, ok := node.(NodeSetattrer); ok { if err := n.Setattr(ctx, r, s); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) break } if err := snode.attr(ctx, &s.Attr); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.SymlinkRequest: s := &fuse.SymlinkResponse{} initLookupResponse(&s.LookupResponse) n, ok := node.(NodeSymlinker) if !ok { done(fuse.EIO) // XXX or EPERM like Mkdir? r.RespondError(fuse.EIO) break } n2, err := n.Symlink(ctx, r) if err != nil { done(err) r.RespondError(err) break } if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.NewName, n2); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.ReadlinkRequest: n, ok := node.(NodeReadlinker) if !ok { done(fuse.EIO) /// XXX or EPERM? r.RespondError(fuse.EIO) break } target, err := n.Readlink(ctx, r) if err != nil { done(err) r.RespondError(err) break } done(target) r.Respond(target) case *fuse.LinkRequest: n, ok := node.(NodeLinker) if !ok { done(fuse.EIO) /// XXX or EPERM? r.RespondError(fuse.EIO) break } c.meta.Lock() var oldNode *serveNode if int(r.OldNode) < len(c.node) { oldNode = c.node[r.OldNode] } c.meta.Unlock() if oldNode == nil { c.debug(logLinkRequestOldNodeNotFound{ Request: r.Hdr(), In: r, }) done(fuse.EIO) r.RespondError(fuse.EIO) break } n2, err := n.Link(ctx, r, oldNode.node) if err != nil { done(err) r.RespondError(err) break } s := &fuse.LookupResponse{} initLookupResponse(s) if err := c.saveLookup(ctx, s, snode, r.NewName, n2); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.RemoveRequest: n, ok := node.(NodeRemover) if !ok { done(fuse.EIO) /// XXX or EPERM? r.RespondError(fuse.EIO) break } err := n.Remove(ctx, r) if err != nil { done(err) r.RespondError(err) break } done(nil) r.Respond() case *fuse.AccessRequest: if n, ok := node.(NodeAccesser); ok { if err := n.Access(ctx, r); err != nil { done(err) r.RespondError(err) break } } done(nil) r.Respond() case *fuse.LookupRequest: var n2 Node var err error s := &fuse.LookupResponse{} initLookupResponse(s) if n, ok := node.(NodeStringLookuper); ok { n2, err = n.Lookup(ctx, r.Name) } else if n, ok := node.(NodeRequestLookuper); ok { n2, err = n.Lookup(ctx, r, s) } else { done(fuse.ENOENT) r.RespondError(fuse.ENOENT) break } if err != nil { done(err) r.RespondError(err) break } if err := c.saveLookup(ctx, s, snode, r.Name, n2); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.MkdirRequest: s := &fuse.MkdirResponse{} initLookupResponse(&s.LookupResponse) n, ok := node.(NodeMkdirer) if !ok { done(fuse.EPERM) r.RespondError(fuse.EPERM) break } n2, err := n.Mkdir(ctx, r) if err != nil { done(err) r.RespondError(err) break } if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.Name, n2); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.OpenRequest: s := &fuse.OpenResponse{} var h2 Handle if n, ok := node.(NodeOpener); ok { hh, err := n.Open(ctx, r, s) if err != nil { done(err) r.RespondError(err) break } h2 = hh } else { h2 = node } s.Handle = c.saveHandle(h2, hdr.Node) done(s) r.Respond(s) case *fuse.CreateRequest: n, ok := node.(NodeCreater) if !ok { // If we send back ENOSYS, FUSE will try mknod+open. done(fuse.EPERM) r.RespondError(fuse.EPERM) break } s := &fuse.CreateResponse{OpenResponse: fuse.OpenResponse{}} initLookupResponse(&s.LookupResponse) n2, h2, err := n.Create(ctx, r, s) if err != nil { done(err) r.RespondError(err) break } if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.Name, n2); err != nil { done(err) r.RespondError(err) break } s.Handle = c.saveHandle(h2, hdr.Node) done(s) r.Respond(s) case *fuse.GetxattrRequest: n, ok := node.(NodeGetxattrer) if !ok { done(fuse.ENOTSUP) r.RespondError(fuse.ENOTSUP) break } s := &fuse.GetxattrResponse{} err := n.Getxattr(ctx, r, s) if err != nil { done(err) r.RespondError(err) break } if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) { done(fuse.ERANGE) r.RespondError(fuse.ERANGE) break } done(s) r.Respond(s) case *fuse.ListxattrRequest: n, ok := node.(NodeListxattrer) if !ok { done(fuse.ENOTSUP) r.RespondError(fuse.ENOTSUP) break } s := &fuse.ListxattrResponse{} err := n.Listxattr(ctx, r, s) if err != nil { done(err) r.RespondError(err) break } if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) { done(fuse.ERANGE) r.RespondError(fuse.ERANGE) break } done(s) r.Respond(s) case *fuse.SetxattrRequest: n, ok := node.(NodeSetxattrer) if !ok { done(fuse.ENOTSUP) r.RespondError(fuse.ENOTSUP) break } err := n.Setxattr(ctx, r) if err != nil { done(err) r.RespondError(err) break } done(nil) r.Respond() case *fuse.RemovexattrRequest: n, ok := node.(NodeRemovexattrer) if !ok { done(fuse.ENOTSUP) r.RespondError(fuse.ENOTSUP) break } err := n.Removexattr(ctx, r) if err != nil { done(err) r.RespondError(err) break } done(nil) r.Respond() case *fuse.ForgetRequest: forget := c.dropNode(hdr.Node, r.N) if forget { n, ok := node.(NodeForgetter) if ok { n.Forget() } } done(nil) r.Respond() // Handle operations. case *fuse.ReadRequest: shandle := c.getHandle(r.Handle) if shandle == nil { done(fuse.ESTALE) r.RespondError(fuse.ESTALE) return } handle := shandle.handle s := &fuse.ReadResponse{Data: make([]byte, 0, r.Size)} if r.Dir { if h, ok := handle.(HandleReadDirAller); ok { if shandle.readData == nil { dirs, err := h.ReadDirAll(ctx) if err != nil { done(err) r.RespondError(err) break } var data []byte for _, dir := range dirs { if dir.Inode == 0 { dir.Inode = c.dynamicInode(snode.inode, dir.Name) } data = fuse.AppendDirent(data, dir) } shandle.readData = data } fuseutil.HandleRead(r, s, shandle.readData) done(s) r.Respond(s) break } } else { if h, ok := handle.(HandleReadAller); ok { if shandle.readData == nil { data, err := h.ReadAll(ctx) if err != nil { done(err) r.RespondError(err) break } if data == nil { data = []byte{} } shandle.readData = data } fuseutil.HandleRead(r, s, shandle.readData) done(s) r.Respond(s) break } h, ok := handle.(HandleReader) if !ok { fmt.Printf("NO READ FOR %T\n", handle) done(fuse.EIO) r.RespondError(fuse.EIO) break } if err := h.Read(ctx, r, s); err != nil { done(err) r.RespondError(err) break } } done(s) r.Respond(s) case *fuse.WriteRequest: shandle := c.getHandle(r.Handle) if shandle == nil { done(fuse.ESTALE) r.RespondError(fuse.ESTALE) return } s := &fuse.WriteResponse{} if h, ok := shandle.handle.(HandleWriter); ok { if err := h.Write(ctx, r, s); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) break } done(fuse.EIO) r.RespondError(fuse.EIO) case *fuse.FlushRequest: shandle := c.getHandle(r.Handle) if shandle == nil { done(fuse.ESTALE) r.RespondError(fuse.ESTALE) return } handle := shandle.handle if h, ok := handle.(HandleFlusher); ok { if err := h.Flush(ctx, r); err != nil { done(err) r.RespondError(err) break } } done(nil) r.Respond() case *fuse.ReleaseRequest: shandle := c.getHandle(r.Handle) if shandle == nil { done(fuse.ESTALE) r.RespondError(fuse.ESTALE) return } handle := shandle.handle // No matter what, release the handle. c.dropHandle(r.Handle) if h, ok := handle.(HandleReleaser); ok { if err := h.Release(ctx, r); err != nil { done(err) r.RespondError(err) break } } done(nil) r.Respond() case *fuse.DestroyRequest: if fs, ok := c.fs.(FSDestroyer); ok { fs.Destroy() } done(nil) r.Respond() case *fuse.RenameRequest: c.meta.Lock() var newDirNode *serveNode if int(r.NewDir) < len(c.node) { newDirNode = c.node[r.NewDir] } c.meta.Unlock() if newDirNode == nil { c.debug(renameNewDirNodeNotFound{ Request: r.Hdr(), In: r, }) done(fuse.EIO) r.RespondError(fuse.EIO) break } n, ok := node.(NodeRenamer) if !ok { done(fuse.EIO) // XXX or EPERM like Mkdir? r.RespondError(fuse.EIO) break } err := n.Rename(ctx, r, newDirNode.node) if err != nil { done(err) r.RespondError(err) break } done(nil) r.Respond() case *fuse.MknodRequest: n, ok := node.(NodeMknoder) if !ok { done(fuse.EIO) r.RespondError(fuse.EIO) break } n2, err := n.Mknod(ctx, r) if err != nil { done(err) r.RespondError(err) break } s := &fuse.LookupResponse{} initLookupResponse(s) if err := c.saveLookup(ctx, s, snode, r.Name, n2); err != nil { done(err) r.RespondError(err) break } done(s) r.Respond(s) case *fuse.FsyncRequest: n, ok := node.(NodeFsyncer) if !ok { done(fuse.EIO) r.RespondError(fuse.EIO) break } err := n.Fsync(ctx, r) if err != nil { done(err) r.RespondError(err) break } done(nil) r.Respond() case *fuse.InterruptRequest: c.meta.Lock() ireq := c.req[r.IntrID] if ireq != nil && ireq.cancel != nil { ireq.cancel() ireq.cancel = nil } c.meta.Unlock() done(nil) r.Respond() /* case *FsyncdirRequest: done(ENOSYS) r.RespondError(ENOSYS) case *GetlkRequest, *SetlkRequest, *SetlkwRequest: done(ENOSYS) r.RespondError(ENOSYS) case *BmapRequest: done(ENOSYS) r.RespondError(ENOSYS) case *SetvolnameRequest, *GetxtimesRequest, *ExchangeRequest: done(ENOSYS) r.RespondError(ENOSYS) */ } }
func (rs *s) Client(p testutil.Identity) Client { return rs.ClientWithDatastore(context.Background(), p, ds.NewMapDatastore()) }