mongodb 3.2.5 → 3.3.0-beta2

package/lib/core/sdam/server_selectors.js

@@ -0,0 +1,244 @@
+'use strict';
+const ServerType = require('./server_description').ServerType;
+const TopologyType = require('./topology_description').TopologyType;
+const ReadPreference = require('../topologies/read_preference');
+const MongoError = require('../error').MongoError;
+
+// max staleness constants
+const IDLE_WRITE_PERIOD = 10000;
+const SMALLEST_MAX_STALENESS_SECONDS = 90;
+
+/**
+ * Returns a server selector that selects for writable servers
+ */
+function writableServerSelector() {
+  return function(topologyDescription, servers) {
+    return latencyWindowReducer(topologyDescription, servers.filter(s => s.isWritable));
+  };
+}
+
+/**
+ * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
+ * found here: https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.rst
+ *
+ * @param {ReadPreference} readPreference The read preference providing max staleness guidance
+ * @param {topologyDescription} topologyDescription The topology description
+ * @param {ServerDescription[]} servers The list of server descriptions to be reduced
+ * @return {ServerDescription[]} 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 MongoError(`maxStalenessSeconds must be at least ${maxStalenessVariance} seconds`);
+  }
+
+  if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) {
+    throw new MongoError(
+      `maxStalenessSeconds must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`
+    );
+  }
+
+  if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
+    const primary = servers.filter(primaryFilter)[0];
+    return servers.reduce((result, server) => {
+      const stalenessMS =
+        server.lastUpdateTime -
+        server.lastWriteDate -
+        (primary.lastUpdateTime - primary.lastWriteDate) +
+        topologyDescription.heartbeatFrequencyMS;
+
+      const staleness = stalenessMS / 1000;
+      if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
+      return result;
+    }, []);
+  } else if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+    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;
+      if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
+      return result;
+    }, []);
+  }
+
+  return servers;
+}
+
+/**
+ * Determines whether a server's tags match a given set of tags
+ *
+ * @param {String[]} tagSet The requested tag set to match
+ * @param {String[]} 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} readPreference The read preference providing the requested tags
+ * @param {ServerDescription[]} servers The list of server descriptions to reduce
+ * @return {ServerDescription[]} 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:
+ * https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst
+ *
+ * @param {topologyDescription} topologyDescription The topology description
+ * @param {ServerDescription[]} servers The list of servers to reduce
+ * @returns {ServerDescription[]} The servers which fall within an acceptable latency window
+ */
+function latencyWindowReducer(topologyDescription, servers) {
+  const low = servers.reduce(
+    (min, server) => (min === -1 ? server.roundTripTime : Math.min(server.roundTripTime, min)),
+    -1
+  );
+
+  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 === ServerType.RSPrimary;
+}
+
+function secondaryFilter(server) {
+  return server.type === ServerType.RSSecondary;
+}
+
+function nearestFilter(server) {
+  return server.type === ServerType.RSSecondary || server.type === ServerType.RSPrimary;
+}
+
+function knownFilter(server) {
+  return server.type !== ServerType.Unknown;
+}
+
+/**
+ * Returns a function which selects servers based on a provided read preference
+ *
+ * @param {ReadPreference} readPreference The read preference to select with
+ */
+function readPreferenceServerSelector(readPreference) {
+  if (!readPreference.isValid()) {
+    throw new TypeError('Invalid read preference specified');
+  }
+
+  return function(topologyDescription, servers) {
+    const commonWireVersion = topologyDescription.commonWireVersion;
+    if (
+      commonWireVersion &&
+      (readPreference.minWireVersion && readPreference.minWireVersion > commonWireVersion)
+    ) {
+      throw new MongoError(
+        `Minimum wire version '${
+          readPreference.minWireVersion
+        }' required, but found '${commonWireVersion}'`
+      );
+    }
+
+    if (
+      topologyDescription.type === TopologyType.Single ||
+      topologyDescription.type === TopologyType.Sharded
+    ) {
+      return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
+    }
+
+    if (readPreference.mode === ReadPreference.PRIMARY) {
+      return servers.filter(primaryFilter);
+    }
+
+    if (readPreference.mode === ReadPreference.SECONDARY) {
+      return latencyWindowReducer(
+        topologyDescription,
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers)
+        )
+      ).filter(secondaryFilter);
+    } else if (readPreference.mode === ReadPreference.NEAREST) {
+      return latencyWindowReducer(
+        topologyDescription,
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers)
+        )
+      ).filter(nearestFilter);
+    } else if (readPreference.mode === ReadPreference.SECONDARY_PREFERRED) {
+      const result = latencyWindowReducer(
+        topologyDescription,
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers)
+        )
+      ).filter(secondaryFilter);
+
+      return result.length === 0 ? servers.filter(primaryFilter) : result;
+    } else if (readPreference.mode === ReadPreference.PRIMARY_PREFERRED) {
+      const result = servers.filter(primaryFilter);
+      if (result.length) {
+        return result;
+      }
+
+      return latencyWindowReducer(
+        topologyDescription,
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers)
+        )
+      ).filter(secondaryFilter);
+    }
+  };
+}
+
+module.exports = {
+  writableServerSelector,
+  readPreferenceServerSelector
+};

package/lib/core/sdam/srv_polling.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const Logger = require('../connection/logger');
+const EventEmitter = require('events').EventEmitter;
+const dns = require('dns');
+/**
+ * Determines whether a provided address matches the provided parent domain in order
+ * to avoid certain attack vectors.
+ *
+ * @param {String} srvAddress The address to check against a domain
+ * @param {String} parentDomain The domain to check the provided address against
+ * @return {Boolean} Whether the provided address matches the parent domain
+ */
+function matchesParentDomain(srvAddress, parentDomain) {
+  const regex = /^.*?\./;
+  const srv = `.${srvAddress.replace(regex, '')}`;
+  const parent = `.${parentDomain.replace(regex, '')}`;
+  return srv.endsWith(parent);
+}
+
+class SrvPollingEvent {
+  constructor(srvRecords) {
+    this.srvRecords = srvRecords;
+  }
+
+  addresses() {
+    return new Set(this.srvRecords.map(record => `${record.name}:${record.port}`));
+  }
+}
+
+class SrvPoller extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {string} options.srvHost
+   * @param {number} [options.heartbeatFrequencyMS]
+   * @param {function} [options.logger]
+   * @param {string} [options.loggerLevel]
+   */
+  constructor(options) {
+    super();
+
+    if (!options || !options.srvHost) {
+      throw new TypeError('options for SrvPoller must exist and include srvHost');
+    }
+
+    this.srvHost = options.srvHost;
+    this.rescanSrvIntervalMS = 60000;
+    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS || 10000;
+    this.logger = Logger('srvPoller', options);
+
+    this.haMode = false;
+    this.generation = 0;
+
+    this._timeout = null;
+  }
+
+  get srvAddress() {
+    return `_mongodb._tcp.${this.srvHost}`;
+  }
+
+  get intervalMS() {
+    return this.haMode ? this.heartbeatFrequencyMS : this.rescanSrvIntervalMs;
+  }
+
+  start() {
+    if (!this._timeout) {
+      this.schedule();
+    }
+  }
+
+  stop() {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+      this.generation += 1;
+      this._timeout = null;
+    }
+  }
+
+  schedule() {
+    clearTimeout(this._timeout);
+    this._timeout = setTimeout(() => this._poll(), this.intervalMS);
+  }
+
+  success(srvRecords) {
+    this.haMode = false;
+    this.schedule();
+    this.emit('srvRecordDiscovery', new SrvPollingEvent(srvRecords));
+  }
+
+  failure(message, obj) {
+    this.logger.warn(message, obj);
+    this.haMode = true;
+    this.schedule();
+  }
+
+  parentDomainMismatch(srvRecord) {
+    this.logger.warn(
+      `parent domain mismatch on SRV record (${srvRecord.name}:${srvRecord.port})`,
+      srvRecord
+    );
+  }
+
+  _poll() {
+    const generation = this.generation;
+    dns.resolveSrv(this.srvAddress, (err, srvRecords) => {
+      if (generation !== this.generation) {
+        return;
+      }
+
+      if (err) {
+        this.failure('DNS error', err);
+        return;
+      }
+
+      const finalAddresses = [];
+      srvRecords.forEach(record => {
+        if (matchesParentDomain(record.name, this.srvHost)) {
+          finalAddresses.push(record);
+        } else {
+          this.parentDomainMismatch(record);
+        }
+      });
+
+      if (!finalAddresses.length) {
+        this.failure('No valid addresses found at host');
+        return;
+      }
+
+      this.success(finalAddresses);
+    });
+  }
+}
+
+module.exports.SrvPollingEvent = SrvPollingEvent;
+module.exports.SrvPoller = SrvPoller;