rpush 1.0.0-java

data/lib/rpush/daemon/tcp_connection.rb

@@ -0,0 +1,143 @@
+module Rpush
+  module Daemon
+    class TcpConnectionError < StandardError; end
+
+    class TcpConnection
+      include Reflectable
+      include Loggable
+
+      attr_accessor :last_write
+
+      def self.idle_period
+        30.minutes
+      end
+
+      def initialize(app, host, port)
+        @app = app
+        @host = host
+        @port = port
+        @certificate = app.certificate
+        @password = app.password
+        written
+      end
+
+      def connect
+        @ssl_context = setup_ssl_context
+        @tcp_socket, @ssl_socket = connect_socket
+      end
+
+      def close
+        begin
+          @ssl_socket.close if @ssl_socket
+          @tcp_socket.close if @tcp_socket
+        rescue IOError
+        end
+      end
+
+      def read(num_bytes)
+        @ssl_socket.read(num_bytes)
+      end
+
+      def select(timeout)
+        IO.select([@ssl_socket], nil, nil, timeout)
+      end
+
+      def write(data)
+        reconnect_idle if idle_period_exceeded?
+
+        retry_count = 0
+
+        begin
+          write_data(data)
+        rescue Errno::EPIPE, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError, IOError => e
+          retry_count += 1;
+
+          if retry_count == 1
+            log_error("Lost connection to #{@host}:#{@port} (#{e.class.name}), reconnecting...")
+            reflect(:apns_connection_lost, @app, e) # deprecated
+            reflect(:tcp_connection_lost, @app, e)
+          end
+
+          if retry_count <= 3
+            reconnect
+            sleep 1
+            retry
+          else
+            raise TcpConnectionError, "#{@app.name} tried #{retry_count-1} times to reconnect but failed (#{e.class.name})."
+          end
+        end
+      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_write > self.class.idle_period
+      end
+
+      def write_data(data)
+        @ssl_socket.write(data)
+        @ssl_socket.flush
+        written
+      end
+
+      def written
+        self.last_write = 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
+        check_certificate_expiration
+
+        tcp_socket = TCPSocket.new(@host, @port)
+        tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
+        tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, @ssl_context)
+        ssl_socket.sync = true
+        ssl_socket.connect
+        log_info("Connected to #{@host}:#{@port}")
+        [tcp_socket, ssl_socket]
+      end
+
+      def check_certificate_expiration
+        cert = @ssl_context.cert
+        if certificate_expired?
+          log_error(certificate_msg('expired'))
+          raise Rpush::Apns::CertificateExpiredError.new(@app, cert.not_after)
+        elsif certificate_expires_soon?
+          log_warn(certificate_msg('will expire'))
+          reflect(:apns_certificate_will_expire, @app, cert.not_after) # deprecated
+          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/lib/rpush/daemon/too_many_requests_error.rb

@@ -0,0 +1,20 @@
+module Rpush
+  class TooManyRequestsError < StandardError
+    attr_reader :code, :description, :response
+
+    def initialize(code, notification_id, description, response)
+      @code = code
+      @notification_id = notification_id
+      @description = description
+      @response = response
+    end
+
+    def to_s
+      message
+    end
+
+    def message
+      "Too many requests for #{@notification_id}, received error #{@code} (#{@description}) - retry after #{@response.header['retry-after']}"
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module Rpush
+  module Daemon
+    module Wpns
+
+      # http://msdn.microsoft.com/en-us/library/windowsphone/develop/ff941100%28v=vs.105%29.aspx
+      class Delivery < Rpush::Daemon::Delivery
+
+        FAILURE_MESSAGES = {
+          400 => 'Bad XML or malformed notification URI.',
+          401 => 'Unauthorized to send a notification to this app.'
+        }
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          begin
+            handle_response(do_post)
+          rescue Rpush::DeliveryError => error
+            mark_failed(error.code, error.description)
+            raise
+          end
+        end
+
+        private
+
+        def handle_response(response)
+          code = response.code.to_i
+          case code
+          when 200
+            ok(response)
+          when 406
+            not_acceptable(response)
+          when 412
+            precondition_failed(response)
+          when 503
+            service_unavailable(response)
+          else
+            handle_failure(code)
+          end
+        end
+
+        def handle_failure(code, msg=nil)
+          unless msg
+            msg = if FAILURE_MESSAGES.key?(code)
+              FAILURE_MESSAGES[code]
+            else
+              Rpush::Daemon::HTTP_STATUS_CODES[code]
+            end
+          end
+          raise Rpush::DeliveryError.new(code, @notification.id, msg)
+        end
+
+        def ok(response)
+          status = status_from_response(response)
+          case status[:notification]
+          when ["Received"]
+            mark_delivered
+            log_info("#{@notification.id} sent successfully")
+          when ["QueueFull"]
+            mark_retryable(@notification, Time.now + (60*10))
+            log_warn("#{@notification.id} cannot be sent. The Queue is full.")
+          when ["Suppressed"]
+            handle_failure(200, "Notification was received but suppressed by the service.")
+          end
+        end
+
+        def not_acceptable(response)
+          retry_notification("Per-day throttling limit reached.")
+        end
+
+        def precondition_failed(response)
+          retry_notification("Device unreachable.")
+        end
+
+        def service_unavailable(response)
+          mark_retryable_exponential(@notification)
+          log_warn("Service Unavailable. " + retry_message)
+        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 retry_notification(reason)
+          deliver_after = Time.now + (60*60)
+          mark_retryable(@notification, deliver_after)
+          log_warn("#{reason} " + retry_message)
+        end
+
+        def do_post
+          body = notification_to_xml
+          header = {
+            "Content-Length" => body.length.to_s,
+            "Content-Type" => "text/xml",
+            "X-WindowsPhone-Target" => "toast",
+            "X-NotificationClass" => '2'
+          }
+          post = Net::HTTP::Post.new(URI.parse(@notification.uri).path, initheader=header)
+          post.body = body
+          @http.request(URI.parse(@notification.uri), post)
+        end
+
+        def status_from_response(response)
+          headers = response.to_hash
+          {
+            notification:         headers["x-notificationstatus"],
+            notification_channel: headers["x-subscriptionstatus"],
+            device_connection:    headers["x-deviceconnectionstatus"]
+          }
+        end
+
+        def notification_to_xml
+          msg = @notification.alert.gsub(/&/, "&amp;").gsub(/</, "&lt;") \
+            .gsub(/>/, "&gt;").gsub(/'/, "&apos;").gsub(/"/, "&quot;")
+          <<-EOF
+<?xml version="1.0" encoding="utf-8"?>
+<wp:Notification xmlns:wp="WPNotification">
+  <wp:Toast>
+    <wp:Text1>#{msg}</wp:Text1>
+  </wp:Toast>
+</wp:Notification>
+          EOF
+        end
+      end
+    end
+  end
+end

data/lib/rpush/daemon/wpns.rb

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

data/lib/rpush/daemon.rb

@@ -0,0 +1,140 @@
+require 'thread'
+require 'socket'
+require 'pathname'
+require 'openssl'
+
+require 'net/http/persistent'
+
+require 'rpush/daemon/constants'
+require 'rpush/daemon/reflectable'
+require 'rpush/daemon/loggable'
+require 'rpush/daemon/interruptible_sleep'
+require 'rpush/daemon/delivery_error'
+require 'rpush/daemon/retryable_error'
+require 'rpush/daemon/too_many_requests_error'
+require 'rpush/daemon/delivery'
+require 'rpush/daemon/feeder'
+require 'rpush/daemon/batch'
+require 'rpush/daemon/app_runner'
+require 'rpush/daemon/tcp_connection'
+require 'rpush/daemon/dispatcher_loop'
+require 'rpush/daemon/dispatcher_loop_collection'
+require 'rpush/daemon/dispatcher/http'
+require 'rpush/daemon/dispatcher/tcp'
+require 'rpush/daemon/service_config_methods'
+require 'rpush/daemon/retry_header_parser'
+
+require 'rpush/daemon/apns/delivery'
+require 'rpush/daemon/apns/disconnection_error'
+require 'rpush/daemon/apns/certificate_expired_error'
+require 'rpush/daemon/apns/feedback_receiver'
+require 'rpush/daemon/apns'
+
+require 'rpush/daemon/gcm/delivery'
+require 'rpush/daemon/gcm'
+
+require 'rpush/daemon/wpns/delivery'
+require 'rpush/daemon/wpns'
+
+require 'rpush/daemon/adm/delivery'
+require 'rpush/daemon/adm'
+
+module Rpush
+  module Daemon
+    class << self
+      attr_accessor :store
+    end
+
+    def self.start
+      setup_signal_traps if trap_signals?
+
+      initialize_store
+      return unless store
+
+      if daemonize?
+        daemonize
+        store.after_daemonize
+      end
+
+      write_pid_file
+      AppRunner.sync
+      Feeder.start
+    end
+
+    def self.shutdown(quiet = false)
+      puts "\nShutting down..." unless quiet
+      Feeder.stop
+      AppRunner.stop
+      delete_pid_file
+    end
+
+    def self.initialize_store
+      return if store
+      begin
+        name = Rpush.config.store.to_s
+        require "rpush/daemon/store/#{name}"
+        self.store = Rpush::Daemon::Store.const_get(name.camelcase).new
+      rescue StandardError, LoadError => e
+        Rpush.logger.error("Failed to load '#{Rpush.config.store}' storage backend.")
+        Rpush.logger.error(e)
+      end
+    end
+
+    protected
+
+    def self.daemonize?
+      !(Rpush.config.foreground || Rpush.config.embedded || Rpush.jruby?)
+    end
+
+    def self.trap_signals?
+      !Rpush.config.embedded
+    end
+
+    def self.setup_signal_traps
+      @shutting_down = false
+
+      Signal.trap('SIGHUP') { AppRunner.sync }
+      Signal.trap('SIGUSR2') { AppRunner.debug }
+
+      ['SIGINT', 'SIGTERM'].each do |signal|
+        Signal.trap(signal) { handle_shutdown_signal }
+      end
+    end
+
+    def self.handle_shutdown_signal
+      exit 1 if @shutting_down
+      @shutting_down = true
+      shutdown
+    end
+
+    def self.write_pid_file
+      if !Rpush.config.pid_file.blank?
+        begin
+          File.open(Rpush.config.pid_file, 'w') { |f| f.puts Process.pid }
+        rescue SystemCallError => e
+          Rpush.logger.error("Failed to write PID to '#{Rpush.config.pid_file}': #{e.inspect}")
+        end
+      end
+    end
+
+    def self.delete_pid_file
+      pid_file = Rpush.config.pid_file
+      File.delete(pid_file) if !pid_file.blank? && File.exists?(pid_file)
+    end
+
+    # :nocov:
+    def self.daemonize
+      if RUBY_VERSION < "1.9"
+        exit if fork
+        Process.setsid
+        exit if fork
+        Dir.chdir "/"
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen "/dev/null", "a"
+      else
+        Process.daemon
+      end
+    end
+  end
+end

data/lib/rpush/deprecatable.rb

@@ -0,0 +1,23 @@
+module Rpush
+  module Deprecatable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def deprecated(method_name, version, msg=nil)
+        instance_eval do
+          alias_method "#{method_name}_without_warning", method_name
+        end
+        warning = "#{method_name} is deprecated and will be removed from Rpush #{version}."
+        warning << " #{msg}" if msg
+        class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{method_name}(*args, &blk)
+            Rpush::Deprecation.warn(#{warning.inspect})
+            #{method_name}_without_warning(*args, &blk)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rpush/deprecation.rb

@@ -0,0 +1,23 @@
+module Rpush
+  class Deprecation
+    def self.muted
+      begin
+        orig_val = Thread.current[:rpush_mute_deprecations]
+        Thread.current[:rpush_mute_deprecations] = true
+        yield
+      ensure
+        Thread.current[:rpush_mute_deprecations] = orig_val
+      end
+    end
+
+    def self.muted?
+      Thread.current[:rpush_mute_deprecations] == true
+    end
+
+    def self.warn(msg)
+      unless Rpush::Deprecation.muted?
+        STDERR.puts "DEPRECATION WARNING: #{msg}"
+      end
+    end
+  end
+end

data/lib/rpush/embed.rb

@@ -0,0 +1,28 @@
+module Rpush
+  def self.embed(options = {})
+    Rpush.require_for_daemon
+
+    config = Rpush::ConfigurationWithoutDefaults.new
+    options.each { |k, v| config.send("#{k}=", v) }
+    config.embedded = true
+    Rpush.config.update(config)
+    Rpush::Daemon.start
+
+    Kernel.at_exit { shutdown }
+  end
+
+  def self.shutdown
+    return unless Rpush.config.embedded
+    Rpush::Daemon.shutdown
+  end
+
+  def self.sync
+    return unless Rpush.config.embedded
+    Rpush::Daemon::AppRunner.sync
+  end
+
+  def self.debug
+    return unless Rpush.config.embedded
+    Rpush::Daemon::AppRunner.debug
+  end
+end

data/lib/rpush/gcm/app.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Gcm
+    class App < Rpush::App
+      validates :auth_key, :presence => true
+
+      def service_name
+        'gcm'
+      end
+    end
+  end
+end

data/lib/rpush/gcm/expiry_collapse_key_mutual_inclusion_validator.rb

@@ -0,0 +1,11 @@
+module Rpush
+  module Gcm
+    class ExpiryCollapseKeyMutualInclusionValidator < ActiveModel::Validator
+      def validate(record)
+        if record.collapse_key && !record.expiry
+          record.errors[:expiry] << "must be set when using a collapse_key"
+        end
+      end
+    end
+  end
+end

data/lib/rpush/gcm/notification.rb

@@ -0,0 +1,30 @@
+module Rpush
+  module Gcm
+    class Notification < Rpush::Notification
+      validates :registration_ids, :presence => true
+
+      validates_with Rpush::PayloadDataSizeValidator, limit: 4096
+      validates_with Rpush::RegistrationIdsCountValidator, limit: 1000
+
+      validates_with Rpush::Gcm::ExpiryCollapseKeyMutualInclusionValidator
+
+      def as_json
+        json = {
+          'registration_ids' => registration_ids,
+          'delay_while_idle' => delay_while_idle,
+          'data' => data
+        }
+
+        if collapse_key
+          json['collapse_key'] = collapse_key
+        end
+
+        if expiry
+          json['time_to_live'] = expiry
+        end
+
+        json
+      end
+    end
+  end
+end

data/lib/rpush/logger.rb

@@ -0,0 +1,63 @@
+module Rpush
+  class Logger
+    def initialize(options)
+      @options = options
+
+      begin
+        log_dir = File.join(Rails.root, 'log')
+        FileUtils.mkdir_p(log_dir)
+        log = File.open(File.join(log_dir, 'rpush.log'), 'a')
+        log.sync = true
+        setup_logger(log)
+      rescue Errno::ENOENT, Errno::EPERM => e
+        @logger = nil
+        error(e)
+        error('Logging disabled.')
+      end
+    end
+
+    def info(msg)
+      log(:info, msg)
+    end
+
+    def error(msg)
+      log(:error, msg, 'ERROR', STDERR)
+    end
+
+    def warn(msg)
+      log(:warn, msg, 'WARNING', STDERR)
+    end
+
+    private
+
+    def setup_logger(log)
+      if Rpush.config.logger
+        @logger = Rpush.config.logger
+      elsif ActiveSupport.const_defined?('BufferedLogger')
+        @logger = ActiveSupport::BufferedLogger.new(log, Rails.logger.level)
+        @logger.auto_flushing = Rails.logger.respond_to?(:auto_flushing) ? Rails.logger.auto_flushing : true
+      else
+        @logger = ActiveSupport::Logger.new(log, Rails.logger.level)
+      end
+    end
+
+    def log(where, msg, 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 << "[#{prefix}] " if prefix
+      formatted_msg << msg
+
+      if io == STDERR
+        io.puts formatted_msg
+      elsif @options[:foreground]
+        io.puts formatted_msg
+      end
+
+      @logger.send(where, formatted_msg) if @logger
+    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