refactor(server): Extract and simplify record retreival/storage, user defined rules.

lib/bans/handler.js

@@ -2,74 +2,30 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-module.exports = function (LIFETIME_SEC, mc, EmailRecord, IpRecord, log) {
-
-  function blockIp(ip, cb) {
-    mc.get(ip,
-      function (err, data) {
-        if (err) {
-          log.error({ op: 'handleBan.blockIp', ip: ip, err: err })
-          return cb(err)
-        }
-
-        log.info({ op: 'handleBan.blockIp', ip: ip })
-        var ir = IpRecord.parse(data)
-        ir.block()
-        var lifetime = Math.max(LIFETIME_SEC, ir.getMinLifetimeMS() / 1000)
-        mc.set(ip, ir, lifetime,
-          function (err) {
-            if (err) {
-              log.error({ op: 'memcachedError', err: err })
-              return cb(err)
-            }
-            mc.end()
-            cb(null)
-          }
-        )
-      }
-    )
+module.exports = function (fetchRecords, setRecord, log) {
+  async function blockIp(ip) {
+    const { ipRecord } = await fetchRecords({ ip })
+    log.info({ op: 'handleBan.blockIp', ip: ip })
+    ipRecord.block()
+    return setRecord(ipRecord)
   }
 
-  function blockEmail(email, cb) {
-    mc.get(email,
-      function (err, data) {
-        if (err) {
-          log.error({ op: 'handleBan.blockEmail', email: email, err: err })
-          return cb(err)
-        }
-
-        log.info({ op: 'handleBan.blockEmail', email: email })
-        var er = EmailRecord.parse(data)
-        er.block()
-        var lifetime = Math.max(LIFETIME_SEC, er.getMinLifetimeMS() / 1000)
-        mc.set(email, er, lifetime,
-          function (err) {
-            if (err) {
-              log.error({ op: 'memcachedError', err: err })
-              return cb(err)
-            }
-            mc.end()
-            cb(null)
-          }
-        )
-      }
-    )
+  async function blockEmail(email) {
+    const { emailRecord } = await fetchRecords({ email })
+    log.info({ op: 'handleBan.blockEmail', email: email })
+    emailRecord.block()
+    return setRecord(emailRecord)
   }
 
-  function handleBan(message, cb) {
-    if (!cb) {
-      cb = function () {}
-    }
+  async function handleBan(message) {
     if (message.ban && message.ban.ip) {
-      blockIp(message.ban.ip, cb)
-    }
-    else if (message.ban && message.ban.email) {
-      blockEmail(message.ban.email, cb)
-    }
-    else {
-      log.error({ op: 'handleBan', ban: !!message.ban })
-      cb('invalid message')
+      return blockIp(message.ban.ip)
+    } else if (message.ban && message.ban.email) {
+      return blockEmail(message.ban.email)
     }
+
+    log.error({ op: 'handleBan', ban: !!message.ban })
+    return Promise.reject('invalid message')
   }
 
   return handleBan

lib/record.js

@@ -7,8 +7,21 @@ class Record {
     object = object || {}
     this.rl = object.rl       // timestamp when the account was rate-limited
     this.hits = object.hits || [] // timestamps when last hit occurred
-    this.limits = config.limits
-    this.actions = config.actions
+
+    Object.defineProperty(this, 'limits', {
+      // limits is not saved to memcached
+      enumerable: false,
+      get () {
+        return config.limits
+      }
+    })
+    Object.defineProperty(this, 'actions', {
+      // actions is not saved to memcached
+      enumerable: false,
+      get () {
+        return config.actions
+      }
+    })
     this.now = now
   }
 

lib/records.js

@@ -0,0 +1,112 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+module.exports = function (mc, reputationService, limits, recordLifetimeSeconds) {
+  const IpEmailRecord = require('./ip_email_record')(limits)
+  const EmailRecord = require('./email_record')(limits)
+  const IpRecord = require('./ip_record')(limits)
+  const UidRecord = require('./uid_record')(limits)
+  const SmsRecord = require('./sms_record')(limits)
+
+  /**
+   * Fetch a single record keyed by `key`, parse the result using `parser`.
+   *
+   * @param {String} key
+   * @param {Function} parser
+   * @returns {Promise} resolves to a Record when complete
+   */
+  async function fetchRecord(key, parser) {
+    const record = await mc.getAsync(key).then(parser, parser)
+    record.key = key
+    return record
+  }
+
+  /**
+   * Fetch a set of records
+   *
+   * @param {Object} config
+   *  @param {String} [object.ip] ip address to fetch
+   *  @param {String} [object.email] email address to fetch
+   *  @param {String} [object.phoneNumber] phone number to fetch
+   *  @param {String} [object.uid] uid to fetch
+   * @returns {Promise} resolves to an object with the following keys:
+   *  `ipRecord`, `reputation`, `emailRecord`, `ipEmailRecord`, `smsRecord`, and `uidRecord`
+   */
+  async function fetchRecords(config) {
+    const records = {}
+
+    const { ip, email, phoneNumber, uid } = config
+
+    if (ip) {
+      records.ipRecord = await fetchRecord(ip, IpRecord.parse)
+      records.reputation = await reputationService.get(ip)
+    }
+
+    // The /checkIpOnly endpoint has no email (or phoneNumber)
+    if (email) {
+      records.emailRecord = await fetchRecord(email, EmailRecord.parse)
+    }
+
+    if (ip && email) {
+      records.ipEmailRecord = await fetchRecord(ip + email, IpEmailRecord.parse)
+    }
+
+    // Check against SMS records to make sure that this request can send to this phone number
+    if (phoneNumber) {
+      records.smsRecord = await fetchRecord(phoneNumber, SmsRecord.parse)
+    }
+
+    if (uid) {
+      records.uidRecord = await fetchRecord(uid, UidRecord.parse)
+    }
+
+    return records
+  }
+
+  /**
+   * Save a record
+   *
+   * @param {Record} record
+   * @returns
+   */
+  function setRecord(record) {
+    const lifetime = Math.max(recordLifetimeSeconds, record.getMinLifetimeMS() / 1000)
+    return mc.setAsync(record.key, marshallRecordForStorage(record), lifetime)
+  }
+
+  /**
+   * Marshall a record for persistent storage
+   *
+   * @param {Record} record
+   * @returns {Object}
+   */
+  function marshallRecordForStorage (record) {
+    const marshalled = {}
+
+    for (const key of Object.keys(record)) {
+      if (key !== 'key' && typeof record[key] !== 'function') {
+        marshalled[key] = record[key]
+      }
+    }
+
+    return marshalled
+  }
+
+  /**
+   * Save records
+   *
+   * @param {Record[]} records to save.
+   * @returns {Promise} Resolves when complete
+   */
+  function setRecords(...records) {
+    return Promise.all(records.map(record => setRecord(record)))
+  }
+
+  return {
+    fetchRecord,
+    fetchRecords,
+    setRecord,
+    setRecords
+  }
+}