Add support for push

Author: wangmengyan95

APNS.js

@@ -33,18 +33,26 @@ function APNS(args) {
   });
 
   this.sender.on("socketError", console.error);
+
+  this.sender.on("transmitted", function(notification, device) {
+    console.log("APNS Notification transmitted to:" + device.token.toString("hex"));
+  });
 }
 
 /**
  * Send apns request.
  * @param {Object} data The data we need to send, the format is the same with api request body
- * @param {Array} deviceTokens A array of device tokens
+ * @param {Array} devices A array of devices
  * @returns {Object} A promise which is resolved immediately
  */
-APNS.prototype.send = function(data, deviceTokens) {
+APNS.prototype.send = function(data, devices) {
   var coreData = data.data;
   var expirationTime = data['expiration_time'];
   var notification = generateNotification(coreData, expirationTime);
+  var deviceTokens = [];
+  for (var i = 0; i < devices.length; i++) {
+    deviceTokens.push(devices[i].deviceToken);
+  }
   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

GCM.js

@@ -5,18 +5,18 @@ var randomstring = require('randomstring');
 var GCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // GCM allows a max of 4 weeks
 var GCMRegistrationTokensMax = 1000;
 
-function GCM(apiKey) {
-  this.sender = new gcm.Sender(apiKey);
+function GCM(args) {
+  this.sender = new gcm.Sender(args.apiKey);
 }
 
 /**
  * Send gcm request.
  * @param {Object} data The data we need to send, the format is the same with api request body
- * @param {Array} registrationTokens A array of registration tokens
+ * @param {Array} devices A array of devices
  * @returns {Object} A promise which is resolved after we get results from gcm
  */
-GCM.prototype.send = function (data, registrationTokens) {
-  if (registrationTokens.length >= GCMRegistrationTokensMax) {
+GCM.prototype.send = function (data, devices) {
+  if (devices.length >= GCMRegistrationTokensMax) {
     throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
                           'Too many registration tokens for a GCM request.');
   }
@@ -36,9 +36,17 @@ GCM.prototype.send = function (data, registrationTokens) {
   // Make and send gcm request
   var message = new gcm.Message(gcmPayload);
   var promise = new Parse.Promise();
+  var registrationTokens = []
+  for (var i = 0; i < devices.length; i++) {
+    registrationTokens.push(devices[i].deviceToken);
+  }
   this.sender.send(message, { registrationTokens: registrationTokens }, 5, function (error, response) {
     // TODO: Use the response from gcm to generate and save push report
     // TODO: If gcm returns some deviceTokens are invalid, set tombstone for the installation
+    console.log('GCM request and response %j', {
+      request: message,
+      response: response
+    });
     promise.resolve();
   });
   return promise;
@@ -76,6 +84,8 @@ var generateGCMPayload = function(coreData, pushId, timeStamp, expirationTime) {
   return payload;
 }
 
+GCM.GCMRegistrationTokensMax = GCMRegistrationTokensMax;
+
 if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
   GCM.generateGCMPayload = generateGCMPayload;
 }

ParsePushAdapter.js

@@ -0,0 +1,156 @@
+// ParsePushAdapter is the default implementation of
+// PushAdapter, it uses GCM for android push and APNS
+// for ios push.
+
+var Parse = require('parse/node').Parse,
+    GCM = require('./GCM'),
+    APNS = require('./APNS');
+
+function ParsePushAdapter() {
+ this.validPushTypes = ['ios', 'android'];
+ this.senders = {};
+}
+
+/**
+ * Register push senders
+ * @param {Object} pushConfig The push configuration which is given when parse server is initialized
+ */
+ParsePushAdapter.prototype.registerPushSenders = function(pushConfig) {
+  // Initialize senders
+  for (var i = 0; i < this.validPushTypes.length; i++) {
+    this.senders[this.validPushTypes[i]] = [];
+  }
+
+  pushConfig = pushConfig || {};
+  var pushTypes = Object.keys(pushConfig);
+  for (var i = 0; i < pushTypes.length; i++) {
+    var pushType = pushTypes[i];
+    if (this.validPushTypes.indexOf(pushType) < 0) {
+      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                            'Push to ' + pushTypes + ' is not supported');
+    }
+
+    var typePushConfig = pushConfig[pushType];
+    var senderArgs = [];
+    // Since for ios, there maybe multiple cert/key pairs,
+    // typePushConfig can be an array.
+    if (Array.isArray(typePushConfig)) {
+      senderArgs = senderArgs.concat(typePushConfig);
+    } else if (typeof typePushConfig === 'object') {
+      senderArgs.push(typePushConfig);
+    } else {
+      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                            'Push Configuration is invalid');
+    }
+    for (var j = 0; j < senderArgs.length; j++) {
+      var senderArg = senderArgs[j];
+      var sender;
+      switch (pushType) {
+        case 'ios':
+          sender = new APNS(senderArg);
+          break;
+        case 'android':
+          sender = new GCM(senderArg);
+          break;
+      }
+      this.senders[pushType].push(sender);
+    }
+  }
+}
+
+/**
+ * Get an array of push senders based on the push type.
+ * @param {String} The push type
+ * @returns {Array|Undefined} An array of push senders
+ */
+ParsePushAdapter.prototype.getPushSenders = function(pushType) {
+  if (!this.senders[pushType]) {
+    console.log('No push sender for push type %s', pushType);
+    return [];
+  }
+  return this.senders[pushType];
+}
+
+/**
+ * Get an array of valid push types.
+ * @returns {Array} An array of valid push types
+ */
+ParsePushAdapter.prototype.getValidPushTypes = function() {
+  return this.validPushTypes;
+}
+
+ParsePushAdapter.prototype.send = function(data, installations) {
+  var deviceMap = classifyInstallation(installations, this.validPushTypes);
+  var sendPromises = [];
+  for (var pushType in deviceMap) {
+    var senders = this.getPushSenders(pushType);
+    // Since ios have dev/prod cert, a push type may have multiple senders
+    for (var i = 0; i < senders.length; i++) {
+      var sender = senders[i];
+      var devices = deviceMap[pushType];
+      if (!sender || devices.length == 0) {
+        continue;
+      }
+      // For android, we can only have 1000 recepients per send
+      var chunkDevices = sliceDevices(pushType, devices, GCM.GCMRegistrationTokensMax);
+      for (var j = 0; j < chunkDevices.length; j++) {
+        sendPromises.push(sender.send(data, chunkDevices[j]));
+      }
+    }
+  }
+  return Parse.Promise.when(sendPromises);
+}
+
+/**
+ * Classify the device token of installations based on its device type.
+ * @param {Object} installations An array of installations
+ * @param {Array} validPushTypes An array of valid push types(string)
+ * @returns {Object} A map whose key is device type and value is an array of device
+ */
+function classifyInstallation(installations, validPushTypes) {
+  // Init deviceTokenMap, create a empty array for each valid pushType
+  var deviceMap = {};
+  for (var i = 0; i < validPushTypes.length; i++) {
+    deviceMap[validPushTypes[i]] = [];
+  }
+  for (var i = 0; i < installations.length; i++) {
+    var installation = installations[i];
+    // No deviceToken, ignore
+    if (!installation.deviceToken) {
+      continue;
+    }
+    var pushType = installation.deviceType;
+    if (deviceMap[pushType]) {
+      deviceMap[pushType].push({
+        deviceToken: installation.deviceToken
+      });
+    } else {
+      console.log('Unknown push type from installation %j', installation);
+    }
+  }
+  return deviceMap;
+}
+
+/**
+ * Slice a list of devices to several list of devices with fixed chunk size.
+ * @param {String} pushType The push type of the given device tokens
+ * @param {Array} devices An array of devices
+ * @param {Number} chunkSize The size of the a chunk
+ * @returns {Array} An array which contaisn several arries of devices with fixed chunk size
+ */
+function sliceDevices(pushType, devices, chunkSize) {
+  if (pushType !== 'android') {
+    return [devices];
+  }
+  var chunkDevices = [];
+  while (devices.length > 0) {
+    chunkDevices.push(devices.splice(0, chunkSize));
+  }
+  return chunkDevices;
+}
+
+if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+  ParsePushAdapter.classifyInstallation = classifyInstallation;
+  ParsePushAdapter.sliceDevices = sliceDevices;
+}
+module.exports = ParsePushAdapter;

PushAdapter.js

@@ -0,0 +1,29 @@
+// Push Adapter
+//
+// Allows you to change the push notification mechanism.
+//
+// Adapter classes must implement the following functions:
+// * registerPushSenders(parseConfig)
+// * getPushSenders(parseConfig)
+// * getValidPushTypes(parseConfig)
+// * send(devices, installations)
+//
+// Default is ParsePushAdapter, which uses GCM for
+// android push and APNS for ios push.
+
+var ParsePushAdapter = require('./ParsePushAdapter');
+
+var adapter = new ParsePushAdapter();
+
+function setAdapter(pushAdapter) {
+  adapter = pushAdapter;
+}
+
+function getAdapter() {
+  return adapter;
+}
+
+module.exports = {
+  getAdapter: getAdapter,
+  setAdapter: setAdapter
+};

index.js

@@ -7,6 +7,7 @@ var batch = require('./batch'),
     express = require('express'),
     FilesAdapter = require('./FilesAdapter'),
     S3Adapter = require('./S3Adapter'),
+    PushAdapter = require('./PushAdapter'),
     middlewares = require('./middlewares'),
     multer = require('multer'),
     Parse = require('parse/node').Parse,
@@ -80,6 +81,10 @@ function ParseServer(args) {
     cache.apps[args.appId]['facebookAppIds'].push(process.env.FACEBOOK_APP_ID);
   }
 
+  // Register push senders
+  var pushConfig = args.push;
+  PushAdapter.getAdapter().registerPushSenders(pushConfig);
+
   // Initialize the node client SDK automatically
   Parse.initialize(args.appId, args.javascriptKey || '', args.masterKey);
   if(args.serverURL) {

push.js

@@ -2,27 +2,34 @@
 
 var Parse = require('parse/node').Parse,
     PromiseRouter = require('./PromiseRouter'),
+    PushAdapter = require('./PushAdapter'),
     rest = require('./rest');
 
-var validPushTypes = ['ios', 'android'];
-
 function handlePushWithoutQueue(req) {
   validateMasterKey(req);
   var where = getQueryCondition(req);
-  validateDeviceType(where);
+  var pushAdapter = PushAdapter.getAdapter();
+  validatePushType(where, pushAdapter.getValidPushTypes());
   // Replace the expiration_time with a valid Unix epoch milliseconds time
   req.body['expiration_time'] = getExpirationTime(req);
-  return rest.find(req.config, req.auth, '_Installation', where).then(function(response) {
-    throw new Parse.Error(Parse.Error.COMMAND_UNAVAILABLE,
-                  'This path is not implemented yet.');
+  // TODO: If the req can pass the checking, we return immediately instead of waiting
+  // pushes to be sent. We probably change this behaviour in the future.
+  rest.find(req.config, req.auth, '_Installation', where).then(function(response) {
+    return pushAdapter.send(req.body, response.results);
+  });
+  return Parse.Promise.as({
+      response: {
+        'result': true
+      }
   });
 }
 
 /**
  * Check whether the deviceType parameter in qury condition is valid or not.
  * @param {Object} where A query condition
+ * @param {Array} validPushTypes An array of valid push types(string)
  */
-function validateDeviceType(where) {
+function validatePushType(where, validPushTypes) {
   var where = where || {};
   var deviceTypeField = where.deviceType || {};
   var deviceTypes = [];
@@ -113,12 +120,12 @@ var router = new PromiseRouter();
 router.route('POST','/push', handlePushWithoutQueue);
 
 module.exports = {
-  router: router
+  router: router,
 }
 
 if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
   module.exports.getQueryCondition = getQueryCondition;
   module.exports.validateMasterKey = validateMasterKey;
   module.exports.getExpirationTime = getExpirationTime;
-  module.exports.validateDeviceType = validateDeviceType;
+  module.exports.validatePushType = validatePushType;
 }

spec/APNS.spec.js

@@ -43,16 +43,18 @@ describe('APNS', () => {
         'alert': 'alert'
       }
     }
-    // Mock registrationTokens
-    var deviceTokens = ['token'];
+    // Mock devices
+    var devices = [
+      { deviceToken: 'token' }
+    ];
 
-    var promise = apns.send(data, deviceTokens);
+    var promise = apns.send(data, devices);
     expect(sender.pushNotification).toHaveBeenCalled();
     var args = sender.pushNotification.calls.first().args;
     var notification = args[0];
     expect(notification.alert).toEqual(data.data.alert);
     expect(notification.expiry).toEqual(data['expiration_time']);
-    expect(args[1]).toEqual(deviceTokens);
+    expect(args[1]).toEqual(['token']);
     done();
   });
 });