mirror of
https://source.quilibrium.com/quilibrium/ceremonyclient.git
synced 2024-12-25 16:15:17 +00:00
561 lines
17 KiB
Go
561 lines
17 KiB
Go
package config
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/libp2p/go-libp2p/core/connmgr"
|
|
"github.com/libp2p/go-libp2p/core/crypto"
|
|
"github.com/libp2p/go-libp2p/core/event"
|
|
"github.com/libp2p/go-libp2p/core/host"
|
|
"github.com/libp2p/go-libp2p/core/metrics"
|
|
"github.com/libp2p/go-libp2p/core/network"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
"github.com/libp2p/go-libp2p/core/peerstore"
|
|
"github.com/libp2p/go-libp2p/core/pnet"
|
|
"github.com/libp2p/go-libp2p/core/protocol"
|
|
"github.com/libp2p/go-libp2p/core/routing"
|
|
"github.com/libp2p/go-libp2p/core/sec"
|
|
"github.com/libp2p/go-libp2p/core/sec/insecure"
|
|
"github.com/libp2p/go-libp2p/core/transport"
|
|
"github.com/libp2p/go-libp2p/p2p/host/autonat"
|
|
"github.com/libp2p/go-libp2p/p2p/host/autorelay"
|
|
bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
|
|
"github.com/libp2p/go-libp2p/p2p/host/eventbus"
|
|
"github.com/libp2p/go-libp2p/p2p/host/peerstore/pstoremem"
|
|
rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
|
|
routed "github.com/libp2p/go-libp2p/p2p/host/routed"
|
|
"github.com/libp2p/go-libp2p/p2p/net/swarm"
|
|
tptu "github.com/libp2p/go-libp2p/p2p/net/upgrader"
|
|
circuitv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/client"
|
|
relayv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
|
|
"github.com/libp2p/go-libp2p/p2p/protocol/holepunch"
|
|
"github.com/libp2p/go-libp2p/p2p/transport/quicreuse"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
madns "github.com/multiformats/go-multiaddr-dns"
|
|
"github.com/quic-go/quic-go"
|
|
"go.uber.org/fx"
|
|
"go.uber.org/fx/fxevent"
|
|
)
|
|
|
|
// AddrsFactory is a function that takes a set of multiaddrs we're listening on and
|
|
// returns the set of multiaddrs we should advertise to the network.
|
|
type AddrsFactory = bhost.AddrsFactory
|
|
|
|
// NATManagerC is a NATManager constructor.
|
|
type NATManagerC func(network.Network) bhost.NATManager
|
|
|
|
type RoutingC func(host.Host) (routing.PeerRouting, error)
|
|
|
|
// AutoNATConfig defines the AutoNAT behavior for the libp2p host.
|
|
type AutoNATConfig struct {
|
|
ForceReachability *network.Reachability
|
|
EnableService bool
|
|
ThrottleGlobalLimit int
|
|
ThrottlePeerLimit int
|
|
ThrottleInterval time.Duration
|
|
}
|
|
|
|
type Security struct {
|
|
ID protocol.ID
|
|
Constructor interface{}
|
|
}
|
|
|
|
// Config describes a set of settings for a libp2p node
|
|
//
|
|
// This is *not* a stable interface. Use the options defined in the root
|
|
// package.
|
|
type Config struct {
|
|
// UserAgent is the identifier this node will send to other peers when
|
|
// identifying itself, e.g. via the identify protocol.
|
|
//
|
|
// Set it via the UserAgent option function.
|
|
UserAgent string
|
|
|
|
// ProtocolVersion is the protocol version that identifies the family
|
|
// of protocols used by the peer in the Identify protocol. It is set
|
|
// using the [ProtocolVersion] option.
|
|
ProtocolVersion string
|
|
|
|
PeerKey crypto.PrivKey
|
|
|
|
QUICReuse []fx.Option
|
|
Transports []fx.Option
|
|
Muxers []tptu.StreamMuxer
|
|
SecurityTransports []Security
|
|
Insecure bool
|
|
PSK pnet.PSK
|
|
|
|
DialTimeout time.Duration
|
|
|
|
RelayCustom bool
|
|
Relay bool // should the relay transport be used
|
|
|
|
EnableRelayService bool // should we run a circuitv2 relay (if publicly reachable)
|
|
RelayServiceOpts []relayv2.Option
|
|
|
|
ListenAddrs []ma.Multiaddr
|
|
AddrsFactory bhost.AddrsFactory
|
|
ConnectionGater connmgr.ConnectionGater
|
|
|
|
ConnManager connmgr.ConnManager
|
|
ResourceManager network.ResourceManager
|
|
|
|
NATManager NATManagerC
|
|
Peerstore peerstore.Peerstore
|
|
Reporter metrics.Reporter
|
|
|
|
MultiaddrResolver *madns.Resolver
|
|
|
|
DisablePing bool
|
|
|
|
Routing RoutingC
|
|
|
|
EnableAutoRelay bool
|
|
AutoRelayOpts []autorelay.Option
|
|
AutoNATConfig
|
|
|
|
EnableHolePunching bool
|
|
HolePunchingOptions []holepunch.Option
|
|
|
|
DisableMetrics bool
|
|
PrometheusRegisterer prometheus.Registerer
|
|
|
|
DialRanker network.DialRanker
|
|
|
|
SwarmOpts []swarm.Option
|
|
|
|
DisableIdentifyAddressDiscovery bool
|
|
}
|
|
|
|
func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swarm, error) {
|
|
if cfg.Peerstore == nil {
|
|
return nil, fmt.Errorf("no peerstore specified")
|
|
}
|
|
|
|
// Check this early. Prevents us from even *starting* without verifying this.
|
|
if pnet.ForcePrivateNetwork && len(cfg.PSK) == 0 {
|
|
log.Error("tried to create a libp2p node with no Private" +
|
|
" Network Protector but usage of Private Networks" +
|
|
" is forced by the environment")
|
|
// Note: This is *also* checked the upgrader itself, so it'll be
|
|
// enforced even *if* you don't use the libp2p constructor.
|
|
return nil, pnet.ErrNotInPrivateNetwork
|
|
}
|
|
|
|
if cfg.PeerKey == nil {
|
|
return nil, fmt.Errorf("no peer key specified")
|
|
}
|
|
|
|
// Obtain Peer ID from public key
|
|
pid, err := peer.IDFromPublicKey(cfg.PeerKey.GetPublic())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := cfg.Peerstore.AddPrivKey(pid, cfg.PeerKey); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := cfg.Peerstore.AddPubKey(pid, cfg.PeerKey.GetPublic()); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
opts := cfg.SwarmOpts
|
|
if cfg.Reporter != nil {
|
|
opts = append(opts, swarm.WithMetrics(cfg.Reporter))
|
|
}
|
|
if cfg.ConnectionGater != nil {
|
|
opts = append(opts, swarm.WithConnectionGater(cfg.ConnectionGater))
|
|
}
|
|
if cfg.DialTimeout != 0 {
|
|
opts = append(opts, swarm.WithDialTimeout(cfg.DialTimeout))
|
|
}
|
|
if cfg.ResourceManager != nil {
|
|
opts = append(opts, swarm.WithResourceManager(cfg.ResourceManager))
|
|
}
|
|
if cfg.MultiaddrResolver != nil {
|
|
opts = append(opts, swarm.WithMultiaddrResolver(cfg.MultiaddrResolver))
|
|
}
|
|
if cfg.DialRanker != nil {
|
|
opts = append(opts, swarm.WithDialRanker(cfg.DialRanker))
|
|
}
|
|
|
|
if enableMetrics {
|
|
opts = append(opts,
|
|
swarm.WithMetricsTracer(swarm.NewMetricsTracer(swarm.WithRegisterer(cfg.PrometheusRegisterer))))
|
|
}
|
|
// TODO: Make the swarm implementation configurable.
|
|
return swarm.NewSwarm(pid, cfg.Peerstore, eventBus, opts...)
|
|
}
|
|
|
|
func (cfg *Config) addTransports() ([]fx.Option, error) {
|
|
fxopts := []fx.Option{
|
|
fx.WithLogger(func() fxevent.Logger { return getFXLogger() }),
|
|
fx.Provide(fx.Annotate(tptu.New, fx.ParamTags(`name:"security"`))),
|
|
fx.Supply(cfg.Muxers),
|
|
fx.Provide(func() connmgr.ConnectionGater { return cfg.ConnectionGater }),
|
|
fx.Provide(func() pnet.PSK { return cfg.PSK }),
|
|
fx.Provide(func() network.ResourceManager { return cfg.ResourceManager }),
|
|
fx.Provide(func() *madns.Resolver { return cfg.MultiaddrResolver }),
|
|
}
|
|
fxopts = append(fxopts, cfg.Transports...)
|
|
if cfg.Insecure {
|
|
fxopts = append(fxopts,
|
|
fx.Provide(
|
|
fx.Annotate(
|
|
func(id peer.ID, priv crypto.PrivKey) []sec.SecureTransport {
|
|
return []sec.SecureTransport{insecure.NewWithIdentity(insecure.ID, id, priv)}
|
|
},
|
|
fx.ResultTags(`name:"security"`),
|
|
),
|
|
),
|
|
)
|
|
} else {
|
|
// fx groups are unordered, but we need to preserve the order of the security transports
|
|
// First of all, we construct the security transports that are needed,
|
|
// and save them to a group call security_unordered.
|
|
for _, s := range cfg.SecurityTransports {
|
|
fxName := fmt.Sprintf(`name:"security_%s"`, s.ID)
|
|
fxopts = append(fxopts, fx.Supply(fx.Annotate(s.ID, fx.ResultTags(fxName))))
|
|
fxopts = append(fxopts,
|
|
fx.Provide(fx.Annotate(
|
|
s.Constructor,
|
|
fx.ParamTags(fxName),
|
|
fx.As(new(sec.SecureTransport)),
|
|
fx.ResultTags(`group:"security_unordered"`),
|
|
)),
|
|
)
|
|
}
|
|
// Then we consume the group security_unordered, and order them by the user's preference.
|
|
fxopts = append(fxopts, fx.Provide(
|
|
fx.Annotate(
|
|
func(secs []sec.SecureTransport) ([]sec.SecureTransport, error) {
|
|
if len(secs) != len(cfg.SecurityTransports) {
|
|
return nil, errors.New("inconsistent length for security transports")
|
|
}
|
|
t := make([]sec.SecureTransport, 0, len(secs))
|
|
for _, s := range cfg.SecurityTransports {
|
|
for _, st := range secs {
|
|
if s.ID != st.ID() {
|
|
continue
|
|
}
|
|
t = append(t, st)
|
|
}
|
|
}
|
|
return t, nil
|
|
},
|
|
fx.ParamTags(`group:"security_unordered"`),
|
|
fx.ResultTags(`name:"security"`),
|
|
)))
|
|
}
|
|
|
|
fxopts = append(fxopts, fx.Provide(PrivKeyToStatelessResetKey))
|
|
fxopts = append(fxopts, fx.Provide(PrivKeyToTokenGeneratorKey))
|
|
if cfg.QUICReuse != nil {
|
|
fxopts = append(fxopts, cfg.QUICReuse...)
|
|
} else {
|
|
fxopts = append(fxopts,
|
|
fx.Provide(func(key quic.StatelessResetKey, tokenGenerator quic.TokenGeneratorKey, _ *swarm.Swarm, lifecycle fx.Lifecycle) (*quicreuse.ConnManager, error) {
|
|
cm, err := quicreuse.NewConnManager(key, tokenGenerator)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lifecycle.Append(fx.StopHook(cm.Close))
|
|
return cm, nil
|
|
}),
|
|
)
|
|
}
|
|
|
|
fxopts = append(fxopts, fx.Invoke(
|
|
fx.Annotate(
|
|
func(swrm *swarm.Swarm, tpts []transport.Transport) error {
|
|
for _, t := range tpts {
|
|
if err := swrm.AddTransport(t); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
},
|
|
fx.ParamTags("", `group:"transport"`),
|
|
)),
|
|
)
|
|
if cfg.Relay {
|
|
fxopts = append(fxopts, fx.Invoke(circuitv2.AddTransport))
|
|
}
|
|
return fxopts, nil
|
|
}
|
|
|
|
func (cfg *Config) newBasicHost(swrm *swarm.Swarm, eventBus event.Bus) (*bhost.BasicHost, error) {
|
|
h, err := bhost.NewHost(swrm, &bhost.HostOpts{
|
|
EventBus: eventBus,
|
|
ConnManager: cfg.ConnManager,
|
|
AddrsFactory: cfg.AddrsFactory,
|
|
NATManager: cfg.NATManager,
|
|
EnablePing: !cfg.DisablePing,
|
|
UserAgent: cfg.UserAgent,
|
|
ProtocolVersion: cfg.ProtocolVersion,
|
|
EnableHolePunching: cfg.EnableHolePunching,
|
|
HolePunchingOptions: cfg.HolePunchingOptions,
|
|
EnableRelayService: cfg.EnableRelayService,
|
|
RelayServiceOpts: cfg.RelayServiceOpts,
|
|
EnableMetrics: !cfg.DisableMetrics,
|
|
PrometheusRegisterer: cfg.PrometheusRegisterer,
|
|
DisableIdentifyAddressDiscovery: cfg.DisableIdentifyAddressDiscovery,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if cfg.Relay {
|
|
// If we've enabled the relay, we should filter out relay
|
|
// addresses by default.
|
|
//
|
|
// TODO: We shouldn't be doing this here.
|
|
oldFactory := h.AddrsFactory
|
|
h.AddrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr {
|
|
return oldFactory(autorelay.Filter(addrs))
|
|
}
|
|
}
|
|
return h, nil
|
|
}
|
|
|
|
// NewNode constructs a new libp2p Host from the Config.
|
|
//
|
|
// This function consumes the config. Do not reuse it (really!).
|
|
func (cfg *Config) NewNode() (host.Host, error) {
|
|
if cfg.EnableAutoRelay && !cfg.Relay {
|
|
return nil, fmt.Errorf("cannot enable autorelay; relay is not enabled")
|
|
}
|
|
// If possible check that the resource manager conn limit is higher than the
|
|
// limit set in the conn manager.
|
|
if l, ok := cfg.ResourceManager.(connmgr.GetConnLimiter); ok {
|
|
err := cfg.ConnManager.CheckLimit(l)
|
|
if err != nil {
|
|
log.Warn(fmt.Sprintf("rcmgr limit conflicts with connmgr limit: %v", err))
|
|
}
|
|
}
|
|
|
|
if !cfg.DisableMetrics {
|
|
rcmgr.MustRegisterWith(cfg.PrometheusRegisterer)
|
|
}
|
|
|
|
fxopts := []fx.Option{
|
|
fx.Provide(func() event.Bus {
|
|
return eventbus.NewBus(eventbus.WithMetricsTracer(eventbus.NewMetricsTracer(eventbus.WithRegisterer(cfg.PrometheusRegisterer))))
|
|
}),
|
|
fx.Provide(func(eventBus event.Bus, lifecycle fx.Lifecycle) (*swarm.Swarm, error) {
|
|
sw, err := cfg.makeSwarm(eventBus, !cfg.DisableMetrics)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lifecycle.Append(fx.StopHook(sw.Close))
|
|
return sw, nil
|
|
}),
|
|
// Make sure the swarm constructor depends on the quicreuse.ConnManager.
|
|
// That way, the ConnManager will be started before the swarm, and more importantly,
|
|
// the swarm will be stopped before the ConnManager.
|
|
fx.Decorate(func(sw *swarm.Swarm, _ *quicreuse.ConnManager, lifecycle fx.Lifecycle) *swarm.Swarm {
|
|
lifecycle.Append(fx.Hook{
|
|
OnStart: func(context.Context) error {
|
|
// TODO: This method succeeds if listening on one address succeeds. We
|
|
// should probably fail if listening on *any* addr fails.
|
|
return sw.Listen(cfg.ListenAddrs...)
|
|
},
|
|
OnStop: func(context.Context) error {
|
|
return sw.Close()
|
|
},
|
|
})
|
|
return sw
|
|
}),
|
|
fx.Provide(cfg.newBasicHost),
|
|
fx.Provide(func(bh *bhost.BasicHost) host.Host {
|
|
return bh
|
|
}),
|
|
fx.Provide(func(h *swarm.Swarm) peer.ID { return h.LocalPeer() }),
|
|
fx.Provide(func(h *swarm.Swarm) crypto.PrivKey { return h.Peerstore().PrivKey(h.LocalPeer()) }),
|
|
}
|
|
transportOpts, err := cfg.addTransports()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fxopts = append(fxopts, transportOpts...)
|
|
|
|
// Configure routing and autorelay
|
|
if cfg.Routing != nil {
|
|
fxopts = append(fxopts,
|
|
fx.Provide(cfg.Routing),
|
|
fx.Provide(func(h host.Host, router routing.PeerRouting) *routed.RoutedHost {
|
|
return routed.Wrap(h, router)
|
|
}),
|
|
)
|
|
}
|
|
|
|
// Note: h.AddrsFactory may be changed by relayFinder, but non-relay version is
|
|
// used by AutoNAT below.
|
|
if cfg.EnableAutoRelay {
|
|
if !cfg.DisableMetrics {
|
|
mt := autorelay.WithMetricsTracer(
|
|
autorelay.NewMetricsTracer(autorelay.WithRegisterer(cfg.PrometheusRegisterer)))
|
|
mtOpts := []autorelay.Option{mt}
|
|
cfg.AutoRelayOpts = append(mtOpts, cfg.AutoRelayOpts...)
|
|
}
|
|
fxopts = append(fxopts,
|
|
fx.Invoke(func(h *bhost.BasicHost, lifecycle fx.Lifecycle) (*autorelay.AutoRelay, error) {
|
|
ar, err := autorelay.NewAutoRelay(h, cfg.AutoRelayOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lifecycle.Append(fx.StartStopHook(ar.Start, ar.Close))
|
|
return ar, nil
|
|
}),
|
|
)
|
|
}
|
|
|
|
var bh *bhost.BasicHost
|
|
fxopts = append(fxopts, fx.Invoke(func(bho *bhost.BasicHost) { bh = bho }))
|
|
fxopts = append(fxopts, fx.Invoke(func(h *bhost.BasicHost, lifecycle fx.Lifecycle) {
|
|
lifecycle.Append(fx.StartHook(h.Start))
|
|
}))
|
|
|
|
var rh *routed.RoutedHost
|
|
if cfg.Routing != nil {
|
|
fxopts = append(fxopts, fx.Invoke(func(bho *routed.RoutedHost) { rh = bho }))
|
|
}
|
|
|
|
app := fx.New(fxopts...)
|
|
if err := app.Start(context.Background()); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := cfg.addAutoNAT(bh); err != nil {
|
|
app.Stop(context.Background())
|
|
if cfg.Routing != nil {
|
|
rh.Close()
|
|
} else {
|
|
bh.Close()
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if cfg.Routing != nil {
|
|
return &closableRoutedHost{App: app, RoutedHost: rh}, nil
|
|
}
|
|
return &closableBasicHost{App: app, BasicHost: bh}, nil
|
|
}
|
|
|
|
func (cfg *Config) addAutoNAT(h *bhost.BasicHost) error {
|
|
addrF := h.AddrsFactory
|
|
autonatOpts := []autonat.Option{
|
|
autonat.UsingAddresses(func() []ma.Multiaddr {
|
|
return addrF(h.AllAddrs())
|
|
}),
|
|
}
|
|
if !cfg.DisableMetrics {
|
|
autonatOpts = append(autonatOpts, autonat.WithMetricsTracer(
|
|
autonat.NewMetricsTracer(autonat.WithRegisterer(cfg.PrometheusRegisterer)),
|
|
))
|
|
}
|
|
if cfg.AutoNATConfig.ThrottleInterval != 0 {
|
|
autonatOpts = append(autonatOpts,
|
|
autonat.WithThrottling(cfg.AutoNATConfig.ThrottleGlobalLimit, cfg.AutoNATConfig.ThrottleInterval),
|
|
autonat.WithPeerThrottling(cfg.AutoNATConfig.ThrottlePeerLimit))
|
|
}
|
|
if cfg.AutoNATConfig.EnableService {
|
|
autonatPrivKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ps, err := pstoremem.NewPeerstore()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Pull out the pieces of the config that we _actually_ care about.
|
|
// Specifically, don't set up things like listeners, identify, etc.
|
|
autoNatCfg := Config{
|
|
Transports: cfg.Transports,
|
|
Muxers: cfg.Muxers,
|
|
SecurityTransports: cfg.SecurityTransports,
|
|
Insecure: cfg.Insecure,
|
|
PSK: cfg.PSK,
|
|
ConnectionGater: cfg.ConnectionGater,
|
|
Reporter: cfg.Reporter,
|
|
PeerKey: autonatPrivKey,
|
|
Peerstore: ps,
|
|
DialRanker: swarm.NoDelayDialRanker,
|
|
SwarmOpts: []swarm.Option{
|
|
// It is better to disable black hole detection and just attempt a dial for autonat
|
|
swarm.WithUDPBlackHoleConfig(false, 0, 0),
|
|
swarm.WithIPv6BlackHoleConfig(false, 0, 0),
|
|
},
|
|
}
|
|
|
|
fxopts, err := autoNatCfg.addTransports()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var dialer *swarm.Swarm
|
|
|
|
fxopts = append(fxopts,
|
|
fx.Provide(eventbus.NewBus),
|
|
fx.Provide(func(lifecycle fx.Lifecycle, b event.Bus) (*swarm.Swarm, error) {
|
|
lifecycle.Append(fx.Hook{
|
|
OnStop: func(context.Context) error {
|
|
return ps.Close()
|
|
}})
|
|
var err error
|
|
dialer, err = autoNatCfg.makeSwarm(b, false)
|
|
return dialer, err
|
|
|
|
}),
|
|
fx.Provide(func(s *swarm.Swarm) peer.ID { return s.LocalPeer() }),
|
|
fx.Provide(func() crypto.PrivKey { return autonatPrivKey }),
|
|
)
|
|
app := fx.New(fxopts...)
|
|
if err := app.Err(); err != nil {
|
|
return err
|
|
}
|
|
err = app.Start(context.Background())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
go func() {
|
|
<-dialer.Done() // The swarm used for autonat has closed, we can cleanup now
|
|
app.Stop(context.Background())
|
|
}()
|
|
autonatOpts = append(autonatOpts, autonat.EnableService(dialer))
|
|
}
|
|
if cfg.AutoNATConfig.ForceReachability != nil {
|
|
autonatOpts = append(autonatOpts, autonat.WithReachability(*cfg.AutoNATConfig.ForceReachability))
|
|
}
|
|
|
|
autonat, err := autonat.New(h, autonatOpts...)
|
|
if err != nil {
|
|
return fmt.Errorf("cannot enable autorelay; autonat failed to start: %v", err)
|
|
}
|
|
h.SetAutoNat(autonat)
|
|
return nil
|
|
}
|
|
|
|
// Option is a libp2p config option that can be given to the libp2p constructor
|
|
// (`libp2p.New`).
|
|
type Option func(cfg *Config) error
|
|
|
|
// Apply applies the given options to the config, returning the first error
|
|
// encountered (if any).
|
|
func (cfg *Config) Apply(opts ...Option) error {
|
|
for _, opt := range opts {
|
|
if opt == nil {
|
|
continue
|
|
}
|
|
if err := opt(cfg); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|