mirror of
https://github.com/ipfs/kubo.git
synced 2026-02-22 02:47:48 +08:00
144 lines
3.1 KiB
Go
144 lines
3.1 KiB
Go
package node
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/ipfs/go-ipfs/core/node/libp2p"
|
|
"github.com/ipfs/go-ipfs/p2p"
|
|
"github.com/ipfs/go-ipfs/provider"
|
|
|
|
offline "github.com/ipfs/go-ipfs-exchange-offline"
|
|
offroute "github.com/ipfs/go-ipfs-routing/offline"
|
|
"github.com/ipfs/go-path/resolver"
|
|
"go.uber.org/fx"
|
|
)
|
|
|
|
var BaseLibP2P = fx.Options(
|
|
fx.Provide(libp2p.AddrFilters),
|
|
fx.Provide(libp2p.BandwidthCounter),
|
|
fx.Provide(libp2p.PNet),
|
|
fx.Provide(libp2p.AddrsFactory),
|
|
fx.Provide(libp2p.ConnectionManager),
|
|
fx.Provide(libp2p.NatPortMap),
|
|
fx.Provide(libp2p.Relay),
|
|
fx.Provide(libp2p.AutoRealy),
|
|
fx.Provide(libp2p.DefaultTransports),
|
|
fx.Provide(libp2p.QUIC),
|
|
|
|
fx.Provide(libp2p.Host),
|
|
|
|
fx.Provide(libp2p.DiscoveryHandler),
|
|
|
|
fx.Invoke(libp2p.AutoNATService),
|
|
fx.Invoke(libp2p.PNetChecker),
|
|
fx.Invoke(libp2p.StartListening),
|
|
fx.Invoke(libp2p.SetupDiscovery),
|
|
)
|
|
|
|
func LibP2P(cfg *BuildCfg) fx.Option {
|
|
opts := fx.Options(
|
|
BaseLibP2P,
|
|
|
|
fx.Provide(libp2p.Security(!cfg.DisableEncryptedConnections)),
|
|
maybeProvide(libp2p.Pubsub, cfg.getOpt("pubsub") || cfg.getOpt("ipnsps")),
|
|
|
|
fx.Provide(libp2p.SmuxTransport(cfg.getOpt("mplex"))),
|
|
fx.Provide(libp2p.Routing),
|
|
fx.Provide(libp2p.BaseRouting),
|
|
maybeProvide(libp2p.PubsubRouter, cfg.getOpt("ipnsps")),
|
|
)
|
|
|
|
return opts
|
|
}
|
|
|
|
// Storage groups units which setup datastore based persistence and blockstore layers
|
|
func Storage(cfg *BuildCfg) fx.Option {
|
|
return fx.Options(
|
|
fx.Provide(RepoConfig),
|
|
fx.Provide(Datastore),
|
|
fx.Provide(BaseBlockstoreCtor(cfg.Permanent, cfg.NilRepo)),
|
|
fx.Provide(GcBlockstoreCtor),
|
|
)
|
|
}
|
|
|
|
// Identity groups units providing cryptographic identity
|
|
var Identity = fx.Options(
|
|
fx.Provide(PeerID),
|
|
fx.Provide(PrivateKey),
|
|
fx.Provide(libp2p.Peerstore),
|
|
)
|
|
|
|
// IPNS groups namesys related units
|
|
var IPNS = fx.Options(
|
|
fx.Provide(RecordValidator),
|
|
)
|
|
|
|
// Providers groups units managing provider routing records
|
|
var Providers = fx.Options(
|
|
fx.Provide(ProviderQueue),
|
|
fx.Provide(ProviderCtor),
|
|
fx.Provide(ReproviderCtor),
|
|
|
|
fx.Invoke(Reprovider),
|
|
)
|
|
|
|
// Online groups online-only units
|
|
func Online(cfg *BuildCfg) fx.Option {
|
|
return fx.Options(
|
|
fx.Provide(OnlineExchange),
|
|
fx.Provide(OnlineNamesys),
|
|
|
|
fx.Invoke(IpnsRepublisher),
|
|
|
|
fx.Provide(p2p.New),
|
|
|
|
LibP2P(cfg),
|
|
Providers,
|
|
)
|
|
}
|
|
|
|
// Offline groups offline alternatives to Online units
|
|
var Offline = fx.Options(
|
|
fx.Provide(offline.Exchange),
|
|
fx.Provide(OfflineNamesys),
|
|
fx.Provide(offroute.NewOfflineRouter),
|
|
fx.Provide(provider.NewOfflineProvider),
|
|
)
|
|
|
|
// Core groups basic IPFS services
|
|
var Core = fx.Options(
|
|
fx.Provide(BlockService),
|
|
fx.Provide(Dag),
|
|
fx.Provide(resolver.NewBasicResolver),
|
|
fx.Provide(Pinning),
|
|
fx.Provide(Files),
|
|
)
|
|
|
|
func Networked(cfg *BuildCfg) fx.Option {
|
|
if cfg.Online {
|
|
return Online(cfg)
|
|
}
|
|
return Offline
|
|
}
|
|
|
|
// IPFS builds a group of fx Options based on the passed BuildCfg
|
|
func IPFS(ctx context.Context, cfg *BuildCfg) fx.Option {
|
|
if cfg == nil {
|
|
cfg = new(BuildCfg)
|
|
}
|
|
|
|
return fx.Options(
|
|
cfg.options(ctx),
|
|
|
|
fx.Provide(baseProcess),
|
|
fx.Invoke(setupSharding),
|
|
|
|
Storage(cfg),
|
|
Identity,
|
|
IPNS,
|
|
Networked(cfg),
|
|
|
|
Core,
|
|
)
|
|
}
|