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 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: ['validate', ({}, cbk) => {
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
- const ports = {'18443/tcp': args.rpc_port, '18444/tcp': args.p2p_port};
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: ['generateAuth', 'spawnDocker', ({generateAuth}, cbk) => {
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: args.rpc_port,
111
+ port: spawnDocker.ports['18443/tcp'],
103
112
  user: rpcUser,
104
113
  },
105
114
  cbk);
106
115
  },
107
- cbk);
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
  },
@@ -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}, cbk);
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 portsPerLnd = 7;
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 options = {startPort: between(startPort, endPort)};
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
- sum[port] = [{HostPort: ports[port].toString()}];
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
- cbk);
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 cbk([503, 'UnexpectedErrorGettingContainerDetails', {err}]);
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: args.chain_rpc_port,
75
+ port: spawnChainDaemon.rpc_port,
100
76
  user: spawnChainDaemon.rpc_user,
101
77
  },
102
- cbk);
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: args.chain_zmq_block_port,
118
- bitcoind_zmq_tx_port: args.chain_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
- cbk);
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: args.chain_rpc_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: args.chain_rpc_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: args.chain_rpc_port,
147
+ port: spawnChainDaemon.rpc_port,
156
148
  user: spawnChainDaemon.rpc_user,
157
149
  }),
158
150
  kill: ({}, cbk) => killDockers({dockers}, cbk),
@@ -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: ['getCertificate', ({getCertificate}, cbk) => {
150
+ createWallet: [
151
+ 'getCertificate',
152
+ 'spawnDocker',
153
+ ({getCertificate, spawnDocker}, cbk) =>
154
+ {
149
155
  const cert = getCertificate.file.toString('hex');
150
- const socket = `localhost:${args.rpc_port}`;
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: `localhost:${args.rpc_port}`,
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: `localhost:${args.rpc_port}`,
212
- tower_socket: `localhost:${args.tower_port}`,
217
+ socket: localSocket(spawnDocker.ports[rpcPort]),
218
+ tower_socket: localSocket(spawnDocker.ports[towerPort]),
213
219
  });
214
220
  }],
215
221
  },
216
- returnResult({reject, resolve, of: 'spawned'}, cbk));
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
- "find-free-ports": "3.1.1",
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.1"
47
+ "version": "8.1.2"
49
48
  }