139 lines
3.4 KiB
Go
139 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
|
|
utils "interop/utils"
|
|
|
|
"github.com/libp2p/go-libp2p-core/network"
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
|
"github.com/libp2p/go-libp2p-core/peerstore"
|
|
|
|
golog "github.com/ipfs/go-log"
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
gologging "github.com/whyrusleeping/go-logging"
|
|
)
|
|
|
|
func main() {
|
|
// LibP2P code uses golog to log messages. They log with different
|
|
// string IDs (i.e. "swarm"). We can control the verbosity level for
|
|
// all loggers with:
|
|
golog.SetAllLoggers(gologging.DEBUG) // Change to DEBUG for extra info
|
|
|
|
// Parse options from the command line
|
|
listenF := flag.Int("l", 0, "wait for incoming connections")
|
|
target := flag.String("d", "", "target peer to dial")
|
|
insecure := flag.Bool("insecure", false, "use an unencrypted connection")
|
|
seed := flag.Int64("seed", 0, "set random seed for id generation")
|
|
flag.Parse()
|
|
|
|
if *listenF == 0 {
|
|
log.Fatal("Please provide a port to bind on with -l")
|
|
}
|
|
|
|
// Make a host that listens on the given multiaddress
|
|
ha, err := utils.MakeBasicHost(*listenF, *insecure, *seed)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
// Set a stream handler on host A. /echo/1.0.0 is
|
|
// a user-defined protocol name.
|
|
ha.SetStreamHandler("/echo/1.0.0", func(s network.Stream) {
|
|
log.Println("Got a new stream!")
|
|
if err := doEcho(s); err != nil {
|
|
log.Println(err)
|
|
s.Reset()
|
|
} else {
|
|
s.Close()
|
|
}
|
|
})
|
|
|
|
if *target == "" {
|
|
log.Println("listening for connections")
|
|
select {} // hang forever
|
|
}
|
|
/**** This is where the listener code ends ****/
|
|
|
|
// The following code extracts target's the peer ID from the
|
|
// given multiaddress
|
|
ipfsaddr, err := ma.NewMultiaddr(*target)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
pid, err := ipfsaddr.ValueForProtocol(ma.P_IPFS)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
peerid, err := peer.IDB58Decode(pid)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
// Decapsulate the /ipfs/<peerID> part from the target
|
|
// /ip4/<a.b.c.d>/ipfs/<peer> becomes /ip4/<a.b.c.d>
|
|
targetPeerAddr, _ := ma.NewMultiaddr(
|
|
fmt.Sprintf("/ipfs/%s", peer.IDB58Encode(peerid)))
|
|
targetAddr := ipfsaddr.Decapsulate(targetPeerAddr)
|
|
log.Println("!@# targetAddr=", targetAddr)
|
|
|
|
// We have a peer ID and a targetAddr so we add it to the peerstore
|
|
// so LibP2P knows how to contact it
|
|
ha.Peerstore().AddAddr(peerid, targetAddr, peerstore.PermanentAddrTTL)
|
|
|
|
log.Println("!@# ipfsaddr=", ipfsaddr)
|
|
pinfo, err := peer.AddrInfoFromP2pAddr(ipfsaddr)
|
|
if err != nil {
|
|
log.Fatalf("failed to parse %v to pinfo\n", ipfsaddr)
|
|
}
|
|
|
|
err = ha.Connect(context.Background(), *pinfo)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
log.Println("connect with peer", *pinfo)
|
|
|
|
// make a new stream from host B to host A
|
|
// it should be handled on host A by the handler we set above because
|
|
// we use the same /echo/1.0.0 protocol
|
|
s, err := ha.NewStream(context.Background(), peerid, "/echo/1.0.0")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
log.Println("opened stream")
|
|
|
|
_, err = s.Write([]byte("Hello, world!\n"))
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
out, err := ioutil.ReadAll(s)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
log.Printf("read reply: %q\n", out)
|
|
}
|
|
|
|
// doEcho reads a line of data a stream and writes it back
|
|
func doEcho(s network.Stream) error {
|
|
buf := bufio.NewReader(s)
|
|
str, err := buf.ReadString('\n')
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
log.Printf("read: %s\n", str)
|
|
_, err = s.Write([]byte(str))
|
|
return err
|
|
}
|