rpush 1.0.0-java → 2.0.0-java

data/lib/rpush/push.rb

@@ -8,9 +8,8 @@ module Rpush
     Rpush.config.update(config)
 
     Rpush::Daemon.initialize_store
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::Synchronizer.sync
     Rpush::Daemon::Feeder.start
-    Rpush::Daemon::AppRunner.wait
     Rpush::Daemon::AppRunner.stop
   end
 end

data/lib/rpush/reflection.rb

@@ -12,16 +12,14 @@ module Rpush
 
     REFLECTIONS = [
       :apns_feedback, :notification_enqueued, :notification_delivered,
-      :notification_failed, :notification_will_retry, :apns_connection_lost,
-      :gcm_delivered_to_recipient, :gcm_failed_to_recipient, :gcm_canonical_id,
-      :gcm_invalid_registration_id, :error, :apns_certificate_will_expire,
-      :adm_canonical_id, :tcp_connection_lost, :ssl_certificate_will_expire
+      :notification_failed, :notification_will_retry, :gcm_delivered_to_recipient,
+      :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
+      :error, :adm_canonical_id, :adm_failed_to_recipient,
+      :tcp_connection_lost, :ssl_certificate_will_expire,
+      :notification_id_will_retry, :notification_id_failed
     ]
 
-    DEPRECATIONS = {
-      :apns_connection_lost => [:tcp_connection_lost, '4.1'],
-      :apns_certificate_will_expire => [:ssl_certificate_will_expire, '4.1']
-    }
+    DEPRECATIONS = {}
 
     REFLECTIONS.each do |reflection|
       class_eval(<<-RUBY, __FILE__, __LINE__)
@@ -36,7 +34,7 @@ module Rpush
       reflection = reflection.to_sym
 
       unless REFLECTIONS.include?(reflection)
-        raise NoSuchReflectionError, reflection
+        fail NoSuchReflectionError, reflection
       end
 
       if DEPRECATIONS.key?(reflection)
@@ -44,9 +42,7 @@ module Rpush
         Rpush::Deprecation.warn("#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.")
       end
 
-      if reflections[reflection]
-        reflections[reflection].call(*args)
-      end
+      reflections[reflection].call(*args) if reflections[reflection]
     end
 
     private

data/lib/rpush/version.rb

@@ -1,3 +1,3 @@
 module Rpush
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/rpush.rb

@@ -1,13 +1,11 @@
-require 'active_record'
 require 'multi_json'
+require 'active_support/all'
 
 module Rpush
   def self.attr_accessible_available?
     require 'rails'
-    ::Rails::VERSION::STRING < '4'
+    ::Rails::VERSION::STRING < '4' || defined?(::ActiveRecord::MassAssignmentSecurity)
   end
-
-  require 'rpush/railtie' if defined?(Rails)
 end
 
 require 'rpush/version'
@@ -15,33 +13,11 @@ require 'rpush/deprecation'
 require 'rpush/deprecatable'
 require 'rpush/logger'
 require 'rpush/multi_json_helper'
-require 'rpush/notification'
-require 'rpush/app'
 require 'rpush/configuration'
 require 'rpush/reflection'
 require 'rpush/embed'
 require 'rpush/push'
 require 'rpush/apns_feedback'
-require 'rpush/notifier'
-require 'rpush/payload_data_size_validator'
-require 'rpush/registration_ids_count_validator'
-
-require 'rpush/apns/binary_notification_validator'
-require 'rpush/apns/device_token_format_validator'
-require 'rpush/apns/notification'
-require 'rpush/apns/feedback'
-require 'rpush/apns/app'
-
-require 'rpush/gcm/expiry_collapse_key_mutual_inclusion_validator'
-require 'rpush/gcm/notification'
-require 'rpush/gcm/app'
-
-require 'rpush/wpns/notification'
-require 'rpush/wpns/app'
-
-require 'rpush/adm/data_validator'
-require 'rpush/adm/notification'
-require 'rpush/adm/app'
 
 module Rpush
   def self.jruby?
@@ -53,10 +29,10 @@ module Rpush
   end
 
   def self.logger
-    @logger ||= Logger.new(:foreground => Rpush.config.foreground)
+    @logger ||= Logger.new
   end
 
-  def self.logger=(logger)
-    @logger = logger
+  class << self
+    attr_writer :logger
   end
 end

data/lib/tasks/quality.rake

@@ -0,0 +1,35 @@
+begin
+  require 'cane/rake_task'
+
+  desc 'Run cane to check quality metrics'
+  Cane::RakeTask.new(:cane_quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 95
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 20
+  end
+
+  namespace :spec do
+    task cane: %w(spec cane_quality)
+  end
+rescue LoadError
+  warn "cane not available."
+
+  namespace :spec do
+    task cane: ['spec']
+  end
+end
+
+begin
+  require 'rubocop/rake_task'
+  t = RuboCop::RakeTask.new
+  t.options << '-D'
+rescue LoadError
+  warn 'rubocop not available.'
+  task rubocop: ['spec']
+end
+
+namespace :spec do
+  task quality: %w(cane rubocop)
+end

data/lib/tasks/test.rake

@@ -4,11 +4,7 @@ namespace :test do
 
     def cmd(str, clean_env = true)
       puts "* #{str}"
-      retval = if clean_env
-        Bundler.with_clean_env { `#{str}` }
-      else
-        `#{str}`
-      end
+      retval = clean_env ? Bundler.with_clean_env { `#{str}` } : `#{str}`
       puts retval.strip
       retval
     end

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from: ../.rubocop.yml
+
+RescueModifier:
+  Enabled: false

data/spec/functional/adm_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'ADM' do
   let(:app) { Rpush::Adm::App.new }
@@ -17,14 +17,11 @@ describe 'ADM' do
     notification.data = { message: 'test' }
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     Net::HTTP::Persistent.stub(new: http)
   end
 
   it 'delivers a notification successfully' do
-    response.stub(body: JSON.dump({registrationID: notification.registration_ids.first.to_s}))
+    response.stub(body: JSON.dump(registrationID: notification.registration_ids.first.to_s))
 
     expect do
       Rpush.push
@@ -33,7 +30,7 @@ describe 'ADM' do
   end
 
   it 'fails to deliver a notification successfully' do
-    response.stub(code: 400, body: JSON.dump({reason: 'error', registrationID: notification.registration_ids.first.to_s}))
+    response.stub(code: 400, body: JSON.dump(reason: 'error', registrationID: notification.registration_ids.first.to_s))
 
     expect do
       Rpush.push

data/spec/functional/apns_spec.rb

@@ -1,58 +1,151 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'APNs' do
-  let(:app) { Rpush::Apns::App.new }
-  let(:notification) { Rpush::Apns::Notification.new }
+  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(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
+  let(:io_double) { double(select: nil) }
 
   before do
+    stub_tcp_connection
+  end
+
+  def create_app
+    app = Rpush::Apns::App.new
     app.certificate = TEST_CERT
     app.name = 'test'
     app.environment = 'sandbox'
     app.save!
+    app
+  end
 
+  def create_notification
+    notification = Rpush::Apns::Notification.new
     notification.app = app
     notification.alert = 'test'
     notification.device_token = 'a' * 64
     notification.save!
+    notification
+  end
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
+  def stub_tcp_connection
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+  end
 
-    stub_tcp_connection
+  def wait_for_notification_to_deliver(notification)
+    Timeout.timeout(timeout) do
+      until notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
   end
 
-  def stub_tcp_connection
-    TCPSocket.stub(:new => tcp_socket)
-    OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
-    IO.stub(:select => nil)
+  def wait_for_notification_to_fail(notification)
+    Timeout.timeout(timeout) do
+      while notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
   end
 
-  it 'delivers a notification successfully' do
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
+  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
   end
 
-  it 'fails to deliver a notification successfully' do
-    IO.stub(:select => true)
-    ssl_socket.stub(:read => [8, 4, 69].pack('ccN'))
+  def fail_notification(notification)
+    ssl_socket.stub(read: [8, 4, notification.id].pack('ccN'))
+    enable_io_select
+  end
 
+  def enable_io_select
+    called = false
+    io_double.stub(:select) do
+      if called
+        nil
+      else
+        called = true
+      end
+    end
+  end
+
+  it 'delivers a notification successfully' do
     expect do
       Rpush.push
       notification.reload
-    end.to_not change(notification, :delivered).to(true)
+    end.to change(notification, :delivered).to(true)
   end
 
   it 'receives feedback' do
     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
+    feedback = Rpush::Apns::Feedback.all.first
+    feedback.should_not be_nil
+    feedback.app_id.should eq(app.id)
+    feedback.device_token.should eq('834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17')
+  end
 
-    expect do
-      Rpush.apns_feedback
-    end.to change(Rpush::Apns::Feedback, :count).to(1)
+  describe 'delivery failures' do
+    before { Rpush.embed }
+    after { Timeout.timeout(timeout) { Rpush.shutdown } }
+
+    it 'fails to deliver a notification' do
+      wait_for_notification_to_deliver(notification)
+      fail_notification(notification)
+      wait_for_notification_to_fail(notification)
+    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] }
+
+      it 'marks the correct notification as failed' do
+        notifications.each { |n| wait_for_notification_to_deliver(n) }
+        fail_notification(notification2)
+        wait_for_notification_to_fail(notification2)
+      end
+
+      it 'does not mark prior notifications as failed' do
+        notifications.each { |n| wait_for_notification_to_deliver(n) }
+        fail_notification(notification2)
+        sleep 1
+        notification1.reload
+        notification1.delivered.should be_true
+      end
+
+      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
+      end
+    end
   end
 end

data/spec/functional/embed_spec.rb

@@ -1,11 +1,12 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'embedding' do
+  let(:timeout) { 10 }
   let(:app) { Rpush::Apns::App.new }
   let(:notification) { Rpush::Apns::Notification.new }
   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(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
+  let(:io_double) { double(select: nil) }
 
   before do
     app.certificate = TEST_CERT
@@ -18,32 +19,31 @@ describe 'embedding' do
     notification.device_token = 'a' * 64
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     stub_tcp_connection
   end
 
   def stub_tcp_connection
-    TCPSocket.stub(:new => tcp_socket)
-    OpenSSL::SSL::SSLSocket.stub(:new => ssl_socket)
-    IO.stub(:select => nil)
-    Rpush::Daemon::Apns::FeedbackReceiver.stub(:new => double.as_null_object)
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+    Rpush::Daemon::Apns::FeedbackReceiver.stub(new: double.as_null_object)
+  end
+
+  before do
+    Rpush.config.push_poll = 5
+    Rpush.embed
   end
 
   it 'delivers a notification successfully' do
     expect do
-      ::ActiveRecord::Base.clear_all_connections!
-
-      pid = fork do
-        Rpush.embed
-        sleep 0.5
-        Rpush.shutdown
-        Kernel.at_exit { exit! } # Don't run any at_exit hooks.
+      Timeout.timeout(timeout) do
+        until notification.delivered
+          notification.reload
+          sleep 0.1
+        end
       end
-
-      Process.waitpid(pid)
-      notification.reload
     end.to change(notification, :delivered).to(true)
   end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
 end

data/spec/functional/gcm_spec.rb

@@ -1,4 +1,4 @@
-require 'unit_spec_helper'
+require 'functional_spec_helper'
 
 describe 'GCM' do
   let(:app) { Rpush::Gcm::App.new }
@@ -11,19 +11,16 @@ describe 'GCM' do
     app.auth_key = 'abc123'
     app.save!
 
-    notification.app = app
+    notification.app_id = app.id
     notification.registration_ids = ['foo']
     notification.data = { message: 'test' }
     notification.save!
 
-    Rails.stub(root: File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp')))
-    Rpush.config.logger = ::Logger.new(STDOUT)
-
     Net::HTTP::Persistent.stub(new: http)
   end
 
   it 'delivers a notification successfully' do
-    response.stub(body: JSON.dump({results: [{message_id: notification.registration_ids.first.to_s}]}))
+    response.stub(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
 
     expect do
       Rpush.push
@@ -32,7 +29,7 @@ describe 'GCM' do
   end
 
   it 'fails to deliver a notification successfully' do
-    response.stub(body: JSON.dump({results: [{error: 'Err'}]}))
+    response.stub(body: JSON.dump(results: [{ error: 'Err' }]))
 
     expect do
       Rpush.push

data/spec/functional/new_app_spec.rb

@@ -0,0 +1,59 @@
+require 'functional_spec_helper'
+
+describe 'New app loading' do
+  let(:timeout) { 10 }
+  let(:app) { create_app }
+  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) }
+
+  before do
+    stub_tcp_connection
+  end
+
+  def create_app
+    app = Rpush::Apns::App.new
+    app.certificate = TEST_CERT
+    app.name = 'test'
+    app.environment = 'sandbox'
+    app.save!
+    app
+  end
+
+  def create_notification
+    notification = Rpush::Apns::Notification.new
+    notification.app = app
+    notification.alert = 'test'
+    notification.device_token = 'a' * 64
+    notification.save!
+    notification
+  end
+
+  def stub_tcp_connection
+    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
+    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
+  end
+
+  def wait_for_notification_to_deliver(notification)
+    Timeout.timeout(timeout) do
+      until notification.delivered
+        sleep 0.1
+        notification.reload
+      end
+    end
+  end
+
+  before do
+    Rpush.config.push_poll = 0
+    Rpush.embed
+  end
+
+  it 'delivers a notification successfully' do
+    sleep 1 # TODO: Need a better way to detect when the Feeder is running.
+    notification = create_notification
+    wait_for_notification_to_deliver(notification)
+  end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
+end

data/spec/functional/retry_spec.rb

@@ -0,0 +1,46 @@
+require 'functional_spec_helper'
+
+describe 'Retries' do
+  let(:app) { Rpush::Gcm::App.new }
+  let(:notification) { Rpush::Gcm::Notification.new }
+  let(:response) { double(Net::HTTPResponse, code: 200) }
+  let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
+
+  before do
+    Rpush::Daemon.initialize_store
+
+    app.name = 'test'
+    app.auth_key = 'abc123'
+    app.save!
+
+    notification.app_id = app.id
+    notification.registration_ids = ['foo']
+    notification.data = { message: 'test' }
+    notification.save!
+
+    Modis.with_connection do |redis|
+      redis.del(Rpush::Client::Redis::Notification.absolute_pending_namespace)
+    end
+
+    Net::HTTP::Persistent.stub(new: http)
+    response.stub(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
+  end
+
+  it 'delivers a notification due to be retried' do
+    Rpush::Daemon.store.mark_retryable(notification, Time.now - 1.minute)
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+
+  it 'does not deliver a notification not due to be retried' do
+    Rpush::Daemon.store.mark_retryable(notification, Time.now + 1.minute)
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to_not change(notification, :delivered).to(true)
+  end
+end

data/spec/functional/synchronization_spec.rb

@@ -0,0 +1,68 @@
+require 'functional_spec_helper'
+
+describe 'Synchronization' do
+  let(:timeout) { 10 }
+  let(:app) { Rpush::Gcm::App.new }
+
+  def wait_for_num_dispatchers(num)
+    Timeout.timeout(timeout) do
+      until Rpush::Daemon::AppRunner.num_dispatchers_for_app(app) == num
+        sleep 0.1
+      end
+    end
+  end
+
+  before do
+    app.name = 'test'
+    app.auth_key = 'abc123'
+    app.connections = 2
+    app.certificate = TEST_CERT_WITH_PASSWORD
+    app.password = 'fubar'
+    app.environment = 'sandbox'
+    app.save!
+
+    Rpush.embed
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  after { Timeout.timeout(timeout) { Rpush.shutdown } }
+
+  it 'increments the number of dispatchers' do
+    app.connections += 1
+    app.save!
+    Rpush.sync
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  it 'decrements the number of dispatchers' do
+    app.connections -= 1
+    app.save!
+    Rpush.sync
+    wait_for_num_dispatchers(app.connections)
+  end
+
+  it 'stops a deleted app' do
+    app.destroy
+    Rpush.sync
+    Rpush::Daemon::AppRunner.app_running?(app).should be_false
+  end
+
+  it 'restarts an app when the certificate is changed' do
+    app.certificate = TEST_CERT
+    app.password = nil
+    app.save!
+    Rpush.sync
+
+    running_app = Rpush::Daemon::AppRunner.app_with_id(app.id)
+    expect(running_app.certificate).to eql(TEST_CERT)
+  end
+
+  it 'restarts an app when the environment is changed' do
+    app.environment = 'production'
+    app.save!
+    Rpush.sync
+
+    running_app = Rpush::Daemon::AppRunner.app_with_id(app.id)
+    expect(running_app.environment).to eql('production')
+  end
+end