func NewNode(ctx context.Context, cfg *BuildCfg) (*IpfsNode, error) { if cfg == nil { cfg = new(BuildCfg) } err := cfg.fillDefaults() if err != nil { return nil, err } n := &IpfsNode{ mode: offlineMode, Repo: cfg.Repo, ctx: ctx, Peerstore: pstore.NewPeerstore(), } if cfg.Online { n.mode = onlineMode } // TODO: this is a weird circular-ish dependency, rework it n.proc = goprocessctx.WithContextAndTeardown(ctx, n.teardown) if err := setupNode(ctx, n, cfg); err != nil { n.Close() return nil, err } return n, nil }
func WrapTransportListener(ctx context.Context, ml transport.Listener, local peer.ID, sk ic.PrivKey) (Listener, error) { l := &listener{ Listener: ml, local: local, privk: sk, } l.proc = goprocessctx.WithContextAndTeardown(ctx, l.teardown) log.Debugf("Conn Listener on %s", l.Multiaddr()) log.Event(ctx, "swarmListen", l) return l, nil }
// newPeernet constructs a new peernet func newPeernet(ctx context.Context, m *mocknet, p peer.ID, ps peer.Peerstore) (*peernet, error) { n := &peernet{ mocknet: m, peer: p, ps: ps, connsByPeer: map[peer.ID]map[*conn]struct{}{}, connsByLink: map[*link]map[*conn]struct{}{}, notifs: make(map[inet.Notifiee]struct{}), } n.proc = goprocessctx.WithContextAndTeardown(ctx, n.teardown) return n, nil }
// NewSwarm constructs a Swarm, with a Chan. func NewSwarm(ctx context.Context, listenAddrs []ma.Multiaddr, local peer.ID, peers peer.Peerstore, bwc metrics.Reporter) (*Swarm, error) { listenAddrs, err := filterAddrs(listenAddrs) if err != nil { return nil, err } wrap := func(c transport.Conn) transport.Conn { return mconn.WrapConn(bwc, c) } s := &Swarm{ swarm: ps.NewSwarm(PSTransport), local: local, peers: peers, ctx: ctx, dialT: DialTimeout, notifs: make(map[inet.Notifiee]ps.Notifiee), transports: []transport.Transport{ transport.NewTCPTransport(), transport.NewUtpTransport(), }, bwc: bwc, fdRateLimit: make(chan struct{}, concurrentFdDials), Filters: filter.NewFilters(), dialer: conn.NewDialer(local, peers.PrivKey(local), wrap), } // configure Swarm s.proc = goprocessctx.WithContextAndTeardown(ctx, s.teardown) s.SetConnHandler(nil) // make sure to setup our own conn handler. err = s.setupInterfaces(listenAddrs) if err != nil { return nil, err } return s, nil }
func WrapTransportListener(ctx context.Context, ml transport.Listener, local peer.ID, sk ic.PrivKey) (Listener, error) { l := &listener{ Listener: ml, local: local, privk: sk, mux: msmux.NewMultistreamMuxer(), incoming: make(chan connErr, connAcceptBuffer), ctx: ctx, } l.proc = goprocessctx.WithContextAndTeardown(ctx, l.teardown) l.catcher.IsTemp = func(e error) bool { // ignore connection breakages up to this point. but log them if e == io.EOF { log.Debugf("listener ignoring conn with EOF: %s", e) return true } te, ok := e.(tec.Temporary) if ok { log.Debugf("listener ignoring conn with temporary err: %s", e) return te.Temporary() } return false } if EncryptConnections { l.mux.AddHandler(SecioTag, nil) } else { l.mux.AddHandler(NoEncryptionTag, nil) } go l.handleIncoming() log.Debugf("Conn Listener on %s", l.Multiaddr()) log.Event(ctx, "swarmListen", l) return l, nil }