Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/jbenet/go-peerstream
p2p stream multi-multiplexing in Go (with https://github.com/docker/spdystream)
https://github.com/jbenet/go-peerstream
Last synced: 18 days ago
JSON representation
p2p stream multi-multiplexing in Go (with https://github.com/docker/spdystream)
- Host: GitHub
- URL: https://github.com/jbenet/go-peerstream
- Owner: jbenet
- License: mit
- Created: 2014-12-14T17:04:49.000Z (almost 10 years ago)
- Default Branch: master
- Last Pushed: 2017-09-20T19:42:33.000Z (about 7 years ago)
- Last Synced: 2024-10-09T23:07:29.417Z (30 days ago)
- Language: Go
- Homepage:
- Size: 1.83 MB
- Stars: 56
- Watchers: 10
- Forks: 18
- Open Issues: 6
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-peer-to-peer - go-peerstream - multiplexing in Go (Libraries)
- awesome-peer-to-peer - go-peerstream - multiplexing in Go (Libraries)
README
# go-peerstream p2p multi-multixplexing
Package peerstream is a peer-to-peer networking library that multiplexes
connections to many hosts. It tried to simplify the complexity of:
* accepting incoming connections over **multiple** listeners
* dialing outgoing connections over **multiple** transports
* multiplexing **multiple** connections per-peer
* multiplexing **multiple** different servers or protocols
* handling backpressure correctly
* handling stream multiplexing (we use SPDY, but maybe QUIC some day)
* providing a **simple** interface to the user
### Godoc: https://godoc.org/github.com/jbenet/go-peerstream
---
See this working [example/example.go](example/example):
```Go
package main
import (
"fmt"
"io"
"net"
"os"
ps "github.com/jbenet/go-peerstream"
)
func main() {
// create a new Swarm
swarm := ps.NewSwarm()
defer swarm.Close()
// tell swarm what to do with a new incoming streams.
// EchoHandler just echos back anything they write.
swarm.SetStreamHandler(ps.EchoHandler)
// Okay, let's try listening on some transports
l1, err := net.Listen("tcp", "localhost:8001")
if err != nil {
panic(err)
}
l2, err := net.Listen("tcp", "localhost:8002")
if err != nil {
panic(err)
}
// tell swarm to accept incoming connections on these
// listeners. Swarm will start accepting new connections.
if err := swarm.AddListener(l1); err != nil {
panic(err)
}
if err := swarm.AddListener(l2); err != nil {
panic(err)
}
// ok, let's try some outgoing connections
nc1, err := net.Dial("tcp", "localhost:8001")
if err != nil {
panic(err)
}
nc2, err := net.Dial("tcp", "localhost:8002")
if err != nil {
panic(err)
}
// add them to the swarm
c1, err := swarm.AddConn(nc1)
if err != nil {
panic(err)
}
c2, err := swarm.AddConn(nc2)
if err != nil {
panic(err)
}
// Swarm treats listeners as sources of new connections and does
// not distinguish between outgoing or incoming connections.
// It provides the net.Conn to the StreamHandler so you can
// distinguish between them however you wish.
// now let's try opening some streams!
// You can specify what connection you want to use
s1, err := swarm.NewStreamWithConn(c1)
if err != nil {
panic(err)
}
// Or, you can specify a SelectConn function that picks between all
// (it calls NewStreamWithConn underneath the hood)
s2, err := swarm.NewStreamSelectConn(func(conns []*ps.Conn) *ps.Conn {
if len(conns) > 0 {
return conns[0]
}
return nil
})
if err != nil {
panic(err)
}
// Or, you can bind connections to ConnGroup ids. You can bind a conn to
// multiple groups. And, if conn wasn't in swarm, it calls swarm.AddConn.
// You can use any Go `KeyType` as a group A `KeyType` as in maps...)
swarm.AddConnToGroup(c2, 1)
// And then use that group to select a connection. Swarm will use any
// connection it finds in that group, using a SelectConn you can rebind:
// swarm.SetGroupSelectConn(1, SelectConn)
// swarm.SetDegaultGroupSelectConn(SelectConn)
s3, err := swarm.NewStreamWithGroup(1)
if err != nil {
panic(err)
}
// Why groups? It's because with many connections, and many transports,
// and many Servers (or Protocols), we can use the Swarm to associate
// a different StreamHandlers per group, and to let us create NewStreams
// on a given group.
// Ok, we have streams. now what. Use them! Our Streams are basically
// streams from github.com/docker/spdystream, so they work the same
// way:
for i, stream := range []ps.Stream{s1, s2, s3} {
stream.Wait()
str := "stream %d ready:"
fmt.Fprintf(stream, str, i)
buf := make([]byte, len(str))
stream.Read(buf)
fmt.Println(string(buf))
}
go io.Copy(os.Stdout, s1)
go io.Copy(os.Stdout, s2)
go io.Copy(os.Stdout, s3)
io.Copy(io.MultiWriter(s1, s2, s3), os.Stdin)
}
func log(s string) {
fmt.Fprintf(os.Stderr, s+"\n")
}
```