ln-docker-daemons 8.1.1 → 8.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +30 -21
- package/bitcoind/spawn_bitcoind_docker.js +43 -23
- package/bitcoinrpc/add_peer.js +13 -1
- package/cluster/spawn_lightning_cluster.js +21 -39
- package/docker/spawn_docker_image.js +42 -4
- package/lnd/spawn_lightning_docker.js +35 -43
- package/lnd/spawn_lnd_docker.js +41 -26
- package/package.json +2 -3
package/README.md
CHANGED
|
@@ -90,11 +90,15 @@ await kill({});
|
|
|
90
90
|
|
|
91
91
|
Spawn a Bitcoin Core Docker image
|
|
92
92
|
|
|
93
|
+
Ports that are not specified are not published to the host, except for RPC,
|
|
94
|
+
which is published on a free port picked by Docker. ZMQ defaults to ports
|
|
95
|
+
28332 and 28333 inside the container.
|
|
96
|
+
|
|
93
97
|
{
|
|
94
|
-
p2p_port: <P2P Port Number>
|
|
95
|
-
rpc_port: <RPC Port Number>
|
|
96
|
-
zmq_block_port: <ZMQ Blocks Port Number>
|
|
97
|
-
zmq_tx_port: <ZMQ Transactions Port Number>
|
|
98
|
+
[p2p_port]: <P2P Port Number>
|
|
99
|
+
[rpc_port]: <RPC Port Number>
|
|
100
|
+
[zmq_block_port]: <ZMQ Blocks Port Number>
|
|
101
|
+
[zmq_tx_port]: <ZMQ Transactions Port Number>
|
|
98
102
|
}
|
|
99
103
|
|
|
100
104
|
@returns via cbk or Promise
|
|
@@ -102,7 +106,10 @@ Spawn a Bitcoin Core Docker image
|
|
|
102
106
|
host: <Host String>
|
|
103
107
|
kill: ({}, [cbk]) => <Kill Promise>
|
|
104
108
|
rpc_pass: <RPC Password String>
|
|
109
|
+
rpc_port: <RPC Port Number>
|
|
105
110
|
rpc_user: <RPC Username String>
|
|
111
|
+
zmq_block_port: <ZMQ Blocks Port Number>
|
|
112
|
+
zmq_tx_port: <ZMQ Transactions Port Number>
|
|
106
113
|
}
|
|
107
114
|
|
|
108
115
|
Example:
|
|
@@ -110,13 +117,8 @@ Example:
|
|
|
110
117
|
```node
|
|
111
118
|
const {spawnBitcoindDocker} = require('ln-docker-daemons');
|
|
112
119
|
|
|
113
|
-
// Launch a Bitcoind Docker image
|
|
114
|
-
const {kill} = spawnBitcoindDocker({
|
|
115
|
-
p2p_port: 2345,
|
|
116
|
-
rpc_port: 3456,
|
|
117
|
-
zmq_block_port: 4567,
|
|
118
|
-
zmq_tx_port: 5678,
|
|
119
|
-
});
|
|
120
|
+
// Launch a Bitcoind Docker image, Docker picks a free port for RPC
|
|
121
|
+
const {kill, rpc_port} = await spawnBitcoindDocker({});
|
|
120
122
|
|
|
121
123
|
// Stop the image
|
|
122
124
|
await kill({});
|
|
@@ -196,15 +198,19 @@ await kill({});
|
|
|
196
198
|
|
|
197
199
|
Spawn an LND Docker
|
|
198
200
|
|
|
201
|
+
Ports are optional. When RPC or tower ports are not specified, Docker picks
|
|
202
|
+
free host ports for them. Other ports that are not specified are only
|
|
203
|
+
reachable over the Docker network.
|
|
204
|
+
|
|
199
205
|
{
|
|
200
|
-
chain_p2p_port: <Chain Network P2P Listen Port Number>
|
|
201
|
-
chain_rpc_port: <Chain Node RPC Port Number>
|
|
202
|
-
chain_zmq_block_port: <Chain Node ZMQ Blocks Port Number>
|
|
203
|
-
chain_zmq_tx_port: <Chain Node ZMQ Transactions Port Number>
|
|
206
|
+
[chain_p2p_port]: <Chain Network P2P Listen Port Number>
|
|
207
|
+
[chain_rpc_port]: <Chain Node RPC Port Number>
|
|
208
|
+
[chain_zmq_block_port]: <Chain Node ZMQ Blocks Port Number>
|
|
209
|
+
[chain_zmq_tx_port]: <Chain Node ZMQ Transactions Port Number>
|
|
204
210
|
generate_address: <Generate Blocks to Address String>
|
|
205
|
-
lightning_p2p_port: <Lightning Network P2P Listen Port Number>
|
|
206
|
-
lightning_rpc_port: <Lightning Node RPC Port Number>
|
|
207
|
-
lightning_tower_port: <Lightning Tower Port Number>
|
|
211
|
+
[lightning_p2p_port]: <Lightning Network P2P Listen Port Number>
|
|
212
|
+
[lightning_rpc_port]: <Lightning Node RPC Port Number>
|
|
213
|
+
[lightning_tower_port]: <Lightning Tower Port Number>
|
|
208
214
|
[lnd_configuration]: [<LND Configuration Argument String>]
|
|
209
215
|
[seed]: <Mnemonic Seed String>
|
|
210
216
|
}
|
|
@@ -226,6 +232,9 @@ Spawn an LND Docker
|
|
|
226
232
|
|
|
227
233
|
Spawn a new Docker image running LND
|
|
228
234
|
|
|
235
|
+
When RPC or tower ports are not specified, Docker picks free host ports for
|
|
236
|
+
them. A p2p port that is not specified is not published to the host.
|
|
237
|
+
|
|
229
238
|
{
|
|
230
239
|
bitcoind_rpc_host: <Bitcoin Core RPC Host String>
|
|
231
240
|
bitcoind_rpc_pass: <Bitcoin Core RPC Password String>
|
|
@@ -234,9 +243,9 @@ Spawn a new Docker image running LND
|
|
|
234
243
|
[bitcoind_zmq_block_port]: <Bitcoin Core ZMQ Block Port Number>
|
|
235
244
|
[bitcoind_zmq_tx_port]: <Bitcoin Core ZMQ Transaction Port Number>
|
|
236
245
|
[configuration]: [<LND Configuration Argument String>]
|
|
237
|
-
p2p_port: <LND Peer to Peer Listen Port Number>
|
|
238
|
-
rpc_port: <LND RPC Port Number>
|
|
239
|
-
tower_port: <LND Tower Port Number>
|
|
246
|
+
[p2p_port]: <LND Peer to Peer Listen Port Number>
|
|
247
|
+
[rpc_port]: <LND RPC Port Number>
|
|
248
|
+
[tower_port]: <LND Tower Port Number>
|
|
240
249
|
[seed]: <Mnemonic Seed String>
|
|
241
250
|
}
|
|
242
251
|
|
|
@@ -12,18 +12,26 @@ const {rpcUser} = require('./constants');
|
|
|
12
12
|
const {spawnDockerImage} = require('./../docker');
|
|
13
13
|
|
|
14
14
|
const clean = string => string.replace(/\+/g, '-').replace(/\//g, '_');
|
|
15
|
+
const defaultZmqBlockPort = 28332;
|
|
16
|
+
const defaultZmqTxPort = 28333;
|
|
15
17
|
const deriveHmac = (s, p) => createHmac('sha256', s).update(p).digest('hex');
|
|
16
18
|
const generateAuthSalt = () => randomBytes(16).toString('hex');
|
|
17
19
|
const generatePassword = () => randomBytes(32).toString('base64');
|
|
18
20
|
const interval = 100;
|
|
19
21
|
const times = 100;
|
|
20
22
|
const trim = string => string.replace(/=+$/g, '');
|
|
23
|
+
const zmqBlockPort = args => args.zmq_block_port || defaultZmqBlockPort;
|
|
24
|
+
const zmqTxPort = args => args.zmq_tx_port || defaultZmqTxPort;
|
|
21
25
|
|
|
22
26
|
/** Spawn a Bitcoin Core Docker image
|
|
23
27
|
|
|
28
|
+
Ports that are not specified are not published to the host, except for RPC,
|
|
29
|
+
which is published on a free port picked by Docker. ZMQ defaults to ports
|
|
30
|
+
28332 and 28333 inside the container.
|
|
31
|
+
|
|
24
32
|
{
|
|
25
|
-
p2p_port: <P2P Port Number>
|
|
26
|
-
rpc_port: <RPC Port Number>
|
|
33
|
+
[p2p_port]: <P2P Port Number>
|
|
34
|
+
[rpc_port]: <RPC Port Number>
|
|
27
35
|
[zmq_block_port]: <ZMQ Blocks Port Number>
|
|
28
36
|
[zmq_tx_port]: <ZMQ Transactions Port Number>
|
|
29
37
|
}
|
|
@@ -33,27 +41,17 @@ const trim = string => string.replace(/=+$/g, '');
|
|
|
33
41
|
host: <Host String>
|
|
34
42
|
kill: ({}, [cbk]) => <Kill Promise>
|
|
35
43
|
rpc_pass: <RPC Password String>
|
|
44
|
+
rpc_port: <RPC Port Number>
|
|
36
45
|
rpc_user: <RPC Username String>
|
|
46
|
+
zmq_block_port: <ZMQ Blocks Port Number>
|
|
47
|
+
zmq_tx_port: <ZMQ Transactions Port Number>
|
|
37
48
|
}
|
|
38
49
|
*/
|
|
39
50
|
module.exports = (args, cbk) => {
|
|
40
51
|
return new Promise((resolve, reject) => {
|
|
41
52
|
return asyncAuto({
|
|
42
|
-
// Check arguments
|
|
43
|
-
validate: cbk => {
|
|
44
|
-
if (!args.p2p_port) {
|
|
45
|
-
return cbk([400, 'ExpectedPeerListenPortToSpawnBitcoindDocker']);
|
|
46
|
-
}
|
|
47
|
-
|
|
48
|
-
if (!args.rpc_port) {
|
|
49
|
-
return cbk([400, 'ExpectedRpcListenPortToSpawnBitcoindDocker']);
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
return cbk();
|
|
53
|
-
},
|
|
54
|
-
|
|
55
53
|
// Generate auth
|
|
56
|
-
generateAuth:
|
|
54
|
+
generateAuth: cbk => {
|
|
57
55
|
const pass = trim(clean(generatePassword()));
|
|
58
56
|
const salt = generateAuthSalt();
|
|
59
57
|
|
|
@@ -61,7 +59,7 @@ module.exports = (args, cbk) => {
|
|
|
61
59
|
rpc_auth: `${rpcUser}:${salt}$${deriveHmac(salt, pass)}`,
|
|
62
60
|
rpc_pass: pass,
|
|
63
61
|
});
|
|
64
|
-
}
|
|
62
|
+
},
|
|
65
63
|
|
|
66
64
|
// Spawn the docker image
|
|
67
65
|
spawnDocker: ['generateAuth', ({generateAuth}, cbk) => {
|
|
@@ -76,18 +74,25 @@ module.exports = (args, cbk) => {
|
|
|
76
74
|
'--rpcbind=0.0.0.0',
|
|
77
75
|
'--server',
|
|
78
76
|
'--txindex',
|
|
77
|
+
`--zmqpubrawblock=tcp://*:${zmqBlockPort(args)}`,
|
|
78
|
+
`--zmqpubrawtx=tcp://*:${zmqTxPort(args)}`,
|
|
79
79
|
];
|
|
80
80
|
|
|
81
81
|
const image = dockerBitcoindImage;
|
|
82
|
-
|
|
82
|
+
|
|
83
|
+
// Docker picks a free host port for RPC when no port is specified
|
|
84
|
+
const ports = {'18443/tcp': args.rpc_port};
|
|
85
|
+
|
|
86
|
+
// Other ports are reached over the Docker network unless specified
|
|
87
|
+
if (!!args.p2p_port) {
|
|
88
|
+
ports['18444/tcp'] = args.p2p_port;
|
|
89
|
+
}
|
|
83
90
|
|
|
84
91
|
if (!!args.zmq_block_port) {
|
|
85
|
-
arguments.push('--zmqpubrawblock=tcp://*:' + args.zmq_block_port);
|
|
86
92
|
ports[`${args.zmq_block_port}/tcp`] = args.zmq_block_port;
|
|
87
93
|
}
|
|
88
94
|
|
|
89
95
|
if (!!args.zmq_tx_port) {
|
|
90
|
-
arguments.push('--zmqpubrawtx=tcp://*:' + args.zmq_tx_port);
|
|
91
96
|
ports[`${args.zmq_tx_port}/tcp`] = args.zmq_tx_port;
|
|
92
97
|
}
|
|
93
98
|
|
|
@@ -95,16 +100,28 @@ module.exports = (args, cbk) => {
|
|
|
95
100
|
}],
|
|
96
101
|
|
|
97
102
|
// Wait for the image to respond to a query
|
|
98
|
-
checkReady: [
|
|
103
|
+
checkReady: [
|
|
104
|
+
'generateAuth',
|
|
105
|
+
'spawnDocker',
|
|
106
|
+
({generateAuth, spawnDocker}, cbk) =>
|
|
107
|
+
{
|
|
99
108
|
return asyncRetry({interval, times}, cbk => {
|
|
100
109
|
return getBlockchainInfo({
|
|
101
110
|
pass: generateAuth.rpc_pass,
|
|
102
|
-
port:
|
|
111
|
+
port: spawnDocker.ports['18443/tcp'],
|
|
103
112
|
user: rpcUser,
|
|
104
113
|
},
|
|
105
114
|
cbk);
|
|
106
115
|
},
|
|
107
|
-
|
|
116
|
+
err => {
|
|
117
|
+
// Exit early when bitcoind is responding
|
|
118
|
+
if (!err) {
|
|
119
|
+
return cbk();
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
// Stop the container when bitcoind never responds
|
|
123
|
+
return spawnDocker.kill({}, () => cbk(err));
|
|
124
|
+
});
|
|
108
125
|
}],
|
|
109
126
|
|
|
110
127
|
// Final docker object
|
|
@@ -118,7 +135,10 @@ module.exports = (args, cbk) => {
|
|
|
118
135
|
host: spawnDocker.host,
|
|
119
136
|
kill: spawnDocker.kill,
|
|
120
137
|
rpc_pass: generateAuth.rpc_pass,
|
|
138
|
+
rpc_port: spawnDocker.ports['18443/tcp'],
|
|
121
139
|
rpc_user: rpcUser,
|
|
140
|
+
zmq_block_port: zmqBlockPort(args),
|
|
141
|
+
zmq_tx_port: zmqTxPort(args),
|
|
122
142
|
});
|
|
123
143
|
}],
|
|
124
144
|
},
|
package/bitcoinrpc/add_peer.js
CHANGED
|
@@ -4,11 +4,16 @@ const {returnResult} = require('asyncjs-util');
|
|
|
4
4
|
const rpc = require('./rpc');
|
|
5
5
|
|
|
6
6
|
const action = 'add';
|
|
7
|
+
const alreadyAdded = -23;
|
|
7
8
|
const cmd = 'addnode';
|
|
8
9
|
const host = 'localhost';
|
|
10
|
+
const isAlreadyAdded = err => isRpcError(err) && err[2].code === alreadyAdded;
|
|
11
|
+
const isRpcError = err => err[1] === 'UnexpectedErrorFromRpcCommand';
|
|
9
12
|
|
|
10
13
|
/** Add a node as a peer
|
|
11
14
|
|
|
15
|
+
Adding a node that is already added is not an error
|
|
16
|
+
|
|
12
17
|
{
|
|
13
18
|
pass: <RPC Password String>
|
|
14
19
|
port: <RPC Port Number>
|
|
@@ -46,7 +51,14 @@ module.exports = ({pass, port, socket, user}, cbk) => {
|
|
|
46
51
|
request: ['validate', ({}, cbk) => {
|
|
47
52
|
const params = [socket, action];
|
|
48
53
|
|
|
49
|
-
return rpc({cmd, host, pass, params, port, user},
|
|
54
|
+
return rpc({cmd, host, pass, params, port, user}, err => {
|
|
55
|
+
// Exit early when the node was already added
|
|
56
|
+
if (!!err && isAlreadyAdded(err)) {
|
|
57
|
+
return cbk();
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
return cbk(err);
|
|
61
|
+
});
|
|
50
62
|
}],
|
|
51
63
|
},
|
|
52
64
|
returnResult({reject, resolve}, cbk));
|
|
@@ -1,28 +1,21 @@
|
|
|
1
1
|
const asyncAuto = require('async/auto');
|
|
2
2
|
const asyncEach = require('async/each');
|
|
3
|
-
const asyncMap = require('async/map');
|
|
4
3
|
const asyncMapSeries = require('async/mapSeries');
|
|
5
4
|
const asyncRetry = require('async/retry');
|
|
6
5
|
const {authenticatedLndGrpc} = require('lightning');
|
|
7
|
-
const {findFreePorts} = require('find-free-ports');
|
|
8
|
-
const {getIdentity} = require('lightning');
|
|
9
6
|
const {returnResult} = require('asyncjs-util');
|
|
10
7
|
|
|
11
8
|
const generateBlocks = require('./generate_blocks');
|
|
12
9
|
const {setupChannel} = require('./../setup');
|
|
13
10
|
const {spawnLightningDocker} = require('./../lnd');
|
|
14
11
|
|
|
15
|
-
const between = (min, max) => Math.floor(Math.random() * (max - min) + min);
|
|
16
|
-
const chunk = (arr, n, size) => [...Array(size)].map(_ => arr.splice(0, n));
|
|
17
12
|
const count = size => size || 1;
|
|
18
|
-
const endPort = 65000;
|
|
19
13
|
const generateAddress = '2N8hwP1WmJrFF5QWABn38y63uYLhnJYJYTF';
|
|
20
14
|
const interval = 10;
|
|
21
15
|
const {isInteger} = Number;
|
|
22
16
|
const line = arr => arr.slice(1).map((_, i) => [i, i + 1]);
|
|
23
17
|
const pairs = n => n.map((x, i) => n.slice(i + 1).map(y => [x, y])).flat();
|
|
24
|
-
const
|
|
25
|
-
const startPort = 1025;
|
|
18
|
+
const started = all => all.filter(n => !!n.value).map(n => n.value);
|
|
26
19
|
|
|
27
20
|
/** Spawn a cluster of nodes
|
|
28
21
|
|
|
@@ -75,38 +68,29 @@ module.exports = (args, cbk) => {
|
|
|
75
68
|
// Spawn nodes
|
|
76
69
|
spawn: ['validate', async () => {
|
|
77
70
|
return await asyncRetry({interval, times: 25}, async () => {
|
|
78
|
-
const
|
|
79
|
-
|
|
80
|
-
// Find ports for the requested daemons
|
|
81
|
-
const findPorts = await findFreePorts(
|
|
82
|
-
portsPerLnd * count(args.size),
|
|
83
|
-
options
|
|
84
|
-
);
|
|
85
|
-
|
|
86
|
-
const nodes = chunk(findPorts, portsPerLnd, count(args.size));
|
|
87
|
-
|
|
88
|
-
return await asyncMap(nodes, async (ports) => {
|
|
89
|
-
const [
|
|
90
|
-
chainP2pPort,
|
|
91
|
-
chainRpcPort,
|
|
92
|
-
chainZmqBlockPort,
|
|
93
|
-
chainZmqTxPort,
|
|
94
|
-
lightningP2pPort,
|
|
95
|
-
lightningRpcPort,
|
|
96
|
-
lightningTowerPort,
|
|
97
|
-
] = ports;
|
|
98
|
-
|
|
99
|
-
const lightningDocker = await spawnLightningDocker({
|
|
100
|
-
chain_p2p_port: chainP2pPort,
|
|
101
|
-
chain_rpc_port: chainRpcPort,
|
|
102
|
-
chain_zmq_block_port: chainZmqBlockPort,
|
|
103
|
-
chain_zmq_tx_port: chainZmqTxPort,
|
|
71
|
+
const spawning = [...Array(count(args.size))].map(() => {
|
|
72
|
+
return spawnLightningDocker({
|
|
104
73
|
generate_address: generateAddress,
|
|
105
|
-
lightning_p2p_port: lightningP2pPort,
|
|
106
|
-
lightning_rpc_port: lightningRpcPort,
|
|
107
|
-
lightning_tower_port: lightningTowerPort,
|
|
108
74
|
lnd_configuration: args.lnd_configuration,
|
|
109
75
|
});
|
|
76
|
+
});
|
|
77
|
+
|
|
78
|
+
// Wait for every node to finish starting, even when one fails
|
|
79
|
+
const spawned = await Promise.allSettled(spawning);
|
|
80
|
+
|
|
81
|
+
const failure = spawned.find(n => n.status === 'rejected');
|
|
82
|
+
|
|
83
|
+
// Stop the nodes that started so they are not left running
|
|
84
|
+
if (!!failure) {
|
|
85
|
+
await asyncEach(started(spawned), async ({kill}) => {
|
|
86
|
+
return await kill({});
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
throw failure.reason;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
return started(spawned).map(lightningDocker => {
|
|
93
|
+
const id = lightningDocker.public_key;
|
|
110
94
|
|
|
111
95
|
const {lnd} = authenticatedLndGrpc({
|
|
112
96
|
cert: lightningDocker.cert,
|
|
@@ -114,8 +98,6 @@ module.exports = (args, cbk) => {
|
|
|
114
98
|
socket: lightningDocker.socket,
|
|
115
99
|
});
|
|
116
100
|
|
|
117
|
-
const id = (await getIdentity({lnd})).public_key;
|
|
118
|
-
|
|
119
101
|
return {
|
|
120
102
|
id,
|
|
121
103
|
lnd,
|
|
@@ -12,6 +12,8 @@ const stopAfterRuntimeSeconds = 60;
|
|
|
12
12
|
|
|
13
13
|
/** Spawn a new docker image
|
|
14
14
|
|
|
15
|
+
An undefined external port is published on a free port that Docker picks
|
|
16
|
+
|
|
15
17
|
{
|
|
16
18
|
arguments: [<Command Arguments String>]
|
|
17
19
|
[expose]: [<Expose Port String>]
|
|
@@ -24,7 +26,11 @@ const stopAfterRuntimeSeconds = 60;
|
|
|
24
26
|
@returns via cbk or Promise
|
|
25
27
|
{
|
|
26
28
|
getFile: <Get File Function>
|
|
29
|
+
host: <Container Network Address String>
|
|
27
30
|
kill: <Kill Daemon Function>
|
|
31
|
+
ports: {
|
|
32
|
+
<Internal Port String>: <External Port Number>
|
|
33
|
+
}
|
|
28
34
|
}
|
|
29
35
|
*/
|
|
30
36
|
module.exports = ({arguments, expose, image, ports}, cbk) => {
|
|
@@ -106,7 +112,8 @@ module.exports = ({arguments, expose, image, ports}, cbk) => {
|
|
|
106
112
|
HostConfig: {
|
|
107
113
|
AutoRemove: true,
|
|
108
114
|
PortBindings: keys(ports).reduce((sum, port) => {
|
|
109
|
-
|
|
115
|
+
// Docker picks a free host port when none is specified
|
|
116
|
+
sum[port] = [{HostPort: !ports[port] ? '' : `${ports[port]}`}];
|
|
110
117
|
|
|
111
118
|
return sum;
|
|
112
119
|
},
|
|
@@ -135,22 +142,53 @@ module.exports = ({arguments, expose, image, ports}, cbk) => {
|
|
|
135
142
|
return cbk();
|
|
136
143
|
});
|
|
137
144
|
},
|
|
138
|
-
|
|
145
|
+
err => {
|
|
146
|
+
// Exit early when the container started
|
|
147
|
+
if (!err) {
|
|
148
|
+
return cbk();
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
// Remove the container so a failed start does not leave it behind
|
|
152
|
+
return container.remove({force: true}, () => cbk(err));
|
|
153
|
+
});
|
|
139
154
|
}],
|
|
140
155
|
|
|
141
156
|
// Get the details about the container
|
|
142
157
|
spawned: ['container', 'start', ({container}, cbk) => {
|
|
143
158
|
return container.inspect({}, (err, res) => {
|
|
144
159
|
if (!!err) {
|
|
145
|
-
return
|
|
160
|
+
return killDocker({container}, () => cbk([
|
|
161
|
+
503,
|
|
162
|
+
'UnexpectedErrorGettingContainerDetails',
|
|
163
|
+
{err},
|
|
164
|
+
]));
|
|
146
165
|
}
|
|
147
166
|
|
|
148
167
|
const network = res.NetworkSettings;
|
|
168
|
+
const published = network.Ports || {};
|
|
169
|
+
const {bridge} = network.Networks || {};
|
|
170
|
+
|
|
171
|
+
const host = network.IPAddress || (!!bridge && bridge.IPAddress);
|
|
172
|
+
|
|
173
|
+
// Exit early when the container has no network address
|
|
174
|
+
if (!host) {
|
|
175
|
+
return killDocker({container}, () => {
|
|
176
|
+
return cbk([503, 'ExpectedNetworkAddressForDockerContainer']);
|
|
177
|
+
});
|
|
178
|
+
}
|
|
149
179
|
|
|
150
180
|
return cbk(null, {
|
|
181
|
+
host,
|
|
151
182
|
getFile: ({path}, cbk) => getFile({container, path}, cbk),
|
|
152
|
-
host: network.IPAddress || network.Networks.bridge.IPAddress,
|
|
153
183
|
kill: ({}, cbk) => killDocker({container}, cbk),
|
|
184
|
+
ports: keys(ports).reduce((sum, port) => {
|
|
185
|
+
const [binding] = published[port] || [];
|
|
186
|
+
|
|
187
|
+
sum[port] = !binding ? undefined : Number(binding.HostPort);
|
|
188
|
+
|
|
189
|
+
return sum;
|
|
190
|
+
},
|
|
191
|
+
{}),
|
|
154
192
|
});
|
|
155
193
|
});
|
|
156
194
|
}],
|
|
@@ -12,15 +12,19 @@ const defaultBitcoindRpcPort = 18443;
|
|
|
12
12
|
|
|
13
13
|
/** Spawn an LND Docker
|
|
14
14
|
|
|
15
|
+
Ports are optional. When RPC or tower ports are not specified, Docker picks
|
|
16
|
+
free host ports for them. Other ports that are not specified are only
|
|
17
|
+
reachable over the Docker network.
|
|
18
|
+
|
|
15
19
|
{
|
|
16
|
-
chain_p2p_port: <Chain Network P2P Listen Port Number>
|
|
17
|
-
chain_rpc_port: <Chain Node RPC Port Number>
|
|
18
|
-
chain_zmq_block_port: <Chain Node ZMQ Blocks Port Number>
|
|
19
|
-
chain_zmq_tx_port: <Chain Node ZMQ Transactions Port Number>
|
|
20
|
+
[chain_p2p_port]: <Chain Network P2P Listen Port Number>
|
|
21
|
+
[chain_rpc_port]: <Chain Node RPC Port Number>
|
|
22
|
+
[chain_zmq_block_port]: <Chain Node ZMQ Blocks Port Number>
|
|
23
|
+
[chain_zmq_tx_port]: <Chain Node ZMQ Transactions Port Number>
|
|
20
24
|
generate_address: <Generate Blocks to Address String>
|
|
21
|
-
lightning_p2p_port: <Lightning Network P2P Listen Port Number>
|
|
22
|
-
lightning_rpc_port: <Lightning Node RPC Port Number>
|
|
23
|
-
lightning_tower_port: <Lightning Tower Port Number>
|
|
25
|
+
[lightning_p2p_port]: <Lightning Network P2P Listen Port Number>
|
|
26
|
+
[lightning_rpc_port]: <Lightning Node RPC Port Number>
|
|
27
|
+
[lightning_tower_port]: <Lightning Tower Port Number>
|
|
24
28
|
[lnd_configuration]: [<LND Configuration Argument String>]
|
|
25
29
|
[seed]: <Mnemonic Seed String>
|
|
26
30
|
}
|
|
@@ -45,38 +49,10 @@ module.exports = (args, cbk) => {
|
|
|
45
49
|
return asyncAuto({
|
|
46
50
|
// Check arguments
|
|
47
51
|
validate: cbk => {
|
|
48
|
-
if (!args.chain_p2p_port) {
|
|
49
|
-
return cbk([400, 'ExpectedBlockchainDaemonP2pPortToSpawnLnDocker']);
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
if (!args.chain_rpc_port) {
|
|
53
|
-
return cbk([400, 'ExpecteddChainRpcPortToSpawnLightningDocker']);
|
|
54
|
-
}
|
|
55
|
-
|
|
56
|
-
if (!args.chain_zmq_block_port) {
|
|
57
|
-
return cbk([400, 'ExpectedChainZmqBlockPortToSpawnLightningDocker']);
|
|
58
|
-
}
|
|
59
|
-
|
|
60
|
-
if (!args.chain_zmq_tx_port) {
|
|
61
|
-
return cbk([400, 'ExpectedChainZmqTxPortToSpawnLightningDocker']);
|
|
62
|
-
}
|
|
63
|
-
|
|
64
52
|
if (!args.generate_address) {
|
|
65
53
|
return cbk([400, 'ExpectedGenerateAddressToSpawnLightningDocker']);
|
|
66
54
|
}
|
|
67
55
|
|
|
68
|
-
if (!args.lightning_p2p_port) {
|
|
69
|
-
return cbk([400, 'ExpectedLnP2pPortToSpawnLightningDocker']);
|
|
70
|
-
}
|
|
71
|
-
|
|
72
|
-
if (!args.lightning_rpc_port) {
|
|
73
|
-
return cbk([400, 'ExpectedLnRpcPortToSpawnLightningDocker']);
|
|
74
|
-
}
|
|
75
|
-
|
|
76
|
-
if (!args.lightning_tower_port) {
|
|
77
|
-
return cbk([400, 'ExpectedLnTowerPortToSpawnLightningDocker']);
|
|
78
|
-
}
|
|
79
|
-
|
|
80
56
|
return cbk();
|
|
81
57
|
},
|
|
82
58
|
|
|
@@ -96,10 +72,18 @@ module.exports = (args, cbk) => {
|
|
|
96
72
|
return generateToAddress({
|
|
97
73
|
address: args.generate_address,
|
|
98
74
|
pass: spawnChainDaemon.rpc_pass,
|
|
99
|
-
port:
|
|
75
|
+
port: spawnChainDaemon.rpc_port,
|
|
100
76
|
user: spawnChainDaemon.rpc_user,
|
|
101
77
|
},
|
|
102
|
-
|
|
78
|
+
err => {
|
|
79
|
+
// Exit early when the block was generated
|
|
80
|
+
if (!err) {
|
|
81
|
+
return cbk();
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
// Stop the chain daemon so it is not left running
|
|
85
|
+
return spawnChainDaemon.kill({}, () => cbk(err));
|
|
86
|
+
});
|
|
103
87
|
}],
|
|
104
88
|
|
|
105
89
|
// Spawn the LND lightning daemon
|
|
@@ -114,14 +98,22 @@ module.exports = (args, cbk) => {
|
|
|
114
98
|
bitcoind_rpc_pass: spawnChainDaemon.rpc_pass,
|
|
115
99
|
bitcoind_rpc_port: defaultBitcoindRpcPort,
|
|
116
100
|
bitcoind_rpc_user: spawnChainDaemon.rpc_user,
|
|
117
|
-
bitcoind_zmq_block_port:
|
|
118
|
-
bitcoind_zmq_tx_port:
|
|
101
|
+
bitcoind_zmq_block_port: spawnChainDaemon.zmq_block_port,
|
|
102
|
+
bitcoind_zmq_tx_port: spawnChainDaemon.zmq_tx_port,
|
|
119
103
|
p2p_port: args.lightning_p2p_port,
|
|
120
104
|
rpc_port: args.lightning_rpc_port,
|
|
121
105
|
tower_port: args.lightning_tower_port,
|
|
122
106
|
seed: args.seed,
|
|
123
107
|
},
|
|
124
|
-
|
|
108
|
+
(err, res) => {
|
|
109
|
+
// Exit early when LND started
|
|
110
|
+
if (!err) {
|
|
111
|
+
return cbk(null, res);
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
// Stop the chain daemon when LND does not start
|
|
115
|
+
return spawnChainDaemon.kill({}, () => cbk(err));
|
|
116
|
+
});
|
|
125
117
|
}],
|
|
126
118
|
|
|
127
119
|
// Return the result
|
|
@@ -136,7 +128,7 @@ module.exports = (args, cbk) => {
|
|
|
136
128
|
add_chain_peer: ({socket}) => addPeer({
|
|
137
129
|
socket,
|
|
138
130
|
pass: spawnChainDaemon.rpc_pass,
|
|
139
|
-
port:
|
|
131
|
+
port: spawnChainDaemon.rpc_port,
|
|
140
132
|
user: spawnChainDaemon.rpc_user,
|
|
141
133
|
}),
|
|
142
134
|
cert: spawnLightningDaemon.cert,
|
|
@@ -145,14 +137,14 @@ module.exports = (args, cbk) => {
|
|
|
145
137
|
address,
|
|
146
138
|
count,
|
|
147
139
|
pass: spawnChainDaemon.rpc_pass,
|
|
148
|
-
port:
|
|
140
|
+
port: spawnChainDaemon.rpc_port,
|
|
149
141
|
user: spawnChainDaemon.rpc_user,
|
|
150
142
|
},
|
|
151
143
|
cbk),
|
|
152
144
|
get_block_info: ({id}) => getBlockInfo({
|
|
153
145
|
id,
|
|
154
146
|
pass: spawnChainDaemon.rpc_pass,
|
|
155
|
-
port:
|
|
147
|
+
port: spawnChainDaemon.rpc_port,
|
|
156
148
|
user: spawnChainDaemon.rpc_user,
|
|
157
149
|
}),
|
|
158
150
|
kill: ({}, cbk) => killDockers({dockers}, cbk),
|
package/lnd/spawn_lnd_docker.js
CHANGED
|
@@ -11,12 +11,19 @@ const {spawnDockerImage} = require('./../docker');
|
|
|
11
11
|
const imageName = ver => !!ver ? `lightninglabs/lnd:${ver}` : dockerLndImage;
|
|
12
12
|
const interval = 100;
|
|
13
13
|
const join = n => n.join('');
|
|
14
|
+
const localSocket = port => `localhost:${port}`;
|
|
14
15
|
const macaroonPath = '/root/.lnd/data/chain/bitcoin/regtest/admin.macaroon';
|
|
16
|
+
const p2pPort = '9735/tcp';
|
|
17
|
+
const rpcPort = '10009/tcp';
|
|
15
18
|
const times = 500;
|
|
16
19
|
const tlsCertPath = '/root/.lnd/tls.cert';
|
|
20
|
+
const towerPort = '9911/tcp';
|
|
17
21
|
|
|
18
22
|
/** Spawn a new Docker image running LND
|
|
19
23
|
|
|
24
|
+
When RPC or tower ports are not specified, Docker picks free host ports for
|
|
25
|
+
them. A p2p port that is not specified is not published to the host.
|
|
26
|
+
|
|
20
27
|
{
|
|
21
28
|
bitcoind_rpc_host: <Bitcoin Core RPC Host String>
|
|
22
29
|
bitcoind_rpc_pass: <Bitcoin Core RPC Password String>
|
|
@@ -25,9 +32,9 @@ const tlsCertPath = '/root/.lnd/tls.cert';
|
|
|
25
32
|
[bitcoind_zmq_block_port]: <Bitcoin Core ZMQ Block Port Number>
|
|
26
33
|
[bitcoind_zmq_tx_port]: <Bitcoin Core ZMQ Transaction Port Number>
|
|
27
34
|
[configuration]: [<LND Configuration Argument String>]
|
|
28
|
-
p2p_port: <LND Peer to Peer Listen Port Number>
|
|
29
|
-
rpc_port: <LND RPC Port Number>
|
|
30
|
-
tower_port: <LND Tower Port Number>
|
|
35
|
+
[p2p_port]: <LND Peer to Peer Listen Port Number>
|
|
36
|
+
[rpc_port]: <LND RPC Port Number>
|
|
37
|
+
[tower_port]: <LND Tower Port Number>
|
|
31
38
|
[seed]: <Mnemonic Seed String>
|
|
32
39
|
}
|
|
33
40
|
|
|
@@ -58,18 +65,6 @@ module.exports = (args, cbk) => {
|
|
|
58
65
|
return cbk([400, 'ExpectedBitcoinCoreRpcUserToSpawnLndDocker']);
|
|
59
66
|
}
|
|
60
67
|
|
|
61
|
-
if (!args.p2p_port) {
|
|
62
|
-
return cbk([400, 'ExpectedLndPeer2PeerNetworkPortToSpawnLndDocker']);
|
|
63
|
-
}
|
|
64
|
-
|
|
65
|
-
if (!args.rpc_port) {
|
|
66
|
-
return cbk([400, 'ExpectedRpcPortToSpawnLndDocker']);
|
|
67
|
-
}
|
|
68
|
-
|
|
69
|
-
if (!args.tower_port) {
|
|
70
|
-
return cbk([400, 'ExpectedTowerPortToSpawnLndDocker']);
|
|
71
|
-
}
|
|
72
|
-
|
|
73
68
|
return cbk();
|
|
74
69
|
},
|
|
75
70
|
|
|
@@ -124,14 +119,21 @@ module.exports = (args, cbk) => {
|
|
|
124
119
|
arguments.push('--bitcoind.txpollinginterval=1s');
|
|
125
120
|
}
|
|
126
121
|
|
|
122
|
+
// Docker picks free host ports for RPC and tower when not specified
|
|
123
|
+
const ports = {
|
|
124
|
+
[rpcPort]: args.rpc_port,
|
|
125
|
+
[towerPort]: args.tower_port,
|
|
126
|
+
};
|
|
127
|
+
|
|
128
|
+
// Peers connect over the Docker network unless a p2p port is specified
|
|
129
|
+
if (!!args.p2p_port) {
|
|
130
|
+
ports[p2pPort] = args.p2p_port;
|
|
131
|
+
}
|
|
132
|
+
|
|
127
133
|
return spawnDockerImage({
|
|
134
|
+
ports,
|
|
128
135
|
arguments: arguments.concat(args.configuration || []),
|
|
129
136
|
image: imageName(process.env.DOCKER_LND_VERSION),
|
|
130
|
-
ports: {
|
|
131
|
-
'9735/tcp': args.p2p_port,
|
|
132
|
-
'9911/tcp': args.tower_port,
|
|
133
|
-
'10009/tcp': args.rpc_port,
|
|
134
|
-
},
|
|
135
137
|
},
|
|
136
138
|
cbk);
|
|
137
139
|
}],
|
|
@@ -145,9 +147,13 @@ module.exports = (args, cbk) => {
|
|
|
145
147
|
}],
|
|
146
148
|
|
|
147
149
|
// Create a wallet for the LND
|
|
148
|
-
createWallet: [
|
|
150
|
+
createWallet: [
|
|
151
|
+
'getCertificate',
|
|
152
|
+
'spawnDocker',
|
|
153
|
+
({getCertificate, spawnDocker}, cbk) =>
|
|
154
|
+
{
|
|
149
155
|
const cert = getCertificate.file.toString('hex');
|
|
150
|
-
const socket =
|
|
156
|
+
const socket = localSocket(spawnDocker.ports[rpcPort]);
|
|
151
157
|
|
|
152
158
|
const {lnd} = unauthenticatedLndGrpc({cert, socket});
|
|
153
159
|
|
|
@@ -185,7 +191,7 @@ module.exports = (args, cbk) => {
|
|
|
185
191
|
const {lnd} = authenticatedLndGrpc({
|
|
186
192
|
cert: getCertificate.file.toString('hex'),
|
|
187
193
|
macaroon: createWallet.toString('hex'),
|
|
188
|
-
socket:
|
|
194
|
+
socket: localSocket(spawnDocker.ports[rpcPort]),
|
|
189
195
|
});
|
|
190
196
|
|
|
191
197
|
return asyncRetry({interval, times}, cbk => {
|
|
@@ -208,11 +214,20 @@ module.exports = (args, cbk) => {
|
|
|
208
214
|
kill: spawnDocker.kill,
|
|
209
215
|
macaroon: createWallet.toString('hex'),
|
|
210
216
|
public_key: waitForRpc.public_key,
|
|
211
|
-
socket:
|
|
212
|
-
tower_socket:
|
|
217
|
+
socket: localSocket(spawnDocker.ports[rpcPort]),
|
|
218
|
+
tower_socket: localSocket(spawnDocker.ports[towerPort]),
|
|
213
219
|
});
|
|
214
220
|
}],
|
|
215
221
|
},
|
|
216
|
-
|
|
222
|
+
(err, res) => {
|
|
223
|
+
// Stop the container when LND does not start so it is not left running
|
|
224
|
+
if (!!err && !!res && !!res.spawnDocker) {
|
|
225
|
+
return res.spawnDocker.kill({}, () => {
|
|
226
|
+
return returnResult({reject, resolve}, cbk)(err);
|
|
227
|
+
});
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
return returnResult({reject, resolve, of: 'spawned'}, cbk)(err, res);
|
|
231
|
+
});
|
|
217
232
|
});
|
|
218
233
|
};
|
package/package.json
CHANGED
|
@@ -15,8 +15,7 @@
|
|
|
15
15
|
"async": "3.2.6",
|
|
16
16
|
"asyncjs-util": "1.2.12",
|
|
17
17
|
"dockerode": "5.0.1",
|
|
18
|
-
"
|
|
19
|
-
"lightning": "13.1.4"
|
|
18
|
+
"lightning": "13.1.5"
|
|
20
19
|
},
|
|
21
20
|
"description": "Spawn and control LN Docker daemons",
|
|
22
21
|
"engines": {
|
|
@@ -45,5 +44,5 @@
|
|
|
45
44
|
"scripts": {
|
|
46
45
|
"test": "node --experimental-test-coverage --test"
|
|
47
46
|
},
|
|
48
|
-
"version": "8.1.
|
|
47
|
+
"version": "8.1.2"
|
|
49
48
|
}
|