diff --git a/.github/dependabot.yml b/.github/dependabot.yml index de46e326..290ad028 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -4,5 +4,5 @@ updates: directory: "/" schedule: interval: daily - time: "11:00" + time: "10:00" open-pull-requests-limit: 10 diff --git a/.github/workflows/automerge.yml b/.github/workflows/automerge.yml new file mode 100644 index 00000000..13da9c15 --- /dev/null +++ b/.github/workflows/automerge.yml @@ -0,0 +1,50 @@ +# Automatically merge pull requests opened by web3-bot, as soon as (and only if) all tests pass. +# This reduces the friction associated with updating with our workflows. + +on: [ pull_request ] +name: Automerge + +jobs: + automerge-check: + if: github.event.pull_request.user.login == 'web3-bot' + runs-on: ubuntu-latest + outputs: + status: ${{ steps.should-automerge.outputs.status }} + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - name: Check if we should automerge + id: should-automerge + run: | + for commit in $(git rev-list --first-parent origin/${{ github.event.pull_request.base.ref }}..${{ github.event.pull_request.head.sha }}); do + committer=$(git show --format=$'%ce' -s $commit) + echo "Committer: $committer" + if [[ "$committer" != "web3-bot@users.noreply.github.com" ]]; then + echo "Commit $commit wasn't committed by web3-bot, but by $committer." + echo "::set-output name=status::false" + exit + fi + done + echo "::set-output name=status::true" + automerge: + needs: automerge-check + runs-on: ubuntu-latest + # The check for the user is redundant here, as this job depends on the automerge-check job, + # but it prevents this job from spinning up, just to be skipped shortly after. + if: github.event.pull_request.user.login == 'web3-bot' && needs.automerge-check.outputs.status == 'true' + steps: + - name: Wait on tests + uses: lewagon/wait-on-check-action@bafe56a6863672c681c3cf671f5e10b20abf2eaa # v0.2 + with: + ref: ${{ github.event.pull_request.head.sha }} + repo-token: ${{ secrets.GITHUB_TOKEN }} + wait-interval: 10 + running-workflow-name: 'automerge' # the name of this job + - name: Merge PR + uses: pascalgn/automerge-action@741c311a47881be9625932b0a0de1b0937aab1ae # v0.13.1 + env: + GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}" + MERGE_LABELS: "" + MERGE_METHOD: "squash" + MERGE_DELETE_BRANCH: true diff --git a/.github/workflows/js-test-and-release.yml b/.github/workflows/js-test-and-release.yml new file mode 100644 index 00000000..8630dc5c --- /dev/null +++ b/.github/workflows/js-test-and-release.yml @@ -0,0 +1,152 @@ +name: test & maybe release +on: + push: + branches: + - master # with #262 - ${{{ github.default_branch }}} + pull_request: + branches: + - master # with #262 - ${{{ github.default_branch }}} + +jobs: + + check: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present lint + - run: npm run --if-present dep-check + + test-node: + needs: check + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [windows-latest, ubuntu-latest, macos-latest] + node: [16] + fail-fast: true + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: ${{ matrix.node }} + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present test:node + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: node + + test-chrome: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present test:chrome + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: chrome + + test-chrome-webworker: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present test:chrome-webworker + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: chrome-webworker + + test-firefox: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present test:firefox + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: firefox + + test-firefox-webworker: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npm run --if-present test:firefox-webworker + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: firefox-webworker + + test-electron-main: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npx xvfb-maybe npm run --if-present test:electron-main + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: electron-main + + test-electron-renderer: + needs: check + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - run: npx xvfb-maybe npm run --if-present test:electron-renderer + - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0 + with: + directory: ./.nyc_output + flags: electron-renderer + + release: + needs: [test-node, test-chrome, test-chrome-webworker, test-firefox, test-firefox-webworker, test-electron-main, test-electron-renderer] + runs-on: ubuntu-latest + if: github.event_name == 'push' && github.ref == 'refs/heads/master' # with #262 - 'refs/heads/${{{ github.default_branch }}}' + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - uses: actions/setup-node@v2 + with: + node-version: lts/* + - uses: ipfs/aegir/actions/cache-node-modules@master + - uses: ipfs/aegir/actions/docker-login@master + with: + docker-token: ${{ secrets.DOCKER_TOKEN }} + docker-username: ${{ secrets.DOCKER_USERNAME }} + - run: npm run --if-present release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + NPM_TOKEN: ${{ secrets.NPM_TOKEN }} diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml deleted file mode 100644 index 58ce5eb8..00000000 --- a/.github/workflows/main.yml +++ /dev/null @@ -1,34 +0,0 @@ -name: ci -on: - push: - branches: - - master - pull_request: - branches: - - master - -jobs: - check: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - run: npm install - - run: npx aegir lint - - run: npx aegir dep-check - test-node: - needs: check - runs-on: ${{ matrix.os }} - strategy: - matrix: - os: [windows-latest, ubuntu-latest, macos-latest] - node: [16] - fail-fast: true - steps: - - uses: actions/checkout@v2 - - uses: actions/setup-node@v1 - with: - node-version: ${{ matrix.node }} - - run: npm install @mapbox/node-pre-gyp -g - - run: npm install - - run: npx aegir test -t node --cov --bail - - uses: codecov/codecov-action@v1 \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..20ce483c --- /dev/null +++ b/LICENSE @@ -0,0 +1,4 @@ +This project is dual licensed under MIT and Apache-2.0. + +MIT: https://www.opensource.org/licenses/mit +Apache-2.0: https://www.apache.org/licenses/license-2.0 diff --git a/LICENSE-APACHE b/LICENSE-APACHE new file mode 100644 index 00000000..14478a3b --- /dev/null +++ b/LICENSE-APACHE @@ -0,0 +1,5 @@ +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. diff --git a/LICENSE-MIT b/LICENSE-MIT new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/LICENSE-MIT @@ -0,0 +1,19 @@ +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/README.md b/README.md index b54b5445..f6d74c09 100644 --- a/README.md +++ b/README.md @@ -1,43 +1,30 @@ -libp2p-daemon JavaScript implementation -====== +# JS libp2p Interfaces - - - - +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai) +[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/) +[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p) +[![](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io) +[![codecov](https://img.shields.io/codecov/c/github/libp2p/js-libp2p-interfaces.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-interfaces) +[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/libp2p/js-libp2p-interfaces/ci?label=ci&style=flat-square)](https://github.com/libp2p/js-libp2p-interfaces/actions?query=branch%3Amaster+workflow%3Aci+) -> A standalone deployment of a libp2p host, running in its own OS process and installing a set of virtual endpoints to enable co-local applications to: communicate with peers, handle protocols, interact with the DHT, participate in pubsub, etc. no matter the language they are developed in, nor whether a native libp2p implementation exists in that language. +> Contains test suites and interfaces you can use to implement the various components of libp2p -## Lead Maintainer +## Structure -[Jacob Heun](https://github.com/jacobheun) +* [`/packages/libp2p-connection`](./packages/libp2p-connection) An implementation of the Connection interface +* [`/packages/libp2p-interfaces`](./packages/libp2p-interfaces) The interface definitions of various libp2p components +* [`/packages/libp2p-interfaces-compliance-tests`](./packages/libp2p-interfaces-compliance-tests) Tests to ensure adherence of an implementation to the spec +* [`/packages/libp2p-pubsub`](./packages/libp2p-pubsub) An implementation of the Pubsub interface +* [`/packages/libp2p-topology`](./packages/libp2p-topology) An implementation of the Topology interface -## Specs - -The specs for the daemon are currently housed in the go implementation. You can read them at [libp2p/go-libp2p-daemon](https://github.com/libp2p/go-libp2p-daemon/blob/master/specs/README.md) - -## Install - -``` -npm i -g libp2p-daemon -``` - -## Usage - -For a full list of options, you can run help `jsp2pd --help`. -Running the defaults, `jsp2pd`, will start the daemon and bind it to a local unix socket path. -Daemon clients will be able to communicate with the daemon over that unix socket. - -As an alternative, you can use this daemon with a different version of libp2p as the one specified in `package.json`. You just need to define its path through an environment variable as follows: +## Contribute -```sh -export LIBP2P_JS=./../../js-libp2p/src/index.js -``` +Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/js-interfaces/issues)! -## Contribute +This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md). -This module is actively under development. Please check out the issues and submit PRs! +[![](https://cdn.rawgit.com/jbenet/contribute-ipfs-gif/master/img/contribute.gif)](https://github.com/ipfs/community/blob/master/contributing.md) ## License -MIT © Protocol Labs +[Apache-2.0](LICENSE-APACHE) or [MIT](LICENSE-MIT) © Protocol Labs diff --git a/lerna.json b/lerna.json new file mode 100644 index 00000000..aa6d0004 --- /dev/null +++ b/lerna.json @@ -0,0 +1,12 @@ +{ + "lerna": "4.0.0", + "packages": [ + "packages/*" + ], + "version": "independent", + "command": { + "run": { + "stream": true + } + } +} diff --git a/package.json b/package.json index 2e75172d..f3fe1071 100644 --- a/package.json +++ b/package.json @@ -1,85 +1,45 @@ { - "name": "libp2p-daemon", - "version": "0.10.2", - "description": "libp2p-daemon JavaScript implementation", - "type": "module", + "name": "js-libp2p-daemon", + "version": "1.0.0", + "description": "Standalone libp2p executable", + "license": "Apache-2.0 OR MIT", + "homepage": "https://github.com/libp2p/js-libp2p-daemon#readme", "repository": { "type": "git", - "url": "https://github.com/libp2p/js-libp2p-daemon.git" - }, - "files": [ - "dist", - "src" - ], - "exports": { - ".": { - "import": "./dist/src/index.js" - } - }, - "bin": { - "jsp2pd": "src/cli/bin.js" - }, - "scripts": { - "lint": "aegir lint", - "build": "tsc", - "postbuild": "mkdirp dist/src/protocol && cp src/protocol/*.js src/protocol/*.d.ts dist/src/protocol", - "generate": "npm run generate:proto && generate:proto-types", - "generate:proto": "pbjs -t static-module -w es6 -r libp2p-daemon --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/protocol/index.js ./src/protocol/index.proto", - "generate:proto-types": "pbts -o src/protocol/index.d.ts src/protocol/index.js", - "pretest": "npm run build", - "test": "aegir test -t node -f test/*.js test/**/*.js", - "test:node": "aegir test -t node -f test/*.js test/**/*.js", - "release": "semantic-release" - }, - "engines": { - "node": ">=16.0.0" + "url": "git+https://github.com/libp2p/js-libp2p-daemon.git" }, "bugs": { "url": "https://github.com/libp2p/js-libp2p-daemon/issues" }, - "homepage": "https://github.com/libp2p/js-libp2p-daemon", "keywords": [ + "interface", "libp2p" ], - "license": "MIT", - "devDependencies": { - "aegir": "^36.0.0", - "delay": "^5.0.0", - "it-pair": "^1.0.0", - "mocha": "^9.0.1", - "p-defer": "^3.0.0", - "sinon": "^12.0.1" + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + }, + "private": true, + "scripts": { + "reset": "lerna run clean && rimraf ./node_modules ./package-lock.json packages/*/node_modules packages/*/package-lock.json packages/*/dist", + "test": "lerna run --concurrency 1 test -- --", + "test:node": "lerna run --concurrency 1 test:node -- --", + "test:chrome": "lerna run --concurrency 1 test:chrome -- --", + "test:chrome-webworker": "lerna --concurrency 1 run test:chrome-webworker -- --", + "test:firefox": "lerna run --concurrency 1 test:firefox -- --", + "test:firefox-webworker": "lerna run --concurrency 1 test:firefox-webworker -- --", + "test:electron-main": "lerna run --concurrency 1 test:electron-main -- --", + "test:electron-renderer": "lerna run --concurrency 1 test:electron-renderer -- --", + "build": "lerna run build", + "lint": "lerna run lint", + "dep-check": "lerna run dep-check", + "release": "lerna exec --concurrency 1 -- semantic-release -e semantic-release-monorepo" }, "dependencies": { - "@chainsafe/libp2p-noise": "^5.0.0", - "it-all": "^1.0.6", - "it-buffer": "^0.1.3", - "it-handshake": "^2.0.0", - "it-length-prefixed": "^5.0.2", - "it-pipe": "^1.1.0", - "it-pushable": "^1.4.0", - "@multiformats/multiaddr": "^10.0.0", - "multiformats": "^9.4.2", - "promisify-es6": "^1.0.3", - "protobufjs": "^6.10.2", - "stream-to-it": "^0.2.0", - "streaming-iterables": "^6.0.0", - "uint8arrays": "^3.0.0", - "yargs": "^17.3.1", - "yargs-promise": "^1.1.0" + "lerna": "^4.0.0", + "rimraf": "^3.0.2" }, - "contributors": [ - "Jacob Heun ", - "Vasco Santos ", - "achingbrain ", - "Arve Knudsen ", - "Marin Petrunić " - ], - "eslintConfig": { - "extends": "ipfs", - "ignorePatterns": [ - "*.d.ts", - "src/profocol/index.js" - ] - } + "workspaces": [ + "packages/*" + ] } diff --git a/packages/libp2p-daemon-client/API.md b/packages/libp2p-daemon-client/API.md new file mode 100644 index 00000000..67732fea --- /dev/null +++ b/packages/libp2p-daemon-client/API.md @@ -0,0 +1,500 @@ +# API + +* [Getting started](#getting-started) +* [`close`](#close) +* [`connect`](#connect) +* [`identify`](#identify) +* [`listPeers`](#listPeers) +* [`openStream`](#openStream) +* [`registerStream`](#registerStream) +* [`dht.put`](#dht.put) +* [`dht.get`](#dht.get) +* [`dht.findPeer`](#dht.findPeer) +* [`dht.provide`](#dht.provide) +* [`dht.findProviders`](#dht.findProviders) +* [`dht.getClosestPeers`](#dht.getClosestPeers) +* [`dht.getPublicKey`](#dht.getPublicKey) +* [`pubsub.getTopics`](#pubsub.getTopics) +* [`pubsub.publish`](#pubsub.publish) +* [`pubsub.subscribe`](#pubsub.subscribe) + +## Getting started + +Create a new daemon client, using a unix socket. + +### `Client(socketPath)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| socketPath | `String` | unix socket path | + +#### Returns + +Client instance + +#### Example + +```js +const Client = require('libp2p-daemon-client') + +const defaultSock = '/tmp/p2pd.sock' +const client = new Client(defaultSock) + +// client.{} +``` + +## close + +Closes the socket. + +### `client.close()` + +#### Returns + +| Type | Description | +|------|-------------| +| `Promise` | Promise resolves when socket is closed | + +#### Example + +```js +const Client = require('libp2p-daemon-client') + +const defaultSock = '/tmp/p2pd.sock' +const client = new Client(defaultSock) + +// close the socket +await client.close() +``` + +## connect + +Requests a connection to a known peer on a given set of addresses. + +### `client.connect(peerId, addrs)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| peerId | [`PeerId`](https://github.com/libp2p/js-peer-id) | peer ID to connect | +| options | `Object` | set of addresses to connect | + +#### Example + +```js +const client = new Client(defaultSock) + +try { + await client.connect(peerId, addrs) +} catch (err) { + // +} +``` + +## identify + +Query the daemon for its peer ID and listen addresses. + +### `client.identify()` + +#### Returns + +| Type | Description | +|------|-------------| +| `Object` | Identify response | +| `Object.peerId` | Peer id of the daemon | +| `Object.addrs` | Addresses of the daemon | + +#### Example + +```js +const client = new Client(defaultSock) + +let identify + +try { + identify = await client.identify() +} catch (err) { + // +} +``` + +## listPeers + +Get a list of IDs of peers the node is connected to. + +### `client.listPeers()` + +#### Returns + +| Type | Description | +|------|-------------| +| `Array` | array of peer id's | +| `Array.` | Peer id of a node | + +#### Example + +```js +const client = new Client(defaultSock) + +let identify + +try { + identify = await client.identify() +} catch (err) { + // +} +``` + +## openStream + +Initiate an outbound stream to a peer on one of a set of protocols. + +### `client.openStream(peerId, protocol)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| peerId | [`PeerId`](https://github.com/libp2p/js-peer-id) | peer ID to connect | +| protocol | `string` | protocol to use | + +#### Returns + +| Type | Description | +|------|-------------| +| `Socket` | socket to write data | + +#### Example + +```js +const protocol = '/protocol/1.0.0' +const client = new Client(defaultSock) + +let socket + +try { + socket = await client.openStream(peerId, protocol) +} catch (err) { + // +} + +socket.write(uint8ArrayFromString('data')) +``` + +## registerStreamHandler + +Register a handler for inbound streams on a given protocol. + +### `client.registerStreamHandler(path, protocol)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| path | `string` | socket path | +| protocol | `string` | protocol to use | + +#### Example + +```js +const protocol = '/protocol/1.0.0' +const client = new Client(defaultSock) + +await client.registerStreamHandler(path, protocol) +``` + +## dht.put + +Write a value to a key in the DHT. + +### `client.dht.put(key, value)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| key | `Uint8Array` | key to add to the dht | +| value | `Uint8Array` | value to add to the dht | + +#### Example + +```js +const client = new Client(defaultSock) + +const key = '/key' +const value = uint8ArrayFromString('oh hello there') + +try { + await client.dht.put(key, value) +} catch (err) { + // +} +``` + +## dht.get + +Query the DHT for a value stored through a key in the DHT. + +### `client.dht.get(key)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| key | `Uint8Array` | key to get from the dht | + +#### Returns + +| Type | Description | +|------|-------------| +| `Uint8Array` | Value obtained from the DHT | + +#### Example + +```js +const client = new Client(defaultSock) + +const key = '/key' +let value + +try { + value = await client.dht.get(key, value) +} catch (err) { + // +} +``` + +## dht.findPeer + +Query the DHT for a given peer's known addresses. + +### `client.dht.findPeer(peerId)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| peerId | [`PeerId`](https://github.com/libp2p/js-peer-id) | ID of the peer to find | + +#### Returns + +| Type | Description | +|------|-------------| +| `PeerInfo` | Peer info of a known peer | + +#### Example + +```js +const client = new Client(defaultSock) + +let peerInfo + +try { + peerInfo = await client.dht.findPeer(peerId) +} catch (err) { + // +} +``` + +## dht.provide + +Announce that have data addressed by a given CID. + +### `client.dht.provide(cid)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| cid | [`CID`](https://github.com/multiformats/js-cid) | cid to provide | + +#### Example + +```js +const client = new Client(defaultSock) + +try { + await client.dht.provide(cid) +} catch (err) { + // +} +``` + +## dht.findProviders + +Query the DHT for peers that have a piece of content, identified by a CID. + +### `client.dht.findProviders(cid, [count])` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| cid | [`CID`](https://github.com/multiformats/js-cid) | cid to find | +| count | `number` | number or results aimed | + +#### Returns + +| Type | Description | +|------|-------------| +| `Array` | array of peer info | +| `Array.` | Peer info of a node | + +#### Example + +```js +const client = new Client(defaultSock) + +let peerInfos + +try { + peerInfos = await client.dht.findProviders(cid) +} catch (err) { + // +} +``` + +## dht.getClosestPeers + +Query the DHT routing table for peers that are closest to a provided key. + +### `client.dht.getClosestPeers(key)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| key | `Uint8Array` | key to get from the dht | + +#### Returns + +| Type | Description | +|------|-------------| +| `Array` | array of peer info | +| `Array.` | Peer info of a node | + +#### Example + +```js +const client = new Client(defaultSock) + +let peerInfos + +try { + peerInfos = await client.dht.getClosestPeers(key) +} catch (err) { + // +} +``` + +## dht.getPublicKey + +Query the DHT routing table for a given peer's public key. + +### `client.dht.getPublicKey(peerId)` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| peerId | [`PeerId`](https://github.com/libp2p/js-peer-id) | ID of the peer to find | + +#### Returns + +| Type | Description | +|------|-------------| +| `PublicKey` | public key of the peer | + +#### Example + +```js +const client = new Client(defaultSock) + +let publicKey + +try { + publicKey = await client.dht.getPublicKey(peerId) +} catch (err) { + // +} +``` + +### `client.pubsub.getTopics()` + +#### Returns + +| Type | Description | +|------|-------------| +| `Array` | topics the node is subscribed to | + +#### Example + +```js +const client = new Client(defaultSock) + +let topics + +try { + topics = await client.pubsub.getTopics() +} catch (err) { + // +} +``` + +### `client.pubsub.publish()` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| topic | `string` | topic to publish | +| data | `Uint8Array` | data to publish | + +#### Returns + +| Type | Description | +|------|-------------| +| `Promise` | publish success | + +#### Example + +```js +const topic = 'topic' +const data = uint8ArrayFromString('data') +const client = new Client(defaultSock) + +try { + await client.pubsub.publish(topic, data) +} catch (err) { + // +} +``` + +### `client.pubsub.subscribe()` + +#### Parameters + +| Name | Type | Description | +|------|------|-------------| +| topic | `string` | topic to subscribe | + +#### Returns + +| Type | Description | +|------|-------------| +| `AsyncIterator` | data published | + +#### Example + +```js +const topic = 'topic' +const client = new Client(defaultSock) + +for await (const msg of client.pubsub.subscribe(topic)) { + // msg.data - pubsub data received +} +``` diff --git a/packages/libp2p-daemon-client/CHANGELOG.md b/packages/libp2p-daemon-client/CHANGELOG.md new file mode 100644 index 00000000..2b0f8eaa --- /dev/null +++ b/packages/libp2p-daemon-client/CHANGELOG.md @@ -0,0 +1,198 @@ +# [0.11.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.10.0...v0.11.0) (2022-01-17) + + +### Features + +* async peerstore ([#110](https://github.com/libp2p/js-libp2p-daemon-client/issues/110)) ([41dc8a5](https://github.com/libp2p/js-libp2p-daemon-client/commit/41dc8a59ce14447b9b5ab7ba9930f4140bda3652)) + + +### BREAKING CHANGES + +* peerstore methods are now all async + + + +# [0.10.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.9.0...v0.10.0) (2021-12-29) + + +### chore + +* update deps ([#103](https://github.com/libp2p/js-libp2p-daemon-client/issues/103)) ([cdbc4b2](https://github.com/libp2p/js-libp2p-daemon-client/commit/cdbc4b22f3599f33911be1b406b02d06515389b8)) + + +### BREAKING CHANGES + +* only node15+ is supported + + + +# [0.9.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.7.0...v0.9.0) (2021-11-18) + + + +# [0.7.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.6.0...v0.7.0) (2021-07-30) + + + +# [0.6.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.5.0...v0.6.0) (2021-05-04) + + + + +# [0.5.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.4.0...v0.5.0) (2020-08-23) + + +### Bug Fixes + +* replace node buffers with uint8arrays ([#42](https://github.com/libp2p/js-libp2p-daemon-client/issues/42)) ([33be887](https://github.com/libp2p/js-libp2p-daemon-client/commit/33be887)) + + +### BREAKING CHANGES + +* - All deps of this module now use uint8arrays in place of node buffers +- DHT keys/values are Uint8Arrays, not Strings or Buffers + +* chore: bump daemon dep + +Co-authored-by: Jacob Heun + + + + +# [0.4.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.3.1...v0.4.0) (2020-06-08) + + + + +## [0.3.1](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.3.0...v0.3.1) (2020-04-20) + + + + +# [0.3.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.2.2...v0.3.0) (2020-01-31) + + +### Chores + +* update deps ([#18](https://github.com/libp2p/js-libp2p-daemon-client/issues/18)) ([61813b9](https://github.com/libp2p/js-libp2p-daemon-client/commit/61813b9)) + + +### BREAKING CHANGES + +* api changed as attach is not needed anymore + +* chore: apply suggestions from code review + +Co-Authored-By: Jacob Heun + +* chore: update aegir + +* chore: update daemon version + +Co-authored-by: Jacob Heun + + + + +## [0.2.2](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.2.1...v0.2.2) (2019-09-05) + + + + +## [0.2.1](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.2.0...v0.2.1) (2019-07-09) + + +### Bug Fixes + +* **client.connect:** handle empty response ([#13](https://github.com/libp2p/js-libp2p-daemon-client/issues/13)) ([ace789d](https://github.com/libp2p/js-libp2p-daemon-client/commit/ace789d)) +* **client.connect:** handle unspecified error in response ([#12](https://github.com/libp2p/js-libp2p-daemon-client/issues/12)) ([7db681b](https://github.com/libp2p/js-libp2p-daemon-client/commit/7db681b)) + + + + +# [0.2.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.1.2...v0.2.0) (2019-07-09) + + +### Bug Fixes + +* use error as field name instead of ErrorResponse ([#14](https://github.com/libp2p/js-libp2p-daemon-client/issues/14)) ([0ff9eda](https://github.com/libp2p/js-libp2p-daemon-client/commit/0ff9eda)) + + +### BREAKING CHANGES + +* errors property name is now `error` instead of `ErrorResponse` + + + + +## [0.1.2](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.1.1...v0.1.2) (2019-03-29) + + +### Bug Fixes + +* dht find providers stream ([24eb727](https://github.com/libp2p/js-libp2p-daemon-client/commit/24eb727)) + + + + +## [0.1.1](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.1.0...v0.1.1) (2019-03-25) + + +### Bug Fixes + +* code review feedback ([7fd02d9](https://github.com/libp2p/js-libp2p-daemon-client/commit/7fd02d9)) + + +### Features + +* pubsub ([c485f50](https://github.com/libp2p/js-libp2p-daemon-client/commit/c485f50)) + + + + +# [0.1.0](https://github.com/libp2p/js-libp2p-daemon-client/compare/v0.0.4...v0.1.0) (2019-03-22) + + +### Bug Fixes + +* update code to work with latest daemon ([#6](https://github.com/libp2p/js-libp2p-daemon-client/issues/6)) ([0ada86c](https://github.com/libp2p/js-libp2p-daemon-client/commit/0ada86c)) + + + + +## [0.0.4](https://github.com/libp2p/js-libp2p-daemon-client/compare/0.0.3...v0.0.4) (2019-03-15) + + +### Features + +* streams ([7cefefd](https://github.com/libp2p/js-libp2p-daemon-client/commit/7cefefd)) + + + + +## [0.0.3](https://github.com/libp2p/js-libp2p-daemon-client/compare/0.0.2...0.0.3) (2019-02-13) + + +### Bug Fixes + +* connect should use peer id in bytes ([b9e4e44](https://github.com/libp2p/js-libp2p-daemon-client/commit/b9e4e44)) + + + + +## [0.0.2](https://github.com/libp2p/js-libp2p-daemon-client/compare/e748b7c...0.0.2) (2019-02-11) + + +### Bug Fixes + +* code review ([6ae7ce0](https://github.com/libp2p/js-libp2p-daemon-client/commit/6ae7ce0)) +* code review ([80e3d62](https://github.com/libp2p/js-libp2p-daemon-client/commit/80e3d62)) +* main on package.json ([8fcc62b](https://github.com/libp2p/js-libp2p-daemon-client/commit/8fcc62b)) + + +### Features + +* initial implementation ([e748b7c](https://github.com/libp2p/js-libp2p-daemon-client/commit/e748b7c)) + + + diff --git a/packages/libp2p-daemon-client/LICENSE b/packages/libp2p-daemon-client/LICENSE new file mode 100644 index 00000000..20ce483c --- /dev/null +++ b/packages/libp2p-daemon-client/LICENSE @@ -0,0 +1,4 @@ +This project is dual licensed under MIT and Apache-2.0. + +MIT: https://www.opensource.org/licenses/mit +Apache-2.0: https://www.apache.org/licenses/license-2.0 diff --git a/packages/libp2p-daemon-client/LICENSE-APACHE b/packages/libp2p-daemon-client/LICENSE-APACHE new file mode 100644 index 00000000..14478a3b --- /dev/null +++ b/packages/libp2p-daemon-client/LICENSE-APACHE @@ -0,0 +1,5 @@ +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. diff --git a/packages/libp2p-daemon-client/LICENSE-MIT b/packages/libp2p-daemon-client/LICENSE-MIT new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/packages/libp2p-daemon-client/LICENSE-MIT @@ -0,0 +1,19 @@ +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/packages/libp2p-daemon-client/README.md b/packages/libp2p-daemon-client/README.md new file mode 100644 index 00000000..1cd8fcec --- /dev/null +++ b/packages/libp2p-daemon-client/README.md @@ -0,0 +1,84 @@ +libp2p-daemon client JavaScript implementation +====== + +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai/) +[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/) +[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p) +[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io) + +> A Javascript client to interact with a standalone deployment of a libp2p host, running in its own OS process. Essentially, this client allows to communicate with other peers, interact with the DHT, participate in pubsub, etc. no matter the language they are implemented with. + +## Lead Maintainer + +[Vasco Santos](https://github.com/vasco-santos) + +## Table of Contents + +* [Specs](#specs) +* [Install](#install) +* [Usage](#usage) +* [API](#api) +* [Contribute](#contribute) +* [License](#license) + +## Specs + +The specs for the daemon are currently housed in the go implementation. You can read them at [libp2p/go-libp2p-daemon](https://github.com/libp2p/go-libp2p-daemon/blob/master/specs/README.md) + +## Install + +`npm install libp2p-daemon-client` + +## Usage + +### Run a daemon process + +There are currently two implementations of the `libp2p-daemon`: + +- [js-libp2p-daemon](https://github.com/libp2p/js-libp2p-daemon) +- [go-libp2p-daemon](https://github.com/libp2p/go-libp2p-daemon) + +### Interact with the daemon process using the client + +```js +const Client = require('libp2p-daemon-client') + +const defaultSock = '/tmp/p2pd.sock' +const client = new Client(defaultSock) + +// interact with the daemon +let identify +try { + identify = await client.identify() +} catch (err) { + // ... +} + +// close the socket +await client.close() +``` + +## API + +* [Getting started](API.md#getting-started) +* [`close`](API.md#close) +* [`connect`](API.md#connect) +* [`identify`](API.md#identify) +* [`listPeers`](API.md#listPeers) +* [`openStream`](API.md#openStream) +* [`registerStream`](API.md#registerStream) +* [`dht.put`](API.md#dht.put) +* [`dht.get`](API.md#dht.get) +* [`dht.findPeer`](API.md#dht.findPeer) +* [`dht.provide`](API.md#dht.provide) +* [`dht.findProviders`](API.md#dht.findProviders) +* [`dht.getClosestPeers`](API.md#dht.getClosestPeers) +* [`dht.getPublicKey`](API.md#dht.getPublicKey) + +## Contribute + +This module is actively under development. Please check out the issues and submit PRs! + +## License + +MIT © Protocol Labs \ No newline at end of file diff --git a/packages/libp2p-daemon-client/package.json b/packages/libp2p-daemon-client/package.json new file mode 100644 index 00000000..42c78577 --- /dev/null +++ b/packages/libp2p-daemon-client/package.json @@ -0,0 +1,152 @@ +{ + "name": "@libp2p/daemon-client", + "version": "0.0.2", + "description": "libp2p-daemon client implementation", + "license": "Apache-2.0 OR MIT", + "homepage": "https://github.com/libp2p/js-libp2p-daemon/tree/master/packages/libp2p-daemon-client#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/libp2p/js-libp2p-daemon.git" + }, + "bugs": { + "url": "https://github.com/libp2p/js-libp2p-daemon/issues" + }, + "keywords": [ + "libp2p" + ], + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + }, + "type": "module", + "types": "./dist/src/index.d.ts", + "files": [ + "src", + "dist/src", + "!dist/test", + "!**/*.tsbuildinfo" + ], + "exports": { + ".": { + "import": "./dist/src/index.js" + } + }, + "eslintConfig": { + "extends": "ipfs", + "parserOptions": { + "sourceType": "module" + } + }, + "release": { + "branches": [ + "master" + ], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { + "breaking": true, + "release": "major" + }, + { + "revert": true, + "release": "patch" + }, + { + "type": "feat", + "release": "minor" + }, + { + "type": "fix", + "release": "patch" + }, + { + "type": "chore", + "release": "patch" + }, + { + "type": "docs", + "release": "patch" + }, + { + "type": "test", + "release": "patch" + }, + { + "scope": "no-release", + "release": false + } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { + "preset": "conventionalcommits", + "presetConfig": { + "types": [ + { + "type": "feat", + "section": "Features" + }, + { + "type": "fix", + "section": "Bug Fixes" + }, + { + "type": "chore", + "section": "Trivial Changes" + }, + { + "type": "docs", + "section": "Trivial Changes" + }, + { + "type": "test", + "section": "Tests" + } + ] + } + } + ], + "@semantic-release/changelog", + "@semantic-release/npm", + "@semantic-release/github", + "@semantic-release/git" + ] + }, + "scripts": { + "lint": "aegir lint", + "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js", + "build": "tsc", + "pretest": "npm run build", + "test": "aegir test -t node -f ./dist/test/*.js", + "test:node": "aegir test -t node -f ./dist/test/*.js", + "release": "semantic-release" + }, + "dependencies": { + "@libp2p/daemon-protocol": "^0.0.1", + "@libp2p/interfaces": "^1.3.17", + "@libp2p/logger": "^1.1.2", + "@libp2p/peer-id": "^1.1.8", + "@libp2p/tcp": "^1.0.6", + "@multiformats/multiaddr": "^10.1.8", + "err-code": "^3.0.1", + "it-stream-types": "^1.0.4", + "multiformats": "^9.4.2" + }, + "devDependencies": { + "@libp2p/interface-compliance-tests": "^1.1.20", + "@libp2p/daemon-server": "^0.0.2", + "@libp2p/peer-id-factory": "^1.0.8", + "aegir": "^36.0.0", + "it-all": "^1.0.6", + "it-pipe": "^2.0.3", + "sinon": "^13.0.1", + "ts-sinon": "^2.0.2", + "uint8arrays": "^3.0.0" + } +} diff --git a/packages/libp2p-daemon-client/src/dht.ts b/packages/libp2p-daemon-client/src/dht.ts new file mode 100644 index 00000000..760bc143 --- /dev/null +++ b/packages/libp2p-daemon-client/src/dht.ts @@ -0,0 +1,282 @@ +import { CID } from 'multiformats/cid' +import { Multiaddr } from '@multiformats/multiaddr' +import errcode from 'err-code' +import { + Request, + Response, + DHTRequest, + DHTResponse +} from '@libp2p/daemon-protocol' +import type { DaemonClient } from './index.js' +import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id' +import type { PeerInfo } from '@libp2p/interfaces/peer-info' +import { peerIdFromBytes } from '@libp2p/peer-id' + +export class DHT { + private readonly client: DaemonClient + + constructor (client: DaemonClient) { + this.client = client + } + + /** + * Write a value to a key in the DHT + */ + async put (key: Uint8Array, value: Uint8Array): Promise { + if (!(key instanceof Uint8Array)) { + throw errcode(new Error('invalid key received'), 'ERR_INVALID_KEY') + } + + if (!(value instanceof Uint8Array)) { + throw errcode(new Error('value received is not a Uint8Array'), 'ERR_INVALID_VALUE') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.PUT_VALUE, + key, + value + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'DHT put failed'), 'ERR_DHT_PUT_FAILED') + } + } + + /** + * Query the DHT for a value stored at a key in the DHT + */ + async get (key: Uint8Array): Promise { + if (!(key instanceof Uint8Array)) { + throw errcode(new Error('invalid key received'), 'ERR_INVALID_KEY') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.GET_VALUE, + key + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'DHT get failed'), 'ERR_DHT_GET_FAILED') + } + + if (response.dht == null || response.dht.value == null) { + throw errcode(new Error('Invalid DHT get response'), 'ERR_DHT_GET_FAILED') + } + + return response.dht.value + } + + /** + * Query the DHT for a given peer's known addresses. + */ + async findPeer (peerId: PeerId): Promise { + if (!isPeerId(peerId)) { + throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.FIND_PEER, + peer: peerId.toBytes() + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'DHT find peer failed'), 'ERR_DHT_FIND_PEER_FAILED') + } + + if (response.dht == null || response.dht.peer == null || response.dht.peer.addrs == null) { + throw errcode(new Error('Invalid response'), 'ERR_DHT_FIND_PEER_FAILED') + } + + return { + id: peerIdFromBytes(response.dht.peer.id), + multiaddrs: response.dht.peer.addrs.map((a) => new Multiaddr(a)), + protocols: [] + } + } + + /** + * Announce to the network that the peer have data addressed by the provided CID + */ + async provide (cid: CID) { + if (cid == null || CID.asCID(cid) == null) { + throw errcode(new Error('invalid cid received'), 'ERR_INVALID_CID') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.PROVIDE, + cid: cid.bytes + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'DHT provide failed'), 'ERR_DHT_PROVIDE_FAILED') + } + } + + /** + * Query the DHT for peers that have a piece of content, identified by a CID + */ + async * findProviders (cid: CID, count: number = 1): AsyncIterable { + if (cid == null || CID.asCID(cid) == null) { + throw errcode(new Error('invalid cid received'), 'ERR_INVALID_CID') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.FIND_PROVIDERS, + cid: cid.bytes, + count + } + }) + + let message = await sh.read() + + // stream begin message + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + await sh.close() + throw errcode(new Error(response.error?.msg ?? 'DHT find providers failed'), 'ERR_DHT_FIND_PROVIDERS_FAILED') + } + + while (true) { + message = await sh.read() + const response = DHTResponse.decode(message) + + // Stream end + if (response.type === DHTResponse.Type.END) { + await sh.close() + return + } + + // Stream values + if (response.type === DHTResponse.Type.VALUE && response.peer != null && response.peer?.addrs != null) { + yield { + id: peerIdFromBytes(response.peer.id), + multiaddrs: response.peer.addrs.map((a) => new Multiaddr(a)), + protocols: [] + } + } else { + // Unexpected message received + await sh.close() + throw errcode(new Error('unexpected message received'), 'ERR_UNEXPECTED_MESSAGE_RECEIVED') + } + } + } + + /** + * Query the DHT routing table for peers that are closest to a provided key. + */ + async * getClosestPeers (key: Uint8Array): AsyncIterable { + if (!(key instanceof Uint8Array)) { + throw errcode(new Error('invalid key received'), 'ERR_INVALID_KEY') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.GET_CLOSEST_PEERS, + key + } + }) + + // stream begin message + let message = await sh.read() + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + await sh.close() + throw errcode(new Error(response.error?.msg ?? 'DHT find providers failed'), 'ERR_DHT_FIND_PROVIDERS_FAILED') + } + + while (true) { + message = await sh.read() + const response = DHTResponse.decode(message) + + // Stream end + if (response.type === DHTResponse.Type.END) { + await sh.close() + return + } + + // Stream values + if (response.type === DHTResponse.Type.VALUE && response.value != null) { + const peerId = peerIdFromBytes(response.value) + + yield { + id: peerId, + multiaddrs: [], + protocols: [] + } + } else { + // Unexpected message received + await sh.close() + throw errcode(new Error('unexpected message received'), 'ERR_UNEXPECTED_MESSAGE_RECEIVED') + } + } + } + + /** + * Query the DHT routing table for a given peer's public key. + */ + async getPublicKey (peerId: PeerId) { + if (!isPeerId(peerId)) { + throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID') + } + + const sh = await this.client.send({ + type: Request.Type.DHT, + dht: { + type: DHTRequest.Type.GET_PUBLIC_KEY, + peer: peerId.toBytes() + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'DHT get public key failed'), 'ERR_DHT_GET_PUBLIC_KEY_FAILED') + } + + if (response.dht == null) { + throw errcode(new Error('Invalid response'), 'ERR_DHT_GET_PUBLIC_KEY_FAILED') + } + + return response.dht.value + } +} diff --git a/packages/libp2p-daemon-client/src/index.ts b/packages/libp2p-daemon-client/src/index.ts new file mode 100644 index 00000000..39b38524 --- /dev/null +++ b/packages/libp2p-daemon-client/src/index.ts @@ -0,0 +1,243 @@ +import errcode from 'err-code' +import { TCP } from '@libp2p/tcp' +import { IRequest, PSMessage, Request, Response } from '@libp2p/daemon-protocol' +import { StreamHandler } from '@libp2p/daemon-protocol/stream-handler' +import { Multiaddr } from '@multiformats/multiaddr' +import { DHT } from './dht.js' +import { Pubsub } from './pubsub.js' +import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id' +import { passThroughUpgrader } from '@libp2p/daemon-protocol/upgrader' +import { peerIdFromBytes } from '@libp2p/peer-id' +import type { Duplex } from 'it-stream-types' +import type { CID } from 'multiformats/cid' +import type { PeerInfo } from '@libp2p/interfaces/peer-info' + +class Client implements DaemonClient { + private readonly multiaddr: Multiaddr + public dht: DHT + public pubsub: Pubsub + private readonly tcp: TCP + + constructor (addr: Multiaddr) { + this.multiaddr = addr + this.tcp = new TCP() + + this.dht = new DHT(this) + this.pubsub = new Pubsub(this) + } + + /** + * Connects to a daemon at the unix socket path the daemon + * was created with + * + * @async + * @returns {MultiaddrConnection} + */ + async connectDaemon () { + return await this.tcp.dial(this.multiaddr, { + upgrader: passThroughUpgrader + }) + } + + /** + * Sends the request to the daemon and returns a stream. This + * should only be used when sending daemon requests. + */ + async send (request: IRequest) { + const maConn = await this.connectDaemon() + + const streamHandler = new StreamHandler({ stream: maConn }) + streamHandler.write(Request.encode(request).finish()) + return streamHandler + } + + /** + * Connect requests a connection to a known peer on a given set of addresses + */ + async connect (peerId: PeerId, addrs: Multiaddr[]) { + if (!isPeerId(peerId)) { + throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID') + } + + if (!Array.isArray(addrs)) { + throw errcode(new Error('addrs received are not in an array'), 'ERR_INVALID_ADDRS_TYPE') + } + + addrs.forEach((addr) => { + if (!Multiaddr.isMultiaddr(addr)) { + throw errcode(new Error('received an address that is not a multiaddr'), 'ERR_NO_MULTIADDR_RECEIVED') + } + }) + + const sh = await this.send({ + type: Request.Type.CONNECT, + connect: { + peer: peerId.toBytes(), + addrs: addrs.map((a) => a.bytes) + } + }) + + const message = await sh.read() + if (message == null) { + throw errcode(new Error('unspecified'), 'ERR_CONNECT_FAILED') + } + + const response = Response.decode(message) + if (response.type !== Response.Type.OK) { + const errResponse = response.error ?? { msg: 'unspecified' } + throw errcode(new Error(errResponse.msg ?? 'unspecified'), 'ERR_CONNECT_FAILED') + } + + await sh.close() + } + + /** + * @typedef {Object} IdentifyResponse + * @property {PeerId} peerId + * @property {Array.} addrs + */ + + /** + * Identify queries the daemon for its peer ID and listen addresses. + */ + async identify (): Promise { + const sh = await this.send({ + type: Request.Type.IDENTIFY + }) + + const message = await sh.read() + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'Identify failed'), 'ERR_IDENTIFY_FAILED') + } + + if (response.identify == null || response.identify.addrs == null) { + throw errcode(new Error('Invalid response'), 'ERR_IDENTIFY_FAILED') + } + + const peerId = peerIdFromBytes(response.identify?.id) + const addrs = response.identify.addrs.map((a) => new Multiaddr(a)) + + await sh.close() + + return ({ peerId, addrs }) + } + + /** + * Get a list of IDs of peers the node is connected to + */ + async listPeers (): Promise { + const sh = await this.send({ + type: Request.Type.LIST_PEERS + }) + + const message = await sh.read() + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'List peers failed'), 'ERR_LIST_PEERS_FAILED') + } + + await sh.close() + + return response.peers.map((peer) => peerIdFromBytes(peer.id)) + } + + /** + * Initiate an outbound stream to a peer on one of a set of protocols. + */ + async openStream (peerId: PeerId, protocol: string): Promise> { + if (!isPeerId(peerId)) { + throw errcode(new Error('invalid peer id received'), 'ERR_INVALID_PEER_ID') + } + + if (typeof protocol !== 'string') { + throw errcode(new Error('invalid protocol received'), 'ERR_INVALID_PROTOCOL') + } + + const sh = await this.send({ + type: Request.Type.STREAM_OPEN, + streamOpen: { + peer: peerId.toBytes(), + proto: [protocol] + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + await sh.close() + throw errcode(new Error(response.error?.msg ?? 'Open stream failed'), 'ERR_OPEN_STREAM_FAILED') + } + + return sh.rest() + } + + /** + * Register a handler for inbound streams on a given protocol + */ + async registerStreamHandler (addr: Multiaddr, protocol: string) { + if (!Multiaddr.isMultiaddr(addr)) { + throw errcode(new Error('invalid multiaddr received'), 'ERR_INVALID_MULTIADDR') + } + + if (typeof protocol !== 'string') { + throw errcode(new Error('invalid protocol received'), 'ERR_INVALID_PROTOCOL') + } + + const sh = await this.send({ + type: Request.Type.STREAM_HANDLER, + streamOpen: null, + streamHandler: { + addr: addr.bytes, + proto: [protocol] + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'Register stream handler failed'), 'ERR_REGISTER_STREAM_HANDLER_FAILED') + } + } +} + +export interface IdentifyResult { + peerId: PeerId + addrs: Multiaddr[] +} + +export interface DHTClient { + put: (key: Uint8Array, value: Uint8Array) => Promise + get: (key: Uint8Array) => Promise + provide: (cid: CID) => Promise + findProviders: (cid: CID, count?: number) => AsyncIterable + findPeer: (peerId: PeerId) => Promise + getClosestPeers: (key: Uint8Array) => AsyncIterable +} + +export interface PubSubClient { + publish: (topic: string, data: Uint8Array) => Promise + subscribe: (topic: string) => AsyncIterable + getTopics: () => Promise +} + +export interface DaemonClient { + identify: () => Promise + listPeers: () => Promise + connect: (peerId: PeerId, addrs: Multiaddr[]) => Promise + dht: DHTClient + pubsub: PubSubClient + + send: (request: IRequest) => Promise + openStream: (peerId: PeerId, protocol: string) => Promise> +} + +export function createClient (multiaddr: Multiaddr): DaemonClient { + return new Client(multiaddr) +} diff --git a/packages/libp2p-daemon-client/src/pubsub.ts b/packages/libp2p-daemon-client/src/pubsub.ts new file mode 100644 index 00000000..e0287817 --- /dev/null +++ b/packages/libp2p-daemon-client/src/pubsub.ts @@ -0,0 +1,106 @@ +import errcode from 'err-code' +import { + Request, + Response, + PSRequest, + PSMessage +} from '@libp2p/daemon-protocol' +import type { DaemonClient } from './index.js' + +export class Pubsub { + private readonly client: DaemonClient + + constructor (client: DaemonClient) { + this.client = client + } + + /** + * Get a list of topics the node is subscribed to. + * + * @returns {Array} topics + */ + async getTopics (): Promise { + const sh = await this.client.send({ + type: Request.Type.PUBSUB, + pubsub: { + type: PSRequest.Type.GET_TOPICS + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'Pubsub get topics failed'), 'ERR_PUBSUB_GET_TOPICS_FAILED') + } + + if (response.pubsub == null || response.pubsub.topics == null) { + throw errcode(new Error('Invalid response'), 'ERR_PUBSUB_GET_TOPICS_FAILED') + } + + return response.pubsub.topics + } + + /** + * Publish data under a topic + */ + async publish (topic: string, data: Uint8Array) { + if (typeof topic !== 'string') { + throw errcode(new Error('invalid topic received'), 'ERR_INVALID_TOPIC') + } + + if (!(data instanceof Uint8Array)) { + throw errcode(new Error('data received is not a Uint8Array'), 'ERR_INVALID_DATA') + } + + const sh = await this.client.send({ + type: Request.Type.PUBSUB, + pubsub: { + type: PSRequest.Type.PUBLISH, + topic, + data + } + }) + + const message = await sh.read() + const response = Response.decode(message) + + await sh.close() + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'Pubsub publish failed'), 'ERR_PUBSUB_PUBLISH_FAILED') + } + } + + /** + * Request to subscribe a certain topic + */ + async * subscribe (topic: string) { + if (typeof topic !== 'string') { + throw errcode(new Error('invalid topic received'), 'ERR_INVALID_TOPIC') + } + + const sh = await this.client.send({ + type: Request.Type.PUBSUB, + pubsub: { + type: PSRequest.Type.SUBSCRIBE, + topic + } + }) + + let message = await sh.read() + const response = Response.decode(message) + + if (response.type !== Response.Type.OK) { + throw errcode(new Error(response.error?.msg ?? 'Pubsub publish failed'), 'ERR_PUBSUB_PUBLISH_FAILED') + } + + // stream messages + while (true) { + message = await sh.read() + yield PSMessage.decode(message) + } + } +} diff --git a/packages/libp2p-daemon-client/test/dht.spec.ts b/packages/libp2p-daemon-client/test/dht.spec.ts new file mode 100644 index 00000000..c3da3ee2 --- /dev/null +++ b/packages/libp2p-daemon-client/test/dht.spec.ts @@ -0,0 +1,236 @@ +/* eslint-env mocha */ + +import { expect } from 'aegir/utils/chai.js' +import sinon from 'sinon' +import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string' +import { createServer, Libp2p, Libp2pServer } from '@libp2p/daemon-server' +import { createClient, DaemonClient } from '../src/index.js' +import { Multiaddr } from '@multiformats/multiaddr' +import { StubbedInstance, stubInterface } from 'ts-sinon' +import { DualDHT, ValueEvent, FinalPeerEvent, PeerResponseEvent, MessageType, EventTypes } from '@libp2p/interfaces/dht' +import { peerIdFromString } from '@libp2p/peer-id' +import { CID } from 'multiformats/cid' +import all from 'it-all' + +const defaultMultiaddr = new Multiaddr('/ip4/0.0.0.0/tcp/12345') + +describe('daemon dht client', function () { + this.timeout(30e3) + + let libp2p: StubbedInstance + let server: Libp2pServer + let client: DaemonClient + let dht: StubbedInstance + + beforeEach(async function () { + dht = stubInterface() + libp2p = stubInterface() + libp2p.dht = dht + + server = createServer(defaultMultiaddr, libp2p) + + await server.start() + + client = createClient(server.getMultiaddr()) + }) + + afterEach(async () => { + if (server != null) { + await server.stop() + } + + sinon.restore() + }) + + describe('put', () => { + const key = uint8ArrayFromString('/key') + const value = uint8ArrayFromString('oh hello there') + + it('should be able to put a value to the dht', async function () { + dht.put.returns(async function * () {}()) + + await client.dht.put(key, value) + + expect(dht.put.calledWith(key, value)).to.be.true() + }) + + it('should error if receive an error message', async () => { + dht.put.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(client.dht.put(key, value)).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('get', () => { + it('should be able to get a value from the dht', async function () { + const key = uint8ArrayFromString('/key') + const value = uint8ArrayFromString('oh hello there') + + dht.get.withArgs(key).returns(async function * () { + const event: ValueEvent = { + name: 'VALUE', + type: EventTypes.VALUE, + value, + from: peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + } + + yield event + }()) + + const result = await client.dht.get(key) + + expect(result).to.equalBytes(value) + }) + + it('should error if receive an error message', async function () { + const key = uint8ArrayFromString('/key') + + dht.get.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(client.dht.get(key)).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('findPeer', () => { + it('should be able to find a peer', async () => { + const id = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + + dht.findPeer.withArgs(id).returns(async function * () { + const event: FinalPeerEvent = { + name: 'FINAL_PEER', + type: EventTypes.FINAL_PEER, + peer: { + id, + multiaddrs: [], + protocols: [] + }, + from: peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + } + + yield event + }()) + + const result = await client.dht.findPeer(id) + + expect(result.id.equals(id)).to.be.true() + }) + + it('should error if receive an error message', async () => { + const id = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + + dht.findPeer.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(client.dht.findPeer(id)).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('provide', () => { + it('should be able to provide', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + + dht.provide.returns(async function * () {}()) + + await client.dht.provide(cid) + + expect(dht.provide.calledWith(cid)).to.be.true() + }) + + it('should error if receive an error message', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + + dht.provide.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(client.dht.provide(cid)).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('findProviders', () => { + it('should be able to find providers', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + const id = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + + dht.findProviders.withArgs(cid).returns(async function * () { + const event: PeerResponseEvent = { + name: 'PEER_RESPONSE', + type: EventTypes.PEER_RESPONSE, + providers: [{ + id, + multiaddrs: [], + protocols: [] + }], + closer: [], + from: id, + messageName: 'GET_PROVIDERS', + messageType: MessageType.GET_PROVIDERS + } + + yield event + }()) + + const result = await all(client.dht.findProviders(cid)) + + expect(result).to.have.lengthOf(1) + expect(result[0].id.equals(id)).to.be.true() + }) + + // skipped because the protocol doesn't handle streaming errors + it.skip('should error if receive an error message', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + + dht.findProviders.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(all(client.dht.findProviders(cid))).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('getClosestPeers', () => { + it('should be able to get the closest peers', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + const id = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + + dht.getClosestPeers.withArgs(cid.bytes).returns(async function * () { + const event: PeerResponseEvent = { + name: 'PEER_RESPONSE', + type: EventTypes.PEER_RESPONSE, + providers: [], + closer: [{ + id, + multiaddrs: [], + protocols: [] + }], + from: id, + messageName: 'GET_PROVIDERS', + messageType: MessageType.GET_PROVIDERS + } + + yield event + }()) + + const result = await all(client.dht.getClosestPeers(cid.bytes)) + + expect(result).to.have.lengthOf(1) + expect(result[0].id.equals(id)).to.be.true() + }) + + // skipped because the protocol doesn't handle streaming errors + it.skip('should error if it gets an invalid key', async () => { + const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') + + dht.getClosestPeers.returns(async function * () { // eslint-disable-line require-yield + throw new Error('Urk!') + }()) + + await expect(all(client.dht.getClosestPeers(cid.bytes))).to.eventually.be.rejectedWith(/Urk!/) + }) + }) +}) diff --git a/packages/libp2p-daemon-client/test/index.spec.ts b/packages/libp2p-daemon-client/test/index.spec.ts new file mode 100644 index 00000000..c3e86bc1 --- /dev/null +++ b/packages/libp2p-daemon-client/test/index.spec.ts @@ -0,0 +1,106 @@ +/* eslint-env mocha */ + +import { expect } from 'aegir/utils/chai.js' +import sinon from 'sinon' +import { createServer, Libp2p, Libp2pServer } from '@libp2p/daemon-server' +import { createClient, DaemonClient } from '../src/index.js' +import { Multiaddr } from '@multiformats/multiaddr' +import { StubbedInstance, stubInterface } from 'ts-sinon' +import { isPeerId } from '@libp2p/interfaces/peer-id' +import { peerIdFromString } from '@libp2p/peer-id' +import { mockConnection, mockDuplex, mockMultiaddrConnection } from '@libp2p/interface-compliance-tests/mocks' +import type { PeerStore, AddressBook } from '@libp2p/interfaces/peer-store' + +const defaultMultiaddr = new Multiaddr('/ip4/0.0.0.0/tcp/0') + +describe('daemon client', function () { + this.timeout(30e3) + + let libp2p: StubbedInstance + let server: Libp2pServer + let client: DaemonClient + + beforeEach(async function () { + libp2p = stubInterface() + libp2p.peerStore = stubInterface() + libp2p.peerStore.addressBook = stubInterface() + + server = createServer(defaultMultiaddr, libp2p) + + await server.start() + + client = createClient(server.getMultiaddr()) + }) + + afterEach(async () => { + if (server != null) { + await server.stop() + } + + sinon.restore() + }) + + describe('identify', () => { + it('should be able to identify', async () => { + libp2p.peerId = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + libp2p.getMultiaddrs.returns([ + new Multiaddr('/ip4/0.0.0.0/tcp/1234/p2p/12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + ]) + + const identify = await client.identify() + + expect(identify).to.exist() + expect(identify.peerId).to.exist() + expect(identify.addrs).to.exist() + expect(isPeerId(identify.peerId)) + }) + + it('should error if receive an error message', async () => { + libp2p.peerId = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + libp2p.getMultiaddrs.throws(new Error('Urk!')) + + await expect(client.identify()).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('listPeers', () => { + it('should be able to listPeers', async () => { + const remotePeer = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + + libp2p.getConnections.returns([ + mockConnection(mockMultiaddrConnection(mockDuplex(), remotePeer)) + ]) + + const peers = await client.listPeers() + + expect(peers).to.have.lengthOf(1) + expect(peers[0].equals(remotePeer)).to.be.true() + }) + + it('should error if receive an error message', async () => { + libp2p.getConnections.throws(new Error('Urk!')) + + await expect(client.listPeers()).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('connect', () => { + it('should be able to connect', async () => { + const remotePeer = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + const multiaddr = new Multiaddr('/ip4/1.2.3.4/tcp/1234') + + await client.connect(remotePeer, [multiaddr]) + + expect(libp2p.dial.calledWith(remotePeer)).to.be.true() + }) + + it('should error if receive an error message', async () => { + const remotePeer = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + const multiaddr = new Multiaddr('/ip4/1.2.3.4/tcp/1234') + + libp2p.dial.rejects(new Error('Urk!')) + + await expect(client.connect(remotePeer, [multiaddr])).to.eventually.be.rejectedWith(/Urk!/) + }) + }) +}) diff --git a/packages/libp2p-daemon-client/test/pubsub.spec.ts b/packages/libp2p-daemon-client/test/pubsub.spec.ts new file mode 100644 index 00000000..fe5899bb --- /dev/null +++ b/packages/libp2p-daemon-client/test/pubsub.spec.ts @@ -0,0 +1,91 @@ +/* eslint-env mocha */ + +import { expect } from 'aegir/utils/chai.js' +import sinon from 'sinon' +import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string' +import { createServer, Libp2p, Libp2pServer } from '@libp2p/daemon-server' +import { createClient, DaemonClient } from '../src/index.js' +import { Multiaddr } from '@multiformats/multiaddr' +import { StubbedInstance, stubInterface } from 'ts-sinon' +import type { PubSub } from '@libp2p/interfaces/pubsub' + +const defaultMultiaddr = new Multiaddr('/ip4/0.0.0.0/tcp/12345') + +describe('daemon pubsub client', function () { + this.timeout(30e3) + + let libp2p: StubbedInstance + let server: Libp2pServer + let client: DaemonClient + let pubsub: StubbedInstance + + beforeEach(async function () { + pubsub = stubInterface() + libp2p = stubInterface() + libp2p.pubsub = pubsub + + server = createServer(defaultMultiaddr, libp2p) + + await server.start() + + client = createClient(server.getMultiaddr()) + }) + + afterEach(async () => { + if (server != null) { + await server.stop() + } + + sinon.restore() + }) + + describe('getTopics', () => { + it('should get empty list of topics when no subscriptions exist', async () => { + pubsub.getTopics.returns([]) + + const topics = await client.pubsub.getTopics() + + expect(topics).to.have.lengthOf(0) + }) + + it('should get a list with a topic when subscribed', async () => { + const topic = 'test-topic' + pubsub.getTopics.returns([topic]) + + const topics = await client.pubsub.getTopics() + + expect(topics).to.have.lengthOf(1) + expect(topics[0]).to.equal(topic) + }) + + it('should error if receive an error message', async () => { + pubsub.getTopics.throws(new Error('Urk!')) + + await expect(client.pubsub.getTopics()).to.eventually.be.rejectedWith(/Urk!/) + }) + }) + + describe('publish', () => { + it('should publish an event', async () => { + const topic = 'test-topic' + const data = uint8ArrayFromString('hello world') + + await client.pubsub.publish(topic, data) + + expect(pubsub.dispatchEvent.called).to.be.true() + + const event = pubsub.dispatchEvent.getCall(0).args[0] + + expect(event.type).to.equal(topic) + expect(event.detail).to.equalBytes(data) + }) + + it('should error if receive an error message', async () => { + const topic = 'test-topic' + const data = uint8ArrayFromString('hello world') + pubsub.dispatchEvent.throws(new Error('Urk!')) + + await expect(client.pubsub.publish(topic, data)).to.eventually.be.rejectedWith(/Urk!/) + }) + }) +}) diff --git a/packages/libp2p-daemon-client/test/stream.spec.ts b/packages/libp2p-daemon-client/test/stream.spec.ts new file mode 100644 index 00000000..3993abf0 --- /dev/null +++ b/packages/libp2p-daemon-client/test/stream.spec.ts @@ -0,0 +1,88 @@ +/* eslint-env mocha */ + +import { expect } from 'aegir/utils/chai.js' +import sinon from 'sinon' +import { createServer, Libp2p, Libp2pServer } from '@libp2p/daemon-server' +import { createClient, DaemonClient } from '../src/index.js' +import { Multiaddr } from '@multiformats/multiaddr' +import { StubbedInstance, stubInterface } from 'ts-sinon' +import { peerIdFromString } from '@libp2p/peer-id' +import { mockRegistrar, connectionPair } from '@libp2p/interface-compliance-tests/mocks' +import type { PeerStore, AddressBook } from '@libp2p/interfaces/peer-store' +import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string' +import { toString as uint8ArrayToString } from 'uint8arrays/to-string' +import all from 'it-all' +import { pipe } from 'it-pipe' + +const defaultMultiaddr = new Multiaddr('/ip4/0.0.0.0/tcp/0') + +describe('daemon stream client', function () { + this.timeout(50e3) + + let libp2p: StubbedInstance + let server: Libp2pServer + let client: DaemonClient + + beforeEach(async function () { + libp2p = stubInterface() + libp2p.peerStore = stubInterface() + libp2p.peerStore.addressBook = stubInterface() + + server = createServer(defaultMultiaddr, libp2p) + + await server.start() + + client = createClient(server.getMultiaddr()) + }) + + afterEach(async () => { + if (server != null) { + await server.stop() + } + + sinon.restore() + }) + + it('should be able to open a stream, write to it and a stream handler, should handle the message', async () => { + const protocol = '/echo/1.0.0' + + const peerA = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsa') + const registrarA = mockRegistrar() + await registrarA.handle(protocol, (data) => { + void pipe( + data.stream, + data.stream + ) + }) + + const peerB = peerIdFromString('12D3KooWJKCJW8Y26pRFNv78TCMGLNTfyN8oKaFswMRYXTzSbSsb') + const registrarB = mockRegistrar() + await registrarB.handle(protocol, (data) => { + void pipe( + data.stream, + data.stream + ) + }) + + const [peerAtoPeerB] = connectionPair({ + peerId: peerA, + registrar: registrarA + }, { + peerId: peerB, + registrar: registrarB + }) + + libp2p.dial.withArgs(peerB).resolves(peerAtoPeerB) + + const stream = await client.openStream(peerB, protocol) + + const data = await pipe( + [uint8ArrayFromString('hello world')], + stream, + async (source) => await all(source) + ) + + expect(data).to.have.lengthOf(1) + expect(uint8ArrayToString(data[0])).to.equal('hello world') + }) +}) diff --git a/packages/libp2p-daemon-client/tsconfig.json b/packages/libp2p-daemon-client/tsconfig.json new file mode 100644 index 00000000..f93b4aad --- /dev/null +++ b/packages/libp2p-daemon-client/tsconfig.json @@ -0,0 +1,28 @@ +{ + "extends": "aegir/src/config/tsconfig.aegir.json", + "compilerOptions": { + "outDir": "dist", + "emitDeclarationOnly": false, + "module": "ES2020", + "lib": [ + "ES2021", + "ES2021.Promise", + "ES2021.String", + "ES2020.BigInt", + "DOM", + "DOM.Iterable" + ] + }, + "include": [ + "src", + "test" + ], + "references": [ + { + "path": "../libp2p-daemon-protocol" + }, + { + "path": "../libp2p-daemon-server" + } + ] +} diff --git a/packages/libp2p-daemon-protocol/LICENSE b/packages/libp2p-daemon-protocol/LICENSE new file mode 100644 index 00000000..20ce483c --- /dev/null +++ b/packages/libp2p-daemon-protocol/LICENSE @@ -0,0 +1,4 @@ +This project is dual licensed under MIT and Apache-2.0. + +MIT: https://www.opensource.org/licenses/mit +Apache-2.0: https://www.apache.org/licenses/license-2.0 diff --git a/packages/libp2p-daemon-protocol/LICENSE-APACHE b/packages/libp2p-daemon-protocol/LICENSE-APACHE new file mode 100644 index 00000000..14478a3b --- /dev/null +++ b/packages/libp2p-daemon-protocol/LICENSE-APACHE @@ -0,0 +1,5 @@ +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. diff --git a/packages/libp2p-daemon-protocol/LICENSE-MIT b/packages/libp2p-daemon-protocol/LICENSE-MIT new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/packages/libp2p-daemon-protocol/LICENSE-MIT @@ -0,0 +1,19 @@ +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/packages/libp2p-daemon-protocol/README.md b/packages/libp2p-daemon-protocol/README.md new file mode 100644 index 00000000..e1763326 --- /dev/null +++ b/packages/libp2p-daemon-protocol/README.md @@ -0,0 +1,24 @@ +# js-libp2p-daemon-protocol + + + + + +> Contains the protobuf definitions of the communication protocol for libp2p daemons + +## Install + +``` +npm i @libp2p/daemon-protocol +``` + +## Contribute + +This module is actively under development. Please check out the issues and submit PRs! + +## License + +Licensed under either of + + * Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / http://www.apache.org/licenses/LICENSE-2.0) + * MIT ([LICENSE-MIT](LICENSE-MIT) / http://opensource.org/licenses/MIT) diff --git a/packages/libp2p-daemon-protocol/package.json b/packages/libp2p-daemon-protocol/package.json new file mode 100644 index 00000000..9d91144b --- /dev/null +++ b/packages/libp2p-daemon-protocol/package.json @@ -0,0 +1,159 @@ +{ + "name": "@libp2p/daemon-protocol", + "version": "0.0.1", + "description": "Communication protocol between libp2p daemons and clients", + "author": "", + "license": "Apache-2.0 OR MIT", + "homepage": "https://github.com/libp2p/js-libp2p-daemon/tree/master/packages/libp2p-daemon-protocol#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/libp2p/js-libp2p-daemon.git" + }, + "bugs": { + "url": "https://github.com/libp2p/js-libp2p-daemon/issues" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + }, + "type": "module", + "types": "./dist/src/index.d.ts", + "typesVersions": { + "*": { + "*": [ + "*", + "dist/*", + "dist/src/*", + "dist/src/*/index" + ], + "src/*": [ + "*", + "dist/*", + "dist/src/*", + "dist/src/*/index" + ] + } + }, + "files": [ + "src", + "dist/src", + "!dist/test", + "!**/*.tsbuildinfo" + ], + "exports": { + ".": { + "import": "./dist/src/index.js" + }, + "./stream-handler": { + "import": "./dist/src/stream-handler.js" + }, + "./upgrader": { + "import": "./dist/src/upgrader.js" + } + }, + "eslintConfig": { + "extends": "ipfs", + "parserOptions": { + "sourceType": "module" + }, + "ignorePatterns": [ + "*.d.ts", + "src/index.js" + ] + }, + "release": { + "branches": [ + "master" + ], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { + "breaking": true, + "release": "major" + }, + { + "revert": true, + "release": "patch" + }, + { + "type": "feat", + "release": "minor" + }, + { + "type": "fix", + "release": "patch" + }, + { + "type": "chore", + "release": "patch" + }, + { + "type": "docs", + "release": "patch" + }, + { + "type": "test", + "release": "patch" + }, + { + "scope": "no-release", + "release": false + } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { + "preset": "conventionalcommits", + "presetConfig": { + "types": [ + { + "type": "feat", + "section": "Features" + }, + { + "type": "fix", + "section": "Bug Fixes" + }, + { + "type": "chore", + "section": "Trivial Changes" + }, + { + "type": "docs", + "section": "Trivial Changes" + }, + { + "type": "test", + "section": "Tests" + } + ] + } + } + ], + "@semantic-release/changelog", + "@semantic-release/npm", + "@semantic-release/github", + "@semantic-release/git" + ] + }, + "scripts": { + "lint": "aegir lint", + "build": "tsc && cp src/*.js src/*.d.ts dist/src", + "generate": "npm run generate:proto && npm run generate:proto-types", + "generate:proto": "pbjs -t static-module -w es6 -r libp2p-daemon --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/protocol/index.js ./src/protocol/index.proto", + "generate:proto-types": "pbts -o src/protocol/index.d.ts src/protocol/index.js", + "release": "semantic-release" + }, + "dependencies": { + "protobufjs": "^6.10.2" + }, + "devDependencies": { + "aegir": "^36.0.0" + } +} diff --git a/src/protocol/index.d.ts b/packages/libp2p-daemon-protocol/src/index.d.ts similarity index 93% rename from src/protocol/index.d.ts rename to packages/libp2p-daemon-protocol/src/index.d.ts index 2a068d65..e912c503 100644 --- a/src/protocol/index.d.ts +++ b/packages/libp2p-daemon-protocol/src/index.d.ts @@ -66,6 +66,30 @@ export class Request implements IRequest { /** Request peerStore. */ public peerStore?: (IPeerstoreRequest|null); + /** Request _connect. */ + public _connect?: "connect"; + + /** Request _streamOpen. */ + public _streamOpen?: "streamOpen"; + + /** Request _streamHandler. */ + public _streamHandler?: "streamHandler"; + + /** Request _dht. */ + public _dht?: "dht"; + + /** Request _connManager. */ + public _connManager?: "connManager"; + + /** Request _disconnect. */ + public _disconnect?: "disconnect"; + + /** Request _pubsub. */ + public _pubsub?: "pubsub"; + + /** Request _peerStore. */ + public _peerStore?: "peerStore"; + /** * Encodes the specified Request message. Does not implicitly {@link Request.verify|verify} messages. * @param m Request message or plain object to encode @@ -184,6 +208,24 @@ export class Response implements IResponse { /** Response peerStore. */ public peerStore?: (IPeerstoreResponse|null); + /** Response _error. */ + public _error?: "error"; + + /** Response _streamInfo. */ + public _streamInfo?: "streamInfo"; + + /** Response _identify. */ + public _identify?: "identify"; + + /** Response _dht. */ + public _dht?: "dht"; + + /** Response _pubsub. */ + public _pubsub?: "pubsub"; + + /** Response _peerStore. */ + public _peerStore?: "peerStore"; + /** * Encodes the specified Response message. Does not implicitly {@link Response.verify|verify} messages. * @param m Response message or plain object to encode @@ -327,7 +369,10 @@ export class ConnectRequest implements IConnectRequest { public addrs: Uint8Array[]; /** ConnectRequest timeout. */ - public timeout: number; + public timeout?: (number|null); + + /** ConnectRequest _timeout. */ + public _timeout?: "timeout"; /** * Encodes the specified ConnectRequest message. Does not implicitly {@link ConnectRequest.verify|verify} messages. @@ -398,7 +443,10 @@ export class StreamOpenRequest implements IStreamOpenRequest { public proto: string[]; /** StreamOpenRequest timeout. */ - public timeout: number; + public timeout?: (number|null); + + /** StreamOpenRequest _timeout. */ + public _timeout?: "timeout"; /** * Encodes the specified StreamOpenRequest message. Does not implicitly {@link StreamOpenRequest.verify|verify} messages. @@ -673,22 +721,40 @@ export class DHTRequest implements IDHTRequest { public type: DHTRequest.Type; /** DHTRequest peer. */ - public peer: Uint8Array; + public peer?: (Uint8Array|null); /** DHTRequest cid. */ - public cid: Uint8Array; + public cid?: (Uint8Array|null); /** DHTRequest key. */ - public key: Uint8Array; + public key?: (Uint8Array|null); /** DHTRequest value. */ - public value: Uint8Array; + public value?: (Uint8Array|null); /** DHTRequest count. */ - public count: number; + public count?: (number|null); /** DHTRequest timeout. */ - public timeout: number; + public timeout?: (number|null); + + /** DHTRequest _peer. */ + public _peer?: "peer"; + + /** DHTRequest _cid. */ + public _cid?: "cid"; + + /** DHTRequest _key. */ + public _key?: "key"; + + /** DHTRequest _value. */ + public _value?: "value"; + + /** DHTRequest _count. */ + public _count?: "count"; + + /** DHTRequest _timeout. */ + public _timeout?: "timeout"; /** * Encodes the specified DHTRequest message. Does not implicitly {@link DHTRequest.verify|verify} messages. @@ -775,7 +841,13 @@ export class DHTResponse implements IDHTResponse { public peer?: (IPeerInfo|null); /** DHTResponse value. */ - public value: Uint8Array; + public value?: (Uint8Array|null); + + /** DHTResponse _peer. */ + public _peer?: "peer"; + + /** DHTResponse _value. */ + public _value?: "value"; /** * Encodes the specified DHTResponse message. Does not implicitly {@link DHTResponse.verify|verify} messages. @@ -921,13 +993,22 @@ export class ConnManagerRequest implements IConnManagerRequest { public type: ConnManagerRequest.Type; /** ConnManagerRequest peer. */ - public peer: Uint8Array; + public peer?: (Uint8Array|null); /** ConnManagerRequest tag. */ - public tag: string; + public tag?: (string|null); /** ConnManagerRequest weight. */ - public weight: number; + public weight?: (number|null); + + /** ConnManagerRequest _peer. */ + public _peer?: "peer"; + + /** ConnManagerRequest _tag. */ + public _tag?: "tag"; + + /** ConnManagerRequest _weight. */ + public _weight?: "weight"; /** * Encodes the specified ConnManagerRequest message. Does not implicitly {@link ConnManagerRequest.verify|verify} messages. @@ -1064,10 +1145,16 @@ export class PSRequest implements IPSRequest { public type: PSRequest.Type; /** PSRequest topic. */ - public topic: string; + public topic?: (string|null); /** PSRequest data. */ - public data: Uint8Array; + public data?: (Uint8Array|null); + + /** PSRequest _topic. */ + public _topic?: "topic"; + + /** PSRequest _data. */ + public _data?: "data"; /** * Encodes the specified PSRequest message. Does not implicitly {@link PSRequest.verify|verify} messages. @@ -1152,22 +1239,37 @@ export class PSMessage implements IPSMessage { constructor(p?: IPSMessage); /** PSMessage from. */ - public from: Uint8Array; + public from?: (Uint8Array|null); /** PSMessage data. */ - public data: Uint8Array; + public data?: (Uint8Array|null); /** PSMessage seqno. */ - public seqno: Uint8Array; + public seqno?: (Uint8Array|null); /** PSMessage topicIDs. */ public topicIDs: string[]; /** PSMessage signature. */ - public signature: Uint8Array; + public signature?: (Uint8Array|null); /** PSMessage key. */ - public key: Uint8Array; + public key?: (Uint8Array|null); + + /** PSMessage _from. */ + public _from?: "from"; + + /** PSMessage _data. */ + public _data?: "data"; + + /** PSMessage _seqno. */ + public _seqno?: "seqno"; + + /** PSMessage _signature. */ + public _signature?: "signature"; + + /** PSMessage _key. */ + public _key?: "key"; /** * Encodes the specified PSMessage message. Does not implicitly {@link PSMessage.verify|verify} messages. @@ -1300,11 +1402,14 @@ export class PeerstoreRequest implements IPeerstoreRequest { public type: PeerstoreRequest.Type; /** PeerstoreRequest id. */ - public id: Uint8Array; + public id?: (Uint8Array|null); /** PeerstoreRequest protos. */ public protos: string[]; + /** PeerstoreRequest _id. */ + public _id?: "id"; + /** * Encodes the specified PeerstoreRequest message. Does not implicitly {@link PeerstoreRequest.verify|verify} messages. * @param m PeerstoreRequest message or plain object to encode @@ -1379,6 +1484,9 @@ export class PeerstoreResponse implements IPeerstoreResponse { /** PeerstoreResponse protos. */ public protos: string[]; + /** PeerstoreResponse _peer. */ + public _peer?: "peer"; + /** * Encodes the specified PeerstoreResponse message. Does not implicitly {@link PeerstoreResponse.verify|verify} messages. * @param m PeerstoreResponse message or plain object to encode diff --git a/src/protocol/index.js b/packages/libp2p-daemon-protocol/src/index.js similarity index 87% rename from src/protocol/index.js rename to packages/libp2p-daemon-protocol/src/index.js index ffa5371a..7f5e12fb 100644 --- a/src/protocol/index.js +++ b/packages/libp2p-daemon-protocol/src/index.js @@ -1,15 +1,13 @@ /*eslint-disable*/ -"use strict"; - -var $protobuf = require("protobufjs/minimal"); +import $protobuf from "protobufjs/minimal.js"; // Common aliases -var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; +const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util; // Exported root namespace -var $root = $protobuf.roots["libp2p-daemon"] || ($protobuf.roots["libp2p-daemon"] = {}); +const $root = $protobuf.roots["libp2p-daemon"] || ($protobuf.roots["libp2p-daemon"] = {}); -$root.Request = (function() { +export const Request = $root.Request = (() => { /** * Properties of a Request. @@ -113,6 +111,97 @@ $root.Request = (function() { */ Request.prototype.peerStore = null; + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * Request _connect. + * @member {"connect"|undefined} _connect + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_connect", { + get: $util.oneOfGetter($oneOfFields = ["connect"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _streamOpen. + * @member {"streamOpen"|undefined} _streamOpen + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_streamOpen", { + get: $util.oneOfGetter($oneOfFields = ["streamOpen"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _streamHandler. + * @member {"streamHandler"|undefined} _streamHandler + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_streamHandler", { + get: $util.oneOfGetter($oneOfFields = ["streamHandler"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _dht. + * @member {"dht"|undefined} _dht + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_dht", { + get: $util.oneOfGetter($oneOfFields = ["dht"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _connManager. + * @member {"connManager"|undefined} _connManager + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_connManager", { + get: $util.oneOfGetter($oneOfFields = ["connManager"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _disconnect. + * @member {"disconnect"|undefined} _disconnect + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_disconnect", { + get: $util.oneOfGetter($oneOfFields = ["disconnect"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _pubsub. + * @member {"pubsub"|undefined} _pubsub + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_pubsub", { + get: $util.oneOfGetter($oneOfFields = ["pubsub"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Request _peerStore. + * @member {"peerStore"|undefined} _peerStore + * @memberof Request + * @instance + */ + Object.defineProperty(Request.prototype, "_peerStore", { + get: $util.oneOfGetter($oneOfFields = ["peerStore"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Encodes the specified Request message. Does not implicitly {@link Request.verify|verify} messages. * @function encode @@ -312,41 +401,49 @@ $root.Request = (function() { var d = {}; if (o.defaults) { d.type = o.enums === String ? "IDENTIFY" : 0; - d.connect = null; - d.streamOpen = null; - d.streamHandler = null; - d.dht = null; - d.connManager = null; - d.disconnect = null; - d.pubsub = null; - d.peerStore = null; } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.Request.Type[m.type] : m.type; } if (m.connect != null && m.hasOwnProperty("connect")) { d.connect = $root.ConnectRequest.toObject(m.connect, o); + if (o.oneofs) + d._connect = "connect"; } if (m.streamOpen != null && m.hasOwnProperty("streamOpen")) { d.streamOpen = $root.StreamOpenRequest.toObject(m.streamOpen, o); + if (o.oneofs) + d._streamOpen = "streamOpen"; } if (m.streamHandler != null && m.hasOwnProperty("streamHandler")) { d.streamHandler = $root.StreamHandlerRequest.toObject(m.streamHandler, o); + if (o.oneofs) + d._streamHandler = "streamHandler"; } if (m.dht != null && m.hasOwnProperty("dht")) { d.dht = $root.DHTRequest.toObject(m.dht, o); + if (o.oneofs) + d._dht = "dht"; } if (m.connManager != null && m.hasOwnProperty("connManager")) { d.connManager = $root.ConnManagerRequest.toObject(m.connManager, o); + if (o.oneofs) + d._connManager = "connManager"; } if (m.disconnect != null && m.hasOwnProperty("disconnect")) { d.disconnect = $root.DisconnectRequest.toObject(m.disconnect, o); + if (o.oneofs) + d._disconnect = "disconnect"; } if (m.pubsub != null && m.hasOwnProperty("pubsub")) { d.pubsub = $root.PSRequest.toObject(m.pubsub, o); + if (o.oneofs) + d._pubsub = "pubsub"; } if (m.peerStore != null && m.hasOwnProperty("peerStore")) { d.peerStore = $root.PeerstoreRequest.toObject(m.peerStore, o); + if (o.oneofs) + d._peerStore = "peerStore"; } return d; }; @@ -378,7 +475,7 @@ $root.Request = (function() { * @property {number} PEERSTORE=9 PEERSTORE value */ Request.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "IDENTIFY"] = 0; values[valuesById[1] = "CONNECT"] = 1; values[valuesById[2] = "STREAM_OPEN"] = 2; @@ -395,7 +492,7 @@ $root.Request = (function() { return Request; })(); -$root.Response = (function() { +export const Response = $root.Response = (() => { /** * Properties of a Response. @@ -491,6 +588,75 @@ $root.Response = (function() { */ Response.prototype.peerStore = null; + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * Response _error. + * @member {"error"|undefined} _error + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_error", { + get: $util.oneOfGetter($oneOfFields = ["error"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Response _streamInfo. + * @member {"streamInfo"|undefined} _streamInfo + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_streamInfo", { + get: $util.oneOfGetter($oneOfFields = ["streamInfo"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Response _identify. + * @member {"identify"|undefined} _identify + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_identify", { + get: $util.oneOfGetter($oneOfFields = ["identify"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Response _dht. + * @member {"dht"|undefined} _dht + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_dht", { + get: $util.oneOfGetter($oneOfFields = ["dht"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Response _pubsub. + * @member {"pubsub"|undefined} _pubsub + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_pubsub", { + get: $util.oneOfGetter($oneOfFields = ["pubsub"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * Response _peerStore. + * @member {"peerStore"|undefined} _peerStore + * @memberof Response + * @instance + */ + Object.defineProperty(Response.prototype, "_peerStore", { + get: $util.oneOfGetter($oneOfFields = ["peerStore"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Encodes the specified Response message. Does not implicitly {@link Response.verify|verify} messages. * @function encode @@ -660,27 +826,29 @@ $root.Response = (function() { } if (o.defaults) { d.type = o.enums === String ? "OK" : 0; - d.error = null; - d.streamInfo = null; - d.identify = null; - d.dht = null; - d.pubsub = null; - d.peerStore = null; } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.Response.Type[m.type] : m.type; } if (m.error != null && m.hasOwnProperty("error")) { d.error = $root.ErrorResponse.toObject(m.error, o); + if (o.oneofs) + d._error = "error"; } if (m.streamInfo != null && m.hasOwnProperty("streamInfo")) { d.streamInfo = $root.StreamInfo.toObject(m.streamInfo, o); + if (o.oneofs) + d._streamInfo = "streamInfo"; } if (m.identify != null && m.hasOwnProperty("identify")) { d.identify = $root.IdentifyResponse.toObject(m.identify, o); + if (o.oneofs) + d._identify = "identify"; } if (m.dht != null && m.hasOwnProperty("dht")) { d.dht = $root.DHTResponse.toObject(m.dht, o); + if (o.oneofs) + d._dht = "dht"; } if (m.peers && m.peers.length) { d.peers = []; @@ -690,9 +858,13 @@ $root.Response = (function() { } if (m.pubsub != null && m.hasOwnProperty("pubsub")) { d.pubsub = $root.PSResponse.toObject(m.pubsub, o); + if (o.oneofs) + d._pubsub = "pubsub"; } if (m.peerStore != null && m.hasOwnProperty("peerStore")) { d.peerStore = $root.PeerstoreResponse.toObject(m.peerStore, o); + if (o.oneofs) + d._peerStore = "peerStore"; } return d; }; @@ -716,7 +888,7 @@ $root.Response = (function() { * @property {number} ERROR=1 ERROR value */ Response.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "OK"] = 0; values[valuesById[1] = "ERROR"] = 1; return values; @@ -725,7 +897,7 @@ $root.Response = (function() { return Response; })(); -$root.IdentifyResponse = (function() { +export const IdentifyResponse = $root.IdentifyResponse = (() => { /** * Properties of an IdentifyResponse. @@ -906,7 +1078,7 @@ $root.IdentifyResponse = (function() { return IdentifyResponse; })(); -$root.ConnectRequest = (function() { +export const ConnectRequest = $root.ConnectRequest = (() => { /** * Properties of a ConnectRequest. @@ -951,11 +1123,25 @@ $root.ConnectRequest = (function() { /** * ConnectRequest timeout. - * @member {number} timeout + * @member {number|null|undefined} timeout * @memberof ConnectRequest * @instance */ - ConnectRequest.prototype.timeout = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + ConnectRequest.prototype.timeout = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * ConnectRequest _timeout. + * @member {"timeout"|undefined} _timeout + * @memberof ConnectRequest + * @instance + */ + Object.defineProperty(ConnectRequest.prototype, "_timeout", { + get: $util.oneOfGetter($oneOfFields = ["timeout"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified ConnectRequest message. Does not implicitly {@link ConnectRequest.verify|verify} messages. @@ -1084,11 +1270,6 @@ $root.ConnectRequest = (function() { if (o.bytes !== Array) d.peer = $util.newBuffer(d.peer); } - if ($util.Long) { - var n = new $util.Long(0, 0, false); - d.timeout = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; - } else - d.timeout = o.longs === String ? "0" : 0; } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = o.bytes === String ? $util.base64.encode(m.peer, 0, m.peer.length) : o.bytes === Array ? Array.prototype.slice.call(m.peer) : m.peer; @@ -1104,6 +1285,8 @@ $root.ConnectRequest = (function() { d.timeout = o.longs === String ? String(m.timeout) : m.timeout; else d.timeout = o.longs === String ? $util.Long.prototype.toString.call(m.timeout) : o.longs === Number ? new $util.LongBits(m.timeout.low >>> 0, m.timeout.high >>> 0).toNumber() : m.timeout; + if (o.oneofs) + d._timeout = "timeout"; } return d; }; @@ -1122,7 +1305,7 @@ $root.ConnectRequest = (function() { return ConnectRequest; })(); -$root.StreamOpenRequest = (function() { +export const StreamOpenRequest = $root.StreamOpenRequest = (() => { /** * Properties of a StreamOpenRequest. @@ -1167,11 +1350,25 @@ $root.StreamOpenRequest = (function() { /** * StreamOpenRequest timeout. - * @member {number} timeout + * @member {number|null|undefined} timeout * @memberof StreamOpenRequest * @instance */ - StreamOpenRequest.prototype.timeout = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + StreamOpenRequest.prototype.timeout = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * StreamOpenRequest _timeout. + * @member {"timeout"|undefined} _timeout + * @memberof StreamOpenRequest + * @instance + */ + Object.defineProperty(StreamOpenRequest.prototype, "_timeout", { + get: $util.oneOfGetter($oneOfFields = ["timeout"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified StreamOpenRequest message. Does not implicitly {@link StreamOpenRequest.verify|verify} messages. @@ -1297,11 +1494,6 @@ $root.StreamOpenRequest = (function() { if (o.bytes !== Array) d.peer = $util.newBuffer(d.peer); } - if ($util.Long) { - var n = new $util.Long(0, 0, false); - d.timeout = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; - } else - d.timeout = o.longs === String ? "0" : 0; } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = o.bytes === String ? $util.base64.encode(m.peer, 0, m.peer.length) : o.bytes === Array ? Array.prototype.slice.call(m.peer) : m.peer; @@ -1317,6 +1509,8 @@ $root.StreamOpenRequest = (function() { d.timeout = o.longs === String ? String(m.timeout) : m.timeout; else d.timeout = o.longs === String ? $util.Long.prototype.toString.call(m.timeout) : o.longs === Number ? new $util.LongBits(m.timeout.low >>> 0, m.timeout.high >>> 0).toNumber() : m.timeout; + if (o.oneofs) + d._timeout = "timeout"; } return d; }; @@ -1335,7 +1529,7 @@ $root.StreamOpenRequest = (function() { return StreamOpenRequest; })(); -$root.StreamHandlerRequest = (function() { +export const StreamHandlerRequest = $root.StreamHandlerRequest = (() => { /** * Properties of a StreamHandlerRequest. @@ -1513,7 +1707,7 @@ $root.StreamHandlerRequest = (function() { return StreamHandlerRequest; })(); -$root.ErrorResponse = (function() { +export const ErrorResponse = $root.ErrorResponse = (() => { /** * Properties of an ErrorResponse. @@ -1646,7 +1840,7 @@ $root.ErrorResponse = (function() { return ErrorResponse; })(); -$root.StreamInfo = (function() { +export const StreamInfo = $root.StreamInfo = (() => { /** * Properties of a StreamInfo. @@ -1841,7 +2035,7 @@ $root.StreamInfo = (function() { return StreamInfo; })(); -$root.DHTRequest = (function() { +export const DHTRequest = $root.DHTRequest = (() => { /** * Properties of a DHTRequest. @@ -1881,51 +2075,120 @@ $root.DHTRequest = (function() { /** * DHTRequest peer. - * @member {Uint8Array} peer + * @member {Uint8Array|null|undefined} peer * @memberof DHTRequest * @instance */ - DHTRequest.prototype.peer = $util.newBuffer([]); + DHTRequest.prototype.peer = null; /** * DHTRequest cid. - * @member {Uint8Array} cid + * @member {Uint8Array|null|undefined} cid * @memberof DHTRequest * @instance */ - DHTRequest.prototype.cid = $util.newBuffer([]); + DHTRequest.prototype.cid = null; /** * DHTRequest key. - * @member {Uint8Array} key + * @member {Uint8Array|null|undefined} key * @memberof DHTRequest * @instance */ - DHTRequest.prototype.key = $util.newBuffer([]); + DHTRequest.prototype.key = null; /** * DHTRequest value. - * @member {Uint8Array} value + * @member {Uint8Array|null|undefined} value * @memberof DHTRequest * @instance */ - DHTRequest.prototype.value = $util.newBuffer([]); + DHTRequest.prototype.value = null; /** * DHTRequest count. - * @member {number} count + * @member {number|null|undefined} count * @memberof DHTRequest * @instance */ - DHTRequest.prototype.count = 0; + DHTRequest.prototype.count = null; /** * DHTRequest timeout. - * @member {number} timeout + * @member {number|null|undefined} timeout + * @memberof DHTRequest + * @instance + */ + DHTRequest.prototype.timeout = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * DHTRequest _peer. + * @member {"peer"|undefined} _peer + * @memberof DHTRequest + * @instance + */ + Object.defineProperty(DHTRequest.prototype, "_peer", { + get: $util.oneOfGetter($oneOfFields = ["peer"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTRequest _cid. + * @member {"cid"|undefined} _cid * @memberof DHTRequest * @instance */ - DHTRequest.prototype.timeout = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + Object.defineProperty(DHTRequest.prototype, "_cid", { + get: $util.oneOfGetter($oneOfFields = ["cid"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTRequest _key. + * @member {"key"|undefined} _key + * @memberof DHTRequest + * @instance + */ + Object.defineProperty(DHTRequest.prototype, "_key", { + get: $util.oneOfGetter($oneOfFields = ["key"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTRequest _value. + * @member {"value"|undefined} _value + * @memberof DHTRequest + * @instance + */ + Object.defineProperty(DHTRequest.prototype, "_value", { + get: $util.oneOfGetter($oneOfFields = ["value"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTRequest _count. + * @member {"count"|undefined} _count + * @memberof DHTRequest + * @instance + */ + Object.defineProperty(DHTRequest.prototype, "_count", { + get: $util.oneOfGetter($oneOfFields = ["count"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTRequest _timeout. + * @member {"timeout"|undefined} _timeout + * @memberof DHTRequest + * @instance + */ + Object.defineProperty(DHTRequest.prototype, "_timeout", { + get: $util.oneOfGetter($oneOfFields = ["timeout"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified DHTRequest message. Does not implicitly {@link DHTRequest.verify|verify} messages. @@ -2109,64 +2372,42 @@ $root.DHTRequest = (function() { var d = {}; if (o.defaults) { d.type = o.enums === String ? "FIND_PEER" : 0; - if (o.bytes === String) - d.peer = ""; - else { - d.peer = []; - if (o.bytes !== Array) - d.peer = $util.newBuffer(d.peer); - } - if (o.bytes === String) - d.cid = ""; - else { - d.cid = []; - if (o.bytes !== Array) - d.cid = $util.newBuffer(d.cid); - } - if (o.bytes === String) - d.key = ""; - else { - d.key = []; - if (o.bytes !== Array) - d.key = $util.newBuffer(d.key); - } - if (o.bytes === String) - d.value = ""; - else { - d.value = []; - if (o.bytes !== Array) - d.value = $util.newBuffer(d.value); - } - d.count = 0; - if ($util.Long) { - var n = new $util.Long(0, 0, false); - d.timeout = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; - } else - d.timeout = o.longs === String ? "0" : 0; } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.DHTRequest.Type[m.type] : m.type; } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = o.bytes === String ? $util.base64.encode(m.peer, 0, m.peer.length) : o.bytes === Array ? Array.prototype.slice.call(m.peer) : m.peer; + if (o.oneofs) + d._peer = "peer"; } if (m.cid != null && m.hasOwnProperty("cid")) { d.cid = o.bytes === String ? $util.base64.encode(m.cid, 0, m.cid.length) : o.bytes === Array ? Array.prototype.slice.call(m.cid) : m.cid; + if (o.oneofs) + d._cid = "cid"; } if (m.key != null && m.hasOwnProperty("key")) { d.key = o.bytes === String ? $util.base64.encode(m.key, 0, m.key.length) : o.bytes === Array ? Array.prototype.slice.call(m.key) : m.key; + if (o.oneofs) + d._key = "key"; } if (m.value != null && m.hasOwnProperty("value")) { d.value = o.bytes === String ? $util.base64.encode(m.value, 0, m.value.length) : o.bytes === Array ? Array.prototype.slice.call(m.value) : m.value; + if (o.oneofs) + d._value = "value"; } if (m.count != null && m.hasOwnProperty("count")) { d.count = m.count; + if (o.oneofs) + d._count = "count"; } if (m.timeout != null && m.hasOwnProperty("timeout")) { if (typeof m.timeout === "number") d.timeout = o.longs === String ? String(m.timeout) : m.timeout; else d.timeout = o.longs === String ? $util.Long.prototype.toString.call(m.timeout) : o.longs === Number ? new $util.LongBits(m.timeout.low >>> 0, m.timeout.high >>> 0).toNumber() : m.timeout; + if (o.oneofs) + d._timeout = "timeout"; } return d; }; @@ -2197,7 +2438,7 @@ $root.DHTRequest = (function() { * @property {number} PROVIDE=8 PROVIDE value */ DHTRequest.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "FIND_PEER"] = 0; values[valuesById[1] = "FIND_PEERS_CONNECTED_TO_PEER"] = 1; values[valuesById[2] = "FIND_PROVIDERS"] = 2; @@ -2213,7 +2454,7 @@ $root.DHTRequest = (function() { return DHTRequest; })(); -$root.DHTResponse = (function() { +export const DHTResponse = $root.DHTResponse = (() => { /** * Properties of a DHTResponse. @@ -2257,11 +2498,36 @@ $root.DHTResponse = (function() { /** * DHTResponse value. - * @member {Uint8Array} value + * @member {Uint8Array|null|undefined} value + * @memberof DHTResponse + * @instance + */ + DHTResponse.prototype.value = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * DHTResponse _peer. + * @member {"peer"|undefined} _peer + * @memberof DHTResponse + * @instance + */ + Object.defineProperty(DHTResponse.prototype, "_peer", { + get: $util.oneOfGetter($oneOfFields = ["peer"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * DHTResponse _value. + * @member {"value"|undefined} _value * @memberof DHTResponse * @instance */ - DHTResponse.prototype.value = $util.newBuffer([]); + Object.defineProperty(DHTResponse.prototype, "_value", { + get: $util.oneOfGetter($oneOfFields = ["value"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified DHTResponse message. Does not implicitly {@link DHTResponse.verify|verify} messages. @@ -2375,23 +2641,19 @@ $root.DHTResponse = (function() { var d = {}; if (o.defaults) { d.type = o.enums === String ? "BEGIN" : 0; - d.peer = null; - if (o.bytes === String) - d.value = ""; - else { - d.value = []; - if (o.bytes !== Array) - d.value = $util.newBuffer(d.value); - } } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.DHTResponse.Type[m.type] : m.type; } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = $root.PeerInfo.toObject(m.peer, o); + if (o.oneofs) + d._peer = "peer"; } if (m.value != null && m.hasOwnProperty("value")) { d.value = o.bytes === String ? $util.base64.encode(m.value, 0, m.value.length) : o.bytes === Array ? Array.prototype.slice.call(m.value) : m.value; + if (o.oneofs) + d._value = "value"; } return d; }; @@ -2416,7 +2678,7 @@ $root.DHTResponse = (function() { * @property {number} END=2 END value */ DHTResponse.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "BEGIN"] = 0; values[valuesById[1] = "VALUE"] = 1; values[valuesById[2] = "END"] = 2; @@ -2426,7 +2688,7 @@ $root.DHTResponse = (function() { return DHTResponse; })(); -$root.PeerInfo = (function() { +export const PeerInfo = $root.PeerInfo = (() => { /** * Properties of a PeerInfo. @@ -2607,7 +2869,7 @@ $root.PeerInfo = (function() { return PeerInfo; })(); -$root.ConnManagerRequest = (function() { +export const ConnManagerRequest = $root.ConnManagerRequest = (() => { /** * Properties of a ConnManagerRequest. @@ -2644,27 +2906,63 @@ $root.ConnManagerRequest = (function() { /** * ConnManagerRequest peer. - * @member {Uint8Array} peer + * @member {Uint8Array|null|undefined} peer * @memberof ConnManagerRequest * @instance */ - ConnManagerRequest.prototype.peer = $util.newBuffer([]); + ConnManagerRequest.prototype.peer = null; /** * ConnManagerRequest tag. - * @member {string} tag + * @member {string|null|undefined} tag * @memberof ConnManagerRequest * @instance */ - ConnManagerRequest.prototype.tag = ""; + ConnManagerRequest.prototype.tag = null; /** * ConnManagerRequest weight. - * @member {number} weight + * @member {number|null|undefined} weight + * @memberof ConnManagerRequest + * @instance + */ + ConnManagerRequest.prototype.weight = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * ConnManagerRequest _peer. + * @member {"peer"|undefined} _peer + * @memberof ConnManagerRequest + * @instance + */ + Object.defineProperty(ConnManagerRequest.prototype, "_peer", { + get: $util.oneOfGetter($oneOfFields = ["peer"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * ConnManagerRequest _tag. + * @member {"tag"|undefined} _tag * @memberof ConnManagerRequest * @instance */ - ConnManagerRequest.prototype.weight = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + Object.defineProperty(ConnManagerRequest.prototype, "_tag", { + get: $util.oneOfGetter($oneOfFields = ["tag"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * ConnManagerRequest _weight. + * @member {"weight"|undefined} _weight + * @memberof ConnManagerRequest + * @instance + */ + Object.defineProperty(ConnManagerRequest.prototype, "_weight", { + get: $util.oneOfGetter($oneOfFields = ["weight"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified ConnManagerRequest message. Does not implicitly {@link ConnManagerRequest.verify|verify} messages. @@ -2791,34 +3089,27 @@ $root.ConnManagerRequest = (function() { var d = {}; if (o.defaults) { d.type = o.enums === String ? "TAG_PEER" : 0; - if (o.bytes === String) - d.peer = ""; - else { - d.peer = []; - if (o.bytes !== Array) - d.peer = $util.newBuffer(d.peer); - } - d.tag = ""; - if ($util.Long) { - var n = new $util.Long(0, 0, false); - d.weight = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n; - } else - d.weight = o.longs === String ? "0" : 0; } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.ConnManagerRequest.Type[m.type] : m.type; } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = o.bytes === String ? $util.base64.encode(m.peer, 0, m.peer.length) : o.bytes === Array ? Array.prototype.slice.call(m.peer) : m.peer; + if (o.oneofs) + d._peer = "peer"; } if (m.tag != null && m.hasOwnProperty("tag")) { d.tag = m.tag; + if (o.oneofs) + d._tag = "tag"; } if (m.weight != null && m.hasOwnProperty("weight")) { if (typeof m.weight === "number") d.weight = o.longs === String ? String(m.weight) : m.weight; else d.weight = o.longs === String ? $util.Long.prototype.toString.call(m.weight) : o.longs === Number ? new $util.LongBits(m.weight.low >>> 0, m.weight.high >>> 0).toNumber() : m.weight; + if (o.oneofs) + d._weight = "weight"; } return d; }; @@ -2843,7 +3134,7 @@ $root.ConnManagerRequest = (function() { * @property {number} TRIM=2 TRIM value */ ConnManagerRequest.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "TAG_PEER"] = 0; values[valuesById[1] = "UNTAG_PEER"] = 1; values[valuesById[2] = "TRIM"] = 2; @@ -2853,7 +3144,7 @@ $root.ConnManagerRequest = (function() { return ConnManagerRequest; })(); -$root.DisconnectRequest = (function() { +export const DisconnectRequest = $root.DisconnectRequest = (() => { /** * Properties of a DisconnectRequest. @@ -2995,7 +3286,7 @@ $root.DisconnectRequest = (function() { return DisconnectRequest; })(); -$root.PSRequest = (function() { +export const PSRequest = $root.PSRequest = (() => { /** * Properties of a PSRequest. @@ -3031,19 +3322,44 @@ $root.PSRequest = (function() { /** * PSRequest topic. - * @member {string} topic + * @member {string|null|undefined} topic * @memberof PSRequest * @instance */ - PSRequest.prototype.topic = ""; + PSRequest.prototype.topic = null; /** * PSRequest data. - * @member {Uint8Array} data + * @member {Uint8Array|null|undefined} data + * @memberof PSRequest + * @instance + */ + PSRequest.prototype.data = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * PSRequest _topic. + * @member {"topic"|undefined} _topic + * @memberof PSRequest + * @instance + */ + Object.defineProperty(PSRequest.prototype, "_topic", { + get: $util.oneOfGetter($oneOfFields = ["topic"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * PSRequest _data. + * @member {"data"|undefined} _data * @memberof PSRequest * @instance */ - PSRequest.prototype.data = $util.newBuffer([]); + Object.defineProperty(PSRequest.prototype, "_data", { + get: $util.oneOfGetter($oneOfFields = ["data"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified PSRequest message. Does not implicitly {@link PSRequest.verify|verify} messages. @@ -3159,23 +3475,19 @@ $root.PSRequest = (function() { var d = {}; if (o.defaults) { d.type = o.enums === String ? "GET_TOPICS" : 0; - d.topic = ""; - if (o.bytes === String) - d.data = ""; - else { - d.data = []; - if (o.bytes !== Array) - d.data = $util.newBuffer(d.data); - } } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.PSRequest.Type[m.type] : m.type; } if (m.topic != null && m.hasOwnProperty("topic")) { d.topic = m.topic; + if (o.oneofs) + d._topic = "topic"; } if (m.data != null && m.hasOwnProperty("data")) { d.data = o.bytes === String ? $util.base64.encode(m.data, 0, m.data.length) : o.bytes === Array ? Array.prototype.slice.call(m.data) : m.data; + if (o.oneofs) + d._data = "data"; } return d; }; @@ -3201,7 +3513,7 @@ $root.PSRequest = (function() { * @property {number} SUBSCRIBE=3 SUBSCRIBE value */ PSRequest.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[0] = "GET_TOPICS"] = 0; values[valuesById[1] = "LIST_PEERS"] = 1; values[valuesById[2] = "PUBLISH"] = 2; @@ -3212,7 +3524,7 @@ $root.PSRequest = (function() { return PSRequest; })(); -$root.PSMessage = (function() { +export const PSMessage = $root.PSMessage = (() => { /** * Properties of a PSMessage. @@ -3244,27 +3556,27 @@ $root.PSMessage = (function() { /** * PSMessage from. - * @member {Uint8Array} from + * @member {Uint8Array|null|undefined} from * @memberof PSMessage * @instance */ - PSMessage.prototype.from = $util.newBuffer([]); + PSMessage.prototype.from = null; /** * PSMessage data. - * @member {Uint8Array} data + * @member {Uint8Array|null|undefined} data * @memberof PSMessage * @instance */ - PSMessage.prototype.data = $util.newBuffer([]); + PSMessage.prototype.data = null; /** * PSMessage seqno. - * @member {Uint8Array} seqno + * @member {Uint8Array|null|undefined} seqno * @memberof PSMessage * @instance */ - PSMessage.prototype.seqno = $util.newBuffer([]); + PSMessage.prototype.seqno = null; /** * PSMessage topicIDs. @@ -3276,19 +3588,77 @@ $root.PSMessage = (function() { /** * PSMessage signature. - * @member {Uint8Array} signature + * @member {Uint8Array|null|undefined} signature * @memberof PSMessage * @instance */ - PSMessage.prototype.signature = $util.newBuffer([]); + PSMessage.prototype.signature = null; /** * PSMessage key. - * @member {Uint8Array} key + * @member {Uint8Array|null|undefined} key + * @memberof PSMessage + * @instance + */ + PSMessage.prototype.key = null; + + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * PSMessage _from. + * @member {"from"|undefined} _from * @memberof PSMessage * @instance */ - PSMessage.prototype.key = $util.newBuffer([]); + Object.defineProperty(PSMessage.prototype, "_from", { + get: $util.oneOfGetter($oneOfFields = ["from"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * PSMessage _data. + * @member {"data"|undefined} _data + * @memberof PSMessage + * @instance + */ + Object.defineProperty(PSMessage.prototype, "_data", { + get: $util.oneOfGetter($oneOfFields = ["data"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * PSMessage _seqno. + * @member {"seqno"|undefined} _seqno + * @memberof PSMessage + * @instance + */ + Object.defineProperty(PSMessage.prototype, "_seqno", { + get: $util.oneOfGetter($oneOfFields = ["seqno"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * PSMessage _signature. + * @member {"signature"|undefined} _signature + * @memberof PSMessage + * @instance + */ + Object.defineProperty(PSMessage.prototype, "_signature", { + get: $util.oneOfGetter($oneOfFields = ["signature"]), + set: $util.oneOfSetter($oneOfFields) + }); + + /** + * PSMessage _key. + * @member {"key"|undefined} _key + * @memberof PSMessage + * @instance + */ + Object.defineProperty(PSMessage.prototype, "_key", { + get: $util.oneOfGetter($oneOfFields = ["key"]), + set: $util.oneOfSetter($oneOfFields) + }); /** * Encodes the specified PSMessage message. Does not implicitly {@link PSMessage.verify|verify} messages. @@ -3434,51 +3804,20 @@ $root.PSMessage = (function() { if (o.arrays || o.defaults) { d.topicIDs = []; } - if (o.defaults) { - if (o.bytes === String) - d.from = ""; - else { - d.from = []; - if (o.bytes !== Array) - d.from = $util.newBuffer(d.from); - } - if (o.bytes === String) - d.data = ""; - else { - d.data = []; - if (o.bytes !== Array) - d.data = $util.newBuffer(d.data); - } - if (o.bytes === String) - d.seqno = ""; - else { - d.seqno = []; - if (o.bytes !== Array) - d.seqno = $util.newBuffer(d.seqno); - } - if (o.bytes === String) - d.signature = ""; - else { - d.signature = []; - if (o.bytes !== Array) - d.signature = $util.newBuffer(d.signature); - } - if (o.bytes === String) - d.key = ""; - else { - d.key = []; - if (o.bytes !== Array) - d.key = $util.newBuffer(d.key); - } - } if (m.from != null && m.hasOwnProperty("from")) { d.from = o.bytes === String ? $util.base64.encode(m.from, 0, m.from.length) : o.bytes === Array ? Array.prototype.slice.call(m.from) : m.from; + if (o.oneofs) + d._from = "from"; } if (m.data != null && m.hasOwnProperty("data")) { d.data = o.bytes === String ? $util.base64.encode(m.data, 0, m.data.length) : o.bytes === Array ? Array.prototype.slice.call(m.data) : m.data; + if (o.oneofs) + d._data = "data"; } if (m.seqno != null && m.hasOwnProperty("seqno")) { d.seqno = o.bytes === String ? $util.base64.encode(m.seqno, 0, m.seqno.length) : o.bytes === Array ? Array.prototype.slice.call(m.seqno) : m.seqno; + if (o.oneofs) + d._seqno = "seqno"; } if (m.topicIDs && m.topicIDs.length) { d.topicIDs = []; @@ -3488,9 +3827,13 @@ $root.PSMessage = (function() { } if (m.signature != null && m.hasOwnProperty("signature")) { d.signature = o.bytes === String ? $util.base64.encode(m.signature, 0, m.signature.length) : o.bytes === Array ? Array.prototype.slice.call(m.signature) : m.signature; + if (o.oneofs) + d._signature = "signature"; } if (m.key != null && m.hasOwnProperty("key")) { d.key = o.bytes === String ? $util.base64.encode(m.key, 0, m.key.length) : o.bytes === Array ? Array.prototype.slice.call(m.key) : m.key; + if (o.oneofs) + d._key = "key"; } return d; }; @@ -3509,7 +3852,7 @@ $root.PSMessage = (function() { return PSMessage; })(); -$root.PSResponse = (function() { +export const PSResponse = $root.PSResponse = (() => { /** * Properties of a PSResponse. @@ -3691,7 +4034,7 @@ $root.PSResponse = (function() { return PSResponse; })(); -$root.PeerstoreRequest = (function() { +export const PeerstoreRequest = $root.PeerstoreRequest = (() => { /** * Properties of a PeerstoreRequest. @@ -3728,11 +4071,11 @@ $root.PeerstoreRequest = (function() { /** * PeerstoreRequest id. - * @member {Uint8Array} id + * @member {Uint8Array|null|undefined} id * @memberof PeerstoreRequest * @instance */ - PeerstoreRequest.prototype.id = $util.newBuffer([]); + PeerstoreRequest.prototype.id = null; /** * PeerstoreRequest protos. @@ -3742,6 +4085,20 @@ $root.PeerstoreRequest = (function() { */ PeerstoreRequest.prototype.protos = $util.emptyArray; + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * PeerstoreRequest _id. + * @member {"id"|undefined} _id + * @memberof PeerstoreRequest + * @instance + */ + Object.defineProperty(PeerstoreRequest.prototype, "_id", { + get: $util.oneOfGetter($oneOfFields = ["id"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Encodes the specified PeerstoreRequest message. Does not implicitly {@link PeerstoreRequest.verify|verify} messages. * @function encode @@ -3860,19 +4217,14 @@ $root.PeerstoreRequest = (function() { } if (o.defaults) { d.type = o.enums === String ? "GET_PROTOCOLS" : 1; - if (o.bytes === String) - d.id = ""; - else { - d.id = []; - if (o.bytes !== Array) - d.id = $util.newBuffer(d.id); - } } if (m.type != null && m.hasOwnProperty("type")) { d.type = o.enums === String ? $root.PeerstoreRequest.Type[m.type] : m.type; } if (m.id != null && m.hasOwnProperty("id")) { d.id = o.bytes === String ? $util.base64.encode(m.id, 0, m.id.length) : o.bytes === Array ? Array.prototype.slice.call(m.id) : m.id; + if (o.oneofs) + d._id = "id"; } if (m.protos && m.protos.length) { d.protos = []; @@ -3902,7 +4254,7 @@ $root.PeerstoreRequest = (function() { * @property {number} GET_PEER_INFO=2 GET_PEER_INFO value */ PeerstoreRequest.Type = (function() { - var valuesById = {}, values = Object.create(valuesById); + const valuesById = {}, values = Object.create(valuesById); values[valuesById[1] = "GET_PROTOCOLS"] = 1; values[valuesById[2] = "GET_PEER_INFO"] = 2; return values; @@ -3911,7 +4263,7 @@ $root.PeerstoreRequest = (function() { return PeerstoreRequest; })(); -$root.PeerstoreResponse = (function() { +export const PeerstoreResponse = $root.PeerstoreResponse = (() => { /** * Properties of a PeerstoreResponse. @@ -3953,6 +4305,20 @@ $root.PeerstoreResponse = (function() { */ PeerstoreResponse.prototype.protos = $util.emptyArray; + // OneOf field names bound to virtual getters and setters + let $oneOfFields; + + /** + * PeerstoreResponse _peer. + * @member {"peer"|undefined} _peer + * @memberof PeerstoreResponse + * @instance + */ + Object.defineProperty(PeerstoreResponse.prototype, "_peer", { + get: $util.oneOfGetter($oneOfFields = ["peer"]), + set: $util.oneOfSetter($oneOfFields) + }); + /** * Encodes the specified PeerstoreResponse message. Does not implicitly {@link PeerstoreResponse.verify|verify} messages. * @function encode @@ -4052,11 +4418,10 @@ $root.PeerstoreResponse = (function() { if (o.arrays || o.defaults) { d.protos = []; } - if (o.defaults) { - d.peer = null; - } if (m.peer != null && m.hasOwnProperty("peer")) { d.peer = $root.PeerInfo.toObject(m.peer, o); + if (o.oneofs) + d._peer = "peer"; } if (m.protos && m.protos.length) { d.protos = []; @@ -4081,4 +4446,4 @@ $root.PeerstoreResponse = (function() { return PeerstoreResponse; })(); -module.exports = $root; +export { $root as default }; diff --git a/src/protocol/index.proto b/packages/libp2p-daemon-protocol/src/index.proto similarity index 100% rename from src/protocol/index.proto rename to packages/libp2p-daemon-protocol/src/index.proto diff --git a/packages/libp2p-daemon-protocol/src/stream-handler.ts b/packages/libp2p-daemon-protocol/src/stream-handler.ts new file mode 100644 index 00000000..b794a9cd --- /dev/null +++ b/packages/libp2p-daemon-protocol/src/stream-handler.ts @@ -0,0 +1,66 @@ +import * as lp from 'it-length-prefixed' +import { handshake } from 'it-handshake' +import { logger } from '@libp2p/logger' +import type { Duplex, Source } from 'it-stream-types' +import type { Handshake } from 'it-handshake' + +const log = logger('libp2p:daemon-protocol:stream-handler') + +export interface StreamHandlerOptions { + stream: Duplex + maxLength?: number +} + +export class StreamHandler { + private readonly stream: Duplex + private readonly shake: Handshake + public decoder: Source + /** + * Create a stream handler for connection + */ + constructor (opts: StreamHandlerOptions) { + const { stream, maxLength } = opts + + this.stream = stream + this.shake = handshake(this.stream) + this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength ?? 4096 }) + } + + /** + * Read and decode message + */ + async read () { + // @ts-expect-error decoder is really a generator + const msg = await this.decoder.next() + if (msg.value != null) { + return msg.value.slice() + } + + log('read received no value, closing stream') + // End the stream, we didn't get data + await this.close() + } + + write (msg: Uint8Array) { + log('write message') + this.shake.write( + lp.encode.single(msg).slice() + ) + } + + /** + * Return the handshake rest stream and invalidate handler + */ + rest () { + this.shake.rest() + return this.shake.stream + } + + /** + * Close the stream + */ + async close () { + log('closing the stream') + await this.rest().sink([]) + } +} diff --git a/packages/libp2p-daemon-protocol/src/upgrader.ts b/packages/libp2p-daemon-protocol/src/upgrader.ts new file mode 100644 index 00000000..cf9905ae --- /dev/null +++ b/packages/libp2p-daemon-protocol/src/upgrader.ts @@ -0,0 +1,8 @@ +import type { Upgrader } from '@libp2p/interfaces/transport' + +export const passThroughUpgrader: Upgrader = { + // @ts-expect-error should return a connection + upgradeInbound: async maConn => maConn, + // @ts-expect-error should return a connection + upgradeOutbound: async maConn => maConn +} diff --git a/tsconfig.json b/packages/libp2p-daemon-protocol/tsconfig.json similarity index 54% rename from tsconfig.json rename to packages/libp2p-daemon-protocol/tsconfig.json index 4eecf340..761d6937 100644 --- a/tsconfig.json +++ b/packages/libp2p-daemon-protocol/tsconfig.json @@ -4,13 +4,19 @@ "outDir": "dist", "emitDeclarationOnly": false, "module": "ES2020", - "lib": ["ES2021", "ES2021.Promise", "ES2021.String", "ES2020.BigInt", "DOM", "DOM.Iterable"], + "lib": [ + "ES2021", + "ES2021.Promise", + "ES2021.String", + "ES2020.BigInt", + "DOM", + "DOM.Iterable" + ] }, "include": [ - "src", - "test" + "src" ], "exclude": [ - "src/protocol/*" + "src/index.js" ] } diff --git a/packages/libp2p-daemon-server/LICENSE b/packages/libp2p-daemon-server/LICENSE new file mode 100644 index 00000000..20ce483c --- /dev/null +++ b/packages/libp2p-daemon-server/LICENSE @@ -0,0 +1,4 @@ +This project is dual licensed under MIT and Apache-2.0. + +MIT: https://www.opensource.org/licenses/mit +Apache-2.0: https://www.apache.org/licenses/license-2.0 diff --git a/packages/libp2p-daemon-server/LICENSE-APACHE b/packages/libp2p-daemon-server/LICENSE-APACHE new file mode 100644 index 00000000..14478a3b --- /dev/null +++ b/packages/libp2p-daemon-server/LICENSE-APACHE @@ -0,0 +1,5 @@ +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. diff --git a/packages/libp2p-daemon-server/LICENSE-MIT b/packages/libp2p-daemon-server/LICENSE-MIT new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/packages/libp2p-daemon-server/LICENSE-MIT @@ -0,0 +1,19 @@ +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/packages/libp2p-daemon-server/README.md b/packages/libp2p-daemon-server/README.md new file mode 100644 index 00000000..b54b5445 --- /dev/null +++ b/packages/libp2p-daemon-server/README.md @@ -0,0 +1,43 @@ +libp2p-daemon JavaScript implementation +====== + + + + + + +> A standalone deployment of a libp2p host, running in its own OS process and installing a set of virtual endpoints to enable co-local applications to: communicate with peers, handle protocols, interact with the DHT, participate in pubsub, etc. no matter the language they are developed in, nor whether a native libp2p implementation exists in that language. + +## Lead Maintainer + +[Jacob Heun](https://github.com/jacobheun) + +## Specs + +The specs for the daemon are currently housed in the go implementation. You can read them at [libp2p/go-libp2p-daemon](https://github.com/libp2p/go-libp2p-daemon/blob/master/specs/README.md) + +## Install + +``` +npm i -g libp2p-daemon +``` + +## Usage + +For a full list of options, you can run help `jsp2pd --help`. +Running the defaults, `jsp2pd`, will start the daemon and bind it to a local unix socket path. +Daemon clients will be able to communicate with the daemon over that unix socket. + +As an alternative, you can use this daemon with a different version of libp2p as the one specified in `package.json`. You just need to define its path through an environment variable as follows: + +```sh +export LIBP2P_JS=./../../js-libp2p/src/index.js +``` + +## Contribute + +This module is actively under development. Please check out the issues and submit PRs! + +## License + +MIT © Protocol Labs diff --git a/packages/libp2p-daemon-server/package.json b/packages/libp2p-daemon-server/package.json new file mode 100644 index 00000000..d00fc96b --- /dev/null +++ b/packages/libp2p-daemon-server/package.json @@ -0,0 +1,153 @@ +{ + "name": "@libp2p/daemon-server", + "version": "0.0.2", + "description": "API server for libp2p-daemon instances", + "license": "Apache-2.0 OR MIT", + "homepage": "https://github.com/libp2p/js-libp2p-daemon/tree/master/packages/libp2p-daemon-server#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/libp2p/js-libp2p-daemon.git" + }, + "bugs": { + "url": "https://github.com/libp2p/js-libp2p-daemon/issues" + }, + "keywords": [ + "libp2p" + ], + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + }, + "type": "module", + "types": "./dist/src/index.d.ts", + "files": [ + "src", + "dist/src", + "!dist/test", + "!**/*.tsbuildinfo" + ], + "exports": { + ".": { + "import": "./dist/src/index.js" + } + }, + "eslintConfig": { + "extends": "ipfs", + "parserOptions": { + "sourceType": "module" + }, + "ignorePatterns": [ + "*.d.ts", + "src/profocol/index.js" + ] + }, + "release": { + "branches": [ + "master" + ], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { + "breaking": true, + "release": "major" + }, + { + "revert": true, + "release": "patch" + }, + { + "type": "feat", + "release": "minor" + }, + { + "type": "fix", + "release": "patch" + }, + { + "type": "chore", + "release": "patch" + }, + { + "type": "docs", + "release": "patch" + }, + { + "type": "test", + "release": "patch" + }, + { + "scope": "no-release", + "release": false + } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { + "preset": "conventionalcommits", + "presetConfig": { + "types": [ + { + "type": "feat", + "section": "Features" + }, + { + "type": "fix", + "section": "Bug Fixes" + }, + { + "type": "chore", + "section": "Trivial Changes" + }, + { + "type": "docs", + "section": "Trivial Changes" + }, + { + "type": "test", + "section": "Tests" + } + ] + } + } + ], + "@semantic-release/changelog", + "@semantic-release/npm", + "@semantic-release/github", + "@semantic-release/git" + ] + }, + "scripts": { + "lint": "aegir lint", + "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js", + "build": "tsc", + "pretest": "npm run build", + "test": "aegir test -t node -f dist/test/*.js dist/test/**/*.js", + "test:node": "aegir test -t node -f dist/test/*.js dist/test/**/*.js", + "release": "semantic-release" + }, + "dependencies": { + "@libp2p/daemon-protocol": "^0.0.1", + "@libp2p/interfaces": "^1.3.17", + "@libp2p/logger": "^1.1.2", + "@libp2p/tcp": "^1.0.6", + "@libp2p/peer-id": "^1.1.8", + "@multiformats/multiaddr": "^10.1.8", + "it-drain": "^1.0.5", + "it-length-prefixed": "^7.0.1", + "it-pipe": "^2.0.3", + "it-pushable": "^2.0.1", + "multiformats": "^9.6.4", + "uint8arrays": "^3.0.0" + }, + "devDependencies": { + "aegir": "^36.0.0", + "sinon": "^13.0.1", + "ts-sinon": "^2.0.2" + } +} diff --git a/packages/libp2p-daemon-server/src/dht.ts b/packages/libp2p-daemon-server/src/dht.ts new file mode 100644 index 00000000..83691962 --- /dev/null +++ b/packages/libp2p-daemon-server/src/dht.ts @@ -0,0 +1,153 @@ +/* eslint max-depth: ["error", 6] */ + +import { + DHTResponse +} from '@libp2p/daemon-protocol' +import { ErrorResponse, OkResponse } from './responses.js' +import type { PeerId } from '@libp2p/interfaces/peer-id' +import type { DualDHT } from '@libp2p/interfaces/dht' +import type { CID } from 'multiformats/cid' +import drain from 'it-drain' +import { logger } from '@libp2p/logger' + +const log = logger('libp2p:daemon-server:dht') + +export interface DHTOperationsInit { + dht: DualDHT +} + +export class DHTOperations { + private readonly dht: DualDHT + + constructor (init: DHTOperationsInit) { + const { dht } = init + + this.dht = dht + } + + async * provide (cid: CID) { + try { + await drain(this.dht.provide(cid)) + yield OkResponse() + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * getClosestPeers (key: Uint8Array) { + yield OkResponse({ + dht: { + type: DHTResponse.Type.BEGIN + } + }) + + for await (const event of this.dht.getClosestPeers(key)) { + if (event.name === 'PEER_RESPONSE') { + yield * event.closer.map(peer => DHTResponse.encode({ + type: DHTResponse.Type.VALUE, + value: peer.id.toBytes() + }).finish()) + } + } + + yield DHTResponse.encode({ + type: DHTResponse.Type.END + }).finish() + } + + async * getPublicKey (peerId: PeerId) { + yield ErrorResponse(new Error('FIX ME: not implemented')) + } + + async * getValue (key: Uint8Array) { + try { + for await (const event of this.dht.get(key)) { + if (event.name === 'VALUE') { + yield OkResponse({ + dht: { + type: DHTResponse.Type.VALUE, + value: event.value + } + }) + } + } + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * putValue (key: Uint8Array, value: Uint8Array) { + try { + await drain(this.dht.put(key, value)) + + yield OkResponse() + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * findPeer (peerId: PeerId) { + try { + for await (const event of this.dht.findPeer(peerId)) { + if (event.name === 'FINAL_PEER') { + yield OkResponse({ + dht: { + type: DHTResponse.Type.VALUE, + peer: { + id: event.peer.id.toBytes(), + addrs: event.peer.multiaddrs.map(m => m.bytes) + } + } + }) + } + } + + throw new Error('Peer not found') + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * findProviders (cid: CID, count: number) { + yield OkResponse({ + dht: { + type: DHTResponse.Type.BEGIN + } + }) + + try { + const maxNumProviders = count + let found = 0 + + for await (const event of this.dht.findProviders(cid)) { + if (event.name === 'PEER_RESPONSE') { + for (const provider of event.providers) { + found++ + + yield DHTResponse.encode({ + type: DHTResponse.Type.VALUE, + peer: { + id: provider.id.toBytes(), + addrs: (provider.multiaddrs ?? []).map(m => m.bytes) + } + }).finish() + } + + if (maxNumProviders === found) { + break + } + } + } + } catch (err: any) { + yield ErrorResponse(err) + } + + yield DHTResponse.encode({ + type: DHTResponse.Type.END + }).finish() + } +} diff --git a/packages/libp2p-daemon-server/src/index.ts b/packages/libp2p-daemon-server/src/index.ts new file mode 100644 index 00000000..17f65893 --- /dev/null +++ b/packages/libp2p-daemon-server/src/index.ts @@ -0,0 +1,524 @@ +/* eslint max-depth: ["error", 6] */ + +import { TCP } from '@libp2p/tcp' +import { Multiaddr, protocols } from '@multiformats/multiaddr' +import { CID } from 'multiformats/cid' +import * as lp from 'it-length-prefixed' +import { pipe } from 'it-pipe' +import { StreamHandler } from '@libp2p/daemon-protocol/stream-handler' +import { passThroughUpgrader } from '@libp2p/daemon-protocol/upgrader' +import { + Request, + DHTRequest, + PeerstoreRequest, + PSRequest, + StreamInfo, + IRequest, + IStreamInfo, + IPSRequest, + IDHTRequest, + IPeerstoreRequest +} from '@libp2p/daemon-protocol' +import type { Listener } from '@libp2p/interfaces/transport' +import type { Connection, Stream } from '@libp2p/interfaces/connection' +import type { PeerId } from '@libp2p/interfaces/peer-id' +import type { AbortOptions } from '@libp2p/interfaces' +import type { StreamHandler as StreamCallback } from '@libp2p/interfaces/registrar' +import type { DualDHT } from '@libp2p/interfaces/dht' +import type { PubSub } from '@libp2p/interfaces/pubsub' +import type { PeerStore } from '@libp2p/interfaces/peer-store' +import { ErrorResponse, OkResponse } from './responses.js' +import { DHTOperations } from './dht.js' +import { peerIdFromBytes } from '@libp2p/peer-id' +import { PubSubOperations } from './pubsub.js' +import { logger } from '@libp2p/logger' + +const LIMIT = 1 << 22 // 4MB +const log = logger('libp2p:daemon-server') + +export interface OpenStream { + streamInfo: IStreamInfo + connection: Stream +} + +export interface Libp2p { + peerId: PeerId + peerStore: PeerStore + pubsub?: PubSub + dht?: DualDHT + + getConnections: (peerId?: PeerId) => Connection[] + getPeers: () => PeerId[] + dial: (peer: PeerId | Multiaddr, options?: AbortOptions) => Promise + handle: (protocol: string | string[], handler: StreamCallback) => Promise + start: () => void | Promise + stop: () => void | Promise + getMultiaddrs: () => Multiaddr[] +} + +export interface DaemonInit { + multiaddr: Multiaddr + libp2pNode: any +} + +export interface Libp2pServer { + start: () => Promise + stop: () => Promise + getMultiaddr: () => Multiaddr +} + +export class Server implements Libp2pServer { + private readonly multiaddr: Multiaddr + private readonly libp2p: Libp2p + private readonly tcp: TCP + private readonly listener: Listener + private readonly streamHandlers: Record + private readonly dhtOperations?: DHTOperations + private readonly pubsubOperations?: PubSubOperations + + constructor (init: DaemonInit) { + const { multiaddr, libp2pNode } = init + + this.multiaddr = multiaddr + this.libp2p = libp2pNode + this.tcp = new TCP() + this.listener = this.tcp.createListener({ + handler: this.handleConnection.bind(this), + upgrader: passThroughUpgrader + }) + this.streamHandlers = {} + this._onExit = this._onExit.bind(this) + + if (libp2pNode.dht != null) { + this.dhtOperations = new DHTOperations({ dht: libp2pNode.dht }) + } + + if (libp2pNode.pubsub != null) { + this.pubsubOperations = new PubSubOperations({ pubsub: libp2pNode.pubsub }) + } + } + + /** + * Connects the daemons libp2p node to the peer provided + */ + async connect (request: IRequest): Promise { + if (request.connect == null || request.connect.addrs == null) { + throw new Error('Invalid request') + } + + const peer = request.connect.peer + const addrs = request.connect.addrs.map((a) => new Multiaddr(a)) + const peerId = peerIdFromBytes(peer) + + await this.libp2p.peerStore.addressBook.set(peerId, addrs) + return await this.libp2p.dial(peerId) + } + + /** + * Opens a stream on one of the given protocols to the given peer + */ + async openStream (request: IRequest): Promise { + if (request.streamOpen == null || request.streamOpen.proto == null) { + throw new Error('Invalid request') + } + + const { peer, proto } = request.streamOpen + + const peerId = peerIdFromBytes(peer) + + const connection = await this.libp2p.dial(peerId) + const { stream, protocol } = await connection.newStream(proto) + + return { + streamInfo: { + peer: peerId.toBytes(), + addr: connection.remoteAddr.bytes, + proto: protocol + }, + connection: stream + } + } + + /** + * Sends inbound requests for the given protocol + * to the unix socket path provided. If an existing handler + * is registered at the path, it will be overridden. + */ + async registerStreamHandler (request: IRequest): Promise { + if (request.streamHandler == null || request.streamHandler.proto == null) { + throw new Error('Invalid request') + } + + const protocols = request.streamHandler.proto + const addr = new Multiaddr(request.streamHandler.addr) + const addrString = addr.toString() + + // If we have a handler, end it + if (this.streamHandlers[addrString] != null) { + await this.streamHandlers[addrString].close() + delete this.streamHandlers[addrString] // eslint-disable-line @typescript-eslint/no-dynamic-delete + } + + await Promise.all( + protocols.map(async (proto) => { + // Connect the client socket with the libp2p connection + await this.libp2p.handle(proto, ({ connection, stream, protocol }) => { + const message = StreamInfo.encode({ + peer: connection.remotePeer.toBytes(), + addr: connection.remoteAddr.bytes, + proto: protocol + }).finish() + const encodedMessage = lp.encode.single(message) + + // Tell the client about the new connection + // And then begin piping the client and peer connection + void pipe( + [encodedMessage, stream.source], + clientConnection, + stream.sink + ).catch(err => { + log.error(err) + }) + }) + }) + ) + + const clientConnection = await this.tcp.dial(addr, { + upgrader: passThroughUpgrader + }) + } + + /** + * Listens for process exit to handle cleanup + */ + _listen () { + // listen for graceful termination + process.on('SIGTERM', this._onExit) + process.on('SIGINT', this._onExit) + process.on('SIGHUP', this._onExit) + } + + _onExit () { + void this.stop({ exit: true }).catch(err => { + log.error(err) + }) + } + + /** + * Starts the daemon + */ + async start () { + this._listen() + await this.libp2p.start() + await this.listener.listen(this.multiaddr) + } + + getMultiaddr (): Multiaddr { + const addrs = this.listener.getAddrs() + + if (addrs.length > 0) { + return addrs[0] + } + + throw new Error('Not started') + } + + /** + * Stops the daemon + */ + async stop (options = { exit: false }) { + await this.libp2p.stop() + await this.listener.close() + if (options.exit) { + log('server closed, exiting') + } + process.removeListener('SIGTERM', this._onExit) + process.removeListener('SIGINT', this._onExit) + process.removeListener('SIGHUP', this._onExit) + } + + async * handlePeerStoreRequest (request: IPeerstoreRequest) { + try { + switch (request.type) { + case PeerstoreRequest.Type.GET_PROTOCOLS: + if (request.id == null) { + throw new Error('Invalid request') + } + + const peerId = peerIdFromBytes(request.id) // eslint-disable-line no-case-declarations + const peer = await this.libp2p.peerStore.get(peerId) // eslint-disable-line no-case-declarations + const protos = peer.protocols // eslint-disable-line no-case-declarations + yield OkResponse({ peerStore: { protos } }) + return + case PeerstoreRequest.Type.GET_PEER_INFO: + throw new Error('ERR_NOT_IMPLEMENTED') + default: + throw new Error('ERR_INVALID_REQUEST_TYPE') + } + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + /** + * Parses and responds to PSRequests + */ + async * handlePubsubRequest (request: IPSRequest) { + try { + if (this.libp2p.pubsub == null || (this.pubsubOperations == null)) { + throw new Error('PubSub not configured') + } + + switch (request.type) { + case PSRequest.Type.GET_TOPICS: + yield * this.pubsubOperations.getTopics() + return + case PSRequest.Type.SUBSCRIBE: + if (request.topic == null) { + throw new Error('Invalid request') + } + + yield * this.pubsubOperations.subscribe(request.topic) + return + case PSRequest.Type.PUBLISH: + if (request.topic == null || request.data == null) { + throw new Error('Invalid request') + } + + yield * this.pubsubOperations.publish(request.topic, request.data) + return + default: + throw new Error('ERR_INVALID_REQUEST_TYPE') + } + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + /** + * Parses and responds to DHTRequests + */ + async * handleDHTRequest (request: IDHTRequest) { + try { + if (this.libp2p.dht == null || (this.dhtOperations == null)) { + throw new Error('DHT not configured') + } + + switch (request.type) { + case DHTRequest.Type.FIND_PEER: + if (request.peer == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.findPeer(peerIdFromBytes(request.peer)) + return + case DHTRequest.Type.FIND_PROVIDERS: + if (request.cid == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.findProviders(CID.decode(request.cid), request.count ?? 20) + return + case DHTRequest.Type.PROVIDE: + if (request.cid == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.provide(CID.decode(request.cid)) + return + case DHTRequest.Type.GET_CLOSEST_PEERS: + if (request.key == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.getClosestPeers(request.key) + return + case DHTRequest.Type.GET_PUBLIC_KEY: + if (request.peer == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.getPublicKey(peerIdFromBytes(request.peer)) + return + case DHTRequest.Type.GET_VALUE: + if (request.key == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.getValue(request.key) + return + case DHTRequest.Type.PUT_VALUE: + if (request.key == null || request.value == null) { + throw new Error('Invalid request') + } + + yield * this.dhtOperations.putValue(request.key, request.value) + return + default: + throw new Error('ERR_INVALID_REQUEST_TYPE') + } + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + /** + * Handles requests for the given connection + */ + async handleConnection (connection: Connection) { + const daemon = this // eslint-disable-line @typescript-eslint/no-this-alias + // @ts-expect-error connection may actually be a maconn? + const streamHandler = new StreamHandler({ stream: connection, maxLength: LIMIT }) + + await pipe( + streamHandler.decoder, + source => (async function * () { + let request: Request + + for await (const buf of source) { + try { + request = Request.decode(buf) + + switch (request.type) { + // Connect to another peer + case Request.Type.CONNECT: { + try { + await daemon.connect(request) + } catch (err: any) { + yield ErrorResponse(err) + break + } + yield OkResponse() + break + } + // Get the daemon peer id and addresses + case Request.Type.IDENTIFY: { + yield OkResponse({ + identify: { + id: daemon.libp2p.peerId.toBytes(), + addrs: daemon.libp2p.getMultiaddrs().map(ma => ma.decapsulateCode(protocols('p2p').code)).map(m => m.bytes) + } + }) + break + } + // Get a list of our current peers + case Request.Type.LIST_PEERS: { + const peers = [] + const seen = new Set() + + for (const connection of daemon.libp2p.getConnections()) { + const peerId = connection.remotePeer.toString() + + if (seen.has(peerId)) { + continue + } + + seen.add(peerId) + + peers.push({ + id: connection.remotePeer.toBytes(), + addrs: [connection.remoteAddr.bytes] + }) + } + + yield OkResponse({ peers }) + break + } + case Request.Type.STREAM_OPEN: { + let response + try { + response = await daemon.openStream(request) + } catch (err: any) { + yield ErrorResponse(err) + break + } + + // write the response + yield OkResponse({ + streamInfo: response.streamInfo + }) + + const stream = streamHandler.rest() + // then pipe the connection to the client + await pipe( + stream, + response.connection, + stream + ) + // Exit the iterator, no more requests can come through + return + } + case Request.Type.STREAM_HANDLER: { + try { + await daemon.registerStreamHandler(request) + } catch (err: any) { + yield ErrorResponse(err) + break + } + + // write the response + yield OkResponse() + break + } + case Request.Type.PEERSTORE: { + if (request.peerStore == null) { + yield ErrorResponse(new Error('ERR_INVALID_REQUEST')) + break + } + + yield * daemon.handlePeerStoreRequest(request.peerStore) + break + } + case Request.Type.PUBSUB: { + if (request.pubsub == null) { + yield ErrorResponse(new Error('ERR_INVALID_REQUEST')) + break + } + + yield * daemon.handlePubsubRequest(request.pubsub) + break + } + case Request.Type.DHT: { + if (request.dht == null) { + yield ErrorResponse(new Error('ERR_INVALID_REQUEST')) + break + } + + yield * daemon.handleDHTRequest(request.dht) + break + } + // Not yet supported or doesn't exist + default: + yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE')) + break + } + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + continue + } + } + })(), + async function (source) { + for await (const result of source) { + streamHandler.write(result) + } + } + ) + } +} + +/** + * Creates a daemon from the provided Daemon Options + */ +export const createServer = (multiaddr: Multiaddr, libp2pNode: Libp2p): Libp2pServer => { + const daemon = new Server({ + multiaddr, + libp2pNode + }) + + return daemon +} diff --git a/packages/libp2p-daemon-server/src/pubsub.ts b/packages/libp2p-daemon-server/src/pubsub.ts new file mode 100644 index 00000000..8f0562a1 --- /dev/null +++ b/packages/libp2p-daemon-server/src/pubsub.ts @@ -0,0 +1,75 @@ +/* eslint max-depth: ["error", 6] */ + +import { + PSMessage +} from '@libp2p/daemon-protocol' +import { ErrorResponse, OkResponse } from './responses.js' +import type { PubSub } from '@libp2p/interfaces/pubsub' +import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string' +import { pushable } from 'it-pushable' +import { CustomEvent } from '@libp2p/interfaces' +import { logger } from '@libp2p/logger' + +const log = logger('libp2p:daemon-server:pubsub') + +export interface PubSubOperationsInit { + pubsub: PubSub +} + +export class PubSubOperations { + private readonly pubsub: PubSub + + constructor (init: PubSubOperationsInit) { + const { pubsub } = init + + this.pubsub = pubsub + } + + async * getTopics () { + try { + yield OkResponse({ + pubsub: { + topics: this.pubsub.getTopics() + } + }) + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * subscribe (topic: string) { + try { + const onMessage = pushable() + + await this.pubsub.addEventListener(topic, (evt) => { + const msg = evt.detail + + onMessage.push(PSMessage.encode({ + from: msg.from.toBytes(), + data: msg.data, + seqno: msg.sequenceNumber == null ? undefined : uint8ArrayFromString(msg.sequenceNumber.toString(16).padStart(16, '0'), 'base16'), + topicIDs: [msg.topic], + signature: msg.signature, + key: msg.key + }).finish()) + }) + + yield OkResponse() + yield * onMessage + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } + + async * publish (topic: string, data: Uint8Array) { + try { + this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data })) + yield OkResponse() + } catch (err: any) { + log.error(err) + yield ErrorResponse(err) + } + } +} diff --git a/packages/libp2p-daemon-server/src/responses.ts b/packages/libp2p-daemon-server/src/responses.ts new file mode 100644 index 00000000..dd0d06a0 --- /dev/null +++ b/packages/libp2p-daemon-server/src/responses.ts @@ -0,0 +1,23 @@ +import { IResponse, Response } from '@libp2p/daemon-protocol' + +/** + * Creates and encodes an OK response + */ +export function OkResponse (data?: Partial): Uint8Array { + return Response.encode({ + type: Response.Type.OK, + ...data + }).finish() +} + +/** + * Creates and encodes an ErrorResponse + */ +export function ErrorResponse (err: Error): Uint8Array { + return Response.encode({ + type: Response.Type.ERROR, + error: { + msg: err.message + } + }).finish() +} diff --git a/packages/libp2p-daemon-server/test/index.spec.ts b/packages/libp2p-daemon-server/test/index.spec.ts new file mode 100644 index 00000000..1a8f4204 --- /dev/null +++ b/packages/libp2p-daemon-server/test/index.spec.ts @@ -0,0 +1,50 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 5] */ + +import { Multiaddr } from '@multiformats/multiaddr' +import { expect } from 'aegir/utils/chai.js' +import { createServer, Libp2p } from '../src/index.js' +import { stubInterface } from 'ts-sinon' + +const multiaddr = new Multiaddr('/ip4/0.0.0.0/tcp/0') + +describe('server', () => { + it('should start', async () => { + const libp2p = stubInterface() + + const server = await createServer(multiaddr, libp2p) + + await server.start() + + expect(libp2p.start.called).to.be.true() + + await server.stop() + }) + + it('should stop', async () => { + const libp2p = stubInterface() + + const server = await createServer(multiaddr, libp2p) + + await server.start() + await server.stop() + + expect(libp2p.stop.called).to.be.true() + }) + + it('should return multiaddrs', async () => { + const libp2p = stubInterface() + + const server = await createServer(multiaddr, libp2p) + + expect(() => server.getMultiaddr()).to.throw(/Not started/) + + await server.start() + + expect(server.getMultiaddr()).to.be.ok() + + await server.stop() + + expect(() => server.getMultiaddr()).to.throw(/Not started/) + }) +}) diff --git a/packages/libp2p-daemon-server/tsconfig.json b/packages/libp2p-daemon-server/tsconfig.json new file mode 100644 index 00000000..68d5ba2c --- /dev/null +++ b/packages/libp2p-daemon-server/tsconfig.json @@ -0,0 +1,25 @@ +{ + "extends": "aegir/src/config/tsconfig.aegir.json", + "compilerOptions": { + "outDir": "dist", + "emitDeclarationOnly": false, + "module": "ES2020", + "lib": [ + "ES2021", + "ES2021.Promise", + "ES2021.String", + "ES2020.BigInt", + "DOM", + "DOM.Iterable" + ] + }, + "include": [ + "src", + "test" + ], + "references": [ + { + "path": "../libp2p-daemon-protocol" + } + ] +} diff --git a/CHANGELOG.md b/packages/libp2p-daemon/CHANGELOG.md similarity index 100% rename from CHANGELOG.md rename to packages/libp2p-daemon/CHANGELOG.md diff --git a/packages/libp2p-daemon/LICENSE b/packages/libp2p-daemon/LICENSE new file mode 100644 index 00000000..20ce483c --- /dev/null +++ b/packages/libp2p-daemon/LICENSE @@ -0,0 +1,4 @@ +This project is dual licensed under MIT and Apache-2.0. + +MIT: https://www.opensource.org/licenses/mit +Apache-2.0: https://www.apache.org/licenses/license-2.0 diff --git a/packages/libp2p-daemon/LICENSE-APACHE b/packages/libp2p-daemon/LICENSE-APACHE new file mode 100644 index 00000000..14478a3b --- /dev/null +++ b/packages/libp2p-daemon/LICENSE-APACHE @@ -0,0 +1,5 @@ +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. diff --git a/packages/libp2p-daemon/LICENSE-MIT b/packages/libp2p-daemon/LICENSE-MIT new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/packages/libp2p-daemon/LICENSE-MIT @@ -0,0 +1,19 @@ +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/packages/libp2p-daemon/README.md b/packages/libp2p-daemon/README.md new file mode 100644 index 00000000..b54b5445 --- /dev/null +++ b/packages/libp2p-daemon/README.md @@ -0,0 +1,43 @@ +libp2p-daemon JavaScript implementation +====== + + + + + + +> A standalone deployment of a libp2p host, running in its own OS process and installing a set of virtual endpoints to enable co-local applications to: communicate with peers, handle protocols, interact with the DHT, participate in pubsub, etc. no matter the language they are developed in, nor whether a native libp2p implementation exists in that language. + +## Lead Maintainer + +[Jacob Heun](https://github.com/jacobheun) + +## Specs + +The specs for the daemon are currently housed in the go implementation. You can read them at [libp2p/go-libp2p-daemon](https://github.com/libp2p/go-libp2p-daemon/blob/master/specs/README.md) + +## Install + +``` +npm i -g libp2p-daemon +``` + +## Usage + +For a full list of options, you can run help `jsp2pd --help`. +Running the defaults, `jsp2pd`, will start the daemon and bind it to a local unix socket path. +Daemon clients will be able to communicate with the daemon over that unix socket. + +As an alternative, you can use this daemon with a different version of libp2p as the one specified in `package.json`. You just need to define its path through an environment variable as follows: + +```sh +export LIBP2P_JS=./../../js-libp2p/src/index.js +``` + +## Contribute + +This module is actively under development. Please check out the issues and submit PRs! + +## License + +MIT © Protocol Labs diff --git a/packages/libp2p-daemon/package.json b/packages/libp2p-daemon/package.json new file mode 100644 index 00000000..c40c1a32 --- /dev/null +++ b/packages/libp2p-daemon/package.json @@ -0,0 +1,145 @@ +{ + "name": "@libp2p/daemon", + "version": "0.0.0", + "description": "libp2p-daemon JavaScript implementation", + "license": "Apache-2.0 OR MIT", + "homepage": "https://github.com/libp2p/js-libp2p-daemon/tree/master/packages/libp2p-daemon#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/libp2p/js-libp2p-daemon.git" + }, + "bugs": { + "url": "https://github.com/libp2p/js-libp2p-daemon/issues" + }, + "keywords": [ + "libp2p" + ], + "engines": { + "node": ">=16.0.0", + "npm": ">=7.0.0" + }, + "bin": { + "jsp2pd": "src/cli/bin.js" + }, + "type": "module", + "types": "./dist/src/index.d.ts", + "files": [ + "src", + "dist/src", + "!dist/test", + "!**/*.tsbuildinfo" + ], + "exports": { + ".": { + "import": "./dist/src/index.js" + } + }, + "eslintConfig": { + "extends": "ipfs", + "parserOptions": { + "sourceType": "module" + } + }, + "release": { + "branches": [ + "master" + ], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "preset": "conventionalcommits", + "releaseRules": [ + { + "breaking": true, + "release": "major" + }, + { + "revert": true, + "release": "patch" + }, + { + "type": "feat", + "release": "minor" + }, + { + "type": "fix", + "release": "patch" + }, + { + "type": "chore", + "release": "patch" + }, + { + "type": "docs", + "release": "patch" + }, + { + "type": "test", + "release": "patch" + }, + { + "scope": "no-release", + "release": false + } + ] + } + ], + [ + "@semantic-release/release-notes-generator", + { + "preset": "conventionalcommits", + "presetConfig": { + "types": [ + { + "type": "feat", + "section": "Features" + }, + { + "type": "fix", + "section": "Bug Fixes" + }, + { + "type": "chore", + "section": "Trivial Changes" + }, + { + "type": "docs", + "section": "Trivial Changes" + }, + { + "type": "test", + "section": "Tests" + } + ] + } + } + ], + "@semantic-release/changelog", + "@semantic-release/npm", + "@semantic-release/github", + "@semantic-release/git" + ] + }, + "scripts": { + "lint": "aegir lint", + "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js", + "build": "tsc", + "pretest": "npm run build", + "test": "aegir test -t node -f dist/test/*.js dist/test/**/*.js", + "test:node": "aegir test -t node -f dist/test/*.js dist/test/**/*.js", + "release": "semantic-release" + }, + "dependencies": { + "@libp2p/daemon-server": "^0.0.2", + "@libp2p/interfaces": "^1.3.17", + "@multiformats/multiaddr": "^10.1.8", + "es-main": "^1.0.2", + "yargs": "^17.3.1", + "yargs-promise": "^1.1.0" + }, + "devDependencies": { + "aegir": "^36.0.0", + "sinon": "^13.0.1" + } +} diff --git a/src/cli/bin.ts b/packages/libp2p-daemon/src/index.ts similarity index 77% rename from src/cli/bin.ts rename to packages/libp2p-daemon/src/index.ts index 61595c2f..89d3a41c 100755 --- a/src/cli/bin.ts +++ b/packages/libp2p-daemon/src/index.ts @@ -1,17 +1,20 @@ #! /usr/bin/env node /* eslint no-console: ["error", { allow: ["log", "warn", "error"] }] */ -'use strict' -const yargs = require('yargs') -const YargsPromise = require('yargs-promise') -const Daemon = require('../daemon') +import { Multiaddr } from '@multiformats/multiaddr' +import yargs from 'yargs' +// @ts-expect-error no types +import YargsPromise from 'yargs-promise' +import type { Libp2pServer } from '@libp2p/daemon-server' +// @ts-expect-error no types +import esMain from 'es-main' const args = process.argv.slice(2) const parser = new YargsPromise(yargs) const log = console.log -const main = async (processArgs) => { +export default async function main (processArgs: string[]) { parser.yargs .option('listen', { desc: 'daemon control listen multiaddr', @@ -88,8 +91,8 @@ const main = async (processArgs) => { type: 'string', default: 'gossipsub' }) - .fail((msg, err, yargs) => { - if (err) { + .fail((msg: string, err: Error | undefined, yargs?: any) => { + if (err != null) { throw err // preserve stack } @@ -102,22 +105,31 @@ const main = async (processArgs) => { }) const { data, argv } = await parser.parse(processArgs) - if (data) { + + if (data != null) { // Log help and exit // eslint-disable-next-line log(data) process.exit(0) } - const daemon = await Daemon.createDaemon(argv) + + const daemon = await createLibp2pServer(new Multiaddr(argv.listen), argv) await daemon.start() - if (!argv.quiet) { + + if (argv.quiet !== true) { // eslint-disable-next-line log('daemon has started') } } -module.exports = main -if (require.main === module) { +export async function createLibp2pServer (listenAddr: Multiaddr, argv: any): Promise { + // const libp2p = await createLibp2p(argv) + // const daemon = await createServer(new Multiaddr(argv.listen), libp2p) + + throw new Error('Not implemented yet') +} + +if (esMain(import.meta) === true) { main(process.argv) .catch((err) => { console.error(err) diff --git a/test/cli.spec.ts b/packages/libp2p-daemon/test/cli.spec.ts similarity index 90% rename from test/cli.spec.ts rename to packages/libp2p-daemon/test/cli.spec.ts index 90495ac2..9718255c 100644 --- a/test/cli.spec.ts +++ b/packages/libp2p-daemon/test/cli.spec.ts @@ -1,12 +1,11 @@ /* eslint-env mocha */ -'use strict' -const { expect } = require('aegir/utils/chai') -const sinon = require('sinon') -const cli = require('../src/cli/bin') +import { expect } from 'aegir/utils/chai.js' +import sinon from 'sinon' +import cli from '../src/index.js' -describe('cli', () => { - const daemon = require('../src/daemon') +describe.skip('cli', () => { + const daemon = { createDaemon: (options: any) => {} } afterEach(() => { sinon.restore() diff --git a/packages/libp2p-daemon/tsconfig.json b/packages/libp2p-daemon/tsconfig.json new file mode 100644 index 00000000..68d5ba2c --- /dev/null +++ b/packages/libp2p-daemon/tsconfig.json @@ -0,0 +1,25 @@ +{ + "extends": "aegir/src/config/tsconfig.aegir.json", + "compilerOptions": { + "outDir": "dist", + "emitDeclarationOnly": false, + "module": "ES2020", + "lib": [ + "ES2021", + "ES2021.Promise", + "ES2021.String", + "ES2020.BigInt", + "DOM", + "DOM.Iterable" + ] + }, + "include": [ + "src", + "test" + ], + "references": [ + { + "path": "../libp2p-daemon-protocol" + } + ] +} diff --git a/src/client.ts b/src/client.ts deleted file mode 100644 index 69b71762..00000000 --- a/src/client.ts +++ /dev/null @@ -1,52 +0,0 @@ -'use strict' - -const TCP = require('libp2p-tcp') -const { passThroughUpgrader } = require('./util') - -class Client { - constructor (addr) { - this.multiaddr = addr - this.server = null - this.tcp = new TCP({ upgrader: passThroughUpgrader }) - } - - /** - * Connects to a daemon at the unix socket path the client - * was created with - * - * @async - * @returns {MultiaddrConnection} - */ - connect () { - return this.tcp.dial(this.multiaddr) - } - - /** - * Starts a server listening at `socketPath`. New connections - * will be sent to the `connectionHandler`. - * - * @param {Multiaddr} addr - * @param {function(Stream)} connectionHandler - * @returns {Promise} - */ - async start (addr, connectionHandler) { - if (this.listener) { - await this.close() - } - this.listener = this.tcp.createListener(maConn => connectionHandler(maConn)) - - await this.listener.listen(addr) - } - - /** - * Closes the socket - * - * @returns {Promise} - */ - async close () { - this.listener && await this.listener.close() - this.listener = null - } -} - -module.exports = Client diff --git a/src/daemon.ts b/src/daemon.ts deleted file mode 100644 index f77cd442..00000000 --- a/src/daemon.ts +++ /dev/null @@ -1,565 +0,0 @@ -/* eslint max-depth: ["error", 6] */ - -'use strict' - -const TCP = require('libp2p-tcp') -const Libp2p = require('./libp2p') -const PeerId = require('peer-id') -const { Multiaddr } = require('multiaddr') -const { CID } = require('multiformats/cid') -const lp = require('it-length-prefixed') -const pipe = require('it-pipe') -const pushable = require('it-pushable') -const StreamHandler = require('./stream-handler') -const { concat } = require('streaming-iterables') -const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') -const { toString: uint8ArrayToString } = require('uint8arrays/to-string') -const { passThroughUpgrader } = require('./util') -const { - Request, - DHTRequest, - PeerstoreRequest, - PSRequest, - Response, - DHTResponse, - PSMessage, - StreamInfo -} = require('./protocol') -const LIMIT = 1 << 22 // 4MB - -const log = require('debug')('libp2p:daemon') - -class Daemon { - /** - * @class - * @param {object} options - * @param {string} options.multiaddr - * @param {Libp2p} options.libp2pNode - */ - constructor ({ - multiaddr, - libp2pNode - }) { - this.multiaddr = new Multiaddr(multiaddr) - this.libp2p = libp2pNode - this.tcp = new TCP({ upgrader: passThroughUpgrader }) - this.listener = this.tcp.createListener((maConn) => { - this.handleConnection(maConn) - }) - this.streamHandlers = {} - this._onExit = this._onExit.bind(this) - } - - /** - * Connects the daemons libp2p node to the peer provided - * in the ConnectRequest - * - * @param {ConnectRequest} connectRequest - * @returns {Promise} - */ - async connect (connectRequest) { - const peer = connectRequest.connect.peer - const addrs = connectRequest.connect.addrs.map((a) => new Multiaddr(a)) - const peerId = PeerId.createFromBytes(peer) - - await this.libp2p.peerStore.addressBook.set(peerId, addrs) - return this.libp2p.dial(peerId) - } - - /** - * A number, or a string containing a number. - * - * @typedef {Object} OpenStream - * @property {StreamInfo} streamInfo - * @property {Stream} connection - */ - - /** - * Opens a stream on one of the given protocols to the given peer - * - * @param {StreamOpenRequest} request - * @throws {Error} - * @returns {OpenStream} - */ - async openStream (request) { - const { peer, proto } = request.streamOpen - - const peerId = PeerId.createFromB58String(uint8ArrayToString(peer, 'base58btc')) - - const connection = this.libp2p.connectionManager.get(peerId) - const { stream, protocol } = await connection.newStream(proto) - - return { - streamInfo: { - peer: peerId.toBytes(), - addr: connection.remoteAddr.bytes, - proto: protocol - }, - connection: stream - } - } - - /** - * Sends inbound requests for the given protocol - * to the unix socket path provided. If an existing handler - * is registered at the path, it will be overridden. - * - * @param {StreamHandlerRequest} request - * @returns {Promise} - */ - async registerStreamHandler (request) { - const protocols = request.streamHandler.proto - const addr = new Multiaddr(request.streamHandler.addr) - const addrString = addr.toString() - - // If we have a handler, end it - if (this.streamHandlers[addrString]) { - this.streamHandlers[addrString].end() - delete this.streamHandlers[addrString] - } - - for (const proto of protocols) { - // Connect the client socket with the libp2p connection - await this.libp2p.handle(proto, ({ connection, stream, protocol }) => { - const message = StreamInfo.encode({ - peer: connection.remotePeer.toBytes(), - addr: connection.remoteAddr.bytes, - proto: protocol - }).finish() - const encodedMessage = lp.encode.single(message) - - // Tell the client about the new connection - // And then begin piping the client and peer connection - pipe( - concat([encodedMessage], stream.source), - clientConnection, - stream.sink - ) - }) - } - - const clientConnection = await this.tcp.dial(addr) - } - - /** - * Listens for process exit to handle cleanup - * - * @private - * @returns {void} - */ - _listen () { - // listen for graceful termination - process.on('SIGTERM', this._onExit) - process.on('SIGINT', this._onExit) - process.on('SIGHUP', this._onExit) - } - - _onExit () { - this.stop({ exit: true }) - } - - /** - * Starts the daemon - * - * @returns {Promise} - */ - async start () { - this._listen() - await this.libp2p.start() - await this.listener.listen(this.multiaddr) - } - - /** - * Stops the daemon - * - * @param {object} options - * @param {boolean} options.exit - If the daemon process should exit - * @returns {Promise} - */ - async stop (options = { exit: false }) { - await this.libp2p.stop() - await this.listener.close() - if (options.exit) { - log('server closed, exiting') - } - process.removeListener('SIGTERM', this._onExit) - process.removeListener('SIGINT', this._onExit) - process.removeListener('SIGHUP', this._onExit) - } - - handlePeerStoreRequest ({ peerStore }) { - const peerStoreAction = { - [PeerstoreRequest.Type.GET_PROTOCOLS]: async function * (daemon) { - try { - const peerId = PeerId.createFromBytes(peerStore.id) - const peer = await daemon.libp2p.peerStore.get(peerId) - const protos = peer.protocols - yield OkResponse({ peerStore: { protos } }) - } catch (err) { - throw new Error('ERR_INVALID_PEERSTORE_REQUEST') - } - }, - [PeerstoreRequest.Type.GET_PEER_INFO]: function * () { - yield ErrorResponse('ERR_NOT_IMPLEMENTED') - }, - invalid: function * () { - yield ErrorResponse('ERR_INVALID_REQUEST_TYPE') - } - } - - return peerStoreAction[peerStore.type](this) - } - - /** - * Parses and responds to PSRequests. An async generator will - * be returned. - * - * @private - * @param {Request} request - * @returns {*} Returns an async generator - */ - handlePubsubRequest ({ pubsub }) { - const pubsubAction = { - [PSRequest.Type.GET_TOPICS]: async function * (daemon) { - const topics = await daemon.libp2p.pubsub.getTopics() - yield OkResponse({ pubsub: { topics } }) - }, - [PSRequest.Type.SUBSCRIBE]: async function * (daemon) { - const topic = pubsub.topic - const onMessage = pushable() - - await daemon.libp2p.pubsub.subscribe(topic, (msg) => { - onMessage.push(PSMessage.encode({ - from: msg.from && uint8ArrayFromString(msg.from), - data: msg.data, - seqno: msg.seqno, - topicIDs: msg.topicIDs, - signature: msg.signature, - key: msg.key - }).finish()) - }) - - yield OkResponse() - yield * onMessage - }, - [PSRequest.Type.PUBLISH]: async function * (daemon) { - const topic = pubsub.topic - const data = pubsub.data - - await daemon.libp2p.pubsub.publish(topic, data) - yield OkResponse() - }, - invalid: function * () { - yield ErrorResponse('ERR_INVALID_REQUEST_TYPE') - } - } - - if (!pubsubAction[pubsub.type]) { - return pubsubAction.invalid() - } - - return pubsubAction[pubsub.type](this) - } - - /** - * Parses and responds to DHTRequests - * - * @private - * @param {Request} request - * @returns {DHTResponse[]} - */ - handleDHTRequest ({ dht }) { - const dhtAction = { - [DHTRequest.Type.FIND_PEER]: async function * (daemon) { - const peerId = PeerId.createFromBytes(dht.peer) - try { - const peer = await daemon.libp2p.peerRouting.findPeer(peerId) - - yield OkResponse({ - dht: { - type: DHTResponse.Type.VALUE, - peer: { - id: peer.id.toBytes(), - addrs: peer.multiaddrs.map(m => m.bytes) - } - } - }) - } catch (err) { - yield ErrorResponse(err.message) - } - }, - [DHTRequest.Type.FIND_PROVIDERS]: async function * (daemon) { - const cid = CID.decode(dht.cid) - const maxNumProviders = dht.count - let okSent = false - try { - for await (const provider of daemon.libp2p.contentRouting.findProviders(cid, { - maxNumProviders - })) { - if (!okSent) { - okSent = true - yield OkResponse({ - dht: { - type: DHTResponse.Type.BEGIN - } - }) - } - - yield DHTResponse.encode({ - type: DHTResponse.Type.VALUE, - peer: { - id: provider.id.toBytes(), - addrs: (provider.multiaddrs || []).map(m => m.bytes) - } - }).finish() - } - } catch (err) { - yield ErrorResponse(err.message) - return - } - - yield DHTResponse.encode({ - type: DHTResponse.Type.END - }).finish() - }, - [DHTRequest.Type.PROVIDE]: async function * (daemon) { - const cid = CID.decode(dht.cid) - await daemon.libp2p.contentRouting.provide(cid) - yield OkResponse() - }, - [DHTRequest.Type.GET_CLOSEST_PEERS]: async function * (daemon) { - yield OkResponse({ - dht: { - type: DHTResponse.Type.BEGIN - } - }) - - for await (const event of daemon.libp2p._dht.getClosestPeers(dht.key)) { - if (event.name === 'FINAL_PEER') { - yield DHTResponse.encode({ - type: DHTResponse.Type.VALUE, - value: event.peer.id.toBytes() - }).finish() - } - } - - yield DHTResponse.encode({ - type: DHTResponse.Type.END - }).finish() - }, - [DHTRequest.Type.GET_PUBLIC_KEY]: async function * (daemon) { - const peerId = PeerId.createFromBytes(dht.peer) - const pubKey = await daemon.libp2p._dht.getPublicKey(peerId) - - yield OkResponse({ - dht: { - type: DHTResponse.Type.VALUE, - value: pubKey.bytes - } - }) - }, - [DHTRequest.Type.GET_VALUE]: async function * (daemon) { - try { - const value = await daemon.libp2p.contentRouting.get(dht.key) - yield OkResponse({ - dht: { - type: DHTResponse.Type.VALUE, - value: value.val - } - }) - } catch (err) { - yield ErrorResponse(err.message) - } - }, - [DHTRequest.Type.PUT_VALUE]: async function * (daemon) { - await daemon.libp2p.contentRouting.put( - dht.key, - dht.value - ) - - yield OkResponse() - }, - invalid: function * () { - yield ErrorResponse('ERR_INVALID_REQUEST_TYPE') - } - } - - if (!dhtAction[dht.type]) { - return dhtAction.invalid() - } - - return dhtAction[dht.type](this) - } - - /** - * Handles requests for the given connection - * - * @private - * @param {MultiaddrConnection} maConn - * @returns {void} - */ - async handleConnection (maConn) { - const daemon = this - const streamHandler = new StreamHandler({ stream: maConn, maxLength: LIMIT }) - - await pipe( - streamHandler.decoder, - source => (async function * () { - for await (let request of source) { - try { - request = Request.decode(request.slice()) - } catch (err) { - yield ErrorResponse('ERR_INVALID_MESSAGE') - } - - switch (request.type) { - // Connect to another peer - case Request.Type.CONNECT: { - try { - await daemon.connect(request) - } catch (err) { - yield ErrorResponse(err.message) - break - } - yield OkResponse() - break - } - // Get the daemon peer id and addresses - case Request.Type.IDENTIFY: { - yield OkResponse({ - identify: { - id: daemon.libp2p.peerId.toBytes(), - addrs: daemon.libp2p.multiaddrs.map(m => m.bytes) - } - }) - break - } - // Get a list of our current peers - case Request.Type.LIST_PEERS: { - const peers = [] - - for await (const peer of daemon.libp2p.peerStore.getPeers()) { - // TODO: conn mgr - const conn = daemon.libp2p.registrar.getConnection(peer.id) - const addr = conn.remoteAddr - - peers.push({ - id: peer.id.toBytes(), - addrs: [addr ? addr.bytes : null] - }) - } - - yield OkResponse({ peers }) - break - } - case Request.Type.STREAM_OPEN: { - let response - try { - response = await daemon.openStream(request) - } catch (err) { - yield ErrorResponse(err.message) - break - } - - // write the response - yield OkResponse({ - streamInfo: response.streamInfo - }) - - const stream = streamHandler.rest() - // then pipe the connection to the client - await pipe( - stream, - response.connection, - stream - ) - // Exit the iterator, no more requests can come through - return - } - case Request.Type.STREAM_HANDLER: { - try { - await daemon.registerStreamHandler(request) - } catch (err) { - yield ErrorResponse(err.message) - break - } - - // write the response - yield OkResponse() - break - } - case Request.Type.PEERSTORE: { - yield * daemon.handlePeerStoreRequest(request) - break - } - case Request.Type.PUBSUB: { - yield * daemon.handlePubsubRequest(request) - break - } - case Request.Type.DHT: { - yield * daemon.handleDHTRequest(request) - break - } - // Not yet supported or doesn't exist - default: - yield ErrorResponse('ERR_INVALID_REQUEST_TYPE') - break - } - } - })(), - async function (source) { - for await (const result of source) { - streamHandler.write(result) - } - } - ) - } -} - -/** - * Creates and encodes an OK response - * - * @private - * @param {Object} data - an optional map of values to be assigned to the response - * @returns {Response} - */ -function OkResponse (data) { - return Response.encode({ - type: Response.Type.OK, - ...data - }).finish() -} - -/** - * Creates and encodes an ErrorResponse - * - * @private - * @param {string} message - * @returns {ErrorResponse} - */ -function ErrorResponse (message) { - return Response.encode({ - type: Response.Type.ERROR, - error: { - msg: message - } - }).finish() -} - -/** - * Creates a daemon from the provided Daemon Options - * - * @param {object} options - * @returns {Daemon} - */ -const createDaemon = async (options) => { - const libp2pNode = await Libp2p.createLibp2p(options) - const daemon = new Daemon({ - multiaddr: options.listen, - libp2pNode: libp2pNode - }) - - return daemon -} - -module.exports.createDaemon = createDaemon diff --git a/src/stream-handler.ts b/src/stream-handler.ts deleted file mode 100644 index ecba9bf5..00000000 --- a/src/stream-handler.ts +++ /dev/null @@ -1,70 +0,0 @@ -'use strict' - -const lp = require('it-length-prefixed') -const handshake = require('it-handshake') - -const debug = require('debug') -const log = debug('stream-handler') - -class StreamHandler { - /** - * Create a stream handler for connection - * - * @param {object} options - * @param {*} options.stream - A duplex iterable - * @param {number} options.maxLength - max bytes length of message - */ - constructor ({ stream, maxLength = 4096 }) { - this.stream = stream - - this.shake = handshake(this.stream) - this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength }) - } - - /** - * Read and decode message - * - * @async - * @returns {void} - */ - async read () { - const msg = await this.decoder.next() - if (msg.value) { - return msg.value.slice() - } - log('read received no value, closing stream') - // End the stream, we didn't get data - this.close() - } - - /** - * - * @param {*} msg - */ - write (msg) { - log('write message') - this.shake.write(lp.encode.single(msg)) - } - - /** - * Return the handshake rest stream and invalidate handler - * - * @returns {*} A duplex iterable - */ - rest () { - this.shake.rest() - return this.shake.stream - } - - /** - * Close the stream - * - * @returns {void} - */ - close () { - log('closing the stream') - this.rest().sink([]) - } -} - -module.exports = StreamHandler diff --git a/src/util/index.ts b/src/util/index.ts deleted file mode 100644 index a571aed4..00000000 --- a/src/util/index.ts +++ /dev/null @@ -1,44 +0,0 @@ -'use strict' - -const os = require('os') -const { resolve } = require('path') - -exports.first = async iterator => { - for await (const value of iterator) return value // eslint-disable-line no-unreachable-loop -} - -exports.last = async iterator => { - let value - for await (value of iterator) { } - return value -} - -exports.ends = iterator => { - iterator.first = () => exports.first(iterator) - iterator.last = () => exports.last(iterator) - return iterator -} - -exports.passThroughUpgrader = { - upgradeInbound: maConn => maConn, - upgradeOutbound: maConn => maConn -} - -/** - * Converts the multiaddr to a nodejs NET compliant option - * for .connect or .listen - * - * @param {Multiaddr} addr - * @returns {string|object} A nodejs NET compliant option - */ -exports.multiaddrToNetConfig = function multiaddrToNetConfig (addr) { - const listenPath = addr.getPath() - // unix socket listening - if (listenPath) { - return resolve(listenPath) - } - // tcp listening - return addr.nodeAddress() -} - -exports.isWindows = os.platform() === 'win32' diff --git a/test/daemon/config.spec.ts b/test/daemon/config.spec.ts deleted file mode 100644 index 7cba23b1..00000000 --- a/test/daemon/config.spec.ts +++ /dev/null @@ -1,92 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const { Multiaddr } = require('multiaddr') -const { createDaemon } = require('../../src/daemon') -const { isWindows } = require('../../src/util') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -describe('configuration', function () { - this.timeout(10e3) - - let daemon - afterEach(async () => { - await daemon && daemon.stop() - }) - - it('should be able to set announce addrs', async () => { - daemon = await createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0', - announceAddrs: '/dns/ipfs.io', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '' - }) - - await daemon.start() - - const addrs = Array.from(daemon.libp2p.addressManager.announce) - expect(addrs).to.deep.eql([ - '/dns/ipfs.io' - ]) - }) - - it('should be able to load an RSA private key', async () => { - daemon = await createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '', - announceAddrs: '', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: path.join(__dirname, '../resources/rsa.key'), - bootstrapPeers: '' - }) - await daemon.start() - - const peerId = daemon.libp2p.peerId - expect(peerId.toB58String()).to.eql('QmPFdSzvgd1HbZSd6oX2N2vCSnhSEeocbQZsMB42UG8smE') - }) - - it('should be able to load a Secp256k1 private key', async () => { - daemon = await createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '', - announceAddrs: '', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: path.join(__dirname, '../resources/secp256k1.key'), - bootstrapPeers: '' - }) - await daemon.start() - - const peerId = daemon.libp2p.peerId - expect(peerId.toB58String()).to.eql('16Uiu2HAm7txvwZbeK5g3oB3DrRhnARTEjTNorVreWJomfHJHbEu2') - }) -}) diff --git a/test/daemon/core.spec.ts b/test/daemon/core.spec.ts deleted file mode 100644 index 8e781b3b..00000000 --- a/test/daemon/core.spec.ts +++ /dev/null @@ -1,156 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const PeerId = require('peer-id') -const { Multiaddr } = require('multiaddr') -const StreamHandler = require('../../src/stream-handler') -const { createDaemon } = require('../../src/daemon') -const Client = require('../../src/client') -const { createLibp2p } = require('../../src/libp2p') -const { isWindows } = require('../../src/util') -const { - Request, - Response -} = require('../../src/protocol') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -describe('core features', () => { - let daemon - let libp2pPeer - let client - - before(function () { - this.timeout(20e3) - return Promise.all([ - createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0,/ip4/0.0.0.0/tcp/0/ws', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '' - }), - createLibp2p({ - dht: true, - nat: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0' - }) - ]).then((results) => { - daemon = results.shift() - libp2pPeer = results.shift() - - return Promise.all([ - daemon.start(), - libp2pPeer.start() - ]) - }) - }) - - after(() => { - return Promise.all([ - daemon.stop(), - libp2pPeer.stop() - ]) - }) - - afterEach(async () => { - await client && client.close() - }) - - it('should be able to connect to another node', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.CONNECT, - connect: { - peer: libp2pPeer.peerId.toBytes(), - addrs: libp2pPeer.multiaddrs.map(addr => addr.bytes) - }, - streamOpen: null, - streamHandler: null, - dht: null, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const message = await streamHandler.read() - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - streamHandler.close() - }) - - it('should be able to list peers', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.LIST_PEERS, - connect: null, - streamOpen: null, - streamHandler: null, - dht: null, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const message = await streamHandler.read() - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - expect(response.peers).to.have.length(1) - streamHandler.close() - }) - - it('should be able to identify', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.IDENTIFY, - connect: null, - streamOpen: null, - streamHandler: null, - dht: null, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(PeerId.createFromBytes(response.identify.id).equals(daemon.libp2p.peerId)).to.eql(true) - - response.identify.addrs.forEach((a, i) => { - expect((new Multiaddr(a)).equals(daemon.libp2p.multiaddrs[i])).to.eql(true) - }) - - streamHandler.close() - }) -}) diff --git a/test/daemon/dht.spec.ts b/test/daemon/dht.spec.ts deleted file mode 100644 index 20b6b1ec..00000000 --- a/test/daemon/dht.spec.ts +++ /dev/null @@ -1,448 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const { CID } = require('multiformats/cid') -const { Multiaddr } = require('multiaddr') -const delay = require('delay') -const PeerId = require('peer-id') -const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') -const { toString: uint8ArrayToString } = require('uint8arrays/to-string') - -const StreamHandler = require('../../src/stream-handler') -const { createDaemon } = require('../../src/daemon') -const { createLibp2p } = require('../../src/libp2p') -const Client = require('../../src/client') -const { isWindows } = require('../../src/util') -const { connect } = require('../util') -const { - Request, - DHTRequest, - Response, - DHTResponse -} = require('../../src/protocol') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -function sameMultiAddrs (a, b) { - const set = new Set([ - ...a.map(a => new Multiaddr(a)).map(a => a.toString()), - ...b.map(b => new Multiaddr(b)).map(b => b.toString()) - ]) - - return (a.length === b.length) && (a.length === set.size) -} - -describe('dht', () => { - const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp38') - let daemon - let libp2pPeer - let client - - before(async function () { - this.timeout(20e3) - ;[daemon, libp2pPeer] = await Promise.all([ - createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0,/ip4/0.0.0.0/tcp/0/ws', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '' - }), - createLibp2p({ - dht: true, - nat: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0' - }) - ]) - await Promise.all([ - daemon.start(), - libp2pPeer.start() - ]) - await connect({ - libp2pPeer, - multiaddr: daemonAddr - }) - - // Give the nodes a moment to handshake - await delay(500) - }) - - after(() => { - return Promise.all([ - daemon.stop(), - libp2pPeer.stop() - ]) - }) - - afterEach(async () => { - await client && client.close() - }) - - it('should be able to find a peer', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.FIND_PEER, - peer: libp2pPeer.peerId.toBytes() - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(PeerId.createFromBytes(response.dht.peer.id).equals(libp2pPeer.peerId)).to.eql(true) - expect(sameMultiAddrs(response.dht.peer.addrs, libp2pPeer.multiaddrs)).to.be.true() - - streamHandler.close() - }) - - it('should return an error when no peer is found', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - const unknownPeer = await PeerId.create({ bits: 512 }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.FIND_PEER, - peer: unknownPeer.toBytes() - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.ERROR) - streamHandler.close() - }) - - it('should be able to register as a provider', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.PROVIDE, - cid: cid.bytes - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - streamHandler.close() - - // The peer should be able to find our daemon as a provider - const providers = [] - for await (const provider of libp2pPeer.contentRouting.findProviders(cid, { maxNumProviders: 1 })) { - providers.push(provider) - } - expect(daemon.libp2p.peerId.isEqual(providers[0].id)).to.eql(true) - }) - - it('should be able to find providers', async () => { - // Register the peer as a provider - const cid = CID.parse('QmaSNGNpisJ1UeuoH3WcKuia4hQVi2XkfhkszTbWak9TxB') - await libp2pPeer.contentRouting.provide(cid) - - // Now find it as a provider - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.FIND_PROVIDERS, - cid: cid.bytes, - count: 1 - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const expectedResponses = [ - (message) => { - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - expect(response.dht.type).to.eql(DHTResponse.Type.BEGIN) - }, - (message) => { - const response = DHTResponse.decode(message) - expect(response.type).to.eql(DHTResponse.Type.VALUE) - expect(PeerId.createFromBytes(response.peer.id).equals(libp2pPeer.peerId)).to.eql(true) - expect(sameMultiAddrs(response.peer.addrs, libp2pPeer.multiaddrs)).to.be.true() - }, - (message) => { - const response = DHTResponse.decode(message) - expect(response.type).to.eql(DHTResponse.Type.END) - } - ] - - while (true) { - if (expectedResponses.length === 0) break - const message = await streamHandler.read() - expectedResponses.shift()(message.slice()) - } - streamHandler.close() - }) - - it('should error when no provider is found', async () => { - // Register the peer as a provider - const cid = CID.parse('QmaSNGNpisJ1UeuoH3WcKuia4hQVi2XkfhkszTbWak9xTB') - - // Now find it as a provider - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.FIND_PROVIDERS, - cid: cid.bytes, - count: 1 - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const expectedResponses = [ - (message) => { - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.ERROR) - } - ] - - while (true) { - if (expectedResponses.length === 0) break - const message = await streamHandler.read() - expectedResponses.shift()(message.slice()) - } - streamHandler.close() - }) - - it('should be able to get closest peers to a key', async () => { - // Now find it as a provider - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.GET_CLOSEST_PEERS, - key: uint8ArrayFromString('foobar') - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const expectedResponses = [ - (message) => { - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - expect(response.dht.type).to.eql(DHTResponse.Type.BEGIN) - }, - (message) => { - const response = DHTResponse.decode(message) - expect(response.type).to.eql(DHTResponse.Type.VALUE) - expect(uint8ArrayToString(response.value, 'base58btc')).to.eql(libp2pPeer.peerId.toB58String()) - }, - (message) => { - const response = DHTResponse.decode(message) - expect(response.type).to.eql(DHTResponse.Type.END) - } - ] - - while (true) { - if (expectedResponses.length === 0) break - const message = await streamHandler.read() - expectedResponses.shift()(message.slice()) - } - streamHandler.close() - }) - - it('should be able to get the public key of a peer', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.GET_PUBLIC_KEY, - peer: libp2pPeer.peerId.toBytes() - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(response.dht.type).to.eql(DHTResponse.Type.VALUE) - expect(new Uint8Array(response.dht.value)).to.eql(libp2pPeer.peerId.pubKey.bytes) - streamHandler.close() - }) - - it('should be able to get a value from the dht', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - await libp2pPeer.contentRouting.put(uint8ArrayFromString('/hello'), uint8ArrayFromString('world')) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.GET_VALUE, - key: uint8ArrayFromString('/hello') - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(response.dht.type).to.eql(DHTResponse.Type.VALUE) - expect(new Uint8Array(response.dht.value)).to.eql(uint8ArrayFromString('world')) - streamHandler.close() - }) - - it('should error when it cannot find a value', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.GET_VALUE, - key: uint8ArrayFromString('/v/doesntexist') - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.ERROR) - streamHandler.close() - }) - - it('should be able to put a value to the dht', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.DHT, - connect: null, - streamOpen: null, - streamHandler: null, - dht: { - type: DHTRequest.Type.PUT_VALUE, - key: uint8ArrayFromString('/hello2'), - value: uint8ArrayFromString('world2') - }, - disconnect: null, - pubsub: null, - connManager: null - } - - streamHandler.write(Request.encode(request).finish()) - - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(response.dht).to.eql(null) - streamHandler.close() - - const result = await libp2pPeer.contentRouting.get(uint8ArrayFromString('/hello2')) - expect(result).to.have.property('val').that.eql(uint8ArrayFromString('world2')) - }) -}) diff --git a/test/daemon/peerstore.spec.ts b/test/daemon/peerstore.spec.ts deleted file mode 100644 index 8ab96c11..00000000 --- a/test/daemon/peerstore.spec.ts +++ /dev/null @@ -1,130 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ['error', 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const { Multiaddr } = require('multiaddr') -const delay = require('delay') -const StreamHandler = require('../../src/stream-handler') -const { createDaemon } = require('../../src/daemon') -const Client = require('../../src/client') -const { createLibp2p } = require('../../src/libp2p') -const { isWindows } = require('../../src/util') -const { connect } = require('../util') -const { - Request, - Response, - PeerstoreRequest -} = require('../../src/protocol') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -describe('peerstore features', () => { - let daemon - let libp2pPeer - let client - - before(async function () { - this.timeout(20e3) - daemon = await createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0,/ip4/0.0.0.0/tcp/0/ws', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '' - }) - libp2pPeer = await createLibp2p({ - dht: true, - hostAddrs: '/ip4/0.0.0.0/tcp/0', - nat: false - }) - - await Promise.all([ - daemon.start(), - libp2pPeer.start() - ]) - - await connect({ - libp2pPeer, - multiaddr: daemonAddr - }) - - // Give the nodes a moment to handshake - await delay(500) - }) - - after(() => { - return Promise.all([ - daemon.stop(), - libp2pPeer.stop() - ]) - }) - - afterEach(async () => { - await client && client.close() - }) - - it('should be able to get the protocols for a peer', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.PEERSTORE, - peerStore: { - type: PeerstoreRequest.Type.GET_PROTOCOLS, - id: libp2pPeer.peerId.toBytes() - } - } - - streamHandler.write(Request.encode(request).finish()) - - const message = await streamHandler.read() - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - expect(response.peerStore.protos).to.eql([ - '/libp2p/circuit/relay/0.1.0', - '/ipfs/ping/1.0.0', - '/ipfs/id/1.0.0', - '/ipfs/id/push/1.0.0', - '/ipfs/kad/1.0.0', - '/libp2p/fetch/0.0.1' - ].sort()) - streamHandler.close() - }) - - it('NOT IMPLEMENTED get peer info', async () => { - client = new Client(daemonAddr) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.PEERSTORE, - peerStore: { - type: PeerstoreRequest.Type.GET_PEER_INFO, - id: libp2pPeer.peerId.toBytes() - } - } - - streamHandler.write(Request.encode(request).finish()) - - const message = await streamHandler.read() - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.ERROR) - expect(response.error.msg).to.eql('ERR_NOT_IMPLEMENTED') - streamHandler.close() - }) -}) diff --git a/test/daemon/pubsub.spec.ts b/test/daemon/pubsub.spec.ts deleted file mode 100644 index e542436d..00000000 --- a/test/daemon/pubsub.spec.ts +++ /dev/null @@ -1,300 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const { Multiaddr } = require('multiaddr') -const delay = require('delay') -const pipe = require('it-pipe') -const { collect, take } = require('streaming-iterables') -const lp = require('it-length-prefixed') -const pDefer = require('p-defer') -const toBuffer = require('it-buffer') -const pushable = require('it-pushable') -const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') - -const StreamHandler = require('../../src/stream-handler') -const { createDaemon } = require('../../src/daemon') -const { createLibp2p } = require('../../src/libp2p') -const Client = require('../../src/client') -const { isWindows } = require('../../src/util') -const { connect } = require('../util') -const { - Request, - Response, - PSRequest, - PSMessage -} = require('../../src/protocol') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -const testPubsub = (router) => { - describe(`pubsub - ${router}`, () => { - let daemon - let libp2pPeer - let client - - beforeEach(async function () { - this.timeout(20e3) - ;[daemon, libp2pPeer] = await Promise.all([ - createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0,/ip4/0.0.0.0/tcp/0/ws', - b: false, - dht: false, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '', - pubsub: true, - pubsubRouter: router - }), - createLibp2p({ - pubsub: true, - nat: false, - pubsubRouter: router, - hostAddrs: '/ip4/0.0.0.0/tcp/0' - }) - ]) - await Promise.all([ - daemon.start(), - libp2pPeer.start() - ]) - - await connect({ - libp2pPeer, - multiaddr: daemonAddr - }) - - // Give the nodes a moment to handshake - await delay(500) - }) - - afterEach(async () => { - await Promise.all([ - client && client.close(), - libp2pPeer.stop(), - daemon.stop() - ]) - }) - - it('should be able to subscribe to a topic', async () => { - const topic = 'test-topic' - client = new Client(daemonAddr) - - const maConn = await client.connect() - - const request = Request.encode({ - type: Request.Type.PUBSUB, - pubsub: { - type: PSRequest.Type.SUBSCRIBE, - topic - } - }).finish() - - const [response] = await pipe( - [request], - lp.encode(), - maConn, - lp.decode(), - take(1), // Just get the OK - source => (async function * () { - for await (const chunk of source) { - yield Response.decode(chunk.slice()) - } - })(), - collect - ) - expect(response.type).to.eql(Response.Type.OK) - - maConn.close() - }) - - it('should get subscribed topics', async () => { - const topic = 'test-topic' - client = new Client(daemonAddr) - - const maConn = await client.connect() - let streamHandler = new StreamHandler({ stream: maConn }) - - const requestGetTopics = { - type: Request.Type.PUBSUB, - connect: null, - streamOpen: null, - streamHandler: null, - pubsub: { - type: PSRequest.Type.GET_TOPICS - }, - disconnect: null, - connManager: null - } - - const requestSubscribe = { - type: Request.Type.PUBSUB, - connect: null, - streamOpen: null, - streamHandler: null, - pubsub: { - type: PSRequest.Type.SUBSCRIBE, - topic - }, - disconnect: null, - connManager: null - } - - streamHandler.write(Request.encode(requestGetTopics).finish()) - let response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(response.pubsub.topics).to.have.lengthOf(0) - - streamHandler.write(Request.encode(requestSubscribe).finish()) - response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - // end the connection as it is now reserved for subscribes - maConn.close() - - const conn2 = await client.connect() - - streamHandler = new StreamHandler({ stream: conn2 }) - streamHandler.write(Request.encode(requestGetTopics).finish()) - response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - expect(response.pubsub.topics).to.have.lengthOf(1) - expect(response.pubsub.topics[0]).to.eql(topic) - conn2.close() - }) - - it('should be able to publish messages', async function () { - this.timeout(10e3) - - const topic = 'test-topic' - const data = uint8ArrayFromString('test-data') - const deferred = pDefer() - - client = new Client(daemonAddr) - const maConn = await client.connect() - - // subscribe topic - await libp2pPeer.pubsub.subscribe(topic, (msg) => { - expect(msg.data).to.equalBytes(data) - deferred.resolve() - }, {}) - - // Give the subscribe call some time to propagate - await delay(1000) - - // publish topic - const request = Request.encode({ - type: Request.Type.PUBSUB, - connect: null, - streamOpen: null, - streamHandler: null, - pubsub: { - type: PSRequest.Type.PUBLISH, - topic, - data: data - }, - disconnect: null, - connManager: null - }).finish() - - const [response] = await pipe( - [request], - lp.encode(), - maConn, - lp.decode(), - source => (async function * () { - for await (const chunk of source) { - yield Response.decode(chunk.slice()) - } - })(), - collect - ) - expect(response.type).to.eql(Response.Type.OK) - - await deferred.promise - maConn.close() - }) - - it('should be able to receive messages from subscribed topics', async function () { - const topic = 'test-topic' - const data = uint8ArrayFromString('test-data') - - client = new Client(daemonAddr) - - const maConn = await client.connect() - - // subscribe topic - const request = Request.encode({ - type: Request.Type.PUBSUB, - connect: null, - streamOpen: null, - streamHandler: null, - pubsub: { - type: PSRequest.Type.SUBSCRIBE, - topic - }, - disconnect: null, - connManager: null - }).finish() - - // Publish in 1 seconds - ;(async () => { - await delay(1000) - await libp2pPeer.pubsub.publish(topic, data) - })() - - // The underlying socket does not allow half closed connections, - // so give it a "pausable" source. - const source = pushable() - source.push(request) - - const responses = await pipe( - source, - lp.encode(), - maConn, - lp.decode(), - take(2), // get the OK and the 1st publish message - toBuffer, - collect - ) - - // We're done, end our half of the connection - source.end() - - const expectedResponses = [ - (message) => { - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - }, - (message) => { - const response = PSMessage.decode(message) - expect(response.from.toString()).to.eql(libp2pPeer.peerId.toB58String()) - expect(response.data).to.exist() - expect(response.data).to.equalBytes(data) - expect(response.topicIDs).to.eql([topic]) - expect(response.seqno).to.exist() - } - ] - expect(responses).to.have.length(2) - for (const response of responses) { - expectedResponses.shift()(response) - } - - maConn.close() - }) - }) -} - -describe('pubsub', () => { - testPubsub('gossipsub') - testPubsub('floodsub') -}) diff --git a/test/daemon/streams.spec.ts b/test/daemon/streams.spec.ts deleted file mode 100644 index d85b2305..00000000 --- a/test/daemon/streams.spec.ts +++ /dev/null @@ -1,196 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 5] */ -'use strict' - -const { expect } = require('aegir/utils/chai') -const os = require('os') -const path = require('path') -const pipe = require('it-pipe') -const { Multiaddr } = require('multiaddr') -const { collect, take } = require('streaming-iterables') -const { toBuffer } = require('it-buffer') -const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string') -const { equals: uint8ArrayEquals } = require('uint8arrays/equals') - -const StreamHandler = require('../../src/stream-handler') -const Client = require('../../src/client') -const { createDaemon } = require('../../src/daemon') -const { createLibp2p } = require('../../src/libp2p') -const { isWindows } = require('../../src/util') -const { connect } = require('../util') -const { - Request, - Response, - StreamInfo -} = require('../../src/protocol') - -const daemonAddr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/8080') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2pd.sock')}`) - -describe('streams', function () { - let daemon - let libp2pPeer - let client - - before(function () { - this.timeout(20e3) - return Promise.all([ - createDaemon({ - quiet: false, - q: false, - bootstrap: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0,/ip4/0.0.0.0/tcp/0/ws', - b: false, - dht: true, - nat: false, - dhtClient: false, - connMgr: false, - listen: daemonAddr.toString(), - id: '', - bootstrapPeers: '' - }), - createLibp2p({ - dht: true, - nat: false, - hostAddrs: '/ip4/0.0.0.0/tcp/0' - }) - ]).then((results) => { - daemon = results.shift() - libp2pPeer = results.shift() - - return Promise.all([ - daemon.start(), - libp2pPeer.start() - ]) - }).then(() => { - return connect({ - libp2pPeer, - multiaddr: daemonAddr - }) - }) - }) - - after(() => { - return Promise.all([ - daemon.stop(), - libp2pPeer.stop() - ]) - }) - - afterEach(async () => { - await client && client.close() - }) - - it('should be able to open a stream and echo with it', async () => { - const hello = uint8ArrayFromString('hello there') - - // Have the peer echo our messages back - await libp2pPeer.handle('/echo/1.0.0', ({ stream }) => pipe(stream, stream)) - - client = new Client(daemonAddr) - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - - const request = { - type: Request.Type.STREAM_OPEN, - connect: null, - streamOpen: { - peer: libp2pPeer.peerId.toBytes(), - proto: ['/echo/1.0.0'] - }, - streamHandler: null, - dht: null, - connManager: null - } - - const req = Request.encode(request).finish() - - // Open a stream from the daemon to the peer node - streamHandler.write(req) - - // Verify the response - const response = Response.decode(await streamHandler.read()) - - expect(response.type).to.eql(Response.Type.OK) - expect(response.streamInfo).to.have.deep.property('peer', libp2pPeer.peerId.toBytes()) - expect(response.streamInfo).to.have.property('proto', '/echo/1.0.0') - expect(response.streamInfo.addr).to.satisfy(function (buffer) { - const addrs = libp2pPeer.multiaddrs - return addrs.filter(addr => uint8ArrayEquals(buffer, addr.encapsulate(`/p2p/${libp2pPeer.peerId.toB58String()}`).bytes)).length > 0 - }, 'Did not contain a valid multiaddr') - - const source = require('it-pushable')() - const stream = streamHandler.rest() - source.push(hello) - const output = await pipe( - source, - stream, - take(1), - toBuffer, - collect - ) - source.end() - expect(output).to.eql([hello]) - }) - - it('should be able to register a stream handler and echo with it', async () => { - client = new Client(daemonAddr) - const addr = isWindows - ? new Multiaddr('/ip4/0.0.0.0/tcp/9090') - : new Multiaddr(`/unix${path.resolve(os.tmpdir(), '/tmp/p2p-echo-handler.sock')}`) - - const maConn = await client.connect() - const streamHandler = new StreamHandler({ stream: maConn }) - // Start an echo server, where we will handle streams from the daemon - await client.start(addr, async (connection) => { - const streamHandler = new StreamHandler({ stream: connection }) - - // Read the stream info from the daemon, then pipe to echo - const message = await streamHandler.read() - const response = StreamInfo.decode(message) - - expect(response.peer).to.eql(libp2pPeer.peerId.toBytes()) - expect(response.proto).to.eql('/echo/1.0.0') - - const stream = streamHandler.rest() - // Echo messages - pipe( - stream, - stream - ) - }) - - const request = { - type: Request.Type.STREAM_HANDLER, - connect: null, - streamOpen: null, - streamHandler: { - addr: addr.bytes, - proto: ['/echo/1.0.0'] - }, - dht: null, - connManager: null - } - - // Register the stream handler - streamHandler.write(Request.encode(request).finish()) - const response = Response.decode(await streamHandler.read()) - expect(response.type).to.eql(Response.Type.OK) - - // Open a connection between the peer and our daemon - // Then send hello from the peer to the daemon - const connection = await libp2pPeer.dial(daemon.libp2p.peerId) - const { stream } = await connection.newStream('/echo/1.0.0') - const hello = uint8ArrayFromString('hello, peer') - - const results = await pipe( - [hello], - stream, - toBuffer, - collect - ) - - expect(results).to.eql([hello]) - }) -}) diff --git a/test/resources/rsa.key b/test/resources/rsa.key deleted file mode 100644 index a428cc56..00000000 Binary files a/test/resources/rsa.key and /dev/null differ diff --git a/test/resources/secp256k1.key b/test/resources/secp256k1.key deleted file mode 100644 index 03bc63c2..00000000 --- a/test/resources/secp256k1.key +++ /dev/null @@ -1 +0,0 @@ - zm/kPaࡓ$Zp">v \ No newline at end of file diff --git a/test/util/index.ts b/test/util/index.ts deleted file mode 100644 index 86a1981a..00000000 --- a/test/util/index.ts +++ /dev/null @@ -1,45 +0,0 @@ -'use strict' - -const { expect } = require('aegir/utils/chai') -const Client = require('../../src/client') -const StreamHandler = require('../../src/stream-handler') -const { - Request, - Response -} = require('../../src/protocol') - -/** - * Creates a new client connected at `options.multiaddr` and connects the daemon - * to`libp2pPeer`. - * - * @param {object} options - * @param {Libp2p} options.libp2pPeer - * @param {Multiaddr} options.multiaddr - * @returns {void} - */ -async function connect ({ - libp2pPeer, - multiaddr -}) { - const client = new Client(multiaddr) - - const maConn = await client.connect() - const request = { - type: Request.Type.CONNECT, - connect: { - peer: libp2pPeer.peerId.toBytes(), - addrs: libp2pPeer.multiaddrs.map(addr => addr.bytes) - } - } - - const streamHandler = new StreamHandler({ stream: maConn }) - streamHandler.write(Request.encode(request).finish()) - - const message = await streamHandler.read() - const response = Response.decode(message) - expect(response.type).to.eql(Response.Type.OK) - - await maConn.close() -} - -module.exports.connect = connect