oxygen-cli 1.40.1 → 1.40.2-beta.1

package/transpiled/mongodb/lib/sdam/server_selection.js

@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MIN_SECONDARY_WRITE_WIRE_VERSION = void 0;
+exports.writableServerSelector = writableServerSelector;
+exports.sameServerSelector = sameServerSelector;
+exports.secondaryWritableServerSelector = secondaryWritableServerSelector;
+exports.readPreferenceServerSelector = readPreferenceServerSelector;
+
+const error_1 = require("../error");
+
+const read_preference_1 = require("../read_preference");
+
+const common_1 = require("./common"); // max staleness constants
+
+
+const IDLE_WRITE_PERIOD = 10000;
+const SMALLEST_MAX_STALENESS_SECONDS = 90; //  Minimum version to try writes on secondaries.
+
+exports.MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
+/**
+ * Returns a server selector that selects for writable servers
+ */
+
+function writableServerSelector() {
+  return function writableServer(topologyDescription, servers) {
+    return latencyWindowReducer(topologyDescription, servers.filter(s => s.isWritable));
+  };
+}
+/**
+ * The purpose of this selector is to select the same server, only
+ * if it is in a state that it can have commands sent to it.
+ */
+
+
+function sameServerSelector(description) {
+  return function sameServerSelector(topologyDescription, servers) {
+    if (!description) return []; // Filter the servers to match the provided description only if
+    // the type is not unknown.
+
+    return servers.filter(sd => {
+      return sd.address === description.address && sd.type !== common_1.ServerType.Unknown;
+    });
+  };
+}
+/**
+ * Returns a server selector that uses a read preference to select a
+ * server potentially for a write on a secondary.
+ */
+
+
+function secondaryWritableServerSelector(wireVersion, readPreference) {
+  // If server version < 5.0, read preference always primary.
+  // If server version >= 5.0...
+  // - If read preference is supplied, use that.
+  // - If no read preference is supplied, use primary.
+  if (!readPreference || !wireVersion || wireVersion && wireVersion < exports.MIN_SECONDARY_WRITE_WIRE_VERSION) {
+    return readPreferenceServerSelector(read_preference_1.ReadPreference.primary);
+  }
+
+  return readPreferenceServerSelector(readPreference);
+}
+/**
+ * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
+ * found here:
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.md
+ *
+ * @param readPreference - The read preference providing max staleness guidance
+ * @param topologyDescription - The topology description
+ * @param servers - The list of server descriptions to be reduced
+ * @returns The list of servers that satisfy the requirements of max staleness
+ */
+
+
+function maxStalenessReducer(readPreference, topologyDescription, servers) {
+  if (readPreference.maxStalenessSeconds == null || readPreference.maxStalenessSeconds < 0) {
+    return servers;
+  }
+
+  const maxStaleness = readPreference.maxStalenessSeconds;
+  const maxStalenessVariance = (topologyDescription.heartbeatFrequencyMS + IDLE_WRITE_PERIOD) / 1000;
+
+  if (maxStaleness < maxStalenessVariance) {
+    throw new error_1.MongoInvalidArgumentError(`Option "maxStalenessSeconds" must be at least ${maxStalenessVariance} seconds`);
+  }
+
+  if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) {
+    throw new error_1.MongoInvalidArgumentError(`Option "maxStalenessSeconds" must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`);
+  }
+
+  if (topologyDescription.type === common_1.TopologyType.ReplicaSetWithPrimary) {
+    const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0];
+    return servers.reduce((result, server) => {
+      const stalenessMS = server.lastUpdateTime - server.lastWriteDate - (primary.lastUpdateTime - primary.lastWriteDate) + topologyDescription.heartbeatFrequencyMS;
+      const staleness = stalenessMS / 1000;
+      const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
+
+      if (staleness <= maxStalenessSeconds) {
+        result.push(server);
+      }
+
+      return result;
+    }, []);
+  }
+
+  if (topologyDescription.type === common_1.TopologyType.ReplicaSetNoPrimary) {
+    if (servers.length === 0) {
+      return servers;
+    }
+
+    const sMax = servers.reduce((max, s) => s.lastWriteDate > max.lastWriteDate ? s : max);
+    return servers.reduce((result, server) => {
+      const stalenessMS = sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS;
+      const staleness = stalenessMS / 1000;
+      const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
+
+      if (staleness <= maxStalenessSeconds) {
+        result.push(server);
+      }
+
+      return result;
+    }, []);
+  }
+
+  return servers;
+}
+/**
+ * Determines whether a server's tags match a given set of tags
+ *
+ * @param tagSet - The requested tag set to match
+ * @param serverTags - The server's tags
+ */
+
+
+function tagSetMatch(tagSet, serverTags) {
+  const keys = Object.keys(tagSet);
+  const serverTagKeys = Object.keys(serverTags);
+
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+
+    if (serverTagKeys.indexOf(key) === -1 || serverTags[key] !== tagSet[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+/**
+ * Reduces a set of server descriptions based on tags requested by the read preference
+ *
+ * @param readPreference - The read preference providing the requested tags
+ * @param servers - The list of server descriptions to reduce
+ * @returns The list of servers matching the requested tags
+ */
+
+
+function tagSetReducer(readPreference, servers) {
+  if (readPreference.tags == null || Array.isArray(readPreference.tags) && readPreference.tags.length === 0) {
+    return servers;
+  }
+
+  for (let i = 0; i < readPreference.tags.length; ++i) {
+    const tagSet = readPreference.tags[i];
+    const serversMatchingTagset = servers.reduce((matched, server) => {
+      if (tagSetMatch(tagSet, server.tags)) matched.push(server);
+      return matched;
+    }, []);
+
+    if (serversMatchingTagset.length) {
+      return serversMatchingTagset;
+    }
+  }
+
+  return [];
+}
+/**
+ * Reduces a list of servers to ensure they fall within an acceptable latency window. This is
+ * further specified in the "Server Selection" specification, found here:
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.md
+ *
+ * @param topologyDescription - The topology description
+ * @param servers - The list of servers to reduce
+ * @returns The servers which fall within an acceptable latency window
+ */
+
+
+function latencyWindowReducer(topologyDescription, servers) {
+  const low = servers.reduce((min, server) => Math.min(server.roundTripTime, min), Infinity);
+  const high = low + topologyDescription.localThresholdMS;
+  return servers.reduce((result, server) => {
+    if (server.roundTripTime <= high && server.roundTripTime >= low) result.push(server);
+    return result;
+  }, []);
+} // filters
+
+
+function primaryFilter(server) {
+  return server.type === common_1.ServerType.RSPrimary;
+}
+
+function secondaryFilter(server) {
+  return server.type === common_1.ServerType.RSSecondary;
+}
+
+function nearestFilter(server) {
+  return server.type === common_1.ServerType.RSSecondary || server.type === common_1.ServerType.RSPrimary;
+}
+
+function knownFilter(server) {
+  return server.type !== common_1.ServerType.Unknown;
+}
+
+function loadBalancerFilter(server) {
+  return server.type === common_1.ServerType.LoadBalancer;
+}
+/**
+ * Returns a function which selects servers based on a provided read preference
+ *
+ * @param readPreference - The read preference to select with
+ */
+
+
+function readPreferenceServerSelector(readPreference) {
+  if (!readPreference.isValid()) {
+    throw new error_1.MongoInvalidArgumentError('Invalid read preference specified');
+  }
+
+  return function readPreferenceServers(topologyDescription, servers, deprioritized = []) {
+    const commonWireVersion = topologyDescription.commonWireVersion;
+
+    if (commonWireVersion && readPreference.minWireVersion && readPreference.minWireVersion > commonWireVersion) {
+      throw new error_1.MongoCompatibilityError(`Minimum wire version '${readPreference.minWireVersion}' required, but found '${commonWireVersion}'`);
+    }
+
+    if (topologyDescription.type === common_1.TopologyType.LoadBalanced) {
+      return servers.filter(loadBalancerFilter);
+    }
+
+    if (topologyDescription.type === common_1.TopologyType.Unknown) {
+      return [];
+    }
+
+    if (topologyDescription.type === common_1.TopologyType.Single) {
+      return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
+    }
+
+    if (topologyDescription.type === common_1.TopologyType.Sharded) {
+      const filtered = servers.filter(server => {
+        return !deprioritized.includes(server);
+      });
+      const selectable = filtered.length > 0 ? filtered : deprioritized;
+      return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter));
+    }
+
+    const mode = readPreference.mode;
+
+    if (mode === read_preference_1.ReadPreference.PRIMARY) {
+      return servers.filter(primaryFilter);
+    }
+
+    if (mode === read_preference_1.ReadPreference.PRIMARY_PREFERRED) {
+      const result = servers.filter(primaryFilter);
+
+      if (result.length) {
+        return result;
+      }
+    }
+
+    const filter = mode === read_preference_1.ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
+    const selectedServers = latencyWindowReducer(topologyDescription, tagSetReducer(readPreference, maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))));
+
+    if (mode === read_preference_1.ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
+      return servers.filter(primaryFilter);
+    }
+
+    return selectedServers;
+  };
+}

package/transpiled/mongodb/lib/sdam/server_selection_events.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WaitingForSuitableServerEvent = exports.ServerSelectionSucceededEvent = exports.ServerSelectionFailedEvent = exports.ServerSelectionStartedEvent = exports.ServerSelectionEvent = void 0;
+
+const utils_1 = require(".././utils");
+
+const constants_1 = require("../constants");
+/**
+ * The base export class for all logs published from server selection
+ * @internal
+ * @category Log Type
+ */
+
+
+class ServerSelectionEvent {
+  /** @internal */
+  constructor(selector, topologyDescription, operation) {
+    this.selector = selector;
+    this.operation = operation;
+    this.topologyDescription = topologyDescription;
+  }
+
+}
+
+exports.ServerSelectionEvent = ServerSelectionEvent;
+/**
+ * An event published when server selection starts
+ * @internal
+ * @category Event
+ */
+
+class ServerSelectionStartedEvent extends ServerSelectionEvent {
+  /** @internal */
+  constructor(selector, topologyDescription, operation) {
+    super(selector, topologyDescription, operation);
+    /** @internal */
+
+    this.name = constants_1.SERVER_SELECTION_STARTED;
+    this.message = 'Server selection started';
+  }
+
+}
+
+exports.ServerSelectionStartedEvent = ServerSelectionStartedEvent;
+/**
+ * An event published when a server selection fails
+ * @internal
+ * @category Event
+ */
+
+class ServerSelectionFailedEvent extends ServerSelectionEvent {
+  /** @internal */
+  constructor(selector, topologyDescription, error, operation) {
+    super(selector, topologyDescription, operation);
+    /** @internal */
+
+    this.name = constants_1.SERVER_SELECTION_FAILED;
+    this.message = 'Server selection failed';
+    this.failure = error;
+  }
+
+}
+
+exports.ServerSelectionFailedEvent = ServerSelectionFailedEvent;
+/**
+ * An event published when server selection succeeds
+ * @internal
+ * @category Event
+ */
+
+class ServerSelectionSucceededEvent extends ServerSelectionEvent {
+  /** @internal */
+  constructor(selector, topologyDescription, address, operation) {
+    super(selector, topologyDescription, operation);
+    /** @internal */
+
+    this.name = constants_1.SERVER_SELECTION_SUCCEEDED;
+    this.message = 'Server selection succeeded';
+    const {
+      host,
+      port
+    } = utils_1.HostAddress.fromString(address).toHostPort();
+    this.serverHost = host;
+    this.serverPort = port;
+  }
+
+}
+
+exports.ServerSelectionSucceededEvent = ServerSelectionSucceededEvent;
+/**
+ * An event published when server selection is waiting for a suitable server to become available
+ * @internal
+ * @category Event
+ */
+
+class WaitingForSuitableServerEvent extends ServerSelectionEvent {
+  /** @internal */
+  constructor(selector, topologyDescription, remainingTimeMS, operation) {
+    super(selector, topologyDescription, operation);
+    /** @internal */
+
+    this.name = constants_1.WAITING_FOR_SUITABLE_SERVER;
+    this.message = 'Waiting for suitable server to become available';
+    this.remainingTimeMS = remainingTimeMS;
+  }
+
+}
+
+exports.WaitingForSuitableServerEvent = WaitingForSuitableServerEvent;

package/transpiled/mongodb/lib/sdam/srv_polling.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SrvPoller = exports.SrvPollingEvent = void 0;
+
+const dns = require("dns");
+
+const timers_1 = require("timers");
+
+const error_1 = require("../error");
+
+const mongo_types_1 = require("../mongo_types");
+
+const utils_1 = require("../utils");
+/**
+ * @internal
+ * @category Event
+ */
+
+
+class SrvPollingEvent {
+  constructor(srvRecords) {
+    this.srvRecords = srvRecords;
+  }
+
+  hostnames() {
+    return new Set(this.srvRecords.map(r => utils_1.HostAddress.fromSrvRecord(r).toString()));
+  }
+
+}
+
+exports.SrvPollingEvent = SrvPollingEvent;
+/** @internal */
+
+class SrvPoller extends mongo_types_1.TypedEventEmitter {
+  constructor(options) {
+    super();
+    this.on('error', utils_1.noop);
+
+    if (!options || !options.srvHost) {
+      throw new error_1.MongoRuntimeError('Options for SrvPoller must exist and include srvHost');
+    }
+
+    this.srvHost = options.srvHost;
+    this.srvMaxHosts = options.srvMaxHosts ?? 0;
+    this.srvServiceName = options.srvServiceName ?? 'mongodb';
+    this.rescanSrvIntervalMS = 60000;
+    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 10000;
+    this.haMode = false;
+    this.generation = 0;
+    this._timeout = undefined;
+  }
+
+  get srvAddress() {
+    return `_${this.srvServiceName}._tcp.${this.srvHost}`;
+  }
+
+  get intervalMS() {
+    return this.haMode ? this.heartbeatFrequencyMS : this.rescanSrvIntervalMS;
+  }
+
+  start() {
+    if (!this._timeout) {
+      this.schedule();
+    }
+  }
+
+  stop() {
+    if (this._timeout) {
+      (0, timers_1.clearTimeout)(this._timeout);
+      this.generation += 1;
+      this._timeout = undefined;
+    }
+  } // TODO(NODE-4994): implement new logging logic for SrvPoller failures
+
+
+  schedule() {
+    if (this._timeout) {
+      (0, timers_1.clearTimeout)(this._timeout);
+    }
+
+    this._timeout = (0, timers_1.setTimeout)(() => {
+      this._poll().then(undefined, utils_1.squashError);
+    }, this.intervalMS);
+  }
+
+  success(srvRecords) {
+    this.haMode = false;
+    this.schedule();
+    this.emit(SrvPoller.SRV_RECORD_DISCOVERY, new SrvPollingEvent(srvRecords));
+  }
+
+  failure() {
+    this.haMode = true;
+    this.schedule();
+  }
+
+  async _poll() {
+    const generation = this.generation;
+    let srvRecords;
+
+    try {
+      srvRecords = await dns.promises.resolveSrv(this.srvAddress);
+    } catch {
+      this.failure();
+      return;
+    }
+
+    if (generation !== this.generation) {
+      return;
+    }
+
+    const finalAddresses = [];
+
+    for (const record of srvRecords) {
+      try {
+        (0, utils_1.checkParentDomainMatch)(record.name, this.srvHost);
+        finalAddresses.push(record);
+      } catch (error) {
+        (0, utils_1.squashError)(error);
+      }
+    }
+
+    if (!finalAddresses.length) {
+      this.failure();
+      return;
+    }
+
+    this.success(finalAddresses);
+  }
+
+}
+
+exports.SrvPoller = SrvPoller;
+/** @event */
+
+SrvPoller.SRV_RECORD_DISCOVERY = 'srvRecordDiscovery';