rpush 1.0.0-java

data/lib/rpush/notification.rb

@@ -0,0 +1,69 @@
+module Rpush
+  class Notification < ActiveRecord::Base
+    include Rpush::MultiJsonHelper
+
+    self.table_name = 'rpush_notifications'
+
+    # TODO: Dump using multi json.
+    serialize :registration_ids
+
+    belongs_to :app, :class_name => 'Rpush::App'
+
+    if Rpush.attr_accessible_available?
+      attr_accessible :badge, :device_token, :sound, :alert, :data, :expiry,:delivered,
+        :delivered_at, :failed, :failed_at, :error_code, :error_description, :deliver_after,
+        :alert_is_json, :app, :app_id, :collapse_key, :delay_while_idle, :registration_ids, :uri
+    end
+
+    validates :expiry, :numericality => true, :allow_nil => true
+    validates :app, :presence => true
+
+    scope :ready_for_delivery, lambda {
+      where('delivered = ? AND failed = ? AND (deliver_after IS NULL OR deliver_after < ?)',
+            false, false, Time.now)
+    }
+
+    scope :for_apps, lambda { |apps|
+      where('app_id IN (?)', apps.map(&:id))
+    }
+
+    scope :completed, lambda { where("delivered = ? OR failed = ?", true, true) }
+
+    def data=(attrs)
+      return unless attrs
+      raise ArgumentError, "must be a Hash" if !attrs.is_a?(Hash)
+      write_attribute(:data, multi_json_dump(attrs.merge(data || {})))
+    end
+
+    def registration_ids=(ids)
+      ids = [ids] if ids && !ids.is_a?(Array)
+      super
+    end
+
+    def data
+      multi_json_load(read_attribute(:data)) if read_attribute(:data)
+    end
+
+    def payload
+      multi_json_dump(as_json)
+    end
+
+    def payload_size
+      payload.bytesize
+    end
+
+    def payload_data_size
+      multi_json_dump(as_json['data']).bytesize
+    end
+
+    class << self
+      def created_before(dt)
+        where("created_at < ?", dt)
+      end
+
+      def completed_and_older_than(dt)
+        completed.created_before(dt)
+      end
+    end
+  end
+end

data/lib/rpush/notifier.rb

@@ -0,0 +1,52 @@
+require 'socket'
+
+module Rpush
+  # This class notifies the sleeping Rpush Daemon that there are new Notifications to send,
+  # and to interrupt its sleep to send them immediately. The purpose of this is to allow
+  # much higher sleep times to reduce database polling activity.
+  class Notifier
+    def initialize(host, port)
+      @host, @port = host, port
+    end
+
+    # notify the daemon that there is a Notification to send.
+    def notify
+      socket.write('x')
+    end
+
+    # @return [UDPSocket]
+    def socket
+      if @socket.nil?
+        @socket = UDPSocket.new
+        @socket.connect(@host, @port)
+      end
+      @socket
+    end
+
+    # close the udp socket
+    def close
+      if @socket
+        @socket.close
+        @socket = nil
+      end
+    end
+
+  end
+
+  # Call this from a client application after saving a Notification to the database to wakeup the Rpush
+  # Daemon to deliver the notification immediately.
+  def self.wakeup
+    notifier.notify
+  end
+
+  # Default notifier instance. This uses the :connect, :port values in Rpush.config.wakeup to connect to the
+  # wakeup socket in the Rpush Daemon. It will fall back to :host, :port if :connect is not specified.
+  def self.notifier
+    unless @notifier
+      if Rpush.config.wakeup
+        @notifier = Notifier.new(Rpush.config.wakeup[:connect] || Rpush.config.wakeup[:host], Rpush.config.wakeup[:port])
+      end
+    end
+    @notifier
+  end
+end

data/lib/rpush/payload_data_size_validator.rb

@@ -0,0 +1,10 @@
+module Rpush
+  class PayloadDataSizeValidator < ActiveModel::Validator
+    def validate(record)
+      limit = options[:limit] || 1024
+      if !record.data.nil? && record.payload_data_size > limit
+        record.errors[:base] << "Notification payload data cannot be larger than #{limit} bytes."
+      end
+    end
+  end
+end

data/lib/rpush/push.rb

@@ -0,0 +1,16 @@
+module Rpush
+  def self.push(options = {})
+    Rpush.require_for_daemon
+
+    config = Rpush::ConfigurationWithoutDefaults.new
+    options.each { |k, v| config.send("#{k}=", v) }
+    config.push = true
+    Rpush.config.update(config)
+
+    Rpush::Daemon.initialize_store
+    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::Feeder.start
+    Rpush::Daemon::AppRunner.wait
+    Rpush::Daemon::AppRunner.stop
+  end
+end

data/lib/rpush/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+module MyPlugin
+  class Railtie < Rails::Railtie
+    railtie_name :rpush
+
+    rake_tasks do
+      load "tasks/rpush.rake"
+    end
+  end
+end

data/lib/rpush/reflection.rb

@@ -0,0 +1,58 @@
+module Rpush
+  def self.reflect
+    yield reflections if block_given?
+  end
+
+  def self.reflections
+    @reflections ||= Reflections.new
+  end
+
+  class Reflections
+    class NoSuchReflectionError < StandardError; end
+
+    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
+    ]
+
+    DEPRECATIONS = {
+      :apns_connection_lost => [:tcp_connection_lost, '4.1'],
+      :apns_certificate_will_expire => [:ssl_certificate_will_expire, '4.1']
+    }
+
+    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 __dispatch(reflection, *args)
+      reflection = reflection.to_sym
+
+      unless REFLECTIONS.include?(reflection)
+        raise NoSuchReflectionError, reflection
+      end
+
+      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
+
+      if reflections[reflection]
+        reflections[reflection].call(*args)
+      end
+    end
+
+    private
+
+    def reflections
+      @reflections ||= {}
+    end
+  end
+end

data/lib/rpush/registration_ids_count_validator.rb

@@ -0,0 +1,10 @@
+module Rpush
+  class RegistrationIdsCountValidator < ActiveModel::Validator
+    def validate(record)
+      limit = options[:limit] || 100
+      if record.registration_ids && record.registration_ids.size > limit
+        record.errors[:base] << "Number of registration_ids cannot be larger than #{limit}."
+      end
+    end
+  end
+end

data/lib/rpush/version.rb

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

data/lib/rpush/wpns/app.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Wpns
+    class App < Rpush::App
+      def service_name
+        'wpns'
+      end
+    end
+  end
+end

data/lib/rpush/wpns/notification.rb

@@ -0,0 +1,26 @@
+module Rpush
+  module Wpns
+    class Notification < Rpush::Notification
+      validates :uri, presence: true
+      validates :uri, format: { with: /https?:\/\/[\S]+/ }
+      validates :alert, presence: true
+
+      def as_json
+        json = {
+          'message' => alert,
+          'uri'     => uri
+        }
+
+        if collapse_key
+          json['consolidationKey'] = collapse_key
+        end
+
+        json
+      end
+
+      def uri_is_valid?
+        return (/https?:\/\/[\S]+/.match(uri) != nil)
+      end
+    end
+  end
+end

data/lib/rpush.rb

@@ -0,0 +1,62 @@
+require 'active_record'
+require 'multi_json'
+
+module Rpush
+  def self.attr_accessible_available?
+    require 'rails'
+    ::Rails::VERSION::STRING < '4'
+  end
+
+  require 'rpush/railtie' if defined?(Rails)
+end
+
+require 'rpush/version'
+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?
+    defined? JRUBY_VERSION
+  end
+
+  def self.require_for_daemon
+    require 'rpush/daemon'
+  end
+
+  def self.logger
+    @logger ||= Logger.new(:foreground => Rpush.config.foreground)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

data/lib/tasks/cane.rake

@@ -0,0 +1,18 @@
+begin
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 98
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 20
+  end
+
+  namespace :spec do
+    task :cane => ['spec', 'quality']
+  end
+rescue LoadError
+  warn "cane not available, quality task not provided."
+end

data/lib/tasks/rpush.rake

@@ -0,0 +1,16 @@
+namespace :rpush do
+  namespace :notifications do
+    desc "Delete completed notifications older than number of days (DAYS > 0)"
+    task :clean => :environment do
+      date = (ENV['DAYS'].blank? || ENV['DAYS'].to_i <= 0)  ? nil : Time.zone.now.end_of_day - (ENV['DAYS'].to_i).days
+
+      if(date.nil?)
+        puts "DAYS is required and must be greater than 0"
+      else
+        puts "BEG: Delete completed notifications before '#{date}'\n"
+        deleted_count = Rpush::Notification.completed_and_older_than(date).delete_all
+        puts "END: Deleted #{deleted_count} notifications"
+      end
+    end
+  end
+end

data/lib/tasks/test.rake

@@ -0,0 +1,38 @@
+namespace :test do
+  task :build_rails do
+    require 'fileutils'
+
+    def cmd(str, clean_env = true)
+      puts "* #{str}"
+      retval = if clean_env
+        Bundler.with_clean_env { `#{str}` }
+      else
+        `#{str}`
+      end
+      puts retval.strip
+      retval
+    end
+
+    rpush_root = Dir.pwd
+    path = '/tmp/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)
+      cmd('echo "gem \'rake\'" >> Gemfile')
+      cmd("echo \"gem 'rpush', :path => '#{rpush_root}'\" >> Gemfile")
+      cmd('bundle install')
+      cmd('bundle exec rails g rpush')
+      cmd('bundle exec rake db:migrate')
+    ensure
+      Dir.chdir(pwd)
+    end
+
+    puts "Built into #{path}"
+  end
+end

data/spec/functional/adm_spec.rb

@@ -0,0 +1,43 @@
+require 'unit_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) }
+
+  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!
+
+    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}))
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  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}))
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to_not change(notification, :delivered).to(true)
+  end
+end

data/spec/functional/apns_spec.rb

@@ -0,0 +1,58 @@
+require 'unit_spec_helper'
+
+describe 'APNs' do
+  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) }
+
+  before do
+    app.certificate = TEST_CERT
+    app.name = 'test'
+    app.environment = 'sandbox'
+    app.save!
+
+    notification.app = app
+    notification.alert = 'test'
+    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)
+  end
+
+  it 'delivers a notification successfully' do
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+
+  it 'fails to deliver a notification successfully' do
+    IO.stub(:select => true)
+    ssl_socket.stub(:read => [8, 4, 69].pack('ccN'))
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to_not 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)
+
+    expect do
+      Rpush.apns_feedback
+    end.to change(Rpush::Apns::Feedback, :count).to(1)
+  end
+end

data/spec/functional/embed_spec.rb

@@ -0,0 +1,49 @@
+require 'unit_spec_helper'
+
+describe 'embedding' do
+  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) }
+
+  before do
+    app.certificate = TEST_CERT
+    app.name = 'test'
+    app.environment = 'sandbox'
+    app.save!
+
+    notification.app = app
+    notification.alert = 'test'
+    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)
+  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.
+      end
+
+      Process.waitpid(pid)
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+end

data/spec/functional/gcm_spec.rb

@@ -0,0 +1,42 @@
+require 'unit_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 = app
+    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}]}))
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+
+  it 'fails to deliver a notification successfully' do
+    response.stub(body: JSON.dump({results: [{error: 'Err'}]}))
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to_not change(notification, :delivered).to(true)
+  end
+end

data/spec/functional/wpns_spec.rb

@@ -0,0 +1,41 @@
+require 'unit_spec_helper'
+
+describe 'GCM' do
+  let(:app) { Rpush::Wpns::App.new }
+  let(:notification) { Rpush::Wpns::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.save!
+
+    notification.app = app
+    notification.uri = 'http://sn1.notify.live.net/'
+    notification.alert = '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(to_hash: {'x-notificationstatus' => ['Received']})
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+
+  it 'fails to deliver a notification successfully' do
+    response.stub(code: 400)
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to_not change(notification, :delivered).to(true)
+  end
+end