Change APNS multiple certs handling

src/APNS.js

@@ -8,37 +8,77 @@ const apn = require('apn');
 /**
  * Create a new connection to the APN service.
  * @constructor
- * @param {Object} args Arguments to config APNS connection
- * @param {String} args.cert The filename of the connection certificate to load from disk, default is cert.pem
- * @param {String} args.key The filename of the connection key to load from disk, default is key.pem
+ * @param {Object|Array} args An argument or a list of arguments to config APNS connection
+ * @param {String} args.cert The filename of the connection certificate to load from disk
+ * @param {String} args.key The filename of the connection key to load from disk
+ * @param {String} args.pfx The filename for private key, certificate and CA certs in PFX or PKCS12 format, it will overwrite cert and key
  * @param {String} args.passphrase The passphrase for the connection key, if required
+ * @param {String} args.bundleId The bundleId for cert
  * @param {Boolean} args.production Specifies which environment to connect to: Production (if true) or Sandbox
  */
 function APNS(args) {
-  this.sender = new apn.connection(args);
+  // Since for ios, there maybe multiple cert/key pairs,
+  // typePushConfig can be an array.
+  let apnsArgsList = [];
+  if (Array.isArray(args)) {
+    apnsArgsList = apnsArgsList.concat(args);
+  } else if (typeof args === 'object') {
+    apnsArgsList.push(args);
+  } else {
+    throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                          'APNS Configuration is invalid');
+  }
 
-  this.sender.on('connected', function() {
-      console.log('APNS Connected');
-  });
-
-  this.sender.on('transmissionError', function(errCode, notification, device) {
-    console.error('APNS Notification caused error: ' + errCode + ' for device ', device, notification);
-    // TODO: For error caseud by invalid deviceToken, we should mark those installations.
-  });
-
-  this.sender.on("timeout", function () {
-      console.log("APNS Connection Timeout");
-  });
-
-  this.sender.on("disconnected", function() {
-      console.log("APNS Disconnected");
-  });
-
-  this.sender.on("socketError", console.error);
-
-  this.sender.on("transmitted", function(notification, device) {
-    console.log("APNS Notification transmitted to:" + device.token.toString("hex"));
+  this.conns = [];
+  for (let apnsArgs of apnsArgsList) {
+    let conn = new apn.Connection(apnsArgs);
+    if (!apnsArgs.bundleId) {
+      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                            'BundleId is mssing for %j', apnsArgs);
+    }
+    conn.bundleId = apnsArgs.bundleId;
+    // Set the priority of the conns, prod cert has higher priority
+    if (apnsArgs.production) {
+      conn.priority = 0;
+    } else {
+      conn.priority = 1;
+    }
+
+    // Set apns client callbacks
+    conn.on('connected', () => {
+      console.log('APNS Connection %d Connected', conn.index);
+    });
+
+    conn.on('transmissionError', (errCode, notification, apnDevice) => {
+      handleTransmissionError(this.conns, errCode, notification, apnDevice);
+    });
+
+    conn.on('timeout', () => {
+      console.log('APNS Connection %d Timeout', conn.index);
+    });
+
+    conn.on('disconnected', () => {
+      console.log('APNS Connection %d Disconnected', conn.index);
+    });
+
+    conn.on('socketError', () => {
+      console.log('APNS Connection %d Socket Error', conn.index);
+    });
+
+    conn.on('transmitted', function(notification, device) {
+      console.log('APNS Connection %d Notification transmitted to %s', conn.index, device.token.toString('hex'));
+    });
+
+    this.conns.push(conn);
+  }
+  // Sort the conn based on priority ascending, high pri first
+  this.conns.sort((s1, s2) => {
+    return s1.priority - s2.priority;
   });
+  // Set index of conns
+  for (let index = 0; index < this.conns.length; index++) {
+    this.conns[index].index = index;
+  }
 }
 
 /**
@@ -51,23 +91,84 @@ APNS.prototype.send = function(data, devices) {
   let coreData = data.data;
   let expirationTime = data['expiration_time'];
   let notification = generateNotification(coreData, expirationTime);
-  let deviceTokens = [];
   for (let device of devices) {
-    deviceTokens.push(device.deviceToken);
+    let qualifiedConnIndexs = chooseConns(this.conns, device);
+    // We can not find a valid conn, just ignore this device
+    if (qualifiedConnIndexs.length == 0) {
+      continue;
+    }
+    let conn = this.conns[qualifiedConnIndexs[0]];
+    let apnDevice = new apn.Device(device.deviceToken);
+    apnDevice.connIndex = qualifiedConnIndexs[0];
+    // Add additional appIdentifier info to apn device instance
+    if (device.appIdentifier) {
+      apnDevice.appIdentifier = device.appIdentifier;
+    }
+    conn.pushNotification(notification, apnDevice);
   }
-  this.sender.pushNotification(notification, deviceTokens);
-  // TODO: pushNotification will push the notification to apn's queue.
-  // We do not handle error in V1, we just relies apn to auto retry and send the
-  // notifications.
   return Parse.Promise.as();
 }
 
+function handleTransmissionError(conns, errCode, notification, apnDevice) {
+  console.error('APNS Notification caused error: ' + errCode + ' for device ', apnDevice, notification);
+  // This means the error notification is not in the cache anymore or the recepient is missing,
+  // we just ignore this case
+  if (!notification || !apnDevice) {
+    return
+  }
+
+  // If currentConn can not send the push notification, we try to use the next available conn.
+  // Since conns is sorted by priority, the next conn means the next low pri conn.
+  // If there is no conn available, we give up on sending the notification to that device.
+  let qualifiedConnIndexs = chooseConns(conns, apnDevice);
+  let currentConnIndex = apnDevice.connIndex;
+
+  let newConnIndex = -1;
+  // Find the next element of currentConnIndex in qualifiedConnIndexs
+  for (let index = 0; index < qualifiedConnIndexs.length - 1; index++) {
+    if (qualifiedConnIndexs[index] === currentConnIndex) {
+      newConnIndex = qualifiedConnIndexs[index + 1];
+      break;
+    }
+  }
+  // There is no more available conns, we give up in this case
+  if (newConnIndex < 0 || newConnIndex >= conns.length) {
+    console.log('APNS can not find vaild connection for %j', apnDevice.token);
+    return;
+  }
+
+  let newConn = conns[newConnIndex];
+  // Update device conn info
+  apnDevice.connIndex = newConnIndex;
+  // Use the new conn to send the notification
+  newConn.pushNotification(notification, apnDevice);
+}
+
+function chooseConns(conns, device) {
+  // If device does not have appIdentifier, all conns maybe proper connections.
+  // Otherwise we try to match the appIdentifier with bundleId
+  let qualifiedConns = [];
+  for (let index = 0; index < conns.length; index++) {
+    let conn = conns[index];
+    // If the device we need to send to does not have
+    // appIdentifier, any conn could be a qualified connection
+    if (!device.appIdentifier || device.appIdentifier === '') {
+      qualifiedConns.push(index);
+      continue;
+    }
+    if (device.appIdentifier === conn.bundleId) {
+      qualifiedConns.push(index);
+    }
+  }
+  return qualifiedConns;
+}
+
 /**
  * Generate the apns notification from the data we get from api request.
  * @param {Object} coreData The data field under api request body
  * @returns {Object} A apns notification
  */
-let generateNotification = function(coreData, expirationTime) {
+function generateNotification(coreData, expirationTime) {
   let notification = new apn.notification();
   let payload = {};
   for (let key in coreData) {
@@ -101,5 +202,7 @@ let generateNotification = function(coreData, expirationTime) {
 
 if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
   APNS.generateNotification = generateNotification;
+  APNS.chooseConns = chooseConns;
+  APNS.handleTransmissionError = handleTransmissionError;
 }
 module.exports = APNS;