rpush 1.0.0

data/lib/rpush/daemon/too_many_requests_error.rb

@@ -0,0 +1,20 @@
+module Rpush
+  class TooManyRequestsError < StandardError
+    attr_reader :code, :description, :response
+
+    def initialize(code, notification_id, description, response)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+      @response = response
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Too many requests for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
+    end
+  end
+end

data/lib/rpush/daemon/wpns.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Wpns
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end

data/lib/rpush/daemon/wpns/delivery.rb

@@ -0,0 +1,132 @@
+module Rpush
+  module Daemon
+    module Wpns
+
+      # http://msdn.microsoft.com/en-us/library/windowsphone/develop/ff941100%28v=vs.105%29.aspx
+      class Delivery < Rpush::Daemon::Delivery
+
+        FAILURE_MESSAGES = {
+          400 => 'Bad XML or malformed notification URI.',
+          401 => 'Unauthorized to send a notification to this app.'
+        }
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          begin
+            handle_response(do_post)
+          rescue Rpush::DeliveryError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        private
+
+        def handle_response(response)
+          code = response.code.to_i
+          case code
+          when 200
+            ok(response)
+          when 406
+            not_acceptable(response)
+          when 412
+            precondition_failed(response)
+          when 503
+            service_unavailable(response)
+          else
+            handle_failure(code)
+          end
+        end
+
+        def handle_failure(code, msg=nil)
+          unless msg
+            msg = if FAILURE_MESSAGES.key?(code)
+              FAILURE_MESSAGES[code]
+            else
+              Rpush::Daemon::HTTP_STATUS_CODES[code]
+            end
+          end
+          raise Rpush::DeliveryError.new(code, @notification.id, msg)
+        end
+
+        def ok(response)
+          status = status_from_response(response)
+          case status[:notification]
+          when ["Received"]
+            mark_delivered
+            log_info("#{@notification.id} sent successfully")
+          when ["QueueFull"]
+            mark_retryable(@notification, Time.now + (60*10))
+            log_warn("#{@notification.id} cannot be sent. The Queue is full.")
+          when ["Suppressed"]
+            handle_failure(200, "Notification was received but suppressed by the service.")
+          end
+        end
+
+        def not_acceptable(response)
+          retry_notification("Per-day throttling limit reached.")
+        end
+
+        def precondition_failed(response)
+          retry_notification("Device unreachable.")
+        end
+
+        def service_unavailable(response)
+          mark_retryable_exponential(@notification)
+          log_warn("Service Unavailable. " + retry_message)
+        end
+
+        def retry_message
+          "Notification #{@notification.id} will be retried after #{@notification.deliver_after.strftime("%Y-%m-%d %H:%M:%S")} (retry #{@notification.retries})."
+        end
+
+        def retry_notification(reason)
+          deliver_after = Time.now + (60*60)
+          mark_retryable(@notification, deliver_after)
+          log_warn("#{reason} " + retry_message)
+        end
+
+        def do_post
+          body = notification_to_xml
+          header = {
+            "Content-Length" => body.length.to_s,
+            "Content-Type" => "text/xml",
+            "X-WindowsPhone-Target" => "toast",
+            "X-NotificationClass" => '2'
+          }
+          post = Net::HTTP::Post.new(URI.parse(@notification.uri).path, initheader=header)
+          post.body = body
+          @http.request(URI.parse(@notification.uri), post)
+        end
+
+        def status_from_response(response)
+          headers = response.to_hash
+          {
+            notification:         headers["x-notificationstatus"],
+            notification_channel: headers["x-subscriptionstatus"],
+            device_connection:    headers["x-deviceconnectionstatus"]
+          }
+        end
+
+        def notification_to_xml
+          msg = @notification.alert.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+            .gsub(/>/, "&gt;").gsub(/'/, "&apos;").gsub(/"/, "&quot;")
+          <<-EOF
+<?xml version="1.0" encoding="utf-8"?>
+<wp:Notification xmlns:wp="WPNotification">
+  <wp:Toast>
+    <wp:Text1>#{msg}</wp:Text1>
+  </wp:Toast>
+</wp:Notification>
+          EOF
+        end
+      end
+    end
+  end
+end

data/lib/rpush/deprecatable.rb

@@ -0,0 +1,23 @@
+module Rpush
+  module Deprecatable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def deprecated(method_name, version, msg=nil)
+        instance_eval do
+          alias_method "#{method_name}_without_warning", method_name
+        end
+        warning = "#{method_name} is deprecated and will be removed from Rpush #{version}."
+        warning << " #{msg}" if msg
+        class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method_name}(*args, &blk)
+            Rpush::Deprecation.warn(#{warning.inspect})
+            #{method_name}_without_warning(*args, &blk)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rpush/deprecation.rb

@@ -0,0 +1,23 @@
+module Rpush
+  class Deprecation
+    def self.muted
+      begin
+        orig_val = Thread.current[:rpush_mute_deprecations]
+        Thread.current[:rpush_mute_deprecations] = true
+        yield
+      ensure
+        Thread.current[:rpush_mute_deprecations] = orig_val
+      end
+    end
+
+    def self.muted?
+      Thread.current[:rpush_mute_deprecations] == true
+    end
+
+    def self.warn(msg)
+      unless Rpush::Deprecation.muted?
+        STDERR.puts "DEPRECATION WARNING: #{msg}"
+      end
+    end
+  end
+end

data/lib/rpush/embed.rb

@@ -0,0 +1,28 @@
+module Rpush
+  def self.embed(options = {})
+    Rpush.require_for_daemon
+
+    config = Rpush::ConfigurationWithoutDefaults.new
+    options.each { |k, v| config.send("#{k}=", v) }
+    config.embedded = true
+    Rpush.config.update(config)
+    Rpush::Daemon.start
+
+    Kernel.at_exit { shutdown }
+  end
+
+  def self.shutdown
+    return unless Rpush.config.embedded
+    Rpush::Daemon.shutdown
+  end
+
+  def self.sync
+    return unless Rpush.config.embedded
+    Rpush::Daemon::AppRunner.sync
+  end
+
+  def self.debug
+    return unless Rpush.config.embedded
+    Rpush::Daemon::AppRunner.debug
+  end
+end

data/lib/rpush/gcm/app.rb

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,30 @@
+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/logger.rb

@@ -0,0 +1,63 @@
+module Rpush
+  class Logger
+    def initialize(options)
+      @options = options
+
+      begin
+        log_dir = File.join(Rails.root, 'log')
+        FileUtils.mkdir_p(log_dir)
+        log = File.open(File.join(log_dir, 'rpush.log'), 'a')
+        log.sync = true
+        setup_logger(log)
+      rescue Errno::ENOENT, Errno::EPERM => e
+        @logger = nil
+        error(e)
+        error('Logging disabled.')
+      end
+    end
+
+    def info(msg)
+      log(:info, msg)
+    end
+
+    def error(msg)
+      log(:error, msg, 'ERROR', STDERR)
+    end
+
+    def warn(msg)
+      log(:warn, msg, 'WARNING', STDERR)
+    end
+
+    private
+
+    def setup_logger(log)
+      if Rpush.config.logger
+        @logger = Rpush.config.logger
+      elsif ActiveSupport.const_defined?('BufferedLogger')
+        @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
+        @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
+      else
+        @logger = ActiveSupport::Logger.new(log, Rails.logger.level)
+      end
+    end
+
+    def log(where, msg, prefix = nil, io = STDOUT)
+      if msg.is_a?(Exception)
+        formatted_backtrace = msg.backtrace.join("\n")
+        msg = "#{msg.class.name}, #{msg.message}\n#{formatted_backtrace}"
+      end
+
+      formatted_msg = "[#{Time.now.to_s(:db)}] "
+      formatted_msg << "[#{prefix}] " if prefix
+      formatted_msg << msg
+
+      if io == STDERR
+        io.puts formatted_msg
+      elsif @options[:foreground]
+        io.puts formatted_msg
+      end
+
+      @logger.send(where, formatted_msg) if @logger
+    end
+  end
+end

data/lib/rpush/multi_json_helper.rb

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

@@ -0,0 +1,69 @@
+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