rpush 2.2.0 → 2.3.0.rc1

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

@@ -17,6 +17,9 @@ module Rpush
 
         def perform
           handle_response(do_post)
+        rescue SocketError => error
+          mark_retryable(@notification, Time.now + 10.seconds, error)
+          raise
         rescue StandardError => error
           mark_failed(error)
           raise
@@ -77,7 +80,7 @@ module Rpush
         end
 
         def retry_message
-          "Notification #{@notification.id} will be retried after #{@notification.deliver_after.strftime("%Y-%m-%d %H:%M:%S")} (retry #{@notification.retries})."
+          "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)
@@ -106,16 +109,22 @@ module Rpush
         end
 
         def notification_to_xml
-          msg = @notification.alert.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+          title = clean_param_string(@notification.data['title']) if @notification.data['title'].present?
+          body = clean_param_string(@notification.data['body']) if @notification.data['body'].present?
+          param = clean_param_string(@notification.data['param']) if @notification.data['param'].present?
+          "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+           <wp:Notification xmlns:wp=\"WPNotification\">
+             <wp:Toast>
+               <wp:Text1>#{title}</wp:Text1>
+               <wp:Text2>#{body}</wp:Text2>
+               <wp:Param>#{param}</wp:Param>
+             </wp:Toast>
+           </wp:Notification>"
+        end
+
+        def clean_param_string(string)
+          string.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

data/lib/rpush/logger.rb

@@ -1,12 +1,15 @@
 module Rpush
   class Logger
+    attr_reader :internal_logger
+
     def initialize
-      FileUtils.mkdir_p(File.dirname(Rpush.config.log_file))
-      log = File.open(Rpush.config.log_file, 'a')
-      log.sync = true
-      setup_logger(log)
+      if Rpush.config.logger
+        @internal_logger = Rpush.config.logger
+      else
+        @internal_logger = setup_logger(open_logfile)
+      end
     rescue Errno::ENOENT, Errno::EPERM => e
-      @logger = nil
+      @internal_logger = nil
       error(e)
       error('Logging disabled.')
     end
@@ -23,16 +26,31 @@ module Rpush
       log(:warn, msg, inline, 'WARNING', STDERR)
     end
 
+    def reopen
+      if Rpush.config.logger
+        Rpush.config.logger.reopen if Rpush.config.logger.respond_to?(:reopen)
+      else
+        @internal_logger.close
+        @internal_logger = setup_logger(open_logfile)
+      end
+    end
+
     private
 
+    def open_logfile
+      FileUtils.mkdir_p(File.dirname(Rpush.config.log_file))
+      log = File.open(Rpush.config.log_file, 'a')
+      log.sync = true
+      log
+    end
+
     def setup_logger(log)
-      if Rpush.config.logger
-        @logger = Rpush.config.logger
-      elsif ActiveSupport.const_defined?('BufferedLogger')
-        @logger = ActiveSupport::BufferedLogger.new(log, Rpush.config.log_level)
-        @logger.auto_flushing = auto_flushing
+      if ActiveSupport.const_defined?('BufferedLogger')
+        logger = ActiveSupport::BufferedLogger.new(log, Rpush.config.log_level)
+        logger.auto_flushing = auto_flushing
+        logger
       else
-        @logger = ActiveSupport::Logger.new(log, Rpush.config.log_level)
+        ActiveSupport::Logger.new(log, Rpush.config.log_level)
       end
     end
 
@@ -55,7 +73,7 @@ module Rpush
       formatted_msg << msg
 
       log_foreground(io, formatted_msg, inline)
-      @logger.send(where, formatted_msg) if @logger
+      @internal_logger.send(where, formatted_msg) if @internal_logger
     end
 
     def log_foreground(io, formatted_msg, inline)

data/lib/rpush/plugin.rb

@@ -0,0 +1,44 @@
+module Rpush
+  def self.plugin(name)
+    plugins[name] ||= Rpush::Plugin.new(name)
+    plugins[name]
+  end
+
+  def self.plugins
+    @plugins ||= {}
+  end
+
+  class Plugin
+    attr_reader :name, :config, :init_block
+    attr_accessor :url, :description
+
+    def initialize(name)
+      @name = name
+      @url = nil
+      @description = nil
+      @config = OpenStruct.new
+      @reflection_collection = Rpush::ReflectionCollection.new
+      @init_block = -> {}
+    end
+
+    def reflect
+      yield(@reflection_collection)
+      return if Rpush.reflection_stack.include?(@reflection_collection)
+      Rpush.reflection_stack << @reflection_collection
+    end
+
+    def configure
+      yield(@config)
+      Rpush.config.plugin.send("#{@name}=", @config)
+    end
+
+    def init(&block) # rubocop:disable Style/TrivialAccessors
+      @init_block = block
+    end
+
+    def unload
+      Rpush.reflection_stack.delete(@reflection_collection)
+      Rpush.config.plugin.send("#{name}=", nil)
+    end
+  end
+end

data/lib/rpush/push.rb

@@ -7,7 +7,7 @@ module Rpush
     config.push = true
     Rpush.config.update(config)
 
-    Rpush::Daemon.initialize_store
+    Rpush::Daemon.common_init
     Rpush::Daemon::Synchronizer.sync
     Rpush::Daemon::Feeder.start
     # TODO: Wait until there are no more notifications.

data/lib/rpush/reflectable.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Reflectable
+    def reflect(name, *args)
+      Rpush.reflection_stack.each do |reflection_collection|
+        reflection_collection.__dispatch(name, *args)
+      end
+    rescue StandardError => e
+      Rpush.logger.error(e)
+    end
+  end
+end

data/lib/rpush/{reflection.rb → reflection_collection.rb}

@@ -1,13 +1,5 @@
 module Rpush
-  def self.reflect
-    yield reflections if block_given?
-  end
-
-  def self.reflections
-    @reflections ||= Reflections.new
-  end
-
-  class Reflections
+  class ReflectionCollection
     class NoSuchReflectionError < StandardError; end
 
     REFLECTIONS = [

data/lib/rpush/reflection_public_methods.rb

@@ -0,0 +1,9 @@
+module Rpush
+  def self.reflect
+    yield reflection_stack[0] if block_given?
+  end
+
+  def self.reflection_stack
+    @reflection_stack ||= [ReflectionCollection.new]
+  end
+end

data/lib/rpush/version.rb

@@ -1,3 +1,3 @@
 module Rpush
-  VERSION = '2.2.0'
+  VERSION = '2.3.0.rc1'
 end

data/lib/tasks/test.rake

@@ -7,6 +7,7 @@ def cmd(str, clean_env = true)
   retval
 end
 
+desc 'Build Rails app bundled with Rpush'
 task :build_rails do
   rpush_root = Dir.pwd
   path = '/tmp/rpush/rails_test'
@@ -27,10 +28,10 @@ task :build_rails do
     File.open('config/database.yml', 'w') do |fd|
       fd.write(<<-YML)
 development:
-adapter: postgresql
-database: rpush_rails_test
-pool: 5
-timeout: 5000
+  adapter: postgresql
+  database: rpush_rails_test
+  pool: 5
+  timeout: 5000
       YML
     end
   ensure
@@ -40,6 +41,7 @@ timeout: 5000
   puts "Built into #{path}"
 end
 
+desc 'Build blank app bundled with Rpush'
 task :build_standalone do
   rpush_root = Dir.pwd
   path = '/tmp/rpush/standalone_test'

data/spec/functional/adm_spec.rb

@@ -5,6 +5,9 @@ describe 'ADM' do
   let(:notification) { Rpush::Adm::Notification.new }
   let(:response) { double(Net::HTTPResponse, code: 200) }
   let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
+  let(:delivered_ids) { [] }
+  let(:failed_ids) { [] }
+  let(:retry_ids) { [] }
 
   before do
     app.name = 'test'
@@ -37,4 +40,13 @@ describe 'ADM' do
       notification.reload
     end.to_not change(notification, :delivered).to(true)
   end
+
+  it 'retries notification that fail due to a SocketError' do
+    expect(http).to receive(:request).and_raise(SocketError.new)
+    expect(notification.deliver_after).to be_nil
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :deliver_after).to(kind_of(Time))
+  end
 end

data/spec/functional/apns_spec.rb

@@ -1,14 +1,16 @@
 require 'functional_spec_helper'
 
 describe 'APNs' do
-  let(:timeout) { 10 }
   let(:app) { create_app }
-  let!(:notification) { create_notification }
   let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
   let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
   let(:io_double) { double(select: nil) }
+  let(:delivered_ids) { [] }
+  let(:failed_ids) { [] }
+  let(:retry_ids) { [] }
 
   before do
+    Rpush.config.push_poll = 0.5
     stub_tcp_connection
   end
 
@@ -36,31 +38,20 @@ describe 'APNs' do
     stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
   end
 
+  def wait
+    sleep 0.1
+  end
+
   def wait_for_notification_to_deliver(notification)
-    Timeout.timeout(timeout) do
-      until notification.delivered
-        sleep 0.1
-        notification.reload
-      end
-    end
+    timeout { wait until delivered_ids.include?(notification.id) }
   end
 
   def wait_for_notification_to_fail(notification)
-    Timeout.timeout(timeout) do
-      while notification.delivered
-        sleep 0.1
-        notification.reload
-      end
-    end
+    timeout { wait until failed_ids.include?(notification.id) }
   end
 
   def wait_for_notification_to_retry(notification)
-    Timeout.timeout(timeout) do
-      until !notification.delivered && !notification.failed && !notification.deliver_after.nil?
-        sleep 0.1
-        notification.reload
-      end
-    end
+    timeout { wait until retry_ids.include?(notification.id) }
   end
 
   def fail_notification(notification)
@@ -79,7 +70,12 @@ describe 'APNs' do
     end
   end
 
+  def timeout(&blk)
+    Timeout.timeout(10, &blk)
+  end
+
   it 'delivers a notification successfully' do
+    notification = create_notification
     expect do
       Rpush.push
       notification.reload
@@ -87,6 +83,7 @@ describe 'APNs' do
   end
 
   it 'receives feedback' do
+    app
     tuple = "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
     allow(ssl_socket).to receive(:read).and_return(tuple, nil)
     Rpush.apns_feedback
@@ -97,21 +94,57 @@ describe 'APNs' do
   end
 
   describe 'delivery failures' do
-    before { Rpush.embed }
-    after { Timeout.timeout(timeout) { Rpush.shutdown } }
+    before do
+      Rpush.reflect do |on|
+        on.notification_delivered do |n|
+          delivered_ids << n.id
+        end
+
+        on.notification_id_failed do |_, n_id|
+          failed_ids << n_id
+        end
+
+        on.notification_id_will_retry do |_, n_id|
+          retry_ids << n_id
+        end
+
+        on.notification_will_retry do |n|
+          retry_ids << n.id
+        end
+      end
+
+      Rpush.embed
+    end
+
+    after do
+      Rpush.reflection_stack.clear
+      Rpush.reflection_stack.push(Rpush::ReflectionCollection.new)
+
+      timeout { Rpush.shutdown }
+    end
 
     it 'fails to deliver a notification' do
+      notification = create_notification
       wait_for_notification_to_deliver(notification)
       fail_notification(notification)
       wait_for_notification_to_fail(notification)
     end
 
+    describe 'with a failed connection' do
+      it 'retries all notifications' do
+        Rpush::Daemon::TcpConnection.any_instance.stub(sleep: nil)
+        expect(ssl_socket).to receive(:write).at_least(1).times.and_raise(Errno::EPIPE)
+        notifications = 2.times.map { create_notification }
+        notifications.each { |n| wait_for_notification_to_retry(n) }
+      end
+    end
+
     describe 'with multiple notifications' do
       let(:notification1) { create_notification }
       let(:notification2) { create_notification }
       let(:notification3) { create_notification }
       let(:notification4) { create_notification }
-      let!(:notifications) { [notification1, notification2, notification3, notification4] }
+      let(:notifications) { [notification1, notification2, notification3, notification4] }
 
       it 'marks the correct notification as failed' do
         notifications.each { |n| wait_for_notification_to_deliver(n) }
@@ -124,29 +157,15 @@ describe 'APNs' do
         fail_notification(notification2)
         wait_for_notification_to_fail(notification2)
 
+        expect(failed_ids).to_not include(notification1.id)
         notification1.reload
         notification1.delivered.should be_true
       end
 
-      # Unreliable.
-      # it 'marks notifications following the failed one as retryable' do
-      #   Rpush.config.push_poll = 1_000_000
-      #
-      #   notifications.each { |n| wait_for_notification_to_deliver(n) }
-      #   fail_notification(notification2)
-      #
-      #   [notification3, notification4].each do |n|
-      #     wait_for_notification_to_retry(n)
-      #   end
-      # end
-
-      describe 'without an error response' do
-        it 'marks all notifications as failed' do
-          notifications.each { |n| wait_for_notification_to_deliver(n) }
-          ssl_socket.stub(read: nil)
-          enable_io_select
-          notifications.each { |n| wait_for_notification_to_fail(n) }
-        end
+      it 'marks notifications following the failed one as retryable' do
+        notifications.each { |n| wait_for_notification_to_deliver(n) }
+        fail_notification(notification2)
+        [notification3, notification4].each { |n| wait_for_notification_to_retry(n) }
       end
     end
   end

data/spec/functional/gcm_spec.rb

@@ -36,4 +36,13 @@ describe 'GCM' do
       notification.reload
     end.to_not change(notification, :delivered).to(true)
   end
+
+  it 'retries notification that fail due to a SocketError' do
+    expect(http).to receive(:request).and_raise(SocketError.new)
+    expect(notification.deliver_after).to be_nil
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :deliver_after).to(kind_of(Time))
+  end
 end