add pingpong http api

README.md

@@ -6,22 +6,21 @@ Work in progress. This is by no means the final abstraction.
 
 ## Usage
 
-In one terminal:
+Execute the same command in two terminals to start `node 1` and `node 2`:
 
 ```sh
 go run ./cmd/bee
 ```
 
-Copy one of the multiaddresses.
-
-In another terminal
+Copy one of the multiaddresses from one running instance.
 
+Make an HTTP request to `localhost:{PORT1}/pingpong/{MULTIADDRESS2}` like:
 
 ```sh
-go run ./cmd/bee -target COPIED_ADDRESS
+curl localhost:8080/pingpong/ip4/127.0.0.1/tcp/60304/p2p/Qmdao2FbfSK8ZcFxuUVmVDPUJifgRmbofNWH21WQESZm7x
 ```
 
-Ping pong messages should be exchanged.
+Ping pong messages should be exchanged from `node 1` (listening on `PORT1`) to `node 2` (with multiaddress `MULTIADDRESS2`).
 
 ## Structure
 

cmd/bee/main.go

@@ -5,14 +5,15 @@ import (
 	"flag"
 	"fmt"
 	"log"
-	"sync"
+	"net"
+	"net/http"
 
+	"github.com/janos/bee/pkg/api"
 	"github.com/janos/bee/pkg/p2p/libp2p"
 	"github.com/janos/bee/pkg/pingpong"
-	"github.com/multiformats/go-multiaddr"
 )
 
-var target = flag.String("target", "", "")
+var addr = flag.String("addr", ":0", "http api listen address")
 
 func main() {
 	flag.Parse()
@@ -23,7 +24,7 @@ func main() {
 	//var idht *dht.IpfsDHT
 
 	// Construct P2P service.
-	s, err := libp2p.New(ctx, libp2p.Options{
+	p2ps, err := libp2p.New(ctx, libp2p.Options{
 		// Routing: func(h host.Host) (r routing.PeerRouting, err error) {
 		// 	idht, err = dht.New(ctx, h)
 		// 	return idht, err
@@ -34,16 +35,14 @@ func main() {
 	}
 
 	// Construct protocols.
-	pingPong := pingpong.New(s)
+	pingPong := pingpong.New(p2ps)
 
 	// Add protocols to the P2P service.
-	if err = s.AddProtocol(pingPong.Protocol()); err != nil {
+	if err = p2ps.AddProtocol(pingPong.Protocol()); err != nil {
 		log.Fatal("pingpong service: ", err)
 	}
 
-	// Bellow is only demo code.
-
-	addrs, err := s.Addresses()
+	addrs, err := p2ps.Addresses()
 	if err != nil {
 		log.Fatal("get server addresses: ", err)
 	}
@@ -52,41 +51,17 @@ func main() {
 		fmt.Println(addr)
 	}
 
-	if *target != "" {
-		for i := 1; i <= 10; i++ {
-			addr, err := multiaddr.NewMultiaddr(*target)
-			if err != nil {
-				log.Fatal("parse target address: ", err)
-			}
-			peerID, err := s.Connect(ctx, addr)
-			if err != nil {
-				log.Fatal("connect to target: ", err)
-			}
-
-			var wg sync.WaitGroup
-			wg.Add(2)
-
-			go func() {
-				defer wg.Done()
-				rtt, err := pingPong.Ping(ctx, peerID, "hey", "there", ",", "how are", "you", "?")
-				if err != nil {
-					log.Fatal("ping: ", err)
-				}
-				fmt.Println("RTT 1", i, rtt)
-			}()
-
-			go func() {
-				defer wg.Done()
-				rtt, err := pingPong.Ping(ctx, peerID, "1", "2", "3", "4", "5", "6")
-				if err != nil {
-					log.Fatal("ping: ", err)
-				}
-				fmt.Println("RTT 2", i, rtt)
-			}()
+	h := api.New(api.Options{
+		P2P:      p2ps,
+		Pingpong: pingPong,
+	})
 
-			wg.Wait()
-		}
+	l, err := net.Listen("tcp", *addr)
+	if err != nil {
+		log.Fatal("tcp: ", err)
 	}
 
-	select {}
+	log.Println("listening: ", l.Addr())
+
+	log.Fatal(http.Serve(l, h))
 }

go.mod

@@ -4,6 +4,7 @@ go 1.13
 
 require (
 	github.com/gogo/protobuf v1.3.1
+	github.com/gorilla/handlers v1.4.2
 	github.com/ipfs/go-log v1.0.1 // indirect
 	github.com/libp2p/go-conn-security v0.1.0 // indirect
 	github.com/libp2p/go-libp2p v0.5.0
@@ -30,5 +31,6 @@ require (
 	github.com/whyrusleeping/go-smux-multistream v2.0.2+incompatible // indirect
 	github.com/whyrusleeping/go-smux-yamux v2.0.9+incompatible // indirect
 	github.com/whyrusleeping/yamux v1.2.0 // indirect
-	honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099
+	honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc
+	resenje.org/web v0.4.0
 )

pkg/api/api.go

+package api
+
+import (
+	"net/http"
+
+	"github.com/janos/bee/pkg/p2p"
+	"github.com/janos/bee/pkg/pingpong"
+)
+
+type server struct {
+	Options
+	http.Handler
+}
+
+type Options struct {
+	P2P      p2p.Service
+	Pingpong *pingpong.Service
+}
+
+func New(o Options) http.Handler {
+	s := &server{
+		Options: o,
+	}
+
+	s.setupRouting()
+
+	return s
+}

pkg/api/pingpong.go

+package api
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/multiformats/go-multiaddr"
+)
+
+func (s *server) pingpongHandler(w http.ResponseWriter, r *http.Request) {
+	target := strings.TrimPrefix(r.URL.Path, "/pingpong")
+
+	addr, err := multiaddr.NewMultiaddr(target)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		fmt.Fprintln(w, "invalid address", target, err)
+		return
+	}
+
+	ctx := r.Context()
+
+	peerID, err := s.P2P.Connect(ctx, addr)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		fmt.Fprintln(w, "connect error", addr, err)
+		return
+	}
+
+	rtt, err := s.Pingpong.Ping(ctx, peerID, "hey", "there", ",", "how are", "you", "?")
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		fmt.Fprintln(w, "ping error", addr, err)
+		return
+	}
+
+	fmt.Fprintln(w, "RTT", rtt)
+}

pkg/api/router.go

+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gorilla/handlers"
+	"resenje.org/web"
+)
+
+func (s *server) setupRouting() {
+	baseRouter := http.NewServeMux()
+
+	baseRouter.HandleFunc("/robots.txt", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "User-agent: *\nDisallow: /")
+	})
+
+	baseRouter.HandleFunc("/pingpong/", s.pingpongHandler)
+
+	s.Handler = web.ChainHandlers(
+		handlers.CompressHandler,
+		web.FinalHandler(baseRouter),
+	)
+}