push for virtual office

Author: aditi-khare-mongoDB

heartbeat-failed-monitor-timer.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+/* eslint-disable no-undef */
+/* eslint-disable no-unused-vars */
+const driverPath = "/Users/aditi.khare/Desktop/node-mongodb-native/lib";
+const func = (async function ({ MongoClient, uri, expect, sleep, getTimerCount }) {
+                                    const heartbeatFrequencyMS = 2000;
+                                    const client = new MongoClient('mongodb://fakeUri', { heartbeatFrequencyMS });
+                                    let heartbeatHappened = false;
+                                    client.on('serverHeartbeatFailed', () => heartbeatHappened = true);
+                                    client.connect();
+                                    await sleep(heartbeatFrequencyMS * 2.5);
+                                    expect(heartbeatHappened).to.be.true;
+                                    function getMonitorTimer(servers) {
+                                        for (const server of servers) {
+                                            return server[1]?.monitor.monitorId.timerId;
+                                        }
+                                    }
+                                    ;
+                                    const servers = client.topology.s.servers;
+                                    expect(getMonitorTimer(servers)).to.exist;
+                                    await client.close();
+                                    expect(getMonitorTimer(servers)).to.not.exist;
+                                    expect(getTimerCount()).to.equal(0);
+                                });
+const scriptName = "heartbeat-failed-monitor-timer";
+const uri = "mongodb://localhost:27017/integration_tests?authSource=admin";
+
+const mongodb = require(driverPath);
+const { MongoClient } = mongodb;
+const process = require('node:process');
+const util = require('node:util');
+const timers = require('node:timers');
+const fs = require('node:fs');
+const sinon = require('sinon');
+const { expect } = require('chai');
+const { setTimeout } = require('timers');
+
+let originalReport;
+const logFile = scriptName + '.logs.txt';
+const sleep = util.promisify(setTimeout);
+
+const run = func;
+
+/**
+ *
+ * Returns an array containing the new libuv resources created after script started.
+ * A new resource is something that will keep the event loop running.
+ *
+ * In order to be counted as a new resource, a resource MUST:
+ * - Must NOT share an address with a libuv resource that existed at the start of script
+ * - Must be referenced. See [here](https://nodejs.org/api/timers.html#timeoutref) for more context.
+ *
+ * We're using the following tool to track resources: `process.report.getReport().libuv`
+ * For more context, see documentation for [process.report.getReport()](https://nodejs.org/api/report.html), and [libuv](https://docs.libuv.org/en/v1.x/handle.html).
+ *
+ */
+function getNewLibuvResourceArray() {
+  let currReport = process.report.getReport().libuv;
+  const originalReportAddresses = originalReport.map(resource => resource.address);
+
+  /**
+   * @typedef {Object} LibuvResource
+   * @property {string} type What is the resource type? For example, 'tcp' | 'timer' | 'udp' | 'tty'... (See more in [docs](https://docs.libuv.org/en/v1.x/handle.html)).
+   * @property {boolean} is_referenced Is the resource keeping the JS event loop active?
+   *
+   * @param {LibuvResource} resource
+   */
+  function isNewLibuvResource(resource) {
+    const serverType = ['tcp', 'udp'];
+    return (
+      !originalReportAddresses.includes(resource.address) && resource.is_referenced // if a resource is unreferenced, it's not keeping the event loop open
+    );
+  }
+
+  currReport = currReport.filter(resource => isNewLibuvResource(resource));
+  return currReport;
+}
+
+/**
+ * Returns an object of the new resources created after script started.
+ *
+ *
+ * In order to be counted as a new resource, a resource MUST either:
+ * - Meet the criteria to be returned by our helper utility `getNewLibuvResourceArray()`
+ * OR
+ * - Be returned by `process.getActiveResourcesInfo() and is not 'TTYWrap'
+ *
+ * The reason we are using both methods to detect active resources is:
+ * - `process.report.getReport().libuv` does not detect active requests (such as timers or file reads) accurately
+ * - `process.getActiveResourcesInfo()` does not contain enough server information we need for our assertions
+ *
+ */
+function getNewResources() {
+  
+  return {
+    libuvResources: getNewLibuvResourceArray(),
+    activeResources: process.getActiveResourcesInfo()
+  };
+}
+
+/**
+ * @returns Number of active timers in event loop
+ */
+const getTimerCount = () => process.getActiveResourcesInfo().filter(r => r === 'Timeout').length;
+
+// A log function for debugging
+function log(message) {
+  // remove outer parentheses for easier parsing
+  const messageToLog = JSON.stringify(message) + ' \n';
+  fs.writeFileSync(logFile, messageToLog, { flag: 'a' });
+}
+
+async function main() {
+  originalReport = process.report.getReport().libuv;
+  process.on('beforeExit', () => {
+    log({ beforeExitHappened: true });
+  });
+  await run({ MongoClient, uri, log, expect, mongodb, sleep, sinon, getTimerCount });
+  log({ newResources: getNewResources() });
+}
+
+main()
+  .then(() => {})
+  .catch(e => {
+    log({ error: { message: e.message, stack: e.stack, resources: getNewResources() } });
+    process.exit(1);
+  });
+
+setTimeout(() => {
+  // this means something was in the event loop such that it hung for more than 10 seconds
+  // so we kill the process
+  log({
+    error: {
+      message: 'Process timed out: resources remain in the event loop',
+      resources: getNewResources()
+    }
+  });
+  process.exit(99);
+  // using `unref` will ensure this setTimeout call is not a resource / does not keep the event loop running
+}, 10000).unref();

heartbeat-failed-monitor-timer.logs.txt

@@ -0,0 +1,2 @@
+{"error":{"message":"expected 1 to equal +0","stack":"AssertionError: expected 1 to equal +0\n    at func (/Users/aditi.khare/Desktop/node-mongodb-native/heartbeat-failed-monitor-timer.cjs:24:64)\n    at async main (/Users/aditi.khare/Desktop/node-mongodb-native/heartbeat-failed-monitor-timer.cjs:119:3)","resources":{"libuvResources":[],"activeResources":[]}}} 
+{"error":{"message":"expected 1 to equal +0","stack":"AssertionError: expected 1 to equal +0\n    at func (/Users/aditi.khare/Desktop/node-mongodb-native/heartbeat-failed-monitor-timer.cjs:24:64)\n    at async main (/Users/aditi.khare/Desktop/node-mongodb-native/heartbeat-failed-monitor-timer.cjs:119:3)","resources":{"libuvResources":[],"activeResources":["TTYWrap"]}}} 

src/utils.ts

@@ -1166,7 +1166,6 @@ export function parseUnsignedInteger(value: unknown): number | null {
  * @returns void
  */
 export function checkParentDomainMatch(address: string, srvHost: string): void {
-  return;
   // Remove trailing dot if exists on either the resolved address or the srv hostname
   const normalizedAddress = address.endsWith('.') ? address.slice(0, address.length - 1) : address;
   const normalizedSrvHost = srvHost.endsWith('.') ? srvHost.slice(0, srvHost.length - 1) : srvHost;

test/integration/node-specific/client_close.test.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
 import { expect } from 'chai';
 import * as sinon from 'sinon';
-import { MongoClient } from '../../mongodb';
+import { Connection, HostAddress, MongoClient } from '../../mongodb';
 import { type TestConfiguration } from '../../tools/runner/config';
 import { runScriptAndGetProcessInfo } from './resource_tracking_script_builder';
 import { sleep } from '../../tools/utils';
-import { ConnectionPool, Timeout } from '../../mongodb';
+import { ConnectionPool } from '../../mongodb';
+import { getActiveResourcesInfo } from 'process';
 
 describe.only('MongoClient.close() Integration', () => {
   // note: these tests are set-up in accordance of the resource ownership tree
@@ -80,31 +81,34 @@ describe.only('MongoClient.close() Integration', () => {
   describe('Topology', () => {
     describe('Node.js resource: Server Selection Timer', () => {
       describe('after a Topology is created through client.connect()', () => {
-        it.only('server selection timers are cleaned up by client.close()', async () => {
-            // note: this test is not called in a separate process since it requires stubbing internal class: Timeout
-            const run = async function ({ MongoClient, uri, expect, sinon, sleep, getTimerCount }) {
-              const serverSelectionTimeoutMS = 777;
+        it('server selection timers are cleaned up by client.close()', async () => {
+            const run = async function ({ MongoClient, uri, expect, sinon, sleep, mongodb, getTimerCount }) {
+              const serverSelectionTimeoutMS = 2222;
               const client = new MongoClient(uri, { minPoolSize: 1, serverSelectionTimeoutMS });
-              const timeoutStartedSpy = sinon.spy(Timeout, 'expires');
+              const timers = require('timers');
+              const timeoutStartedSpy = sinon.spy(timers, 'setTimeout');
               let serverSelectionTimeoutStarted = false;
 
               // make server selection hang so check out timer isn't cleared and check that the timeout has started
-              sinon.stub(Promise, 'race').callsFake(() => {
-                serverSelectionTimeoutStarted = timeoutStartedSpy.getCalls().filter(r => r.args.includes(777)).flat().length > 0;
+              sinon.stub(Promise, 'race').callsFake(async ([serverPromise, timeout]) => {
+                serverSelectionTimeoutStarted = timeoutStartedSpy.getCalls().filter(r => r.args.includes(serverSelectionTimeoutMS)).flat().length > 0;
+                await timeout;
               });
 
-              client.db('db').collection('collection').insertOne({ x: 1 }).catch(e => e);
+              const insertPromise =  client.db('db').collection('collection').insertOne({ x: 1 });
 
-              // don't allow entire checkout timer to elapse to ensure close is called mid-timeout
+              // don't allow entire server selection timer to elapse to ensure close is called mid-timeout
               await sleep(serverSelectionTimeoutMS / 2);
               expect(serverSelectionTimeoutStarted).to.be.true;
 
+              expect(getTimerCount()).to.not.equal(0);
               await client.close();
               expect(getTimerCount()).to.equal(0);
-            };
 
-            const getTimerCount = () => process.getActiveResourcesInfo().filter(r => r === 'Timeout').length;
-            await run({ MongoClient, uri: config.uri, sleep, sinon, expect, getTimerCount});
+              const err = await insertPromise.catch(e => e);
+              expect(err).to.be.instanceOf(mongodb.MongoServerSelectionError);
+            };
+            await runScriptAndGetProcessInfo('timer-server-selection', config, run);
         });
       });
     });
@@ -143,13 +147,35 @@ describe.only('MongoClient.close() Integration', () => {
 
                   expect(getTimerCount()).to.equal(0);
                 };
-
                 await runScriptAndGetProcessInfo('timer-monitor-interval', config, run);
               });
             });
 
             describe('after a heartbeat fails', () => {
-              it.skip('the new monitor interval timer is cleaned up by client.close()', metadata, async () => {});
+              it('the new monitor interval timer is cleaned up by client.close()', metadata, async () => {
+                const run = async function ({ MongoClient, uri, expect, sleep, getTimerCount }) {
+                  const heartbeatFrequencyMS = 2000;
+                  const client = new MongoClient('mongodb://fakeUri', { heartbeatFrequencyMS });
+                  let heartbeatHappened = false;
+                  client.on('serverHeartbeatFailed', () => heartbeatHappened = true);
+                  client.connect();
+                  await sleep(heartbeatFrequencyMS * 2.5);
+                  expect(heartbeatHappened).to.be.true;
+
+                  function getMonitorTimer(servers) {
+                    for (const server of servers) {                      
+                      return server[1]?.monitor.monitorId.timerId;
+                    }
+                  };
+                  const servers = client.topology.s.servers;
+                  expect(getMonitorTimer(servers)).to.exist;
+                  await client.close();
+                  expect(getMonitorTimer(servers)).to.not.exist;
+
+                  expect(getTimerCount()).to.equal(0);
+                };
+                await runScriptAndGetProcessInfo('timer-heartbeat-failed-monitor', config, run);
+              });
             });
           });
         });
@@ -219,7 +245,6 @@ describe.only('MongoClient.close() Integration', () => {
 
                   expect(getTimerCount()).to.equal(0);
                 };
-
                 await runScriptAndGetProcessInfo('timer-rtt-monitor', config, run);
               });
             });
@@ -315,31 +340,33 @@ describe.only('MongoClient.close() Integration', () => {
         });
 
         describe('Node.js resource: checkOut Timer', () => {
-          // waitQueueTimeoutMS
           describe('after new connection pool is created', () => {
             it('the wait queue timer is cleaned up by client.close()', async function () {
-              // note: this test is not called in a separate process since it requires stubbing internal function
+              // note: this test is not called in a separate process since it stubs internal class: ConnectionPool
               const run = async function ({ MongoClient, uri, expect, sinon, sleep, getTimerCount }) {
                 const waitQueueTimeoutMS = 999;
                 const client = new MongoClient(uri, { minPoolSize: 1, waitQueueTimeoutMS });
-                const timeoutStartedSpy = sinon.spy(Timeout, 'expires');
+                const timers = require('timers');
+                const timeoutStartedSpy = sinon.spy(timers, 'setTimeout');
                 let checkoutTimeoutStarted = false;
 
                 // make waitQueue hang so check out timer isn't cleared and check that the timeout has started
                 sinon.stub(ConnectionPool.prototype, 'processWaitQueue').callsFake(async () => {
-                  checkoutTimeoutStarted = timeoutStartedSpy.getCalls().map(r => r.args).filter(r => r.includes(999)) ? true : false;
+                  checkoutTimeoutStarted = timeoutStartedSpy.getCalls().filter(r => r.args.includes(waitQueueTimeoutMS)).flat().length > 0;
                 });
 
-                client.db('db').collection('collection').insertOne({ x: 1 }).catch(e => e);
+                const insertPromise = client.db('db').collection('collection').insertOne({ x: 1 }).catch(e => e);
 
                 // don't allow entire checkout timer to elapse to ensure close is called mid-timeout
                 await sleep(waitQueueTimeoutMS / 2);
                 expect(checkoutTimeoutStarted).to.be.true;
 
                 await client.close();
                 expect(getTimerCount()).to.equal(0);
-              };
 
+                const err = await insertPromise;
+                expect(err).to.not.be.instanceOf(Error);
+              };
               const getTimerCount = () => process.getActiveResourcesInfo().filter(r => r === 'Timeout').length;
               await run({ MongoClient, uri: config.uri, sleep, sinon, expect, getTimerCount});
             });
@@ -389,39 +416,40 @@ describe.only('MongoClient.close() Integration', () => {
           }
         };
         describe('after SRVPoller is created', () => {
-          it.skip('timers are cleaned up by client.close()', metadata, async () => {
-            const run = async function ({ MongoClient, uri, expect, log, sinon, mongodb, getTimerCount }) {
+          it.only('timers are cleaned up by client.close()', metadata, async () => {
+            const run = async function ({ MongoClient, uri, expect, mongodb, sinon, getTimerCount }) {
               const dns = require('dns');
-
               sinon.stub(dns.promises, 'resolveTxt').callsFake(async () => {
                 throw { code: 'ENODATA' };
               });
               sinon.stub(dns.promises, 'resolveSrv').callsFake(async () => {
-                const formattedUri = mongodb.HostAddress.fromString(uri.split('//')[1]);
                 return [
                   {
-                    name: formattedUri.host,
-                    port: formattedUri.port,
+                    name: 'domain.localhost',
+                    port: 27017,
                     weight: 0,
                     priority: 0,
-                    protocol: formattedUri.host.isIPv6 ? 'IPv6' : 'IPv4'
+                    protocol: 'IPv6'
                   }
                 ];
               });
-              /* sinon.stub(mongodb, 'checkParentDomainMatch').callsFake(async () => {
-                console.log('in here!!!');
-              }); */
 
               const client = new MongoClient('mongodb+srv://localhost');
-              await client.connect();
+              client.connect();
+
+              const topology = client.topology;
+              const prevDesc = topology;
+              log({ topology });
+              const currDesc = prevDesc;
+              client.topology.emit(
+                'topologyDescriptionChanged',
+                mongodb.TopologyDescriptionChangedEvent(client.topology.s.id, prevDesc, currDesc)
+              );
+              
               await client.close();
               expect(getTimerCount()).to.equal(0);
-              sinon.restore();
             };
-
-            const getTimerCount = () => process.getActiveResourcesInfo().filter(r => r === 'Timeout').length;
-            // await run({ MongoClient, uri: config.uri, sleep, sinon, expect, mongodb, getTimerCount});
-            await runScriptAndGetProcessInfo('srv-poller-timer', config, run);
+            await runScriptAndGetProcessInfo('timer-srv-poller', config, run);
           });
         });
       });
@@ -564,4 +592,4 @@ describe.only('MongoClient.close() Integration', () => {
       it.skip('all active server-side cursors are closed by client.close()', async function () {});
     });
   });
-});
+});

test/integration/node-specific/resource_tracking_script_builder.ts

@@ -188,8 +188,8 @@ export async function runScriptAndGetProcessInfo(
     .reduce((acc, curr) => ({ ...acc, ...curr }), {});
 
   // delete temporary files
-  await unlink(scriptName);
-  await unlink(logFile);
+  // await unlink(scriptName);
+  // await unlink(logFile);
 
   // assertions about exit status
   if (exitCode) {