[WIP] Implement CoreAPI

api.go

@@ -0,0 +1,116 @@
+package shell
+
+import (
+	"context"
+	"errors"
+	"os"
+	"strings"
+	"path/filepath"
+	"io/ioutil"
+	"net/http"
+
+	homedir "github.com/mitchellh/go-homedir"
+	iface "github.com/ipfs/go-ipfs/core/coreapi/interface"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr-net"
+)
+
+const (
+	DefaultPathName = ".ipfs"
+	DefaultPathRoot = "~/" + DefaultPathName
+	DefaultApiFile  = "api"
+	EnvDir          = "IPFS_PATH"
+)
+
+type httpApi struct{
+	url    string
+	client *http.Client
+}
+
+func NewLocalApi() (iface.CoreAPI, error) {
+	baseDir := os.Getenv(EnvDir)
+	if baseDir == "" {
+		baseDir = DefaultPathRoot
+	}
+
+	baseDir, err := homedir.Expand(baseDir)
+	if err != nil {
+		return nil, err
+	}
+
+	apiFile := filepath.Join(baseDir, DefaultApiFile)
+
+	if _, err := os.Stat(apiFile); err != nil {
+		return nil, err
+	}
+
+	api, err := ioutil.ReadFile(apiFile)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewApi(strings.TrimSpace(string(api)))
+}
+
+func NewApi(url string) (iface.CoreAPI, error) {
+	if a, err := ma.NewMultiaddr(url); err == nil {
+		_, host, err := manet.DialArgs(a)
+		if err == nil {
+			url = host
+		}
+	}
+
+	return &httpApi{
+		url: url,
+		client: &http.Client{
+			Transport: &http.Transport{
+				DisableKeepAlives: true,
+			},
+		},
+	}, nil
+}
+
+// Unixfs returns the UnixfsAPI interface backed by the go-ipfs node
+func (api *httpApi) Unixfs() iface.UnixfsAPI {
+	return nil
+}
+
+func (api *httpApi) Block() iface.BlockAPI {
+	return nil
+}
+
+// Dag returns the DagAPI interface backed by the go-ipfs node
+func (api *httpApi) Dag() iface.DagAPI {
+	return nil
+}
+
+// Name returns the NameAPI interface backed by the go-ipfs node
+func (api *httpApi) Name() iface.NameAPI {
+	return nil
+}
+
+// Key returns the KeyAPI interface backed by the go-ipfs node
+func (api *httpApi) Key() iface.KeyAPI {
+	return (*httpKeyApi)(api)
+}
+
+//Object returns the ObjectAPI interface backed by the go-ipfs node
+func (api *httpApi) Object() iface.ObjectAPI {
+	return nil
+}
+
+func (api *httpApi) Pin() iface.PinAPI {
+	return nil
+}
+
+// ResolveNode resolves the path `p` using Unixfs resolver, gets and returns the
+// resolved Node.
+func (api *httpApi) ResolveNode(ctx context.Context, p iface.Path) (iface.Node, error) {
+	return nil, errors.New("TODO")
+}
+
+// ResolvePath resolves the path `p` using Unixfs resolver, returns the
+// resolved path.
+func (api *httpApi) ResolvePath(ctx context.Context, p iface.Path) (iface.Path, error) {
+	return nil, errors.New("TODO")
+}

key.go

@@ -0,0 +1,76 @@
+package shell
+
+import (
+	"context"
+	"errors"
+	"encoding/json"
+
+	"github.com/ipfs/go-ipfs/core/coreapi/interface"
+	"github.com/ipfs/go-ipfs/core/coreapi/interface/options"
+)
+
+type httpKeyApi httpApi
+
+type key struct {
+	KeyName string `json:"Name"`
+	Id      string `json:"Id"`
+}
+
+func (k *key) Name() string {
+	return k.KeyName
+}
+
+func (k *key) Path() iface.Path {
+	return nil //TODO
+}
+
+
+func (api *httpKeyApi) Generate(ctx context.Context, name string, opts ...options.KeyGenerateOption) (iface.Key, error) {
+	return nil, errors.New("TODO")
+}
+
+func (api *httpKeyApi) WithType(algorithm string) options.KeyGenerateOption {
+	return nil
+}
+
+func (api *httpKeyApi) WithSize(size int) options.KeyGenerateOption {
+	return nil
+}
+
+func (api *httpKeyApi) Rename(ctx context.Context, oldName string, newName string, opts ...options.KeyRenameOption) (iface.Key, bool, error) {
+	return nil, false, errors.New("TODO")
+}
+
+func (api *httpKeyApi) WithForce(force bool) options.KeyRenameOption {
+	return nil
+}
+
+func (api *httpKeyApi) List(ctx context.Context) ([]iface.Key, error) {
+	resp, err := api.core().newRequest(ctx, "key/list").Send(api.client)
+	if err != nil {
+		return nil, err
+	}
+
+	var res = struct{
+		Keys []*key
+	}{}
+
+	if err := json.NewDecoder(resp.Output).Decode(&res); err != nil {
+		return nil, err
+	}
+
+	out := make([]iface.Key, len(res.Keys))
+	for i, e := range res.Keys {
+		out[i] = e
+	}
+
+	return out, nil
+}
+
+func (api *httpKeyApi) Remove(ctx context.Context, name string) (iface.Path, error) {
+	return nil, errors.New("TODO")
+}
+
+func (api *httpKeyApi) core() *httpApi {
+	return (*httpApi)(api)
+}

key_test.go

@@ -0,0 +1,24 @@
+package shell
+
+import (
+	"testing"
+	"context"
+)
+
+//TODO: create utils to run tests on a proper test node
+func TestListSelf(t *testing.T) {
+	ctx := context.Background()
+	api, err := NewLocalApi()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	keys, err := api.Key().List(ctx)
+	if err != nil {
+		t.Fatalf("failed to list keys: %s", err)
+	}
+
+	if keys[0].Name() != "self" {
+		t.Errorf("expected the key to be called 'self', got '%s'", keys[0].Name())
+	}
+}

legacy.go

@@ -0,0 +1,19 @@
+package shell
+
+import (
+	gohttp "net/http"
+
+	"github.com/ipfs/go-ipfs-api/legacy"
+)
+
+func NewLocalShell() *legacy.Shell {
+	return legacy.NewLocalShell()
+}
+
+func NewShell(url string) *legacy.Shell {
+	return legacy.NewShell(url)
+}
+
+func NewShellWithClient(url string, c *gohttp.Client) *legacy.Shell {
+	return legacy.NewShellWithClient(url, c)
+}

dag.go → legacy/dag.go

@@ -1,4 +1,4 @@
-package shell
+package legacy
 
 import (
 	"bytes"

ipns.go → legacy/ipns.go

@@ -1,4 +1,4 @@
-package shell
+package legacy
 
 import (
 	"context"

pubsub.go → legacy/pubsub.go

@@ -1,4 +1,4 @@
-package shell
+package legacy
 
 import (
 	"encoding/binary"