ceremonyclient/go-libp2p/examples/routed-echo/main.go

195 lines
5.0 KiB
Go
Raw Normal View History

2023-08-21 03:50:38 +00:00
package main
import (
"bufio"
"context"
"crypto/rand"
"flag"
"fmt"
"io"
"log"
mrand "math/rand"
"github.com/libp2p/go-libp2p"
"github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/host"
"github.com/libp2p/go-libp2p/core/network"
"github.com/libp2p/go-libp2p/core/peer"
ds "github.com/ipfs/go-datastore"
dsync "github.com/ipfs/go-datastore/sync"
golog "github.com/ipfs/go-log/v2"
dht "github.com/libp2p/go-libp2p-kad-dht"
rhost "github.com/libp2p/go-libp2p/p2p/host/routed"
ma "github.com/multiformats/go-multiaddr"
)
// makeRoutedHost creates a LibP2P host with a random peer ID listening on the
// given multiaddress. It will bootstrap using the provided PeerInfo.
func makeRoutedHost(listenPort int, randseed int64, bootstrapPeers []peer.AddrInfo, globalFlag string) (host.Host, error) {
// If the seed is zero, use real cryptographic randomness. Otherwise, use a
// deterministic randomness source to make generated keys stay the same
// across multiple runs
var r io.Reader
if randseed == 0 {
r = rand.Reader
} else {
r = mrand.New(mrand.NewSource(randseed))
}
// Generate a key pair for this host. We will use it at least
// to obtain a valid host ID.
priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, r)
if err != nil {
return nil, err
}
opts := []libp2p.Option{
libp2p.ListenAddrStrings(fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", listenPort)),
libp2p.Identity(priv),
libp2p.DefaultTransports,
libp2p.DefaultMuxers,
libp2p.DefaultSecurity,
libp2p.NATPortMap(),
}
ctx := context.Background()
basicHost, err := libp2p.New(opts...)
if err != nil {
return nil, err
}
// Construct a datastore (needed by the DHT). This is just a simple, in-memory thread-safe datastore.
dstore := dsync.MutexWrap(ds.NewMapDatastore())
// Make the DHT
dht := dht.NewDHT(ctx, basicHost, dstore)
// Make the routed host
routedHost := rhost.Wrap(basicHost, dht)
// connect to the chosen ipfs nodes
err = bootstrapConnect(ctx, routedHost, bootstrapPeers)
if err != nil {
return nil, err
}
// Bootstrap the host
err = dht.Bootstrap(ctx)
if err != nil {
return nil, err
}
// Build host multiaddress
2024-06-08 11:32:45 +00:00
hostAddr, _ := ma.NewMultiaddr(fmt.Sprintf("/ipfs/%s", routedHost.ID()))
2023-08-21 03:50:38 +00:00
// Now we can build a full multiaddress to reach this host
// by encapsulating both addresses:
// addr := routedHost.Addrs()[0]
addrs := routedHost.Addrs()
log.Println("I can be reached at:")
for _, addr := range addrs {
log.Println(addr.Encapsulate(hostAddr))
}
2024-06-08 11:32:45 +00:00
log.Printf("Now run \"./routed-echo -l %d -d %s%s\" on a different terminal\n", listenPort+1, routedHost.ID(), globalFlag)
2023-08-21 03:50:38 +00:00
return routedHost, nil
}
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(golog.LevelInfo) // Change to INFO 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")
seed := flag.Int64("seed", 0, "set random seed for id generation")
global := flag.Bool("global", false, "use global ipfs peers for bootstrapping")
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
var bootstrapPeers []peer.AddrInfo
var globalFlag string
if *global {
log.Println("using global bootstrap")
bootstrapPeers = IPFS_PEERS
globalFlag = " -global"
} else {
log.Println("using local bootstrap")
bootstrapPeers = getLocalPeerInfo()
globalFlag = ""
}
ha, err := makeRoutedHost(*listenF, *seed, bootstrapPeers, globalFlag)
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 ****/
peerid, err := peer.Decode(*target)
if err != nil {
log.Fatalln(err)
}
// peerinfo := peer.AddrInfo{ID: peerid}
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 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!\n"))
if err != nil {
log.Fatalln(err)
}
out, err := io.ReadAll(s)
if err != nil {
log.Fatalln(err)
}
log.Printf("read reply: %q\n", out)
}
// doEcho reads a line of data from 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
}