Compare commits

..

55 Commits

Author SHA1 Message Date
ef54e0a10e chore: release version v0.35.8 2021-12-29 11:00:11 +01:00
61bf546c46 chore: update contributors 2021-12-29 11:00:11 +01:00
d2b7ec0f6b fix: look for final peer event instead of peer response (#1092)
`FINAL_PEER` means we found the peer, `PEER_RESPONSE` means a peer
responded to our query.
2021-12-29 10:56:56 +01:00
79b3cfc6ad fix: do not wait for autodial start (#1089)
When we've previously seen loads of peers and stored them in the
datastore we'll try to dial them as part of starting the autodial
component.

If we or our peers have bad network connections this can make
starting a libp2p node take ages so don't wait for a round of auto
dialing before considering the component started.
2021-12-29 10:55:48 +01:00
f18fc80b70 fix: increase listeners on any-signal (#1084)
Increase the number of listeners we allow on the actual signal we pass along, instead of the signal we pass into any-signal.
2021-12-29 10:51:26 +01:00
b4b432406e fix: record tracked map clears (#1085)
Record the size of a map after we `.clear()` it.
2021-12-27 07:14:27 +01:00
bbdd559a02 chore: release version v0.35.7 2021-12-24 14:51:51 +00:00
4070dcdf55 chore: update contributors 2021-12-24 14:51:51 +00:00
cb0d7d6c99 fix: type definitions for big dialrequest and persistent peerstore (#1078)
Signed-off-by: Tuyen Nguyen <vutuyen2636@gmail.com>
2021-12-24 15:46:00 +01:00
d1c48dcbed fix: main ci (#1079) 2021-12-24 11:18:09 +01:00
c4a442788b docs: update example config ipfs links (#1077) 2021-12-22 17:03:03 +01:00
70a4bb9451 docs: peerstore configuration datastore fixed 2021-12-22 14:15:18 +01:00
a0516ebc85 docs: update node and npm version badge according to package.json (#1074) 2021-12-22 14:01:54 +01:00
b425fa1230 fix: add tracked map (#1069)
Small refactor of the component stats - adds a `TrackedMap` which encapsulates updating the metrics and means we don't need to null guard on `this._metrics` everywhere.

If metrics are not enabled a regular `Map` is used.
2021-12-21 15:51:06 +01:00
0a485d07b3 chore: release version v0.35.6 2021-12-18 07:55:27 +01:00
0c3ed0a4ac chore: update contributors 2021-12-18 07:55:26 +01:00
09a0f940df fix: increase the maxlisteners for timeout controllers (#1065)
We use timeout controllers to ensure we're not dialling peers forever but we can end up registering lots of listeners for the `abort` event when peers have a lot of addresses.

In node this means we see an unhelpful `MaxListenersExceededWarning` in the console warning of a potential memory leak.

Increase the max number of listeners on the signal to silence the warning.
2021-12-18 07:34:27 +01:00
a642ad2a03 chore(deps-dev): bump libp2p-floodsub from 0.27.1 to 0.28.0 (#1062)
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2021-12-15 09:30:49 +00:00
8ce2f08589 chore: release version v0.35.5 2021-12-15 09:28:05 +00:00
fe0d9828bb chore: update contributors 2021-12-15 09:28:04 +00:00
c8e1b08c19 chore: typo 2021-12-15 09:25:40 +00:00
faf1f89d9e chore: release version v0.35.4 2021-12-15 08:18:44 +00:00
76f4ea5e8a chore: update contributors 2021-12-15 08:18:44 +00:00
2f0b311df7 feat: allow per-component metrics to be collected (#1061)
Implements the idea from #1060 - allows us to get some insight into what's happening in a libp2p node out side of just bandwidth stats.

Configures a few default metrics if metrics are enabled - current connections, the state of the dial queue, etc.

Also makes the `Metrics` class not depend on the `ConnectionManager` class, otherwise we can't collect simple metrics from the connection manager class due to the circular dependency.
2021-12-15 08:03:09 +00:00
d172d0d952 chore: release version v0.35.3 2021-12-13 09:03:54 +00:00
f8e8023aed chore: update contributors 2021-12-13 09:03:54 +00:00
bdc9f16d0c fix: clean up pending dial targets (#1059)
If the `Promise.race` throws, execution of the function is terminated so the pending dial target is never removed from the map and we leak memory.

This can happen when there are invalid multiaddrs or when a peer reports more dialable addresses than the threshold.

Instead wrap the `Promise.race` in a `try/finally` which will always remove the pending dial target in the event of success or failure.
2021-12-10 12:42:09 +00:00
1b46f47fdb chore: run node tests in ci (#1057)
Looks like this project stopped running the `test:node` npm script when it was migrated to gh actions.

Re-enable it and fix all the related test failures.
2021-12-08 08:38:17 +00:00
b539f9b655 chore(deps-dev): bump libp2p-gossipsub from 0.11.4 to 0.12.1 (#1045)
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2021-12-07 21:06:06 +00:00
103818733e chore(deps-dev): bump @chainsafe/libp2p-noise from 4.1.1 to 5.0.0 (#1053)
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2021-12-07 21:05:53 +00:00
1f1bbc0ee6 docs: naming error in the documentation (#1056)
Changed LevelStore to LevelDatastore
2021-12-07 21:05:33 +00:00
3b683e7156 fix: fix uncaught promise rejection when finding peers (#1044)
Do not abort all attempts to find peers when `findPeers` on one router throws synchronously

Co-authored-by: Robert Kiel <robert.kiel@hoprnet.io>
Co-authored-by: achingbrain <alex@achingbrain.net>
2021-12-07 17:51:48 +00:00
b25e0fe531 fix: make error codes consistent (#1054)
Sometimes they are `NOT_FOUND`, sometimes `ERR_NOT_FOUND`, etc.

Move all error codes into `errors.js` and reference them from there.
2021-12-07 14:42:10 +00:00
cbaa5a2ef3 chore: switch to nat api (#1052)
@motrix/nat-api is a fork, nat-api has the fix from https://github.com/alxhotel/nat-api/pull/25
2021-12-07 09:37:12 +00:00
51dabb1724 chore: pubsub example subscribe returns void (#1048)
Seems like the correct return type of `Libp2p.pubsub.subscribe` is `void`, so the `await` can be removed: ae21299ade/src/pubsub-adapter.js (L29)
2021-12-06 21:12:38 +01:00
b9339bccaa chore: release version v0.35.2 2021-12-06 21:07:39 +01:00
9b21893b64 chore: update contributors 2021-12-06 21:07:38 +01:00
b70fb43427 fix: increase maxlisteners on event target (#1050)
Sometimes you encounter peers with lots of addresses. When this happens
you can attach more than 10x event listeners to the abort signal we
use to abort all the dials - this causes node to print a warning
which is misleading.

This PR increases the default number of listeners on the signal.

Fixes #900
2021-12-06 20:54:44 +01:00
ae21299ade chore: release version v0.35.1 2021-12-03 16:24:14 +00:00
149120bebc chore: update contributors 2021-12-03 16:24:13 +00:00
91c2ec9856 fix: do not let closest peers run forever (#1047)
The DHT takes a `signal` not a timeout so if a timeout is passed,
create a `TimeoutController` that will abort the query after the
timeout.
2021-12-03 15:47:30 +00:00
6d0ac819f1 chore: release version v0.35.0 2021-12-02 10:44:07 +00:00
15a0b1dbf2 chore: update contributors 2021-12-02 10:44:07 +00:00
9cbf36fcb5 chore: update peer id and libp2p crypto (#1042)
BREAKING CHANGE: requires node 15+
2021-12-02 10:11:23 +00:00
3a9d5f64d9 fix: stop dht before connection manager (#1041)
Stop the dht before the connection manager, otherwise in-flight eviction pings fail and we move on to the next one when we should just abort them all.

Also pulls in the fix from #1039 and splits the auto-dialler out from the connection manager as during shutdown it can get into a weird state where it's simultaneously killing and creating connections so stop auto-dialling things before we cause connections to dip below the low watermark by killing existing connections.

Fixes: https://github.com/ipfs/js-ipfs/issues/3923
2021-11-30 18:07:57 +00:00
eacd7e8f76 chore: update deps (#1038) 2021-11-26 16:00:47 +00:00
7f2cc4dc44 chore(deps-dev): bump ipfs-http-client from 52.0.5 to 54.0.2 (#1035)
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2021-11-26 14:26:26 +00:00
5cc5a8749a chore: release version v0.34.0 2021-11-25 16:49:46 +00:00
ee60e18213 chore: update contributors 2021-11-25 16:49:46 +00:00
a4a2fac41e chore: node_modules is not required 2021-11-25 16:48:41 +00:00
2f598eba09 feat: update dht (#1009)
Changes dht creation to use factory function and updates docs

BREAKING CHANGE: libp2p-kad-dht has a new event-based API which is exposed as `_dht`
2021-11-25 16:32:19 +00:00
443a102528 docs: minor corrections to discovery-mechanisms readme (#1030) 2021-11-21 23:18:45 +01:00
3bed7b4cb2 chore: update aegir (#1027)
Updates aegir, fixes all new linting errors.
2021-11-19 08:02:24 +00:00
3fb424914f chore: fix examples (#1026)
Uses npm to install deps for examples.

We can put yarn back when we remove `node-fetch@2.x` from ipfs-utils, or when
yarn can download tarball dependencies reliably.

This either needs:

1. https://github.com/node-fetch/node-fetch/pull/1172 merging
2. Swap node-fetch for undici
3. Drop CJS support (node-fetch 3 has the above fix but is ESM-only)
2021-11-19 07:26:38 +00:00
bb0ca28195 docs: update connection link in API docs (#1024)
Fixes #1018

The issue was caused when the repo [js-libp2p-interfaces](https://github.com/libp2p/js-libp2p-interfaces) was renamed and refactored in this [commit](946348f7f8)
2021-11-16 15:55:00 +00:00
76 changed files with 1191 additions and 527 deletions

View File

@ -12,6 +12,9 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: npx aegir lint - run: npx aegir lint
- run: npx aegir ts -p check - run: npx aegir ts -p check
@ -21,82 +24,118 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- auto-relay - run: cd examples && npm i && npm run test -- auto-relay
test-chat-example: test-chat-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- chat - run: cd examples && npm i && npm run test -- chat
test-connection-encryption-example: test-connection-encryption-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- connection-encryption - run: cd examples && npm i && npm run test -- connection-encryption
test-discovery-mechanisms-example: test-discovery-mechanisms-example:
needs: check needs: check
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- discovery-mechanisms - run: cd examples && npm i && npm run test -- discovery-mechanisms
test-echo-example: test-echo-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- echo - run: cd examples && npm i && npm run test -- echo
test-libp2p-in-the-browser-example: test-libp2p-in-the-browser-example:
needs: check needs: check
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- libp2p-in-the-browser - run: cd examples && npm i && npm run test -- libp2p-in-the-browser
test-peer-and-content-routing-example: test-peer-and-content-routing-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- peer-and-content-routing - run: cd examples && npm i && npm run test -- peer-and-content-routing
test-pnet-example: test-pnet-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- pnet - run: cd examples && npm i && npm run test -- pnet
test-protocol-and-stream-muxing-example: test-protocol-and-stream-muxing-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- protocol-and-stream-muxing - run: cd examples && npm i && npm run test -- protocol-and-stream-muxing
test-pubsub-example: test-pubsub-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- pubsub - run: cd examples && npm i && npm run test -- pubsub
test-transports-example: test-transports-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: 16
- run: npm install - run: npm install
- run: cd examples && npm install && npm run test -- transports - run: cd examples && npm i && npm run test -- transports
test-webrtc-direct-example: test-webrtc-direct-example:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- run: npm install - uses: actions/setup-node@v2
- run: cd examples && npm install && npm run test -- webrtc-direct with:
node-version: 16
- run: npm install -g @mapbox/node-pre-gyp && npm install
- run: cd examples && npm i && npm run test -- webrtc-direct

View File

@ -14,13 +14,12 @@ jobs:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2 - uses: actions/setup-node@v2
with: with:
node-version: 14 node-version: 16
- run: npm install - run: npm install
- run: npx aegir lint - run: npx aegir lint
- uses: gozala/typescript-error-reporter-action@v1.0.8
- run: npx aegir build - run: npx aegir build
- run: npx aegir dep-check - run: npx aegir dep-check
- uses: ipfs/aegir/actions/bundle-size@v32.1.0 - uses: ipfs/aegir/actions/bundle-size@master
name: size name: size
with: with:
github_token: ${{ secrets.GITHUB_TOKEN }} github_token: ${{ secrets.GITHUB_TOKEN }}
@ -30,7 +29,7 @@ jobs:
strategy: strategy:
matrix: matrix:
os: [windows-latest, ubuntu-latest, macos-latest] os: [windows-latest, ubuntu-latest, macos-latest]
node: [14, 16] node: [16]
fail-fast: true fail-fast: true
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
@ -38,27 +37,36 @@ jobs:
with: with:
node-version: ${{ matrix.node }} node-version: ${{ matrix.node }}
- run: npm install - run: npm install
- run: npx aegir test -t node --cov --bail - run: npm run test:node -- --cov --bail
- uses: codecov/codecov-action@v1 - uses: codecov/codecov-action@v1
test-chrome: test-chrome:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: lts/*
- run: npm install - run: npm install
- run: npx aegir test -t browser -t webworker --bail - run: npm run test:browser -- -t browser -t webworker --bail
test-firefox: test-firefox:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: lts/*
- run: npm install - run: npm install
- run: npx aegir test -t browser -t webworker --bail -- --browser firefox - run: npm run test:browser -- -t browser -t webworker --bail -- --browser firefox
test-ts: test-ts:
needs: check needs: check
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: lts/*
- run: npm install - run: npm install
- run: npm run test:ts - run: npm run test:ts
test-interop: test-interop:
@ -66,5 +74,8 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- uses: actions/setup-node@v2
with:
node-version: lts/*
- run: npm install - run: npm install
- run: cd node_modules/interop-libp2p && yarn && LIBP2P_JS=${GITHUB_WORKSPACE}/src/index.js npx aegir test -t node --bail -- --exit - run: npm run test:interop -- --bail -- --exit

View File

@ -1,3 +1,143 @@
## [0.35.8](https://github.com/libp2p/js-libp2p/compare/v0.35.7...v0.35.8) (2021-12-29)
### Bug Fixes
* do not wait for autodial start ([#1089](https://github.com/libp2p/js-libp2p/issues/1089)) ([79b3cfc](https://github.com/libp2p/js-libp2p/commit/79b3cfc6ad02ecc76fe23a3c3ff2d0b32a0ae4a8))
* increase listeners on any-signal ([#1084](https://github.com/libp2p/js-libp2p/issues/1084)) ([f18fc80](https://github.com/libp2p/js-libp2p/commit/f18fc80b70bf7b6b26fffa70b0a8d0502a6c4801))
* look for final peer event instead of peer response ([#1092](https://github.com/libp2p/js-libp2p/issues/1092)) ([d2b7ec0](https://github.com/libp2p/js-libp2p/commit/d2b7ec0f6be0ee80f2c963279a8ec2385059a889))
* record tracked map clears ([#1085](https://github.com/libp2p/js-libp2p/issues/1085)) ([b4b4324](https://github.com/libp2p/js-libp2p/commit/b4b432406ebc08ef2fc3a1922c64cde7c9060cae))
## [0.35.7](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.7) (2021-12-24)
### Bug Fixes
* add tracked map ([#1069](https://github.com/libp2p/js-libp2p/issues/1069)) ([b425fa1](https://github.com/libp2p/js-libp2p/commit/b425fa12304def2a007d43a0aa445c28b766ed02))
* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
* main ci ([#1079](https://github.com/libp2p/js-libp2p/issues/1079)) ([d1c48dc](https://github.com/libp2p/js-libp2p/commit/d1c48dcbeded828f2dd3044cc9aed3f17f02846d))
* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
* type definitions for big dialrequest and persistent peerstore ([#1078](https://github.com/libp2p/js-libp2p/issues/1078)) ([cb0d7d6](https://github.com/libp2p/js-libp2p/commit/cb0d7d6c99d179498f04e76df76e70e4f7d41c4c))
### Features
* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
## [0.35.6](https://github.com/libp2p/js-libp2p/compare/v0.35.5...v0.35.6) (2021-12-18)
### Bug Fixes
* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
## [0.35.5](https://github.com/libp2p/js-libp2p/compare/v0.35.4...v0.35.5) (2021-12-15)
## [0.35.4](https://github.com/libp2p/js-libp2p/compare/v0.35.3...v0.35.4) (2021-12-15)
### Features
* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
## [0.35.3](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.3) (2021-12-13)
### Bug Fixes
* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
## [0.35.2](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.35.2) (2021-12-06)
### Bug Fixes
* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
* increase maxlisteners on event target ([#1050](https://github.com/libp2p/js-libp2p/issues/1050)) ([b70fb43](https://github.com/libp2p/js-libp2p/commit/b70fb43427b47df079b55929ec8956f69cbda966)), closes [#900](https://github.com/libp2p/js-libp2p/issues/900)
* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
### chore
* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
### Features
* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
### BREAKING CHANGES
* requires node 15+
* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
## [0.35.1](https://github.com/libp2p/js-libp2p/compare/v0.35.0...v0.35.1) (2021-12-03)
### Bug Fixes
* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
# [0.35.0](https://github.com/libp2p/js-libp2p/compare/v0.34.0...v0.35.0) (2021-12-02)
### Bug Fixes
* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
### chore
* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
### BREAKING CHANGES
* requires node 15+
# [0.34.0](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.34.0) (2021-11-25)
### Bug Fixes
* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
### Features
* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
### BREAKING CHANGES
* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
# [0.33.0](https://github.com/libp2p/js-libp2p/compare/v0.32.5...v0.33.0) (2021-09-24) # [0.33.0](https://github.com/libp2p/js-libp2p/compare/v0.32.5...v0.33.0) (2021-09-24)

View File

@ -23,8 +23,8 @@
<a href="https://david-dm.org/libp2p/js-libp2p"><img src="https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square" /></a> <a href="https://david-dm.org/libp2p/js-libp2p"><img src="https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square" /></a>
<a href="https://github.com/feross/standard"><img src="https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square"></a> <a href="https://github.com/feross/standard"><img src="https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square"></a>
<a href="https://github.com/RichardLitt/standard-readme"><img src="https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square" /></a> <a href="https://github.com/RichardLitt/standard-readme"><img src="https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square" /></a>
<a href=""><img src="https://img.shields.io/badge/npm-%3E%3D6.0.0-orange.svg?style=flat-square" /></a> <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D7.0.0-orange.svg?style=flat-square" /></a>
<a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D12.0.0-orange.svg?style=flat-square" /></a> <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D15.0.0-orange.svg?style=flat-square" /></a>
<br> <br>
</p> </p>

View File

@ -2086,7 +2086,7 @@ the NatManager performing NAT hole punching.
[address]: https://github.com/libp2p/js-libp2p/tree/master/src/peer-store/address-book.js [address]: https://github.com/libp2p/js-libp2p/tree/master/src/peer-store/address-book.js
[cid]: https://github.com/multiformats/js-cid [cid]: https://github.com/multiformats/js-cid
[connection]: https://github.com/libp2p/js-interfaces/tree/master/src/connection [connection]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/connection
[multiaddr]: https://github.com/multiformats/js-multiaddr [multiaddr]: https://github.com/multiformats/js-multiaddr
[peer-id]: https://github.com/libp2p/js-peer-id [peer-id]: https://github.com/libp2p/js-peer-id
[keys]: https://github.com/libp2p/js-libp2p-crypto/tree/master/src/keys [keys]: https://github.com/libp2p/js-libp2p-crypto/tree/master/src/keys

View File

@ -1,37 +1,37 @@
# #
- [Configuration](#configuration) - [Overview](#overview)
- [Overview](#overview) - [Modules](#modules)
- [Modules](#modules) - [Transport](#transport)
- [Transport](#transport) - [Stream Multiplexing](#stream-multiplexing)
- [Stream Multiplexing](#stream-multiplexing) - [Connection Encryption](#connection-encryption)
- [Connection Encryption](#connection-encryption) - [Peer Discovery](#peer-discovery)
- [Peer Discovery](#peer-discovery) - [Content Routing](#content-routing)
- [Content Routing](#content-routing) - [Peer Routing](#peer-routing)
- [Peer Routing](#peer-routing) - [DHT](#dht)
- [DHT](#dht) - [Pubsub](#pubsub)
- [Pubsub](#pubsub) - [Customizing libp2p](#customizing-libp2p)
- [Customizing libp2p](#customizing-libp2p) - [Examples](#examples)
- [Examples](#examples) - [Basic setup](#basic-setup)
- [Basic setup](#basic-setup) - [Customizing Peer Discovery](#customizing-peer-discovery)
- [Customizing Peer Discovery](#customizing-peer-discovery) - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
- [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery) - [Customizing Pubsub](#customizing-pubsub)
- [Customizing Pubsub](#customizing-pubsub) - [Customizing DHT](#customizing-dht)
- [Customizing DHT](#customizing-dht) - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
- [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing) - [Setup with Relay](#setup-with-relay)
- [Setup with Relay](#setup-with-relay) - [Setup with Auto Relay](#setup-with-auto-relay)
- [Setup with Auto Relay](#setup-with-auto-relay) - [Setup with Keychain](#setup-with-keychain)
- [Setup with Keychain](#setup-with-keychain) - [Configuring Dialing](#configuring-dialing)
- [Configuring Dialing](#configuring-dialing) - [Configuring Connection Manager](#configuring-connection-manager)
- [Configuring Connection Manager](#configuring-connection-manager) - [Configuring Transport Manager](#configuring-transport-manager)
- [Configuring Transport Manager](#configuring-transport-manager) - [Configuring Metrics](#configuring-metrics)
- [Configuring Metrics](#configuring-metrics) - [Configuring PeerStore](#configuring-peerstore)
- [Configuring PeerStore](#configuring-peerstore) - [Customizing Transports](#customizing-transports)
- [Customizing Transports](#customizing-transports) - [Configuring the NAT Manager](#configuring-the-nat-manager)
- [Configuring the NAT Manager](#configuring-the-nat-manager) - [Browser support](#browser-support)
- [Browser support](#browser-support) - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
- [UPnP and NAT-PMP](#upnp-and-nat-pmp) - [Configuring protocol name](#configuring-protocol-name)
- [Configuration examples](#configuration-examples) - [Configuration examples](#configuration-examples)
## Overview ## Overview
@ -374,11 +374,7 @@ const node = await Libp2p.create({
dht: { // The DHT options (and defaults) can be found in its documentation dht: { // The DHT options (and defaults) can be found in its documentation
kBucketSize: 20, kBucketSize: 20,
enabled: true, // This flag is required for DHT to run (disabled by default) enabled: true, // This flag is required for DHT to run (disabled by default)
randomWalk: { clientMode: false // Whether to run the WAN DHT in client or server mode (default: client mode)
enabled: true, // Allows to disable discovery (enabled by default)
interval: 300e3,
timeout: 10e3
}
} }
} }
}) })
@ -501,9 +497,9 @@ const Libp2p = require('libp2p')
const TCP = require('libp2p-tcp') const TCP = require('libp2p-tcp')
const MPLEX = require('libp2p-mplex') const MPLEX = require('libp2p-mplex')
const { NOISE } = require('libp2p-noise') const { NOISE } = require('libp2p-noise')
const LevelStore = require('datastore-level') const LevelDatastore = require('datastore-level')
const datastore = new LevelStore('path/to/store') const datastore = new LevelDatastore('path/to/store')
await datastore.open() await datastore.open()
const node = await Libp2p.create({ const node = await Libp2p.create({
@ -676,18 +672,18 @@ const Libp2p = require('libp2p')
const TCP = require('libp2p-tcp') const TCP = require('libp2p-tcp')
const MPLEX = require('libp2p-mplex') const MPLEX = require('libp2p-mplex')
const { NOISE } = require('libp2p-noise') const { NOISE } = require('libp2p-noise')
const LevelStore = require('datastore-level') const LevelDatastore = require('datastore-level')
const datastore = new LevelStore('path/to/store') const datastore = new LevelDatastore('path/to/store')
const dsInstant = await datastore.open() await datastore.open() // level database must be ready before node boot
const node = await Libp2p.create({ const node = await Libp2p.create({
datastore, // pass the opened datastore
modules: { modules: {
transport: [TCP], transport: [TCP],
streamMuxer: [MPLEX], streamMuxer: [MPLEX],
connEncryption: [NOISE] connEncryption: [NOISE]
}, },
datastore: dsInstant,
peerStore: { peerStore: {
persistence: true, persistence: true,
threshold: 5 threshold: 5
@ -788,7 +784,7 @@ By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.o
#### Configuring protocol name #### Configuring protocol name
Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes. Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes.
```js ```js
const node = await Libp2p.create({ const node = await Libp2p.create({
@ -810,8 +806,8 @@ protocols: [
As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration: As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration:
- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-nodejs.js) - libp2p configuration used by js-ipfs when running in Node.js - [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.js) - libp2p configuration used by js-ipfs when running in Node.js
- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC) - [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)
If you have developed a project using `js-libp2p`, please consider submitting your configuration to this list so that it can be found easily by other users. If you have developed a project using `js-libp2p`, please consider submitting your configuration to this list so that it can be found easily by other users.

View File

@ -7,7 +7,7 @@
"libp2p": "github:libp2p/js-libp2p#master", "libp2p": "github:libp2p/js-libp2p#master",
"libp2p-delegated-content-routing": "~0.2.2", "libp2p-delegated-content-routing": "~0.2.2",
"libp2p-delegated-peer-routing": "~0.2.2", "libp2p-delegated-peer-routing": "~0.2.2",
"libp2p-kad-dht": "~0.14.12", "libp2p-kad-dht": "^0.26.5",
"libp2p-mplex": "~0.8.5", "libp2p-mplex": "~0.8.5",
"libp2p-secio": "~0.11.1", "libp2p-secio": "~0.11.1",
"libp2p-webrtc-star": "~0.15.8", "libp2p-webrtc-star": "~0.15.8",

View File

@ -55,7 +55,7 @@ const node = await Libp2p.create({
peerId, peerId,
addresses: { addresses: {
listen: ['/ip4/0.0.0.0/tcp/0'] listen: ['/ip4/0.0.0.0/tcp/0']
} },
modules: { modules: {
transport: [ TCP ], transport: [ TCP ],
streamMuxer: [ Mplex ], streamMuxer: [ Mplex ],
@ -117,7 +117,7 @@ const createNode = () => {
return Libp2p.create({ return Libp2p.create({
addresses: { addresses: {
listen: ['/ip4/0.0.0.0/tcp/0'] listen: ['/ip4/0.0.0.0/tcp/0']
} },
modules: { modules: {
transport: [ TCP ], transport: [ TCP ],
streamMuxer: [ Mplex ], streamMuxer: [ Mplex ],
@ -144,8 +144,13 @@ const [node1, node2] = await Promise.all([
createNode() createNode()
]) ])
node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String())) node1.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String())) node2.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
await Promise.all([
node1.start(),
node2.start()
])
``` ```
If you run this example, you will see the other peers being discovered. If you run this example, you will see the other peers being discovered.

View File

@ -28,6 +28,6 @@
"babel-plugin-syntax-async-functions": "^6.13.0", "babel-plugin-syntax-async-functions": "^6.13.0",
"babel-plugin-transform-regenerator": "^6.26.0", "babel-plugin-transform-regenerator": "^6.26.0",
"babel-polyfill": "^6.26.0", "babel-polyfill": "^6.26.0",
"parcel": "next" "parcel": "^2.0.1"
} }
} }

View File

@ -38,7 +38,7 @@ async function run() {
) )
await browser.close(); await browser.close();
} catch (err) { } catch (/** @type {any} */ err) {
console.error(err) console.error(err)
process.exit(1) process.exit(1)
} finally { } finally {

View File

@ -41,13 +41,13 @@ const createNode = async () => {
node1.pubsub.on(topic, (msg) => { node1.pubsub.on(topic, (msg) => {
console.log(`node1 received: ${uint8ArrayToString(msg.data)}`) console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
}) })
await node1.pubsub.subscribe(topic) node1.pubsub.subscribe(topic)
// Will not receive own published messages by default // Will not receive own published messages by default
node2.pubsub.on(topic, (msg) => { node2.pubsub.on(topic, (msg) => {
console.log(`node2 received: ${uint8ArrayToString(msg.data)}`) console.log(`node2 received: ${uint8ArrayToString(msg.data)}`)
}) })
await node2.pubsub.subscribe(topic) node2.pubsub.subscribe(topic)
// node2 publishes "news" every second // node2 publishes "news" every second
setInterval(() => { setInterval(() => {

View File

@ -81,7 +81,7 @@ function print ({ stream }) {
// node 3 (listening WebSockets) can dial node 1 (TCP) // node 3 (listening WebSockets) can dial node 1 (TCP)
try { try {
await node3.dialProtocol(node1.peerId, '/print') await node3.dialProtocol(node1.peerId, '/print')
} catch (err) { } catch (/** @type {any} */ err) {
console.log('node 3 failed to dial to node 1 with:', err.message) console.log('node 3 failed to dial to node 1 with:', err.message)
} }
})(); })();

View File

@ -91,7 +91,7 @@ const concat = require('it-concat')
const MPLEX = require('libp2p-mplex') const MPLEX = require('libp2p-mplex')
``` ```
We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`. We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`.
```js ```js
const createNode = async () => { const createNode = async () => {
const node = await Libp2p.create({ const node = await Libp2p.create({

View File

@ -9,7 +9,7 @@ async function isExecutable (command) {
await fs.access(command, fs.constants.X_OK) await fs.access(command, fs.constants.X_OK)
return true return true
} catch (err) { } catch (/** @type {any} */ err) {
if (err.code === 'ENOENT') { if (err.code === 'ENOENT') {
return isExecutable(await which(command)) return isExecutable(await which(command))
} }
@ -49,7 +49,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {
try { try {
await proc await proc
} catch (err) { } catch (/** @type {any} */ err) {
if (!err.killed) { if (!err.killed) {
throw err throw err
} }

View File

@ -12,6 +12,6 @@
<main> <main>
<pre id="output"></pre> <pre id="output"></pre>
</main> </main>
<script src="./dialer.js"></script> <script src="./dialer.js" type="module"></script>
</body> </body>
</html> </html>

View File

@ -3,7 +3,6 @@
"version": "0.0.1", "version": "0.0.1",
"private": true, "private": true,
"description": "", "description": "",
"main": "dist/index.html",
"scripts": { "scripts": {
"test": "echo \"Error: no test specified\" && exit 1", "test": "echo \"Error: no test specified\" && exit 1",
"build": "parcel build index.html", "build": "parcel build index.html",
@ -16,7 +15,7 @@
"babel-plugin-syntax-async-functions": "^6.13.0", "babel-plugin-syntax-async-functions": "^6.13.0",
"babel-plugin-transform-regenerator": "^6.26.0", "babel-plugin-transform-regenerator": "^6.26.0",
"babel-polyfill": "^6.26.0", "babel-polyfill": "^6.26.0",
"parcel-bundler": "1.12.3", "parcel": "^2.0.1",
"util": "^0.12.3" "util": "^0.12.3"
}, },
"dependencies": { "dependencies": {
@ -25,7 +24,7 @@
"libp2p-mplex": "^0.10.4", "libp2p-mplex": "^0.10.4",
"@chainsafe/libp2p-noise": "^4.1.0", "@chainsafe/libp2p-noise": "^4.1.0",
"libp2p-webrtc-direct": "^0.7.0", "libp2p-webrtc-direct": "^0.7.0",
"peer-id": "^0.15.0" "peer-id": "^0.16.0"
}, },
"browser": { "browser": {
"ipfs": "ipfs/dist/index.min.js" "ipfs": "ipfs/dist/index.min.js"

View File

@ -72,7 +72,7 @@ async function test () {
{ timeout: 10000 } { timeout: 10000 }
) )
await browser.close(); await browser.close();
} catch (err) { } catch (/** @type {any} */ err) {
console.error(err) console.error(err)
process.exit(1) process.exit(1)
} finally { } finally {

View File

@ -1,6 +1,6 @@
{ {
"name": "libp2p", "name": "libp2p",
"version": "0.33.0", "version": "0.35.8",
"description": "JavaScript implementation of libp2p, a modular peer to peer network stack", "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
"leadMaintainer": "Jacob Heun <jacobheun@gmail.com>", "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
"main": "src/index.js", "main": "src/index.js",
@ -41,6 +41,7 @@
"test:node": "aegir test -t node -f \"./test/**/*.{node,spec}.js\"", "test:node": "aegir test -t node -f \"./test/**/*.{node,spec}.js\"",
"test:browser": "aegir test -t browser", "test:browser": "aegir test -t browser",
"test:examples": "cd examples && npm run test:all", "test:examples": "cd examples && npm run test:all",
"test:interop": "LIBP2P_JS=$PWD npx aegir test -t node -f ./node_modules/libp2p-interop/test/*",
"prepare": "aegir build --no-bundle", "prepare": "aegir build --no-bundle",
"release": "aegir release -t node -t browser", "release": "aegir release -t node -t browser",
"release-minor": "aegir release --type minor -t node -t browser", "release-minor": "aegir release --type minor -t node -t browser",
@ -65,23 +66,23 @@
"homepage": "https://libp2p.io", "homepage": "https://libp2p.io",
"license": "MIT", "license": "MIT",
"engines": { "engines": {
"node": ">=14.0.0" "node": ">=15.0.0"
}, },
"browser": { "browser": {
"@motrix/nat-api": false "nat-api": false
}, },
"eslintConfig": { "eslintConfig": {
"extends": "ipfs", "extends": "ipfs",
"ignorePatterns": [ "ignorePatterns": [
"!.aegir.js", "!.aegir.js",
"test/ts-use" "test/ts-use",
"*.d.ts"
] ]
}, },
"dependencies": { "dependencies": {
"abortable-iterator": "^3.0.0",
"@motrix/nat-api": "^0.3.1",
"@vascosantos/moving-average": "^1.1.0", "@vascosantos/moving-average": "^1.1.0",
"abort-controller": "^3.0.0", "abort-controller": "^3.0.0",
"abortable-iterator": "^3.0.0",
"aggregate-error": "^3.1.0", "aggregate-error": "^3.1.0",
"any-signal": "^2.1.1", "any-signal": "^2.1.1",
"bignumber.js": "^9.0.1", "bignumber.js": "^9.0.1",
@ -103,8 +104,8 @@
"it-merge": "^1.0.0", "it-merge": "^1.0.0",
"it-pipe": "^1.1.0", "it-pipe": "^1.1.0",
"it-take": "^1.0.0", "it-take": "^1.0.0",
"libp2p-crypto": "^0.19.4", "libp2p-crypto": "^0.21.0",
"libp2p-interfaces": "^1.0.0", "libp2p-interfaces": "^2.0.1",
"libp2p-utils": "^0.4.0", "libp2p-utils": "^0.4.0",
"mafmt": "^10.0.0", "mafmt": "^10.0.0",
"merge-options": "^3.0.4", "merge-options": "^3.0.4",
@ -112,60 +113,61 @@
"multiformats": "^9.0.0", "multiformats": "^9.0.0",
"multistream-select": "^2.0.0", "multistream-select": "^2.0.0",
"mutable-proxy": "^1.0.0", "mutable-proxy": "^1.0.0",
"nat-api": "^0.3.1",
"node-forge": "^0.10.0", "node-forge": "^0.10.0",
"p-any": "^3.0.0", "p-any": "^3.0.0",
"p-fifo": "^1.0.0", "p-fifo": "^1.0.0",
"p-retry": "^4.4.0", "p-retry": "^4.4.0",
"p-settle": "^4.1.1", "p-settle": "^4.1.1",
"peer-id": "^0.15.0", "peer-id": "^0.16.0",
"private-ip": "^2.1.0", "private-ip": "^2.1.0",
"protobufjs": "^6.10.2", "protobufjs": "^6.10.2",
"retimer": "^3.0.0", "retimer": "^3.0.0",
"sanitize-filename": "^1.6.3", "sanitize-filename": "^1.6.3",
"set-delayed-interval": "^1.0.0", "set-delayed-interval": "^1.0.0",
"streaming-iterables": "^6.0.0", "streaming-iterables": "^6.0.0",
"timeout-abort-controller": "^1.1.1", "timeout-abort-controller": "^2.0.0",
"uint8arrays": "^3.0.0", "uint8arrays": "^3.0.0",
"varint": "^6.0.0", "varint": "^6.0.0",
"wherearewe": "^1.0.0", "wherearewe": "^1.0.0",
"xsalsa20": "^1.1.0" "xsalsa20": "^1.1.0"
}, },
"devDependencies": { "devDependencies": {
"@chainsafe/libp2p-noise": "^4.0.0", "@chainsafe/libp2p-noise": "^5.0.0",
"@nodeutils/defaults-deep": "^1.1.0", "@nodeutils/defaults-deep": "^1.1.0",
"@types/es6-promisify": "^6.0.0", "@types/es6-promisify": "^6.0.0",
"@types/node": "^16.0.1", "@types/node": "^16.0.1",
"@types/node-forge": "^0.10.1", "@types/node-forge": "^0.10.1",
"@types/varint": "^6.0.0", "@types/varint": "^6.0.0",
"aegir": "^33.1.1", "aegir": "^36.0.0",
"buffer": "^6.0.3", "buffer": "^6.0.3",
"datastore-core": "^6.0.7", "datastore-core": "^6.0.7",
"delay": "^5.0.0", "delay": "^5.0.0",
"interop-libp2p": "^0.4.0", "into-stream": "^6.0.0",
"into-stream": "^7.0.0", "ipfs-http-client": "^54.0.2",
"ipfs-http-client": "^52.0.2",
"it-concat": "^2.0.0", "it-concat": "^2.0.0",
"it-pair": "^1.0.0", "it-pair": "^1.0.0",
"it-pushable": "^1.4.0", "it-pushable": "^1.4.0",
"libp2p": ".", "libp2p": ".",
"libp2p-bootstrap": "^0.13.0", "libp2p-bootstrap": "^0.14.0",
"libp2p-delegated-content-routing": "^0.11.0", "libp2p-delegated-content-routing": "^0.11.0",
"libp2p-delegated-peer-routing": "^0.10.0", "libp2p-delegated-peer-routing": "^0.11.1",
"libp2p-floodsub": "^0.27.0", "libp2p-floodsub": "^0.28.0",
"libp2p-gossipsub": "^0.11.0", "libp2p-gossipsub": "^0.12.1",
"libp2p-interfaces-compliance-tests": "^1.0.0", "libp2p-interfaces-compliance-tests": "^2.0.1",
"libp2p-kad-dht": "^0.24.2", "libp2p-interop": "^0.5.0",
"libp2p-mdns": "^0.17.0", "libp2p-kad-dht": "^0.27.1",
"libp2p-mdns": "^0.18.0",
"libp2p-mplex": "^0.10.1", "libp2p-mplex": "^0.10.1",
"libp2p-tcp": "^0.17.0", "libp2p-tcp": "^0.17.0",
"libp2p-webrtc-star": "^0.23.0", "libp2p-webrtc-star": "^0.25.0",
"libp2p-websockets": "^0.16.0", "libp2p-websockets": "^0.16.0",
"nock": "^13.0.3", "nock": "^13.0.3",
"p-defer": "^3.0.0", "p-defer": "^3.0.0",
"p-times": "^3.0.0", "p-times": "^3.0.0",
"p-wait-for": "^3.2.0", "p-wait-for": "^3.2.0",
"rimraf": "^3.0.2", "rimraf": "^3.0.2",
"sinon": "^11.1.1", "sinon": "^12.0.1",
"util": "^0.12.3" "util": "^0.12.3"
}, },
"contributors": [ "contributors": [
@ -179,42 +181,45 @@
"Friedel Ziegelmayer <dignifiedquire@gmail.com>", "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
"Maciej Krüger <mkg20001@gmail.com>", "Maciej Krüger <mkg20001@gmail.com>",
"Hugo Dias <mail@hugodias.me>", "Hugo Dias <mail@hugodias.me>",
"Chris Dostert <chrisdostert@users.noreply.github.com>",
"dirkmc <dirkmdev@gmail.com>", "dirkmc <dirkmdev@gmail.com>",
"Volker Mische <volker.mische@gmail.com>", "Volker Mische <volker.mische@gmail.com>",
"Chris Dostert <chrisdostert@users.noreply.github.com>",
"zeim839 <50573884+zeim839@users.noreply.github.com>", "zeim839 <50573884+zeim839@users.noreply.github.com>",
"Robert Kiel <robert.kiel@hoprnet.org>",
"Richard Littauer <richard.littauer@gmail.com>", "Richard Littauer <richard.littauer@gmail.com>",
"a1300 <matthias-knopp@gmx.net>", "a1300 <matthias-knopp@gmx.net>",
"Ryan Bell <ryan@piing.net>", "Ryan Bell <ryan@piing.net>",
"ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>", "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
"Andrew Nesbitt <andrewnez@gmail.com>",
"Franck Royer <franck@royer.one>", "Franck Royer <franck@royer.one>",
"Thomas Eizinger <thomas@eizinger.io>", "Thomas Eizinger <thomas@eizinger.io>",
"Vít Habada <vithabada93@gmail.com>",
"Giovanni T. Parra <fiatjaf@gmail.com>", "Giovanni T. Parra <fiatjaf@gmail.com>",
"acolytec3 <17355484+acolytec3@users.noreply.github.com>", "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
"Alan Smithee <ggnore.alan.smithee@gmail.com>",
"Elven <mon.samuel@qq.com>", "Elven <mon.samuel@qq.com>",
"Andrew Nesbitt <andrewnez@gmail.com>",
"Samlior <samlior@foxmail.com>", "Samlior <samlior@foxmail.com>",
"Didrik Nordström <didrik.nordstrom@gmail.com>", "Didrik Nordström <didrik.nordstrom@gmail.com>",
"RasmusErik Voel Jensen <github@solsort.com>", "Aditya Bose <13054902+adbose@users.noreply.github.com>",
"Robert Kiel <robert.kiel@hoprnet.org>",
"Smite Chow <xiaopengyou@live.com>",
"Soeren <nikorpoulsen@gmail.com>",
"Sönke Hahn <soenkehahn@gmail.com>",
"TJKoury <TJKoury@gmail.com>", "TJKoury <TJKoury@gmail.com>",
"TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
"Tiago Alves <alvesjtiago@gmail.com>", "Tiago Alves <alvesjtiago@gmail.com>",
"Tim Daubenschütz <tim@daubenschuetz.de>",
"XiaoZhang <zxinmyth@gmail.com>", "XiaoZhang <zxinmyth@gmail.com>",
"Yusef Napora <yusef@napora.org>", "Yusef Napora <yusef@napora.org>",
"Zane Starr <zcstarr@gmail.com>", "Zane Starr <zcstarr@gmail.com>",
"ebinks <elizabethjbinks@gmail.com>", "ebinks <elizabethjbinks@gmail.com>",
"Aditya Bose <13054902+adbose@users.noreply.github.com>", "greenSnot <greenSnot@users.noreply.github.com>",
"isan_rivkin <isanrivkin@gmail.com>", "isan_rivkin <isanrivkin@gmail.com>",
"mayerwin <mayerwin@users.noreply.github.com>", "mayerwin <mayerwin@users.noreply.github.com>",
"mcclure <andi.m.mcclure@gmail.com>", "mcclure <andi.m.mcclure@gmail.com>",
"patrickwoodhead <91056047+patrickwoodhead@users.noreply.github.com>",
"phillmac <phillmac@users.noreply.github.com>", "phillmac <phillmac@users.noreply.github.com>",
"robertkiel <robert.kiel@validitylabs.org>", "robertkiel <robert.kiel@validitylabs.org>",
"shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>", "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
"swedneck <40505480+swedneck@users.noreply.github.com>", "swedneck <40505480+swedneck@users.noreply.github.com>",
"greenSnot <greenSnot@users.noreply.github.com>", "tuyennhv <vutuyen2636@gmail.com>",
"Sönke Hahn <soenkehahn@gmail.com>",
"Aleksei <vozhdb@gmail.com>", "Aleksei <vozhdb@gmail.com>",
"Bernd Strehl <bernd.strehl@gmail.com>", "Bernd Strehl <bernd.strehl@gmail.com>",
"Chris Bratlien <chrisbratlien@gmail.com>", "Chris Bratlien <chrisbratlien@gmail.com>",
@ -239,9 +244,13 @@
"Lars Gierth <lgierth@users.noreply.github.com>", "Lars Gierth <lgierth@users.noreply.github.com>",
"Leask Wong <i@leaskh.com>", "Leask Wong <i@leaskh.com>",
"Marcin Tojek <mtojek@users.noreply.github.com>", "Marcin Tojek <mtojek@users.noreply.github.com>",
"Marston Connell <34043723+TheMarstonConnell@users.noreply.github.com>",
"Michael Burns <5170+mburns@users.noreply.github.com>", "Michael Burns <5170+mburns@users.noreply.github.com>",
"Miguel Mota <miguelmota2@gmail.com>", "Miguel Mota <miguelmota2@gmail.com>",
"Nuno Nogueira <nunofmn@gmail.com>", "Nuno Nogueira <nunofmn@gmail.com>",
"Philipp Muens <raute1337@gmx.de>" "Philipp Muens <raute1337@gmx.de>",
"RasmusErik Voel Jensen <github@solsort.com>",
"Smite Chow <xiaopengyou@live.com>",
"Soeren <nikorpoulsen@gmail.com>"
] ]
} }

View File

@ -116,7 +116,7 @@ class AutoRelay {
this._peerStore.metadataBook.set(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE)) this._peerStore.metadataBook.set(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
await this._addListenRelay(connection, id) await this._addListenRelay(connection, id)
} }
} catch (err) { } catch (/** @type {any} */ err) {
this._onError(err) this._onError(err)
} }
} }
@ -169,7 +169,7 @@ class AutoRelay {
try { try {
await this._transportManager.listen([new Multiaddr(listenAddr)]) await this._transportManager.listen([new Multiaddr(listenAddr)])
// Announce multiaddrs will update on listen success by TransportManager event being triggered // Announce multiaddrs will update on listen success by TransportManager event being triggered
} catch (err) { } catch (/** @type {any} */ err) {
this._onError(err) this._onError(err)
this._listenRelays.delete(id) this._listenRelays.delete(id)
} }
@ -267,7 +267,7 @@ class AutoRelay {
return return
} }
} }
} catch (err) { } catch (/** @type {any} */ err) {
this._onError(err) this._onError(err)
} }
} }
@ -279,7 +279,7 @@ class AutoRelay {
try { try {
const connection = await this._libp2p.dial(peerId) const connection = await this._libp2p.dial(peerId)
await this._addListenRelay(connection, peerId.toB58String()) await this._addListenRelay(connection, peerId.toB58String())
} catch (err) { } catch (/** @type {any} */ err) {
this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`) this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
} }
} }

View File

@ -54,7 +54,7 @@ async function handleHop ({
// Validate the HOP request has the required input // Validate the HOP request has the required input
try { try {
validateAddrs(request, streamHandler) validateAddrs(request, streamHandler)
} catch (err) { } catch (/** @type {any} */ err) {
return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err) return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err)
} }
@ -93,7 +93,7 @@ async function handleHop ({
connection: destinationConnection, connection: destinationConnection,
request: stopRequest request: stopRequest
}) })
} catch (err) { } catch (/** @type {any} */ err) {
return log.error(err) return log.error(err)
} }

View File

@ -34,7 +34,7 @@ module.exports.handleStop = function handleStop ({
// Validate the STOP request has the required input // Validate the STOP request has the required input
try { try {
validateAddrs(request, streamHandler) validateAddrs(request, streamHandler)
} catch (err) { } catch (/** @type {any} */ err) {
return log.error('invalid stop request via peer %s', connection.remotePeer.toB58String(), err) return log.error('invalid stop request via peer %s', connection.remotePeer.toB58String(), err)
} }

View File

@ -34,7 +34,7 @@ function validateAddrs (msg, streamHandler) {
return new Multiaddr(addr) return new Multiaddr(addr)
}) })
} }
} catch (err) { } catch (/** @type {any} */ err) {
writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
: CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID) : CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID)
@ -47,7 +47,7 @@ function validateAddrs (msg, streamHandler) {
return new Multiaddr(addr) return new Multiaddr(addr)
}) })
} }
} catch (err) { } catch (/** @type {any} */ err) {
writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID
: CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID) : CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID)

View File

@ -4,7 +4,7 @@ const debug = require('debug')
const log = Object.assign(debug('libp2p:relay'), { const log = Object.assign(debug('libp2p:relay'), {
error: debug('libp2p:relay:err') error: debug('libp2p:relay:err')
}) })
const { codes } = require('./../errors')
const { const {
setDelayedInterval, setDelayedInterval,
clearDelayedInterval clearDelayedInterval
@ -87,8 +87,8 @@ class Relay {
try { try {
const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS) const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
await this._libp2p.contentRouting.provide(cid) await this._libp2p.contentRouting.provide(cid)
} catch (err) { } catch (/** @type {any} */ err) {
if (err.code === 'NO_ROUTERS_AVAILABLE') { if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err) log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
// Stop the advertise // Stop the advertise
this.stop() this.stop()

View File

@ -171,7 +171,7 @@ class Circuit {
log('new outbound connection %s', maConn.remoteAddr) log('new outbound connection %s', maConn.remoteAddr)
return this._upgrader.upgradeOutbound(maConn) return this._upgrader.upgradeOutbound(maConn)
} catch (err) { } catch (/** @type {any} */ err) {
log.error('Circuit relay dial failed', err) log.error('Circuit relay dial failed', err)
disconnectOnFailure && await relayConnection.close() disconnectOnFailure && await relayConnection.close()
throw err throw err

View File

@ -60,13 +60,7 @@ const DefaultConfig = {
protocolPrefix: 'ipfs', protocolPrefix: 'ipfs',
dht: { dht: {
enabled: false, enabled: false,
kBucketSize: 20, kBucketSize: 20
randomWalk: {
enabled: false, // disabled waiting for https://github.com/libp2p/js-libp2p-kad-dht/issues/86
queriesPerPeriod: 1,
interval: 300e3,
timeout: 10e3
}
}, },
nat: { nat: {
enabled: true, enabled: true,

View File

@ -0,0 +1,120 @@
'use strict'
const debug = require('debug')
const mergeOptions = require('merge-options')
// @ts-ignore retimer does not have types
const retimer = require('retimer')
const log = Object.assign(debug('libp2p:connection-manager:auto-dialler'), {
error: debug('libp2p:connection-manager:auto-dialler:err')
})
const defaultOptions = {
enabled: true,
minConnections: 0,
autoDialInterval: 10000
}
/**
* @typedef {import('../index')} Libp2p
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
*/
/**
* @typedef {Object} AutoDiallerOptions
* @property {boolean} [enabled = true] - Should preemptively guarantee connections are above the low watermark
* @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning
* @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
*/
class AutoDialler {
/**
* Proactively tries to connect to known peers stored in the PeerStore.
* It will keep the number of connections below the upper limit and sort
* the peers to connect based on wether we know their keys and protocols.
*
* @class
* @param {Libp2p} libp2p
* @param {AutoDiallerOptions} options
*/
constructor (libp2p, options = {}) {
this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
this._libp2p = libp2p
this._running = false
this._autoDialTimeout = null
this._autoDial = this._autoDial.bind(this)
log('options: %j', this._options)
}
/**
* Starts the auto dialer
*/
start () {
if (!this._options.enabled) {
log('not enabled')
return
}
this._running = true
this._autoDial().catch(err => {
log.error('could start autodial', err)
})
log('started')
}
/**
* Stops the auto dialler
*/
async stop () {
if (!this._options.enabled) {
log('not enabled')
return
}
this._running = false
this._autoDialTimeout && this._autoDialTimeout.clear()
log('stopped')
}
async _autoDial () {
const minConnections = this._options.minConnections
// Already has enough connections
if (this._libp2p.connections.size >= minConnections) {
this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
return
}
// Sort peers on wether we know protocols of public keys for them
const peers = Array.from(this._libp2p.peerStore.peers.values())
.sort((a, b) => {
if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
return 1
} else if (b.id.pubKey && !a.id.pubKey) {
return 1
}
return -1
})
for (let i = 0; this._running && i < peers.length && this._libp2p.connections.size < minConnections; i++) {
if (!this._libp2p.connectionManager.get(peers[i].id)) {
log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
try {
await this._libp2p.dialer.connectToPeer(peers[i].id)
} catch (/** @type {any} */ err) {
log.error('could not connect to peerStore stored peer', err)
}
}
}
// Connection Manager was stopped
if (!this._running) {
return
}
this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
}
}
module.exports = AutoDialler

View File

@ -12,7 +12,7 @@ const LatencyMonitor = require('./latency-monitor')
const retimer = require('retimer') const retimer = require('retimer')
const { EventEmitter } = require('events') const { EventEmitter } = require('events')
const trackedMap = require('../metrics/tracked-map')
const PeerId = require('peer-id') const PeerId = require('peer-id')
const { const {
@ -32,6 +32,10 @@ const defaultOptions = {
defaultPeerValue: 1 defaultPeerValue: 1
} }
const METRICS_COMPONENT = 'connection-manager'
const METRICS_PEER_CONNECTIONS = 'peer-connections'
const METRICS_PEER_VALUES = 'peer-values'
/** /**
* @typedef {import('../')} Libp2p * @typedef {import('../')} Libp2p
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@ -83,20 +87,18 @@ class ConnectionManager extends EventEmitter {
* *
* @type {Map<string, number>} * @type {Map<string, number>}
*/ */
this._peerValues = new Map() this._peerValues = trackedMap(METRICS_COMPONENT, METRICS_PEER_VALUES, this._libp2p.metrics)
/** /**
* Map of connections per peer * Map of connections per peer
* *
* @type {Map<string, Connection[]>} * @type {Map<string, Connection[]>}
*/ */
this.connections = new Map() this.connections = trackedMap(METRICS_COMPONENT, METRICS_PEER_CONNECTIONS, this._libp2p.metrics)
this._started = false this._started = false
this._timer = null this._timer = null
this._autoDialTimeout = null
this._checkMetrics = this._checkMetrics.bind(this) this._checkMetrics = this._checkMetrics.bind(this)
this._autoDial = this._autoDial.bind(this)
this._latencyMonitor = new LatencyMonitor({ this._latencyMonitor = new LatencyMonitor({
latencyCheckIntervalMs: this._options.pollInterval, latencyCheckIntervalMs: this._options.pollInterval,
@ -128,8 +130,6 @@ class ConnectionManager extends EventEmitter {
this._started = true this._started = true
log('started') log('started')
this._options.autoDial && this._autoDial()
} }
/** /**
@ -138,7 +138,6 @@ class ConnectionManager extends EventEmitter {
* @async * @async
*/ */
async stop () { async stop () {
this._autoDialTimeout && this._autoDialTimeout.clear()
this._timer && this._timer.clear() this._timer && this._timer.clear()
this._latencyMonitor.removeListener('data', this._onLatencyMeasure) this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
@ -216,6 +215,7 @@ class ConnectionManager extends EventEmitter {
const storedConn = this.connections.get(peerIdStr) const storedConn = this.connections.get(peerIdStr)
this.emit('peer:connect', connection) this.emit('peer:connect', connection)
if (storedConn) { if (storedConn) {
storedConn.push(connection) storedConn.push(connection)
} else { } else {
@ -248,6 +248,8 @@ class ConnectionManager extends EventEmitter {
this.connections.delete(peerId) this.connections.delete(peerId)
this._peerValues.delete(connection.remotePeer.toB58String()) this._peerValues.delete(connection.remotePeer.toB58String())
this.emit('peer:disconnect', connection) this.emit('peer:disconnect', connection)
this._libp2p.metrics && this._libp2p.metrics.onPeerDisconnected(connection.remotePeer)
} }
} }
@ -312,53 +314,6 @@ class ConnectionManager extends EventEmitter {
} }
} }
/**
* Proactively tries to connect to known peers stored in the PeerStore.
* It will keep the number of connections below the upper limit and sort
* the peers to connect based on wether we know their keys and protocols.
*
* @async
* @private
*/
async _autoDial () {
const minConnections = this._options.minConnections
// Already has enough connections
if (this.size >= minConnections) {
this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
return
}
// Sort peers on wether we know protocols of public keys for them
const peers = Array.from(this._libp2p.peerStore.peers.values())
.sort((a, b) => {
if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
return 1
} else if (b.id.pubKey && !a.id.pubKey) {
return 1
}
return -1
})
for (let i = 0; i < peers.length && this.size < minConnections; i++) {
if (!this.get(peers[i].id)) {
log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
try {
await this._libp2p.dialer.connectToPeer(peers[i].id)
// Connection Manager was stopped
if (!this._started) {
return
}
} catch (err) {
log.error('could not connect to peerStore stored peer', err)
}
}
}
this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
}
/** /**
* If we have more connections than our maximum, close a connection * If we have more connections than our maximum, close a connection
* to the lowest valued peer. * to the lowest valued peer.

View File

@ -8,9 +8,10 @@ const {
requirePeers, requirePeers,
maybeLimitSource maybeLimitSource
} = require('./utils') } = require('./utils')
const drain = require('it-drain')
const merge = require('it-merge') const merge = require('it-merge')
const { pipe } = require('it-pipe') const { pipe } = require('it-pipe')
const { DHTContentRouting } = require('../dht/dht-content-routing')
/** /**
* @typedef {import('peer-id')} PeerId * @typedef {import('peer-id')} PeerId
@ -38,7 +39,7 @@ class ContentRouting {
// If we have the dht, add it to the available content routers // If we have the dht, add it to the available content routers
if (this.dht && libp2p._config.dht.enabled) { if (this.dht && libp2p._config.dht.enabled) {
this.routers.push(this.dht) this.routers.push(new DHTContentRouting(this.dht))
} }
} }
@ -53,7 +54,7 @@ class ContentRouting {
*/ */
async * findProviders (key, options = {}) { async * findProviders (key, options = {}) {
if (!this.routers.length) { if (!this.routers.length) {
throw errCode(new Error('No content this.routers available'), 'NO_ROUTERS_AVAILABLE') throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
} }
yield * pipe( yield * pipe(
@ -76,7 +77,7 @@ class ContentRouting {
*/ */
async provide (key) { async provide (key) {
if (!this.routers.length) { if (!this.routers.length) {
throw errCode(new Error('No content routers available'), 'NO_ROUTERS_AVAILABLE') throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
} }
await Promise.all(this.routers.map((router) => router.provide(key))) await Promise.all(this.routers.map((router) => router.provide(key)))
@ -91,12 +92,12 @@ class ContentRouting {
* @param {number} [options.minPeers] - minimum number of peers required to successfully put * @param {number} [options.minPeers] - minimum number of peers required to successfully put
* @returns {Promise<void>} * @returns {Promise<void>}
*/ */
put (key, value, options) { async put (key, value, options) {
if (!this.libp2p.isStarted() || !this.dht.isStarted) { if (!this.libp2p.isStarted() || !this.dht.isStarted) {
throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED) throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
} }
return this.dht.put(key, value, options) await drain(this.dht.put(key, value, options))
} }
/** /**
@ -108,12 +109,18 @@ class ContentRouting {
* @param {number} [options.timeout] - optional timeout (default: 60000) * @param {number} [options.timeout] - optional timeout (default: 60000)
* @returns {Promise<GetData>} * @returns {Promise<GetData>}
*/ */
get (key, options) { async get (key, options) {
if (!this.libp2p.isStarted() || !this.dht.isStarted) { if (!this.libp2p.isStarted() || !this.dht.isStarted) {
throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED) throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
} }
return this.dht.get(key, options) for await (const event of this.dht.get(key, options)) {
if (event.name === 'VALUE') {
return { from: event.peerId, val: event.value }
}
}
throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
} }
/** /**
@ -123,14 +130,33 @@ class ContentRouting {
* @param {number} nVals * @param {number} nVals
* @param {Object} [options] - get options * @param {Object} [options] - get options
* @param {number} [options.timeout] - optional timeout (default: 60000) * @param {number} [options.timeout] - optional timeout (default: 60000)
* @returns {Promise<GetData[]>}
*/ */
async getMany (key, nVals, options) { // eslint-disable-line require-await async * getMany (key, nVals, options) { // eslint-disable-line require-await
if (!this.libp2p.isStarted() || !this.dht.isStarted) { if (!this.libp2p.isStarted() || !this.dht.isStarted) {
throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED) throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
} }
return this.dht.getMany(key, nVals, options) if (!nVals) {
return
}
let gotValues = 0
for await (const event of this.dht.get(key, options)) {
if (event.name === 'VALUE') {
yield { from: event.peerId, val: event.value }
gotValues++
if (gotValues === nVals) {
break
}
}
}
if (gotValues === 0) {
throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
}
} }
} }

View File

@ -0,0 +1,44 @@
'use strict'
const drain = require('it-drain')
/**
* @typedef {import('peer-id')} PeerId
* @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
* @typedef {import('multiformats/cid').CID} CID
*/
/**
* Wrapper class to convert events into returned values
*
* @implements {ContentRoutingModule}
*/
class DHTContentRouting {
/**
* @param {import('libp2p-kad-dht').DHT} dht
*/
constructor (dht) {
this._dht = dht
}
/**
* @param {CID} cid
*/
async provide (cid) {
await drain(this._dht.provide(cid))
}
/**
* @param {CID} cid
* @param {*} options
*/
async * findProviders (cid, options) {
for await (const event of this._dht.findProviders(cid, options)) {
if (event.name === 'PROVIDER') {
yield * event.providers
}
}
}
}
module.exports = { DHTContentRouting }

View File

@ -0,0 +1,51 @@
'use strict'
const errCode = require('err-code')
const { messages, codes } = require('../errors')
/**
* @typedef {import('peer-id')} PeerId
* @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
*/
/**
* Wrapper class to convert events into returned values
*
* @implements {PeerRoutingModule}
*/
class DHTPeerRouting {
/**
* @param {import('libp2p-kad-dht').DHT} dht
*/
constructor (dht) {
this._dht = dht
}
/**
* @param {PeerId} peerId
* @param {any} options
*/
async findPeer (peerId, options = {}) {
for await (const event of this._dht.findPeer(peerId, options)) {
if (event.name === 'FINAL_PEER') {
return event.peer
}
}
throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
}
/**
* @param {Uint8Array} key
* @param {any} options
*/
async * getClosestPeers (key, options = {}) {
for await (const event of this._dht.getClosestPeers(key, options)) {
if (event.name === 'PEER_RESPONSE') {
yield * event.closer
}
}
}
}
module.exports = { DHTPeerRouting }

View File

@ -1,11 +1,13 @@
'use strict' 'use strict'
const errCode = require('err-code') const errCode = require('err-code')
const AbortController = require('abort-controller').default
const { anySignal } = require('any-signal') const { anySignal } = require('any-signal')
// @ts-ignore p-fifo does not export types // @ts-ignore p-fifo does not export types
const FIFO = require('p-fifo') const FIFO = require('p-fifo')
const pAny = require('p-any') const pAny = require('p-any')
// @ts-expect-error setMaxListeners is missing from the types
const { setMaxListeners } = require('events')
const { codes } = require('../errors')
/** /**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@ -54,12 +56,17 @@ class DialRequest {
const tokens = this.dialer.getTokens(this.addrs.length) const tokens = this.dialer.getTokens(this.addrs.length)
// If no tokens are available, throw // If no tokens are available, throw
if (tokens.length < 1) { if (tokens.length < 1) {
throw errCode(new Error('No dial tokens available'), 'ERR_NO_DIAL_TOKENS') throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
} }
const tokenHolder = new FIFO() const tokenHolder = new FIFO()
tokens.forEach(token => tokenHolder.push(token)) tokens.forEach(token => tokenHolder.push(token))
const dialAbortControllers = this.addrs.map(() => new AbortController()) const dialAbortControllers = this.addrs.map(() => {
const controller = new AbortController()
setMaxListeners && setMaxListeners(Infinity, controller.signal)
return controller
})
let completedDials = 0 let completedDials = 0
try { try {

View File

@ -6,15 +6,15 @@ const log = Object.assign(debug('libp2p:dialer'), {
}) })
const errCode = require('err-code') const errCode = require('err-code')
const { Multiaddr } = require('multiaddr') const { Multiaddr } = require('multiaddr')
// @ts-ignore timeout-abourt-controles does not export types const { TimeoutController } = require('timeout-abort-controller')
const TimeoutController = require('timeout-abort-controller')
const { AbortError } = require('abortable-iterator') const { AbortError } = require('abortable-iterator')
const { anySignal } = require('any-signal') const { anySignal } = require('any-signal')
// @ts-expect-error setMaxListeners is missing from the types
const { setMaxListeners } = require('events')
const DialRequest = require('./dial-request') const DialRequest = require('./dial-request')
const { publicAddressesFirst } = require('libp2p-utils/src/address-sort') const { publicAddressesFirst } = require('libp2p-utils/src/address-sort')
const getPeer = require('../get-peer') const getPeer = require('../get-peer')
const trackedMap = require('../metrics/tracked-map')
const { codes } = require('../errors') const { codes } = require('../errors')
const { const {
DIAL_TIMEOUT, DIAL_TIMEOUT,
@ -23,6 +23,10 @@ const {
MAX_ADDRS_TO_DIAL MAX_ADDRS_TO_DIAL
} = require('../constants') } = require('../constants')
const METRICS_COMPONENT = 'dialler'
const METRICS_PENDING_DIALS = 'pending-dials'
const METRICS_PENDING_DIAL_TARGETS = 'pending-dial-targets'
/** /**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('peer-id')} PeerId * @typedef {import('peer-id')} PeerId
@ -45,14 +49,15 @@ const {
* @property {number} [maxDialsPerPeer = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer. * @property {number} [maxDialsPerPeer = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
* @property {number} [dialTimeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take. * @property {number} [dialTimeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
* @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing * @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing
* @property {import('../metrics')} [metrics]
* *
* @typedef DialTarget * @typedef DialTarget
* @property {string} id * @property {string} id
* @property {Multiaddr[]} addrs * @property {Multiaddr[]} addrs
* *
* @typedef PendingDial * @typedef PendingDial
* @property {DialRequest} dialRequest * @property {import('./dial-request')} dialRequest
* @property {TimeoutController} controller * @property {import('timeout-abort-controller').TimeoutController} controller
* @property {Promise<Connection>} promise * @property {Promise<Connection>} promise
* @property {function():void} destroy * @property {function():void} destroy
*/ */
@ -70,7 +75,8 @@ class Dialer {
maxAddrsToDial = MAX_ADDRS_TO_DIAL, maxAddrsToDial = MAX_ADDRS_TO_DIAL,
dialTimeout = DIAL_TIMEOUT, dialTimeout = DIAL_TIMEOUT,
maxDialsPerPeer = MAX_PER_PEER_DIALS, maxDialsPerPeer = MAX_PER_PEER_DIALS,
resolvers = {} resolvers = {},
metrics
}) { }) {
this.transportManager = transportManager this.transportManager = transportManager
this.peerStore = peerStore this.peerStore = peerStore
@ -80,8 +86,12 @@ class Dialer {
this.timeout = dialTimeout this.timeout = dialTimeout
this.maxDialsPerPeer = maxDialsPerPeer this.maxDialsPerPeer = maxDialsPerPeer
this.tokens = [...new Array(maxParallelDials)].map((_, index) => index) this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
this._pendingDials = new Map()
this._pendingDialTargets = new Map() /** @type {Map<string, PendingDial>} */
this._pendingDials = trackedMap(METRICS_COMPONENT, METRICS_PENDING_DIALS, metrics)
/** @type {Map<string, { resolve: (value: any) => void, reject: (err: Error) => void}>} */
this._pendingDialTargets = trackedMap(METRICS_COMPONENT, METRICS_PENDING_DIAL_TARGETS, metrics)
for (const [key, value] of Object.entries(resolvers)) { for (const [key, value] of Object.entries(resolvers)) {
Multiaddr.resolvers.set(key, value) Multiaddr.resolvers.set(key, value)
@ -95,7 +105,7 @@ class Dialer {
for (const dial of this._pendingDials.values()) { for (const dial of this._pendingDials.values()) {
try { try {
dial.controller.abort() dial.controller.abort()
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -129,7 +139,7 @@ class Dialer {
const connection = await pendingDial.promise const connection = await pendingDial.promise
log('dial succeeded to %s', dialTarget.id) log('dial succeeded to %s', dialTarget.id)
return connection return connection
} catch (err) { } catch (/** @type {any} */ err) {
// Error is a timeout // Error is a timeout
if (pendingDial.controller.signal.aborted) { if (pendingDial.controller.signal.aborted) {
err.code = codes.ERR_TIMEOUT err.code = codes.ERR_TIMEOUT
@ -156,14 +166,16 @@ class Dialer {
this._pendingDialTargets.set(id, { resolve, reject }) this._pendingDialTargets.set(id, { resolve, reject })
}) })
const dialTarget = await Promise.race([ try {
this._createDialTarget(peer), const dialTarget = await Promise.race([
cancellablePromise this._createDialTarget(peer),
]) cancellablePromise
])
this._pendingDialTargets.delete(id) return dialTarget
} finally {
return dialTarget this._pendingDialTargets.delete(id)
}
} }
/** /**
@ -240,10 +252,15 @@ class Dialer {
// Combine the timeout signal and options.signal, if provided // Combine the timeout signal and options.signal, if provided
const timeoutController = new TimeoutController(this.timeout) const timeoutController = new TimeoutController(this.timeout)
const signals = [timeoutController.signal] const signals = [timeoutController.signal]
options.signal && signals.push(options.signal) options.signal && signals.push(options.signal)
const signal = anySignal(signals) const signal = anySignal(signals)
// this signal will potentially be used while dialing lots of
// peers so prevent MaxListenersExceededWarning appearing in the console
setMaxListeners && setMaxListeners(Infinity, signal)
const pendingDial = { const pendingDial = {
dialRequest, dialRequest,
controller: timeoutController, controller: timeoutController,
@ -254,6 +271,7 @@ class Dialer {
} }
} }
this._pendingDials.set(dialTarget.id, pendingDial) this._pendingDials.set(dialTarget.id, pendingDial)
return pendingDial return pendingDial
} }

View File

@ -3,7 +3,8 @@
exports.messages = { exports.messages = {
NOT_STARTED_YET: 'The libp2p node is not started yet', NOT_STARTED_YET: 'The libp2p node is not started yet',
DHT_DISABLED: 'DHT is not available', DHT_DISABLED: 'DHT is not available',
CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required' CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required',
NOT_FOUND: 'Not found'
} }
exports.codes = { exports.codes = {
@ -29,10 +30,35 @@ exports.codes = {
ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS', ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS',
ERR_INVALID_PEER: 'ERR_INVALID_PEER', ERR_INVALID_PEER: 'ERR_INVALID_PEER',
ERR_MUXER_UNAVAILABLE: 'ERR_MUXER_UNAVAILABLE', ERR_MUXER_UNAVAILABLE: 'ERR_MUXER_UNAVAILABLE',
ERR_NOT_FOUND: 'ERR_NOT_FOUND',
ERR_TIMEOUT: 'ERR_TIMEOUT', ERR_TIMEOUT: 'ERR_TIMEOUT',
ERR_TRANSPORT_UNAVAILABLE: 'ERR_TRANSPORT_UNAVAILABLE', ERR_TRANSPORT_UNAVAILABLE: 'ERR_TRANSPORT_UNAVAILABLE',
ERR_TRANSPORT_DIAL_FAILED: 'ERR_TRANSPORT_DIAL_FAILED', ERR_TRANSPORT_DIAL_FAILED: 'ERR_TRANSPORT_DIAL_FAILED',
ERR_UNSUPPORTED_PROTOCOL: 'ERR_UNSUPPORTED_PROTOCOL', ERR_UNSUPPORTED_PROTOCOL: 'ERR_UNSUPPORTED_PROTOCOL',
ERR_INVALID_MULTIADDR: 'ERR_INVALID_MULTIADDR', ERR_INVALID_MULTIADDR: 'ERR_INVALID_MULTIADDR',
ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID' ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID',
ERR_FIND_SELF: 'ERR_FIND_SELF',
ERR_NO_ROUTERS_AVAILABLE: 'ERR_NO_ROUTERS_AVAILABLE',
ERR_CONNECTION_NOT_MULTIPLEXED: 'ERR_CONNECTION_NOT_MULTIPLEXED',
ERR_NO_DIAL_TOKENS: 'ERR_NO_DIAL_TOKENS',
ERR_KEYCHAIN_REQUIRED: 'ERR_KEYCHAIN_REQUIRED',
ERR_INVALID_CMS: 'ERR_INVALID_CMS',
ERR_MISSING_KEYS: 'ERR_MISSING_KEYS',
ERR_NO_KEY: 'ERR_NO_KEY',
ERR_INVALID_KEY_NAME: 'ERR_INVALID_KEY_NAME',
ERR_INVALID_KEY_TYPE: 'ERR_INVALID_KEY_TYPE',
ERR_KEY_ALREADY_EXISTS: 'ERR_KEY_ALREADY_EXISTS',
ERR_INVALID_KEY_SIZE: 'ERR_INVALID_KEY_SIZE',
ERR_KEY_NOT_FOUND: 'ERR_KEY_NOT_FOUND',
ERR_OLD_KEY_NAME_INVALID: 'ERR_OLD_KEY_NAME_INVALID',
ERR_NEW_KEY_NAME_INVALID: 'ERR_NEW_KEY_NAME_INVALID',
ERR_PASSWORD_REQUIRED: 'ERR_PASSWORD_REQUIRED',
ERR_PEM_REQUIRED: 'ERR_PEM_REQUIRED',
ERR_CANNOT_READ_KEY: 'ERR_CANNOT_READ_KEY',
ERR_MISSING_PRIVATE_KEY: 'ERR_MISSING_PRIVATE_KEY',
ERR_INVALID_OLD_PASS_TYPE: 'ERR_INVALID_OLD_PASS_TYPE',
ERR_INVALID_NEW_PASS_TYPE: 'ERR_INVALID_NEW_PASS_TYPE',
ERR_INVALID_PASS_LENGTH: 'ERR_INVALID_PASS_LENGTH',
ERR_NOT_IMPLEMENTED: 'ERR_NOT_IMPLEMENTED',
ERR_WRONG_PING_ACK: 'ERR_WRONG_PING_ACK'
} }

View File

@ -32,7 +32,7 @@ function getPeer (peer) {
try { try {
peer = PeerId.createFromB58String(idStr) peer = PeerId.createFromB58String(idStr)
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode( throw errCode(
new Error(`${peer} is not a valid peer type`), new Error(`${peer} is not a valid peer type`),
codes.ERR_INVALID_MULTIADDR codes.ERR_INVALID_MULTIADDR

View File

@ -124,7 +124,7 @@ class IdentifyService {
stream, stream,
consume consume
) )
} catch (err) { } catch (/** @type {any} */ err) {
// Just log errors // Just log errors
log.error('could not push identify update to peer', err) log.error('could not push identify update to peer', err)
} }
@ -182,7 +182,7 @@ class IdentifyService {
let message let message
try { try {
message = Message.Identify.decode(data) message = Message.Identify.decode(data)
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_INVALID_MESSAGE) throw errCode(err, codes.ERR_INVALID_MESSAGE)
} }
@ -211,14 +211,14 @@ class IdentifyService {
this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion)) this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
return return
} }
} catch (err) { } catch (/** @type {any} */ err) {
log('received invalid envelope, discard it and fallback to listenAddrs is available', err) log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
} }
// LEGACY: Update peers data in PeerStore // LEGACY: Update peers data in PeerStore
try { try {
this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr))) this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr)))
} catch (err) { } catch (/** @type {any} */ err) {
log.error('received invalid addrs', err) log.error('received invalid addrs', err)
} }
@ -287,7 +287,7 @@ class IdentifyService {
stream, stream,
consume consume
) )
} catch (err) { } catch (/** @type {any} */ err) {
log.error('could not respond to identify request', err) log.error('could not respond to identify request', err)
} }
} }
@ -313,7 +313,7 @@ class IdentifyService {
collect collect
) )
message = Message.Identify.decode(data) message = Message.Identify.decode(data)
} catch (err) { } catch (/** @type {any} */ err) {
return log.error('received invalid message', err) return log.error('received invalid message', err)
} }
@ -325,7 +325,7 @@ class IdentifyService {
this.peerStore.protoBook.set(id, message.protocols) this.peerStore.protoBook.set(id, message.protocols)
return return
} }
} catch (err) { } catch (/** @type {any} */ err) {
log('received invalid envelope, discard it and fallback to listenAddrs is available', err) log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
} }
@ -333,7 +333,7 @@ class IdentifyService {
try { try {
this.peerStore.addressBook.set(id, this.peerStore.addressBook.set(id,
message.listenAddrs.map((addr) => new Multiaddr(addr))) message.listenAddrs.map((addr) => new Multiaddr(addr)))
} catch (err) { } catch (/** @type {any} */ err) {
log.error('received invalid addrs', err) log.error('received invalid addrs', err)
} }

View File

@ -18,6 +18,7 @@ const { codes, messages } = require('./errors')
const AddressManager = require('./address-manager') const AddressManager = require('./address-manager')
const ConnectionManager = require('./connection-manager') const ConnectionManager = require('./connection-manager')
const AutoDialler = require('./connection-manager/auto-dialler')
const Circuit = require('./circuit/transport') const Circuit = require('./circuit/transport')
const Relay = require('./circuit') const Relay = require('./circuit')
const Dialer = require('./dialer') const Dialer = require('./dialer')
@ -47,6 +48,8 @@ const { updateSelfPeerRecord } = require('./record/utils')
* @typedef {import('libp2p-interfaces/src/pubsub').PubsubOptions} PubsubOptions * @typedef {import('libp2p-interfaces/src/pubsub').PubsubOptions} PubsubOptions
* @typedef {import('interface-datastore').Datastore} Datastore * @typedef {import('interface-datastore').Datastore} Datastore
* @typedef {import('./pnet')} Protector * @typedef {import('./pnet')} Protector
* @typedef {Object} PersistentPeerStoreOptions
* @property {number} [threshold]
*/ */
/** /**
@ -55,16 +58,9 @@ const { updateSelfPeerRecord } = require('./record/utils')
* @property {MuxedStream} stream * @property {MuxedStream} stream
* @property {string} protocol * @property {string} protocol
* *
* @typedef {Object} RandomWalkOptions
* @property {boolean} [enabled = false]
* @property {number} [queriesPerPeriod = 1]
* @property {number} [interval = 300e3]
* @property {number} [timeout = 10e3]
*
* @typedef {Object} DhtOptions * @typedef {Object} DhtOptions
* @property {boolean} [enabled = false] * @property {boolean} [enabled = false]
* @property {number} [kBucketSize = 20] * @property {number} [kBucketSize = 20]
* @property {RandomWalkOptions} [randomWalk]
* @property {boolean} [clientMode] * @property {boolean} [clientMode]
* @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors] * @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors]
* @property {import('libp2p-interfaces/src/types').DhtValidators} [validators] * @property {import('libp2p-interfaces/src/types').DhtValidators} [validators]
@ -116,7 +112,7 @@ const { updateSelfPeerRecord } = require('./record/utils')
* @property {KeychainOptions & import('./keychain/index').KeychainOptions} [keychain] * @property {KeychainOptions & import('./keychain/index').KeychainOptions} [keychain]
* @property {MetricsOptions & import('./metrics').MetricsOptions} [metrics] * @property {MetricsOptions & import('./metrics').MetricsOptions} [metrics]
* @property {import('./peer-routing').PeerRoutingOptions} [peerRouting] * @property {import('./peer-routing').PeerRoutingOptions} [peerRouting]
* @property {PeerStoreOptions & import('./peer-store/persistent').PersistentPeerStoreOptions} [peerStore] * @property {PeerStoreOptions & PersistentPeerStoreOptions} [peerStore]
* @property {import('./transport-manager').TransportManagerOptions} [transportManager] * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
* @property {Libp2pConfig} [config] * @property {Libp2pConfig} [config]
* *
@ -167,6 +163,15 @@ class Libp2p extends EventEmitter {
this.peerId = this._options.peerId this.peerId = this._options.peerId
this.datastore = this._options.datastore this.datastore = this._options.datastore
// Create Metrics
if (this._options.metrics.enabled) {
const metrics = new Metrics({
...this._options.metrics
})
this.metrics = metrics
}
this.peerStore = (this.datastore && this._options.peerStore.persistence) this.peerStore = (this.datastore && this._options.peerStore.persistence)
? new PersistentPeerStore({ ? new PersistentPeerStore({
peerId: this.peerId, peerId: this.peerId,
@ -193,17 +198,13 @@ class Libp2p extends EventEmitter {
// Create the Connection Manager // Create the Connection Manager
this.connectionManager = new ConnectionManager(this, { this.connectionManager = new ConnectionManager(this, {
autoDial: this._config.peerDiscovery.autoDial,
...this._options.connectionManager ...this._options.connectionManager
}) })
this._autodialler = new AutoDialler(this, {
// Create Metrics enabled: this._config.peerDiscovery.autoDial,
if (this._options.metrics.enabled) { minConnections: this._options.connectionManager.minConnections,
this.metrics = new Metrics({ autoDialInterval: this._options.connectionManager.autoDialInterval
...this._options.metrics, })
connectionManager: this.connectionManager
})
}
// Create keychain // Create keychain
if (this._options.keychain && this._options.keychain.datastore) { if (this._options.keychain && this._options.keychain.datastore) {
@ -264,6 +265,7 @@ class Libp2p extends EventEmitter {
this.dialer = new Dialer({ this.dialer = new Dialer({
transportManager: this.transportManager, transportManager: this.transportManager,
peerStore: this.peerStore, peerStore: this.peerStore,
metrics: this.metrics,
...this._options.dialer ...this._options.dialer
}) })
@ -301,14 +303,9 @@ class Libp2p extends EventEmitter {
// dht provided components (peerRouting, contentRouting, dht) // dht provided components (peerRouting, contentRouting, dht)
if (this._modules.dht) { if (this._modules.dht) {
const DHT = this._modules.dht const DHT = this._modules.dht
// @ts-ignore Object is not constructable // @ts-ignore TODO: types need fixing - DHT is an `object` which has no `create` method
this._dht = new DHT({ this._dht = DHT.create({
libp2p: this, libp2p: this,
dialer: this.dialer,
peerId: this.peerId,
peerStore: this.peerStore,
registrar: this.registrar,
datastore: this.datastore,
...this._config.dht ...this._config.dht
}) })
} }
@ -363,7 +360,7 @@ class Libp2p extends EventEmitter {
await this._onStarting() await this._onStarting()
await this._onDidStart() await this._onDidStart()
log('libp2p has started') log('libp2p has started')
} catch (err) { } catch (/** @type {any} */ err) {
this.emit('error', err) this.emit('error', err)
log.error('An error occurred starting libp2p', err) log.error('An error occurred starting libp2p', err)
await this.stop() await this.stop()
@ -385,6 +382,8 @@ class Libp2p extends EventEmitter {
this.relay && this.relay.stop() this.relay && this.relay.stop()
this.peerRouting.stop() this.peerRouting.stop()
this._autodialler.stop()
await (this._dht && this._dht.stop())
for (const service of this._discovery.values()) { for (const service of this._discovery.values()) {
service.removeListener('peer', this._onDiscoveryPeer) service.removeListener('peer', this._onDiscoveryPeer)
@ -399,7 +398,6 @@ class Libp2p extends EventEmitter {
await Promise.all([ await Promise.all([
this.pubsub && this.pubsub.stop(), this.pubsub && this.pubsub.stop(),
this._dht && this._dht.stop(),
this.metrics && this.metrics.stop() this.metrics && this.metrics.stop()
]) ])
@ -408,7 +406,7 @@ class Libp2p extends EventEmitter {
ping.unmount(this) ping.unmount(this)
this.dialer.destroy() this.dialer.destroy()
} catch (err) { } catch (/** @type {any} */ err) {
if (err) { if (err) {
log.error(err) log.error(err)
this.emit('error', err) this.emit('error', err)
@ -431,7 +429,7 @@ class Libp2p extends EventEmitter {
try { try {
await this.keychain.findKeyByName('self') await this.keychain.findKeyByName('self')
} catch (err) { } catch (/** @type {any} */ err) {
await this.keychain.importPeer('self', this.peerId) await this.keychain.importPeer('self', this.peerId)
} }
} }
@ -624,7 +622,7 @@ class Libp2p extends EventEmitter {
// DHT subsystem // DHT subsystem
if (this._config.dht.enabled) { if (this._config.dht.enabled) {
this._dht && this._dht.start() this._dht && await this._dht.start()
// TODO: this should be modified once random-walk is used as // TODO: this should be modified once random-walk is used as
// the other discovery modules // the other discovery modules
@ -655,6 +653,7 @@ class Libp2p extends EventEmitter {
} }
this.connectionManager.start() this.connectionManager.start()
this._autodialler.start()
// Peer discovery // Peer discovery
await this._setupPeerDiscovery() await this._setupPeerDiscovery()
@ -698,7 +697,7 @@ class Libp2p extends EventEmitter {
log('connecting to discovered peer %s', peerId.toB58String()) log('connecting to discovered peer %s', peerId.toB58String())
try { try {
await this.dialer.connectToPeer(peerId) await this.dialer.connectToPeer(peerId)
} catch (err) { } catch (/** @type {any} */ err) {
log.error(`could not connect to discovered peer ${peerId.toB58String()} with ${err}`) log.error(`could not connect to discovered peer ${peerId.toB58String()} with ${err}`)
} }
} }

View File

@ -55,7 +55,7 @@ async function encrypt (localId, conn, remoteId) {
let peerId let peerId
try { try {
peerId = await PeerId.createFromPubKey(id.pubkey.Data) peerId = await PeerId.createFromPubKey(id.pubkey.Data)
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
throw new InvalidCryptoExchangeError('Remote did not provide its public key') throw new InvalidCryptoExchangeError('Remote did not provide its public key')
} }

View File

@ -10,6 +10,7 @@ const { certificateForKey, findAsync } = require('./util')
const errcode = require('err-code') const errcode = require('err-code')
const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
const { toString: uint8ArrayToString } = require('uint8arrays/to-string') const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
const { codes } = require('../errors')
const privates = new WeakMap() const privates = new WeakMap()
@ -31,7 +32,7 @@ class CMS {
*/ */
constructor (keychain, dek) { constructor (keychain, dek) {
if (!keychain) { if (!keychain) {
throw errcode(new Error('keychain is required'), 'ERR_KEYCHAIN_REQUIRED') throw errcode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
} }
this.keychain = keychain this.keychain = keychain
@ -49,7 +50,7 @@ class CMS {
*/ */
async encrypt (name, plain) { async encrypt (name, plain) {
if (!(plain instanceof Uint8Array)) { if (!(plain instanceof Uint8Array)) {
throw errcode(new Error('Plain data must be a Uint8Array'), 'ERR_INVALID_PARAMS') throw errcode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
} }
const key = await this.keychain.findKeyByName(name) const key = await this.keychain.findKeyByName(name)
@ -81,7 +82,7 @@ class CMS {
*/ */
async decrypt (cmsData) { async decrypt (cmsData) {
if (!(cmsData instanceof Uint8Array)) { if (!(cmsData instanceof Uint8Array)) {
throw errcode(new Error('CMS data is required'), 'ERR_INVALID_PARAMS') throw errcode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
} }
let cms let cms
@ -90,8 +91,8 @@ class CMS {
const obj = forge.asn1.fromDer(buf) const obj = forge.asn1.fromDer(buf)
// @ts-ignore not defined // @ts-ignore not defined
cms = forge.pkcs7.messageFromAsn1(obj) cms = forge.pkcs7.messageFromAsn1(obj)
} catch (err) { } catch (/** @type {any} */ err) {
throw errcode(new Error('Invalid CMS: ' + err.message), 'ERR_INVALID_CMS') throw errcode(new Error('Invalid CMS: ' + err.message), codes.ERR_INVALID_CMS)
} }
// Find a recipient whose key we hold. We only deal with recipient certs // Find a recipient whose key we hold. We only deal with recipient certs
@ -114,7 +115,7 @@ class CMS {
try { try {
const key = await this.keychain.findKeyById(recipient.keyId) const key = await this.keychain.findKeyById(recipient.keyId)
if (key) return true if (key) return true
} catch (err) { } catch (/** @type {any} */ err) {
return false return false
} }
return false return false
@ -123,7 +124,7 @@ class CMS {
if (!r) { if (!r) {
// @ts-ignore cms types not defined // @ts-ignore cms types not defined
const missingKeys = recipients.map(r => r.keyId) const missingKeys = recipients.map(r => r.keyId)
throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), 'ERR_MISSING_KEYS', { throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), codes.ERR_MISSING_KEYS, {
missingKeys missingKeys
}) })
} }
@ -131,7 +132,7 @@ class CMS {
const key = await this.keychain.findKeyById(r.keyId) const key = await this.keychain.findKeyById(r.keyId)
if (!key) { if (!key) {
throw errcode(new Error('No key available to decrypto'), 'ERR_NO_KEY') throw errcode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
} }
const pem = await this.keychain._getPrivateKey(key.name) const pem = await this.keychain._getPrivateKey(key.name)

View File

@ -10,6 +10,7 @@ const crypto = require('libp2p-crypto')
const { Key } = require('interface-datastore/key') const { Key } = require('interface-datastore/key')
const CMS = require('./cms') const CMS = require('./cms')
const errcode = require('err-code') const errcode = require('err-code')
const { codes } = require('../errors')
const { toString: uint8ArrayToString } = require('uint8arrays/to-string') const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
@ -210,21 +211,21 @@ class Keychain {
const self = this const self = this
if (!validateKeyName(name) || name === 'self') { if (!validateKeyName(name) || name === 'self') {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
if (typeof type !== 'string') { if (typeof type !== 'string') {
return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), 'ERR_INVALID_KEY_TYPE')) return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), codes.ERR_INVALID_KEY_TYPE))
} }
const dsname = DsName(name) const dsname = DsName(name)
const exists = await self.store.has(dsname) const exists = await self.store.has(dsname)
if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS')) if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
switch (type.toLowerCase()) { switch (type.toLowerCase()) {
case 'rsa': case 'rsa':
if (!Number.isSafeInteger(size) || size < 2048) { if (!Number.isSafeInteger(size) || size < 2048) {
return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), 'ERR_INVALID_KEY_SIZE')) return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), codes.ERR_INVALID_KEY_SIZE))
} }
break break
default: default:
@ -248,7 +249,7 @@ class Keychain {
batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo))) batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
await batch.commit() await batch.commit()
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
@ -284,7 +285,7 @@ class Keychain {
try { try {
const keys = await this.listKeys() const keys = await this.listKeys()
return keys.find((k) => k.id === id) return keys.find((k) => k.id === id)
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
} }
@ -297,15 +298,15 @@ class Keychain {
*/ */
async findKeyByName (name) { async findKeyByName (name) {
if (!validateKeyName(name)) { if (!validateKeyName(name)) {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
const dsname = DsInfoName(name) const dsname = DsInfoName(name)
try { try {
const res = await this.store.get(dsname) const res = await this.store.get(dsname)
return JSON.parse(uint8ArrayToString(res)) return JSON.parse(uint8ArrayToString(res))
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND')) return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
} }
} }
@ -318,7 +319,7 @@ class Keychain {
async removeKey (name) { async removeKey (name) {
const self = this const self = this
if (!validateKeyName(name) || name === 'self') { if (!validateKeyName(name) || name === 'self') {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
const dsname = DsName(name) const dsname = DsName(name)
const keyInfo = await self.findKeyByName(name) const keyInfo = await self.findKeyByName(name)
@ -339,10 +340,10 @@ class Keychain {
async renameKey (oldName, newName) { async renameKey (oldName, newName) {
const self = this const self = this
if (!validateKeyName(oldName) || oldName === 'self') { if (!validateKeyName(oldName) || oldName === 'self') {
return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), 'ERR_OLD_KEY_NAME_INVALID')) return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), codes.ERR_OLD_KEY_NAME_INVALID))
} }
if (!validateKeyName(newName) || newName === 'self') { if (!validateKeyName(newName) || newName === 'self') {
return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), 'ERR_NEW_KEY_NAME_INVALID')) return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), codes.ERR_NEW_KEY_NAME_INVALID))
} }
const oldDsname = DsName(oldName) const oldDsname = DsName(oldName)
const newDsname = DsName(newName) const newDsname = DsName(newName)
@ -350,7 +351,7 @@ class Keychain {
const newInfoName = DsInfoName(newName) const newInfoName = DsInfoName(newName)
const exists = await self.store.has(newDsname) const exists = await self.store.has(newDsname)
if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), 'ERR_KEY_ALREADY_EXISTS')) if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
try { try {
const pem = await self.store.get(oldDsname) const pem = await self.store.get(oldDsname)
@ -365,7 +366,7 @@ class Keychain {
batch.delete(oldInfoName) batch.delete(oldInfoName)
await batch.commit() await batch.commit()
return keyInfo return keyInfo
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
} }
@ -379,10 +380,10 @@ class Keychain {
*/ */
async exportKey (name, password) { async exportKey (name, password) {
if (!validateKeyName(name)) { if (!validateKeyName(name)) {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
if (!password) { if (!password) {
return throwDelayed(errcode(new Error('Password is required'), 'ERR_PASSWORD_REQUIRED')) return throwDelayed(errcode(new Error('Password is required'), codes.ERR_PASSWORD_REQUIRED))
} }
const dsname = DsName(name) const dsname = DsName(name)
@ -393,7 +394,7 @@ class Keychain {
const dek = privates.get(this).dek const dek = privates.get(this).dek
const privateKey = await crypto.keys.import(pem, dek) const privateKey = await crypto.keys.import(pem, dek)
return privateKey.export(password) return privateKey.export(password)
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
} }
@ -409,20 +410,20 @@ class Keychain {
async importKey (name, pem, password) { async importKey (name, pem, password) {
const self = this const self = this
if (!validateKeyName(name) || name === 'self') { if (!validateKeyName(name) || name === 'self') {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
if (!pem) { if (!pem) {
return throwDelayed(errcode(new Error('PEM encoded key is required'), 'ERR_PEM_REQUIRED')) return throwDelayed(errcode(new Error('PEM encoded key is required'), codes.ERR_PEM_REQUIRED))
} }
const dsname = DsName(name) const dsname = DsName(name)
const exists = await self.store.has(dsname) const exists = await self.store.has(dsname)
if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS')) if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
let privateKey let privateKey
try { try {
privateKey = await crypto.keys.import(pem, password) privateKey = await crypto.keys.import(pem, password)
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), 'ERR_CANNOT_READ_KEY')) return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), codes.ERR_CANNOT_READ_KEY))
} }
let kid let kid
@ -431,7 +432,7 @@ class Keychain {
/** @type {string} */ /** @type {string} */
const dek = privates.get(this).dek const dek = privates.get(this).dek
pem = await privateKey.export(dek) pem = await privateKey.export(dek)
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
@ -457,16 +458,16 @@ class Keychain {
async importPeer (name, peer) { async importPeer (name, peer) {
const self = this const self = this
if (!validateKeyName(name)) { if (!validateKeyName(name)) {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
if (!peer || !peer.privKey) { if (!peer || !peer.privKey) {
return throwDelayed(errcode(new Error('Peer.privKey is required'), 'ERR_MISSING_PRIVATE_KEY')) return throwDelayed(errcode(new Error('Peer.privKey is required'), codes.ERR_MISSING_PRIVATE_KEY))
} }
const privateKey = peer.privKey const privateKey = peer.privKey
const dsname = DsName(name) const dsname = DsName(name)
const exists = await self.store.has(dsname) const exists = await self.store.has(dsname)
if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS')) if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
try { try {
const kid = await privateKey.id() const kid = await privateKey.id()
@ -482,7 +483,7 @@ class Keychain {
batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo))) batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
await batch.commit() await batch.commit()
return keyInfo return keyInfo
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(err) return throwDelayed(err)
} }
} }
@ -495,15 +496,15 @@ class Keychain {
*/ */
async _getPrivateKey (name) { async _getPrivateKey (name) {
if (!validateKeyName(name)) { if (!validateKeyName(name)) {
return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME')) return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
} }
try { try {
const dsname = DsName(name) const dsname = DsName(name)
const res = await this.store.get(dsname) const res = await this.store.get(dsname)
return uint8ArrayToString(res) return uint8ArrayToString(res)
} catch (err) { } catch (/** @type {any} */ err) {
return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND')) return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
} }
} }
@ -515,13 +516,13 @@ class Keychain {
*/ */
async rotateKeychainPass (oldPass, newPass) { async rotateKeychainPass (oldPass, newPass) {
if (typeof oldPass !== 'string') { if (typeof oldPass !== 'string') {
return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), 'ERR_INVALID_OLD_PASS_TYPE')) return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), codes.ERR_INVALID_OLD_PASS_TYPE))
} }
if (typeof newPass !== 'string') { if (typeof newPass !== 'string') {
return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), 'ERR_INVALID_NEW_PASS_TYPE')) return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), codes.ERR_INVALID_NEW_PASS_TYPE))
} }
if (newPass.length < 20) { if (newPass.length < 20) {
return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), 'ERR_INVALID_PASS_LENGTH')) return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), codes.ERR_INVALID_PASS_LENGTH))
} }
log('recreating keychain') log('recreating keychain')
const oldDek = privates.get(this).dek const oldDek = privates.get(this).dek

View File

@ -24,9 +24,6 @@ const directionToEvent = {
*/ */
/** /**
* @typedef MetricsProperties
* @property {import('../connection-manager')} connectionManager
*
* @typedef MetricsOptions * @typedef MetricsOptions
* @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize] * @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize]
* @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout] * @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout]
@ -37,7 +34,7 @@ const directionToEvent = {
class Metrics { class Metrics {
/** /**
* @class * @class
* @param {MetricsProperties & MetricsOptions} options * @param {MetricsOptions} options
*/ */
constructor (options) { constructor (options) {
this._options = mergeOptions(defaultOptions, options) this._options = mergeOptions(defaultOptions, options)
@ -47,10 +44,7 @@ class Metrics {
this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention) this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention)
this._running = false this._running = false
this._onMessage = this._onMessage.bind(this) this._onMessage = this._onMessage.bind(this)
this._connectionManager = options.connectionManager this._componentMetrics = new Map()
this._connectionManager.on('peer:disconnect', (connection) => {
this.onPeerDisconnected(connection.remotePeer)
})
} }
/** /**
@ -94,6 +88,22 @@ class Metrics {
return Array.from(this._peerStats.keys()) return Array.from(this._peerStats.keys())
} }
/**
* @returns {Map}
*/
getComponentMetrics () {
return this._componentMetrics
}
updateComponentMetric (component, metric, value) {
if (!this._componentMetrics.has(component)) {
this._componentMetrics.set(component, new Map())
}
const map = this._componentMetrics.get(component)
map.set(metric, value)
}
/** /**
* Returns the `Stats` object for the given `PeerId` whether it * Returns the `Stats` object for the given `PeerId` whether it
* is a live peer, or in the disconnected peer LRU cache. * is a live peer, or in the disconnected peer LRU cache.

View File

@ -8,6 +8,7 @@ const retimer = require('retimer')
/** /**
* @typedef {import('@vascosantos/moving-average').IMovingAverage} IMovingAverage * @typedef {import('@vascosantos/moving-average').IMovingAverage} IMovingAverage
* @typedef {import('bignumber.js').BigNumber} Big
*/ */
class Stats extends EventEmitter { class Stats extends EventEmitter {

View File

@ -0,0 +1,68 @@
'use strict'
/**
* @template K
* @template V
*/
class TrackedMap extends Map {
/**
* @param {string} component
* @param {string} name
* @param {import('.')} metrics
*/
constructor (component, name, metrics) {
super()
this._component = component
this._name = name
this._metrics = metrics
this._metrics.updateComponentMetric(this._component, this._name, this.size)
}
/**
* @param {K} key
* @param {V} value
*/
set (key, value) {
super.set(key, value)
this._metrics.updateComponentMetric(this._component, this._name, this.size)
return this
}
/**
* @param {K} key
*/
delete (key) {
const deleted = super.delete(key)
this._metrics.updateComponentMetric(this._component, this._name, this.size)
return deleted
}
clear () {
super.clear()
this._metrics.updateComponentMetric(this._component, this._name, this.size)
}
}
/**
* @template K
* @template V
* @param {string} component
* @param {string} name
* @param {import('.')} [metrics]
* @returns {Map<K, V>}
*/
module.exports = (component, name, metrics) => {
/** @type {Map<K, V>} */
let map
if (metrics) {
map = new TrackedMap(component, name, metrics)
} else {
map = new Map()
}
return map
}

View File

@ -1,7 +1,7 @@
'use strict' 'use strict'
// @ts-ignore nat-api does not export types // @ts-ignore nat-api does not export types
const NatAPI = require('@motrix/nat-api') const NatAPI = require('nat-api')
const debug = require('debug') const debug = require('debug')
const { promisify } = require('es6-promisify') const { promisify } = require('es6-promisify')
const { Multiaddr } = require('multiaddr') const { Multiaddr } = require('multiaddr')
@ -114,7 +114,7 @@ class NatManager {
const client = this._getClient() const client = this._getClient()
const publicIp = this._externalIp || await client.externalIp() const publicIp = this._externalIp || await client.externalIp()
// @ts-ignore isPrivate has no call signatures // @ts-expect-error types are wrong
if (isPrivateIp(publicIp)) { if (isPrivateIp(publicIp)) {
throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`) throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`)
} }
@ -188,7 +188,7 @@ class NatManager {
try { try {
await this._client.destroy() await this._client.destroy()
this._client = null this._client = null
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }

View File

@ -5,11 +5,13 @@ const log = Object.assign(debug('libp2p:peer-routing'), {
error: debug('libp2p:peer-routing:err') error: debug('libp2p:peer-routing:err')
}) })
const errCode = require('err-code') const errCode = require('err-code')
const errors = require('./errors')
const { const {
storeAddresses, storeAddresses,
uniquePeers, uniquePeers,
requirePeers requirePeers
} = require('./content-routing/utils') } = require('./content-routing/utils')
const { TimeoutController } = require('timeout-abort-controller')
const merge = require('it-merge') const merge = require('it-merge')
const { pipe } = require('it-pipe') const { pipe } = require('it-pipe')
@ -21,6 +23,9 @@ const {
clearDelayedInterval clearDelayedInterval
// @ts-ignore module with no types // @ts-ignore module with no types
} = require('set-delayed-interval') } = require('set-delayed-interval')
const { DHTPeerRouting } = require('./dht/dht-peer-routing')
// @ts-expect-error setMaxListeners is missing from the types
const { setMaxListeners } = require('events')
/** /**
* @typedef {import('peer-id')} PeerId * @typedef {import('peer-id')} PeerId
@ -33,6 +38,7 @@ const {
* @property {boolean} [enabled = true] - Whether to enable the Refresh manager * @property {boolean} [enabled = true] - Whether to enable the Refresh manager
* @property {number} [bootDelay = 6e5] - Boot delay to start the Refresh Manager (in ms) * @property {number} [bootDelay = 6e5] - Boot delay to start the Refresh Manager (in ms)
* @property {number} [interval = 10e3] - Interval between each Refresh Manager run (in ms) * @property {number} [interval = 10e3] - Interval between each Refresh Manager run (in ms)
* @property {number} [timeout = 10e3] - How long to let each refresh run (in ms)
* *
* @typedef {Object} PeerRoutingOptions * @typedef {Object} PeerRoutingOptions
* @property {RefreshManagerOptions} [refreshManager] * @property {RefreshManagerOptions} [refreshManager]
@ -51,7 +57,7 @@ class PeerRouting {
// If we have the dht, add it to the available peer routers // If we have the dht, add it to the available peer routers
if (libp2p._dht && libp2p._config.dht.enabled) { if (libp2p._dht && libp2p._config.dht.enabled) {
this._routers.push(libp2p._dht) this._routers.push(new DHTPeerRouting(libp2p._dht))
} }
this._refreshManagerOptions = libp2p._options.peerRouting.refreshManager this._refreshManagerOptions = libp2p._options.peerRouting.refreshManager
@ -78,8 +84,8 @@ class PeerRouting {
async _findClosestPeersTask () { async _findClosestPeersTask () {
try { try {
// nb getClosestPeers adds the addresses to the address book // nb getClosestPeers adds the addresses to the address book
await drain(this.getClosestPeers(this._peerId.id)) await drain(this.getClosestPeers(this._peerId.id, { timeout: this._refreshManagerOptions.timeout || 10e3 }))
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -101,19 +107,24 @@ class PeerRouting {
*/ */
async findPeer (id, options) { // eslint-disable-line require-await async findPeer (id, options) { // eslint-disable-line require-await
if (!this._routers.length) { if (!this._routers.length) {
throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE') throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
} }
if (id.toB58String() === this._peerId.toB58String()) { if (id.toB58String() === this._peerId.toB58String()) {
throw errCode(new Error('Should not try to find self'), 'ERR_FIND_SELF') throw errCode(new Error('Should not try to find self'), errors.codes.ERR_FIND_SELF)
} }
const output = await pipe( const output = await pipe(
merge( merge(
...this._routers.map(router => [router.findPeer(id, options)]) ...this._routers.map(router => (async function * () {
try {
yield await router.findPeer(id, options)
} catch (err) {
log.error(err)
}
})())
), ),
(source) => filter(source, Boolean), (source) => filter(source, Boolean),
// @ts-ignore findPeer resolves a Promise
(source) => storeAddresses(source, this._peerStore), (source) => storeAddresses(source, this._peerStore),
(source) => first(source) (source) => first(source)
) )
@ -122,7 +133,7 @@ class PeerRouting {
return output return output
} }
throw errCode(new Error('not found'), 'NOT_FOUND') throw errCode(new Error(errors.messages.NOT_FOUND), errors.codes.ERR_NOT_FOUND)
} }
/** /**
@ -130,12 +141,22 @@ class PeerRouting {
* *
* @param {Uint8Array} key - A CID like key * @param {Uint8Array} key - A CID like key
* @param {Object} [options] * @param {Object} [options]
* @param {number} [options.timeout=30e3] - How long the query can take. * @param {number} [options.timeout=30e3] - How long the query can take
* @param {AbortSignal} [options.signal] - An AbortSignal to abort the request
* @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} * @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>}
*/ */
async * getClosestPeers (key, options = { timeout: 30e3 }) { async * getClosestPeers (key, options = { timeout: 30e3 }) {
if (!this._routers.length) { if (!this._routers.length) {
throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE') throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
}
if (options.timeout) {
const controller = new TimeoutController(options.timeout)
// this controller will potentially be used while dialing lots of
// peers so prevent MaxListenersExceededWarning appearing in the console
setMaxListeners && setMaxListeners(Infinity, controller.signal)
options.signal = controller.signal
} }
yield * pipe( yield * pipe(

View File

@ -83,7 +83,7 @@ class AddressBook extends Book {
let peerRecord let peerRecord
try { try {
peerRecord = PeerRecord.createFromProtobuf(envelope.payload) peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
} catch (err) { } catch (/** @type {any} */ err) {
log.error('invalid peer record received') log.error('invalid peer record received')
return false return false
} }

View File

@ -2,10 +2,7 @@
const errcode = require('err-code') const errcode = require('err-code')
const PeerId = require('peer-id') const PeerId = require('peer-id')
const { codes } = require('../errors')
const {
codes: { ERR_INVALID_PARAMETERS }
} = require('../errors')
/** /**
* @param {any} data * @param {any} data
@ -48,7 +45,7 @@ class Book {
* @param {any[]|any} data * @param {any[]|any} data
*/ */
set (peerId, data) { set (peerId, data) {
throw errcode(new Error('set must be implemented by the subclass'), 'ERR_NOT_IMPLEMENTED') throw errcode(new Error('set must be implemented by the subclass'), codes.ERR_NOT_IMPLEMENTED)
} }
/** /**
@ -94,7 +91,7 @@ class Book {
*/ */
get (peerId) { get (peerId) {
if (!PeerId.isPeerId(peerId)) { if (!PeerId.isPeerId(peerId)) {
throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS) throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
} }
const rec = this.data.get(peerId.toB58String()) const rec = this.data.get(peerId.toB58String())
@ -111,7 +108,7 @@ class Book {
*/ */
delete (peerId) { delete (peerId) {
if (!PeerId.isPeerId(peerId)) { if (!PeerId.isPeerId(peerId)) {
throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS) throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
} }
if (!this.data.delete(peerId.toB58String())) { if (!this.data.delete(peerId.toB58String())) {

View File

@ -80,10 +80,11 @@ class MetadataBook extends Book {
/** /**
* Set data into the datastructure * Set data into the datastructure
* *
* @override
* @param {PeerId} peerId * @param {PeerId} peerId
* @param {string} key * @param {string} key
* @param {Uint8Array} value * @param {Uint8Array} value
* @param {object} [opts]
* @param {boolean} [opts.emit]
*/ */
_setValue (peerId, key, value, { emit = true } = {}) { _setValue (peerId, key, value, { emit = true } = {}) {
const id = peerId.toB58String() const id = peerId.toB58String()

View File

@ -249,7 +249,7 @@ class PersistentPeerStore extends PeerStore {
}).finish() }).finish()
batch.put(key, encodedData) batch.put(key, encodedData)
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -275,7 +275,7 @@ class PersistentPeerStore extends PeerStore {
const encodedData = peerId.marshalPubKey() const encodedData = peerId.marshalPubKey()
batch.put(key, encodedData) batch.put(key, encodedData)
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -302,7 +302,7 @@ class PersistentPeerStore extends PeerStore {
batch.delete(key) batch.delete(key)
} }
}) })
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -330,7 +330,7 @@ class PersistentPeerStore extends PeerStore {
const encodedData = Protocols.encode({ protocols }).finish() const encodedData = Protocols.encode({ protocols }).finish()
batch.put(key, encodedData) batch.put(key, encodedData)
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }
@ -399,7 +399,7 @@ class PersistentPeerStore extends PeerStore {
default: default:
log('invalid data persisted for: ', key.toString()) log('invalid data persisted for: ', key.toString())
} }
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
} }

View File

@ -5,7 +5,7 @@ const log = Object.assign(debug('libp2p:ping'), {
error: debug('libp2p:ping:err') error: debug('libp2p:ping:err')
}) })
const errCode = require('err-code') const errCode = require('err-code')
const { codes } = require('../errors')
const crypto = require('libp2p-crypto') const crypto = require('libp2p-crypto')
const { pipe } = require('it-pipe') const { pipe } = require('it-pipe')
// @ts-ignore it-buffer has no types exported // @ts-ignore it-buffer has no types exported
@ -50,7 +50,7 @@ async function ping (node, peer) {
const end = Date.now() const end = Date.now()
if (!equals(data, result)) { if (!equals(data, result)) {
throw errCode(new Error('Received wrong ping ack'), 'ERR_WRONG_PING_ACK') throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
} }
return end - start return end - start

View File

@ -77,7 +77,7 @@ module.exports.decodeV1PSK = (pskBuffer) => {
codecName: codec, codecName: codec,
psk: psk psk: psk
} }
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
throw new Error(Errors.INVALID_PSK) throw new Error(Errors.INVALID_PSK)
} }

View File

@ -28,6 +28,6 @@ try {
// @ts-ignore // @ts-ignore
generate(process.stdout) generate(process.stdout)
} }
} catch (error) { } catch (/** @type {any} */ error) {
} }

View File

@ -109,7 +109,7 @@ class TransportManager {
try { try {
return await transport.dial(ma, options) return await transport.dial(ma, options)
} catch (err) { } catch (/** @type {any} */ err) {
if (!err.code) err.code = codes.ERR_TRANSPORT_DIAL_FAILED if (!err.code) err.code = codes.ERR_TRANSPORT_DIAL_FAILED
throw err throw err
} }

View File

@ -106,7 +106,7 @@ class Upgrader {
} else { } else {
upgradedConn = encryptedConn upgradedConn = encryptedConn
} }
} catch (err) { } catch (/** @type {any} */ err) {
log.error('Failed to upgrade inbound connection', err) log.error('Failed to upgrade inbound connection', err)
await maConn.close(err) await maConn.close(err)
throw err throw err
@ -181,7 +181,7 @@ class Upgrader {
} else { } else {
upgradedConn = encryptedConn upgradedConn = encryptedConn
} }
} catch (err) { } catch (/** @type {any} */ err) {
log.error('Failed to upgrade outbound connection', err) log.error('Failed to upgrade outbound connection', err)
await maConn.close(err) await maConn.close(err)
throw err throw err
@ -245,7 +245,7 @@ class Upgrader {
if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol }) if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol })
connection.addStream(muxedStream, { protocol }) connection.addStream(muxedStream, { protocol })
this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol }) this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol })
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} }
}, },
@ -263,7 +263,7 @@ class Upgrader {
const { stream, protocol } = await mss.select(protocols) const { stream, protocol } = await mss.select(protocols)
if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol }) if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol })
return { stream: { ...muxedStream, ...stream }, protocol } return { stream: { ...muxedStream, ...stream }, protocol }
} catch (err) { } catch (/** @type {any} */ err) {
log.error('could not create new stream', err) log.error('could not create new stream', err)
throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL) throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
} }
@ -283,7 +283,7 @@ class Upgrader {
if (connection.stat.status === 'open') { if (connection.stat.status === 'open') {
await connection.close() await connection.close()
} }
} catch (err) { } catch (/** @type {any} */ err) {
log.error(err) log.error(err)
} finally { } finally {
this.onConnectionEnd(connection) this.onConnectionEnd(connection)
@ -297,7 +297,7 @@ class Upgrader {
maConn.timeline.upgraded = Date.now() maConn.timeline.upgraded = Date.now()
const errConnectionNotMultiplexed = () => { const errConnectionNotMultiplexed = () => {
throw errCode(new Error('connection is not multiplexed'), 'ERR_CONNECTION_NOT_MULTIPLEXED') throw errCode(new Error('connection is not multiplexed'), codes.ERR_CONNECTION_NOT_MULTIPLEXED)
} }
// Create the connection // Create the connection
@ -371,7 +371,7 @@ class Upgrader {
...await crypto.secureInbound(localPeer, stream), ...await crypto.secureInbound(localPeer, stream),
protocol protocol
} }
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_ENCRYPTION_FAILED) throw errCode(err, codes.ERR_ENCRYPTION_FAILED)
} }
} }
@ -406,7 +406,7 @@ class Upgrader {
...await crypto.secureOutbound(localPeer, stream, remotePeerId), ...await crypto.secureOutbound(localPeer, stream, remotePeerId),
protocol protocol
} }
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_ENCRYPTION_FAILED) throw errCode(err, codes.ERR_ENCRYPTION_FAILED)
} }
} }
@ -430,7 +430,7 @@ class Upgrader {
log('%s selected as muxer protocol', protocol) log('%s selected as muxer protocol', protocol)
const Muxer = muxers.get(protocol) const Muxer = muxers.get(protocol)
return { stream, Muxer } return { stream, Muxer }
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_MUXER_UNAVAILABLE) throw errCode(err, codes.ERR_MUXER_UNAVAILABLE)
} }
} }
@ -453,7 +453,7 @@ class Upgrader {
const { stream, protocol } = await listener.handle(protocols) const { stream, protocol } = await listener.handle(protocols)
const Muxer = muxers.get(protocol) const Muxer = muxers.get(protocol)
return { stream, Muxer } return { stream, Muxer }
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_MUXER_UNAVAILABLE) throw errCode(err, codes.ERR_MUXER_UNAVAILABLE)
} }
} }

View File

@ -34,16 +34,16 @@ describe('content-routing', () => {
try { try {
for await (const _ of node.contentRouting.findProviders('a cid')) {} // eslint-disable-line for await (const _ of node.contentRouting.findProviders('a cid')) {} // eslint-disable-line
throw new Error('.findProviders should return an error') throw new Error('.findProviders should return an error')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
expect(err.code).to.equal('NO_ROUTERS_AVAILABLE') expect(err.code).to.equal('ERR_NO_ROUTERS_AVAILABLE')
} }
}) })
it('.provide should return an error', async () => { it('.provide should return an error', async () => {
await expect(node.contentRouting.provide('a cid')) await expect(node.contentRouting.provide('a cid'))
.to.eventually.be.rejected() .to.eventually.be.rejected()
.and.to.have.property('code', 'NO_ROUTERS_AVAILABLE') .and.to.have.property('code', 'ERR_NO_ROUTERS_AVAILABLE')
}) })
}) })
@ -87,8 +87,11 @@ describe('content-routing', () => {
sinon.stub(nodes[0]._dht, 'findProviders').callsFake(function * () { sinon.stub(nodes[0]._dht, 'findProviders').callsFake(function * () {
deferred.resolve() deferred.resolve()
yield { yield {
id: providerPeerId, name: 'PROVIDER',
multiaddrs: [] providers: [{
id: providerPeerId,
multiaddrs: []
}]
} }
}) })
@ -238,7 +241,7 @@ describe('content-routing', () => {
try { try {
for await (const _ of node.contentRouting.findProviders(cid)) { } // eslint-disable-line for await (const _ of node.contentRouting.findProviders(cid)) { } // eslint-disable-line
throw new Error('should handle errors when finding providers') throw new Error('should handle errors when finding providers')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
} }
@ -361,7 +364,12 @@ describe('content-routing', () => {
} }
sinon.stub(node._dht, 'findProviders').callsFake(async function * () { sinon.stub(node._dht, 'findProviders').callsFake(async function * () {
yield result1 yield {
name: 'PROVIDER',
providers: [
result1
]
}
}) })
sinon.stub(delegate, 'findProviders').callsFake(async function * () { sinon.stub(delegate, 'findProviders').callsFake(async function * () {
yield result2 yield result2
@ -382,7 +390,8 @@ describe('content-routing', () => {
const dhtDeferred = pDefer() const dhtDeferred = pDefer()
const delegatedDeferred = pDefer() const delegatedDeferred = pDefer()
sinon.stub(node._dht, 'provide').callsFake(() => { sinon.stub(node._dht, 'provide').callsFake(async function * () {
yield
dhtDeferred.resolve() dhtDeferred.resolve()
}) })
@ -406,7 +415,12 @@ describe('content-routing', () => {
}] }]
sinon.stub(node._dht, 'findProviders').callsFake(function * () { sinon.stub(node._dht, 'findProviders').callsFake(function * () {
yield results[0] yield {
name: 'PROVIDER',
providers: [
results[0]
]
}
}) })
sinon.stub(delegate, 'findProviders').callsFake(function * () { // eslint-disable-line require-yield sinon.stub(delegate, 'findProviders').callsFake(function * () { // eslint-disable-line require-yield

View File

@ -38,13 +38,13 @@ describe('DHT subsystem is configurable', () => {
}) })
libp2p = await create(customOptions) libp2p = await create(customOptions)
expect(libp2p._dht.isStarted).to.equal(false) expect(libp2p._dht.isStarted()).to.equal(false)
await libp2p.start() await libp2p.start()
expect(libp2p._dht.isStarted).to.equal(true) expect(libp2p._dht.isStarted()).to.equal(true)
await libp2p.stop() await libp2p.stop()
expect(libp2p._dht.isStarted).to.equal(false) expect(libp2p._dht.isStarted()).to.equal(false)
}) })
it('should not start if disabled once libp2p starts', async () => { it('should not start if disabled once libp2p starts', async () => {
@ -63,10 +63,10 @@ describe('DHT subsystem is configurable', () => {
}) })
libp2p = await create(customOptions) libp2p = await create(customOptions)
expect(libp2p._dht.isStarted).to.equal(false) expect(libp2p._dht.isStarted()).to.equal(false)
await libp2p.start() await libp2p.start()
expect(libp2p._dht.isStarted).to.equal(false) expect(libp2p._dht.isStarted()).to.equal(false)
}) })
it('should allow a manual start', async () => { it('should allow a manual start', async () => {
@ -86,9 +86,9 @@ describe('DHT subsystem is configurable', () => {
libp2p = await create(customOptions) libp2p = await create(customOptions)
await libp2p.start() await libp2p.start()
expect(libp2p._dht.isStarted).to.equal(false) expect(libp2p._dht.isStarted()).to.equal(false)
await libp2p._dht.start() await libp2p._dht.start()
expect(libp2p._dht.isStarted).to.equal(true) expect(libp2p._dht.isStarted()).to.equal(true)
}) })
}) })

View File

@ -60,8 +60,8 @@ describe('DHT subsystem operates correctly', () => {
expect(connection).to.exist() expect(connection).to.exist()
return Promise.all([ return Promise.all([
pWaitFor(() => libp2p._dht.routingTable.size === 1), pWaitFor(() => libp2p._dht._lan._routingTable.size === 1),
pWaitFor(() => remoteLibp2p._dht.routingTable.size === 1) pWaitFor(() => remoteLibp2p._dht._lan._routingTable.size === 1)
]) ])
}) })
@ -71,14 +71,14 @@ describe('DHT subsystem operates correctly', () => {
await libp2p.dialProtocol(remAddr, subsystemMulticodecs) await libp2p.dialProtocol(remAddr, subsystemMulticodecs)
await Promise.all([ await Promise.all([
pWaitFor(() => libp2p._dht.routingTable.size === 1), pWaitFor(() => libp2p._dht._lan._routingTable.size === 1),
pWaitFor(() => remoteLibp2p._dht.routingTable.size === 1) pWaitFor(() => remoteLibp2p._dht._lan._routingTable.size === 1)
]) ])
await libp2p.contentRouting.put(key, value) await libp2p.contentRouting.put(key, value)
const fetchedValue = await remoteLibp2p.contentRouting.get(key)
expect(fetchedValue).to.eql(value) const fetchedValue = await remoteLibp2p.contentRouting.get(key)
expect(fetchedValue).to.have.property('val').that.equalBytes(value)
}) })
}) })
@ -119,11 +119,13 @@ describe('DHT subsystem operates correctly', () => {
const connection = await libp2p.dial(remAddr) const connection = await libp2p.dial(remAddr)
expect(connection).to.exist() expect(connection).to.exist()
expect(libp2p._dht.routingTable.size).to.be.eql(0) expect(libp2p._dht._lan._routingTable.size).to.be.eql(0)
expect(remoteLibp2p._dht.routingTable.size).to.be.eql(0)
await remoteLibp2p._dht.start() await remoteLibp2p._dht.start()
return pWaitFor(() => libp2p._dht.routingTable.size === 1) // should be 0 directly after start - TODO this may be susceptible to timing bugs, we should have
// the ability to report stats on the DHT routing table instead of reaching into it's heart like this
expect(remoteLibp2p._dht._lan._routingTable.size).to.be.eql(0)
return pWaitFor(() => libp2p._dht._lan._routingTable.size === 1)
}) })
it('should put on a peer and get from the other', async () => { it('should put on a peer and get from the other', async () => {
@ -133,12 +135,12 @@ describe('DHT subsystem operates correctly', () => {
const value = uint8ArrayFromString('world') const value = uint8ArrayFromString('world')
await remoteLibp2p._dht.start() await remoteLibp2p._dht.start()
await pWaitFor(() => libp2p._dht.routingTable.size === 1) await pWaitFor(() => libp2p._dht._lan._routingTable.size === 1)
await libp2p.contentRouting.put(key, value) await libp2p.contentRouting.put(key, value)
const fetchedValue = await remoteLibp2p.contentRouting.get(key) const fetchedValue = await remoteLibp2p.contentRouting.get(key)
expect(fetchedValue).to.eql(value) expect(fetchedValue).to.have.property('val').that.equalBytes(value)
}) })
}) })
}) })

View File

@ -1,7 +1,6 @@
'use strict' 'use strict'
const KadDht = require('libp2p-kad-dht') const KadDht = require('libp2p-kad-dht')
const { multicodec } = require('libp2p-kad-dht')
const Crypto = require('../../../src/insecure/plaintext') const Crypto = require('../../../src/insecure/plaintext')
const Muxer = require('libp2p-mplex') const Muxer = require('libp2p-mplex')
const Transport = require('libp2p-tcp') const Transport = require('libp2p-tcp')
@ -25,13 +24,12 @@ const subsystemOptions = mergeOptions(baseOptions, {
config: { config: {
dht: { dht: {
kBucketSize: 20, kBucketSize: 20,
randomWalk: {
enabled: true
},
enabled: true enabled: true
} }
} }
}) })
module.exports.subsystemOptions = subsystemOptions module.exports.subsystemOptions = subsystemOptions
module.exports.subsystemMulticodecs = [multicodec] module.exports.subsystemMulticodecs = [
'/ipfs/lan/kad/1.0.0'
]

View File

@ -13,9 +13,6 @@ const routingOptions = mergeOptions(baseOptions, {
config: { config: {
dht: { dht: {
kBucketSize: 20, kBucketSize: 20,
randomWalk: {
enabled: true
},
enabled: true enabled: true
} }
} }

View File

@ -125,7 +125,7 @@ describe('Dial Request', () => {
try { try {
await dialRequest.run({ signal: controller.signal }) await dialRequest.run({ signal: controller.signal })
expect.fail('Should have thrown') expect.fail('Should have thrown')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.be.an.instanceof(AggregateError) expect(err).to.be.an.instanceof(AggregateError)
} }
@ -162,7 +162,7 @@ describe('Dial Request', () => {
try { try {
await dialRequest.run({ signal: controller.signal }) await dialRequest.run({ signal: controller.signal })
expect.fail('Should have thrown') expect.fail('Should have thrown')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.be.an.instanceof(AggregateError) expect(err).to.be.an.instanceof(AggregateError)
} }
@ -212,7 +212,7 @@ describe('Dial Request', () => {
setTimeout(() => controller.abort(), 100) setTimeout(() => controller.abort(), 100)
await dialRequest.run({ signal: controller.signal }) await dialRequest.run({ signal: controller.signal })
expect.fail('dial should have failed') expect.fail('dial should have failed')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.be.an.instanceof(AggregateError) expect(err).to.be.an.instanceof(AggregateError)
} }

View File

@ -277,7 +277,7 @@ describe('Dialing (direct, TCP)', () => {
try { try {
await libp2p.dial(remoteLibp2p.transportManager.getAddrs()[0]) await libp2p.dial(remoteLibp2p.transportManager.getAddrs()[0])
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.have.property('code', ErrorCodes.ERR_INVALID_MULTIADDR) expect(err).to.have.property('code', ErrorCodes.ERR_INVALID_MULTIADDR)
return return
} }

View File

@ -304,7 +304,7 @@ describe('Dialing (direct, WebSockets)', () => {
dialer.destroy() dialer.destroy()
await dialPromise await dialPromise
expect.fail('should have failed') expect.fail('should have failed')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.be.an.instanceof(AggregateError) expect(err).to.be.an.instanceof(AggregateError)
expect(dialer._pendingDials.size).to.equal(0) // 1 dial request expect(dialer._pendingDials.size).to.equal(0) // 1 dial request
} }

View File

@ -296,7 +296,7 @@ describe('keychain', () => {
it('requires plain data as a Uint8Array', async () => { it('requires plain data as a Uint8Array', async () => {
const err = await ks.cms.encrypt(rsaKeyName, 'plain data').then(fail, err => err) const err = await ks.cms.encrypt(rsaKeyName, 'plain data').then(fail, err => err)
expect(err).to.exist() expect(err).to.exist()
expect(err).to.have.property('code', 'ERR_INVALID_PARAMS') expect(err).to.have.property('code', 'ERR_INVALID_PARAMETERS')
}) })
it('encrypts', async () => { it('encrypts', async () => {
@ -308,7 +308,7 @@ describe('keychain', () => {
it('is a PKCS #7 message', async () => { it('is a PKCS #7 message', async () => {
const err = await ks.cms.decrypt('not CMS').then(fail, err => err) const err = await ks.cms.decrypt('not CMS').then(fail, err => err)
expect(err).to.exist() expect(err).to.exist()
expect(err).to.have.property('code', 'ERR_INVALID_PARAMS') expect(err).to.have.property('code', 'ERR_INVALID_PARAMETERS')
}) })
it('is a PKCS #7 binary message', async () => { it('is a PKCS #7 binary message', async () => {
@ -519,7 +519,7 @@ describe('keychain', () => {
it('should validate newPass is a string', async () => { it('should validate newPass is a string', async () => {
try { try {
await kc.rotateKeychainPass(oldPass, 1234567890) await kc.rotateKeychainPass(oldPass, 1234567890)
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
} }
}) })
@ -527,7 +527,7 @@ describe('keychain', () => {
it('should validate oldPass is a string', async () => { it('should validate oldPass is a string', async () => {
try { try {
await kc.rotateKeychainPass(1234, 'newInsecurePassword1') await kc.rotateKeychainPass(1234, 'newInsecurePassword1')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
} }
}) })
@ -535,7 +535,7 @@ describe('keychain', () => {
it('should validate newPass is at least 20 characters', async () => { it('should validate newPass is at least 20 characters', async () => {
try { try {
await kc.rotateKeychainPass(oldPass, 'not20Chars') await kc.rotateKeychainPass(oldPass, 'not20Chars')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
} }
}) })
@ -586,7 +586,7 @@ describe('libp2p.keychain', () => {
try { try {
await libp2p.keychain.createKey('keyName', 'rsa', 2048) await libp2p.keychain.createKey('keyName', 'rsa', 2048)
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
return return
} }

View File

@ -3,9 +3,6 @@
const { expect } = require('aegir/utils/chai') const { expect } = require('aegir/utils/chai')
const sinon = require('sinon') const sinon = require('sinon')
const { EventEmitter } = require('events')
const { randomBytes } = require('libp2p-crypto') const { randomBytes } = require('libp2p-crypto')
const duplexPair = require('it-pair/duplex') const duplexPair = require('it-pair/duplex')
const pipe = require('it-pipe') const pipe = require('it-pipe')
@ -34,8 +31,7 @@ describe('Metrics', () => {
const [local, remote] = duplexPair() const [local, remote] = duplexPair()
const metrics = new Metrics({ const metrics = new Metrics({
computeThrottleMaxQueueSize: 1, // compute after every message computeThrottleMaxQueueSize: 1, // compute after every message
movingAverageIntervals: [10, 100, 1000], movingAverageIntervals: [10, 100, 1000]
connectionManager: new EventEmitter()
}) })
metrics.trackStream({ metrics.trackStream({
@ -70,8 +66,7 @@ describe('Metrics', () => {
const [local, remote] = duplexPair() const [local, remote] = duplexPair()
const metrics = new Metrics({ const metrics = new Metrics({
computeThrottleMaxQueueSize: 1, // compute after every message computeThrottleMaxQueueSize: 1, // compute after every message
movingAverageIntervals: [10, 100, 1000], movingAverageIntervals: [10, 100, 1000]
connectionManager: new EventEmitter()
}) })
metrics.trackStream({ metrics.trackStream({
@ -119,8 +114,7 @@ describe('Metrics', () => {
const [local2, remote2] = duplexPair() const [local2, remote2] = duplexPair()
const metrics = new Metrics({ const metrics = new Metrics({
computeThrottleMaxQueueSize: 1, // compute after every message computeThrottleMaxQueueSize: 1, // compute after every message
movingAverageIntervals: [10, 100, 1000], movingAverageIntervals: [10, 100, 1000]
connectionManager: new EventEmitter()
}) })
const protocol = '/echo/1.0.0' const protocol = '/echo/1.0.0'
metrics.start() metrics.start()
@ -175,8 +169,7 @@ describe('Metrics', () => {
const [local, remote] = duplexPair() const [local, remote] = duplexPair()
const metrics = new Metrics({ const metrics = new Metrics({
computeThrottleMaxQueueSize: 1, // compute after every message computeThrottleMaxQueueSize: 1, // compute after every message
movingAverageIntervals: [10, 100, 1000], movingAverageIntervals: [10, 100, 1000]
connectionManager: new EventEmitter()
}) })
metrics.start() metrics.start()
@ -231,8 +224,7 @@ describe('Metrics', () => {
})) }))
const metrics = new Metrics({ const metrics = new Metrics({
maxOldPeersRetention: 5, // Only keep track of 5 maxOldPeersRetention: 5 // Only keep track of 5
connectionManager: new EventEmitter()
}) })
// Clone so trackedPeers isn't modified // Clone so trackedPeers isn't modified
@ -262,4 +254,22 @@ describe('Metrics', () => {
expect(spy).to.have.property('callCount', 1) expect(spy).to.have.property('callCount', 1)
} }
}) })
it('should allow components to track metrics', () => {
const metrics = new Metrics({
maxOldPeersRetention: 5 // Only keep track of 5
})
expect(metrics.getComponentMetrics()).to.be.empty()
const component = 'my-component'
const metric = 'some-metric'
const value = 1
metrics.updateComponentMetric(component, metric, value)
expect(metrics.getComponentMetrics()).to.have.lengthOf(1)
expect(metrics.getComponentMetrics().get(component)).to.have.lengthOf(1)
expect(metrics.getComponentMetrics().get(component).get(metric)).to.equal(value)
})
}) })

View File

@ -244,6 +244,10 @@ describe('Nat Manager (TCP)', () => {
}) })
it('shuts the nat api down when stopping', async function () { it('shuts the nat api down when stopping', async function () {
if (process.env.CI) {
return this.skip('CI environments will not let us map external ports')
}
function findRoutableAddress () { function findRoutableAddress () {
const interfaces = networkInterfaces() const interfaces = networkInterfaces()
@ -261,7 +265,7 @@ describe('Nat Manager (TCP)', () => {
if (!addr) { if (!addr) {
// skip test if no non-loopback address is found // skip test if no non-loopback address is found
this.skip() return this.skip()
} }
const { const {

View File

@ -161,20 +161,13 @@ describe('peer discovery scenarios', () => {
autoDial: false autoDial: false
}, },
dht: { dht: {
randomWalk: {
enabled: false,
delay: 1000, // start the first query quickly
interval: 10000,
timeout: 5000
},
enabled: true enabled: true
} }
} }
}) })
const localConfig = getConfig(peerId) const localConfig = getConfig(peerId)
// Only run random walk on our local node
localConfig.config.dht.randomWalk.enabled = true
libp2p = new Libp2p(localConfig) libp2p = new Libp2p(localConfig)
const remoteLibp2p1 = new Libp2p(getConfig(remotePeerId1)) const remoteLibp2p1 = new Libp2p(getConfig(remotePeerId1))

View File

@ -36,16 +36,16 @@ describe('peer-routing', () => {
it('.findPeer should return an error', async () => { it('.findPeer should return an error', async () => {
await expect(node.peerRouting.findPeer('a cid')) await expect(node.peerRouting.findPeer('a cid'))
.to.eventually.be.rejected() .to.eventually.be.rejected()
.and.to.have.property('code', 'NO_ROUTERS_AVAILABLE') .and.to.have.property('code', 'ERR_NO_ROUTERS_AVAILABLE')
}) })
it('.getClosestPeers should return an error', async () => { it('.getClosestPeers should return an error', async () => {
try { try {
for await (const _ of node.peerRouting.getClosestPeers('a cid')) { } // eslint-disable-line for await (const _ of node.peerRouting.getClosestPeers('a cid')) { } // eslint-disable-line
throw new Error('.getClosestPeers should return an error') throw new Error('.getClosestPeers should return an error')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
expect(err.code).to.equal('NO_ROUTERS_AVAILABLE') expect(err.code).to.equal('ERR_NO_ROUTERS_AVAILABLE')
} }
}) })
}) })
@ -72,33 +72,38 @@ describe('peer-routing', () => {
after(() => Promise.all(nodes.map((n) => n.stop()))) after(() => Promise.all(nodes.map((n) => n.stop())))
it('should use the nodes dht', () => { it('should use the nodes dht', async () => {
const deferred = pDefer() sinon.stub(nodes[0]._dht, 'findPeer').callsFake(async function * () {
sinon.stub(nodes[0]._dht, 'findPeer').callsFake(() => {
deferred.resolve()
return nodes[1].peerId
})
nodes[0].peerRouting.findPeer()
return deferred.promise
})
it('should use the nodes dht to get the closest peers', async () => {
const deferred = pDefer()
const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
sinon.stub(nodes[0]._dht, 'getClosestPeers').callsFake(function * () {
deferred.resolve()
yield { yield {
id: remotePeerId, name: 'PEER_RESPONSE',
multiaddrs: [] closer: [{
id: nodes[1].peerId,
multiaddrs: []
}]
} }
}) })
await nodes[0].peerRouting.getClosestPeers().next() expect(nodes[0]._dht.findPeer.called).to.be.false()
await nodes[0].peerRouting.findPeer(nodes[1].peerId)
expect(nodes[0]._dht.findPeer.called).to.be.true()
nodes[0]._dht.findPeer.restore()
})
return deferred.promise it('should use the nodes dht to get the closest peers', async () => {
sinon.stub(nodes[0]._dht, 'getClosestPeers').callsFake(async function * () {
yield {
name: 'PEER_RESPONSE',
closer: [{
id: nodes[1].peerId,
multiaddrs: []
}]
}
})
expect(nodes[0]._dht.getClosestPeers.called).to.be.false()
await drain(nodes[0].peerRouting.getClosestPeers(nodes[1].peerId))
expect(nodes[0]._dht.getClosestPeers.called).to.be.true()
nodes[0]._dht.getClosestPeers.restore()
}) })
it('should error when peer tries to find itself', async () => { it('should error when peer tries to find itself', async () => {
@ -106,6 +111,95 @@ describe('peer-routing', () => {
.to.eventually.be.rejected() .to.eventually.be.rejected()
.and.to.have.property('code', 'ERR_FIND_SELF') .and.to.have.property('code', 'ERR_FIND_SELF')
}) })
it('should handle error thrown synchronously during find peer', async () => {
const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
nodes[0].peerRouting._routers = [{
findPeer () {
throw new Error('Thrown sync')
}
}]
await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
.to.eventually.be.rejected()
.and.to.have.property('code', 'ERR_NOT_FOUND')
})
it('should handle error thrown asynchronously during find peer', async () => {
const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
nodes[0].peerRouting._routers = [{
async findPeer () {
throw new Error('Thrown async')
}
}]
await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
.to.eventually.be.rejected()
.and.to.have.property('code', 'ERR_NOT_FOUND')
})
it('should handle error thrown asynchronously after delay during find peer', async () => {
const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
nodes[0].peerRouting._routers = [{
async findPeer () {
await delay(100)
throw new Error('Thrown async after delay')
}
}]
await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
.to.eventually.be.rejected()
.and.to.have.property('code', 'ERR_NOT_FOUND')
})
it('should return value when one router errors synchronously and another returns a value', async () => {
const [peer] = await peerUtils.createPeerId({ number: 1, fixture: false })
nodes[0].peerRouting._routers = [{
findPeer () {
throw new Error('Thrown sync')
}
}, {
async findPeer () {
return Promise.resolve({
id: peer,
multiaddrs: []
})
}
}]
await expect(nodes[0].peerRouting.findPeer(peer))
.to.eventually.deep.equal({
id: peer,
multiaddrs: []
})
})
it('should return value when one router errors asynchronously and another returns a value', async () => {
const [peer] = await peerUtils.createPeerId({ number: 1, fixture: false })
nodes[0].peerRouting._routers = [{
async findPeer () {
throw new Error('Thrown sync')
}
}, {
async findPeer () {
return Promise.resolve({
id: peer,
multiaddrs: []
})
}
}]
await expect(nodes[0].peerRouting.findPeer(peer))
.to.eventually.deep.equal({
id: peer,
multiaddrs: []
})
})
}) })
describe('via delegate router', () => { describe('via delegate router', () => {
@ -145,36 +239,35 @@ describe('peer-routing', () => {
}) })
it('should use the delegate router to find peers', async () => { it('should use the delegate router to find peers', async () => {
const deferred = pDefer()
const [remotePeerId] = await peerUtils.createPeerId({ fixture: false }) const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
sinon.stub(delegate, 'findPeer').callsFake(() => { sinon.stub(delegate, 'findPeer').callsFake(() => {
deferred.resolve()
return { return {
id: remotePeerId, id: remotePeerId,
multiaddrs: [] multiaddrs: []
} }
}) })
await node.peerRouting.findPeer() expect(delegate.findPeer.called).to.be.false()
return deferred.promise await node.peerRouting.findPeer(remotePeerId)
expect(delegate.findPeer.called).to.be.true()
delegate.findPeer.restore()
}) })
it('should use the delegate router to get the closest peers', async () => { it('should use the delegate router to get the closest peers', async () => {
const deferred = pDefer()
const [remotePeerId] = await peerUtils.createPeerId({ fixture: false }) const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
sinon.stub(delegate, 'getClosestPeers').callsFake(function * () { sinon.stub(delegate, 'getClosestPeers').callsFake(function * () {
deferred.resolve()
yield { yield {
id: remotePeerId, id: remotePeerId,
multiaddrs: [] multiaddrs: []
} }
}) })
await node.peerRouting.getClosestPeers().next() expect(delegate.getClosestPeers.called).to.be.false()
await drain(node.peerRouting.getClosestPeers(remotePeerId))
return deferred.promise expect(delegate.getClosestPeers.called).to.be.true()
delegate.getClosestPeers.restore()
}) })
it('should be able to find a peer', async () => { it('should be able to find a peer', async () => {
@ -200,7 +293,7 @@ describe('peer-routing', () => {
}) })
it('should error when a peer cannot be found', async () => { it('should error when a peer cannot be found', async () => {
const peerKey = 'key of a peer not on the network' const peerId = await PeerId.create({ keyType: 'ed25519' })
const mockApi = nock('http://0.0.0.0:60197') const mockApi = nock('http://0.0.0.0:60197')
.post('/api/v0/dht/findpeer') .post('/api/v0/dht/findpeer')
.query(true) .query(true)
@ -209,20 +302,20 @@ describe('peer-routing', () => {
'X-Chunked-Output', '1' 'X-Chunked-Output', '1'
]) ])
await expect(node.peerRouting.findPeer(peerKey)) await expect(node.peerRouting.findPeer(peerId))
.to.eventually.be.rejected() .to.eventually.be.rejected()
expect(mockApi.isDone()).to.equal(true) expect(mockApi.isDone()).to.equal(true)
}) })
it('should handle errors from the api', async () => { it('should handle errors from the api', async () => {
const peerKey = 'key of a peer not on the network' const peerId = await PeerId.create({ keyType: 'ed25519' })
const mockApi = nock('http://0.0.0.0:60197') const mockApi = nock('http://0.0.0.0:60197')
.post('/api/v0/dht/findpeer') .post('/api/v0/dht/findpeer')
.query(true) .query(true)
.reply(502) .reply(502)
await expect(node.peerRouting.findPeer(peerKey)) await expect(node.peerRouting.findPeer(peerId))
.to.eventually.be.rejected() .to.eventually.be.rejected()
expect(mockApi.isDone()).to.equal(true) expect(mockApi.isDone()).to.equal(true)
@ -230,7 +323,6 @@ describe('peer-routing', () => {
it('should be able to get the closest peers', async () => { it('should be able to get the closest peers', async () => {
const peerId = await PeerId.create({ keyType: 'ed25519' }) const peerId = await PeerId.create({ keyType: 'ed25519' })
const closest1 = '12D3KooWLewYMMdGWAtuX852n4rgCWkK7EBn4CWbwwBzhsVoKxk3' const closest1 = '12D3KooWLewYMMdGWAtuX852n4rgCWkK7EBn4CWbwwBzhsVoKxk3'
const closest2 = '12D3KooWDtoQbpKhtnWddfj72QmpFvvLDTsBLTFkjvgQm6cde2AK' const closest2 = '12D3KooWDtoQbpKhtnWddfj72QmpFvvLDTsBLTFkjvgQm6cde2AK'
@ -249,15 +341,12 @@ describe('peer-routing', () => {
'X-Chunked-Output', '1' 'X-Chunked-Output', '1'
]) ])
const closestPeers = [] const closestPeers = await all(node.peerRouting.getClosestPeers(peerId.id, { timeout: 1000 }))
for await (const peer of node.peerRouting.getClosestPeers(peerId.id, { timeout: 1000 })) {
closestPeers.push(peer)
}
expect(closestPeers).to.have.length(2) expect(closestPeers).to.have.length(2)
expect(closestPeers[0].id.toB58String()).to.equal(closest2) expect(closestPeers[0].id.toB58String()).to.equal(closest1)
expect(closestPeers[0].multiaddrs).to.have.lengthOf(2) expect(closestPeers[0].multiaddrs).to.have.lengthOf(2)
expect(closestPeers[1].id.toB58String()).to.equal(closest1) expect(closestPeers[1].id.toB58String()).to.equal(closest2)
expect(closestPeers[1].multiaddrs).to.have.lengthOf(2) expect(closestPeers[1].multiaddrs).to.have.lengthOf(2)
expect(mockApi.isDone()).to.equal(true) expect(mockApi.isDone()).to.equal(true)
}) })
@ -275,7 +364,7 @@ describe('peer-routing', () => {
try { try {
for await (const _ of node.peerRouting.getClosestPeers(peerId.id)) { } // eslint-disable-line for await (const _ of node.peerRouting.getClosestPeers(peerId.id)) { } // eslint-disable-line
throw new Error('should handle errors when getting the closest peers') throw new Error('should handle errors when getting the closest peers')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
} }
@ -316,7 +405,7 @@ describe('peer-routing', () => {
multiaddrs: [] multiaddrs: []
} }
sinon.stub(node._dht, 'findPeer').callsFake(() => {}) sinon.stub(node._dht, 'findPeer').callsFake(async function * () {})
sinon.stub(delegate, 'findPeer').callsFake(() => { sinon.stub(delegate, 'findPeer').callsFake(() => {
return results return results
}) })
@ -334,7 +423,8 @@ describe('peer-routing', () => {
const defer = pDefer() const defer = pDefer()
sinon.stub(node._dht, 'findPeer').callsFake(async () => { sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
yield
await defer.promise await defer.promise
}) })
sinon.stub(delegate, 'findPeer').callsFake(() => { sinon.stub(delegate, 'findPeer').callsFake(() => {
@ -349,29 +439,34 @@ describe('peer-routing', () => {
it('should not wait for the delegate to return if the dht does first', async () => { it('should not wait for the delegate to return if the dht does first', async () => {
const [remotePeerId] = await peerUtils.createPeerId({ fixture: false }) const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
const results = { const result = {
id: remotePeerId, id: remotePeerId,
multiaddrs: [] multiaddrs: []
} }
const defer = pDefer() const defer = pDefer()
sinon.stub(node._dht, 'findPeer').callsFake(() => { sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
return results yield {
name: 'PEER_RESPONSE',
closer: [
result
]
}
}) })
sinon.stub(delegate, 'findPeer').callsFake(async () => { sinon.stub(delegate, 'findPeer').callsFake(async () => {
await defer.promise await defer.promise
}) })
const peer = await node.peerRouting.findPeer(remotePeerId) const peer = await node.peerRouting.findPeer(remotePeerId)
expect(peer).to.eql(results) expect(peer).to.eql(result)
defer.resolve() defer.resolve()
}) })
it('should store the addresses of the found peer', async () => { it('should store the addresses of the found peer', async () => {
const [remotePeerId] = await peerUtils.createPeerId({ fixture: false }) const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
const results = { const result = {
id: remotePeerId, id: remotePeerId,
multiaddrs: [ multiaddrs: [
new Multiaddr('/ip4/123.123.123.123/tcp/38982') new Multiaddr('/ip4/123.123.123.123/tcp/38982')
@ -380,14 +475,19 @@ describe('peer-routing', () => {
const spy = sinon.spy(node.peerStore.addressBook, 'add') const spy = sinon.spy(node.peerStore.addressBook, 'add')
sinon.stub(node._dht, 'findPeer').callsFake(() => { sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
return results yield {
name: 'PEER_RESPONSE',
closer: [
result
]
}
}) })
sinon.stub(delegate, 'findPeer').callsFake(() => {}) sinon.stub(delegate, 'findPeer').callsFake(() => {})
await node.peerRouting.findPeer(remotePeerId) await node.peerRouting.findPeer(remotePeerId)
expect(spy.calledWith(results.id, results.multiaddrs)).to.be.true() expect(spy.calledWith(result.id, result.multiaddrs)).to.be.true()
}) })
it('should use the delegate if the dht fails to get the closest peer', async () => { it('should use the delegate if the dht fails to get the closest peer', async () => {
@ -487,8 +587,18 @@ describe('peer-routing', () => {
sinon.spy(node.peerStore.addressBook, 'add') sinon.spy(node.peerStore.addressBook, 'add')
sinon.stub(node._dht, 'getClosestPeers').callsFake(function * () { sinon.stub(node._dht, 'getClosestPeers').callsFake(function * () {
yield results[0] yield {
yield results[1] name: 'PEER_RESPONSE',
closer: [
results[0]
]
}
yield {
name: 'PEER_RESPONSE',
closer: [
results[1]
]
}
}) })
await node.start() await node.start()
@ -522,7 +632,7 @@ describe('peer-routing', () => {
started: false started: false
}) })
sinon.stub(node._dht, 'getClosestPeers').callsFake(function * () { sinon.stub(node._dht, 'getClosestPeers').callsFake(async function * () {
yield yield
throw new Error('should not be called') throw new Error('should not be called')
}) })

View File

@ -13,9 +13,6 @@ const routingOptions = mergeOptions(baseOptions, {
config: { config: {
dht: { dht: {
kBucketSize: 20, kBucketSize: 20,
randomWalk: {
enabled: true
},
enabled: true enabled: true
} }
} }

View File

@ -45,7 +45,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
ab.set('invalid peerId') ab.set('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -55,7 +55,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if no addresses provided', () => { it('throwns invalid parameters error if no addresses provided', () => {
try { try {
ab.set(peerId) ab.set(peerId)
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -65,7 +65,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid multiaddrs are provided', () => { it('throwns invalid parameters error if invalid multiaddrs are provided', () => {
try { try {
ab.set(peerId, ['invalid multiaddr']) ab.set(peerId, ['invalid multiaddr'])
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -159,7 +159,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
ab.add('invalid peerId') ab.add('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -169,7 +169,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if no addresses provided', () => { it('throwns invalid parameters error if no addresses provided', () => {
try { try {
ab.add(peerId) ab.add(peerId)
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -179,7 +179,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid multiaddrs are provided', () => { it('throwns invalid parameters error if invalid multiaddrs are provided', () => {
try { try {
ab.add(peerId, ['invalid multiaddr']) ab.add(peerId, ['invalid multiaddr'])
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -308,7 +308,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
ab.get('invalid peerId') ab.get('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -343,7 +343,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
ab.getMultiaddrsForPeer('invalid peerId') ab.getMultiaddrsForPeer('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -391,7 +391,7 @@ describe('addressBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
ab.delete('invalid peerId') ab.delete('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }

View File

@ -23,7 +23,7 @@ describe('keyBook', () => {
it('throws invalid parameters error if invalid PeerId is provided in set', () => { it('throws invalid parameters error if invalid PeerId is provided in set', () => {
try { try {
kb.set('invalid peerId') kb.set('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -33,7 +33,7 @@ describe('keyBook', () => {
it('throws invalid parameters error if invalid PeerId is provided in get', () => { it('throws invalid parameters error if invalid PeerId is provided in get', () => {
try { try {
kb.get('invalid peerId') kb.get('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }

View File

@ -34,7 +34,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if invalid PeerId is provided', () => { it('throws invalid parameters error if invalid PeerId is provided', () => {
try { try {
mb.set('invalid peerId') mb.set('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -44,7 +44,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if no key provided', () => { it('throws invalid parameters error if no key provided', () => {
try { try {
mb.set(peerId) mb.set(peerId)
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -54,7 +54,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if no value provided', () => { it('throws invalid parameters error if no value provided', () => {
try { try {
mb.set(peerId, 'location') mb.set(peerId, 'location')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -64,7 +64,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if value is not a buffer', () => { it('throws invalid parameters error if value is not a buffer', () => {
try { try {
mb.set(peerId, 'location', 'mars') mb.set(peerId, 'location', 'mars')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -163,7 +163,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if invalid PeerId is provided', () => { it('throws invalid parameters error if invalid PeerId is provided', () => {
try { try {
mb.get('invalid peerId') mb.get('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -199,7 +199,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if invalid PeerId is provided', () => { it('throws invalid parameters error if invalid PeerId is provided', () => {
try { try {
mb.getValue('invalid peerId') mb.getValue('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -248,7 +248,7 @@ describe('metadataBook', () => {
it('throwns invalid parameters error if invalid PeerId is provided', () => { it('throwns invalid parameters error if invalid PeerId is provided', () => {
try { try {
mb.delete('invalid peerId') mb.delete('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }
@ -305,7 +305,7 @@ describe('metadataBook', () => {
it('throws invalid parameters error if invalid PeerId is provided', () => { it('throws invalid parameters error if invalid PeerId is provided', () => {
try { try {
mb.deleteValue('invalid peerId') mb.deleteValue('invalid peerId')
} catch (err) { } catch (/** @type {any} */ err) {
expect(err.code).to.equal(ERR_INVALID_PARAMETERS) expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
return return
} }

View File

@ -13,6 +13,7 @@ const { Multiaddr } = require('multiaddr')
const mockUpgrader = require('../utils/mockUpgrader') const mockUpgrader = require('../utils/mockUpgrader')
const sinon = require('sinon') const sinon = require('sinon')
const Peers = require('../fixtures/peers') const Peers = require('../fixtures/peers')
const pWaitFor = require('p-wait-for')
const addrs = [ const addrs = [
new Multiaddr('/ip4/127.0.0.1/tcp/0'), new Multiaddr('/ip4/127.0.0.1/tcp/0'),
new Multiaddr('/ip4/127.0.0.1/tcp/0') new Multiaddr('/ip4/127.0.0.1/tcp/0')
@ -72,9 +73,13 @@ describe('Transport Manager (TCP)', () => {
tm.add(Transport.prototype[Symbol.toStringTag], Transport) tm.add(Transport.prototype[Symbol.toStringTag], Transport)
await tm.listen(addrs) await tm.listen(addrs)
// Should created Self Peer record on new listen address // Should created Self Peer record on new listen address, but it is done async
signedPeerRecord = await tm.libp2p.peerStore.addressBook.getPeerRecord(localPeer) // with no event so we have to wait a bit
expect(signedPeerRecord).to.exist() await pWaitFor(async () => {
signedPeerRecord = await tm.libp2p.peerStore.addressBook.getPeerRecord(localPeer)
return signedPeerRecord != null
}, { interval: 100, timeout: 2000 })
const record = PeerRecord.createFromProtobuf(signedPeerRecord.payload) const record = PeerRecord.createFromProtobuf(signedPeerRecord.payload)
expect(record).to.exist() expect(record).to.exist()

View File

@ -201,7 +201,7 @@ describe('libp2p.transportManager (dial only)', () => {
try { try {
await libp2p.start() await libp2p.start()
} catch (err) { } catch (/** @type {any} */ err) {
expect(err).to.exist() expect(err).to.exist()
expect(err.code).to.equal(ErrorCodes.ERR_NO_VALID_ADDRESSES) expect(err.code).to.equal(ErrorCodes.ERR_NO_VALID_ADDRESSES)
return return

View File

@ -7,16 +7,16 @@
"libp2p": "file:../..", "libp2p": "file:../..",
"libp2p-bootstrap": "^0.13.0", "libp2p-bootstrap": "^0.13.0",
"libp2p-delegated-content-routing": "^0.11.0", "libp2p-delegated-content-routing": "^0.11.0",
"libp2p-delegated-peer-routing": "^0.10.0", "libp2p-delegated-peer-routing": "^0.11.1",
"libp2p-gossipsub": "^0.9.0", "libp2p-gossipsub": "^0.9.0",
"libp2p-interfaces": "^1.0.1", "libp2p-interfaces": "^1.0.1",
"libp2p-kad-dht": "^0.23.1", "libp2p-kad-dht": "^0.26.5",
"libp2p-mplex": "^0.10.4", "libp2p-mplex": "^0.10.4",
"@chainsafe/libp2p-noise": "^4.1.0", "@chainsafe/libp2p-noise": "^4.1.0",
"libp2p-record": "^0.10.4", "libp2p-record": "^0.10.4",
"libp2p-tcp": "^0.17.1", "libp2p-tcp": "^0.17.1",
"libp2p-websockets": "^0.16.1", "libp2p-websockets": "^0.16.1",
"peer-id": "^0.15.0" "peer-id": "^0.16.0"
}, },
"scripts": { "scripts": {
"build": "npx tsc", "build": "npx tsc",

View File

@ -123,11 +123,6 @@ async function main() {
dht: { dht: {
enabled: true, enabled: true,
kBucketSize: 20, kBucketSize: 20,
randomWalk: {
enabled: true, // Allows to disable discovery (enabled by default)
interval: 300e3,
timeout: 10e3
},
clientMode: true, clientMode: true,
validators: { validators: {
pk: Libp2pRecord.validator.validators.pk pk: Libp2pRecord.validator.validators.pk

View File

@ -108,7 +108,7 @@ function createConnection ({
// Need to be able to notify a peer of this this._onStream({ connection, stream, protocol }) // Need to be able to notify a peer of this this._onStream({ connection, stream, protocol })
const handler = protocols.get(protocol) const handler = protocols.get(protocol)
handler({ connection, stream, protocol }) handler({ connection, stream, protocol })
} catch (err) { } catch (/** @type {any} */ err) {
// Do nothing // Do nothing
} }
}, },
@ -124,7 +124,7 @@ function createConnection ({
try { try {
const { stream, protocol } = await mss.select(protocols) const { stream, protocol } = await mss.select(protocols)
return { stream: { ...muxedStream, ...stream }, protocol } return { stream: { ...muxedStream, ...stream }, protocol }
} catch (err) { } catch (/** @type {any} */ err) {
throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL) throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
} }
} }

View File

@ -1,5 +1,5 @@
{ {
"extends": "./node_modules/aegir/src/config/tsconfig.aegir.json", "extends": "aegir/src/config/tsconfig.aegir.json",
"compilerOptions": { "compilerOptions": {
"outDir": "dist" "outDir": "dist"
}, },