Skip to content

GitLab

Commit 7e11c600 authored by Hector Sanjuan's avatar Hector Sanjuan
Browse files

Docs: Improve echo example 



* Do not use testutil to generate random keys and ids since this is a testing
dependency. Use crypto.GenerateKeyPair() instead.
* Echo full lines
* Improve output by telling the user what to run
* More code comments

License: MIT
Signed-off-by: default avatarHector Sanjuan <hector@protocol.ai>
parent a1240fdd
Hide whitespace changes
Inline Side-by-side
examples/echo/README.md
View file @ 7e11c600
......@@ -25,18 +25,19 @@ From `go-libp2p` base folder:
## Usage
```
> ./echo -l 1235
2016/11/10 10:45:37 I am /ip4/127.0.0.1/tcp/1235/ipfs/QmNtX1cvrm2K6mQmMEaMxAuB4rTexhd87vpYVot4sEZzxc
2016/11/10 10:45:37 listening for connections
> ./echo -l 10000
2017/03/15 14:11:32 I am /ip4/127.0.0.1/tcp/10000/ipfs/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e
2017/03/15 14:11:32 Now run "./echo -l 10001 -d /ip4/127.0.0.1/tcp/10000/ipfs/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e -secio" on a different terminal
2017/03/15 14:11:32 listening for connections
```
The listener libp2p host will print its `Multiaddress`, which indicates how it
can be reached (ip4+tcp) and its randomly generated ID (`QmNtX1cv...`)
can be reached (ip4+tcp) and its randomly generated ID (`QmYo41Gyb...`)
Now, launch another node that talks to the listener:
```
> ./echo -d /ip4/127.0.0.1/tcp/1235/ipfs/QmNtX1cvrm2K6mQmMEaMxAuB4rTexhd87vpYVot4sEZzxc -l 1236
> ./echo -l 10001 -d /ip4/127.0.0.1/tcp/10000/ipfs/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e
```
The new node with send the message `"Hello, world!"` to the
......@@ -61,9 +62,9 @@ In order to create the swarm (and a `basichost`), the example needs:
* An
[ipfs-procotol ID](https://godoc.org/github.com/libp2p/go-libp2p-peer#ID)
like `QmNtX1cvrm2K6mQmMEaMxAuB4rTexhd87vpYVot4sEZzxc`. The example
autogenerates this on every run. An optional key-pair to secure
communications can be added to it. The example autogenerates them when
using `-secio`.
autogenerates a key pair on every run and uses an ID extracted from the
public key (the hash of the public key). When using `-secio`, it uses
the key pair to encrypt communications.
* A [Multiaddress](https://godoc.org/github.com/multiformats/go-multiaddr),
which indicates how to reach this peer. There can be several of them
(using different protocols or locations for example). Example:
......
examples/echo/main.go
View file @ 7e11c600
package main
import (
"bufio"
"context"
"flag"
"fmt"
"io/ioutil"
"log"
"math/rand"
"strings"
"time"
golog "github.com/ipfs/go-log"
crypto "github.com/libp2p/go-libp2p-crypto"
host "github.com/libp2p/go-libp2p-host"
net "github.com/libp2p/go-libp2p-net"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
swarm "github.com/libp2p/go-libp2p-swarm"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
testutil "github.com/libp2p/go-testutil"
ma "github.com/multiformats/go-multiaddr"
gologging "github.com/whyrusleeping/go-logging"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
)
// create a 'Host' with a random peer to listen on the given address
func makeBasicHost(listen string, secio bool) (host.Host, error) {
addr, err := ma.NewMultiaddr(listen)
// makeBasicHost creates a LibP2P host with a random peer ID listening on the
// given multiaddress. It will use secio if secio is true.
func makeBasicHost(listenPort int, secio bool) (host.Host, error) {
// Generate a key pair for this host. We will use it at least
// to obtain a valid host ID.
priv, pub, err := crypto.GenerateKeyPair(crypto.RSA, 2048)
if err != nil {
return nil, err
}
// Obtain Peer ID from public key
pid, err := peer.IDFromPublicKey(pub)
if err != nil {
return nil, err
}
// Create a multiaddress
addr, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", listenPort))
if err != nil {
return nil, err
}
// Create a peerstore
ps := pstore.NewPeerstore()
var pid peer.ID
// If using secio, we add the keys to the peerstore
// for this peer ID.
if secio {
ident, err := testutil.RandIdentity()
if err != nil {
return nil, err
}
ident.PrivateKey()
ps.AddPrivKey(ident.ID(), ident.PrivateKey())
ps.AddPubKey(ident.ID(), ident.PublicKey())
pid = ident.ID()
} else {
fakepid, err := testutil.RandPeerID()
if err != nil {
return nil, err
}
pid = fakepid
ps.AddPrivKey(pid, priv)
ps.AddPubKey(pid, pub)
}
ctx := context.Background()
// Create swarm (implements libP2P Network)
netwrk, err := swarm.NewNetwork(
context.Background(),
[]ma.Multiaddr{addr},
pid,
ps,
nil)
// create a new swarm to be used by the service host
netw, err := swarm.NewNetwork(ctx, []ma.Multiaddr{addr}, pid, ps, nil)
if err != nil {
return nil, err
basicHost := bhost.New(netwrk)
// Build host multiaddress
hostAddr, _ := ma.NewMultiaddr(fmt.Sprintf("/ipfs/%s", basicHost.ID().Pretty()))
// Now we can build a full multiaddress to reach this host
// by encapsulating both addresses:
fullAddr := addr.Encapsulate(hostAddr)
log.Printf("I am %s\n", fullAddr)
if secio {
log.Printf("Now run \"./echo -l %d -d %s -secio\" on a different terminal\n", listenPort+1, fullAddr)
} else {
log.Printf("Now run \"./echo -l %d -d %s\" on a different terminal\n", listenPort+1, fullAddr)
}
log.Printf("I am %s/ipfs/%s\n", addr, pid.Pretty())
return bhost.New(netw), nil
return basicHost, nil
}
func main() {
rand.Seed(time.Now().UnixNano())
// 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.INFO) // 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")
secio := flag.Bool("secio", false, "enable secio")
flag.Parse()
if *listenF == 0 {
log.Fatal("Please provide a port to bind on with -l")
}
listenaddr := fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", *listenF)
ha, err := makeBasicHost(listenaddr, *secio)
// Make a host that listens on the given multiaddress
ha, err := makeBasicHost(*listenF, *secio)
if err != nil {
log.Fatal(err)
}
// Set a stream handler on host A
// 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 net.Stream) {
log.Println("Got a new stream!")
defer s.Close()
......@@ -93,8 +114,10 @@ func main() {
log.Println("listening for connections")
select {} // hang forever
}
// This is where the listener code ends
/**** 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)
......@@ -110,26 +133,26 @@ func main() {
log.Fatalln(err)
}
tptaddr := strings.Split(ipfsaddr.String(), "/ipfs/")[0]
// This creates a MA with the "/ip4/ipaddr/tcp/port" part of the target
tptmaddr, err := ma.NewMultiaddr(tptaddr)
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)
// We need to add the target to our peerstore, so we know how we can
// contact it
ha.Peerstore().AddAddr(peerid, tptmaddr, pstore.PermanentAddrTTL)
// 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("opening stream")
// make a new stream from host B to host A
// it should be handled on host A by the handler we set above
// 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)
}
_, err = s.Write([]byte("Hello, world!"))
_, err = s.Write([]byte("Hello, world!\n"))
if err != nil {
log.Fatalln(err)
}
......@@ -142,18 +165,17 @@ func main() {
log.Printf("read reply: %q\n", out)
}
// doEcho reads some data from a stream, writes it back and closes the
// stream.
// doEcho reads a line of data a stream and writes it back
func doEcho(s net.Stream) {
buf := make([]byte, 1024)
n, err := s.Read(buf)
buf := bufio.NewReader(s)
str, err := buf.ReadString('\n')
if err != nil {
log.Println(err)
return
}
log.Printf("read request: %q\n", buf[:n])
_, err = s.Write(buf[:n])
log.Printf("read: %s\n", str)
_, err = s.Write([]byte(str))
if err != nil {
log.Println(err)
return
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment