refactor to put an IpnsFilesystem into the core.IpfsNode for ease of closability

Author: whyrusleeping

cmd/ipfs/init.go

@@ -10,7 +10,6 @@ import (
 	cmds "github.com/jbenet/go-ipfs/commands"
 	core "github.com/jbenet/go-ipfs/core"
 	coreunix "github.com/jbenet/go-ipfs/core/coreunix"
-	ipnsfs "github.com/jbenet/go-ipfs/ipnsfs"
 	config "github.com/jbenet/go-ipfs/repo/config"
 	fsrepo "github.com/jbenet/go-ipfs/repo/fsrepo"
 	uio "github.com/jbenet/go-ipfs/unixfs/io"
@@ -172,5 +171,5 @@ func initializeIpnsKeyspace(repoRoot string) error {
 		return err
 	}
 
-	return ipnsfs.InitializeKeyspace(nd, nd.PrivateKey)
+	return nd.IpnsFs.InitializeKeyspace(ctx, nd.PrivateKey)
 }

core/core.go

@@ -37,6 +37,7 @@ import (
 	rp "github.com/jbenet/go-ipfs/exchange/reprovide"
 
 	mount "github.com/jbenet/go-ipfs/fuse/mount"
+	ipnsfs "github.com/jbenet/go-ipfs/ipnsfs"
 	merkledag "github.com/jbenet/go-ipfs/merkledag"
 	namesys "github.com/jbenet/go-ipfs/namesys"
 	path "github.com/jbenet/go-ipfs/path"
@@ -89,6 +90,8 @@ type IpfsNode struct {
 	Diagnostics  *diag.Diagnostics   // the diagnostics service
 	Reprovider   *rp.Reprovider      // the value reprovider system
 
+	IpnsFs *ipnsfs.Filesystem
+
 	ctxgroup.ContextGroup
 
 	mode mode
@@ -268,6 +271,13 @@ func (n *IpfsNode) startOnlineServicesWithHost(ctx context.Context, host p2phost
 
 	// setup name system
 	n.Namesys = namesys.NewNameSystem(n.Routing)
+
+	// Setup the mutable ipns filesystem structure
+	fs, err := ipnsfs.NewFilesystem(n.Context(), n.DAG, n.Namesys, n.Pinning, n.PrivateKey)
+	if err != nil {
+		return debugerror.Wrap(err)
+	}
+	n.IpnsFs = fs
 	return nil
 }
 
@@ -288,6 +298,10 @@ func (n *IpfsNode) teardown() error {
 		}
 	}
 
+	if n.IpnsFs != nil {
+		addCloser(n.IpnsFs)
+	}
+
 	addCloser(n.Bootstrapper)
 	if dht, ok := n.Routing.(*dht.IpfsDHT); ok {
 		addCloser(dht)

fuse/ipns/ipns_test.go

@@ -3,15 +3,15 @@ package ipns
 import (
 	"bytes"
 	"crypto/rand"
-	//context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
 	"io/ioutil"
 	"os"
 	"testing"
 
 	fstest "github.com/jbenet/go-ipfs/Godeps/_workspace/src/bazil.org/fuse/fs/fstestutil"
 
+	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
 	core "github.com/jbenet/go-ipfs/core"
-	//u "github.com/jbenet/go-ipfs/util"
+	nsfs "github.com/jbenet/go-ipfs/ipnsfs"
 	ci "github.com/jbenet/go-ipfs/util/testutil/ci"
 )
 
@@ -103,6 +103,13 @@ func setupIpnsTest(t *testing.T, node *core.IpfsNode) (*core.IpfsNode, *fstest.M
 		if err != nil {
 			t.Fatal(err)
 		}
+
+		ipnsfs, err := nsfs.NewFilesystem(context.TODO(), node.DAG, node.Namesys, node.Pinning, node.PrivateKey)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		node.IpnsFs = ipnsfs
 	}
 
 	fs, err := NewFileSystem(node, node.PrivateKey, "")

fuse/ipns/ipns_unix.go

@@ -47,11 +47,18 @@ func NewFileSystem(ipfs *core.IpfsNode, sk ci.PrivKey, ipfspath string) (*FileSy
 }
 
 // Root constructs the Root of the filesystem, a Root object.
-func (f FileSystem) Root() (fs.Node, error) {
+func (f *FileSystem) Root() (fs.Node, error) {
 	log.Debug("Filesystem, get root")
 	return f.RootNode, nil
 }
 
+func (f *FileSystem) Destroy() {
+	err := f.RootNode.Close()
+	if err != nil {
+		log.Errorf("Error Shutting Down Filesystem: %s\n", err)
+	}
+}
+
 // Root is the root object of the filesystem tree.
 type Root struct {
 	Ipfs *core.IpfsNode
@@ -67,10 +74,6 @@ type Root struct {
 }
 
 func CreateRoot(ipfs *core.IpfsNode, keys []ci.PrivKey, ipfspath string) (*Root, error) {
-	fi, err := nsfs.NewFilesystem(ipfs, keys...)
-	if err != nil {
-		return nil, err
-	}
 	ldirs := make(map[string]fs.Node)
 	roots := make(map[string]*nsfs.KeyRoot)
 	for _, k := range keys {
@@ -79,7 +82,7 @@ func CreateRoot(ipfs *core.IpfsNode, keys []ci.PrivKey, ipfspath string) (*Root,
 			return nil, err
 		}
 		name := u.Key(pkh).B58String()
-		root, err := fi.GetRoot(name)
+		root, err := ipfs.IpnsFs.GetRoot(name)
 		if err != nil {
 			return nil, err
 		}
@@ -90,14 +93,14 @@ func CreateRoot(ipfs *core.IpfsNode, keys []ci.PrivKey, ipfspath string) (*Root,
 		case *nsfs.Directory:
 			ldirs[name] = &Directory{val}
 		case nsfs.File:
-			ldirs[name] = &File{val}
+			ldirs[name] = &File{fi: val}
 		default:
 			return nil, errors.New("unrecognized type")
 		}
 	}
 
 	return &Root{
-		fs:        fi,
+		fs:        ipfs.IpnsFs,
 		Ipfs:      ipfs,
 		IpfsRoot:  ipfspath,
 		Keys:      keys,
@@ -149,6 +152,24 @@ func (s *Root) Lookup(ctx context.Context, name string) (fs.Node, error) {
 	return &Link{s.IpfsRoot + "/" + resolved.B58String()}, nil
 }
 
+func (r *Root) Close() error {
+	for _, kr := range r.Roots {
+		err := kr.Publish(r.Ipfs.Context())
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Forget is called when the filesystem is unmounted. probably.
+func (r *Root) Forget() {
+	err := r.Close()
+	if err != nil {
+		log.Error(err)
+	}
+}
+
 // ReadDirAll reads a particular directory. Will show locally available keys
 func (r *Root) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) {
 	log.Debug("Root ReadDirAll")
@@ -205,6 +226,8 @@ type Directory struct {
 
 type File struct {
 	fi nsfs.File
+
+	fs.NodeRef
 }
 
 /*
@@ -245,7 +268,7 @@ func (s *Directory) Lookup(ctx context.Context, name string) (fs.Node, error) {
 	case *nsfs.Directory:
 		return &Directory{child}, nil
 	case nsfs.File:
-		return &File{child}, nil
+		return &File{fi: child}, nil
 	default:
 		panic("system has proven to be insane")
 	}
@@ -355,7 +378,7 @@ func (dir *Directory) Create(ctx context.Context, req *fuse.CreateRequest, resp
 		return nil, nil, errors.New("child creation failed")
 	}
 
-	nodechild := &File{fi}
+	nodechild := &File{fi: fi}
 	return nodechild, nodechild, nil
 }
 

ipnsfs/dir.go

@@ -12,7 +12,7 @@ import (
 )
 
 type Directory struct {
-	dserv     dag.DAGService
+	fs        *Filesystem
 	parent    childCloser
 	childDirs map[string]*Directory
 	files     map[string]*file
@@ -25,9 +25,9 @@ type Directory struct {
 	refLock sync.Mutex
 }
 
-func NewDirectory(name string, node *dag.Node, parent childCloser, dserv dag.DAGService) *Directory {
+func NewDirectory(name string, node *dag.Node, parent childCloser, fs *Filesystem) *Directory {
 	return &Directory{
-		dserv:     dserv,
+		fs:        fs,
 		name:      name,
 		node:      node,
 		parent:    parent,
@@ -49,7 +49,7 @@ func (d *Directory) Open(tpath []string, mode int) (File, error) {
 		if mode|os.O_CREATE != 0 {
 			fnode := new(dag.Node)
 			fnode.Data = ft.FilePBData(nil, 0)
-			nfi, err := NewFile(tpath[0], fnode, d, d.dserv)
+			nfi, err := NewFile(tpath[0], fnode, d, d.fs)
 			if err != nil {
 				return nil, err
 			}
@@ -83,7 +83,7 @@ func (d *Directory) closeChild(name string) error {
 		return err
 	}
 
-	_, err = d.dserv.Add(nd)
+	_, err = d.fs.dserv.Add(nd)
 	if err != nil {
 		return err
 	}
@@ -114,7 +114,7 @@ func (d *Directory) childFile(name string) (*file, error) {
 	// search dag
 	for _, lnk := range d.node.Links {
 		if lnk.Name == name {
-			nd, err := lnk.GetNode(d.dserv)
+			nd, err := lnk.GetNode(d.fs.dserv)
 			if err != nil {
 				return nil, err
 			}
@@ -127,7 +127,7 @@ func (d *Directory) childFile(name string) (*file, error) {
 			case ufspb.Data_Directory:
 				return nil, ErrIsDirectory
 			case ufspb.Data_File:
-				nfi, err := NewFile(name, nd, d, d.dserv)
+				nfi, err := NewFile(name, nd, d, d.fs)
 				if err != nil {
 					return nil, err
 				}
@@ -151,7 +151,7 @@ func (d *Directory) childDir(name string) (*Directory, error) {
 
 	for _, lnk := range d.node.Links {
 		if lnk.Name == name {
-			nd, err := lnk.GetNode(d.dserv)
+			nd, err := lnk.GetNode(d.fs.dserv)
 			if err != nil {
 				return nil, err
 			}
@@ -162,7 +162,7 @@ func (d *Directory) childDir(name string) (*Directory, error) {
 
 			switch i.GetType() {
 			case ufspb.Data_Directory:
-				ndir := NewDirectory(name, nd, d, d.dserv)
+				ndir := NewDirectory(name, nd, d, d.fs)
 				d.childDirs[name] = ndir
 				return ndir, nil
 			case ufspb.Data_File:
@@ -310,9 +310,9 @@ func (d *Directory) AddChild(name string, nd *dag.Node) error {
 
 	switch pbn.GetType() {
 	case ft.TDirectory:
-		d.childDirs[name] = NewDirectory(name, nd, d, d.dserv)
+		d.childDirs[name] = NewDirectory(name, nd, d, d.fs)
 	case ft.TFile, ft.TMetadata, ft.TRaw:
-		nfi, err := NewFile(name, nd, d, d.dserv)
+		nfi, err := NewFile(name, nd, d, d.fs)
 		if err != nil {
 			return err
 		}

ipnsfs/file.go

@@ -25,11 +25,10 @@ type File interface {
 
 type file struct {
 	parent childCloser
-	dserv  dag.DAGService
 	node   *dag.Node
+	fs     *Filesystem
 
-	name     string
-	openMode int
+	name string
 
 	refLk sync.Mutex
 	ref   int
@@ -38,15 +37,15 @@ type file struct {
 	mod *mod.DagModifier
 }
 
-func NewFile(name string, node *dag.Node, parent childCloser, dserv dag.DAGService) (*file, error) {
-	dmod, err := mod.NewDagModifier(context.TODO(), node, dserv, nil, chunk.DefaultSplitter)
+func NewFile(name string, node *dag.Node, parent childCloser, fs *Filesystem) (*file, error) {
+	dmod, err := mod.NewDagModifier(context.TODO(), node, fs.dserv, fs.pins.GetManual(), chunk.DefaultSplitter)
 	if err != nil {
 		return nil, err
 	}
 
 	return &file{
+		fs:     fs,
 		parent: parent,
-		dserv:  dserv,
 		node:   node,
 		name:   name,
 		mod:    dmod,