-
Notifications
You must be signed in to change notification settings - Fork 3
/
index.js
199 lines (153 loc) · 4.85 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
import Hyperdrive from 'hyperdrive'
import ram from 'random-access-memory'
import crypto from 'hypercore-crypto'
import DatDNSAPI from 'dat-dns'
import DiscoverySwarm from 'discovery-swarm'
import HypercoreProtocol from 'hypercore-protocol'
import DatEncoding from 'dat-encoding'
import { EventEmitter } from 'events'
import krpc from 'k-rpc'
import sha1 from 'simple-sha1'
import SWARM_DEFAULTS from 'dat-swarm-defaults'
const DEFAULT_OPTIONS = {
sparse: true
}
const DEFAULT_DNS_HOST = 'dns.dns-over-https.com'
const DEFAULT_DNS_PATH = '/dns-query'
const DEFAULT_DNS_OPTS = {
dnsHost: DEFAULT_DNS_HOST,
dnsPath: DEFAULT_DNS_PATH
}
const DAT_SWARM_PORT = 3282
/**
* The Dat object. Manages multiple repositories in
* a single discovery-swarm instance.
* @param {Object} opts Default options to use for the dat.
*/
export default class Dat extends EventEmitter {
async resolveName (url) {
return this.dns.resolveName(url)
}
constructor (opts) {
super()
this.opts = Object.assign({}, DEFAULT_OPTIONS, opts || {})
if (!this.opts.id) this.opts.id = crypto.randomBytes(32)
this.archives = []
this.dns = DatDNSAPI(Object.assign({}, DEFAULT_DNS_OPTS, this.opts))
const swarmOpts = SWARM_DEFAULTS({
hash: false,
stream: (info) => this._createReplicationStream(info)
})
swarmOpts.dht.krpc = krpc({
isIP: () => true,
idLength: Buffer.from(sha1.sync(Buffer.from('')), 'hex').length
})
this.swarm = new DiscoverySwarm(swarmOpts)
this._opening = new Promise((resolve, reject) => {
this.swarm.listen(DAT_SWARM_PORT, (err) => {
if (err) return reject(err)
this._opening = null
resolve()
})
})
}
// Based on beaker-core https://github.com/beakerbrowser/beaker-core/blob/54726a042dc0f72773a9e147c87f8072a9d7a39a/dat/daemon/index.js#L531
_createReplicationStream (info) {
// console.log('Got peer', info)
const stream = new HypercoreProtocol({
id: this.opts.id,
live: true,
encrypt: true
})
stream.peerInfo = info
stream.on('error', (e) => console.log(e))
if (info.channel) this._replicateWith(stream, info.channel)
return stream
}
_replicateWith (stream, discoveryKey) {
const discoveryKeyString = DatEncoding.encode(discoveryKey)
const archive = this.archives.find((archive) => DatEncoding.encode(archive.discoveryKey) === discoveryKeyString)
// Unknown archive
if (!archive) return
archive.replicate({ stream, live: true })
}
/**
* Returns a repo with the given url. Returns undefined
* if no repository is found with that url.
* @param {url} url The url of the repo.
* @return {Promise<Repo>} The repo object with the corresponding url.
*/
async get (url) {
const key = await this.resolveName(url)
const stringkey = DatEncoding.encode(key)
const archive = this.archives.find((archive) => DatEncoding.encode(archive.key) === stringkey)
if (archive) return archive
return this._add(key)
}
async _add (key, opts) {
if (this.destroyed) throw new Error('client is destroyed')
await this._opening
if (!opts) opts = {}
const finalOpts = Object.assign({}, this.opts, opts)
if (!key) {
const keyPair = crypto.keyPair()
key = keyPair.publicKey
finalOpts.secretKey = keyPair.secretKey
}
const stringkey = DatEncoding.encode(key)
const db = (file) => {
const db = finalOpts.db || ram
return db(stringkey + '/' + file)
}
// console.log('Resolved key', key.toString('hex'))
const archive = new Hyperdrive(db, key, finalOpts)
this.archives.push(archive)
return new Promise((resolve, reject) => {
console.log('Waiting for ready')
archive.ready(() => {
console.log('Ready')
// archive.metadata.update((err) => {
// if (err) reject(err)
// else resolve(archive)
resolve(archive)
this.emit('repo', archive)
// })
this.swarm.join(archive.discoveryKey, {
announce: true
})
})
})
}
async create (opts) {
return this._add(null, opts)
}
async has (url) {
const key = await this.resolveName(url)
const stringkey = DatEncoding.encode(key)
const archive = this.archives.find((archive) => DatEncoding.encode(archive.key) === stringkey)
return !!archive
}
/**
* Closes the dat, the swarm, and all underlying repo instances.
*/
async close () {
if (this.destroyed) {
return
}
this.destroyed = true
await new Promise((resolve, reject) => {
this.swarm.close((err) => {
if (err) reject(err)
else resolve()
})
})
await Promise.all(this.archives.map((archive) => {
return new Promise(resolve => archive.close(resolve))
}))
this.repos = null
this.emit('close')
}
destroy () {
return this.close()
}
}