ipfs + ipns mounts with flags + config

cmd/ipfs/init.go

@@ -92,6 +92,12 @@ func initCmd(c *commander.Command, inp []string) error {
 		API:   "/ip4/127.0.0.1/tcp/5001",
 	}
 
+	// setup the node mount points.
+	cfg.Mounts = config.Mounts{
+		IPFS: "/ipfs",
+		IPNS: "/ipns",
+	}
+
 	nbits, ok := c.Flag.Lookup("b").Value.Get().(int)
 	if !ok {
 		return errors.New("failed to get bits flag")

cmd/ipfs/mount_unix.go

@@ -3,14 +3,12 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/gonuts/flag"
 	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/commander"
-	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 
-	"github.com/jbenet/go-ipfs/daemon"
+	core "github.com/jbenet/go-ipfs/core"
 	ipns "github.com/jbenet/go-ipfs/fuse/ipns"
 	rofs "github.com/jbenet/go-ipfs/fuse/readonly"
 )
@@ -30,59 +28,64 @@ var cmdIpfsMount = &commander.Command{
 }
 
 func init() {
+	cmdIpfsMount.Flag.String("f", "", "specify a mountpoint for ipfs")
 	cmdIpfsMount.Flag.String("n", "", "specify a mountpoint for ipns")
-	cmdIpfsMount.Flag.String("f", "/ipfs", "specify a mountpoint for ipfs")
 }
 
 func mountCmd(c *commander.Command, inp []string) error {
-	conf, err := getConfigDir(c.Parent)
-	if err != nil {
-		fmt.Println("Couldnt get config dir")
-		return err
-	}
-	n, err := localNode(conf, true)
-	if err != nil {
-		fmt.Println("Local node creation failed.")
-		return err
-	}
 
-	// launch the API RPC endpoint.
+	cc, err := setupCmdContext(c, true)
-	if n.Config.Addresses.API == "" {
-		return errors.New("no config.RPCAddress endpoint supplied")
-	}
-
-	maddr, err := ma.NewMultiaddr(n.Config.Addresses.API)
 	if err != nil {
 		return err
 	}
+	defer cc.daemon.Close()
 
-	dl, err := daemon.NewDaemonListener(n, maddr, conf)
+	// update fsdir with flag.
-	if err != nil {
+	fsdir := cc.node.Config.Mounts.IPFS
-		fmt.Println("Failed to create daemon listener.")
+	if val, ok := c.Flag.Lookup("f").Value.Get().(string); ok && val != "" {
-		return err
+		fsdir = val
 	}
-	go dl.Listen()
+	fsdone := mountIpfs(cc.node, fsdir)
-	defer dl.Close()
 
-	mp := c.Flag.Lookup("f").Value.Get().(string)
+	// get default mount points
-	fmt.Printf("Mounting at %s\n", mp)
+	nsdir := cc.node.Config.Mounts.IPNS
+	if val, ok := c.Flag.Lookup("n").Value.Get().(string); ok && val != "" {
+		nsdir = val
+	}
+	nsdone := mountIpns(cc.node, nsdir, fsdir)
+
+	// wait till mounts are done.
+	err1 := <-fsdone
+	err2 := <-nsdone
+
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+func mountIpfs(node *core.IpfsNode, fsdir string) <-chan error {
+	done := make(chan error)
+	fmt.Printf("mounting ipfs at %s\n", fsdir)
 
-	var ipnsDone chan struct{}
-	ns, ok := c.Flag.Lookup("n").Value.Get().(string)
-	if ok && ns != "" {
-		ipnsDone = make(chan struct{})
 	go func() {
-			err = ipns.Mount(n, ns, mp)
+		err := rofs.Mount(node, fsdir)
-			if err != nil {
+		done <- err
-				fmt.Printf("Error mounting ipns: %s\n", err)
+		close(done)
-			}
-			ipnsDone <- struct{}{}
 	}()
+
+	return done
 }
 
-	err = rofs.Mount(n, mp)
+func mountIpns(node *core.IpfsNode, nsdir, fsdir string) <-chan error {
-	if ipnsDone != nil {
+	done := make(chan error)
-		<-ipnsDone
+	fmt.Printf("mounting ipns at %s\n", nsdir)
-	}
+
-	return err
+	go func() {
+		err := ipns.Mount(node, nsdir, fsdir)
+		done <- err
+		close(done)
+	}()
+
+	return done
 }

config/config.go

@@ -29,6 +29,12 @@ type Addresses struct {
 	API   string // address for the local API (RPC)
 }
 
+// Mounts stores the (string) mount points
+type Mounts struct {
+	IPFS string
+	IPNS string
+}
+
 // BootstrapPeer is a peer used to bootstrap the network.
 type BootstrapPeer struct {
 	Address string
@@ -40,6 +46,7 @@ type Config struct {
 	Identity  Identity         // local node's peer identity
 	Datastore Datastore        // local node's storage
 	Addresses Addresses        // local node's addresses
+	Mounts    Mounts           // local node's mount points
 	Bootstrap []*BootstrapPeer // local nodes's bootstrap peers
 }