rpush_extended 3.2.5

data/lib/rpush/embed.rb

@@ -0,0 +1,41 @@
+module Rpush
+  def self.embed
+    require 'rpush/daemon'
+
+    if @embed_thread
+      STDERR.puts 'Rpush.embed can only be run once inside this process.'
+    end
+
+    Rpush.config.embedded = true
+    Rpush.config.foreground = true
+    Kernel.at_exit { shutdown }
+    @embed_thread = Thread.new { Rpush::Daemon.start }
+  end
+
+  def self.shutdown
+    return unless Rpush.config.embedded
+    Rpush::Daemon.shutdown
+    @embed_thread.join if @embed_thread
+  rescue StandardError => e
+    STDERR.puts(e.message)
+    STDERR.puts(e.backtrace.join("\n"))
+  ensure
+    @embed_thread = nil
+  end
+
+  def self.sync
+    return unless Rpush.config.embedded
+    Rpush::Daemon::Synchronizer.sync
+  end
+
+  def self.status
+    return unless Rpush.config.embedded
+    status = Rpush::Daemon::AppRunner.status
+    Rpush.logger.info(JSON.pretty_generate(status))
+    status
+  end
+
+  def self.debug
+    status
+  end
+end

data/lib/rpush/logger.rb

@@ -0,0 +1,92 @@
+module Rpush
+  class Logger
+    attr_reader :internal_logger
+
+    def initialize
+      @internal_logger = Rpush.config.logger || setup_logger(open_logfile)
+      @internal_logger.level = Rpush.config.log_level
+    rescue SystemCallError => e
+      @internal_logger = nil
+      error(e)
+      error('Logging disabled.')
+    end
+
+    def debug(msg, inline = false)
+      log(:debug, msg, inline)
+    end
+
+    def info(msg, inline = false)
+      log(:info, msg, inline)
+    end
+
+    def error(msg, inline = false)
+      log(:error, msg, inline, 'ERROR', STDERR)
+    end
+
+    def warn(msg, inline = false)
+      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 ActiveSupport.const_defined?('BufferedLogger')
+        logger = ActiveSupport::BufferedLogger.new(log)
+        logger.auto_flushing = auto_flushing
+        logger
+      else
+        ActiveSupport::Logger.new(log)
+      end
+    end
+
+    def auto_flushing
+      if defined?(Rails) && Rails.logger.respond_to?(:auto_flushing)
+        Rails.logger.auto_flushing
+      else
+        true
+      end
+    end
+
+    def log(where, msg, inline = false, 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 << '[rpush] ' if Rpush.config.embedded
+      formatted_msg << "[#{prefix}] " if prefix
+      formatted_msg << msg
+
+      log_foreground(io, formatted_msg, inline)
+      @internal_logger.send(where, formatted_msg) if @internal_logger
+    end
+
+    def log_foreground(io, formatted_msg, inline)
+      return unless io == STDERR || Rpush.config.foreground
+
+      if inline
+        io.write(formatted_msg)
+        io.flush
+      else
+        io.puts(formatted_msg)
+      end
+    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/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)
+      @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

@@ -0,0 +1,11 @@
+module Rpush
+  def self.push
+    require 'rpush/daemon'
+
+    Rpush.config.push = true
+    Rpush::Daemon.common_init
+    Rpush::Daemon::Synchronizer.sync
+    Rpush::Daemon::Feeder.start(true) # non-blocking
+    Rpush::Daemon::AppRunner.stop
+  end
+end

data/lib/rpush/reflectable.rb

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

data/lib/rpush/reflection_collection.rb

@@ -0,0 +1,44 @@
+module Rpush
+  class ReflectionCollection
+    class NoSuchReflectionError < StandardError; end
+
+    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,
+      :error, :adm_canonical_id, :adm_failed_to_recipient, :wns_invalid_channel,
+      :tcp_connection_lost, :ssl_certificate_will_expire, :ssl_certificate_revoked,
+      :notification_id_will_retry, :notification_id_failed
+    ]
+
+    DEPRECATIONS = {}
+
+    REFLECTIONS.each do |reflection|
+      class_eval(<<-RUBY, __FILE__, __LINE__)
+        def #{reflection}(*args, &blk)
+          raise "block required" unless block_given?
+          @reflections[:#{reflection}] = blk
+        end
+      RUBY
+    end
+
+    def initialize
+      @reflections = {}
+    end
+
+    def __dispatch(reflection, *args)
+      blk = @reflections[reflection]
+
+      if blk
+        blk.call(*args)
+
+        if DEPRECATIONS.key?(reflection)
+          replacement, removal_version = DEPRECATIONS[reflection]
+          Rpush::Deprecation.warn("#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.")
+        end
+      elsif !REFLECTIONS.include?(reflection)
+        raise NoSuchReflectionError, reflection
+      end
+    end
+  end
+end

data/lib/rpush/reflection_public_methods.rb

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

data/lib/rpush/version.rb

@@ -0,0 +1,14 @@
+module Rpush
+  module VERSION
+    MAJOR = 3
+    MINOR = 2
+    TINY = 5
+    PRE = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze
+
+    def self.to_s
+      STRING
+    end
+  end
+end

data/lib/rpush.rb

@@ -0,0 +1,43 @@
+require 'logger'
+require 'multi_json'
+require 'active_support/all'
+require 'net-http2'
+require 'jwt'
+
+require 'rails'
+
+require 'rpush/version'
+require 'rpush/cli'
+require 'rpush/deprecation'
+require 'rpush/deprecatable'
+require 'rpush/logger'
+require 'rpush/multi_json_helper'
+require 'rpush/configuration'
+require 'rpush/reflection_collection'
+require 'rpush/reflection_public_methods'
+require 'rpush/reflectable'
+require 'rpush/plugin'
+require 'rpush/embed'
+require 'rpush/push'
+require 'rpush/apns_feedback'
+
+module Rpush
+  def self.jruby?
+    defined? JRUBY_VERSION
+  end
+
+  def self.logger
+    @logger ||= Logger.new
+  end
+
+  def self.root
+    require 'rails'
+    Rails.root || Dir.pwd
+  rescue LoadError
+    Dir.pwd
+  end
+
+  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', :>=, 80
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 22
+  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

@@ -0,0 +1,69 @@
+require 'fileutils'
+
+def cmd(str, clean_env = true)
+  puts "* #{str}"
+  retval = clean_env ? Bundler.with_clean_env { `#{str}` } : `#{str}`
+  puts retval.strip
+  retval
+end
+
+def add_ruby_dot_files
+  cmd("echo '#{RUBY_ENGINE}-#{RUBY_VERSION}' > .ruby-version")
+  cmd("echo 'rpush_test' > .ruby-gemset")
+end
+
+desc 'Build Rails app bundled with Rpush'
+task :build_rails do
+  rpush_root = Dir.pwd
+  path = '/tmp/rpush/rails_test'
+  cmd("rm -rf #{path}")
+  FileUtils.mkdir_p(path)
+  pwd = Dir.pwd
+
+  cmd("bundle exec rails --version", false)
+  cmd("bundle exec rails new #{path} --skip-bundle", false)
+
+  begin
+    Dir.chdir(path)
+    add_ruby_dot_files
+    cmd('echo "gem \'rake\'" >> Gemfile')
+    cmd('echo "gem \'pg\'" >> Gemfile')
+    cmd("echo \"gem 'rpush', path: '#{rpush_root}'\" >> Gemfile")
+
+    File.open('config/database.yml', 'w') do |fd|
+      fd.write(<<-YML)
+development:
+  adapter: postgresql
+  database: rpush_rails_test
+  pool: 5
+  timeout: 5000
+      YML
+    end
+  ensure
+    Dir.chdir(pwd)
+  end
+
+  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'
+  cmd("rm -rf #{path}")
+  FileUtils.mkdir_p(path)
+  pwd = Dir.pwd
+
+  begin
+    Dir.chdir(path)
+    add_ruby_dot_files
+    cmd('echo "source \'https://rubygems.org\'" >> Gemfile')
+    cmd('echo "gem \'rake\'" >> Gemfile')
+    cmd('echo "gem \'rpush-redis\'" >> Gemfile')
+    cmd("echo \"gem 'rpush', path: '#{rpush_root}'\" >> Gemfile")
+  ensure
+    Dir.chdir(pwd)
+  end
+
+  puts "Built into #{path}"
+end

data/spec/.rubocop.yml

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

data/spec/functional/adm_spec.rb

@@ -0,0 +1,50 @@
+require 'functional_spec_helper'
+
+describe 'ADM' do
+  let(:app) { Rpush::Adm::App.new }
+  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'
+    app.client_id = 'abc'
+    app.client_secret = '123'
+    app.save!
+
+    notification.app = app
+    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(registrationID: 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(code: 400, body: JSON.dump(reason: 'error', registrationID: notification.registration_ids.first.to_s))
+    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