diff --git a/examples/echo/README.md b/examples/echo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..4a0ca8b6d8c889cc270a62e9bcf3a09e321059a9 --- /dev/null +++ b/examples/echo/README.md @@ -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!" +> +``` diff --git a/examples/hosts/main.go b/examples/echo/main.go similarity index 83% rename from examples/hosts/main.go rename to examples/echo/main.go index ed66256fa441340feb8f9f62b5dcc30adff21412..55abc801bab44c4411288e35f7d819164ab3a7d3 100644 --- a/examples/hosts/main.go +++ b/examples/echo/main.go @@ -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 } } diff --git a/examples/hosts/README.md b/examples/hosts/README.md deleted file mode 100644 index cec309d27f70207fa5b59d5c1877d203b4617854..0000000000000000000000000000000000000000 --- a/examples/hosts/README.md +++ /dev/null @@ -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 -``` - diff --git a/examples/justtcp/README.md b/examples/justtcp/README.md deleted file mode 100644 index 9c6b486e90bdadffba41650a61dd1bacbdb316ed..0000000000000000000000000000000000000000 --- a/examples/justtcp/README.md +++ /dev/null @@ -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 -``` diff --git a/examples/justtcp/main.go b/examples/justtcp/main.go deleted file mode 100644 index e9f53b00f93df508836da8f16f666a787d8320df..0000000000000000000000000000000000000000 --- a/examples/justtcp/main.go +++ /dev/null @@ -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) -}