rpush 8.0.0 → 9.1.0

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

@@ -1,241 +0,0 @@
-module Rpush
-  module Daemon
-    module Gcm
-      # https://firebase.google.com/docs/cloud-messaging/server
-      class Delivery < Rpush::Daemon::Delivery
-        include MultiJsonHelper
-
-        host = 'https://fcm.googleapis.com'
-        FCM_URI = URI.parse("#{host}/fcm/send")
-        UNAVAILABLE_STATES = %w(Unavailable BadGateway InternalServerError)
-        INVALID_REGISTRATION_ID_STATES = %w(InvalidRegistration MismatchSenderId NotRegistered InvalidPackageName)
-
-        def initialize(app, http, notification, batch)
-          @app = app
-          @http = http
-          @notification = notification
-          @batch = batch
-        end
-
-        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
-        ensure
-          @batch.notification_processed
-        end
-
-        protected
-
-        def handle_response(response)
-          case response.code.to_i
-          when 200
-            ok(response)
-          when 400
-            bad_request
-          when 401
-            unauthorized
-          when 500
-            internal_server_error(response)
-          when 502
-            bad_gateway(response)
-          when 503
-            service_unavailable(response)
-          when 500..599
-            other_5xx_error(response)
-          else
-            fail Rpush::DeliveryError.new(response.code.to_i, @notification.id, Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i])
-          end
-        end
-
-        def ok(response)
-          results = process_response(response)
-          handle_successes(results.successes)
-
-          if results.failures.any?
-            handle_failures(results.failures, response)
-          else
-            mark_delivered
-            log_info("#{@notification.id} sent to #{@notification.registration_ids.join(', ')}")
-          end
-        end
-
-        def process_response(response)
-          body = multi_json_load(response.body)
-          results = Results.new(body['results'], @notification.registration_ids)
-          results.process(invalid: INVALID_REGISTRATION_ID_STATES, unavailable: UNAVAILABLE_STATES)
-          results
-        end
-
-        def handle_successes(successes)
-          successes.each do |result|
-            reflect(:gcm_delivered_to_recipient, @notification, result[:registration_id])
-            next unless result.key?(:canonical_id)
-            reflect(:gcm_canonical_id, result[:registration_id], result[:canonical_id])
-          end
-        end
-
-        def handle_failures(failures, response)
-          if failures[:unavailable].count == @notification.registration_ids.count
-            retry_delivery(@notification, response)
-            log_warn("All recipients unavailable. #{retry_message}")
-          else
-            if failures[:unavailable].any?
-              unavailable_idxs = failures[:unavailable].map { |result| result[:index] }
-              new_notification = create_new_notification(response, unavailable_idxs)
-              failures.description += " #{unavailable_idxs.join(', ')} will be retried as notification #{new_notification.id}."
-            end
-            handle_errors(failures)
-            fail Rpush::DeliveryError.new(nil, @notification.id, failures.description)
-          end
-        end
-
-        def handle_errors(failures)
-          failures.each do |result|
-            reflect(:gcm_failed_to_recipient, @notification, result[:error], result[:registration_id])
-          end
-          failures[:invalid].each do |result|
-            reflect(:gcm_invalid_registration_id, @app, result[:error], result[:registration_id])
-          end
-        end
-
-        def create_new_notification(response, unavailable_idxs)
-          attrs = { 'app_id' => @notification.app_id, 'collapse_key' => @notification.collapse_key, 'delay_while_idle' => @notification.delay_while_idle }
-          registration_ids = @notification.registration_ids.values_at(*unavailable_idxs)
-          Rpush::Daemon.store.create_gcm_notification(attrs, @notification.data,
-                                                      registration_ids, deliver_after_header(response), @app)
-        end
-
-        def bad_request
-          fail Rpush::DeliveryError.new(400, @notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
-        end
-
-        def unauthorized
-          fail Rpush::DeliveryError.new(401, @notification.id, 'Unauthorized, check your App auth_key.')
-        end
-
-        def internal_server_error(response)
-          retry_delivery(@notification, response)
-          log_warn("GCM responded with an Internal Error. " + retry_message)
-        end
-
-        def bad_gateway(response)
-          retry_delivery(@notification, response)
-          log_warn("GCM responded with a Bad Gateway Error. " + retry_message)
-        end
-
-        def service_unavailable(response)
-          retry_delivery(@notification, response)
-          log_warn("GCM responded with an Service Unavailable Error. " + retry_message)
-        end
-
-        def other_5xx_error(response)
-          retry_delivery(@notification, response)
-          log_warn("GCM responded with a 5xx Error. " + retry_message)
-        end
-
-        def deliver_after_header(response)
-          Rpush::Daemon::RetryHeaderParser.parse(response.header['retry-after'])
-        end
-
-        def retry_delivery(notification, response)
-          time = deliver_after_header(response)
-          if time
-            mark_retryable(notification, time)
-          else
-            mark_retryable_exponential(notification)
-          end
-        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 do_post
-          post = Net::HTTP::Post.new(FCM_URI.path, 'Content-Type'  => 'application/json',
-                                                   'Authorization' => "key=#{@app.auth_key}")
-          post.body = @notification.as_json.to_json
-          @http.request(FCM_URI, post)
-        end
-      end
-
-      class Results
-        attr_reader :successes, :failures
-
-        def initialize(results_data, registration_ids)
-          @results_data = results_data
-          @registration_ids = registration_ids
-        end
-
-        def process(failure_partitions = {}) # rubocop:disable Metrics/AbcSize
-          @successes = []
-          @failures = Failures.new
-          failure_partitions.each_key do |category|
-            failures[category] = []
-          end
-
-          @results_data.each_with_index do |result, index|
-            entry = {
-              registration_id: @registration_ids[index],
-              index: index
-            }
-            if result['message_id']
-              entry[:canonical_id] = result['registration_id'] if result['registration_id'].present?
-              successes << entry
-            elsif result['error']
-              entry[:error] = result['error']
-              failures << entry
-              failure_partitions.each do |category, error_states|
-                failures[category] << entry if error_states.include?(result['error'])
-              end
-            end
-          end
-          failures.all_failed = failures.count == @registration_ids.count
-        end
-      end
-
-      class Failures < Hash
-        include Enumerable
-        attr_writer :all_failed, :description
-
-        def initialize
-          super[:all] = []
-        end
-
-        def each
-          self[:all].each { |x| yield x }
-        end
-
-        def <<(item)
-          self[:all] << item
-        end
-
-        def description
-          @description ||= describe
-        end
-
-        def any?
-          self[:all].any?
-        end
-
-        private
-
-        def describe
-          if @all_failed
-            error_description = "Failed to deliver to all recipients."
-          else
-            index_list = map { |item| item[:index] }
-            error_description = "Failed to deliver to recipients #{index_list.join(', ')}."
-          end
-
-          error_list = map { |item| item[:error] }
-          error_description + " Errors: #{error_list.join(', ')}."
-        end
-      end
-    end
-  end
-end

data/lib/rpush/daemon/gcm.rb

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

data/lib/rpush/daemon/tcp_connection.rb

@@ -1,190 +0,0 @@
-module Rpush
-  module Daemon
-    class TcpConnectionError < StandardError; end
-
-    class TcpConnection
-      include Reflectable
-      include Loggable
-
-      OSX_TCP_KEEPALIVE = 0x10 # Defined in <netinet/tcp.h>
-      KEEPALIVE_INTERVAL = 5
-      KEEPALIVE_IDLE = 5
-      KEEPALIVE_MAX_FAIL_PROBES = 1
-      TCP_ERRORS = [SystemCallError, OpenSSL::OpenSSLError, IOError]
-
-      attr_accessor :last_touch
-      attr_reader :host, :port
-
-      def self.idle_period
-        30.minutes
-      end
-
-      def initialize(app, host, port)
-        @app = app
-        @host = host
-        @port = port
-        @certificate = app.certificate
-        @password = app.password
-        @connected = false
-        @connection_callbacks = []
-        touch
-      end
-
-      def on_connect(&blk)
-        raise 'already connected' if @connected
-        @connection_callbacks << blk
-      end
-
-      def connect
-        @ssl_context = setup_ssl_context
-        @tcp_socket, @ssl_socket = connect_socket
-        @connected = true
-
-        @connection_callbacks.each do |blk|
-          begin
-            blk.call
-          rescue StandardError => e
-            log_error(e)
-          end
-        end
-
-        @connection_callbacks.clear
-      end
-
-      def close
-        @ssl_socket.close if @ssl_socket
-        @tcp_socket.close if @tcp_socket
-      rescue IOError # rubocop:disable HandleExceptions
-      end
-
-      def read(num_bytes)
-        @ssl_socket.read(num_bytes) if @ssl_socket
-      end
-
-      def select(timeout)
-        IO.select([@ssl_socket], nil, nil, timeout) if @ssl_socket
-      end
-
-      def write(data)
-        connect unless @connected
-        reconnect_idle if idle_period_exceeded?
-
-        retry_count = 0
-
-        begin
-          write_data(data)
-        rescue *TCP_ERRORS => e
-          retry_count += 1
-
-          if retry_count == 1
-            log_error("Lost connection to #{@host}:#{@port} (#{e.class.name}, #{e.message}), reconnecting...")
-            reflect(:tcp_connection_lost, @app, e)
-          end
-
-          if retry_count <= 3
-            reconnect_with_rescue
-            sleep 1
-            retry
-          else
-            raise TcpConnectionError, "#{@app.name} tried #{retry_count - 1} times to reconnect but failed (#{e.class.name}, #{e.message})."
-          end
-        end
-      end
-
-      def reconnect_with_rescue
-        reconnect
-      rescue StandardError => e
-        log_error(e)
-      end
-
-      def reconnect
-        close
-        @tcp_socket, @ssl_socket = connect_socket
-      end
-
-      protected
-
-      def reconnect_idle
-        log_info("Idle period exceeded, reconnecting...")
-        reconnect
-      end
-
-      def idle_period_exceeded?
-        Time.now - last_touch > self.class.idle_period
-      end
-
-      def write_data(data)
-        @ssl_socket.write(data)
-        @ssl_socket.flush
-        touch
-      end
-
-      def touch
-        self.last_touch = Time.now
-      end
-
-      def setup_ssl_context
-        ssl_context = OpenSSL::SSL::SSLContext.new
-        ssl_context.key = OpenSSL::PKey::RSA.new(@certificate, @password)
-        ssl_context.cert = OpenSSL::X509::Certificate.new(@certificate)
-        ssl_context
-      end
-
-      def connect_socket
-        touch
-        check_certificate_expiration
-
-        tcp_socket = TCPSocket.new(@host, @port)
-        tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
-        tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-
-        # Linux
-        if [:SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all? { |c| Socket.const_defined?(c) }
-          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, KEEPALIVE_IDLE)
-          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, KEEPALIVE_INTERVAL)
-          tcp_socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, KEEPALIVE_MAX_FAIL_PROBES)
-        end
-
-        # OSX
-        if RUBY_PLATFORM =~ /darwin/
-          tcp_socket.setsockopt(Socket::IPPROTO_TCP, OSX_TCP_KEEPALIVE, KEEPALIVE_IDLE)
-        end
-
-        ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, @ssl_context)
-        ssl_socket.sync = true
-        ssl_socket.connect
-        [tcp_socket, ssl_socket]
-      rescue *TCP_ERRORS => error
-        if error.message =~ /certificate revoked/i
-          log_error('Certificate has been revoked.')
-          reflect(:ssl_certificate_revoked, @app, error)
-        end
-        raise TcpConnectionError, "#{error.class.name}, #{error.message}"
-      end
-
-      def check_certificate_expiration
-        cert = @ssl_context.cert
-        if certificate_expired?
-          log_error(certificate_msg('expired'))
-          raise Rpush::CertificateExpiredError.new(@app, cert.not_after)
-        elsif certificate_expires_soon?
-          log_warn(certificate_msg('will expire'))
-          reflect(:ssl_certificate_will_expire, @app, cert.not_after)
-        end
-      end
-
-      def certificate_msg(msg)
-        time = @ssl_context.cert.not_after.utc.strftime('%Y-%m-%d %H:%M:%S UTC')
-        "Certificate #{msg} at #{time}."
-      end
-
-      def certificate_expired?
-        @ssl_context.cert.not_after && @ssl_context.cert.not_after.utc < Time.now.utc
-      end
-
-      def certificate_expires_soon?
-        @ssl_context.cert.not_after && @ssl_context.cert.not_after.utc < (Time.now + 1.month).utc
-      end
-    end
-  end
-end

data/spec/functional/apns_spec.rb

@@ -1,162 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'APNs' do
-  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) }
-  let(:delivered_ids) { [] }
-  let(:failed_ids) { [] }
-  let(:retry_ids) { [] }
-
-  before do
-    Rpush.config.push_poll = 0.5
-    stub_tcp_connection(tcp_socket, ssl_socket, io_double)
-  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' * 108
-    notification.save!
-    notification
-  end
-
-  def wait
-    sleep 0.1
-  end
-
-  def wait_for_notification_to_deliver(notification)
-    timeout { wait until delivered_ids.include?(notification.id) }
-  end
-
-  def wait_for_notification_to_fail(notification)
-    timeout { wait until failed_ids.include?(notification.id) }
-  end
-
-  def wait_for_notification_to_retry(notification)
-    timeout { wait until retry_ids.include?(notification.id) }
-  end
-
-  def fail_notification(notification)
-    allow(ssl_socket).to receive_messages(read: [8, 4, notification.id].pack('ccN'))
-    enable_io_select
-  end
-
-  def enable_io_select
-    called = false
-    allow(io_double).to receive(:select) do
-      if called
-        nil
-      else
-        called = true
-      end
-    end
-  end
-
-  it 'delivers a notification successfully' do
-    notification = create_notification
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
-  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
-    feedback = Rpush::Apns::Feedback.all.first
-    expect(feedback).not_to be_nil
-    expect(feedback.app_id).to eq(app.id)
-    expect(feedback.device_token).to eq('834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17')
-  end
-
-  describe 'delivery failures' do
-    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
-        allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(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] }
-
-      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)
-        wait_for_notification_to_fail(notification2)
-
-        expect(failed_ids).to_not include(notification1.id)
-        notification1.reload
-        expect(notification1.delivered).to eq(true)
-      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
-end

data/spec/functional/gcm_priority_spec.rb

@@ -1,40 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'GCM priority' do
-  let(:app) { Rpush::Gcm::App.new }
-  let(:notification) { Rpush::Gcm::Notification.new }
-  let(:hydrated_notification) { Rpush::Gcm::Notification.find(notification.id) }
-  let(:response) { double(Net::HTTPResponse, code: 200) }
-  let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
-  let(:priority) { 'normal' }
-
-  before do
-    app.name = 'test'
-    app.auth_key = 'abc123'
-    app.save!
-
-    notification.app_id = app.id
-    notification.registration_ids = ['foo']
-    notification.data = { message: 'test' }
-    notification.priority = priority
-    notification.save!
-
-    allow(Net::HTTP::Persistent).to receive_messages(new: http)
-  end
-
-  it 'supports normal priority' do
-    expect(hydrated_notification.as_json['priority']).to eq('normal')
-  end
-
-  context 'high priority' do
-    let(:priority) { 'high' }
-
-    it 'supports high priority' do
-      expect(hydrated_notification.as_json['priority']).to eq('high')
-    end
-  end
-
-  it 'does not add an error when receiving expected priority' do
-    expect(hydrated_notification.errors.messages[:priority]).to be_empty
-  end
-end

data/spec/functional/gcm_spec.rb

@@ -1,46 +0,0 @@
-require 'functional_spec_helper'
-
-describe 'GCM' 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
-    app.name = 'test'
-    app.auth_key = 'abc123'
-    app.save!
-
-    notification.app_id = app.id
-    notification.registration_ids = ['foo']
-    notification.data = { message: 'test' }
-    notification.save!
-
-    allow(Net::HTTP::Persistent).to receive_messages(new: http)
-  end
-
-  it 'delivers a notification successfully' do
-    allow(response).to receive_messages(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
-
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
-  end
-
-  it 'fails to deliver a notification successfully' do
-    allow(response).to receive_messages(body: JSON.dump(results: [{ error: 'Err' }]))
-    Rpush.push
-    notification.reload
-    expect(notification.delivered).to eq(false)
-  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