banjo-apn_sender 2.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kali Donovan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,124 @@
+== Synopsis
+
+Based on Kali Donovan's APN sender 1.x.
+
+In 2.0 we keep things lean - we removed the resque layer, and make APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.
+
+== The Story
+
+So you're building the server component of an iPhone application in Ruby.  And you want to send background notifications through the Apple Push Notification servers, which doesn't seem too bad at first.  But then you read in the {Apple Documentation}[https://developer.apple.com/iphone/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/WhatAreRemoteNotif/WhatAreRemoteNotif.html#//apple_ref/doc/uid/TP40008194-CH102-SW7] that Apple's servers may treat non-persistent connections as a Denial of Service attack, and you realize that Rails has no easy way to maintain a persistent connection internally, and things start looking more complicated.
+
+The apn_sender 2.0 gem is pluggable to run on delayed job workers, and processes background messages from your application and sends them along to Apple <em>over a single, persistent socket</em>.
+
+Same as 1.x, it also includes the ability to query the Feedback service, helper methods for enqueueing your jobs.
+
+== Yet another ApplePushNotification interface?
+
+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.
+
+== Usage
+
+=== 0. Setting up the pem certs
+
+Put your <code>apn_production.pem</code> and <code>apn_production_sandbox.pem</code> certificates from Apple in your <code>RAILS_ROOT/config/certs</code> directory.
+
+=== 1. Sending Messages From Your Application
+
+To send a message through Apple's Push Notification service from your Rails application:
+
+  APN::Connection.send(token, options, sandbox)
+
+where,
+  +token+ is the unique identifier of the iPhone to receive the notification 
+  +sandbox+ is a boolean to indicate if you are using the APN sandbox push server
+  +options+ can have any of the following keys:
+
+  # :alert  #=> The alert to send
+  # :badge  #=> The badge number to send
+  # :sound  #=> The sound file to play on receipt, or true to play the default sound installed with your app
+  # :custom #=> Anything else that goes to the root of the message
+
+If any other keys are present they'll be added to the root of the aps hash
+
+=== 2. Sending as Queued Message using delayed processes, ie: SideKiq as the example here
+
+  class ApnSideKiqWorker
+    sidekiq_options queue: :apn
+
+    def perform(token, options, sandbox = false)
+      APN::Connection.send(token, options, sandbox)
+    end
+  end
+
+  options = { alert: 'Hello from APN', sound: 'default.wav', badge: 10, extra: { id: 1234 } }
+  ApnSideKiqWorker.perform_async(device.token, options, device.build == 'development')
+
+Once this is done, you can fire off the SideKiq background worker with
+
+  $ sidekiq -c 5 -q apn
+  
+=== 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:
+
+  # APN::Feedback accepts the same optional :environment and :cert_path / :full_cert_path options as APN::Sender
+  feedback = APN::Feedback.new()
+
+  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
+  end
+  
+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.each do |item|
+    item.token
+    item.timestamp
+    # ... custom logic here
+  end
+
+The Feedback Service works as a big queue.  When you connect it pops off all its data and sends it over the wire at once, which means connecting a second time will return an empty array, so for ease of use a call to either +tokens+ or +data+ will connect once and cache the data.  If you call either one again it'll continue to use its cached version (rather than connecting to Apple a second time to retrieve an empty array, which is probably not what you want).
+
+Forcing a reconnect is as easy as calling either method with the single parameter +true+, but be sure you've already used the existing data because you'll never get it back.
+
+
+==== Warning: No really, check Apple's Feedback Service occasionally
+
+If you're sending notifications, you should definitely call one of the <code>receive</code> methods periodically, as Apple's policies require it and they apparently monitor providers for compliance.  I'd definitely recommend throwing together a quick rake task to take care of this for you (the {whenever library}[http://github.com/javan/whenever] provides a nice wrapper around scheduling tasks to run at certain times (for systems with cron enabled)).
+
+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.each do |item|
+      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) 
+      end
+    end
+  end
+
+
+== Installation
+
+Add this to your Gemfile:
+  
+  gem 'apn_sender', :require => 'apn'
+
+Then bunndle, 
+
+  $ bundle install
+
+
+== Copyright
+
+Copyright (c) 2010 Kali Donovan. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "apn_sender"
+    gem.summary = %Q{APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.}
+    gem.description = %Q{Based on Kali Donovan's APN sender 1.x. 2.0 keep things lean - we removed the resque layer, and make APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.}
+    gem.email = "kali.donovan@gmail.com justin@teambanjo.com"
+    gem.homepage = "http://github.com/BanjoInc/apn_sender"
+    gem.authors = ["Kali Donovan", "KW Justin Leung"]
+    gem.add_dependency 'yajl-ruby'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+2.0.0

data/apn_sender.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{banjo-apn_sender}
+  s.version = "2.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Kali Donovan}, %q{KW Justin Leung}]
+  s.date = %q{2012-06-19}
+  s.description = %q{Based on Kali Donovan's APN sender 1.x. 2.0 keep things lean - we removed the resque layer, and make APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.}
+  s.email = %q{kali.donovan@gmail.com justin@teambanjo.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "apn_sender.gemspec",
+    "lib/apn.rb",
+    "lib/apn/base.rb",
+    "lib/apn/feedback.rb",
+    "lib/apn/notification.rb"
+  ]
+  s.homepage = %q{http://github.com/BanjoInc/apn_sender}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{APN connection pluggable to multithreaded background worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<apn_sender>, [">= 0"])
+      s.add_runtime_dependency(%q<yajl-ruby>, [">= 0"])
+    else
+      s.add_dependency(%q<apn_sender>, [">= 0"])
+      s.add_dependency(%q<yajl-ruby>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<apn_sender>, [">= 0"])
+    s.add_dependency(%q<yajl-ruby>, [">= 0"])
+  end
+end
+

data/lib/apn/base.rb

@@ -0,0 +1,121 @@
+require 'socket'
+require 'openssl'
+
+module APN
+    # APN::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
+        setup_paths
+        log(:info, "APN::Sender with opts #{@opts}")
+      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 logger, if available
+      def setup_logger
+        @logger = defined?(::Rails.logger) ? ::Rails.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.
+      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 self.logger && self.logger.respond_to?(level)
+        self.logger.send(level, "[#{apn_environment}] #{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_enterprise?
+        @apn_enterprise ||= @opts[:enterprise].present?
+      end      
+
+      def apn_sandbox?
+        @apn_sandbox ||= @opts[:sandbox].present?
+      end
+      
+      def apn_enterprise?
+        @apn_enterprise ||= @opts[:enterprise].present?
+      end
+      
+      def apn_environment
+        @apn_envoironment ||= (apn_sandbox? ? 'sandbox' : 'production') + (apn_enterprise? ? '_enterprise' : '')
+      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_' + ::Rails.env + (apn_sandbox? ? '_sandbox' : '') + (apn_enterprise? ? '_enterprise' : '') + '.pem'
+
+          File.join(@opts[:cert_path], @opts[:cert_name])
+        end
+        
+        log(:info, "APN environment=#{apn_environment}, Rails environment=#{::Rails.env}, using cert #{cert_path}")
+        @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 && !@socket.closed? && !@socket_tcp.closed?
+        log_and_die("Trying to open half-open connection") if (@socket && !@socket.closed?) || (@socket_tcp && !@socket_tcp.closed?)
+
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.cert = OpenSSL::X509::Certificate.new(@apn_cert)
+        ctx.key = OpenSSL::PKey::RSA.new(@apn_cert)
+
+        @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 && !@socket_tcp.closed?
+        rescue Exception => e
+          log(:error, "Error closing TCP Socket: #{e}")
+        end
+      end
+    end
+end

data/lib/apn/feedback.rb

@@ -0,0 +1,91 @@
+require 'apn/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.
+  class FeedbackItem
+    attr_accessor :timestamp, :token
+
+    def initialize(time, token)
+      @timestamp = time
+      @token = token
+    end
+
+    # For convenience, return the token on to_s
+    def to_s
+      token
+    end
+  end
+  
+  # When supplied with the certificate path and the desired environment, connects to the {APN Feedback Service}[http://developer.apple.com/iphone/library/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingWIthAPS/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW3]
+  # and returns any response as an array of APN::FeedbackItem elements.
+  # 
+  # See README for usage and details.
+  class Feedback
+    include APN::Base
+        
+    # 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
+    # existing feedback array.  Note that once you force resetting the cache you loose all previous feedback,
+    # so be sure you've already processed it.
+    def data(force = nil)
+      @feedback = nil if force
+      @feedback ||= receive
+    end
+    
+    # Wrapper around +data+ returning just an array of token strings.
+    def tokens(force = nil)
+      data(force).map(&:token)
+    end
+    
+    # Prettify to return meaningful status information when printed. Can't add these directly to connection/base, because Resque depends on decoding to_s
+    def inspect
+      "#<#{self.class.name}: #{to_s}>"
+    end
+    
+    # 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}"
+    end
+    
+    protected
+        
+    # 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])
+      end
+
+      # Bye Apple
+      teardown_connection
+
+      return feedback
+    end
+    
+    
+    def apn_host
+      @apn_host ||= apn_sandbox? ? "feedback.sandbox.push.apple.com" : "feedback.push.apple.com"
+    end
+    
+    def apn_port
+      2196
+    end
+    
+  end
+end
+
+
+
+__END__
+# Testing from irb
+irb -r 'lib/apn/feedback'
+
+a=APN::Feedback.new(:cert_path => '/Users/kali/Code/insurrection/certs/', :environment => :production)

data/lib/apn/notification.rb

@@ -0,0 +1,95 @@
+module APN
+  # Encapsulates the logic necessary to convert an iPhone token and an array of options into a string of the format required
+  # by Apple's servers to send the notification.  Much of the processing code here copied with many thanks from
+  # http://github.com/samsoffes/apple_push_notification/blob/master/lib/apple_push_notification.rb
+  #
+  # APN::Notification.new's first argument is the token of the iPhone which should receive the notification.  The second argument
+  # is a hash with any of :alert, :badge, and :sound keys. All three accept string arguments, while :sound can also be set to +true+
+  # to play the default sound installed with the application. At least one of these keys must exist.  Any other keys are merged into
+  # the root of the hash payload ultimately sent to the iPhone:
+  #
+  #   APN::Notification.new(token, {:alert => 'Stuff', :custom => {:code => 23}})
+  #   # Writes this JSON to servers: {"aps" => {"alert" => "Stuff"}, "custom" => {"code" => 23}}
+  # 
+  # As a shortcut, APN::Notification.new also accepts a string as the second argument, which it converts into the alert to send.  The 
+  # following two lines are equivalent:
+  #
+  #   APN::Notification.new(token, 'Some Alert')
+  #   APN::Notification.new(token, {:alert => 'Some Alert'})
+  #
+  class Notification
+    # Available to help clients determine before they create the notification if their message will be too large.
+    # 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 
+    
+    attr_accessor :options, :token
+    def initialize(token, opts)
+      @options = hash_as_symbols(opts.is_a?(Hash) ? opts : {:alert => opts})
+      @token = token
+      payload_size = packaged_message.bytesize.to_i
+
+      raise "Payload bytesize of #{payload_size} is > the maximum allowed size of 255." if payload_size > 255
+    end
+
+    def to_s
+      packaged_notification
+    end
+    
+    # Ensures at least one of <code>%w(alert badge sound)</code> is present
+    def valid?
+      return true if %w(alert badge sound).any?{|key| options.keys.include?(key.to_sym) }
+      false
+    end
+    
+    # Converts the supplied options into the JSON needed for Apple's push notification servers.
+    # Extracts :alert, :badge, :sound, 'aps' hash, merges 'custom' hash data
+    # into the root of the hash to encode and send to apple.
+    def packaged_message
+      self.class.packaged_message(@options)
+    end
+
+    def self.packaged_message(options)
+      raise "Message #{options} is missing the alert or badge keys." unless options[:badge] || options[:alert]
+
+      opts = options.clone # Don't destroy our pristine copy
+      aps_hash = {}
+
+      if sound = opts.delete(:sound)
+        aps_hash['sound'] = sound.is_a?(TrueClass) ? 'default' : sound.to_s
+      end
+
+      hsh = { 'aps' => aps_hash }
+      hsh.merge!(opts.delete(:custom) || {})
+      hsh['aps'].merge!(opts)
+
+      Yajl::Encoder.encode(hsh)
+    end
+    
+    protected
+    # Completed encoded notification, ready to send down the wire to Apple
+    def packaged_notification
+      pt = packaged_token
+      pm = packaged_message
+      [0, 0, 32, pt, 0, pm.bytesize, pm].pack("ccca*cca*") 
+    end
+
+    # Device token, compressed and hex-ified
+    def packaged_token
+      [@token.gsub(/[\s|<|>]/,'')].pack('H*')
+    end
+
+    # Symbolize keys, using ActiveSupport if available
+    def hash_as_symbols(hash)
+      if hash.respond_to?(:symbolize_keys)
+        return hash.symbolize_keys
+      else
+       hash.inject({}) do |opt, (key, value)|
+         opt[(key.to_sym rescue key) || key] = value
+         opt
+       end
+     end
+   end
+ end   
+end
+

data/lib/apn.rb

@@ -0,0 +1,7 @@
+require 'yajl'
+require 'json'
+require 'active_support'
+require 'apn/notification'
+require 'apn/base'
+require 'apn/connection'
+require 'apn/feedback'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: banjo-apn_sender
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Kali Donovan
+- KW Justin Leung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: apn_sender
+  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: yajl-ruby
+  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: Based on Kali Donovan's APN sender 1.x. 2.0 keep things lean - we removed
+  the resque layer, and make APN connection pluggable to multithreaded background
+  worker (like SideKiq) to send Apple Push Notifications over a persistent TCP socket.
+email: kali.donovan@gmail.com justin@teambanjo.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- apn_sender.gemspec
+- lib/apn.rb
+- lib/apn/base.rb
+- lib/apn/feedback.rb
+- lib/apn/notification.rb
+homepage: http://github.com/BanjoInc/apn_sender
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: APN connection pluggable to multithreaded background worker (like SideKiq)
+  to send Apple Push Notifications over a persistent TCP socket.
+test_files: []