Skip to content

GitLab

Unverified Commit 9f25f923 authored by Abhishek Upperwal's avatar Abhishek Upperwal Committed by GitHub
Browse files

Merge pull request #2 from libp2p/master 

refactor merge
parents aedbe954 9e5ef7a4
Hide whitespace changes
Inline Side-by-side
examples/protocol-multiplexing-with-multicodecs/main.go
View file @ 9f25f923
......@@ -8,15 +8,11 @@ import (
"math/rand"
"time"
crypto "github.com/libp2p/go-libp2p-crypto"
host "github.com/libp2p/go-libp2p-host"
inet "github.com/libp2p/go-libp2p-net"
peer "github.com/libp2p/go-libp2p-peer"
ps "github.com/libp2p/go-libp2p-peerstore"
swarm "github.com/libp2p/go-libp2p-swarm"
ma "github.com/multiformats/go-multiaddr"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
libp2p "github.com/libp2p/go-libp2p"
multicodec "github.com/multiformats/go-multicodec"
json "github.com/multiformats/go-multicodec/json"
)
......@@ -80,17 +76,11 @@ var conversationMsgs = []string{
}
func makeRandomHost(port int) host.Host {
// Ignoring most errors for brevity
// See echo example for more details and better implementation
priv, pub, _ := crypto.GenerateKeyPair(crypto.RSA, 2048)
pid, _ := peer.IDFromPublicKey(pub)
listen, _ := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port))
ps := ps.NewPeerstore()
ps.AddPrivKey(pid, priv)
ps.AddPubKey(pid, pub)
n, _ := swarm.NewNetwork(context.Background(),
[]ma.Multiaddr{listen}, pid, ps, nil)
return bhost.New(n)
h, err := libp2p.New(context.Background(), libp2p.ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)))
if err != nil {
panic(err)
}
return h
}
func main() {
......
libp2p.go
View file @ 9f25f923
......@@ -2,240 +2,49 @@ package libp2p
import (
"context"
"crypto/rand"
"fmt"
crypto "github.com/libp2p/go-libp2p-crypto"
config "github.com/libp2p/go-libp2p/config"
host "github.com/libp2p/go-libp2p-host"
pnet "github.com/libp2p/go-libp2p-interface-pnet"
metrics "github.com/libp2p/go-libp2p-metrics"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
swarm "github.com/libp2p/go-libp2p-swarm"
transport "github.com/libp2p/go-libp2p-transport"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
mux "github.com/libp2p/go-stream-muxer"
ma "github.com/multiformats/go-multiaddr"
mplex "github.com/whyrusleeping/go-smux-multiplex"
msmux "github.com/whyrusleeping/go-smux-multistream"
yamux "github.com/whyrusleeping/go-smux-yamux"
)
// Config describes a set of settings for a libp2p node
type Config struct {
Transports []transport.Transport
Muxer mux.Transport
ListenAddrs []ma.Multiaddr
PeerKey crypto.PrivKey
Peerstore pstore.Peerstore
Protector pnet.Protector
Reporter metrics.Reporter
DisableSecio bool
EnableNAT bool
}
type Option func(cfg *Config) error
type Config = config.Config
func Transports(tpts ...transport.Transport) Option {
return func(cfg *Config) error {
cfg.Transports = append(cfg.Transports, tpts...)
return nil
}
}
// Option is a libp2p config option that can be given to the libp2p constructor
// (`libp2p.New`).
type Option = config.Option
func ListenAddrStrings(s ...string) Option {
// ChainOptions chains multiple options into a single option.
func ChainOptions(opts ...Option) Option {
return func(cfg *Config) error {
for _, addrstr := range s {
a, err := ma.NewMultiaddr(addrstr)
if err != nil {
for _, opt := range opts {
if err := opt(cfg); err != nil {
return err
}
cfg.ListenAddrs = append(cfg.ListenAddrs, a)
}
return nil
}
}
func ListenAddrs(addrs ...ma.Multiaddr) Option {
return func(cfg *Config) error {
cfg.ListenAddrs = append(cfg.ListenAddrs, addrs...)
return nil
}
}
type transportEncOpt int
const (
EncPlaintext = transportEncOpt(0)
EncSecio = transportEncOpt(1)
)
func TransportEncryption(tenc ...transportEncOpt) Option {
return func(cfg *Config) error {
if len(tenc) != 1 {
return fmt.Errorf("can only specify a single transport encryption option right now")
}
// TODO: actually make this pluggable, otherwise tls will get tricky
switch tenc[0] {
case EncPlaintext:
cfg.DisableSecio = true
case EncSecio:
// noop
default:
return fmt.Errorf("unrecognized transport encryption option: %d", tenc[0])
}
return nil
}
}
func NoEncryption() Option {
return TransportEncryption(EncPlaintext)
}
func NATPortMap() Option {
return func(cfg *Config) error {
cfg.EnableNAT = true
return nil
}
}
func Muxer(m mux.Transport) Option {
return func(cfg *Config) error {
if cfg.Muxer != nil {
return fmt.Errorf("cannot specify multiple muxer options")
}
cfg.Muxer = m
return nil
}
}
func Peerstore(ps pstore.Peerstore) Option {
return func(cfg *Config) error {
if cfg.Peerstore != nil {
return fmt.Errorf("cannot specify multiple peerstore options")
}
cfg.Peerstore = ps
return nil
}
}
func PrivateNetwork(prot pnet.Protector) Option {
return func(cfg *Config) error {
if cfg.Protector != nil {
return fmt.Errorf("cannot specify multiple private network options")
}
cfg.Protector = prot
return nil
}
}
func BandwidthReporter(rep metrics.Reporter) Option {
return func(cfg *Config) error {
if cfg.Reporter != nil {
return fmt.Errorf("cannot specify multiple bandwidth reporter options")
}
cfg.Reporter = rep
return nil
}
}
func Identity(sk crypto.PrivKey) Option {
return func(cfg *Config) error {
if cfg.PeerKey != nil {
return fmt.Errorf("cannot specify multiple identities")
}
cfg.PeerKey = sk
return nil
}
}
// New constructs a new libp2p node with the given options (falling back on
// reasonable defaults).
//
// Canceling the passed context will stop the returned libp2p node.
func New(ctx context.Context, opts ...Option) (host.Host, error) {
var cfg Config
for _, opt := range opts {
if err := opt(&cfg); err != nil {
return nil, err
}
}
return newWithCfg(ctx, &cfg)
return NewWithoutDefaults(ctx, append(opts, FallbackDefaults)...)
}
func newWithCfg(ctx context.Context, cfg *Config) (host.Host, error) {
// If no key was given, generate a random 2048 bit RSA key
if cfg.PeerKey == nil {
priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, rand.Reader)
if err != nil {
return nil, err
}
cfg.PeerKey = priv
}
// Obtain Peer ID from public key
pid, err := peer.IDFromPublicKey(cfg.PeerKey.GetPublic())
if err != nil {
return nil, err
}
// Create a new blank peerstore if none was passed in
ps := cfg.Peerstore
if ps == nil {
ps = pstore.NewPeerstore()
}
// Set default muxer if none was passed in
muxer := cfg.Muxer
if muxer == nil {
muxer = DefaultMuxer()
}
// If secio is disabled, don't add our private key to the peerstore
if !cfg.DisableSecio {
ps.AddPrivKey(pid, cfg.PeerKey)
ps.AddPubKey(pid, cfg.PeerKey.GetPublic())
}
swrm, err := swarm.NewSwarmWithProtector(ctx, cfg.ListenAddrs, pid, ps, cfg.Protector, muxer, cfg.Reporter)
if err != nil {
// NewWithoutDefaults constructs a new libp2p node with the given options but
// *without* falling back on reasonable defaults.
//
// Warning: This function should not be considered a stable interface. We may
// choose to add required services at any time and, by using this function, you
// opt-out of any defaults we may provide.
func NewWithoutDefaults(ctx context.Context, opts ...Option) (host.Host, error) {
var cfg Config
if err := cfg.Apply(opts...); err != nil {
return nil, err
}
netw := (*swarm.Network)(swrm)
hostOpts := &bhost.HostOpts{}
if cfg.EnableNAT {
hostOpts.NATManager = bhost.NewNATManager(netw)
}
return bhost.NewHost(ctx, netw, hostOpts)
}
func DefaultMuxer() mux.Transport {
// Set up stream multiplexer
tpt := msmux.NewBlankTransport()
// By default, support yamux and multiplex
tpt.AddTransport("/yamux/1.0.0", yamux.DefaultTransport)
tpt.AddTransport("/mplex/6.3.0", mplex.DefaultTransport)
return tpt
}
func Defaults(cfg *Config) error {
// Create a multiaddress that listens on a random port on all interfaces
addr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/0")
if err != nil {
return err
}
cfg.ListenAddrs = []ma.Multiaddr{addr}
cfg.Peerstore = pstore.NewPeerstore()
cfg.Muxer = DefaultMuxer()
return nil
return cfg.NewNode(ctx)
}
libp2p_test.go
View file @ 9f25f923
......@@ -3,6 +3,7 @@ package libp2p
import (
"context"
"fmt"
"strings"
"testing"
crypto "github.com/libp2p/go-libp2p-crypto"
......@@ -10,10 +11,32 @@ import (
)
func TestNewHost(t *testing.T) {
_, err := makeRandomHost(t, 9000)
h, err := makeRandomHost(t, 9000)
if err != nil {
t.Fatal(err)
}
h.Close()
}
func TestBadTransportConstructor(t *testing.T) {
ctx := context.Background()
h, err := New(ctx, Transport(func() {}))
if err == nil {
h.Close()
t.Fatal("expected an error")
}
if !strings.Contains(err.Error(), "libp2p_test.go") {
t.Error("expected error to contain debugging info")
}
}
func TestInsecure(t *testing.T) {
ctx := context.Background()
h, err := New(ctx, NoSecurity)
if err != nil {
t.Fatal(err)
}
h.Close()
}
func makeRandomHost(t *testing.T, port int) (host.Host, error) {
......@@ -26,7 +49,9 @@ func makeRandomHost(t *testing.T, port int) (host.Host, error) {
opts := []Option{
ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)),
Identity(priv),
Muxer(DefaultMuxer()),
DefaultTransports,
DefaultMuxers,
DefaultSecurity,
NATPortMap(),
}
......
options.go 0 → 100644
View file @ 9f25f923
package libp2p
// This file contains all libp2p configuration options (except the defaults,
// those are in defaults.go)
import (
"fmt"
"net"
config "github.com/libp2p/go-libp2p/config"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
circuit "github.com/libp2p/go-libp2p-circuit"
crypto "github.com/libp2p/go-libp2p-crypto"
ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
pnet "github.com/libp2p/go-libp2p-interface-pnet"
metrics "github.com/libp2p/go-libp2p-metrics"
pstore "github.com/libp2p/go-libp2p-peerstore"
filter "github.com/libp2p/go-maddr-filter"
ma "github.com/multiformats/go-multiaddr"
)
// ListenAddrStrings configures libp2p to listen on the given (unparsed)
// addresses.
func ListenAddrStrings(s ...string) Option {
return func(cfg *Config) error {
for _, addrstr := range s {
a, err := ma.NewMultiaddr(addrstr)
if err != nil {
return err
}
cfg.ListenAddrs = append(cfg.ListenAddrs, a)
}
return nil
}
}
// ListenAddrs configures libp2p to listen on the given addresses.
func ListenAddrs(addrs ...ma.Multiaddr) Option {
return func(cfg *Config) error {
cfg.ListenAddrs = append(cfg.ListenAddrs, addrs...)
return nil
}
}
// Security configures libp2p to use the given security transport (or transport
// constructor).
//
// Name is the protocol name.
//
// The transport can be a constructed security.Transport or a function taking
// any subset of this libp2p node's:
// * Public key
// * Private key
// * Peer ID
// * Host
// * Network
// * Peerstore
func Security(name string, tpt interface{}) Option {
stpt, err := config.SecurityConstructor(tpt)
err = traceError(err, 1)
return func(cfg *Config) error {
if err != nil {
return err
}
if cfg.Insecure {
return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
}
cfg.SecurityTransports = append(cfg.SecurityTransports, config.MsSecC{SecC: stpt, ID: name})
return nil
}
}
// NoSecurity is an option that completely disables all transport security.
// It's incompatible with all other transport security protocols.
var NoSecurity Option = func(cfg *Config) error {
if len(cfg.SecurityTransports) > 0 {
return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
}
cfg.Insecure = true
return nil
}
// Muxer configures libp2p to use the given stream multiplexer (or stream
// multiplexer constructor).
//
// Name is the protocol name.
//
// The transport can be a constructed mux.Transport or a function taking any
// subset of this libp2p node's:
// * Peer ID
// * Host
// * Network
// * Peerstore
func Muxer(name string, tpt interface{}) Option {
mtpt, err := config.MuxerConstructor(tpt)
err = traceError(err, 1)
return func(cfg *Config) error {
if err != nil {
return err
}
cfg.Muxers = append(cfg.Muxers, config.MsMuxC{MuxC: mtpt, ID: name})
return nil
}
}
// Transport configures libp2p to use the given transport (or transport
// constructor).
//
// The transport can be a constructed transport.Transport or a function taking
// any subset of this libp2p node's:
// * Transport Upgrader (*tptu.Upgrader)
// * Host
// * Stream muxer (muxer.Transport)
// * Security transport (security.Transport)
// * Private network protector (pnet.Protector)
// * Peer ID
// * Private Key
// * Public Key
// * Address filter (filter.Filter)
// * Peerstore
func Transport(tpt interface{}) Option {
tptc, err := config.TransportConstructor(tpt)
err = traceError(err, 1)
return func(cfg *Config) error {
if err != nil {
return err
}
cfg.Transports = append(cfg.Transports, tptc)
return nil
}
}
// Peerstore configures libp2p to use the given peerstore.
func Peerstore(ps pstore.Peerstore) Option {
return func(cfg *Config) error {
if cfg.Peerstore != nil {
return fmt.Errorf("cannot specify multiple peerstore options")
}
cfg.Peerstore = ps
return nil
}
}
// PrivateNetwork configures libp2p to use the given private network protector.
func PrivateNetwork(prot pnet.Protector) Option {
return func(cfg *Config) error {
if cfg.Protector != nil {
return fmt.Errorf("cannot specify multiple private network options")
}
cfg.Protector = prot
return nil
}
}
// BandwidthReporter configures libp2p to use the given bandwidth reporter.
func BandwidthReporter(rep metrics.Reporter) Option {
return func(cfg *Config) error {
if cfg.Reporter != nil {
return fmt.Errorf("cannot specify multiple bandwidth reporter options")
}
cfg.Reporter = rep
return nil
}
}
// Identity configures libp2p to use the given private key to identify itself.
func Identity(sk crypto.PrivKey) Option {
return func(cfg *Config) error {
if cfg.PeerKey != nil {
return fmt.Errorf("cannot specify multiple identities")
}
cfg.PeerKey = sk
return nil
}
}
// ConnectionManager configures libp2p to use the given connection manager.
func ConnectionManager(connman ifconnmgr.ConnManager) Option {
return func(cfg *Config) error {
if cfg.ConnManager != nil {
return fmt.Errorf("cannot specify multiple connection managers")
}
cfg.ConnManager = connman
return nil
}
}
// AddrsFactory configures libp2p to use the given address factory.
func AddrsFactory(factory config.AddrsFactory) Option {
return func(cfg *Config) error {
if cfg.AddrsFactory != nil {
return fmt.Errorf("cannot specify multiple address factories")
}
cfg.AddrsFactory = factory
return nil
}
}
// EnableRelay configures libp2p to enable the relay transport.
func EnableRelay(options ...circuit.RelayOpt) Option {
return func(cfg *Config) error {
cfg.Relay = true
cfg.RelayOpts = options
return nil
}
}
// FilterAddresses configures libp2p to never dial nor accept connections from
// the given addresses.
func FilterAddresses(addrs ...*net.IPNet) Option {
return func(cfg *Config) error {
if cfg.Filters == nil {
cfg.Filters = filter.NewFilters()
}
for _, addr := range addrs {
cfg.Filters.AddDialFilter(addr)
}
return nil
}
}
// NATPortMap configures libp2p to use the default NATManager. The default
// NATManager will attempt to open a port in your network's firewall using UPnP.
func NATPortMap() Option {
return NATManager(bhost.NewNATManager)
}
// NATManager will configure libp2p to use the requested NATManager. This
// function should be passed a NATManager *constructor* that takes a libp2p Network.
func NATManager(nm config.NATManagerC) Option {
return func(cfg *Config) error {
if cfg.NATManager != nil {
return fmt.Errorf("cannot specify multiple NATManagers")
}
cfg.NATManager = nm
return nil
}
}
p2p/discovery/mdns_test.go
View file @ 9f25f923
......@@ -8,7 +8,7 @@ import (
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
host "github.com/libp2p/go-libp2p-host"
netutil "github.com/libp2p/go-libp2p-netutil"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
pstore "github.com/libp2p/go-libp2p-peerstore"
)
......@@ -28,8 +28,8 @@ func TestMdnsDiscovery(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
a := bhost.New(netutil.GenSwarmNetwork(t, ctx))
b := bhost.New(netutil.GenSwarmNetwork(t, ctx))
a := bhost.New(swarmt.GenSwarm(t, ctx))
b := bhost.New(swarmt.GenSwarm(t, ctx))
sa, err := NewMdnsService(ctx, a, time.Second, "someTag")
if err != nil {
......
p2p/host/basic/basic_host.go
View file @ 9f25f923
......@@ -9,10 +9,8 @@ import (
logging "github.com/ipfs/go-log"
goprocess "github.com/jbenet/goprocess"
circuit "github.com/libp2p/go-libp2p-circuit"
goprocessctx "github.com/jbenet/goprocess/context"
ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
metrics "github.com/libp2p/go-libp2p-metrics"
mstream "github.com/libp2p/go-libp2p-metrics/stream"
inet "github.com/libp2p/go-libp2p-net"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
......@@ -67,8 +65,6 @@ type BasicHost struct {
negtimeout time.Duration
proc goprocess.Process
bwc metrics.Reporter
}
// HostOpts holds options that can be passed to NewHost in order to
......@@ -97,25 +93,14 @@ type HostOpts struct {
// NATManager takes care of setting NAT port mappings, and discovering external addresses.
// If omitted, this will simply be disabled.
NATManager NATManager
// BandwidthReporter is used for collecting aggregate metrics of the
// bandwidth used by various protocols.
BandwidthReporter metrics.Reporter
NATManager func(inet.Network) NATManager
// ConnManager is a libp2p connection manager
ConnManager ifconnmgr.ConnManager
// Relay indicates whether the host should use circuit relay transport
EnableRelay bool
// RelayOpts are options for the relay transport; only meaningful when Relay=true
RelayOpts []circuit.RelayOpt
}
// NewHost constructs a new *BasicHost and activates it by attaching its stream and connection handlers to the given inet.Network.
func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost, error) {
ctx, cancel := context.WithCancel(ctx)
h := &BasicHost{
network: net,
mux: msmux.NewMultistreamMuxer(),
......@@ -124,11 +109,10 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
maResolver: madns.DefaultResolver,
}
h.proc = goprocess.WithTeardown(func() error {
h.proc = goprocessctx.WithContextAndTeardown(ctx, func() error {
if h.natmgr != nil {
h.natmgr.Close()
}
cancel()
return h.Network().Close()
})
......@@ -152,18 +136,13 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
}
if opts.NATManager != nil {
h.natmgr = opts.NATManager
h.natmgr = opts.NATManager(net)
}
if opts.MultiaddrResolver != nil {
h.maResolver = opts.MultiaddrResolver
}
if opts.BandwidthReporter != nil {
h.bwc = opts.BandwidthReporter
h.ids.Reporter = opts.BandwidthReporter
}
if opts.ConnManager == nil {
h.cmgr = &ifconnmgr.NullConnMgr{}
} else {
......@@ -173,20 +152,16 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
net.SetConnHandler(h.newConnHandler)
net.SetStreamHandler(h.newStreamHandler)
if opts.EnableRelay {
err := circuit.AddRelayTransport(ctx, h, opts.RelayOpts...)
if err != nil {
h.Close()
return nil, err
}
}
return h, nil
}
// New constructs and sets up a new *BasicHost with given Network and options.
// Three options can be passed: NATPortMap, AddrsFactory, and metrics.Reporter.
// The following options can be passed:
// * NATPortMap
// * AddrsFactory
// * ifconnmgr.ConnManager
// * madns.Resolver
//
// This function is deprecated in favor of NewHost and HostOpts.
func New(net inet.Network, opts ...interface{}) *BasicHost {
hostopts := &HostOpts{}
......@@ -196,10 +171,8 @@ func New(net inet.Network, opts ...interface{}) *BasicHost {
case Option:
switch o {
case NATPortMap:
hostopts.NATManager = newNatManager(net)
hostopts.NATManager = NewNATManager
}
case metrics.Reporter:
hostopts.BandwidthReporter = o
case AddrsFactory:
hostopts.AddrsFactory = AddrsFactory(o)
case ifconnmgr.ConnManager:
......@@ -270,10 +243,6 @@ func (h *BasicHost) newStreamHandler(s inet.Stream) {
}
s.SetProtocol(protocol.ID(protoID))
if h.bwc != nil {
s = mstream.WrapStream(s, h.bwc)
}
log.Debugf("protocol negotiation took %s", took)
go handle(protoID, s)
......@@ -366,10 +335,6 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
s.SetProtocol(selpid)
h.Peerstore().AddProtocols(p, selected)
if h.bwc != nil {
s = mstream.WrapStream(s, h.bwc)
}
return s, nil
}
......@@ -403,10 +368,6 @@ func (h *BasicHost) newStream(ctx context.Context, p peer.ID, pid protocol.ID) (
s.SetProtocol(pid)
if h.bwc != nil {
s = mstream.WrapStream(s, h.bwc)
}
lzcon := msmux.NewMSSelect(s, string(pid))
return &streamWrapper{
Stream: s,
......@@ -423,8 +384,7 @@ func (h *BasicHost) Connect(ctx context.Context, pi pstore.PeerInfo) error {
// absorb addresses into peerstore
h.Peerstore().AddAddrs(pi.ID, pi.Addrs, pstore.TempAddrTTL)
cs := h.Network().ConnsToPeer(pi.ID)
if len(cs) > 0 {
if h.Network().Connectedness(pi.ID) == inet.Connected {
return nil
}
......@@ -471,7 +431,7 @@ func (h *BasicHost) resolveAddrs(ctx context.Context, pi pstore.PeerInfo) ([]ma.
// dialPeer opens a connection to peer, and makes sure to identify
// the connection once it has been opened.
func (h *BasicHost) dialPeer(ctx context.Context, p peer.ID) error {
log.Debugf("host %s dialing %s", h.ID, p)
log.Debugf("host %s dialing %s", h.ID(), p)
c, err := h.Network().DialPeer(ctx, p)
if err != nil {
return err
......@@ -536,11 +496,6 @@ func (h *BasicHost) Close() error {
return h.proc.Close()
}
// GetBandwidthReporter exposes the Host's bandiwth metrics reporter
func (h *BasicHost) GetBandwidthReporter() metrics.Reporter {
return h.bwc
}
type streamWrapper struct {
inet.Stream
rw io.ReadWriter
......
p2p/host/basic/basic_host_test.go
View file @ 9f25f923
......@@ -8,11 +8,13 @@ import (
"testing"
"time"
testutil "github.com/libp2p/go-testutil"
host "github.com/libp2p/go-libp2p-host"
inet "github.com/libp2p/go-libp2p-net"
testutil "github.com/libp2p/go-libp2p-netutil"
pstore "github.com/libp2p/go-libp2p-peerstore"
protocol "github.com/libp2p/go-libp2p-protocol"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
ma "github.com/multiformats/go-multiaddr"
madns "github.com/multiformats/go-multiaddr-dns"
)
......@@ -20,8 +22,8 @@ import (
func TestHostSimple(t *testing.T) {
ctx := context.Background()
h1 := New(testutil.GenSwarmNetwork(t, ctx))
h2 := New(testutil.GenSwarmNetwork(t, ctx))
h1 := New(swarmt.GenSwarm(t, ctx))
h2 := New(swarmt.GenSwarm(t, ctx))
defer h1.Close()
defer h2.Close()
......@@ -74,7 +76,7 @@ func TestHostAddrsFactory(t *testing.T) {
}
ctx := context.Background()
h := New(testutil.GenSwarmNetwork(t, ctx), AddrsFactory(addrsFactory))
h := New(swarmt.GenSwarm(t, ctx), AddrsFactory(addrsFactory))
defer h.Close()
addrs := h.Addrs()
......@@ -87,8 +89,8 @@ func TestHostAddrsFactory(t *testing.T) {
}
func getHostPair(ctx context.Context, t *testing.T) (host.Host, host.Host) {
h1 := New(testutil.GenSwarmNetwork(t, ctx))
h2 := New(testutil.GenSwarmNetwork(t, ctx))
h1 := New(swarmt.GenSwarm(t, ctx))
h2 := New(swarmt.GenSwarm(t, ctx))
h2pi := h2.Peerstore().PeerInfo(h2.ID())
if err := h1.Connect(ctx, h2pi); err != nil {
......@@ -193,8 +195,8 @@ func TestHostProtoPreknowledge(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
h1 := New(testutil.GenSwarmNetwork(t, ctx))
h2 := New(testutil.GenSwarmNetwork(t, ctx))
h1 := New(swarmt.GenSwarm(t, ctx))
h2 := New(swarmt.GenSwarm(t, ctx))
conn := make(chan protocol.ID)
handler := func(s inet.Stream) {
......@@ -358,7 +360,7 @@ func TestAddrResolution(t *testing.T) {
}
resolver := &madns.Resolver{Backend: backend}
h := New(testutil.GenSwarmNetwork(t, ctx), resolver)
h := New(swarmt.GenSwarm(t, ctx), resolver)
defer h.Close()
pi, err := pstore.InfoFromP2pAddr(p2paddr1)
......
p2p/host/routed/routed.go
View file @ 9f25f923
......@@ -47,7 +47,7 @@ func Wrap(h host.Host, r Routing) *RoutedHost {
// given peer, it will use its routing system to try to find some.
func (rh *RoutedHost) Connect(ctx context.Context, pi pstore.PeerInfo) error {
// first, check if we're already connected.
if len(rh.Network().ConnsToPeer(pi.ID)) > 0 {
if rh.Network().Connectedness(pi.ID) == inet.Connected {
return nil
}
......
p2p/net/mock/mock_conn.go
View file @ 9f25f923
......@@ -118,12 +118,12 @@ func (c *conn) NewStream() (inet.Stream, error) {
return s, nil
}
func (c *conn) GetStreams() ([]inet.Stream, error) {
func (c *conn) GetStreams() []inet.Stream {
var out []inet.Stream
for e := c.streams.Front(); e != nil; e = e.Next() {
out = append(out, e.Value.(*stream))
}
return out, nil
return out
}
// LocalMultiaddr is the Multiaddr on this side
......
p2p/net/mock/mock_test.go
View file @ 9f25f923
......@@ -582,3 +582,57 @@ func TestLimitedStreams(t *testing.T) {
t.Fatal("Expected 2ish seconds but got ", time.Since(before))
}
}
func TestStreamsWithLatency(t *testing.T) {
latency := time.Millisecond * 500
mn, err := WithNPeers(context.Background(), 2)
if err != nil {
t.Fatal(err)
}
// configure the Mocknet with some latency and link/connect its peers
mn.SetLinkDefaults(LinkOptions{Latency: latency})
mn.LinkAll()
mn.ConnectAllButSelf()
msg := []byte("ping")
mln := len(msg)
var wg sync.WaitGroup
// we'll write once to a single stream
wg.Add(1)
handler := func(s inet.Stream) {
b := make([]byte, mln)
if _, err := io.ReadFull(s, b); err != nil {
t.Fatal(err)
}
wg.Done()
s.Close()
}
mn.Hosts()[0].SetStreamHandler(protocol.TestingID, handler)
mn.Hosts()[1].SetStreamHandler(protocol.TestingID, handler)
s, err := mn.Hosts()[0].NewStream(context.Background(), mn.Hosts()[1].ID(), protocol.TestingID)
if err != nil {
t.Fatal(err)
}
// writing to the stream will be subject to our configured latency
checkpoint := time.Now()
if _, err := s.Write(msg); err != nil {
t.Fatal(err)
}
wg.Wait()
delta := time.Since(checkpoint)
tolerance := time.Millisecond * 100
if !within(delta, latency, tolerance) {
t.Fatalf("Expected write to take ~%s (+/- %s), but took %s", latency.String(), tolerance.String(), delta.String())
}
}
p2p/protocol/identify/id.go
View file @ 9f25f923
......@@ -13,8 +13,6 @@ import (
ic "github.com/libp2p/go-libp2p-crypto"
host "github.com/libp2p/go-libp2p-host"
lgbl "github.com/libp2p/go-libp2p-loggables"
metrics "github.com/libp2p/go-libp2p-metrics"
mstream "github.com/libp2p/go-libp2p-metrics/stream"
inet "github.com/libp2p/go-libp2p-net"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
......@@ -44,7 +42,6 @@ var ClientVersion = "go-libp2p/3.3.4"
type IDService struct {
Host host.Host
Reporter metrics.Reporter
// connections undergoing identification
// for wait purposes
currid map[inet.Conn]chan struct{}
......@@ -64,7 +61,7 @@ func NewIDService(h host.Host) *IDService {
Host: h,
currid: make(map[inet.Conn]chan struct{}),
}
h.SetStreamHandler(ID, s.RequestHandler)
h.SetStreamHandler(ID, s.requestHandler)
h.Network().Notify((*netNotifiee)(s))
return s
}
......@@ -95,21 +92,17 @@ func (ids *IDService) IdentifyConn(c inet.Conn) {
c.Close()
return
}
defer s.Close()
defer inet.FullClose(s)
s.SetProtocol(ID)
if ids.Reporter != nil {
s = mstream.WrapStream(s, ids.Reporter)
}
// ok give the response to our handler.
if err := msmux.SelectProtoOrFail(ID, s); err != nil {
log.Event(context.TODO(), "IdentifyOpenFailed", c.RemotePeer(), logging.Metadata{"error": err})
return
}
ids.ResponseHandler(s)
ids.responseHandler(s)
ids.currmu.Lock()
_, found := ids.currid[c]
......@@ -122,14 +115,10 @@ func (ids *IDService) IdentifyConn(c inet.Conn) {
}
}
func (ids *IDService) RequestHandler(s inet.Stream) {
defer s.Close()
func (ids *IDService) requestHandler(s inet.Stream) {
defer inet.FullClose(s)
c := s.Conn()
if ids.Reporter != nil {
s = mstream.WrapStream(s, ids.Reporter)
}
w := ggio.NewDelimitedWriter(s)
mes := pb.Identify{}
ids.populateMessage(&mes, s.Conn())
......@@ -139,8 +128,7 @@ func (ids *IDService) RequestHandler(s inet.Stream) {
c.RemotePeer(), c.RemoteMultiaddr())
}
func (ids *IDService) ResponseHandler(s inet.Stream) {
defer s.Close()
func (ids *IDService) responseHandler(s inet.Stream) {
c := s.Conn()
r := ggio.NewDelimitedReader(s, 2048)
......@@ -267,7 +255,7 @@ func (ids *IDService) consumeReceivedPubKey(c inet.Conn, kb []byte) {
newKey, err := ic.UnmarshalPublicKey(kb)
if err != nil {
log.Errorf("%s cannot unmarshal key from remote peer: %s", lp, rp)
log.Warningf("%s cannot unmarshal key from remote peer: %s, %s", lp, rp, err)
return
}
......
p2p/protocol/identify/id_test.go
View file @ 9f25f923
......@@ -6,9 +6,9 @@ import (
"time"
ic "github.com/libp2p/go-libp2p-crypto"
testutil "github.com/libp2p/go-libp2p-netutil"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
identify "github.com/libp2p/go-libp2p/p2p/protocol/identify"
blhost "github.com/libp2p/go-libp2p-blankhost"
......@@ -20,8 +20,8 @@ func subtestIDService(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
h1 := blhost.NewBlankHost(testutil.GenSwarmNetwork(t, ctx))
h2 := blhost.NewBlankHost(testutil.GenSwarmNetwork(t, ctx))
h1 := blhost.NewBlankHost(swarmt.GenSwarm(t, ctx))
h2 := blhost.NewBlankHost(swarmt.GenSwarm(t, ctx))
h1p := h1.ID()
h2p := h2.ID()
......@@ -65,7 +65,7 @@ func subtestIDService(t *testing.T) {
ids2.IdentifyConn(c[0])
addrs := h1.Peerstore().Addrs(h1p)
addrs = append(addrs, c[0].RemoteMultiaddr(), forgetMe)
addrs = append(addrs, forgetMe)
// and the protocol versions.
t.Log("test peer2 has peer1 addrs correctly")
......
p2p/protocol/ping/ping_test.go
View file @ 9f25f923
......@@ -5,17 +5,17 @@ import (
"testing"
"time"
netutil "github.com/libp2p/go-libp2p-netutil"
peer "github.com/libp2p/go-libp2p-peer"
pstore "github.com/libp2p/go-libp2p-peerstore"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
)
func TestPing(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
h1 := bhost.New(netutil.GenSwarmNetwork(t, ctx))
h2 := bhost.New(netutil.GenSwarmNetwork(t, ctx))
h1 := bhost.New(swarmt.GenSwarm(t, ctx))
h2 := bhost.New(swarmt.GenSwarm(t, ctx))
err := h1.Connect(ctx, pstore.PeerInfo{
ID: h2.ID(),
......
p2p/test/backpressure/backpressure_test.go
View file @ 9f25f923
......@@ -13,9 +13,9 @@ import (
logging "github.com/ipfs/go-log"
host "github.com/libp2p/go-libp2p-host"
inet "github.com/libp2p/go-libp2p-net"
testutil "github.com/libp2p/go-libp2p-netutil"
peer "github.com/libp2p/go-libp2p-peer"
protocol "github.com/libp2p/go-libp2p-protocol"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
)
var log = logging.Logger("backpressure")
......@@ -137,8 +137,8 @@ a problem.
// ok that's enough setup. let's do it!
ctx := context.Background()
h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h1 := bhost.New(swarmt.GenSwarm(t, ctx))
h2 := bhost.New(swarmt.GenSwarm(t, ctx))
// setup receiver handler
h1.SetStreamHandler(protocol.TestingID, receiver)
......@@ -274,8 +274,8 @@ func TestStBackpressureStreamWrite(t *testing.T) {
// setup the networks
ctx := context.Background()
h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h1 := bhost.New(swarmt.GenSwarm(t, ctx))
h2 := bhost.New(swarmt.GenSwarm(t, ctx))
// setup sender handler on 1
h1.SetStreamHandler(protocol.TestingID, sender)
......
p2p/test/reconnects/reconnect_test.go
View file @ 9f25f923
......@@ -14,17 +14,10 @@ import (
logging "github.com/ipfs/go-log"
host "github.com/libp2p/go-libp2p-host"
inet "github.com/libp2p/go-libp2p-net"
testutil "github.com/libp2p/go-libp2p-netutil"
protocol "github.com/libp2p/go-libp2p-protocol"
swarm "github.com/libp2p/go-libp2p-swarm"
ps "github.com/libp2p/go-peerstream"
swarmt "github.com/libp2p/go-libp2p-swarm/testing"
)
func init() {
// change the garbage collect timeout for testing.
ps.GarbageCollectTimeout = 10 * time.Millisecond
}
var log = logging.Logger("reconnect")
func EchoStreamHandler(stream inet.Stream) {
......@@ -109,8 +102,8 @@ func newSender() (chan sendChans, func(s inet.Stream)) {
// TestReconnect tests whether hosts are able to disconnect and reconnect.
func TestReconnect2(t *testing.T) {
ctx := context.Background()
h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h1 := bhost.New(swarmt.GenSwarm(t, ctx))
h2 := bhost.New(swarmt.GenSwarm(t, ctx))
hosts := []host.Host{h1, h2}
h1.SetStreamHandler(protocol.TestingID, EchoStreamHandler)
......@@ -129,11 +122,11 @@ func TestReconnect2(t *testing.T) {
// TestReconnect tests whether hosts are able to disconnect and reconnect.
func TestReconnect5(t *testing.T) {
ctx := context.Background()
h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h3 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h4 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h5 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
h1 := bhost.New(swarmt.GenSwarm(t, ctx))
h2 := bhost.New(swarmt.GenSwarm(t, ctx))
h3 := bhost.New(swarmt.GenSwarm(t, ctx))
h4 := bhost.New(swarmt.GenSwarm(t, ctx))
h5 := bhost.New(swarmt.GenSwarm(t, ctx))
hosts := []host.Host{h1, h2, h3, h4, h5}
h1.SetStreamHandler(protocol.TestingID, EchoStreamHandler)
......@@ -219,13 +212,11 @@ func SubtestConnSendDisc(t *testing.T, hosts []host.Host) {
// close connection
cs := h1.Network().Conns()
for _, c := range cs {
sc := c.(*swarm.Conn)
if sc.LocalPeer() > sc.RemotePeer() {
continue // only close it on one side.
if c.LocalPeer() > c.RemotePeer() {
continue
}
log.Debugf("closing: %s", sc.RawConn())
sc.Close()
log.Debugf("closing: %s", c)
c.Close()
}
}
......
package.json
View file @ 9f25f923
......@@ -14,29 +14,19 @@
"version": "0.0.0"
},
{
"hash": "QmWSvDKkcno2UyDg13rUBwWfhRsdj7uR3daAq57VoG5QeN",
"hash": "QmNeRzgrSpwbMU7VKLRyfvbqf1nRrAiQ7fEXaBxWGT5Ygr",
"name": "mdns",
"version": "0.1.1"
"version": "0.1.3"
},
{
"hash": "QmWBug6eBS7AxRdCDVuSY5CnSit7cS2XnPFYJWqWDumhCG",
"name": "go-msgio",
"version": "0.0.3"
},
{
"hash": "QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx",
"hash": "QmPdKqUcHGFdeSpvjVoaTRPPstGif9GBZb5Q56RVw9o69A",
"name": "go-ipfs-util",
"version": "1.2.7"
},
{
"hash": "QmUusaX99BZoELh7dmPgirqRQ1FAmMnmnBn3oiqDFGBUSc",
"name": "go-keyspace",
"version": "1.0.0"
"version": "1.2.8"
},
{
"hash": "QmTnsezaB1wWNRHeHnYrm8K4d5i9wtyj3GsqjC3Rt5b5v5",
"hash": "QmbXRda5H2K3MSQyWWxTMtd8DWuguEBUCe6hpxfXVpFUGj",
"name": "go-multistream",
"version": "0.3.6"
"version": "0.3.7"
},
{
"hash": "Qmf7HqcW7LtCi1W8y2bdx2eJpze74jkbKqpByxgXikdbLF",
......@@ -49,29 +39,14 @@
"version": "1.0.0"
},
{
"hash": "QmTG23dvpBCBjqQwyDxV8CQT6jmS4PSftNr1VqHhE3MLy7",
"hash": "QmcVVHfdyv15GVPk7NrxdWjh2hLVccXnoD8j2tyQShiXJb",
"name": "go-log",
"version": "1.4.1"
"version": "1.5.3"
},
{
"hash": "QmRK2LxanhK2gZq6k6R7vk5ZoYZk8ULSSTB7FzDsMUX6CB",
"hash": "QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai",
"name": "go-multiaddr-net",
"version": "1.5.7"
},
{
"hash": "QmZyZDi491cCNTLfAhwcaDii2Kg4pwKRkhqQzURGDvY6ua",
"name": "go-multihash",
"version": "1.0.7"
},
{
"hash": "QmSMZwvs3n4GBikZ7hKzT17c3bk65FmyZo2JqtJ16swqCv",
"name": "multiaddr-filter",
"version": "1.0.2"
},
{
"hash": "QmaPHkZLbQQbvcyavn8q1GFHg6o6yeceyHFSJ3Pjf3p3TQ",
"name": "go-crypto",
"version": "0.0.0"
"version": "1.6.3"
},
{
"hash": "QmZ4Qi3GaRbjcx28Sme5eMH7RQjGkt8wHxt2a65oLaeFEV",
......@@ -79,82 +54,45 @@
"version": "0.0.0"
},
{
"hash": "QmWWQ2Txc2c6tqjsBpzg5Ar652cHPGNsQQp2SejkNmkUMb",
"hash": "QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7",
"name": "go-multiaddr",
"version": "1.2.6"
},
{
"hash": "QmeYJHEk8UjVVZ4XCRTZe6dFQrb8pGWD81LYCgeLp8CvMB",
"name": "go-metrics",
"version": "0.0.0"
},
{
"hash": "QmYvsG72GsfLgUeSojXArjnU6L4Wmwk7wuAxtNLuyXcc1T",
"name": "randbo",
"version": "0.0.0"
},
{
"hash": "QmeQW4ayVqi7Jjay1SrP2wYydsH9KwSrzQBnqyC25gPFnG",
"name": "go-notifier",
"version": "1.0.0"
},
{
"hash": "QmWHgLqrghM9zw77nF6gdvT9ExQ2RB9pLxkd8sDHZf1rWb",
"name": "go-temp-err-catcher",
"version": "0.0.0"
},
{
"hash": "QmVXXxPsnDY16szK4gPy1oz4qKd8HHshemX1miZR2frtJo",
"name": "go-peerstream",
"version": "2.1.5"
},
{
"author": "whyrusleeping",
"hash": "QmTy17Jm1foTnvUS9JXRhLbRQ3XuC64jPTjUfpB4mHz2QM",
"name": "mafmt",
"version": "1.2.5"
},
{
"author": "whyrusleeping",
"hash": "QmTd4Jgb4nbJq5uR55KJgGLyHWmM3dovS21D1HcwRneSLu",
"name": "gorocheck",
"version": "0.0.0"
"version": "1.3.0"
},
{
"author": "whyrusleeping",
"hash": "QmPDZJxtWGfcwLPazJxD4h3v3aDs43V7UNAVs3Jz1Wo7o4",
"hash": "QmRPkGkHLB72caXgdDYnoaWigXNWx95BcYDKV1n3KTEpaG",
"name": "go-libp2p-loggables",
"version": "1.1.14"
"version": "1.1.18"
},
{
"author": "whyrusleeping",
"hash": "QmP47neqyP4NR9CKbjVogZ8U9Gybxfcfsa8HtPSPSxwiA8",
"hash": "QmXzYnwYnJiDDV9y4QmbmtSeVyJ1R8HAmGnrnY2D6G3YcV",
"name": "go-libp2p-secio",
"version": "1.2.7"
"version": "2.0.4"
},
{
"author": "whyrusleeping",
"hash": "QmdeiKhUy1TVGBaKxt7y1QmBDLBdisSrLJ1x58Eoj4PXUh",
"hash": "QmZR2XWVVBCtbgBWnQhWk2xcQfaR3W8faQPriAiaaj7rsr",
"name": "go-libp2p-peerstore",
"version": "1.4.17"
"version": "1.4.22"
},
{
"author": "whyrusleeping",
"hash": "QmPUHzTLPZFYqv8WqcBTuMFYTgeom4uHHEaxzk7bd5GYZB",
"hash": "QmW5LxJm2Yo3S7uVsfLM7NsJn2QnKbvZD7uYsZVYR7YViE",
"name": "go-libp2p-transport",
"version": "2.2.14"
"version": "3.0.5"
},
{
"author": "whyrusleeping",
"hash": "QmdxKHpkZCTV3C7xdE1iJdPfFm5LVvMPvirdFmKu1TimzY",
"hash": "QmSggepaKhRfgEDiz2B6eGaCTK3TqDHXzK6F6HfsU7KPXt",
"name": "go-tcp-transport",
"version": "1.2.9"
"version": "2.0.5"
},
{
"author": "whyrusleeping",
"hash": "Qmf2UAmRwDG4TvnkQpHZWPAzw7rpCYVhxmRXmYxXr5LD1g",
"hash": "QmSW4uNHbvQia8iZDXzbwjiyHQtnyo9aFqfQAMasj3TJ6Y",
"name": "go-maddr-filter",
"version": "1.1.6"
"version": "1.1.9"
},
{
"author": "whyrusleeping",
......@@ -164,69 +102,51 @@
},
{
"author": "whyrusleeping",
"hash": "QmTGSre9j1otFgsr1opCUQDXTPSM6BTZnMWwPeA5nYJM7w",
"name": "go-addr-util",
"version": "1.2.7"
},
{
"author": "whyrusleeping",
"hash": "QmUJzxQQ2kzwQubsMqBTr1NGDpLfh7pGA2E1oaJULcKDPq",
"hash": "QmcW4FGAt24fdK1jBgWQn3yP4R9ZLyWQqjozv9QK7epRhL",
"name": "go-testutil",
"version": "1.2.1"
},
{
"author": "whyrusleeping",
"hash": "QmaHsbK8b39AzQWEwDsysCutdJXyfa3k9oFh1cr6dfMhHT",
"name": "go-libp2p-conn",
"version": "1.7.6"
"version": "1.2.5"
},
{
"author": "whyrusleeping",
"hash": "QmXoz9o2PT3tEzf7hicegwex5UgVP54n3k82K7jrWFyN86",
"hash": "QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh",
"name": "go-libp2p-net",
"version": "2.0.7"
"version": "3.0.5"
},
{
"author": "whyrusleeping",
"hash": "QmVvu4bS5QLfS19ePkp5Wgzn2ZUma5oXTT9BgDFyQLxUZF",
"hash": "QmcoBbyTiL9PFjo1GFixJwqQ8mZLJ36CribuqyKmS1okPu",
"name": "go-libp2p-metrics",
"version": "2.0.6"
},
{
"author": "whyrusleeping",
"hash": "QmYDNqBAMWVMHKndYR35Sd8PfEVWBiDmpHYkuRJTunJDeJ",
"name": "go-libp2p-interface-conn",
"version": "0.4.13"
"version": "2.1.3"
},
{
"author": "whyrusleeping",
"hash": "QmfZTdmunzKzAGJrSvXXQbQ5kLLUiEMX5vdwux7iXkdk7D",
"hash": "Qmb8T6YBBsjYsVGfrihQLfCJveczZnneSBqBKkYEBWDjge",
"name": "go-libp2p-host",
"version": "2.1.7"
"version": "3.0.4"
},
{
"author": "whyrusleeping",
"hash": "QmRqfgh56f8CrqpwH7D2s6t8zQRsvPoftT3sp5Y6SUhNA3",
"hash": "QmemVjhp1UuWPQqrWSvPcaqH3QJRMjMqNm4T2RULMkDDQe",
"name": "go-libp2p-swarm",
"version": "2.1.7"
"version": "3.0.6"
},
{
"author": "whyrusleeping",
"hash": "QmXtFH52dAPCq5i4iYjr1g8xVFVJD3fwKWWyNHjVB4sHRp",
"hash": "QmW25V77H8nb1ucUe8BDUbR3QXLNzTearBLYMW5DqDVWd5",
"name": "go-libp2p-nat",
"version": "0.0.8"
"version": "0.8.5"
},
{
"author": "whyrusleeping",
"hash": "Qmb6BsZf6Y3kxffXMNTubGPF1w1bkHtpvhfYbmnwP3NQyw",
"hash": "QmcxUtMB5sJrXR3znSvkrDd2ghvwGM8rLRqwJiPUdgQwat",
"name": "go-libp2p-netutil",
"version": "0.3.11"
"version": "0.4.4"
},
{
"author": "whyrusleeping",
"hash": "Qmc64U41EEB4nPG7wxjEqFwKJajS2f8kk5q2TvUrQf78Xu",
"hash": "QmT1Q44YeQXSiK3LBXbXBRdxJAFZZSTarseqt7DVe9ASNA",
"name": "go-libp2p-blankhost",
"version": "0.2.7"
"version": "0.3.4"
},
{
"author": "whyrusleeping",
......@@ -236,9 +156,9 @@
},
{
"author": "whyrusleeping",
"hash": "QmNWCEvi7bPRcvqAV8AKLGVNoQdArWi7NJayka2SM4XtRe",
"hash": "QmcsgrV3nCAKjiHKZhKVXWc4oY3WBECJCqahXEMpHeMrev",
"name": "go-smux-yamux",
"version": "2.0.1"
"version": "2.0.3"
},
{
"author": "whyrusleeping",
......@@ -248,39 +168,39 @@
},
{
"author": "whyrusleeping",
"hash": "QmVniQJkdzLZaZwzwMdd3dJTvWiJ1DQEkreVy6hs6h7Vk5",
"hash": "QmWzjXAyBTygw6CeCTUnhJzhFucfxY5FJivSoiGuiSbPjS",
"name": "go-smux-multistream",
"version": "2.0.0"
"version": "2.0.1"
},
{
"author": "whyrusleeping",
"hash": "QmcJukH2sAFjY3HdBKq35WDzWoL3UUu2gt9wdfqZTUyM74",
"hash": "QmdVrMn1LhB4ybb8hMVaMLXnA8XRSewMnK6YqXKXoTcRvN",
"name": "go-libp2p-peer",
"version": "2.3.2"
"version": "2.3.5"
},
{
"author": "vyzo",
"hash": "QmZRbCo2gw7ghw5m7L77a8FvvQTVr62J4hmy8ozpdq7dHF",
"hash": "QmcQ56iqKP8ZRhRGLe5EReJVvrJZDaGzkuatrPv4Z1B6cG",
"name": "go-libp2p-circuit",
"version": "2.0.12"
"version": "2.1.6"
},
{
"author": "lgierth",
"hash": "QmQMRYmPn77CKRFf4YFjX3M5e6uw6DFAgsQffCX6mwZ4mA",
"hash": "QmfXU2MhWoegxHoeMd3A2ytL2P6CY4FfqGWc23LTNWBwZt",
"name": "go-multiaddr-dns",
"version": "0.2.2"
"version": "0.2.4"
},
{
"author": "why",
"hash": "QmfQNieWBPwmnUjXWPZbjJPzhNwFFabTb5RQ79dyVWGujQ",
"hash": "QmXuucFcuvAWYAJfhHV2h4BYreHEAsLSsiquosiXeuduTN",
"name": "go-libp2p-interface-connmgr",
"version": "0.0.8"
"version": "0.0.11"
},
{
"author": "whyrusleeping",
"hash": "QmenmFuirGzv8S1R3DyvbZ6tFmQapkGeDCebgYzni1Ntn3",
"hash": "QmZHiqdRuNXujvSPNu1ZWxxzV6a2WhoZpfYkesdgyaKF9f",
"name": "go-smux-multiplex",
"version": "3.0.6"
"version": "3.0.11"
},
{
"author": "multiformats",
......@@ -289,10 +209,46 @@
"version": "0.1.5"
},
{
"author": "satori",
"hash": "QmcBWojPoNh4qm7zvv4qiepvCnnc7ALS9qcp7TNwwxT1gT",
"name": "go.uuid",
"version": "1.1.0"
"author": "whyrusleeping",
"hash": "QmX4UrmHGPnFxwfsunZjPbykzyv8Frg9AVmNariXqrLsMs",
"name": "go-ws-transport",
"version": "2.0.5"
},
{
"author": "stebalien",
"hash": "QmZaZ4nkadScQtG7KaGUWyh24jz5tD8d6AyetJmGnMo49t",
"name": "go-conn-security-multistream",
"version": "0.1.4"
},
{
"author": "Stebalien",
"hash": "QmYMGCwtKbLXfh2MUTbLoP66N9Y24DSg8PFJRG21eE2qwv",
"name": "go-conn-security",
"version": "0.1.5"
},
{
"author": "libp2p",
"hash": "QmW7Ump7YyBMr712Ta3iEVh3ZYcfVvJaPryfbCnyE826b4",
"name": "go-libp2p-interface-pnet",
"version": "3.0.0"
},
{
"author": "whyrusleeping",
"hash": "QmY9JXR3FupnYAYJWK9aMr9bCpqWKcToQ1tz8DVGTrHpHw",
"name": "go-stream-muxer",
"version": "3.0.0"
},
{
"author": "steb",
"hash": "Qma7AuxEA7dd1wAy95hTxXgxy4q7mU4Pyd1x4PRAzGP1fs",
"name": "go-libp2p-transport-upgrader",
"version": "0.1.5"
},
{
"author": "google",
"hash": "QmSSeQqc5QeuefkaM6JFV5tSF9knLUkXKVhW1eYRiqe72W",
"name": "uuid",
"version": "0.1.0"
}
],
"gxVersion": "0.4.0",
......@@ -300,6 +256,6 @@
"license": "MIT",
"name": "go-libp2p",
"releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
"version": "5.0.17"
"version": "6.0.6"
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment