rapns 2.0.5 → 3.0.0.beta.1

data/lib/rapns/daemon/gcm/delivery.rb

@@ -0,0 +1,206 @@
+module Rapns
+  module Daemon
+    module Gcm
+      # http://developer.android.com/guide/google/gcm/gcm.html#response
+      class Delivery < Rapns::Daemon::Delivery
+        include Rapns::MultiJsonHelper
+
+        GCM_URI = URI.parse('https://android.googleapis.com/gcm/send')
+        UNAVAILABLE_STATES = ['Unavailable', 'InternalServerError']
+
+        def initialize(app, http, notification)
+          @app = app
+          @http = http
+          @notification = notification
+        end
+
+        def perform
+          begin
+            handle_response(do_post)
+          rescue Rapns::DeliveryError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        protected
+
+        def handle_response(response)
+          case response.code.to_i
+          when 200
+            ok(response)
+          when 400
+            bad_request(response)
+          when 401
+            unauthorized(response)
+          when 500
+            internal_server_error(response)
+          when 503
+            service_unavailable(response)
+          else
+            raise Rapns::DeliveryError.new(response.code, @notification.id, HTTP_STATUS_CODES[response.code.to_i])
+          end
+        end
+
+        def ok(response)
+          body = multi_json_load(response.body)
+
+          if body['failure'].to_i == 0
+            mark_delivered
+            Rapns::Daemon.logger.info("[#{@app.name}] #{@notification.id} sent to #{@notification.registration_ids.join(', ')}")
+          else
+            handle_errors(response, body)
+          end
+        end
+
+        def handle_errors(response, body)
+          errors = {}
+
+          body['results'].each_with_index do |result, i|
+            errors[i] = result['error'] if result['error']
+          end
+
+          if body['success'].to_i == 0 && errors.values.all? { |error| error.in?(UNAVAILABLE_STATES) }
+            all_devices_unavailable(response)
+          elsif errors.values.any? { |error| error.in?(UNAVAILABLE_STATES) }
+            some_devices_unavailable(response, errors)
+          else
+            raise Rapns::DeliveryError.new(nil, @notification.id, describe_errors(errors))
+          end
+        end
+
+        def bad_request(response)
+          raise Rapns::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
+        end
+
+        def unauthorized(response)
+          raise Rapns::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
+        end
+
+        def internal_server_error(response)
+          retry_delivery(@notification, response)
+          Rapns::Daemon.logger.warn("GCM responded with an Internal Error. " + retry_message)
+        end
+
+        def service_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns::Daemon.logger.warn("GCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def all_devices_unavailable(response)
+          retry_delivery(@notification, response)
+          Rapns::Daemon.logger.warn("All recipients unavailable. " + retry_message)
+        end
+
+        def some_devices_unavailable(response, errors)
+          unavailable_idxs = errors.find_all { |i, error| error.in?(UNAVAILABLE_STATES) }.map(&:first)
+          new_notification = build_new_notification(response, unavailable_idxs)
+          with_database_reconnect_and_retry { new_notification.save! }
+          raise Rapns::DeliveryError.new(nil, @notification.id,
+            describe_errors(errors) + " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}.")
+        end
+
+        def build_new_notification(response, idxs)
+          notification = Rapns::Gcm::Notification.new
+          notification.assign_attributes(@notification.attributes.slice('app_id', 'collapse_key', 'delay_while_idle'))
+          notification.data = @notification.data
+          notification.registration_ids = idxs.map { |i| @notification.registration_ids[i] }
+          notification.deliver_after = deliver_after_header(response)
+          notification
+        end
+
+        def deliver_after_header(response)
+          if response.header['retry-after']
+            retry_after = if response.header['retry-after'].to_s =~ /^[0-9]+$/
+              Time.now + response.header['retry-after'].to_i
+            else
+              Time.httpdate(response.header['retry-after'])
+            end
+          end
+        end
+
+        def retry_delivery(notification, response)
+          if time = deliver_after_header(response)
+            retry_after(notification, time)
+          else
+            retry_exponentially(notification)
+          end
+        end
+
+        def describe_errors(errors)
+          description = if errors.size == @notification.registration_ids.size
+            "Failed to deliver to all recipients. Errors: #{errors.values.join(', ')}."
+          else
+            "Failed to deliver to recipients #{errors.keys.join(', ')}. Errors: #{errors.values.join(', ')}."
+          end
+        end
+
+        def retry_message
+          "Notification #{@notification.id} will be retired after #{@notification.deliver_after.strftime("%Y-%m-%d %H:%M:%S")} (retry #{@notification.retries})."
+        end
+
+        def do_post
+          post = Net::HTTP::Post.new(GCM_URI.path, initheader = {'Content-Type'  => 'application/json',
+                                                                 'Authorization' => "key=#{@notification.app.auth_key}"})
+          post.body = @notification.as_json.to_json
+          @http.request(GCM_URI, post)
+        end
+
+        HTTP_STATUS_CODES = {
+          100  => 'Continue',
+          101  => 'Switching Protocols',
+          102  => 'Processing',
+          200  => 'OK',
+          201  => 'Created',
+          202  => 'Accepted',
+          203  => 'Non-Authoritative Information',
+          204  => 'No Content',
+          205  => 'Reset Content',
+          206  => 'Partial Content',
+          207  => 'Multi-Status',
+          226  => 'IM Used',
+          300  => 'Multiple Choices',
+          301  => 'Moved Permanently',
+          302  => 'Found',
+          303  => 'See Other',
+          304  => 'Not Modified',
+          305  => 'Use Proxy',
+          306  => 'Reserved',
+          307  => 'Temporary Redirect',
+          400  => 'Bad Request',
+          401  => 'Unauthorized',
+          402  => 'Payment Required',
+          403  => 'Forbidden',
+          404  => 'Not Found',
+          405  => 'Method Not Allowed',
+          406  => 'Not Acceptable',
+          407  => 'Proxy Authentication Required',
+          408  => 'Request Timeout',
+          409  => 'Conflict',
+          410  => 'Gone',
+          411  => 'Length Required',
+          412  => 'Precondition Failed',
+          413  => 'Request Entity Too Large',
+          414  => 'Request-URI Too Long',
+          415  => 'Unsupported Media Type',
+          416  => 'Requested Range Not Satisfiable',
+          417  => 'Expectation Failed',
+          418  => "I'm a Teapot",
+          422  => 'Unprocessable Entity',
+          423  => 'Locked',
+          424  => 'Failed Dependency',
+          426  => 'Upgrade Required',
+          500  => 'Internal Server Error',
+          501  => 'Not Implemented',
+          502  => 'Bad Gateway',
+          503  => 'Service Unavailable',
+          504  => 'Gateway Timeout',
+          505  => 'HTTP Version Not Supported',
+          506  => 'Variant Also Negotiates',
+          507  => 'Insufficient Storage',
+          510  => 'Not Extended',
+        }
+      end
+    end
+  end
+end

data/lib/rapns/daemon/gcm/delivery_handler.rb

@@ -0,0 +1,20 @@
+module Rapns
+  module Daemon
+    module Gcm
+      class DeliveryHandler < Rapns::Daemon::DeliveryHandler
+        def initialize(app)
+          @app = app
+          @http = Net::HTTP::Persistent.new('rapns')
+        end
+
+        def deliver(notification)
+          Rapns::Daemon::Gcm::Delivery.perform(@app, @http, notification)
+        end
+
+        def stopped
+          @http.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/rapns/daemon.rb

@@ -3,18 +3,28 @@ require 'socket'
 require 'pathname'
 require 'openssl'
 
+require 'net/http/persistent'
+
 require 'rapns/daemon/interruptible_sleep'
 require 'rapns/daemon/delivery_error'
-require 'rapns/daemon/disconnection_error'
-require 'rapns/daemon/connection'
 require 'rapns/daemon/database_reconnectable'
+require 'rapns/daemon/delivery'
 require 'rapns/daemon/delivery_queue'
-require 'rapns/daemon/delivery_handler'
-require 'rapns/daemon/delivery_handler_pool'
-require 'rapns/daemon/feedback_receiver'
-require 'rapns/daemon/app_runner'
 require 'rapns/daemon/feeder'
 require 'rapns/daemon/logger'
+require 'rapns/daemon/app_runner'
+require 'rapns/daemon/delivery_handler'
+
+require 'rapns/daemon/apns/delivery'
+require 'rapns/daemon/apns/disconnection_error'
+require 'rapns/daemon/apns/connection'
+require 'rapns/daemon/apns/app_runner'
+require 'rapns/daemon/apns/delivery_handler'
+require 'rapns/daemon/apns/feedback_receiver'
+
+require 'rapns/daemon/gcm/delivery'
+require 'rapns/daemon/gcm/app_runner'
+require 'rapns/daemon/gcm/delivery_handler'
 
 module Rapns
   module Daemon
@@ -90,19 +100,6 @@ module Rapns
       delete_pid_file
     end
 
-    def self.daemonize
-      exit if pid = fork
-      Process.setsid
-      exit if pid = fork
-
-      Dir.chdir '/'
-      File.umask 0000
-
-      STDIN.reopen '/dev/null'
-      STDOUT.reopen '/dev/null', 'a'
-      STDERR.reopen STDOUT
-    end
-
     def self.write_pid_file
       if !config.pid_file.blank?
         begin
@@ -117,5 +114,19 @@ module Rapns
       pid_file = config.pid_file
       File.delete(pid_file) if !pid_file.blank? && File.exists?(pid_file)
     end
+
+    # :nocov:
+    def self.daemonize
+      exit if pid = fork
+      Process.setsid
+      exit if pid = fork
+
+      Dir.chdir '/'
+      File.umask 0000
+
+      STDIN.reopen '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen STDOUT
+    end
   end
-end
+end

data/lib/rapns/gcm/app.rb

@@ -0,0 +1,7 @@
+module Rapns
+  module Gcm
+    class App < Rapns::App
+      validates :auth_key, :presence => true
+    end
+  end
+end

data/lib/rapns/gcm/expiry_collapse_key_mutual_inclusion_validator.rb

@@ -0,0 +1,11 @@
+module Rapns
+  module Gcm
+    class ExpiryCollapseKeyMutualInclusionValidator < ActiveModel::Validator
+      def validate(record)
+        if record.collapse_key && !record.expiry
+          record.errors[:expiry] << "must be set when using a collapse_key"
+        end
+      end
+    end
+  end
+end

data/lib/rapns/gcm/notification.rb

@@ -0,0 +1,31 @@
+module Rapns
+  module Gcm
+    class Notification < Rapns::Notification
+      validates :registration_ids, :presence => true
+      validates_with Rapns::Gcm::ExpiryCollapseKeyMutualInclusionValidator
+      validates_with Rapns::Gcm::PayloadSizeValidator
+
+      def registration_ids=(ids)
+        ids = [ids] if ids && !ids.is_a?(Array)
+        super
+      end
+
+      def as_json
+        json = {
+          'registration_ids' => registration_ids,
+          'delay_while_idle' => delay_while_idle,
+          'data' => data
+        }
+
+        if collapse_key
+          json.merge!({
+            'collapse_key' => collapse_key,
+            'time_to_live' => expiry
+          })
+        end
+
+        json
+      end
+    end
+  end
+end

data/lib/rapns/gcm/payload_size_validator.rb

@@ -0,0 +1,13 @@
+module Rapns
+  module Gcm
+    class PayloadSizeValidator < ActiveModel::Validator
+      LIMIT = 4096
+
+      def validate(record)
+        if record.payload_size > LIMIT
+          record.errors[:base] << "GCM notification payload cannot be larger than #{LIMIT} bytes."
+        end
+      end
+    end
+  end
+end

data/lib/rapns/multi_json_helper.rb

@@ -0,0 +1,16 @@
+module Rapns
+  module MultiJsonHelper
+    def multi_json_load(string, options = {})
+      # Calling load on multi_json less than v1.3.0 attempts to load a file from disk.
+      if Gem.loaded_specs['multi_json'].version >= Gem::Version.create('1.3.0')
+        MultiJson.load(string, options)
+      else
+        MultiJson.decode(string, options)
+      end
+    end
+
+    def multi_json_dump(string, options = {})
+      MultiJson.respond_to?(:dump) ? MultiJson.dump(string, options) : MultiJson.encode(string, options)
+    end
+  end
+end

data/lib/rapns/notification.rb

@@ -1,90 +1,46 @@
 module Rapns
   class Notification < ActiveRecord::Base
-    self.table_name = 'rapns_notifications'
+    include Rapns::MultiJsonHelper
 
-    attr_accessible :badge, :device_token, :sound, :alert, :attributes_for_device, :expiry,:delivered,
-      :delivered_at, :failed, :failed_at, :error_code, :error_description, :deliver_after, :alert_is_json, :app
+    self.table_name = 'rapns_notifications'
 
-    validates :app, :presence => true
-    validates :device_token, :presence => true
-    validates :badge, :numericality => true, :allow_nil => true
-    validates :expiry, :numericality => true, :presence => true
+    # TODO: Dump using multi json.
+    serialize :registration_ids
 
-    validates_with Rapns::DeviceTokenFormatValidator
-    validates_with Rapns::BinaryNotificationValidator
+    belongs_to :app, :class_name => 'Rapns::App'
 
-    scope :ready_for_delivery, lambda { where('delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)', false, false, Time.now) }
+    attr_accessible :badge, :device_token, :sound, :alert, :data, :expiry,:delivered,
+      :delivered_at, :failed, :failed_at, :error_code, :error_description, :deliver_after,
+      :alert_is_json, :app, :app_id, :collapse_key, :delay_while_idle, :registration_ids
 
-    def device_token=(token)
-      write_attribute(:device_token, token.delete(" <>")) if !token.nil?
-    end
+    validates :expiry, :numericality => true, :allow_nil => true
+    validates :app, :presence => true
 
-    def alert=(alert)
-      if alert.is_a?(Hash)
-        write_attribute(:alert, multi_json_dump(alert))
-        self.alert_is_json = true if has_attribute?(:alert_is_json)
-      else
-        write_attribute(:alert, alert)
-        self.alert_is_json = false if has_attribute?(:alert_is_json)
-      end
-    end
+    scope :ready_for_delivery, lambda {
+      where('delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)',
+            false, false, Time.now)
+    }
 
-    def alert
-      string_or_json = read_attribute(:alert)
+    scope :for_apps, lambda { |apps|
+      where(:app_id => apps.map(&:id))
+    }
 
-      if has_attribute?(:alert_is_json)
-        if alert_is_json?
-          multi_json_load(string_or_json)
-        else
-          string_or_json
-        end
-      else
-        multi_json_load(string_or_json) rescue string_or_json
+    def initialize(attributes = nil, options = {})
+      if attributes.is_a?(Hash) && attributes.keys.include?(:attributes_for_device)
+        msg = ":attributes_for_device via mass-assignment is deprecated. Use :data or the attributes_for_device= instance method."
+        ActiveSupport::Deprecation.warn(msg, caller(1))
       end
+      super
     end
 
-    def attributes_for_device=(attrs)
-      raise ArgumentError, "attributes_for_device must be a Hash" if !attrs.is_a?(Hash)
-      write_attribute(:attributes_for_device, multi_json_dump(attrs))
+    def data=(attrs)
+      return unless attrs
+      raise ArgumentError, "must be a Hash" if !attrs.is_a?(Hash)
+      write_attribute(:data, multi_json_dump(attrs))
     end
 
-    def attributes_for_device
-      multi_json_load(read_attribute(:attributes_for_device)) if read_attribute(:attributes_for_device)
-    end
-
-    MDM_KEY = '__rapns_mdm__'
-    def mdm=(magic)
-      self.attributes_for_device = { MDM_KEY => magic }
-    end
-
-    CONTENT_AVAILABLE_KEY = '__rapns_content_available__'
-    def content_available=(bool)
-      return unless bool
-      self.attributes_for_device = { CONTENT_AVAILABLE_KEY => true }
-    end
-
-    def as_json
-      json = ActiveSupport::OrderedHash.new
-
-      if attributes_for_device && attributes_for_device.key?(MDM_KEY)
-        json['mdm'] = attributes_for_device[MDM_KEY]
-      else
-        json['aps'] = ActiveSupport::OrderedHash.new
-        json['aps']['alert'] = alert if alert
-        json['aps']['badge'] = badge if badge
-        json['aps']['sound'] = sound if sound
-
-        if attributes_for_device && attributes_for_device[CONTENT_AVAILABLE_KEY]
-          json['aps']['content-available'] = 1
-        end
-
-        if attributes_for_device
-          non_aps_attributes = attributes_for_device.reject { |k, v| k == CONTENT_AVAILABLE_KEY }
-          non_aps_attributes.each { |k, v| json[k.to_s] = v.to_s }
-        end
-      end
-
-      json
+    def data
+      multi_json_load(read_attribute(:data)) if read_attribute(:data)
     end
 
     def payload
@@ -94,28 +50,5 @@ module Rapns
     def payload_size
       payload.bytesize
     end
-
-    # This method conforms to the enhanced binary format.
-    # http://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingWIthAPS/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4
-    def to_binary(options = {})
-      id_for_pack = options[:for_validation] ? 0 : id
-      [1, id_for_pack, expiry, 0, 32, device_token, payload_size, payload].pack("cNNccH*na*")
-    end
-
-
-    private
-
-    def multi_json_load(string, options = {})
-      # Calling load on multi_json less than v1.3.0 attempts to load a file from disk. Check the version explicitly.
-      if Gem.loaded_specs['multi_json'].version >= Gem::Version.create('1.3.0')
-        MultiJson.load(string, options)
-      else
-        MultiJson.decode(string, options)
-      end
-    end
-
-    def multi_json_dump(string, options = {})
-      MultiJson.respond_to?(:dump) ? MultiJson.dump(string, options) : MultiJson.encode(string, options)
-    end
   end
 end

data/lib/rapns/version.rb

@@ -1,3 +1,3 @@
 module Rapns
-  VERSION = '2.0.5'
+  VERSION = '3.0.0.beta.1'
 end

data/lib/rapns.rb

@@ -2,9 +2,19 @@ require 'active_record'
 require 'multi_json'
 
 require 'rapns/version'
-require 'rapns/binary_notification_validator'
-require 'rapns/device_token_format_validator'
+require 'rapns/multi_json_helper'
 require 'rapns/notification'
-require 'rapns/feedback'
 require 'rapns/app'
-require 'rapns/config'
+require 'rapns/configuration'
+
+require 'rapns/apns/binary_notification_validator'
+require 'rapns/apns/device_token_format_validator'
+require 'rapns/apns/notification'
+require 'rapns/apns/feedback'
+require 'rapns/apns/app'
+
+require 'rapns/gcm/expiry_collapse_key_mutual_inclusion_validator'
+require 'rapns/gcm/payload_size_validator'
+require 'rapns/gcm/notification'
+require 'rapns/gcm/app'
+

data/lib/tasks/cane.rake

@@ -0,0 +1,19 @@
+begin
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 97
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 15
+    cane.abc_exclude = %w(Rapns::Daemon::Gcm::Delivery#handle_errors)
+  end
+
+  namespace :spec do
+    task :cane => ['spec', 'quality']
+  end
+rescue LoadError
+  warn "cane not available, quality task not provided."
+end

data/lib/tasks/test.rake

@@ -0,0 +1,34 @@
+namespace :test do
+  task :build_rails do
+    require 'fileutils'
+
+    def cmd(str)
+      puts "* #{str}"
+      retval = Bundler.with_clean_env { `#{str}` }
+      puts retval.strip
+      retval
+    end
+
+    rapns_root = Dir.pwd
+    path = '/tmp/rails_test'
+    cmd("rm -rf #{path}")
+    FileUtils.mkdir_p(path)
+    pwd = Dir.pwd
+
+    cmd("bundle exec rails new #{path} --skip-bundle")
+    branch = cmd("git branch | grep '\*'").split(' ').last
+
+    begin
+      Dir.chdir(path)
+      cmd('echo "gem \'rake\'" >> Gemfile')
+      cmd("echo \"gem 'rapns', :git => '#{rapns_root}', :branch => '#{branch}'\" >> Gemfile")
+      cmd('bundle install')
+      cmd('bundle exec rails g rapns')
+      cmd('bundle exec rake db:migrate')
+    ensure
+      Dir.chdir(pwd)
+    end
+
+    puts "Built into #{path}"
+  end
+end

data/spec/acceptance/gcm_upgrade_spec.rb

@@ -0,0 +1,34 @@
+require 'acceptance_spec_helper'
+
+describe 'GCM upgrade' do
+  before do
+    setup_rails
+    generate
+    migrate('create_rapns_notifications', 'create_rapns_feedback',
+      'add_alert_is_json_to_rapns_notifications', 'add_app_to_rapns',
+      'create_rapns_apps')
+
+    as_test_rails_db do
+      now = Time.now.to_s(:db)
+      ActiveRecord::Base.connection.execute <<-SQL
+        INSERT INTO rapns_apps (key, environment, certificate, created_at, updated_at)
+          VALUES ('test', 'development', 'c3rt', '#{now}', '#{now}')
+      SQL
+
+      ActiveRecord::Base.connection.execute <<-SQL
+        INSERT INTO rapns_notifications (app, device_token, created_at, updated_at)
+          VALUES ('test', 't0k3n', '#{now}', '#{now}')
+      SQL
+    end
+
+    migrate('add_gcm')
+  end
+
+  it 'associates apps and notifications' do
+    as_test_rails_db do
+      app = Rapns::Apns::App.first
+      app.name.should == 'test'
+      app.notifications.count.should == 1
+    end
+  end
+end