From adbc85bf8a8cf44f7d579ac427d7ea727ffd3f02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Magiera?= Date: Mon, 1 Apr 2019 21:34:17 +0200 Subject: [PATCH] Remove old constructor code MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit License: MIT Signed-off-by: Łukasz Magiera --- core/builder.go | 154 +----------- core/core.go | 646 ++---------------------------------------------- 2 files changed, 17 insertions(+), 783 deletions(-) diff --git a/core/builder.go b/core/builder.go index e9cdc8fa3..4a4c2423b 100644 --- a/core/builder.go +++ b/core/builder.go @@ -7,37 +7,23 @@ import ( "errors" "os" "syscall" - "time" "go.uber.org/fx" "github.com/ipfs/go-ipfs/p2p" "github.com/ipfs/go-ipfs/provider" - filestore "github.com/ipfs/go-ipfs/filestore" - namesys "github.com/ipfs/go-ipfs/namesys" - pin "github.com/ipfs/go-ipfs/pin" repo "github.com/ipfs/go-ipfs/repo" - cidv0v1 "github.com/ipfs/go-ipfs/thirdparty/cidv0v1" - "github.com/ipfs/go-ipfs/thirdparty/verifbs" - bserv "github.com/ipfs/go-blockservice" ds "github.com/ipfs/go-datastore" - retry "github.com/ipfs/go-datastore/retrystore" dsync "github.com/ipfs/go-datastore/sync" - bstore "github.com/ipfs/go-ipfs-blockstore" cfg "github.com/ipfs/go-ipfs-config" offline "github.com/ipfs/go-ipfs-exchange-offline" offroute "github.com/ipfs/go-ipfs-routing/offline" - dag "github.com/ipfs/go-merkledag" metrics "github.com/ipfs/go-metrics-interface" resolver "github.com/ipfs/go-path/resolver" - uio "github.com/ipfs/go-unixfs/io" - libp2p "github.com/libp2p/go-libp2p" ci "github.com/libp2p/go-libp2p-crypto" - p2phost "github.com/libp2p/go-libp2p-host" peer "github.com/libp2p/go-libp2p-peer" - pstore "github.com/libp2p/go-libp2p-peerstore" ) type BuildCfg struct { @@ -245,6 +231,8 @@ func NewNode(ctx context.Context, cfg *BuildCfg) (*IpfsNode, error) { ) go func() { + // Note that some services use contexts to signal shutting down, which is + // very suboptimal. This needs to be here until that's addressed somehow <-ctx.Done() app.Stop(context.Background()) }() @@ -252,25 +240,6 @@ func NewNode(ctx context.Context, cfg *BuildCfg) (*IpfsNode, error) { n.IsOnline = cfg.Online n.app = app - /* n := &IpfsNode{ - IsOnline: cfg.Online, - Repo: cfg.Repo, - ctx: ctx, - Peerstore: pstoremem.NewPeerstore(), - } - - n.RecordValidator = record.NamespacedValidator{ - "pk": record.PublicKeyValidator{}, - "ipns": ipns.Validator{KeyBook: n.Peerstore}, - } - */ - // TODO: port to lifetimes - // n.proc = goprocessctx.WithContextAndTeardown(ctx, n.teardown) - - /*if err := setupNode(ctx, n, cfg); err != nil { - n.Close() - return nil, err - }*/ if app.Err() != nil { return nil, app.Err() } @@ -295,122 +264,3 @@ func isTooManyFDError(err error) bool { return false } - -func setupNode(ctx context.Context, n *IpfsNode, cfg *BuildCfg) error { - // setup local identity - if err := n.loadID(); err != nil { - return err - } - - // load the private key (if present) - if err := n.loadPrivateKey(); err != nil { - return err - } - - rds := &retry.Datastore{ - Batching: n.Repo.Datastore(), - Delay: time.Millisecond * 200, - Retries: 6, - TempErrFunc: isTooManyFDError, - } - - // hash security - bs := bstore.NewBlockstore(rds) - bs = &verifbs.VerifBS{Blockstore: bs} - - opts := bstore.DefaultCacheOpts() - conf, err := n.Repo.Config() - if err != nil { - return err - } - - // TEMP: setting global sharding switch here - uio.UseHAMTSharding = conf.Experimental.ShardingEnabled - - opts.HasBloomFilterSize = conf.Datastore.BloomFilterSize - if !cfg.Permanent { - opts.HasBloomFilterSize = 0 - } - - if !cfg.NilRepo { - bs, err = bstore.CachedBlockstore(ctx, bs, opts) - if err != nil { - return err - } - } - - bs = bstore.NewIdStore(bs) - - bs = cidv0v1.NewBlockstore(bs) - - n.BaseBlocks = bs - n.GCLocker = bstore.NewGCLocker() - n.Blockstore = bstore.NewGCBlockstore(bs, n.GCLocker) - - if conf.Experimental.FilestoreEnabled || conf.Experimental.UrlstoreEnabled { - // hash security - n.Filestore = filestore.NewFilestore(bs, n.Repo.FileManager()) - n.Blockstore = bstore.NewGCBlockstore(n.Filestore, n.GCLocker) - n.Blockstore = &verifbs.VerifBSGC{GCBlockstore: n.Blockstore} - } - - rcfg, err := n.Repo.Config() - if err != nil { - return err - } - - if rcfg.Datastore.HashOnRead { - bs.HashOnRead(true) - } - - hostOption := cfg.Host - if cfg.DisableEncryptedConnections { - innerHostOption := hostOption - hostOption = func(ctx context.Context, id peer.ID, ps pstore.Peerstore, options ...libp2p.Option) (p2phost.Host, error) { - return innerHostOption(ctx, id, ps, append(options, libp2p.NoSecurity)...) - } - // TODO: shouldn't this be Errorf to guarantee visibility? - log.Warningf(`Your IPFS node has been configured to run WITHOUT ENCRYPTED CONNECTIONS. - You will not be able to connect to any nodes configured to use encrypted connections`) - } - - if cfg.Online { - do := setupDiscoveryOption(rcfg.Discovery) - if err := n.startOnlineServices(ctx, cfg.Routing, hostOption, do, cfg.getOpt("pubsub"), cfg.getOpt("ipnsps"), cfg.getOpt("mplex")); err != nil { - return err - } - } else { - n.Exchange = offline.Exchange(n.Blockstore) - n.Routing = offroute.NewOfflineRouter(n.Repo.Datastore(), n.RecordValidator) - n.Namesys = namesys.NewNameSystem(n.Routing, n.Repo.Datastore(), 0) - } - - n.Blocks = bserv.New(n.Blockstore, n.Exchange) - n.DAG = dag.NewDAGService(n.Blocks) - - internalDag := dag.NewDAGService(bserv.New(n.Blockstore, offline.Exchange(n.Blockstore))) - n.Pinning, err = pin.LoadPinner(n.Repo.Datastore(), n.DAG, internalDag) - if err != nil { - // TODO: we should move towards only running 'NewPinner' explicitly on - // node init instead of implicitly here as a result of the pinner keys - // not being found in the datastore. - // this is kinda sketchy and could cause data loss - n.Pinning = pin.NewPinner(n.Repo.Datastore(), n.DAG, internalDag) - } - n.Resolver = resolver.NewBasicResolver(n.DAG) - - // Provider - queue, err := provider.NewQueue(ctx, "provider-v1", n.Repo.Datastore()) - if err != nil { - return err - } - n.Provider = provider.NewProvider(ctx, queue, n.Routing) - - if cfg.Online { - if err := n.startLateOnlineServices(ctx); err != nil { - return err - } - } - - return n.loadFilesRoot() -} diff --git a/core/core.go b/core/core.go index 1a62dc4e4..3056bd805 100644 --- a/core/core.go +++ b/core/core.go @@ -10,9 +10,7 @@ interfaces and how core/... fits into the bigger IPFS picture, see: package core import ( - "bytes" "context" - "errors" "fmt" "io" "io/ioutil" @@ -24,36 +22,32 @@ import ( version "github.com/ipfs/go-ipfs" rp "github.com/ipfs/go-ipfs/exchange/reprovide" - filestore "github.com/ipfs/go-ipfs/filestore" - mount "github.com/ipfs/go-ipfs/fuse/mount" - namesys "github.com/ipfs/go-ipfs/namesys" + "github.com/ipfs/go-ipfs/filestore" + "github.com/ipfs/go-ipfs/fuse/mount" + "github.com/ipfs/go-ipfs/namesys" ipnsrp "github.com/ipfs/go-ipfs/namesys/republisher" - p2p "github.com/ipfs/go-ipfs/p2p" - pin "github.com/ipfs/go-ipfs/pin" - provider "github.com/ipfs/go-ipfs/provider" - repo "github.com/ipfs/go-ipfs/repo" + "github.com/ipfs/go-ipfs/p2p" + "github.com/ipfs/go-ipfs/pin" + "github.com/ipfs/go-ipfs/provider" + "github.com/ipfs/go-ipfs/repo" - bitswap "github.com/ipfs/go-bitswap" - bsnet "github.com/ipfs/go-bitswap/network" bserv "github.com/ipfs/go-blockservice" - cid "github.com/ipfs/go-cid" + "github.com/ipfs/go-cid" ds "github.com/ipfs/go-datastore" bstore "github.com/ipfs/go-ipfs-blockstore" config "github.com/ipfs/go-ipfs-config" exchange "github.com/ipfs/go-ipfs-exchange-interface" nilrouting "github.com/ipfs/go-ipfs-routing/none" - u "github.com/ipfs/go-ipfs-util" ipld "github.com/ipfs/go-ipld-format" logging "github.com/ipfs/go-log" - merkledag "github.com/ipfs/go-merkledag" - mfs "github.com/ipfs/go-mfs" - resolver "github.com/ipfs/go-path/resolver" + "github.com/ipfs/go-merkledag" + "github.com/ipfs/go-mfs" + "github.com/ipfs/go-path/resolver" ft "github.com/ipfs/go-unixfs" - goprocess "github.com/jbenet/goprocess" - libp2p "github.com/libp2p/go-libp2p" + "github.com/jbenet/goprocess" + "github.com/libp2p/go-libp2p" autonat "github.com/libp2p/go-libp2p-autonat-svc" circuit "github.com/libp2p/go-libp2p-circuit" - connmgr "github.com/libp2p/go-libp2p-connmgr" ic "github.com/libp2p/go-libp2p-crypto" p2phost "github.com/libp2p/go-libp2p-host" ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr" @@ -62,17 +56,13 @@ import ( metrics "github.com/libp2p/go-libp2p-metrics" peer "github.com/libp2p/go-libp2p-peer" pstore "github.com/libp2p/go-libp2p-peerstore" - pnet "github.com/libp2p/go-libp2p-pnet" pubsub "github.com/libp2p/go-libp2p-pubsub" psrouter "github.com/libp2p/go-libp2p-pubsub-router" - quic "github.com/libp2p/go-libp2p-quic-transport" record "github.com/libp2p/go-libp2p-record" routing "github.com/libp2p/go-libp2p-routing" - rhelpers "github.com/libp2p/go-libp2p-routing-helpers" - discovery "github.com/libp2p/go-libp2p/p2p/discovery" + "github.com/libp2p/go-libp2p/p2p/discovery" p2pbhost "github.com/libp2p/go-libp2p/p2p/host/basic" - rhost "github.com/libp2p/go-libp2p/p2p/host/routed" - identify "github.com/libp2p/go-libp2p/p2p/protocol/identify" + "github.com/libp2p/go-libp2p/p2p/protocol/identify" mafilter "github.com/libp2p/go-maddr-filter" smux "github.com/libp2p/go-stream-muxer" ma "github.com/multiformats/go-multiaddr" @@ -153,218 +143,6 @@ type Mounts struct { Ipns mount.Mount } -func (n *IpfsNode) startOnlineServices(ctx context.Context, routingOption RoutingOption, hostOption HostOption, do DiscoveryOption, pubsub, ipnsps, mplex bool) error { - if n.PeerHost != nil { // already online. - return errors.New("node already online") - } - - if n.PrivateKey == nil { - return fmt.Errorf("private key not available") - } - - // get undialable addrs from config - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - var libp2pOpts []libp2p.Option - for _, s := range cfg.Swarm.AddrFilters { - f, err := mamask.NewMask(s) - if err != nil { - return fmt.Errorf("incorrectly formatted address filter in config: %s", s) - } - libp2pOpts = append(libp2pOpts, libp2p.FilterAddresses(f)) - } - - if !cfg.Swarm.DisableBandwidthMetrics { - // Set reporter - n.Reporter = metrics.NewBandwidthCounter() - libp2pOpts = append(libp2pOpts, libp2p.BandwidthReporter(n.Reporter)) - } - - swarmkey, err := n.Repo.SwarmKey() - if err != nil { - return err - } - - if swarmkey != nil { - protec, err := pnet.NewProtector(bytes.NewReader(swarmkey)) - if err != nil { - return fmt.Errorf("failed to configure private network: %s", err) - } - n.PNetFingerprint = protec.Fingerprint() - go func() { - t := time.NewTicker(30 * time.Second) - <-t.C // swallow one tick - for { - select { - case <-t.C: - if ph := n.PeerHost; ph != nil { - if len(ph.Network().Peers()) == 0 { - log.Warning("We are in private network and have no peers.") - log.Warning("This might be configuration mistake.") - } - } - //case <-n.Process().Closing(): - // t.Stop() - // return - } - } - }() - - libp2pOpts = append(libp2pOpts, libp2p.PrivateNetwork(protec)) - } - - addrsFactory, err := makeAddrsFactory(cfg.Addresses) - if err != nil { - return err - } - if !cfg.Swarm.DisableRelay { - addrsFactory = composeAddrsFactory(addrsFactory, filterRelayAddrs) - } - libp2pOpts = append(libp2pOpts, libp2p.AddrsFactory(addrsFactory)) - - connm, err := constructConnMgr(cfg.Swarm.ConnMgr) - if err != nil { - return err - } - libp2pOpts = append(libp2pOpts, libp2p.ConnectionManager(connm)) - - libp2pOpts = append(libp2pOpts, makeSmuxTransportOption(mplex)) - - if !cfg.Swarm.DisableNatPortMap { - libp2pOpts = append(libp2pOpts, libp2p.NATPortMap()) - } - - // disable the default listen addrs - libp2pOpts = append(libp2pOpts, libp2p.NoListenAddrs) - - if cfg.Swarm.DisableRelay { - // Enabled by default. - libp2pOpts = append(libp2pOpts, libp2p.DisableRelay()) - } else { - relayOpts := []circuit.RelayOpt{circuit.OptDiscovery} - if cfg.Swarm.EnableRelayHop { - relayOpts = append(relayOpts, circuit.OptHop) - } - libp2pOpts = append(libp2pOpts, libp2p.EnableRelay(relayOpts...)) - } - - // explicitly enable the default transports - libp2pOpts = append(libp2pOpts, libp2p.DefaultTransports) - - if cfg.Experimental.QUIC { - libp2pOpts = append(libp2pOpts, libp2p.Transport(quic.NewTransport)) - } - - // enable routing - libp2pOpts = append(libp2pOpts, libp2p.Routing(func(h p2phost.Host) (routing.PeerRouting, error) { - r, err := routingOption(ctx, h, n.Repo.Datastore(), n.RecordValidator) - n.Routing = r - return r, err - })) - - // enable autorelay - if cfg.Swarm.EnableAutoRelay { - libp2pOpts = append(libp2pOpts, libp2p.EnableAutoRelay()) - } - - peerhost, err := hostOption(ctx, n.Identity, n.Peerstore, libp2pOpts...) - - if err != nil { - return err - } - - n.PeerHost = peerhost - - if err := n.startOnlineServicesWithHost(ctx, routingOption, pubsub, ipnsps); err != nil { - return err - } - - // Ok, now we're ready to listen. - if err := startListening(n.PeerHost, cfg); err != nil { - return err - } - - n.P2P = p2p.NewP2P(n.Identity, n.PeerHost, n.Peerstore) - - // setup local discovery - if do != nil { - service, err := do(ctx, n.PeerHost) - if err != nil { - log.Error("mdns error: ", err) - } else { - service.RegisterNotifee(n) - n.Discovery = service - } - } - - return n.Bootstrap(DefaultBootstrapConfig) -} - -func constructConnMgr(cfg config.ConnMgr) (ifconnmgr.ConnManager, error) { - switch cfg.Type { - case "": - // 'default' value is the basic connection manager - return connmgr.NewConnManager(config.DefaultConnMgrLowWater, config.DefaultConnMgrHighWater, config.DefaultConnMgrGracePeriod), nil - case "none": - return nil, nil - case "basic": - grace, err := time.ParseDuration(cfg.GracePeriod) - if err != nil { - return nil, fmt.Errorf("parsing Swarm.ConnMgr.GracePeriod: %s", err) - } - - return connmgr.NewConnManager(cfg.LowWater, cfg.HighWater, grace), nil - default: - return nil, fmt.Errorf("unrecognized ConnMgr.Type: %q", cfg.Type) - } -} - -func (n *IpfsNode) startLateOnlineServices(ctx context.Context) error { - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - // Provider - - n.Provider.Run() - - // Reprovider - - var keyProvider rp.KeyChanFunc - - switch cfg.Reprovider.Strategy { - case "all": - fallthrough - case "": - keyProvider = rp.NewBlockstoreProvider(n.Blockstore) - case "roots": - keyProvider = rp.NewPinnedProvider(n.Pinning, n.DAG, true) - case "pinned": - keyProvider = rp.NewPinnedProvider(n.Pinning, n.DAG, false) - default: - return fmt.Errorf("unknown reprovider strategy '%s'", cfg.Reprovider.Strategy) - } - n.Reprovider = rp.NewReprovider(ctx, n.Routing, keyProvider) - - reproviderInterval := kReprovideFrequency - if cfg.Reprovider.Interval != "" { - dur, err := time.ParseDuration(cfg.Reprovider.Interval) - if err != nil { - return err - } - - reproviderInterval = dur - } - - go n.Reprovider.Run(reproviderInterval) - - return nil -} - func makeAddrsFactory(cfg config.Addresses) (p2pbhost.AddrsFactory, error) { var annAddrs []ma.Multiaddr for _, addr := range cfg.Announce { @@ -453,200 +231,6 @@ func makeSmuxTransportOption(mplexExp bool) libp2p.Option { return libp2p.ChainOptions(opts...) } -func setupDiscoveryOption(d config.Discovery) DiscoveryOption { - if d.MDNS.Enabled { - return func(ctx context.Context, h p2phost.Host) (discovery.Service, error) { - if d.MDNS.Interval == 0 { - d.MDNS.Interval = 5 - } - return discovery.NewMdnsService(ctx, h, time.Duration(d.MDNS.Interval)*time.Second, discovery.ServiceTag) - } - } - return nil -} - -// HandlePeerFound attempts to connect to peer from `PeerInfo`, if it fails -// logs a warning log. -func (n *IpfsNode) HandlePeerFound(p pstore.PeerInfo) { - log.Warning("trying peer info: ", p) - ctx, cancel := context.WithTimeout(n.Context(), discoveryConnTimeout) - defer cancel() - if err := n.PeerHost.Connect(ctx, p); err != nil { - log.Warning("Failed to connect to peer found by discovery: ", err) - } -} - -// startOnlineServicesWithHost is the set of services which need to be -// initialized with the host and _before_ we start listening. -func (n *IpfsNode) startOnlineServicesWithHost(ctx context.Context, routingOption RoutingOption, enablePubsub bool, enableIpnsps bool) error { - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - if cfg.Swarm.EnableAutoNATService { - var opts []libp2p.Option - if cfg.Experimental.QUIC { - opts = append(opts, libp2p.DefaultTransports, libp2p.Transport(quic.NewTransport)) - } - - svc, err := autonat.NewAutoNATService(ctx, n.PeerHost, opts...) - if err != nil { - return err - } - n.AutoNAT = svc - } - - if enablePubsub || enableIpnsps { - var service *pubsub.PubSub - - var pubsubOptions []pubsub.Option - if cfg.Pubsub.DisableSigning { - pubsubOptions = append(pubsubOptions, pubsub.WithMessageSigning(false)) - } - - if cfg.Pubsub.StrictSignatureVerification { - pubsubOptions = append(pubsubOptions, pubsub.WithStrictSignatureVerification(true)) - } - - switch cfg.Pubsub.Router { - case "": - fallthrough - case "floodsub": - service, err = pubsub.NewFloodSub(ctx, n.PeerHost, pubsubOptions...) - - case "gossipsub": - service, err = pubsub.NewGossipSub(ctx, n.PeerHost, pubsubOptions...) - - default: - err = fmt.Errorf("Unknown pubsub router %s", cfg.Pubsub.Router) - } - - if err != nil { - return err - } - n.PubSub = service - } - - // this code is necessary just for tests: mock network constructions - // ignore the libp2p constructor options that actually construct the routing! - if n.Routing == nil { - r, err := routingOption(ctx, n.PeerHost, n.Repo.Datastore(), n.RecordValidator) - if err != nil { - return err - } - n.Routing = r - n.PeerHost = rhost.Wrap(n.PeerHost, n.Routing) - } - - // TODO: I'm not a fan of type assertions like this but the - // `RoutingOption` system doesn't currently provide access to the - // IpfsNode. - // - // Ideally, we'd do something like: - // - // 1. Add some fancy method to introspect into tiered routers to extract - // things like the pubsub router or the DHT (complicated, messy, - // probably not worth it). - // 2. Pass the IpfsNode into the RoutingOption (would also remove the - // PSRouter case below. - // 3. Introduce some kind of service manager? (my personal favorite but - // that requires a fair amount of work). - if dht, ok := n.Routing.(*dht.IpfsDHT); ok { - n.DHT = dht - } - - if enableIpnsps { - n.PSRouter = psrouter.NewPubsubValueStore( - ctx, - n.PeerHost, - n.Routing, - n.PubSub, - n.RecordValidator, - ) - n.Routing = rhelpers.Tiered{ - Routers: []routing.IpfsRouting{ - // Always check pubsub first. - &rhelpers.Compose{ - ValueStore: &rhelpers.LimitedValueStore{ - ValueStore: n.PSRouter, - Namespaces: []string{"ipns"}, - }, - }, - n.Routing, - }, - Validator: n.RecordValidator, - } - } - - // setup exchange service - bitswapNetwork := bsnet.NewFromIpfsHost(n.PeerHost, n.Routing) - n.Exchange = bitswap.New(ctx, bitswapNetwork, n.Blockstore) - - size, err := n.getCacheSize() - if err != nil { - return err - } - - // setup name system - n.Namesys = namesys.NewNameSystem(n.Routing, n.Repo.Datastore(), size) - - // setup ipns republishing - return n.setupIpnsRepublisher() -} - -// getCacheSize returns cache life and cache size -func (n *IpfsNode) getCacheSize() (int, error) { - cfg, err := n.Repo.Config() - if err != nil { - return 0, err - } - - cs := cfg.Ipns.ResolveCacheSize - if cs == 0 { - cs = DefaultIpnsCacheSize - } - if cs < 0 { - return 0, fmt.Errorf("cannot specify negative resolve cache size") - } - return cs, nil -} - -func (n *IpfsNode) setupIpnsRepublisher() error { - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - n.IpnsRepub = ipnsrp.NewRepublisher(n.Namesys, n.Repo.Datastore(), n.PrivateKey, n.Repo.Keystore()) - - if cfg.Ipns.RepublishPeriod != "" { - d, err := time.ParseDuration(cfg.Ipns.RepublishPeriod) - if err != nil { - return fmt.Errorf("failure to parse config setting IPNS.RepublishPeriod: %s", err) - } - - if !u.Debug && (d < time.Minute || d > (time.Hour*24)) { - return fmt.Errorf("config setting IPNS.RepublishPeriod is not between 1min and 1day: %s", d) - } - - n.IpnsRepub.Interval = d - } - - if cfg.Ipns.RecordLifetime != "" { - d, err := time.ParseDuration(cfg.Ipns.RecordLifetime) - if err != nil { - return fmt.Errorf("failure to parse config setting IPNS.RecordLifetime: %s", err) - } - - n.IpnsRepub.RecordLifetime = d - } - - //n.Process().Go(n.IpnsRepub.Run) - - return nil -} - // Close calls Close() on the App object func (n *IpfsNode) Close() error { return n.app.Stop(n.ctx) @@ -660,68 +244,6 @@ func (n *IpfsNode) Context() context.Context { return n.ctx } -// teardown closes owned children. If any errors occur, this function returns -// the first error. -func (n *IpfsNode) teardown() error { - log.Debug("core is shutting down...") - // owned objects are closed in this teardown to ensure that they're closed - // regardless of which constructor was used to add them to the node. - var closers []io.Closer - - // NOTE: The order that objects are added(closed) matters, if an object - // needs to use another during its shutdown/cleanup process, it should be - // closed before that other object - - if n.Provider != nil { - closers = append(closers, n.Provider) - } - - if n.FilesRoot != nil { - closers = append(closers, n.FilesRoot) - } - - if n.Exchange != nil { - closers = append(closers, n.Exchange) - } - - if n.Mounts.Ipfs != nil && !n.Mounts.Ipfs.IsActive() { //TODO - closers = append(closers, mount.Closer(n.Mounts.Ipfs)) - } - if n.Mounts.Ipns != nil && !n.Mounts.Ipns.IsActive() { // TODO - closers = append(closers, mount.Closer(n.Mounts.Ipns)) - } - - if n.DHT != nil { - closers = append(closers, n.DHT.Process()) - } - - if n.Blocks != nil { - closers = append(closers, n.Blocks) - } - - if n.Bootstrapper != nil { - closers = append(closers, n.Bootstrapper) - } - - if n.PeerHost != nil { - closers = append(closers, n.PeerHost) - } - - // Repo closed last, most things need to preserve state here - closers = append(closers, n.Repo) - - var errs []error - for _, closer := range closers { - if err := closer.Close(); err != nil { - errs = append(errs, err) - } - } - if len(errs) > 0 { - return errs[0] - } - return nil -} - // Bootstrap will set and call the IpfsNodes bootstrap function. func (n *IpfsNode) Bootstrap(cfg BootstrapConfig) error { // TODO what should return value be when in offlineMode? @@ -751,80 +273,6 @@ func (n *IpfsNode) Bootstrap(cfg BootstrapConfig) error { return err } -func (n *IpfsNode) loadID() error { - if n.Identity != "" { - return errors.New("identity already loaded") - } - - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - cid := cfg.Identity.PeerID - if cid == "" { - return errors.New("identity was not set in config (was 'ipfs init' run?)") - } - if len(cid) == 0 { - return errors.New("no peer ID in config! (was 'ipfs init' run?)") - } - - id, err := peer.IDB58Decode(cid) - if err != nil { - return fmt.Errorf("peer ID invalid: %s", err) - } - - n.Identity = id - return nil -} - -// GetKey will return a key from the Keystore with name `name`. -func (n *IpfsNode) GetKey(name string) (ic.PrivKey, error) { - if name == "self" { - if n.PrivateKey == nil { - return nil, fmt.Errorf("private key not available") - } - return n.PrivateKey, nil - } else { - return n.Repo.Keystore().Get(name) - } -} - -// loadPrivateKey loads the private key *if* available -func (n *IpfsNode) loadPrivateKey() error { - if n.Identity == "" || n.Peerstore == nil { - return errors.New("loaded private key out of order") - } - - if n.PrivateKey != nil { - log.Warning("private key already loaded") - return nil - } - - cfg, err := n.Repo.Config() - if err != nil { - return err - } - - if cfg.Identity.PrivKey == "" { - return nil - } - - sk, err := loadPrivateKey(&cfg.Identity, n.Identity) - if err != nil { - return err - } - - if err := n.Peerstore.AddPrivKey(n.Identity, sk); err != nil { - return err - } - if err := n.Peerstore.AddPubKey(n.Identity, sk.GetPublic()); err != nil { - return err - } - n.PrivateKey = sk - return nil -} - func (n *IpfsNode) loadBootstrapPeers() ([]pstore.PeerInfo, error) { cfg, err := n.Repo.Config() if err != nil { @@ -838,70 +286,6 @@ func (n *IpfsNode) loadBootstrapPeers() ([]pstore.PeerInfo, error) { return toPeerInfos(parsed), nil } -func (n *IpfsNode) loadFilesRoot() error { - dsk := ds.NewKey("/local/filesroot") - pf := func(ctx context.Context, c cid.Cid) error { - return n.Repo.Datastore().Put(dsk, c.Bytes()) - } - - var nd *merkledag.ProtoNode - val, err := n.Repo.Datastore().Get(dsk) - - switch { - case err == ds.ErrNotFound || val == nil: - nd = ft.EmptyDirNode() - err := n.DAG.Add(n.Context(), nd) - if err != nil { - return fmt.Errorf("failure writing to dagstore: %s", err) - } - case err == nil: - c, err := cid.Cast(val) - if err != nil { - return err - } - - rnd, err := n.DAG.Get(n.Context(), c) - if err != nil { - return fmt.Errorf("error loading filesroot from DAG: %s", err) - } - - pbnd, ok := rnd.(*merkledag.ProtoNode) - if !ok { - return merkledag.ErrNotProtobuf - } - - nd = pbnd - default: - return err - } - - mr, err := mfs.NewRoot(n.Context(), n.DAG, nd, pf) - if err != nil { - return err - } - - n.FilesRoot = mr - return nil -} - -func loadPrivateKey(cfg *config.Identity, id peer.ID) (ic.PrivKey, error) { - sk, err := cfg.DecodePrivateKey("passphrase todo!") - if err != nil { - return nil, err - } - - id2, err := peer.IDFromPrivateKey(sk) - if err != nil { - return nil, err - } - - if id2 != id { - return nil, fmt.Errorf("private key in config does not match id: %s != %s", id, id2) - } - - return sk, nil -} - func listenAddresses(cfg *config.Config) ([]ma.Multiaddr, error) { var listen []ma.Multiaddr for _, addr := range cfg.Addresses.Swarm {