npm - roster-server - Versions diffs - 2.4.12 → 2.4.14 - Mend

roster-server 2.4.12 → 2.4.14

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.

Files changed (15) hide show

package/README.md +198 -398
package/index.js +434 -126
package/lib/static-site-handler.js +36 -27
package/package.json +1 -1
package/skills/roster-server/SKILL.md +50 -338
package/test/https-integration.test.js +149 -0
package/test/lifecycle.test.js +469 -0
package/test/roster-server.test.js +22 -22
package/test/scanner-blocker.test.js +3 -6
package/test/signals.test.js +183 -0
package/test/static-and-tls.test.js +273 -0
package/vendor/greenlock-express/greenlock-express.js +1 -1
package/vendor/greenlock-express/servers.js +2 -1
package/vendor/greenlock-express/single.js +1 -1
package/vendor/greenlock-express/worker.js +2 -2

package/test/roster-server.test.js CHANGED Viewed

@@ -16,14 +16,8 @@ const {
     buildCertLookupCandidates
 } = require('../index.js');
-function closePortServers(roster) {
-    if (roster.portServers && typeof roster.portServers === 'object') {
-        for (const server of Object.values(roster.portServers)) {
-            try {
-                server.close();
-            } catch (_) {}
-        }
-    }
+async function closePortServers(roster) {
+    await roster.close();
 }
 function httpGet(host, port, pathname = '/') {
@@ -490,7 +484,7 @@ describe('Roster local mode (local: true)', () => {
             assert.strictEqual(probe.statusCode, 404);
             assert.strictEqual(probe.body, 'Not Found');
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
         }
     });
@@ -507,7 +501,7 @@ describe('Roster local mode (local: true)', () => {
             assert.ok(url && url.startsWith('http://localhost:'));
             assert.ok(roster.domainPorts['geturltest.example'] !== undefined);
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
         }
     });
 });
@@ -533,26 +527,32 @@ describe('Roster loadSites', () => {
         try {
             await roster.init();
-            const dispatch = (port) => {
+            const { Writable } = require('stream');
+            const dispatch = async (port) => {
                 let statusCode;
                 let body = '';
-                const res = {
-                    writeHead: (status) => { statusCode = status; },
-                    end: (value) => { body = value ? value.toString() : ''; }
-                };
+                const res = new Writable({
+                    write(chunk, encoding, done) { body += chunk.toString(); done(); }
+                });
+                res.writeHead = status => { statusCode = status; };
+                const finished = new Promise((resolve, reject) => {
+                    res.once('finish', resolve);
+                    res.once('error', reject);
+                });
                 roster.requestHandler(port)(
                     { headers: { host: 'persist.example.com' }, method: 'GET', url: '/' },
                     res
                 );
+                await finished;
                 return { statusCode, body };
             };
-            assert.deepStrictEqual(dispatch(443), {
+            assert.deepStrictEqual(await dispatch(443), {
                 statusCode: 200,
                 body: '<html>static-443</html>'
             });
-            assert.deepStrictEqual(dispatch(8880), { statusCode: 200, body: 'app-8880' });
-            assert.deepStrictEqual(dispatch(8882), { statusCode: 200, body: 'socket-8882' });
+            assert.deepStrictEqual(await dispatch(8880), { statusCode: 200, body: 'app-8880' });
+            assert.deepStrictEqual(await dispatch(8882), { statusCode: 200, body: 'socket-8882' });
         } finally {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
@@ -691,7 +691,7 @@ describe('Roster loadSites', () => {
             assert.strictEqual(result.statusCode, 200);
             assert.ok(result.body.includes('static ok'));
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
@@ -711,7 +711,7 @@ describe('Roster loadSites', () => {
             const result = await httpGet('localhost', port, '/nonexistent.html');
             assert.strictEqual(result.statusCode, 404);
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
@@ -738,7 +738,7 @@ describe('Roster loadSites', () => {
             assert.strictEqual(resultNoSlash.statusCode, 200);
             assert.ok(resultNoSlash.body.includes('en page'));
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
@@ -860,7 +860,7 @@ describe('Roster init() (cluster-friendly API)', () => {
             assert.strictEqual(result.statusCode, 200);
             assert.strictEqual(result.body, 'after-init');
         } finally {
-            closePortServers(roster);
+            await closePortServers(roster);
         }
     });
 });

package/test/scanner-blocker.test.js CHANGED Viewed

@@ -191,11 +191,8 @@ describe('Roster request plugins', () => {
         asyncRoster.use(async () => false);
         asyncRoster.register('example.com', () => () => {});
         await asyncRoster.init();
-        assert.throws(() => {
-            asyncRoster.requestHandler()(
-                { headers: { host: 'example.com' }, url: '/', socket: {} },
-                { writeHead() {}, end() {} }
-            );
-        }, /must be synchronous/);
+        const result = invoke(asyncRoster.requestHandler(), { headers: { host: 'example.com' } });
+        assert.strictEqual(result.statusCode, 500);
+        assert.strictEqual(result.body, 'Internal Server Error');
     });
 });

package/test/signals.test.js ADDED Viewed

@@ -0,0 +1,183 @@
+'use strict';
+const { it } = require('node:test');
+const assert = require('node:assert/strict');
+const { spawn } = require('node:child_process');
+const { once } = require('node:events');
+async function runChild(t, body, onMessage = () => {}) {
+    const script = `
+        const assert = require('node:assert/strict');
+        const http = require('node:http');
+        const Roster = require(${JSON.stringify(require.resolve('../index.js'))});
+        const options = { local: true, wwwPath: '/tmp/roster-signals-' + process.pid };
+        const signals = ['SIGINT', 'SIGTERM'];
+        (async () => { ${body} })().catch(error => {
+            console.error(error);
+            process.exitCode = 1;
+        }).finally(() => process.disconnect());
+    `;
+    const child = spawn(process.execPath, ['-e', script], { stdio: ['ignore', 'ignore', 'pipe', 'ipc'] });
+    const messages = [];
+    let stderr = '';
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('message', message => {
+        messages.push(message);
+        onMessage(message, child);
+    });
+    t.after(() => {
+        if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
+    });
+    const [code, signal] = await once(child, 'close');
+    return { code, signal, messages, stderr };
+}
+function assertSuccess(result) {
+    assert.equal(result.signal, null, result.stderr);
+    assert.equal(result.code, 0, result.stderr);
+}
+it('does not install signal listeners unless explicitly enabled', { timeout: 10000 }, async t => {
+    assertSuccess(await runChild(t, `
+        const before = signals.map(signal => process.listeners(signal));
+        for (const handleSignals of [undefined, false]) {
+            const roster = new Roster({ ...options, handleSignals });
+            await roster.init();
+            signals.forEach((signal, i) => assert.deepEqual(process.listeners(signal), before[i]));
+            await roster.close();
+            signals.forEach((signal, i) => assert.deepEqual(process.listeners(signal), before[i]));
+        }
+    `));
+});
+it('installs listeners once at initialization and removes only the closing instance listeners', { timeout: 10000 }, async t => {
+    assertSuccess(await runChild(t, `
+        const existing = () => {};
+        signals.forEach(signal => process.on(signal, existing));
+        const before = signals.map(signal => process.listeners(signal));
+        const first = new Roster({ ...options, handleSignals: true });
+        const second = new Roster({ ...options, handleSignals: true });
+        signals.forEach((signal, i) => assert.deepEqual(process.listeners(signal), before[i]));
+        await Promise.all([first.init(), first.init(), second.init()]);
+        signals.forEach((signal, i) => assert.equal(process.listenerCount(signal), before[i].length + 2));
+        await Promise.all([first.close(), first.close()]);
+        signals.forEach((signal, i) => {
+            assert.equal(process.listenerCount(signal), before[i].length + 1);
+            assert.ok(process.listeners(signal).includes(existing));
+        });
+        await second.close();
+        signals.forEach((signal, i) => assert.deepEqual(process.listeners(signal), before[i]));
+    `));
+});
+it('removes signal listeners after initialization and cleanup both fail', { timeout: 10000 }, async t => {
+    assertSuccess(await runChild(t, `
+        const before = signals.map(signal => process.listeners(signal));
+        const roster = new Roster({ ...options, handleSignals: true });
+        roster.register('example.com', virtual => {
+            virtual.onClose(() => { throw new Error('cleanup failed'); });
+            throw new Error('factory failed');
+        });
+        await assert.rejects(roster.init(), AggregateError);
+        signals.forEach((signal, i) => assert.deepEqual(process.listeners(signal), before[i]));
+    `));
+});
+for (const signal of ['SIGINT', 'SIGTERM']) {
+    it(`drains HTTP and runs hooks once on real ${signal}, including repeated signals`, { timeout: 10000 }, async t => {
+        const result = await runChild(t, `
+            const roster = new Roster({ ...options, handleSignals: true });
+            roster.assignPortToDomain = () => 0;
+            let cleaned = 0;
+            let finished = false;
+            let response;
+            const repeated = new Promise(resolve => process.once(${JSON.stringify(signal === 'SIGINT' ? 'SIGTERM' : 'SIGINT')}, resolve));
+            roster.register('example.com', virtual => {
+                virtual.on('close', () => {
+                    process.send('closing');
+                    setImmediate(() => { finished = true; response.end(' drained'); });
+                });
+                virtual.onClose(async () => {
+                    assert.equal(finished, true);
+                    await repeated;
+                    cleaned++;
+                });
+                return (req, res) => {
+                    response = res;
+                    res.write('active');
+                };
+            });
+            await Promise.all([roster.start(), roster.start()]);
+            const server = roster.portServers[0];
+            const body = await new Promise((resolve, reject) => {
+                http.get({ hostname: 'localhost', port: server.address().port, agent: false }, res => {
+                    let body = '';
+                    res.once('data', () => process.send('ready'));
+                    res.on('data', chunk => { body += chunk; });
+                    res.on('end', () => resolve(body));
+                    res.on('error', reject);
+                }).on('error', reject);
+            });
+            await roster.close();
+            assert.equal(body, 'active drained');
+            assert.equal(cleaned, 1);
+            assert.equal(server.listening, false);
+            signals.forEach(signal => assert.equal(process.listenerCount(signal), 0));
+            process.send('complete');
+        `, (message, child) => {
+            if (message === 'ready') child.kill(signal);
+            if (message === 'closing') child.kill(signal === 'SIGINT' ? 'SIGTERM' : 'SIGINT');
+        });
+        assertSuccess(result);
+        assert.deepEqual(result.messages, ['ready', 'closing', 'complete']);
+    });
+}
+it('reports signal-triggered cleanup failure with exit code 1 and removes listeners', { timeout: 10000 }, async t => {
+    const result = await runChild(t, `
+        const roster = new Roster({ ...options, handleSignals: true });
+        roster.assignPortToDomain = () => 0;
+        let entered;
+        const closing = new Promise(resolve => { entered = resolve; });
+        roster.register('example.com', virtual => {
+            virtual.on('close', entered);
+            virtual.onClose(() => { throw new Error('cleanup failed'); });
+            return (req, res) => res.end();
+        });
+        await roster.start();
+        process.send('ready');
+        await closing;
+        await assert.rejects(roster.close(), AggregateError);
+        signals.forEach(signal => assert.equal(process.listenerCount(signal), 0));
+        assert.equal(process.exitCode, 1);
+        process.send('complete');
+    `, (message, child) => { if (message === 'ready') child.kill('SIGTERM'); });
+    assert.equal(result.signal, null, result.stderr);
+    assert.equal(result.code, 1, result.stderr);
+    assert.deepEqual(result.messages, ['ready', 'complete']);
+});
+it('handles signals during initialization and cleans up its listeners', { timeout: 10000 }, async t => {
+    const result = await runChild(t, `
+        const roster = new Roster({ ...options, handleSignals: true });
+        let release;
+        roster.loadSites = () => new Promise(resolve => { release = resolve; });
+        let called = false;
+        roster.register('example.com', () => { called = true; });
+        const initializing = assert.rejects(roster.init(), /closing or closed/);
+        process.once('message', () => release());
+        const close = roster.close.bind(roster);
+        roster.close = () => { const result = close(); process.send('closing'); return result; };
+        process.send('ready');
+        await initializing;
+        await close();
+        assert.equal(called, false);
+        signals.forEach(signal => assert.equal(process.listenerCount(signal), 0));
+        process.send('complete');
+    `, (message, child) => {
+        if (message === 'ready') child.kill('SIGTERM');
+        if (message === 'closing') child.send('release');
+    });
+    assertSuccess(result);
+    assert.deepEqual(result.messages, ['ready', 'closing', 'complete']);
+});

package/test/static-and-tls.test.js ADDED Viewed

@@ -0,0 +1,273 @@
+'use strict';
+const { it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const http = require('node:http');
+const { Writable } = require('node:stream');
+const { execFileSync } = require('node:child_process');
+const { createStaticHandler } = require('../lib/static-site-handler.js');
+const Roster = require('../index.js');
+function temporaryDirectory(t) {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'roster-files-'));
+    t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+    return directory;
+}
+function response() {
+    const chunks = [];
+    const res = new Writable({ write(chunk, encoding, done) { chunks.push(chunk); done(); } });
+    res.writeHead = (status, headers) => { res.status = status; res.headers = headers; res.headersSent = true; };
+    return { res, body: () => Buffer.concat(chunks) };
+}
+it('streams a static file without synchronous filesystem calls', async t => {
+    const root = temporaryDirectory(t);
+    const content = Buffer.alloc(1024 * 1024, 'a');
+    fs.writeFileSync(path.join(root, 'index.html'), content);
+    const handler = createStaticHandler(root)();
+    const result = response();
+    for (const method of ['readFileSync', 'statSync', 'existsSync']) {
+        t.mock.method(fs, method, () => { throw new Error(`Unexpected ${method}`); });
+    }
+    await handler({ method: 'GET', url: '/' }, result.res);
+    assert.equal(result.res.status, 200);
+    assert.equal(result.res.headers['Content-Length'], content.length);
+    assert.deepEqual(result.body(), content);
+});
+it('serves HEAD using metadata without reading file contents', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'index.html'), 'head content');
+    const open = fs.promises.open.bind(fs.promises);
+    t.mock.method(fs.promises, 'open', async (...args) => {
+        const file = await open(...args);
+        file.createReadStream = () => { throw new Error('HEAD must not stream'); };
+        file.readFile = () => { throw new Error('HEAD must not read'); };
+        return file;
+    });
+    const result = response();
+    await createStaticHandler(root)()({ method: 'HEAD', url: '/' }, result.res);
+    assert.equal(result.res.status, 200);
+    assert.equal(result.res.headers['Content-Length'], 12);
+    assert.equal(result.body().length, 0);
+});
+it('handles directory indexes, missing files, and an open race', async t => {
+    const root = temporaryDirectory(t);
+    fs.mkdirSync(path.join(root, 'en'));
+    fs.writeFileSync(path.join(root, 'en', 'index.html'), 'directory');
+    const handler = createStaticHandler(root)();
+    const directory = response();
+    await handler({ method: 'GET', url: '/en/?a=b' }, directory.res);
+    assert.equal(directory.body().toString(), 'directory');
+    const missing = response();
+    await handler({ method: 'GET', url: '/missing' }, missing.res);
+    assert.equal(missing.res.status, 404);
+    t.mock.method(fs.promises, 'open', async () => { throw Object.assign(new Error('removed'), { code: 'ENOENT' }); });
+    const removed = response();
+    await handler({ method: 'GET', url: '/en/' }, removed.res);
+    assert.equal(removed.res.status, 404);
+});
+it('closes static file handles when the client disconnects mid-stream', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'large.bin'), Buffer.alloc(8 * 1024 * 1024));
+    const handler = createStaticHandler(root)();
+    const handles = [];
+    const open = fs.promises.open.bind(fs.promises);
+    t.mock.method(fs.promises, 'open', async (...args) => {
+        const file = await open(...args);
+        handles.push(file);
+        return file;
+    });
+    let handled;
+    const complete = new Promise(resolve => { handled = resolve; });
+    const server = http.createServer((req, res) => {
+        handler(req, res).then(handled);
+    });
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    t.after(() => new Promise(resolve => { server.close(resolve); server.closeAllConnections(); }));
+    await new Promise((resolve, reject) => {
+        const req = http.get({ hostname: '127.0.0.1', port: server.address().port, path: '/large.bin' }, res => {
+            res.once('data', () => { res.destroy(); resolve(); });
+        });
+        req.on('error', reject);
+    });
+    await complete;
+    assert.equal(handles.length, 1);
+    assert.equal(handles[0].fd, -1);
+});
+it('rejects non-regular files before opening them', async t => {
+    const root = temporaryDirectory(t);
+    t.mock.method(fs.promises, 'stat', async () => ({ isDirectory: () => false, isFile: () => false }));
+    t.mock.method(fs.promises, 'open', () => { throw new Error('Must not open special files'); });
+    const result = response();
+    await createStaticHandler(root)()({ method: 'GET', url: '/pipe' }, result.res);
+    assert.equal(result.res.status, 404);
+});
+it('maps filesystem failures to HTTP errors without exposing internal details', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'index.html'), 'content');
+    for (const method of ['stat', 'open']) {
+        for (const [code, status, body] of [
+            ['ENOTDIR', 404, 'Not Found'],
+            ['EACCES', 403, 'Forbidden'],
+            ['EIO', 500, 'Internal Server Error']
+        ]) {
+            await t.test(`${method}: ${code}`, async t => {
+                t.mock.method(fs.promises, method, async () => {
+                    throw Object.assign(new Error('internal filesystem detail'), { code });
+                });
+                const result = response();
+                await createStaticHandler(root)()({ method: 'GET', url: '/' }, result.res);
+                assert.equal(result.res.status, status);
+                assert.equal(result.body().toString(), body);
+            });
+        }
+    }
+});
+it('uses opened-file metadata and closes the handle when the file changes before open', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'index.html'), 'old');
+    const open = fs.promises.open.bind(fs.promises);
+    let handle;
+    t.mock.method(fs.promises, 'open', async (...args) => {
+        fs.writeFileSync(path.join(root, 'index.html'), 'replacement content');
+        handle = await open(...args);
+        return handle;
+    });
+    const result = response();
+    await createStaticHandler(root)()({ method: 'GET', url: '/' }, result.res);
+    assert.equal(result.res.headers['Content-Length'], Buffer.byteLength('replacement content'));
+    assert.equal(result.body().toString(), 'replacement content');
+    assert.equal(handle.fd, -1);
+});
+it('closes opened files if fstat fails or finds a non-regular replacement', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'index.html'), 'content');
+    const open = fs.promises.open.bind(fs.promises);
+    for (const fail of [false, true]) {
+        await t.test(fail ? 'fstat failure' : 'non-regular replacement', async t => {
+            let handle;
+            t.mock.method(fs.promises, 'open', async (...args) => {
+                handle = await open(...args);
+                t.mock.method(handle, 'stat', async () => {
+                    if (fail) throw Object.assign(new Error('stat failed'), { code: 'EIO' });
+                    return { isFile: () => false };
+                });
+                return handle;
+            });
+            const result = response();
+            await createStaticHandler(root)()({ method: 'GET', url: '/' }, result.res);
+            assert.equal(result.res.status, fail ? 500 : 404);
+            assert.equal(handle.fd, -1);
+        });
+    }
+});
+it('closes a file opened after its response was already destroyed', async t => {
+    const root = temporaryDirectory(t);
+    fs.writeFileSync(path.join(root, 'index.html'), 'content');
+    const result = response();
+    const open = fs.promises.open.bind(fs.promises);
+    let handle;
+    t.mock.method(fs.promises, 'open', async (...args) => {
+        result.res.destroy();
+        handle = await open(...args);
+        return handle;
+    });
+    await createStaticHandler(root)()({ method: 'GET', url: '/' }, result.res);
+    assert.equal(result.res.headersSent, undefined);
+    assert.equal(handle.fd, -1);
+});
+it('reuses TLS contexts, coalesces concurrent loads, and reloads changed certificates', async t => {
+    const root = temporaryDirectory(t);
+    const directory = path.join(root, 'live', 'example.com');
+    fs.mkdirSync(directory, { recursive: true });
+    const key = path.join(directory, 'privkey.pem');
+    const cert = path.join(directory, 'cert.pem');
+    execFileSync('openssl', ['req', '-x509', '-newkey', 'rsa:2048', '-nodes', '-keyout', key,
+        '-out', cert, '-subj', '/CN=example.com', '-days', '1'], { stdio: 'ignore' });
+    fs.writeFileSync(path.join(directory, 'chain.pem'), '');
+    const roster = new Roster({ local: true, wwwPath: root, greenlockStorePath: root });
+    t.after(() => roster.close());
+    const read = fs.promises.readFile.bind(fs.promises);
+    let reads = 0;
+    t.mock.method(fs.promises, 'readFile', (...args) => { reads++; return read(...args); });
+    const contexts = await Promise.all(Array.from({ length: 8 }, () => roster._resolveSecureContext('example.com')));
+    assert.ok(contexts[0]);
+    assert.ok(contexts.every(context => context === contexts[0]));
+    assert.equal(reads, 3);
+    assert.equal(await roster._resolveSecureContext('example.com'), contexts[0]);
+    assert.equal(reads, 3);
+    execFileSync('openssl', ['req', '-x509', '-key', key, '-out', cert,
+        '-subj', '/CN=example.com', '-days', '1', '-set_serial', '2'], { stdio: 'ignore' });
+    assert.notEqual(await roster._resolveSecureContext('example.com'), contexts[0]);
+    assert.equal(reads, 6);
+    fs.unlinkSync(cert);
+    assert.equal(await roster._resolveSecureContext('example.com'), null);
+    assert.equal(roster._secureContexts.size, 0);
+});
+it('coalesces certificate checks and prevents new issuance after close', async t => {
+    const root = temporaryDirectory(t);
+    const roster = new Roster({ local: true, wwwPath: root });
+    let calls = 0;
+    let release;
+    roster._greenlockRuntime = { get: () => { calls++; return new Promise(resolve => { release = resolve; }); } };
+    const first = roster._checkCertificate('example.com');
+    assert.equal(first, roster._checkCertificate('example.com'));
+    await Promise.resolve();
+    assert.equal(calls, 1);
+    release();
+    await first;
+    assert.equal(roster._certificateChecks.size, 0);
+    await roster.close();
+    assert.throws(() => roster._checkCertificate('example.com'), /closing or closed/);
+});
+it('waits for in-flight certificate work before running close hooks', async t => {
+    const root = temporaryDirectory(t);
+    const roster = new Roster({ local: true, wwwPath: root });
+    t.after(() => roster.close());
+    let cleaned = false;
+    roster.register('example.com', virtual => {
+        virtual.onClose(() => { cleaned = true; });
+        return () => {};
+    });
+    await roster.init();
+    let release;
+    roster._greenlockRuntime = { get: () => new Promise(resolve => { release = resolve; }) };
+    const check = roster._checkCertificate('example.com');
+    await Promise.resolve();
+    const closing = roster.close();
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(cleaned, false);
+    release();
+    await Promise.all([check, closing]);
+    assert.equal(cleaned, true);
+});
+it('does not repopulate TLS caches when close interrupts a context load', async t => {
+    const root = temporaryDirectory(t);
+    const roster = new Roster({ local: true, wwwPath: root });
+    t.after(() => roster.close());
+    let release;
+    const pendingStat = new Promise(resolve => { release = resolve; });
+    t.mock.method(fs.promises, 'stat', () => pendingStat);
+    const loading = assert.rejects(roster._resolveSecureContext('example.com'), /closing or closed/);
+    const closing = roster.close();
+    release({});
+    await Promise.all([loading, closing]);
+    assert.equal(roster._contextLoads.size, 0);
+    assert.equal(roster._secureContexts.size, 0);
+});

package/vendor/greenlock-express/greenlock-express.js CHANGED Viewed

@@ -20,7 +20,7 @@ GLE.init = function(fn) {
     // See https://git.coolaj86.com/coolaj86/greenlock-express.js/issues/80
     if (fn && false !== fn.cluster && cluster.isWorker) {
         // ignore the init function and launch the worker
-        return require("./worker.js").create();
+        return require("./worker.js").create(fn);
     }
     var opts;

package/vendor/greenlock-express/servers.js CHANGED Viewed

@@ -9,12 +9,13 @@ var sni = require("./sni.js");
 var cluster = require("cluster");
 var log = require("lemonlog")("greenlock-servers");
-Servers.create = function(greenlock) {
+Servers.create = function(greenlock, onError) {
     var servers = {};
     var _httpServer;
     var _httpsServer;
     function startError(e) {
+        if (onError) return onError(e);
         explainError(e);
         process.exit(1);
     }

package/vendor/greenlock-express/single.js CHANGED Viewed

@@ -8,7 +8,7 @@ var Servers = require("./servers.js");
 Single.create = function(opts) {
     var greenlock = require("./greenlock-shim.js").create(opts);
-    var servers = Servers.create(greenlock);
+    var servers = Servers.create(greenlock, opts.onServerError);
     var single = {
         ready: function(fn) {

package/vendor/greenlock-express/worker.js CHANGED Viewed

@@ -5,7 +5,7 @@ var Worker = module.exports;
 var messageTimeout = 30 * 1000;
 var msgPrefix = "greenlock:";
-Worker.create = function() {
+Worker.create = function(opts) {
     var greenlock = {};
     ["getAcmeHttp01ChallengeResponse", "get", "notify", "_notify"].forEach(function(k) {
         greenlock[k] = function(args) {
@@ -15,7 +15,7 @@ Worker.create = function() {
     var worker = {
         ready: function(fn) {
-            var servers = require("./servers.js").create(greenlock);
+            var servers = require("./servers.js").create(greenlock, opts && opts.onServerError);
             fn(servers);
             return worker;
         },