rpush 7.0.1 → 9.0.0

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

@@ -0,0 +1,162 @@
+module Rpush
+  module Daemon
+    module Fcm
+      # https://firebase.google.com/docs/cloud-messaging/server
+      class Delivery < Rpush::Daemon::Delivery
+        include MultiJsonHelper
+
+        HOST = 'https://fcm.googleapis.com'.freeze
+        SCOPE = 'https://www.googleapis.com/auth/firebase.messaging'.freeze
+
+        def initialize(app, http, notification, batch)
+          if necessary_data_exists?(app)
+            @app = app
+            @http = http
+            @notification = notification
+            @batch = batch
+
+            @uri = URI.parse("#{HOST}/v1/projects/#{@app.firebase_project_id || ENV['FIREBASE_PROJECT_ID']}/messages:send")
+          else
+            Rpush.logger.error("Cannot find necessary configuration! Please make sure you have set all necessary ENV variables or firebase_project_id and json_key attributes.")
+          end
+        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
+          when 400
+            bad_request(response)
+          when 401
+            unauthorized
+          when 403
+            sender_id_mismatch
+          when 404
+            unregistered(response)
+          when 429
+            too_many_requests
+          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
+          reflect(:fcm_delivered_to_recipient, @notification)
+          mark_delivered
+          log_info("#{@notification.id} sent to #{@notification.device_token}")
+        end
+
+        def bad_request(response)
+          fail Rpush::DeliveryError.new(400, @notification.id, "FCM failed to handle the JSON request. (#{parse_error(response)})")
+        end
+
+        def unauthorized
+          fail Rpush::DeliveryError.new(401, @notification.id, 'Unauthorized, Bearer token could not be validated.')
+        end
+
+        def sender_id_mismatch
+          fail Rpush::DeliveryError.new(403, @notification.id, 'The sender ID was mismatched. It seems the device token is wrong.')
+        end
+
+        def unregistered(response)
+          error = parse_error(response)
+          reflect(:fcm_invalid_device_token, @app, error, @notification.device_token)
+          fail Rpush::DeliveryError.new(404, @notification.id, "Client was not registered for your app. (#{error})")
+        end
+
+        def too_many_requests
+          fail Rpush::DeliveryError.new(429, @notification.id, 'Slow down. Too many requests were sent!')
+        end
+
+        def internal_server_error(response)
+          retry_delivery(@notification, response)
+          log_warn("FCM responded with an Internal Error. " + retry_message)
+        end
+
+        def bad_gateway(response)
+          retry_delivery(@notification, response)
+          log_warn("FCM responded with a Bad Gateway Error. " + retry_message)
+        end
+
+        def service_unavailable(response)
+          retry_delivery(@notification, response)
+          log_warn("FCM responded with an Service Unavailable Error. " + retry_message)
+        end
+
+        def other_5xx_error(response)
+          retry_delivery(@notification, response)
+          log_warn("FCM responded with a 5xx Error. " + retry_message)
+        end
+
+        def parse_error(response)
+          error = multi_json_load(response.body)['error']
+          "#{error['status']}: #{error['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 obtain_access_token
+          GoogleCredentialCache.instance.access_token(SCOPE, @app.json_key)
+        end
+
+        def do_post
+          token = obtain_access_token['access_token']
+          post = Net::HTTP::Post.new(@uri.path, 'Content-Type' => 'application/json',
+                                     'Authorization' => "Bearer #{token}")
+          post.body = @notification.as_json.to_json
+          @http.request(@uri, post)
+        end
+
+        def necessary_data_exists?(app)
+          # Needed for Google Auth
+          # See https://github.com/googleapis/google-auth-library-ruby#example-environment-variables
+          # for further information
+          (app.firebase_project_id || ENV.key?('FIREBASE_PROJECT_ID')) &&
+            (app.json_key || (
+              ENV.key?('GOOGLE_ACCOUNT_TYPE') &&
+                ENV.key?('GOOGLE_CLIENT_ID') &&
+                ENV.key?('GOOGLE_CLIENT_EMAIL') &&
+                ENV.key?('GOOGLE_PRIVATE_KEY')
+            ))
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/{gcm.rb → fcm.rb}

@@ -1,6 +1,6 @@
 module Rpush
   module Daemon
-    module Gcm
+    module Fcm
       extend ServiceConfigMethods
 
       dispatcher :http

data/lib/rpush/daemon/google_credential_cache.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+module Rpush
+  module Daemon
+    class GoogleCredentialCache
+      include Singleton
+      include Loggable
+
+      # Assuming tokens are valid for 1 hour
+      TOKEN_VALID_FOR_SEC = 60 * 59
+
+      def initialize
+        @credentials_cache = {}
+      end
+
+      def access_token(scope, json_key)
+        key = hash_key(scope, json_key)
+
+        if @credentials_cache[key].nil? || Time.now > @credentials_cache[key][:expires_at]
+          token = fetch_fresh_token(scope, json_key)
+          expires_at = Time.now + TOKEN_VALID_FOR_SEC
+          @credentials_cache[key] = { token: token, expires_at: expires_at }
+        end
+
+        @credentials_cache[key][:token]
+      end
+
+      private
+
+      def fetch_fresh_token(scope, json_key)
+        json_key_io = json_key ? StringIO.new(json_key) : nil
+        log_debug("FCM - Obtaining access token.")
+        authorizer = Google::Auth::ServiceAccountCredentials.make_creds(scope: scope, json_key_io: json_key_io)
+        authorizer.fetch_access_token
+      end
+
+      def hash_key(scope, json_key)
+        scope.hash ^ json_key.hash
+      end
+    end
+  end
+end

data/lib/rpush/daemon/service_config_methods.rb

@@ -3,8 +3,6 @@ module Rpush
     module ServiceConfigMethods
       DISPATCHERS = {
         http:       Rpush::Daemon::Dispatcher::Http,
-        tcp:        Rpush::Daemon::Dispatcher::Tcp,
-        apns_tcp:   Rpush::Daemon::Dispatcher::ApnsTcp,
         apns_http2: Rpush::Daemon::Dispatcher::ApnsHttp2,
         apnsp8_http2: Rpush::Daemon::Dispatcher::Apnsp8Http2
       }

data/lib/rpush/daemon/store/active_record.rb

@@ -138,21 +138,14 @@ module Rpush
           end
         end
 
-        def create_apns_feedback(failed_at, device_token, app)
-          with_database_reconnect_and_retry do
-            Rpush::Client::ActiveRecord::Apns::Feedback.create!(failed_at: failed_at,
-                                                                device_token: device_token, app_id: app.id)
-          end
-        end
-
-        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
-          notification = Rpush::Client::ActiveRecord::Gcm::Notification.new
-          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        def create_fcm_notification(attrs, data, app)
+          notification = Rpush::Client::ActiveRecord::Fcm::Notification.new
+          create_fcm_like_notification(notification, attrs, data, app)
         end
 
         def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::ActiveRecord::Adm::Notification.new
-          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+          create_adm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
         end
 
         def update_app(app)
@@ -194,7 +187,17 @@ module Rpush
 
         private
 
-        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
+        def create_fcm_like_notification(notification, attrs, data, app) # rubocop:disable Metrics/ParameterLists
+          with_database_reconnect_and_retry do
+            notification.assign_attributes(attrs)
+            notification.data = data
+            notification.app = app
+            notification.save!
+            notification
+          end
+        end
+
+        def create_adm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
           with_database_reconnect_and_retry do
             notification.assign_attributes(attrs)
             notification.data = data

data/lib/rpush/daemon/store/interface.rb

@@ -4,9 +4,9 @@ module Rpush
       class Interface
         PUBLIC_METHODS = [:deliverable_notifications, :mark_retryable,
                           :mark_batch_retryable, :mark_delivered, :mark_batch_delivered,
-                          :mark_failed, :mark_batch_failed, :create_apns_feedback,
-                          :create_gcm_notification, :create_adm_notification, :update_app,
-                          :update_notification, :release_connection,
+                          :mark_failed, :mark_batch_failed,
+                          :create_fcm_notification, :create_adm_notification,
+                          :update_app, :update_notification, :release_connection,
                           :all_apps, :app, :mark_ids_failed, :mark_ids_retryable,
                           :reopen_log, :pending_delivery_count, :translate_integer_notification_id]
 

data/lib/rpush/daemon/store/redis.rb

@@ -88,18 +88,14 @@ module Rpush
           end
         end
 
-        def create_apns_feedback(failed_at, device_token, app)
-          Rpush::Client::Redis::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app_id: app.id)
-        end
-
-        def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
-          notification = Rpush::Client::Redis::Gcm::Notification.new
-          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+        def create_fcm_notification(attrs, data, app)
+          notification = Rpush::Client::Redis::Fcm::Notification.new
+          create_fcm_like_notification(notification, attrs, data, app)
         end
 
         def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::Redis::Adm::Notification.new
-          create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
+          create_adm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
         end
 
         def update_app(app)
@@ -138,7 +134,15 @@ module Rpush
           nil
         end
 
-        def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
+        def create_fcm_like_notification(notification, attrs, data, app) # rubocop:disable Metrics/ParameterLists
+          notification.assign_attributes(attrs)
+          notification.data = data
+          notification.app = app
+          notification.save!
+          notification
+        end
+
+        def create_adm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
           notification.assign_attributes(attrs)
           notification.data = data
           notification.registration_ids = registration_ids

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "webpush"
+require "web-push"
 
 module Rpush
   module Daemon
@@ -10,7 +10,7 @@ module Rpush
       # We just override #perform to inject the http instance that is managed
       # by Rpush.
       #
-      class Request < ::Webpush::Request
+      class Request < ::WebPush::Request
         def perform(http)
           req = Net::HTTP::Post.new(uri.request_uri, headers)
           req.body = body

data/lib/rpush/daemon.rb

@@ -19,11 +19,8 @@ require 'rpush/daemon/batch'
 require 'rpush/daemon/queue_payload'
 require 'rpush/daemon/synchronizer'
 require 'rpush/daemon/app_runner'
-require 'rpush/daemon/tcp_connection'
 require 'rpush/daemon/dispatcher_loop'
 require 'rpush/daemon/dispatcher/http'
-require 'rpush/daemon/dispatcher/tcp'
-require 'rpush/daemon/dispatcher/apns_tcp'
 require 'rpush/daemon/dispatcher/apns_http2'
 require 'rpush/daemon/dispatcher/apnsp8_http2'
 require 'rpush/daemon/service_config_methods'
@@ -38,10 +35,6 @@ require 'rpush/daemon/rpc/client'
 
 require 'rpush/daemon/store/interface'
 
-require 'rpush/daemon/apns/delivery'
-require 'rpush/daemon/apns/feedback_receiver'
-require 'rpush/daemon/apns'
-
 require 'rpush/daemon/apns2/delivery'
 require 'rpush/daemon/apns2'
 
@@ -49,8 +42,9 @@ require 'rpush/daemon/apnsp8/delivery'
 require 'rpush/daemon/apnsp8/token'
 require 'rpush/daemon/apnsp8'
 
-require 'rpush/daemon/gcm/delivery'
-require 'rpush/daemon/gcm'
+require 'rpush/daemon/fcm/delivery'
+require 'rpush/daemon/fcm'
+require 'rpush/daemon/google_credential_cache'
 
 require 'rpush/daemon/wpns/delivery'
 require 'rpush/daemon/wpns'

data/lib/rpush/reflection_collection.rb

@@ -4,10 +4,10 @@ module Rpush
 
     REFLECTIONS = [
       :apns_feedback, :notification_enqueued, :notification_delivered,
-      :notification_failed, :notification_will_retry, :gcm_delivered_to_recipient,
-      :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
+      :notification_failed, :notification_will_retry,
+      :fcm_delivered_to_recipient, :fcm_failed_to_recipient, :fcm_canonical_id, :fcm_invalid_device_token,
       :error, :adm_canonical_id, :adm_failed_to_recipient, :wns_invalid_channel,
-      :tcp_connection_lost, :ssl_certificate_will_expire, :ssl_certificate_revoked,
+      :ssl_certificate_will_expire, :ssl_certificate_revoked,
       :notification_id_will_retry, :notification_id_failed
     ]
 

data/lib/rpush/version.rb

@@ -1,8 +1,8 @@
 module Rpush
   module VERSION
-    MAJOR = 7
+    MAJOR = 9
     MINOR = 0
-    TINY = 1
+    TINY = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze

data/lib/rpush.rb

@@ -3,6 +3,7 @@ require 'multi_json'
 require 'active_support/all'
 require 'net-http2'
 require 'jwt'
+require 'googleauth'
 
 require 'rails'
 
@@ -19,7 +20,6 @@ require 'rpush/reflectable'
 require 'rpush/plugin'
 require 'rpush/embed'
 require 'rpush/push'
-require 'rpush/apns_feedback'
 
 module Rpush
   def self.jruby?

data/spec/functional/apns2_spec.rb

@@ -79,8 +79,7 @@ describe 'APNs http2 adapter' do
           headers: {
             'apns-expiration' => '0',
             'apns-priority' => '10',
-            'apns-topic' => 'com.example.app',
-            'apns-push-type' => 'background'
+            'apns-topic' => 'com.example.app'
           }
         }
       )
@@ -114,8 +113,7 @@ describe 'APNs http2 adapter' do
             headers: {
               'apns-topic' => bundle_id,
               'apns-expiration' => '0',
-              'apns-priority' => '10',
-              'apns-push-type' => 'background'
+              'apns-priority' => '10'
             }
           }
         ).and_return(fake_http2_request)
@@ -257,7 +255,6 @@ describe 'APNs http2 adapter' do
         Rpush.reflect do |on|
           on.error do |error|
             expect(error).to be_kind_of(StandardError)
-           reflector.accept
           end
         end
 
@@ -292,7 +289,6 @@ describe 'APNs http2 adapter' do
           on.error do |error|
             reflected_error = true
             expect(error).to be_kind_of(StandardError)
-            reflector.accept
           end
         end
 

data/spec/functional/cli_spec.rb

@@ -2,31 +2,57 @@ require 'functional_spec_helper'
 
 describe Rpush::CLI do
   def create_app
-    app = Rpush::Apns::App.new
+    app = Rpush::Apns2::App.new
     app.certificate = TEST_CERT
     app.name = 'test'
-    app.environment = 'sandbox'
+    app.environment = 'development'
+    app.bundle_id = 'com.example.app'
     app.save!
     app
   end
 
-  describe 'status' do
-    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(:fake_client) {
+    double(
+      prepare_request: fake_http2_request,
+      close:           'ok',
+      call_async:      'ok',
+      join:            'ok',
+      on:              'ok'
+    )
+  }
+  let(:fake_http2_request) { double }
+  let(:fake_http_resp_headers) {
+    {
+      ":status" => "200",
+      "apns-id"=>"C6D65840-5E3F-785A-4D91-B97D305C12F6"
+    }
+  }
+  let(:fake_http_resp_body) { '' }
 
-    before do
-      create_app
-      stub_tcp_connection(tcp_socket, ssl_socket, io_double)
-      Rpush.embed
+  before do
+    create_app
+    Rpush.config.push_poll = 0.5
 
-      timeout do
-        Thread.pass until File.exist?(Rpush::Daemon::Rpc.socket_path)
-      end
-    end
+    allow(NetHttp2::Client).
+      to receive(:new).and_return(fake_client)
+    allow(fake_http2_request).
+      to receive(:on).with(:headers).
+      and_yield(fake_http_resp_headers)
+    allow(fake_http2_request).
+      to receive(:on).with(:body_chunk).
+      and_yield(fake_http_resp_body)
+    allow(fake_http2_request).
+      to receive(:on).with(:close).
+      and_yield
+
+    Rpush.embed
+  end
 
-    after { timeout { Rpush.shutdown } }
+  after do
+    timeout { Rpush.shutdown }
+  end
 
+  describe 'status' do
     it 'prints the status' do
       expect(subject).to receive(:configure_rpush) { true }
       expect(subject).to receive(:puts).with(/app_runners:/)

data/spec/functional/embed_spec.rb

@@ -1,49 +1,80 @@
 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(:io_double) { double(select: nil) }
-
-  before do
+  def create_app
+    app = Rpush::Apns2::App.new
     app.certificate = TEST_CERT
     app.name = 'test'
-    app.environment = 'sandbox'
+    app.environment = 'development'
+    app.bundle_id = 'com.example.app'
     app.save!
+    app
+  end
 
+  let(:fake_device_token) { 'a' * 108 }
+  let(:notification_data) { nil }
+
+  def create_notification(app)
+    notification = Rpush::Apns2::Notification.new
     notification.app = app
+    notification.sound = 'default'
     notification.alert = 'test'
-    notification.device_token = 'a' * 108
+    notification.device_token = fake_device_token
+    notification.data = notification_data
+    notification.content_available = 1
     notification.save!
-
-    stub_tcp_connection
+    notification
   end
 
-  def stub_tcp_connection
-    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(connect_socket: [tcp_socket, ssl_socket])
-    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(setup_ssl_context: double.as_null_object)
-    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
-    allow(Rpush::Daemon::Apns::FeedbackReceiver).to receive_messages(new: double.as_null_object)
-  end
+  let(:app) { create_app }
+  let(:notification) { create_notification(app) }
+
+  let(:fake_client) {
+    double(
+      prepare_request: fake_http2_request,
+      close:           'ok',
+      call_async:      'ok',
+      join:            'ok',
+      on:              'ok'
+    )
+  }
+  let(:fake_http2_request) { double }
+  let(:fake_http_resp_headers) {
+    {
+      ":status" => "200",
+      "apns-id"=>"C6D65840-5E3F-785A-4D91-B97D305C12F6"
+    }
+  }
+  let(:fake_http_resp_body) { '' }
 
   before do
-    Rpush.config.push_poll = 5
+    Rpush.config.push_poll = 0.5
+
+    allow(NetHttp2::Client).
+      to receive(:new).and_return(fake_client)
+    allow(fake_http2_request).
+      to receive(:on).with(:headers).
+      and_yield(fake_http_resp_headers)
+    allow(fake_http2_request).
+      to receive(:on).with(:body_chunk).
+      and_yield(fake_http_resp_body)
+    allow(fake_http2_request).
+      to receive(:on).with(:close).
+      and_yield
+
     Rpush.embed
   end
 
+  after do
+    timeout { Rpush.shutdown }
+  end
+
   it 'delivers a notification successfully' do
     expect do
-      Timeout.timeout(timeout) do
-        until notification.delivered
-          notification.reload
-          sleep 0.1
-        end
+      until notification.delivered
+        notification.reload
+        sleep 0.1
       end
     end.to change(notification, :delivered).to(true)
   end
-
-  after { Timeout.timeout(timeout) { Rpush.shutdown } }
 end