check for API -- WIP

jbenet · jbenet · commit 0fe6fe296627 · 2015-08-22T21:34:48.000+02:00
This is a WIP to make the ipfs cli tool check for a running daemon
via the API, and make sure the APIs match.

I ran into some complexity i need to think more about before
attepting to fix... anyone feel free to pick this up!

License: MIT
Signed-off-by: Juan Batiz-Benet &lt;juan@benet.ai&gt;
diff --git a/cmd/ipfs/main.go b/cmd/ipfs/main.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"math/rand"
 	"os"
 	"os/signal"
@@ -23,6 +24,7 @@ import (
 	cmdsCli "github.com/ipfs/go-ipfs/commands/cli"
 	cmdsHttp "github.com/ipfs/go-ipfs/commands/http"
 	core "github.com/ipfs/go-ipfs/core"
+	coreCmds "github.com/ipfs/go-ipfs/core/commands"
 	config "github.com/ipfs/go-ipfs/repo/config"
 	fsrepo "github.com/ipfs/go-ipfs/repo/fsrepo"
 	eventlog "github.com/ipfs/go-ipfs/thirdparty/eventlog"
@@ -32,8 +34,12 @@ import (
 // log is the command logger
 var log = eventlog.Logger("cmd/ipfs")
 
-// signal to output help
-var errHelpRequested = errors.New("Help Requested")
+var (
+	errHelpRequested       = errors.New("Help Requested")
+	errApiNotRunning       = errors.New("api not running")
+	errUnexpectedApiOutput = errors.New("api returned unexpected output")
+	errApiVersionMismatch  = errors.New("api version mismatch")
+)
 
 const (
 	EnvEnableProfiling = "IPFS_PROF"
@@ -293,6 +299,9 @@ func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd
 	}
 
 	log.Debug("looking for running daemon...")
+
+	getApiClient(repoPath, apiAddrStr)
+
 	useDaemon, err := commandShouldRunOnDaemon(*details, req, root)
 	if err != nil {
 		return nil, err
@@ -571,3 +580,69 @@ func profileIfEnabled() (func(), error) {
 	}
 	return func() {}, nil
 }
+
+// getApiClient checks the repo, and the given options, checking for
+// a running API service. if there is one, it returns a client.
+// otherwise, it returns errApiNotRunning, or another error.
+func getApiClient(repoPath, apiAddrStr string) (*cmdsHttp.Client, error) {
+	// parse given option
+	if apiAddrStr != "" {
+		addr, err = ma.NewMultiaddr(apiAddrStr)
+	} else { // get opt from file.
+		addr, err = fsrepo.APIAddr(repoPath)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	client, err := apiClientForAddr(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	// make sure the api is actually running.
+	// this is slow, as it might mean an RTT to a remote server.
+	// TODO: optimize some way
+	if err := checkApiVersionMatch(client); err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}
+
+// apiVersionMatches checks whether the api server is running the
+// same version of go-ipfs. for now, only the exact same version of
+// client + server work. In the future, we should use semver for
+// proper API versioning! \o/
+func apiVersionMatches(client *cmdsHttp.Client) (err error) {
+	cmd := coreCmds.VersionCmd
+	req, err := cmds.NewRequest([]string{"version"}, nil, nil, nil, cmd, nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := client.Send(req)
+	if err != nil {
+		return err
+	}
+
+	ver, ok := res.Output().(*coreCmds.VersionOutput)
+	if !ok {
+		return errApiOutputErr
+	}
+
+	currv := config.CurrentVersionNumber
+	if ver.Version != currv {
+		return fmt.Errorf("%s (%s != %s)", errApiVersionMismatch, ver.Version, currv)
+	}
+	return nil
+}
+
+func apiClientForAddr(addr ma.Multiaddr) (*cmdsHttp.Client, error) {
+	_, host, err := manet.DialArgs(addr)
+	if err != nil {
+		return false, err
+	}
+
+	return cmdsHttp.NewClient(host), nil
+}
diff --git a/repo/fsrepo/fsrepo.go b/repo/fsrepo/fsrepo.go
@@ -15,6 +15,7 @@ import (
 	levelds "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/leveldb"
 	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/measure"
 	"github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/mount"
+	ma "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 	ldbopts "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt"
 	repo "github.com/ipfs/go-ipfs/repo"
 	"github.com/ipfs/go-ipfs/repo/common"
@@ -58,6 +59,7 @@ func (err NoRepoError) Error() string {
 const (
 	leveldbDirectory = "datastore"
 	flatfsDirectory  = "blocks"
+	apiFile          = "api"
 )
 
 var (
@@ -285,14 +287,36 @@ func Remove(repoPath string) error {
 // process. If true, then the repo cannot be opened by this process.
 func LockedByOtherProcess(repoPath string) (bool, error) {
 	repoPath = path.Clean(repoPath)
-
-	// TODO replace this with the "api" file
-	// https://github.com/ipfs/specs/tree/master/repo/fs-repo
-
 	// NB: the lock is only held when repos are Open
 	return lockfile.Locked(repoPath)
 }
 
+// APIAddr returns the registered API addr, according to the api file
+// in the fsrepo. This is a concurrent operation, meaning that any
+// process may read this file. modifying this file, therefore, should
+// use "mv" to replace the whole file and avoid interleaved read/writes.
+func APIAddr(repoPath string) (ma.Multiaddr, error) {
+	repoPath = path.Clean(repoPath)
+	apiFilePath := path.Join(repoPath, apiFile)
+
+	// if there is no file, assume there is no api addr.
+	f, err := os.Open(apiFilePath)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	// read up to 2048 bytes. io.ReadAll is a vulnerability, as
+	// someone could hose the process by putting a massive file there.
+	buf := make([]byte, 0, 2048)
+	n, err := f.Read(buf)
+	if err != nil && err != io.EOF {
+		return "", err
+	}
+
+	return ma.NewMultiaddr(string(buf[:n]))
+}
+
 // openConfig returns an error if the config file is not present.
 func (r *FSRepo) openConfig() error {
 	configFilename, err := config.Filename(r.path)
