fix(ios): enable tcp shell on ios simulator only

android/bridge/src/main/java/ipfs/gomobile/android/IPFS.java

@@ -112,7 +112,7 @@ synchronized public void start()
 
         try {
             node = Ipfs.newNode(repo);
-            node.serveOnUDS(absSockPath);
+            node.serveUnixSocketAPI(absSockPath);
         } catch (Exception e) {
             throw new NodeStartException("Node start failed", e);
         }

go/bind/ipfs/bind_config.go → go/bind/ipfs/config.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io/ioutil"
 
-	mobile_config "github.com/berty/gomobile-ipfs/go/bind/ipfs/config"
 	ipfs_config "github.com/ipfs/go-ipfs-config"
 	ipfs_common "github.com/ipfs/go-ipfs/repo/common"
 )
@@ -21,7 +20,7 @@ func NewConfig(raw_json []byte) (cfg *Config, err error) {
 }
 
 func NewDefaultConfig() (*Config, error) {
-	cfg, err := mobile_config.InitConfig(ioutil.Discard, 2048)
+	cfg, err := initConfig(ioutil.Discard, 2048)
 	if err != nil {
 		return nil, err
 	}

go/bind/ipfs/config/init.go → go/bind/ipfs/init.go

@@ -1,4 +1,4 @@
-package config
+package ipfs
 
 import (
 	"encoding/base64"
@@ -12,7 +12,7 @@ import (
 	libp2p_peer "github.com/libp2p/go-libp2p-core/peer"
 )
 
-func InitConfig(out io.Writer, nBitsForKeypair int) (*ipfs_config.Config, error) {
+func initConfig(out io.Writer, nBitsForKeypair int) (*ipfs_config.Config, error) {
 	identity, err := identityConfig(out, nBitsForKeypair)
 	if err != nil {
 		return nil, err

go/bind/ipfs/bind_node.go → go/bind/ipfs/node.go

@@ -9,6 +9,7 @@ package ipfs
 
 import (
 	"context"
+	"fmt"
 	"log"
 
 	mobile_host "github.com/berty/gomobile-ipfs/go/pkg/host"
@@ -19,19 +20,29 @@ import (
 )
 
 type Node struct {
-	*mobile_node.IpfsMobile
+	ipfsMobile *mobile_node.IpfsMobile
 }
 
 func (n *Node) Close() error {
-	return n.IpfsMobile.Close()
+	return n.ipfsMobile.Close()
 }
 
 func (n *Node) ServeUnixSocketAPI(sockpath string) error {
-	return n.IpfsMobile.Serve("/unix/" + sockpath)
+	return n.ipfsMobile.Serve("/unix/" + sockpath)
 }
 
-func (n *Node) ServeTCPAPI(port string) error {
-	return n.IpfsMobile.Serve("/ip4/127.0.0.1/tcp/" + port)
+// Serve API on the given port and return the current listening maddr
+func (n *Node) ServeTCPAPI(port string) (string, error) {
+	if err := n.ipfsMobile.Serve("/ip4/127.0.0.1/tcp/" + port); err != nil {
+		return "", err
+	}
+
+	// get the last maddr added
+	if addrs := n.ipfsMobile.GetAPIAddrs(); len(addrs) > 0 {
+		return addrs[len(addrs)-1], nil
+	}
+
+	return "", fmt.Errorf("unable to serve api, no listener registered")
 }
 
 func NewNode(r *Repo) (*Node, error) {

go/bind/ipfs/bind_test.go → go/bind/ipfs/node_test.go

@@ -8,8 +8,6 @@ import (
 	"testing"
 
 	ipfs_config "github.com/ipfs/go-ipfs-config"
-	ma "github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr-net"
 
 	. "github.com/smartystreets/goconvey/convey"
 )
@@ -33,9 +31,12 @@ func TestMobile(t *testing.T) {
 	var (
 		testCfg  *Config
 		testRepo *Repo
-		testNode Node
+		testNode *Node
 		testID   *ipfs_config.Identity
 
+		sockpath string
+		tcpaddr  string
+
 		err error
 	)
 
@@ -57,6 +58,26 @@ func TestMobile(t *testing.T) {
 	}()
 
 	Convey("test config", t, FailureHalts, func() {
+		Convey("test sockmanager", FailureHalts, func() {
+			var sm *SockManager
+
+			wrongpath := strings.Repeat("a", 110)
+			sm, err = NewSockManager(wrongpath)
+			So(err, ShouldNotBeNil)
+			So(sm, ShouldBeNil)
+
+			sm, err = NewSockManager(tmpdir)
+			So(err, ShouldBeNil)
+			So(sm, ShouldNotBeNil)
+
+			for i := 0; i < 100; i++ {
+				sockpath, err = sm.NewSockPath()
+				So(err, ShouldBeNil)
+				So(sockpath, ShouldNotBeEmpty)
+				So(len(sockpath), ShouldBeLessThan, 104)
+			}
+		})
+
 		Convey("test get/set config", FailureHalts, func() {
 			var cfg *Config
 			var val []byte
@@ -136,11 +157,7 @@ func TestMobile(t *testing.T) {
 			ok = RepoIsInitialized(tmpdir)
 			So(ok, ShouldBeFalse)
 
-			testCfg.SetupTCPAPI("0")
-			testCfg.SetupUnixSocketAPI("api.sock")
-
-			testCfg.SetupTCPGateway("0")
-			testCfg.SetupUnixSocketGateway("gateway.sock")
+			testCfg.SetupUnixSocketAPI(sockpath)
 
 			// init repo
 			err = InitRepo(tmpdir, testCfg)
@@ -164,10 +181,14 @@ func TestMobile(t *testing.T) {
 		Convey("test node", FailureHalts, func() {
 			testNode, err = NewNode(testRepo)
 			So(err, ShouldBeNil)
+
+			tcpaddr, err = testNode.ServeTCPAPI("0")
+			So(err, ShouldBeNil)
+			So(tcpaddr, ShouldNotBeEmpty)
 		})
 
 		Convey("test Unix Soscket shell", FailureHalts, func() {
-			socketaddr := "/unix/" + tmpdir + "/api.sock"
+			socketaddr := "/unix/" + sockpath
 			shell, err := NewShell(socketaddr)
 			So(err, ShouldBeNil)
 
@@ -177,7 +198,7 @@ func TestMobile(t *testing.T) {
 			So(err, ShouldBeNil)
 
 			api := struct {
-				Addrs []string `json:"Value"`
+				Addrs string `json:"Value"`
 			}{}
 
 			err = json.Unmarshal(res, &api)
@@ -186,26 +207,10 @@ func TestMobile(t *testing.T) {
 		})
 
 		Convey("test TCP shell", FailureHalts, func() {
-			addrs := strings.Split(testNode.GetApiAddrs(), ",")
-			So(len(addrs), ShouldBeGreaterThan, 0)
-			apiaddr := ""
-			for _, addr := range addrs {
-				maddr, err := ma.NewMultiaddr(addr)
-				So(err, ShouldBeNil)
-
-				naddr, err := manet.ToNetAddr(maddr)
-				So(err, ShouldBeNil)
-				if naddr.Network() == "tcp" {
-					apiaddr = addr
-				}
-			}
-
-			So(apiaddr, ShouldNotBeEmpty)
-
-			shell, err := NewShell(apiaddr)
+			shell, err := NewShell(tcpaddr)
 			So(err, ShouldBeNil)
-			out, err := shell.Request("id", nil)
 
+			out, err := shell.Request("id", nil)
 			So(err, ShouldBeNil)
 
 			id := struct {

go/pkg/node/node.go

@@ -32,6 +32,25 @@ func (im *IpfsMobile) Close() error {
 	return err
 }
 
+// GetApiAddrs return current api listeners (separate with a comma)
+func (im *IpfsMobile) GetAPIAddrs() (addrs []string) {
+	im.muListeners.Lock()
+
+	addrs = make([]string, len(im.listeners))
+	for i, l := range im.listeners {
+		a, err := manet.FromNetAddr(l.Addr())
+		if err == nil {
+			addrs[i] = a.String()
+		} else {
+			log.Printf("unable to get multiaddr from `%s`: %s", l.Addr().String(), err)
+		}
+
+	}
+	im.muListeners.Unlock()
+
+	return addrs
+}
+
 func NewNode(ctx context.Context, repo *MobileRepo, mcfg *host.MobileConfig) (*IpfsMobile, error) {
 	cfg, err := repo.Config()
 	if err != nil {

go/pkg/node/node_api.go

@@ -14,6 +14,7 @@ import (
 	manet "github.com/multiformats/go-multiaddr-net"
 )
 
+// @TODO: return multiaddr served
 func (im *IpfsMobile) Serve(maddrs ...string) error {
 	var err error
 
@@ -60,7 +61,8 @@ func (im *IpfsMobile) Serve(maddrs ...string) error {
 		l := manet.NetListener(ml)
 		go func(l net.Listener) {
 			if err := ipfs_corehttp.Serve(im.IpfsNode, l, opts...); err != nil {
-				log.Printf("serve error: %s", err)
+				l.Close()
+				log.Printf("Serve on `%s` failed: %s", maddr.String(), err)
 			}
 		}(l)
 

ios/GomobileIPFS/Classes/IPFS.swift

@@ -107,10 +107,11 @@ public class IPFS: NSObject {
         // serve api
         var err: NSError?
 
+        // init shell
         #if targetEnvironment(simulator) // fallback on tcp on simulator
-        try node.serve(onTCPPort: "4555")
+        let maddr: String = try node.serve(onTCPPort: "0")
         // init shell
-        if let shell = IpfsNewTCPShell("4555", &err) {
+        if let shell = IpfsNewShell(maddr, &err) {
             self.shell = shell
         } else {
             throw IpfsError.runtimeError("unable to get shell")

ios/GomobileIPFS/Classes/Node.swift

@@ -15,10 +15,10 @@ public enum NodeError: Error {
 
 public class Node {
     let node: IpfsNode
-    
+
     public init(_ repo: Repo) throws {
         var err: NSError?
-        
+
         if let node = IpfsNewNode(repo.goRepo, &err) {
             self.node = node
         } else if let error = err {
@@ -31,12 +31,20 @@ public class Node {
     public func close() throws {
         try self.node.close()
     }
-    
+
     public func serve(onUDS: String) throws {
         try self.node.serveUnixSocketAPI(onUDS)
     }
-
-    public func serve(onTCPPort: String) throws {
-        try self.node.serveTCPAPI(onTCPPort)
+
+    // return the multiaddr from listener
+    public func serve(onTCPPort: String) throws -> String {
+        var err: NSError?
+
+        let maddr = self.node.serveTCPAPI(onTCPPort, error: &err)
+        if let error = err {
+            throw NodeError.runtimeError(error, "unable to serve api")
+        }
+
+        return maddr
     }
 }