rpush 1.0.0 → 2.0.0.beta1

data/lib/rpush/TODO

@@ -1,3 +0,0 @@
-* Should internal errors mark a notification as failed?
-* Check cert expiry when connected.
-* Lazy connect on socket write? - would allow to catch initial expiry error and mark on notification.

data/lib/rpush/adm/app.rb

@@ -1,15 +0,0 @@
-module Rpush
-  module Adm
-    class App < Rpush::App
-      validates :client_id, :client_secret, :presence => true
-
-      def access_token_expired?
-        self.access_token_expiration.nil? || self.access_token_expiration < Time.now
-      end
-
-      def service_name
-        'adm'
-      end
-    end
-  end
-end

data/lib/rpush/adm/data_validator.rb

@@ -1,11 +0,0 @@
-module Rpush
-  module Adm
-    class DataValidator < ActiveModel::Validator
-      def validate(record)
-        if record.collapse_key.nil? && record.data.nil?
-          record.errors[:data] << "must be set unless collapse_key is specified"
-        end
-      end
-    end
-  end
-end

data/lib/rpush/adm/notification.rb

@@ -1,29 +0,0 @@
-module Rpush
-  module Adm
-    class Notification < Rpush::Notification
-      validates :registration_ids, :presence => true
-
-      validates_with Rpush::PayloadDataSizeValidator, limit: 6144
-      validates_with Rpush::RegistrationIdsCountValidator, limit: 100
-
-      validates_with Rpush::Adm::DataValidator
-
-      def as_json
-        json = {
-          'data' => data
-        }
-
-        if collapse_key
-          json['consolidationKey'] = collapse_key
-        end
-
-        # number of seconds before message is expired
-        if expiry
-          json['expiresAfter'] = expiry
-        end
-
-        json
-      end
-    end
-  end
-end

data/lib/rpush/apns/app.rb

@@ -1,29 +0,0 @@
-module Rpush
-  module Apns
-    class App < Rpush::App
-      validates :environment, :presence => true, :inclusion => { :in => %w(development production sandbox) }
-      validates :certificate, :presence => true
-      validate :certificate_has_matching_private_key
-
-      def service_name
-        'apns'
-      end
-
-      private
-
-      def certificate_has_matching_private_key
-        result = false
-        if certificate.present?
-          begin
-            x509 = OpenSSL::X509::Certificate.new(certificate)
-            pkey = OpenSSL::PKey::RSA.new(certificate, password)
-            result = !x509.nil? && !pkey.nil?
-          rescue OpenSSL::OpenSSLError
-            errors.add :certificate, 'Certificate value must contain a certificate and a private key.'
-          end
-        end
-        result
-      end
-    end
-  end
-end

data/lib/rpush/apns/binary_notification_validator.rb

@@ -1,12 +0,0 @@
-module Rpush
-  module Apns
-    class BinaryNotificationValidator < ActiveModel::Validator
-
-      def validate(record)
-        if record.payload_size > 256
-          record.errors[:base] << "APN notification cannot be larger than 256 bytes. Try condensing your alert and device attributes."
-        end
-      end
-    end
-  end
-end

data/lib/rpush/apns/device_token_format_validator.rb

@@ -1,12 +0,0 @@
-module Rpush
-  module Apns
-    class DeviceTokenFormatValidator < ActiveModel::Validator
-
-      def validate(record)
-        if record.device_token !~ /^[a-z0-9]{64}$/i
-          record.errors[:device_token] << "is invalid"
-        end
-      end
-    end
-  end
-end

data/lib/rpush/apns/feedback.rb

@@ -1,16 +0,0 @@
-module Rpush
-  module Apns
-    class Feedback < ActiveRecord::Base
-      self.table_name = 'rpush_feedback'
-
-      if Rpush.attr_accessible_available?
-        attr_accessible :device_token, :failed_at, :app
-      end
-
-      validates :device_token, :presence => true
-      validates :failed_at, :presence => true
-
-      validates_with Rpush::Apns::DeviceTokenFormatValidator
-    end
-  end
-end

data/lib/rpush/apns/notification.rb

@@ -1,84 +0,0 @@
-module Rpush
-  module Apns
-    class Notification < Rpush::Notification
-      class MultipleAppAssignmentError < StandardError; end
-
-      validates :device_token, :presence => true
-      validates :badge, :numericality => true, :allow_nil => true
-
-      validates_with Rpush::Apns::DeviceTokenFormatValidator
-      validates_with Rpush::Apns::BinaryNotificationValidator
-
-      alias_method :attributes_for_device=, :data=
-      alias_method :attributes_for_device, :data
-
-      def device_token=(token)
-        write_attribute(:device_token, token.delete(" <>")) if !token.nil?
-      end
-
-      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
-
-      def alert
-        string_or_json = read_attribute(:alert)
-
-        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
-        end
-      end
-
-      MDM_KEY = '__rpush_mdm__'
-      def mdm=(magic)
-        self.attributes_for_device = (attributes_for_device || {}).merge({ MDM_KEY => magic })
-      end
-
-      CONTENT_AVAILABLE_KEY = '__rpush_content_available__'
-      def content_available=(bool)
-        return unless bool
-        self.attributes_for_device = (attributes_for_device || {}).merge({ 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 }
-          end
-        end
-
-        json
-      end
-
-      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
-    end
-  end
-end

data/lib/rpush/app.rb

@@ -1,18 +0,0 @@
-module Rpush
-  class App < ActiveRecord::Base
-    self.table_name = 'rpush_apps'
-
-    if Rpush.attr_accessible_available?
-      attr_accessible :name, :environment, :certificate, :password, :connections, :auth_key, :client_id, :client_secret
-    end
-
-    has_many :notifications, :class_name => 'Rpush::Notification', :dependent => :destroy
-
-    validates :name, :presence => true, :uniqueness => { :scope => [:type, :environment] }
-    validates_numericality_of :connections, :greater_than => 0, :only_integer => true
-
-    def service_name
-      raise NotImplementedError
-    end
-  end
-end

data/lib/rpush/daemon/apns/certificate_expired_error.rb

@@ -1,20 +0,0 @@
-module Rpush
-  module Apns
-    class CertificateExpiredError < StandardError
-      attr_reader :app, :time
-
-      def initialize(app, time)
-        @app = app
-        @time = time
-      end
-
-      def to_s
-        message
-      end
-
-      def message
-        "#{app.name} certificate expired at #{time}."
-      end
-    end
-  end
-end

data/lib/rpush/daemon/apns/disconnection_error.rb

@@ -1,20 +0,0 @@
-module Rpush
-  module Apns
-    class DisconnectionError < StandardError
-      attr_reader :code, :description
-
-      def initialize
-        @code = nil
-        @description = "APNs disconnected without returning an error."
-      end
-
-      def to_s
-        message
-      end
-
-      def message
-        "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host."
-      end
-    end
-  end
-end

data/lib/rpush/gcm/app.rb

@@ -1,11 +0,0 @@
-module Rpush
-  module Gcm
-    class App < Rpush::App
-      validates :auth_key, :presence => true
-
-      def service_name
-        'gcm'
-      end
-    end
-  end
-end

data/lib/rpush/gcm/expiry_collapse_key_mutual_inclusion_validator.rb

@@ -1,11 +0,0 @@
-module Rpush
-  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/rpush/gcm/notification.rb

@@ -1,30 +0,0 @@
-module Rpush
-  module Gcm
-    class Notification < Rpush::Notification
-      validates :registration_ids, :presence => true
-
-      validates_with Rpush::PayloadDataSizeValidator, limit: 4096
-      validates_with Rpush::RegistrationIdsCountValidator, limit: 1000
-
-      validates_with Rpush::Gcm::ExpiryCollapseKeyMutualInclusionValidator
-
-      def as_json
-        json = {
-          'registration_ids' => registration_ids,
-          'delay_while_idle' => delay_while_idle,
-          'data' => data
-        }
-
-        if collapse_key
-          json['collapse_key'] = collapse_key
-        end
-
-        if expiry
-          json['time_to_live'] = expiry
-        end
-
-        json
-      end
-    end
-  end
-end

data/lib/rpush/notification.rb

@@ -1,69 +0,0 @@
-module Rpush
-  class Notification < ActiveRecord::Base
-    include Rpush::MultiJsonHelper
-
-    self.table_name = 'rpush_notifications'
-
-    # TODO: Dump using multi json.
-    serialize :registration_ids
-
-    belongs_to :app, :class_name => 'Rpush::App'
-
-    if Rpush.attr_accessible_available?
-      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, :uri
-    end
-
-    validates :expiry, :numericality => true, :allow_nil => true
-    validates :app, :presence => true
-
-    scope :ready_for_delivery, lambda {
-      where('delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)',
-            false, false, Time.now)
-    }
-
-    scope :for_apps, lambda { |apps|
-      where('app_id IN (?)', apps.map(&:id))
-    }
-
-    scope :completed, lambda { where("delivered = ? OR failed = ?", true, true) }
-
-    def data=(attrs)
-      return unless attrs
-      raise ArgumentError, "must be a Hash" if !attrs.is_a?(Hash)
-      write_attribute(:data, multi_json_dump(attrs.merge(data || {})))
-    end
-
-    def registration_ids=(ids)
-      ids = [ids] if ids && !ids.is_a?(Array)
-      super
-    end
-
-    def data
-      multi_json_load(read_attribute(:data)) if read_attribute(:data)
-    end
-
-    def payload
-      multi_json_dump(as_json)
-    end
-
-    def payload_size
-      payload.bytesize
-    end
-
-    def payload_data_size
-      multi_json_dump(as_json['data']).bytesize
-    end
-
-    class << self
-      def created_before(dt)
-        where("created_at < ?", dt)
-      end
-
-      def completed_and_older_than(dt)
-        completed.created_before(dt)
-      end
-    end
-  end
-end

data/lib/rpush/notifier.rb

@@ -1,52 +0,0 @@
-require 'socket'
-
-module Rpush
-  # This class notifies the sleeping Rpush Daemon that there are new Notifications to send,
-  # and to interrupt its sleep to send them immediately. The purpose of this is to allow
-  # much higher sleep times to reduce database polling activity.
-  class Notifier
-    def initialize(host, port)
-      @host, @port = host, port
-    end
-
-    # notify the daemon that there is a Notification to send.
-    def notify
-      socket.write('x')
-    end
-
-    # @return [UDPSocket]
-    def socket
-      if @socket.nil?
-        @socket = UDPSocket.new
-        @socket.connect(@host, @port)
-      end
-      @socket
-    end
-
-    # close the udp socket
-    def close
-      if @socket
-        @socket.close
-        @socket = nil
-      end
-    end
-
-  end
-
-  # Call this from a client application after saving a Notification to the database to wakeup the Rpush
-  # Daemon to deliver the notification immediately.
-  def self.wakeup
-    notifier.notify
-  end
-
-  # Default notifier instance. This uses the :connect, :port values in Rpush.config.wakeup to connect to the
-  # wakeup socket in the Rpush Daemon. It will fall back to :host, :port if :connect is not specified.
-  def self.notifier
-    unless @notifier
-      if Rpush.config.wakeup
-        @notifier = Notifier.new(Rpush.config.wakeup[:connect] || Rpush.config.wakeup[:host], Rpush.config.wakeup[:port])
-      end
-    end
-    @notifier
-  end
-end