added ipfs swarm connect

core/commands2/swarm.go

@@ -3,9 +3,15 @@ package commands
 import (
 	"bytes"
 	"fmt"
+	"path"
 
 	cmds "github.com/jbenet/go-ipfs/commands"
+	internal "github.com/jbenet/go-ipfs/core/commands2/internal"
+	peer "github.com/jbenet/go-ipfs/peer"
 	errors "github.com/jbenet/go-ipfs/util/debugerror"
+
+	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
+	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
 type stringList struct {
@@ -26,8 +32,8 @@ ipfs peers in the internet.
 `,
 	},
 	Subcommands: map[string]*cmds.Command{
-		"peers": swarmPeersCmd,
-		// "connect": swarmConnectCmd,
+		"peers":   swarmPeersCmd,
+		"connect": swarmConnectCmd,
 	},
 }
 
@@ -66,6 +72,62 @@ ipfs swarm peers lists the set of peers this node is connected to.
 	Type: &stringList{},
 }
 
+var swarmConnectCmd = &cmds.Command{
+	Helptext: cmds.HelpText{
+		Tagline: "Open connection to a given peer",
+		ShortDescription: `
+'ipfs swarm connect' opens a connection to a peer address. The address format
+is an ipfs multiaddr:
+
+ipfs swarm connect /ip4/104.131.131.82/tcp/4001/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ
+`,
+	},
+	Arguments: []cmds.Argument{
+		cmds.StringArg("address", true, true, "address of peer to connect to"),
+	},
+	Run: func(req cmds.Request) (interface{}, error) {
+		ctx := context.TODO()
+
+		log.Debug("ipfs swarm connect")
+		n, err := req.Context().GetNode()
+		if err != nil {
+			return nil, err
+		}
+
+		addrs, err := internal.CastToStrings(req.Arguments())
+		if err != nil {
+			return nil, cmds.ClientError("Improperly formatted peer addresses: " + err.Error())
+		}
+
+		if n.Network == nil {
+			return nil, errNotOnline
+		}
+
+		peers, err := peersWithAddresses(n.Peerstore, addrs)
+		if err != nil {
+			return nil, err
+		}
+
+		output := make([]string, len(peers))
+		for i, p := range peers {
+			output[i] = "connect " + p.ID().String()
+
+			err := n.Network.DialPeer(ctx, p)
+			if err != nil {
+				output[i] += " failure: " + err.Error()
+			} else {
+				output[i] += " success"
+			}
+		}
+
+		return &stringList{output}, nil
+	},
+	Marshalers: cmds.MarshalerMap{
+		cmds.Text: stringListMarshaler,
+	},
+	Type: &stringList{},
+}
+
 func stringListMarshaler(res cmds.Response) ([]byte, error) {
 	list, ok := res.Output().(*stringList)
 	if !ok {
@@ -79,3 +141,41 @@ func stringListMarshaler(res cmds.Response) ([]byte, error) {
 	}
 	return buf.Bytes(), nil
 }
+
+// splitAddresses is a function that takes in a slice of string peer addresses
+// (multiaddr + peerid) and returns slices of multiaddrs and peerids.
+func splitAddresses(addrs []string) (maddrs []ma.Multiaddr, pids []peer.ID, err error) {
+
+	maddrs = make([]ma.Multiaddr, len(addrs))
+	pids = make([]peer.ID, len(addrs))
+	for i, addr := range addrs {
+		a, err := ma.NewMultiaddr(path.Dir(addr))
+		if err != nil {
+			return nil, nil, cmds.ClientError("invalid peer address: " + err.Error())
+		}
+		maddrs[i] = a
+		pids[i] = peer.DecodePrettyID(path.Base(addr))
+	}
+	return
+}
+
+// peersWithAddresses is a function that takes in a slice of string peer addresses
+// (multiaddr + peerid) and returns a slice of properly constructed peers
+func peersWithAddresses(ps peer.Peerstore, addrs []string) ([]peer.Peer, error) {
+	maddrs, pids, err := splitAddresses(addrs)
+	if err != nil {
+		return nil, err
+	}
+
+	peers := make([]peer.Peer, len(pids))
+	for i, pid := range pids {
+		p, err := ps.Get(pid)
+		if err != nil {
+			return nil, err
+		}
+
+		p.AddAddress(maddrs[i])
+		peers[i] = p
+	}
+	return peers, nil
+}