apn_sender 1.0.6 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d85dcde79eb0f21533547c631b827e73081d5167
+  data.tar.gz: a3bd028152b5f7ee6960b1516bf87b2fa7abdce8
+SHA512:
+  metadata.gz: 96a448c4a6d1ed2fcc9807617eea4171e876ef45f7dd94b41925ca84c81f656404ef526ab590f7d30612571bd3ecab4f47621aabe44aeb66c5c3909b89794da5
+  data.tar.gz: 12b386591581bdcb234d0dd90de44f0836ad27705aedeeefcc6e0333d5225207fdabd0e085c0cf2675abfbbed1b725d716611ca859ea06c60a6ffe9cb1385a46

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Version 2.0
+## 2.0.0
+- adding connection_pool for handle apple sockets
+- removing resque hard dependency
+- adding support for sending sync messages
+- adding Thread support
+- adding support to sidekiq (Caue Guerra)
+- truncation messages when payload is greater than 256 option (Caue Guerra)
+
+# Version 1.0
+## 1.0.6
+- Added support for password-protected .pem files
+- Read feedback data in 38-byte chunks
+- Support passing dictionary as :alert key
+- Logging to STDOUT if no other loggers present

data/README.md

@@ -1,6 +1,9 @@
+[![Code Climate](https://codeclimate.com/github/arthurnn/apn_sender.png)](https://codeclimate.com/github/arthurnn/apn_sender)
+[![Build Status](https://travis-ci.org/arthurnn/apn_sender.png)](https://travis-ci.org/arthurnn/apn_sender)
+
 ## UPDATE May 3, 2013: current status
 
-This project was not supported for a while, but we are going to support it again. 
+This project was not supported for a while, but we are going to support it again.
 
 -----
 
@@ -19,7 +22,7 @@ The apn_sender gem includes a background daemon which processes background messa
 Yup.  There's some great code out there already, but we didn't like the idea of getting banned from the APN gateway for establishing a new connection each time we needed to send a batch of messages, and none of the libraries I found handled maintaining a persistent connection.
 
 ## Current Status
-This gem has been in production on 500px,sending million of notifications.
+This gem has been used in production, on 500px, sending millions of notifications.
 
 ## Usage
 
@@ -28,7 +31,7 @@ This gem has been in production on 500px,sending million of notifications.
 To queue a message for sending through Apple's Push Notification service from your Rails application:
 
 ```
-APN.notify(token, opts_hash)
+APN.notify_async(token, opts_hash)
 ```
 
 where ```token``` is the unique identifier of the iPhone to receive the notification and ```opts_hash``` can have any of the following keys:
@@ -59,10 +62,9 @@ For production, you're probably better off running a dedicated daemon and settin
 ./script/generate apn_sender
 
  # To run daemon. Pass --help to print all options
-./script/apn_sender --environment#production --verbose start
+./script/apn_sender start
 ```
 
-Note the --environment must be explicitly set (separately from your <code>Rails.env</code>) to production in order to send messages via the production APN servers.  Any other environment sends messages through Apple's sandbox servers at <code>gateway.sandbox.push.apple.com</code>.
 
 Also, there are two similar options: ```:cert_path``` and ```:full_cert_path```.  The former specifies the directory in which to find the .pem file (either apn_production.pem or apn_development.pem, depending on the environment). The latter specifies a .pem file explicitly, allowing customized certificate names if needed.
 
@@ -70,7 +72,7 @@ Check ```logs/apn_sender.log``` for debugging output.  In addition to logging an
 
 
 ### 3. Checking Apple's Feedback Service
-  
+
 Since push notifications are a fire-and-forget sorta deal, where you get no indication if your message was received (or if the specified recipient even exists), Apple needed to come up with some other way to ensure their network isn't clogged with thousands of bogus messages (e.g. from developers sending messages to phones where their application <em>used</em> to be installed, but where the user has since removed it).  Hence, the Feedback Service.
 
 It's actually really simple - you connect to them periodically and they give you a big dump of tokens you shouldn't send to anymore.  The gem wraps this up nicely -- just call:
@@ -78,9 +80,9 @@ It's actually really simple - you connect to them periodically and they give you
 ```
  # APN::Feedback accepts the same optional :environment
  # and :cert_path / :full_cert_path options as APN::Sender
- feedback # APN::Feedback.new()
+ feedback = APN::Feedback.new()
 
- tokens # feedback.tokens # #> Array of device tokens
+ tokens = feedback.tokens # Array of device tokens
  tokens.each do |token|
    # ... custom logic here to stop you app from
    # sending further notifications to this token
@@ -90,7 +92,7 @@ It's actually really simple - you connect to them periodically and they give you
 If you're interested in knowing exactly <em>when</em> Apple determined each token was expired (which can be useful in determining if the application re-registered with your service since it first appeared in the expired queue):
 
 ```
- items # feedback.data # #> Array of APN::FeedbackItem elements
+ items = feedback.data # Array of APN::FeedbackItem elements
  items.each do |item|
    item.token
    item.timestamp
@@ -110,15 +112,15 @@ If you're sending notifications, you should definitely call one of the ```receiv
 Just for the record, this is essentially what you want to have whenever run periodically for you:
 ```
 def self.clear_uninstalled_applications
-  feedback_data # APN::Feedback.new(:environment #> :production).data
-  
+  feedback_data = APN::Feedback.new(:environment #> :production).data
+
   feedback_data.each do |item|
-    user # User.find_by_iphone_token( item.token )
-      
+    user = User.find_by_iphone_token( item.token )
+
     if user.iphone_token_updated_at && user.iphone_token_updated_at > item.timestamp
       return true # App has been reregistered since Apple determined it'd been uninstalled
     else
-      user.update_attributes(:iphone_token #> nil, :iphone_token_updated_at #> Time.now) 
+      user.update_attributes(iphone_token: nil, iphone_token_updated_at: Time.now)
     end
   end
 end
@@ -141,12 +143,12 @@ In your Rails app, add (2.3.x):
 
 ```
   config.gem 'apn_sender', :lib => 'apn'
-``` 
+```
 or (3.x) to your Gemfile:
 
-```  
+```
   gem 'apn_sender', require: 'apn'
-```  
+```
 To add a few useful rake tasks for running workers, add the following line to your Rakefile:
 
 ```
@@ -155,4 +157,4 @@ To add a few useful rake tasks for running workers, add the following line to yo
 
 ## Copyright
 
-Copyright (c) 2010 Kali Donovan. See LICENSE for details.
+Copyright (c) 2013 Arthur Nogueira Neves. See LICENSE for details.

data/lib/apn.rb

@@ -1,13 +1,96 @@
-require 'resque'
-require 'resque/plugins/access_worker_from_job'
-require 'resque/hooks/before_unregister_worker'
-require 'json'
-require 'active_support'
-
-require 'apn/queue_name'
-require 'apn/queue_manager'
+require "openssl"
+require "socket"
+require "active_support/core_ext"
+require "active_support/json"
+require 'connection_pool'
+
+require "apn/version"
+require 'apn/connection'
+
+module APN
+
+  class << self
+    include APN::Connection
+
+    def notify_async(token, opts = {})
+      token = token.to_s.gsub(/\W/, '')
+      backend.notify(token, opts)
+    end
+
+    def notify_sync(token, opts)
+      token = token.to_s.gsub(/\W/, '')
+      msg = APN::Notification.new(token, opts)
+      raise "Invalid notification options (did you provide :alert, :badge, or :sound?): #{opts.inspect}" unless msg.valid?
+
+      APN.with_connection do |client|
+        client.push(msg)
+      end
+    end
+
+    def backend=(backend)
+      @backend = backend
+    end
+
+    def backend
+      @backend ||=
+        if defined?(Sidekiq)
+          APN::Backend::Sidekiq.new
+        elsif defined?(Resque)
+          APN::Backend::Resque.new
+        else
+          APN::Backend::Simple.new
+        end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def truncate_alert
+      @truncate_alert ||= false
+    end
+
+    def truncate_alert=(truncate)
+      @truncate_alert = truncate
+    end
+
+    # Log message to any logger provided by the user (e.g. the Rails logger).
+    # Accepts +log_level+, +message+, since that seems to make the most sense,
+    # and just +message+, to be compatible with Resque's log method and to enable
+    # sending verbose and very_verbose worker messages to e.g. the rails logger.
+    #
+    # Perhaps a method definition of +message, +level+ would make more sense, but
+    # that's also the complete opposite of what anyone comming from rails would expect.
+    def log(level, message = nil)
+      level, message = 'info', level if message.nil? # Handle only one argument if called from Resque, which expects only message
+
+      return false unless logger && logger.respond_to?(level)
+      logger.send(level, "#{Time.now}: #{message}")
+    end
+
+    # Log the message first, to ensure it reports what went wrong if in daemon mode.
+    # Then die, because something went horribly wrong.
+    def log_and_die(msg)
+      logger.fatal(msg)
+      raise msg
+    end
+  end
+end
+
 require 'apn/notification'
-require 'apn/notification_job'
-require 'apn/connection/base'
-require 'apn/sender'
-require 'apn/feedback'
+require 'apn/client'
+require 'apn/feedback'
+
+module APN::Jobs
+  QUEUE_NAME = :apple_push_notifications
+end
+
+require 'apn/jobs/sidekiq_notification_job' if defined?(Sidekiq)
+require 'apn/jobs/resque_notification_job' if defined?(Resque)
+require "apn/railtie" if defined?(Rails)
+
+require 'apn/backend'

data/lib/apn/backend.rb

@@ -0,0 +1,34 @@
+module APN
+  module Backend
+
+    class Sidekiq
+
+      def notify(token, opts)
+        ::Sidekiq::Client.enqueue(APN::Jobs::SidekiqNotificationJob, token, opts)
+      end
+    end
+
+    class Resque
+
+      def notify(token, opts)
+        ::Resque.enqueue(APN::Jobs::ResqueNotificationJob, token, opts)
+      end
+    end
+
+    class Simple
+
+      def notify(token, opts)
+        Thread.new do
+          APN.notify_sync(token, opts)
+        end
+      end
+    end
+
+    class Null
+
+      def notify(token, opts)
+        APN.log("Null Backend sending message to #{token}")
+      end
+    end
+  end
+end

data/lib/apn/client.rb

@@ -0,0 +1,65 @@
+module APN
+  class Client
+
+    DEFAULTS = {port: 2195, host: "gateway.push.apple.com"}
+
+    def initialize(options = {})
+      options = DEFAULTS.merge options.reject{|k,v| v.nil?}
+      @apn_cert, @cert_pass = options[:certificate], options[:password]
+      @host, @port = options[:host], options[:port]
+      self
+    end
+
+    def push(message)
+      socket.write(message.to_s)
+      socket.flush
+      if IO.select([socket], nil, nil, 1) && error = socket.read(6)
+        error = error.unpack("ccN")
+        APN.log(:error, "Error on message: #{error}")
+        return false
+      end
+
+      APN.log(:debug, "Message sent.")
+      true
+    end
+
+    def feedback
+      if bunch = socket.read(38)
+        f = bunch.strip.unpack('N1n1H140')
+        APN::FeedbackItem.new(Time.at(f[0]), f[2])
+      end
+    end
+
+    def socket
+      @socket ||= setup_socket
+    end
+
+    private
+    # Open socket to Apple's servers
+    def setup_socket
+      ctx = setup_certificate
+
+      APN.log(:debug, "Connecting to #{@host}:#{@port}...")
+
+      socket_tcp = TCPSocket.new(@host, @port)
+      OpenSSL::SSL::SSLSocket.new(socket_tcp, ctx).tap do |s|
+        s.sync = true
+        s.connect
+      end
+    end
+
+    def setup_certificate
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.cert = OpenSSL::X509::Certificate.new(@apn_cert)
+      if @cert_pass
+        ctx.key = OpenSSL::PKey::RSA.new(@apn_cert, @cert_pass)
+        APN.log(:debug, "Setting up certificate using a password.")
+
+      else
+        ctx.key = OpenSSL::PKey::RSA.new(@apn_cert)
+      end
+      ctx
+    end
+
+  end
+end

data/lib/apn/connection.rb

@@ -0,0 +1,39 @@
+module APN
+  module Connection
+    # APN::Connection::Base takes care of all the boring certificate loading, socket creating, and logging
+    # responsibilities so APN::Sender and APN::Feedback and focus on their respective specialties.
+    def connection_pool
+      @pool ||= ConnectionPool.new(size: (pool_size || 1), timeout: (pool_timeout || 5)) do
+        APN::Client.new(host: host,
+                        port: port,
+                        certificate: certificate,
+                        password: password)
+      end
+    end
+
+    def with_connection(&block)
+      connection_pool.with(&block)
+    end
+
+    # pool config
+    attr_accessor :pool_size, :pool_timeout
+
+    attr_accessor :host, :port, :root, :full_certificate_path, :password
+
+    def certificate
+      @apn_cert ||= File.read(certificate_path)
+    end
+
+    def certificate_path
+      full_certificate_path || File.join(root, certificate_name)
+    end
+
+    def certificate_name
+      @cert_name || "apn_production.pem"
+    end
+
+    def certificate_name=(name)
+      @cert_name = name
+    end
+  end
+end

data/lib/apn/feedback.rb

@@ -1,5 +1,3 @@
-require 'apn/connection/base'
-
 module APN
   # Encapsulates data returned from the {APN Feedback Service}[http://developer.apple.com/iphone/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingWIthAPS/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW3].
   # Possesses +timestamp+ and +token+ attributes.
@@ -22,7 +20,10 @@ module APN
   #
   # See README for usage and details.
   class Feedback
-    include APN::Connection::Base
+
+    def initialize(options = {})
+      @apn_host, @apn_port = options[:host], options[:port]
+    end
 
     # Returns array of APN::FeedbackItem elements read from Apple. Connects to Apple once and caches the
     # data, continues to returns cached data unless called with <code>data(true)</code>, which clears the
@@ -45,7 +46,7 @@ module APN
 
     # Prettify to return meaningful status information when printed. Can't add these directly to connection/base, because Resque depends on decoding to_s
     def to_s
-      "#{@socket ? 'Connected' : 'Connection not currently established'} to #{apn_host} on #{apn_port}"
+      "#{@socket ? 'Connected' : 'Connection not currently established'} to #{host} on #{port}"
     end
 
     protected
@@ -53,31 +54,26 @@ module APN
     # Connects to Apple's Feedback Service and checks if there's anything there for us.
     # Returns an array of APN::FeedbackItem pairs
     def receive
-      feedback = []
-
-      # Hi Apple
-      setup_connection
-
-      # Unpacking code borrowed from http://github.com/jpoz/APNS/blob/master/lib/apns/core.rb
-      while bunch = socket.read(38)   # Read data from the socket
-        f = bunch.strip.unpack('N1n1H140')
-        feedback << APN::FeedbackItem.new(Time.at(f[0]), f[2])
+      feedbacks = []
+      while f = client.feedback
+        feedbacks << f
       end
-
-      # Bye Apple
-      teardown_connection
-
-      return feedback
+      return feedbacks
     end
 
-
-    def apn_host
-      @apn_host ||= apn_production? ? "feedback.push.apple.com" : "feedback.sandbox.push.apple.com"
+    def client
+      @client ||= APN::Client.new(host: host,
+                                  port: port,
+                                  certificate: APN.certificate,
+                                  password: APN.password)
     end
 
-    def apn_port
-      2196
+    def host
+      @apn_host || "feedback.push.apple.com"
     end
 
+    def port
+      @apn_port || 2196
+    end
   end
 end

data/lib/apn/jobs/resque_notification_job.rb

@@ -0,0 +1,15 @@
+module APN::Jobs
+  # This is the class that's actually enqueued via Resque when user calls +APN.notify+.
+  # It gets added to the +apple_server_notifications+ Resque queue, which should only be operated on by
+  # workers of the +APN::Sender+ class.
+  class ResqueNotificationJob
+
+    # Behind the scenes, this is the name of our Resque queue
+    @queue = QUEUE_NAME
+
+    # Build a notification from arguments and send to Apple
+    def self.perform(token, opts)
+      APN.notify_sync(token, opts)
+    end
+  end
+end

data/lib/apn/jobs/sidekiq_notification_job.rb

@@ -0,0 +1,15 @@
+module APN::Jobs
+  # This is the class that's actually enqueued via Resque when user calls +APN.notify+.
+  # It gets added to the +apple_server_notifications+ Resque queue, which should only be operated on by
+  # workers of the +APN::Sender+ class.
+  class SidekiqNotificationJob
+    include Sidekiq::Worker
+    # Behind the scenes, this is the name of our Sidekiq queue
+    @queue = QUEUE_NAME
+
+    # Build a notification from arguments and send to Apple
+    def perform(token, opts)
+      APN.notify_sync(token, opts)
+    end
+  end
+end

data/lib/apn/notification.rb

@@ -22,12 +22,15 @@ module APN
     # Each iPhone Notification payload must be 256 or fewer characters.  Encoding a null message has a 57
     # character overhead, so there are 199 characters available for the alert string.
     MAX_ALERT_LENGTH = 199
+    DATA_MAX_BYTES = 256
 
     attr_accessor :options, :token
     def initialize(token, opts)
       @options = opts.is_a?(Hash) ? opts.symbolize_keys : {:alert => opts}
       @token = token
 
+      truncate_alert! if APN.truncate_alert
+
       raise "The maximum size allowed for a notification payload is 256 bytes." if packaged_notification.size.to_i > 256
     end
 
@@ -41,8 +44,6 @@ module APN
       false
     end
 
-    protected
-
     # Completed encoded notification, ready to send down the wire to Apple
     def packaged_notification
       pt = packaged_token
@@ -73,5 +74,15 @@ module APN
       ActiveSupport::JSON::encode(hsh)
     end
 
+    def truncate_alert!
+      while packaged_notification.size.to_i > DATA_MAX_BYTES
+        if @options[:alert].is_a? Hash
+          last = @options[:alert]['loc-args'].pop
+          @options[:alert]['loc-args'] << last[0..-2]
+        else
+          @options[:alert] = @options[:alert][0..-2]
+        end
+      end
+    end
   end
 end

data/lib/apn/railtie.rb

@@ -0,0 +1,16 @@
+module APN
+  class Railtie < Rails::Railtie
+    initializer "apn.setup" do |app|
+
+      APN.root = File.join(Rails.root, "config", "certs")
+      if Rails.env.development?
+        APN.certificate_name =  "apn_development.pem"
+        APN.host =  "gateway.sandbox.push.apple.com"
+      end
+
+      logger = Logger.new(File.join(Rails.root, 'log', 'apn_sender.log'))
+      APN.logger = logger
+
+    end
+  end
+end

data/lib/apn/sender_daemon.rb

@@ -3,6 +3,7 @@ require 'rubygems'
 require 'daemons'
 require 'optparse'
 require 'logger'
+require 'resque'
 
 module APN
   # A wrapper designed to daemonize an APN::Sender instance to keep in running in the background.
@@ -12,10 +13,10 @@ module APN
   # Based off delayed_job's great example, except we can be much lighter by not loading the entire
   # Rails environment.  To use in a Rails app, <code>script/generate apn_sender</code>.
   class SenderDaemon
-    
+
     def initialize(args)
-      @options = {:worker_count => 1, :environment => :development, :delay => 5}
-      
+      @options = {worker_count: 1, delay: 5}
+
       optparse = OptionParser.new do |opts|
         opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
 
@@ -23,59 +24,52 @@ module APN
           puts opts
           exit 1
         end
-        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this apn_sender under ([development]/production).') do |e|
-          @options[:environment] = e
-        end
-        opts.on('--cert-path=NAME', 'Path to directory containing apn .pem certificates.') do |path|
-          @options[:cert_path] = path
+        opts.on('--cert-path=PATH', 'Path to directory containing apn .pem certificates.') do |path|
+          @options[:cert_root] = path
         end
-        opts.on('c', '--full-cert-path=NAME', 'Full path to desired .pem certificate (overrides environment selector).') do |path|
+        opts.on('c', '--full-cert-path=PATH', 'Full path to desired .pem certificate.') do |path|
           @options[:full_cert_path] = path
         end
         opts.on('--cert-pass=PASSWORD', 'Password for the apn .pem certificates.') do |pass|
           @options[:cert_pass] = pass
         end
+        opts.on('--cert-name=NAME', 'Certificate file name. Default: apn_production.pem') do |certificate_name|
+          @options[:certificate_name] = certificate_name
+        end
         opts.on('-n', '--number-of-workers=WORKERS', "Number of unique workers to spawn") do |worker_count|
           @options[:worker_count] = worker_count.to_i rescue 1
         end
-        opts.on('-v', '--verbose', "Turn on verbose mode") do
-          @options[:verbose] = true
-        end
-        opts.on('-V', '--very-verbose', "Turn on very verbose mode") do
-          @options[:very_verbose] = true
-        end
         opts.on('-d', '--delay=D', "Delay between rounds of work (seconds)") do |d|
           @options[:delay] = d
         end
       end
-      
+
       # If no arguments, give help screen
       @args = optparse.parse!(args.empty? ? ['-h'] : args)
-      @options[:verbose] = true if @options[:very_verbose]
     end
-  
+
     def daemonize
       @options[:worker_count].times do |worker_index|
         process_name = @options[:worker_count] == 1 ? "apn_sender" : "apn_sender.#{worker_index}"
-        Daemons.run_proc(process_name, :dir => "#{::RAILS_ROOT}/tmp/pids", :dir_mode => :normal, :ARGV => @args) do |*args|
-          run process_name
+        pids_dir = defined?(Rails) ? "#{::RAILS_ROOT}/tmp/pids" : "tmp/pids"
+        Daemons.run_proc(process_name, :dir => pids_dir, :dir_mode => :normal, :ARGV => @args) do |*args|
+          run(process_name)
         end
       end
     end
-    
+
     def run(worker_name = nil)
-      logger = Logger.new(File.join(::RAILS_ROOT, 'log', 'apn_sender.log'))
-      
-      worker = APN::Sender.new(@options)
-      worker.logger = logger
-      worker.verbose = @options[:verbose]
-      worker.very_verbose = @options[:very_verbose]
+      APN.password = @options[:cert_pass]
+      APN.full_certificate_path = @options[:full_cert_path]
+      APN.root = @options[:cert_root]
+      APN.certificate_name = @options[:certificate_name]
+
+      worker = ::Resque::Worker.new(APN::Jobs::QUEUE_NAME)
       worker.work(@options[:delay])
     rescue => e
       STDERR.puts e.message
-      logger.fatal(e) if logger && logger.respond_to?(:fatal)
       exit 1
     end
-    
+
   end
 end

data/lib/apn/tasks.rb

@@ -8,9 +8,16 @@ namespace :apn do
   task :sender => :setup do
     require 'apn'
 
-    worker = APN::Sender.new(:full_cert_path => ENV['FULL_CERT_PATH'], :cert_path => ENV['CERT_PATH'], :environment => ENV['ENVIRONMENT'], :cert_pass => ENV['CERT_PASS'])
-    worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
-    worker.very_verbose = ENV['VVERBOSE']
+    unless defined?(Resque)
+      puts "This rake task is only for resque workers"
+      return
+    end
+
+    APN.password = ENV['CERT_PASS']
+    APN.full_certificate_path =  ENV['FULL_CERT_PATH']
+    APN.logger = Rails.logger
+
+    worker = ::Resque::Worker.new(APN::Jobs::QUEUE_NAME)
 
     puts "*** Starting worker to send apple notifications in the background from #{worker}"
 
@@ -29,4 +36,4 @@ namespace :apn do
 
     threads.each { |thread| thread.join }
   end
-end
+end

data/lib/apn/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module APN
-  VERSION = "1.0.6"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apn_sender
 version: !ruby/object:Gem::Version
-  version: 1.0.6
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Kali Donovan
@@ -13,102 +12,94 @@ cert_chain: []
 date: 2011-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: resque
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: resque-access_worker_from_job
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: active_support
+  name: daemons
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Resque-based background worker to send Apple Push Notifications over
-  a persistent TCP socket. Includes Resque tweaks to allow persistent sockets between
-  jobs, helper methods for enqueueing APN notifications, and a background daemon to
-  send them.
+description: Background worker to send Apple Push Notifications over a persistent
+  TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper
+  methods for enqueueing APN notifications, and a background daemon to send them.
 email: arthurnn@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/apn/connection/base.rb
+- lib/apn/backend.rb
+- lib/apn/client.rb
+- lib/apn/connection.rb
 - lib/apn/feedback.rb
+- lib/apn/jobs/resque_notification_job.rb
+- lib/apn/jobs/sidekiq_notification_job.rb
 - lib/apn/notification.rb
-- lib/apn/notification_job.rb
-- lib/apn/queue_manager.rb
-- lib/apn/queue_name.rb
-- lib/apn/sender.rb
+- lib/apn/railtie.rb
 - lib/apn/sender_daemon.rb
 - lib/apn/tasks.rb
 - lib/apn/version.rb
 - lib/apn.rb
-- lib/resque/hooks/before_unregister_worker.rb
-- CHANGELOG
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
 homepage: http://github.com/arthurnn/apn_sender
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: Resque-based background worker to send Apple Push Notifications over a persistent
-  TCP socket.
+specification_version: 4
+summary: Background worker to send Apple Push Notifications over a persistent TCP
+  socket.
 test_files: []

data/CHANGELOG

@@ -1,5 +0,0 @@
-* 1.0.6
-- Added support for password-protected .pem files
-- Read feedback data in 38-byte chunks
-- Support passing dictionary as :alert key
-- Logging to STDOUT if no other loggers present

data/lib/apn/connection/base.rb

@@ -1,127 +0,0 @@
-require 'socket'
-require 'openssl'
-require 'resque'
-
-module APN
-  module Connection
-    # APN::Connection::Base takes care of all the boring certificate loading, socket creating, and logging
-    # responsibilities so APN::Sender and APN::Feedback and focus on their respective specialties.
-    module Base
-      attr_accessor :opts, :logger
-      
-      def initialize(opts = {})
-        @opts = opts
-
-        setup_logger
-        log(:info, "APN::Sender initializing. Establishing connections first...") if @opts[:verbose]
-        setup_paths
-
-        super( APN::QUEUE_NAME ) if self.class.ancestors.include?(Resque::Worker)
-      end
-      
-      # Lazy-connect the socket once we try to access it in some way
-      def socket
-        setup_connection unless @socket
-        return @socket
-      end
-            
-      protected
-      
-      # Default to Rails or Merg logger, if available
-      def setup_logger
-        @logger = if defined?(Merb::Logger)
-          Merb.logger
-        elsif defined?(::Rails.logger)
-          ::Rails.logger
-        end
-        @logger ||= Logger.new(STDOUT)
-      end
-      
-      # Log message to any logger provided by the user (e.g. the Rails logger).
-      # Accepts +log_level+, +message+, since that seems to make the most sense,
-      # and just +message+, to be compatible with Resque's log method and to enable
-      # sending verbose and very_verbose worker messages to e.g. the rails logger.
-      #
-      # Perhaps a method definition of +message, +level+ would make more sense, but
-      # that's also the complete opposite of what anyone comming from rails would expect.
-      alias_method(:resque_log, :log) if defined?(log)
-      def log(level, message = nil)
-        level, message = 'info', level if message.nil? # Handle only one argument if called from Resque, which expects only message
-
-        resque_log(message) if defined?(resque_log)
-        return false unless self.logger && self.logger.respond_to?(level)
-        self.logger.send(level, "#{Time.now}: #{message}")
-      end
-      
-      # Log the message first, to ensure it reports what went wrong if in daemon mode. 
-      # Then die, because something went horribly wrong.
-      def log_and_die(msg)
-        log(:fatal, msg)
-        raise msg
-      end
-      
-      def apn_production?
-        @opts[:environment] && @opts[:environment] != '' && :production == @opts[:environment].to_sym
-      end
-      
-      # Get a fix on the .pem certificate we'll be using for SSL
-      def setup_paths
-        @opts[:environment] ||= ::Rails.env if defined?(::Rails.env)
-
-        # Accept a complete :full_cert_path allowing arbitrary certificate names, or create a default from the Rails env
-        cert_path = @opts[:full_cert_path] || begin
-          # Note that RAILS_ROOT is still here not from Rails, but to handle passing in root from sender_daemon
-          @opts[:root_path] ||= defined?(::Rails.root) ? ::Rails.root.to_s : (defined?(RAILS_ROOT) ? RAILS_ROOT : '/')
-          @opts[:cert_path] ||= File.join(File.expand_path(@opts[:root_path]), "config", "certs")
-          @opts[:cert_name] ||= apn_production? ? "apn_production.pem" : "apn_development.pem"
-
-          File.join(@opts[:cert_path], @opts[:cert_name])
-        end
-        
-        @apn_cert = File.read(cert_path) if File.exists?(cert_path)
-        log_and_die("Please specify correct :full_cert_path. No apple push notification certificate found in: #{cert_path}") unless @apn_cert
-      end
-      
-      # Open socket to Apple's servers
-      def setup_connection
-        log_and_die("Missing apple push notification certificate") unless @apn_cert
-        return true if @socket && @socket_tcp
-        log_and_die("Trying to open half-open connection") if @socket || @socket_tcp
-
-        ctx = OpenSSL::SSL::SSLContext.new
-        ctx.cert = OpenSSL::X509::Certificate.new(@apn_cert)
-        
-        if @opts[:cert_pass]
-          ctx.key = OpenSSL::PKey::RSA.new(@apn_cert, @opts[:cert_pass])
-        else
-          ctx.key = OpenSSL::PKey::RSA.new(@apn_cert)
-        end
-
-        @socket_tcp = TCPSocket.new(apn_host, apn_port)
-        @socket = OpenSSL::SSL::SSLSocket.new(@socket_tcp, ctx)
-        @socket.sync = true
-        @socket.connect
-      rescue SocketError => error
-        log_and_die("Error with connection to #{apn_host}: #{error}")
-      end
-
-      # Close open sockets
-      def teardown_connection
-        log(:info, "Closing connections...") if @opts[:verbose]
-
-        begin
-          @socket.close if @socket
-        rescue Exception => e
-          log(:error, "Error closing SSL Socket: #{e}")
-        end
-
-        begin
-          @socket_tcp.close if @socket_tcp
-        rescue Exception => e
-          log(:error, "Error closing TCP Socket: #{e}")
-        end
-      end
-      
-    end
-  end
-end

data/lib/apn/notification_job.rb

@@ -1,24 +0,0 @@
-module APN
-  # This is the class that's actually enqueued via Resque when user calls +APN.notify+.
-  # It gets added to the +apple_server_notifications+ Resque queue, which should only be operated on by
-  # workers of the +APN::Sender+ class.
-  class NotificationJob
-    # Behind the scenes, this is the name of our Resque queue
-    @queue = APN::QUEUE_NAME
-
-    # Build a notification from arguments and send to Apple
-    def self.perform(token, opts)
-      msg = APN::Notification.new(token, opts)
-      raise "Invalid notification options (did you provide :alert, :badge, or :sound?): #{opts.inspect}" unless msg.valid?
-
-      raise "APN::NotificationJob was picked up by a non-APN:Sender resque worker. Aborting." unless worker
-      worker.send_to_apple(msg)
-    end
-
-
-    # Only execute this job in specialized APN::Sender workers, since
-    # standard Resque workers don't maintain the persistent TCP connection.
-    extend Resque::Plugins::AccessWorkerFromJob
-    self.required_worker_class = 'APN::Sender'
-  end
-end

data/lib/apn/queue_manager.rb

@@ -1,57 +0,0 @@
-# Extending Resque to respond to the +before_unregister_worker+ hook. Note this requires a matching
-# monkeypatch in the Resque::Worker class. See +resque/hooks/before_unregister_worker.rb+ for an
-# example implementation
-
-module APN
-  # Enqueues a notification to be sent in the background via the persistent TCP socket, assuming apn_sender is running (or will be soon)
-  def self.notify(token, opts = {})
-    token = token.to_s.gsub(/\W/, '')
-    APN::QueueManager.enqueue(APN::NotificationJob, token, opts)
-  end  
-  
-  # Extends Resque, allowing us to add all the callbacks to Resque we desire without affecting the expected
-  # functionality in the parent app, if we're included in e.g. a Rails application.
-  class QueueManager
-    extend Resque
-
-    def self.before_unregister_worker(&block)
-      block ? (@before_unregister_worker = block) : @before_unregister_worker
-    end
-
-    def self.before_unregister_worker=(before_unregister_worker)
-      @before_unregister_worker = before_unregister_worker
-    end
-
-    def self.to_s
-      "APN::QueueManager (Resque Client) connected to #{redis.server}"
-    end
-  end
-  
-end
-
-# Ensures we close any open sockets when the worker exits
-APN::QueueManager.before_unregister_worker do |worker|
-  worker.send(:teardown_connection) if worker.respond_to?(:teardown_connection)
-end
-
-
-# # Run N jobs per fork, rather than creating a new fork for each notification
-# # By defunkt - http://gist.github.com/349376
-# APN::QueueManager.after_fork do |job|
-#   # How many jobs should we process in each fork?
-#   jobs_per_fork = 10
-# 
-#   # Set hook to nil to prevent running this hook over
-#   # and over while processing more jobs in this fork.
-#   Resque.after_fork = nil
-# 
-#   # Make sure we process jobs in the right order.
-#   job.worker.process(job)
-# 
-#   # One less than specified because the child will run a
-#   # final job after exiting this hook.
-#   (jobs_per_fork.to_i - 1).times do
-#     job.worker.process
-#   end
-# end
-

data/lib/apn/queue_name.rb

@@ -1,4 +0,0 @@
-module APN
-  # Change this to modify the queue from which notification jobs are pushed and pulled
-  QUEUE_NAME = :apple_push_notifications
-end

data/lib/apn/sender.rb

@@ -1,49 +0,0 @@
-module APN
-  # Subclass of Resque::Worker which initializes a single TCP socket on creation to communicate with Apple's Push Notification servers.
-  # Shares this socket with each child process forked off by Resque to complete a job. Socket is closed in the before_unregister_worker
-  # callback, which gets called on normal or exceptional exits.
-  #
-  # End result: single persistent TCP connection to Apple, so they don't ban you for frequently opening and closing connections,
-  # which they apparently view as a DOS attack.
-  #
-  # Accepts <code>:environment</code> (production vs anything else), <code>:cert_pass</code> and <code>:cert_path</code> options on initialization.  If called in a 
-  # Rails context, will default to RAILS_ENV and RAILS_ROOT/config/certs. :environment will default to development.  
-  # APN::Sender expects two files to exist in the specified <code>:cert_path</code> directory: 
-  # <code>apn_production.pem</code> and <code>apn_development.pem</code>.
-  #
-  # Use the <code>:cert_pass</code> option if your certificates require a password
-  #
-  # If a socket error is encountered, will teardown the connection and retry again twice before admitting defeat.
-  class Sender < ::Resque::Worker
-    include APN::Connection::Base
-    TIMES_TO_RETRY_SOCKET_ERROR = 2
-                                
-    # Send a raw string over the socket to Apple's servers (presumably already formatted by APN::Notification)
-    def send_to_apple( notification, attempt = 0 )
-      if attempt > TIMES_TO_RETRY_SOCKET_ERROR
-        log_and_die("Error with connection to #{apn_host} (retried #{TIMES_TO_RETRY_SOCKET_ERROR} times): #{error}")
-      end
-      
-      self.socket.write( notification.to_s )
-    rescue SocketError => error
-      log(:error, "Error with connection to #{apn_host} (attempt #{attempt}): #{error}")
-      
-      # Try reestablishing the connection
-      teardown_connection
-      setup_connection
-      send_to_apple(notification, attempt + 1)
-    end
-    
-    protected
-    
-    def apn_host
-      @apn_host ||= apn_production? ? "gateway.push.apple.com" : "gateway.sandbox.push.apple.com"
-    end
-    
-    def apn_port
-      2195
-    end
-
-  end
-
-end

data/lib/resque/hooks/before_unregister_worker.rb

@@ -1,30 +0,0 @@
-# Adding a +before_unregister_worker+ hook Resque::Worker. To be used, must be matched by a similar monkeypatch
-# for Resque class itself, or else a class that extends Resque. See apple_push_notification/queue_manager.rb for 
-# an implementation.
-module Resque
-  class Worker
-    alias_method :unregister_worker_without_before_hook, :unregister_worker
-
-    # Wrapper for original unregister_worker method which adds a before hook +before_unregister_worker+
-    # to be executed if present.
-    def unregister_worker
-      run_hook(:before_unregister_worker, self) 
-      unregister_worker_without_before_hook
-    end
-    
-    
-    # Unforunately have to override Resque::Worker's +run_hook+ method to call hook on 
-    # APN::QueueManager rather on Resque directly. Any suggestions on
-    # how to make this more flexible are more than welcome.
-    def run_hook(name, *args)
-      # return unless hook = Resque.send(name)
-      return unless hook = APN::QueueManager.send(name)
-      msg = "Running #{name} hook"
-      msg << " with #{args.inspect}" if args.any?
-      log msg
-
-      args.any? ? hook.call(*args) : hook.call
-    end
-    
-  end
-end