GitLab

* support for forced direct connections.

It's impossible to run two nodes on the same IP:port, so we know for
sure that any dial to an address that we're listening on will fail (as
the peer IDs won't match).
In practice, this will be most useful for preventing dials to localhost
for nodes that are listening on the default port.

This commit switches over to the new Close/CloseWrite/CloseRead interface
changes in go-libp2p-core 0.7.0.

This change also removes a now obsolete hack to implicitly clean up streams
after reading an EOF; calling Close or Reset is now required.

See: https://github.com/libp2p/go-libp2p-core/releases/tag/v0.7.0

* Rank dial addresss.

1. Always return the caller's context error if relevant.
2. Don't return "context canceled" when we're just shutting down.
3. Don't claim that the context deadline has been exceeded when the dial timeout
is canceled.

* Limits the number of dial errors we keep
* Exposes the dial errors
* Avoids string formatting unless we actually need to.

Helps address https://github.com/libp2p/go-libp2p-swarm/issues/119

License: MIT
Signed-off-by: Georgij Tolstov <tolstov.georgij@gmail.com>

This commit moves filtering of dial candidates into its own little function.
Things that are being filtered: addresses configured to be blocked,
IPv6 link-local addresses, addresses without a dial-capable transport,
and addresses that we know to be our own. It's is an optimization to
avoid wasting time on dials that we know are going to fail.

This also relaxes the filtering of addresses that we consider our own.
Previously, any address would get filtered that's registered in peerstore
for or own PeerID. For e.g. /ip4/1.2.3.4/tcp/4001 that's fine, but for
ephemeral ports it can already cause problems.

In addition, now that go-libp2p-circuit is being fixed to handle its
multiaddrs slightly differently, /p2p-circuit addresses won't contain
the PeerID anymore. That means they stand for themselves, and would get
filtered too. (/p2p-circuit is the address we want to dial, but it's
also on of "our own addresses").

In the future we'd want to use the mafmt package here, and also consider
/quic, /ws, etc. addresses as our own.

On trying to open a new stream against an empty peer ID, we get an
error saying that failed to dial a peer.

This commit changes that to a more informative error message:
`empty peer ID`

This timeout is already set by the dial limiter.

The global per-peer dial timeout had a significant drawback: When dialing many
peers, this timeout could cause libp2p to cancel dials while they were still
stuck in the limiter.

A better but more complicated approach is a time budget system but we can
implement that later.

This change simply applies the limit to each `DialPeer`/`NewStream` call
independently and makes it easy to override. While old timeout tried to
account for how much we're willing to spend dialing a single peer, this new
timeout tries to account for the amount of time a single "client" is willing to
wait for a dial to complete before they no longer care.

Removes:

* go-libp2p-conn logic (moved to transports)
* go-libp2p-peerstream (moved here)

Changes:

* New transport interface.
* Explicit over implicit (the implicit automagic now all lives in go-libp2p):
  * No more default transports, muxers, etc.
  * No more fallback dialer. Transports are now *required*.
* Stream opening:
  * Connection picking logic (instead of just picking the first).
  * Tries harder to open a stream of some connections happen to be closed.
* Stream closing:
  * No longer treats half-closed streams as fully closed. Users *must* read the
    an EOF or reset the stream for it to be garbage collected.
* No more polling for dead connections.
* Multiplexers are now *non-optional*. Really, they haven't been optional for a
  while but we still pretended that they were.
* No more Network type alias. It added a bunch of code and didn't really provide
  anything but an alternative set of methods that do the same thing.
* Notifications:
  * New guarantee: connection open notifications will complete before connection
    close notifications begin.
  * Given that, notifications are now delivered in parallel. No more
    notification backlogs blocking connection closing/opening.

We already setup the connection from within the new connection handler. No need
to do it *again* on dial.

It doesn't exist anymore. This is now handled entirely though contexts.

fixes libp2p/go-libp2p-kad-dht#96