Absorb go-libp2p abstractions and core types into this module (#1)

core/alias.go

@@ -0,0 +1,50 @@
+// Package core provides convenient access to foundational, central go-libp2p primitives via type aliases.
+package core
+
+import (
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/protocol"
+	"github.com/multiformats/go-multiaddr"
+)
+
+// Multiaddr aliases the Multiaddr type from github.com/multiformats/go-multiaddr.
+//
+// Refer to the docs on that type for more info.
+type Multiaddr = multiaddr.Multiaddr
+
+// PeerID aliases peer.ID.
+//
+// Refer to the docs on that type for more info.
+type PeerID = peer.ID
+
+// PeerID aliases protocol.ID.
+//
+// Refer to the docs on that type for more info.
+type ProtocolID = protocol.ID
+
+// PeerAddrInfo aliases peer.AddrInfo.
+//
+// Refer to the docs on that type for more info.
+type PeerAddrInfo = peer.AddrInfo
+
+// Host aliases host.Host.
+//
+// Refer to the docs on that type for more info.
+type Host = host.Host
+
+// Network aliases network.Network.
+//
+// Refer to the docs on that type for more info.
+type Network = network.Network
+
+// Conn aliases network.Conn.
+//
+// Refer to the docs on that type for more info.
+type Conn = network.Conn
+
+// Stream aliases network.Stream.
+//
+// Refer to the docs on that type for more info.
+type Stream = network.Stream

core/connmgr/connmgr.go

@@ -0,0 +1,78 @@
+// Package connmgr provides connection tracking and management interfaces for libp2p.
+//
+// The ConnManager interface exported from this package allows libp2p to enforce an
+// upper bound on the total number of open connections. To avoid service disruptions,
+// connections can be tagged with metadata and optionally "protected" to ensure that
+// essential connections are not arbitrarily cut.
+package connmgr
+
+import (
+	"context"
+	"time"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+)
+
+// ConnManager tracks connections to peers, and allows consumers to associate metadata
+// with each peer.
+//
+// It enables connections to be trimmed based on implementation-defined heuristics.
+// The ConnManager allows libp2p to enforce an upper bound on the total number of
+// open connections.
+type ConnManager interface {
+
+	// TagPeer tags a peer with a string, associating a weight with the tag.
+	TagPeer(peer.ID, string, int)
+
+	// Untag removes the tagged value from the peer.
+	UntagPeer(p peer.ID, tag string)
+
+	// UpsertTag updates an existing tag or inserts a new one.
+	//
+	// The connection manager calls the upsert function supplying the current
+	// value of the tag (or zero if inexistent). The return value is used as
+	// the new value of the tag.
+	UpsertTag(p peer.ID, tag string, upsert func(int) int)
+
+	// GetTagInfo returns the metadata associated with the peer,
+	// or nil if no metadata has been recorded for the peer.
+	GetTagInfo(p peer.ID) *TagInfo
+
+	// TrimOpenConns terminates open connections based on an implementation-defined
+	// heuristic.
+	TrimOpenConns(ctx context.Context)
+
+	// Notifee returns an implementation that can be called back to inform of
+	// opened and closed connections.
+	Notifee() network.Notifiee
+
+	// Protect protects a peer from having its connection(s) pruned.
+	//
+	// Tagging allows different parts of the system to manage protections without interfering with one another.
+	//
+	// Calls to Protect() with the same tag are idempotent. They are not refcounted, so after multiple calls
+	// to Protect() with the same tag, a single Unprotect() call bearing the same tag will revoke the protection.
+	Protect(id peer.ID, tag string)
+
+	// Unprotect removes a protection that may have been placed on a peer, under the specified tag.
+	//
+	// The return value indicates whether the peer continues to be protected after this call, by way of a different tag.
+	// See notes on Protect() for more info.
+	Unprotect(id peer.ID, tag string) (protected bool)
+
+	// Close closes the connection manager and stops background processes
+	Close() error
+}
+
+// TagInfo stores metadata associated with a peer.
+type TagInfo struct {
+	FirstSeen time.Time
+	Value     int
+
+	// Tags maps tag ids to the numerical values.
+	Tags map[string]int
+
+	// Conns maps connection ids (such as remote multiaddr) to their creation time.
+	Conns map[string]time.Time
+}

core/connmgr/null.go

@@ -0,0 +1,23 @@
+package connmgr
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+)
+
+// NullConnMgr is a ConnMgr that provides no functionality.
+type NullConnMgr struct{}
+
+var _ ConnManager = (*NullConnMgr)(nil)
+
+func (_ NullConnMgr) TagPeer(peer.ID, string, int)             {}
+func (_ NullConnMgr) UntagPeer(peer.ID, string)                {}
+func (_ NullConnMgr) UpsertTag(peer.ID, string, func(int) int) {}
+func (_ NullConnMgr) GetTagInfo(peer.ID) *TagInfo              { return &TagInfo{} }
+func (_ NullConnMgr) TrimOpenConns(ctx context.Context)        {}
+func (_ NullConnMgr) Notifee() network.Notifiee                { return network.GlobalNoopNotifiee }
+func (_ NullConnMgr) Protect(peer.ID, string)                  {}
+func (_ NullConnMgr) Unprotect(peer.ID, string) bool           { return false }
+func (_ NullConnMgr) Close() error                             { return nil }

core/crypto/bench_test.go

@@ -0,0 +1,84 @@
+package crypto
+
+import "testing"
+
+func BenchmarkSignRSA1B(b *testing.B)      { RunBenchmarkSignRSA(b, 1) }
+func BenchmarkSignRSA10B(b *testing.B)     { RunBenchmarkSignRSA(b, 10) }
+func BenchmarkSignRSA100B(b *testing.B)    { RunBenchmarkSignRSA(b, 100) }
+func BenchmarkSignRSA1000B(b *testing.B)   { RunBenchmarkSignRSA(b, 1000) }
+func BenchmarkSignRSA10000B(b *testing.B)  { RunBenchmarkSignRSA(b, 10000) }
+func BenchmarkSignRSA100000B(b *testing.B) { RunBenchmarkSignRSA(b, 100000) }
+
+func BenchmarkVerifyRSA1B(b *testing.B)      { RunBenchmarkVerifyRSA(b, 1) }
+func BenchmarkVerifyRSA10B(b *testing.B)     { RunBenchmarkVerifyRSA(b, 10) }
+func BenchmarkVerifyRSA100B(b *testing.B)    { RunBenchmarkVerifyRSA(b, 100) }
+func BenchmarkVerifyRSA1000B(b *testing.B)   { RunBenchmarkVerifyRSA(b, 1000) }
+func BenchmarkVerifyRSA10000B(b *testing.B)  { RunBenchmarkVerifyRSA(b, 10000) }
+func BenchmarkVerifyRSA100000B(b *testing.B) { RunBenchmarkVerifyRSA(b, 100000) }
+
+func BenchmarkSignEd255191B(b *testing.B)      { RunBenchmarkSignEd25519(b, 1) }
+func BenchmarkSignEd2551910B(b *testing.B)     { RunBenchmarkSignEd25519(b, 10) }
+func BenchmarkSignEd25519100B(b *testing.B)    { RunBenchmarkSignEd25519(b, 100) }
+func BenchmarkSignEd255191000B(b *testing.B)   { RunBenchmarkSignEd25519(b, 1000) }
+func BenchmarkSignEd2551910000B(b *testing.B)  { RunBenchmarkSignEd25519(b, 10000) }
+func BenchmarkSignEd25519100000B(b *testing.B) { RunBenchmarkSignEd25519(b, 100000) }
+
+func BenchmarkVerifyEd255191B(b *testing.B)      { RunBenchmarkVerifyEd25519(b, 1) }
+func BenchmarkVerifyEd2551910B(b *testing.B)     { RunBenchmarkVerifyEd25519(b, 10) }
+func BenchmarkVerifyEd25519100B(b *testing.B)    { RunBenchmarkVerifyEd25519(b, 100) }
+func BenchmarkVerifyEd255191000B(b *testing.B)   { RunBenchmarkVerifyEd25519(b, 1000) }
+func BenchmarkVerifyEd2551910000B(b *testing.B)  { RunBenchmarkVerifyEd25519(b, 10000) }
+func BenchmarkVerifyEd25519100000B(b *testing.B) { RunBenchmarkVerifyEd25519(b, 100000) }
+
+func RunBenchmarkSignRSA(b *testing.B, numBytes int) {
+	runBenchmarkSign(b, numBytes, RSA)
+}
+
+func RunBenchmarkSignEd25519(b *testing.B, numBytes int) {
+	runBenchmarkSign(b, numBytes, Ed25519)
+}
+
+func runBenchmarkSign(b *testing.B, numBytes int, t int) {
+	secret, _, err := GenerateKeyPair(t, 1024)
+	if err != nil {
+		b.Fatal(err)
+	}
+	someData := make([]byte, numBytes)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := secret.Sign(someData)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func RunBenchmarkVerifyRSA(b *testing.B, numBytes int) {
+	runBenchmarkSign(b, numBytes, RSA)
+}
+
+func RunBenchmarkVerifyEd25519(b *testing.B, numBytes int) {
+	runBenchmarkSign(b, numBytes, Ed25519)
+}
+
+func runBenchmarkVerify(b *testing.B, numBytes int, t int) {
+	secret, public, err := GenerateKeyPair(t, 1024)
+	if err != nil {
+		b.Fatal(err)
+	}
+	someData := make([]byte, numBytes)
+	signature, err := secret.Sign(someData)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		valid, err := public.Verify(someData, signature)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if !valid {
+			b.Fatal("signature should be valid")
+		}
+	}
+}