status-im
/
go-libp2p
mirror of https://github.com/status-im/go-libp2p.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #146 from libp2p/fix/examples 

Update examples
This commit is contained in:
Jeromy Johnson 2016-11-09 11:01:26 -08:00 committed by GitHub
parent 1c10ed41da f3812decb8
commit 647d20ae2c
5 changed files with 59 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
examples/echo/README.md Normal file
View File

@ -0,0 +1,41 @@
# Echo client/server with libp2p
This example can be started in either listen mode (server), or dial mode (client).
In listen mode, it will sit and wait for incoming connections on
the `/echo/1.0.0` protocol. Whenever it receives a stream, it will
write whatever message it received, and close the stream.
In dial mode, it will connect to the target peer on the given address.
It then opens a stream, writes a short message on the same protocol,
and print whatever reply it receives.
## Build
```
> make deps
> go build ./examples/hosts
```
## Usage
In one terminal:
```
> ./hosts -l 4737
2016/11/06 04:37:00 I am /ip4/127.0.0.1/tcp/4737/ipfs/QmXzbaXtBw6mU29WoeYrCtcRLVbT8asWCcEFVuDy4w6pdq
2016/11/06 04:37:00 listening for connections
2016/11/06 04:37:01 got a new stream
2016/11/06 04:37:01 read request: "Hello, world!"
```
In another, copy the address printed by the listener and do:
```
> ./hosts -d /ip4/127.0.0.1/tcp/4737/ipfs/QmXzbaXtBw6mU29WoeYrCtcRLVbT8asWCcEFVuDy4w6pdq
2016/11/06 04:37:01 I am /ip4/127.0.0.1/tcp/0/ipfs/QmeMNYMmkgoyd8M7y925r4yVVDjKtiYtU4rNCyj7wDWzk1
2016/11/06 04:37:01 connecting to target
2016/11/06 04:37:01 opening stream
2016/11/06 04:37:01 read reply: "Hello, world!"
>
```

37
examples/hosts/main.go → examples/echo/main.go
View File

@ -67,7 +67,7 @@ func main() {
flag.Parse()
listenaddr := fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", *listenF)
listenaddr := fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", *listenF)
ha, err := makeDummyHost(listenaddr, *secio)
if err != nil {
@ -76,12 +76,13 @@ func main() {
// Set a stream handler on host A
ha.SetStreamHandler("/echo/1.0.0", func(s net.Stream) {
log.Println("Got a new stream!")
log.Println("got a new stream")
doEcho(s)
defer s.Close()
})
if *target == "" {
log.Println("listening for connections...")
log.Println("listening for connections")
select {} // hang forever
}
@ -117,15 +118,15 @@ func main() {
log.Fatalln(err)
}
log.Println("opening stream...")
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
s, err := ha.NewStream(context.Background(), peerid, "/hello/1.0.0")
s, err := ha.NewStream(context.Background(), peerid, "/echo/1.0.0")
if err != nil {
log.Fatalln(err)
}
_, err = s.Write([]byte("Hello world of peer two peer"))
_, err = s.Write([]byte("Hello, world!"))
if err != nil {
log.Fatalln(err)
}
@ -135,23 +136,21 @@ func main() {
log.Fatalln(err)
}
log.Println("GOT: ", string(out))
log.Printf("read reply: %q\n", out)
}
func doEcho(s inet.Stream) {
buf := make([]byte, 1024)
for {
n, err := s.Read(buf)
if err != nil {
log.Println(err)
return
}
n, err := s.Read(buf)
if err != nil {
log.Println(err)
return
}
log.Printf("read data: %q\n", buf[:n])
_, err = s.Write(buf[:n])
if err != nil {
log.Println(err)
return
}
log.Printf("read request: %q\n", buf[:n])
_, err = s.Write(buf[:n])
if err != nil {
log.Println(err)
return
}
}

28
examples/hosts/README.md
View File

@ -1,28 +0,0 @@
# libp2p host example
## What this does
This example can be started in either listen mode, or dial mode.
When running as a listener, it will sit and wait for incoming connections on
the `/hello/1.0.0` protocol. Whenever it receives a stream, it will
write the message "hello libp2p" over the stream and close it.
When run in dial mode, the node will start up, connect to the given
address, open a stream to the target peer, and read a message on the
protocol `/hello/1.0.0`
## Building
```
$ go build
```
## Usage
In one terminal:
```
$ ./hosts -l 4737
```
In another, copy the address printed by the listener and do:
```
$ ./hosts -d ADDRESS
```

16
examples/justtcp/README.md
View File

@ -1,16 +0,0 @@
# libp2p 'just tcp' example
## What this does
This example starts up a libp2p swarm that listens for tcp connections behind a
multistream muxer protocol of `/plaintext/1.0.0`. All connections made to it
will be echoed back.
## Building
```
$ go build
```
## Usage
```
$ ./justtcp
```

59
examples/justtcp/main.go
View File

@ -1,59 +0,0 @@
package main
import (
"context"
"fmt"
"os"
"github.com/libp2p/go-libp2p-swarm"
tcpt "github.com/libp2p/go-tcp-transport"
ma "github.com/multiformats/go-multiaddr"
)
func fatal(i interface{}) {
fmt.Println(i)
os.Exit(1)
}
func main() {
laddr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/5555")
if err != nil {
fatal(err)
}
// create a new swarm with a dummy peer ID, no private key, and no stream muxer
s := swarm.NewBlankSwarm(context.Background(), "bob", nil, nil)
// Add a TCP transport to it
s.AddTransport(tcpt.NewTCPTransport())
// Add an address to start listening on
err = s.AddListenAddr(laddr)
if err != nil {
fatal(err)
}
// Set a handler for incoming connections
s.SetConnHandler(func(c *swarm.Conn) {
fmt.Println("Got a new connection!")
defer c.Close()
buf := make([]byte, 1024)
for {
n, err := c.RawConn().Read(buf)
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("read: %q\n", string(buf[:n]))
_, err = c.RawConn().Write(buf[:n])
if err != nil {
fmt.Println(err)
return
}
}
})
// Wait forever
<-make(chan bool)
}