Merge pull request #146 from libp2p/fix/examples

Update examples

examples/echo/README.md

+# 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!"
+>
+```

examples/hosts/main.go → 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
 	}
 
-		log.Printf("read data: %q\n", buf[:n])
+	log.Printf("read request: %q\n", buf[:n])
 	_, err = s.Write(buf[:n])
 	if err != nil {
 		log.Println(err)
 		return
 	}
-	}
 }

examples/hosts/README.md

-# 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
-```
-

examples/justtcp/README.md

-# 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
-```

examples/justtcp/main.go

-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)
-}