apns-ruby 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb1f035a12ec76366159c112eccd23dc2f319b8d
+  data.tar.gz: 2d6a9188eba06cb48683f10ba748a71069a46157
+SHA512:
+  metadata.gz: 07fe76e8c32cd0a91d0bc76eb283896aa53a65b4ffc4b5caf960fbb018c1212c29880e13b9acb7a65d948ab8618497b70fe6da9f946d8595e528f87ed03c1987
+  data.tar.gz: 47499c4c0f549710d22a27e4d379d8642ebc0e2cd34fb18b9c3d9b2b8e7a65b6cfd4a76f599eec9c23853d00b078df8de61a43b3f6dbe9ecb3cebaa6385652fc

data/README.md

@@ -0,0 +1,39 @@
+apns-ruby
+-----
+This gem sends APNS notifications with proper error handling. Most importantly, it does this without all the nonsense other gems provide:
+* Storing notifications in a database, and have a separate process consume them. Worse, only a single consumer is ever allowed.
+* Opening a new SSL connection for every notification, which typically takes several hundred milliseconds. Imagine how long it would take to send a million notifications.
+
+Beware though, that this gem has it's own nonsense in that by default, it sets the notification buffer size to 1 million, which could potentially take up 256MB of memory (Apple caps the size of a single notification's payload at 256 bytes). If you cannot afford to spare that amount of memory, configure it to a lesser number `conn = APNS::Connection.new(notification_buffer_size: 1024) # 1024 bytes`.
+
+Example usage:
+```
+pem = path_to_your_pem_file
+host = 'gateway.sandbox.push.apple.com' # or 'gateway.push.apple.com' on production
+token = a_valid_apns_device_token
+conn = APNS::Connection.new(pem: pem, host: host)
+conn.error_handler = ->(code, notification) {
+  case code
+  when 8
+    puts "Invalid token: #{notification.device_token}"
+  else
+    # Consult Apple's docs
+  end
+}
+n1 = APNS::Notification.new(token, alert: 'hello')
+ne = APNS::Notification.new('bogustoken', alert: 'error')
+n2 = APNS::Notification.new(token, alert: 'world')
+conn.write([n1, ne, n2])
+# Should receive only a 'hello' notification on your device
+
+# Wait for Apple to report an error and close the connection
+sleep(7)
+conn.write([APNS::Notification.new(token, alert: 'hello world 0')])
+sleep(7)
+conn.write([APNS::Notification.new(token, alert: 'hello world 1')])
+
+# 'Invalid token: bogustoken' is printed out
+# We should be receiving the 'world', 'hello world 0', and 'hello world 1' notifications
+```
+
+A great amount of code in this gem is copied from https://github.com/jpoz/APNS , many thanks to his pioneering work. This work itself is licensed under the MIT license.

data/lib/apns.rb

@@ -0,0 +1,2 @@
+require 'apns/connection'
+require 'apns/notification'

data/lib/apns/connection.rb

@@ -0,0 +1,103 @@
+require 'openssl'
+require 'socket'
+require 'timeout'
+
+module APNS
+class Connection
+  attr_accessor :error_handler
+
+  def initialize(pem: ,
+                 pass: nil,
+                 host: 'gateway.sandbox.push.apple.com',
+                 port: 2195,
+                 notification_buffer_size: 1_000_000)
+    @notifications = []
+    @pem =  pem
+    @pass = pass
+    @host = host
+    @port = port
+    @notification_buffer_size = notification_buffer_size
+
+    @sock, @ssl = open_connection
+    ObjectSpace.define_finalizer(self, self.class.finalize(@sock, @ssl))
+  end
+  def self.finalize sock, ssl
+    proc {
+      ssl.close
+      sock.close
+    }
+  end
+
+  def write ns
+    if @notifications.size > @notification_buffer_size
+      ns = detect_failed_notifications(timeout: 0.5) + ns
+      @notifications = []
+    end
+
+    packed = pack_notifications(ns)
+    @ssl.write(packed)
+  rescue Errno::EPIPE, Errno::ECONNRESET, OpenSSL::SSL::SSLError
+    failed_notifications = detect_failed_notifications timeout: 3
+    @notifications = []
+    @ssl.close
+    @sock.close
+    @sock, @ssl = open_connection
+
+    ns = failed_notifications
+    retry
+  end
+
+  def pack_notifications notifications
+    bytes = ''
+
+    notifications.each do |n|
+      n.message_identifier = [@notifications.size].pack('N')
+      @notifications << n
+
+      # Each notification frame consists of
+      # 1. (e.g. protocol version) 2 (unsigned char [1 byte]) 
+      # 2. size of the full frame (unsigend int [4 byte], big endian)
+      pn = n.packaged_notification
+      bytes << ([2, pn.bytesize].pack('CN') + pn)
+    end
+
+    bytes
+  end
+
+  def detect_failed_notifications(timeout:)
+    begin
+      tuple = Timeout::timeout(timeout){ @ssl.read(6) }
+      _, code, failed_id = tuple.unpack("ccN")
+    rescue Timeout::Error
+    end
+    failed_id ||= @notifications.size
+
+    # Report error to user
+    failed_notification = @notifications[failed_id]
+    if @error_handler && failed_notification
+      @error_handler.call(code, failed_notification)
+    end
+
+    @notifications[failed_id+1..-1] || []
+  end
+
+  def open_connection
+    context      = OpenSSL::SSL::SSLContext.new
+    context.cert = OpenSSL::X509::Certificate.new(File.read(@pem))
+    context.key  = OpenSSL::PKey::RSA.new(File.read(@pem), @pass)
+
+    sock         = TCPSocket.new(@host, @port)
+    ssl          = OpenSSL::SSL::SSLSocket.new(sock,context)
+    ssl.connect
+
+    return sock, ssl
+  end
+
+  # Override inspect since we do not want to print out the entire @notifications,
+  # whose size might be over a hundred thousand
+  def inspect
+    puts "#<#{self.class}:#{'0x%014x' % object_id} @pem=#{@pem} @pass=#{@pass} @host=#{@host} @port=#{@port} @notifications.size=#{@notifications.size} @error_handler=#{@error_handler}>"
+  end
+
+end
+end

data/lib/apns/notification.rb

@@ -0,0 +1,70 @@
+require 'json'
+
+module APNS
+
+  class Notification
+    attr_accessor :device_token, :alert, :badge, :sound, :other, :priority
+    attr_accessor :message_identifier, :expiration_date
+    attr_accessor :content_available
+    
+    def initialize(device_token, message)
+      self.device_token = device_token
+      if message.is_a?(Hash)
+        self.alert = message[:alert]
+        self.badge = message[:badge]
+        self.sound = message[:sound]
+        self.other = message[:other]
+        self.message_identifier = message[:message_identifier]
+        self.content_available = !message[:content_available].nil?
+        self.expiration_date = message[:expiration_date]
+        self.priority = if self.content_available
+          message[:priority] || 5
+        else
+          message[:priority] || 10
+        end
+      elsif message.is_a?(String)
+        self.alert = message
+      else
+        raise "Notification needs to have either a hash or string"
+      end
+
+      self.message_identifier ||= "0000"
+    end
+        
+    def packaged_notification
+      pt = self.packaged_token
+      pm = self.packaged_message
+      pi = self.message_identifier
+      pe = (self.expiration_date || 0).to_i
+      pr = (self.priority || 10).to_i
+
+      # Each item consist of
+      # 1. unsigned char [1 byte] is the item (type) number according to Apple's docs
+      # 2. short [big endian, 2 byte] is the size of this item
+      # 3. item data, depending on the type fixed or variable length
+      data = ''
+      data << [1, pt.bytesize, pt].pack("CnA*")
+      data << [2, pm.bytesize, pm].pack("CnA*")
+      data << [3, pi.bytesize, pi].pack("CnA*")
+      data << [4, 4, pe].pack("CnN")
+      data << [5, 1, pr].pack("CnC")
+      
+      data
+    end
+  
+    def packaged_token
+      [device_token.gsub(/[\s|<|>]/,'')].pack('H*')
+    end
+  
+    def packaged_message
+      aps = {'aps'=> {} }
+      aps['aps']['alert'] = self.alert if self.alert
+      aps['aps']['badge'] = self.badge if self.badge
+      aps['aps']['sound'] = self.sound if self.sound
+      aps['aps']['content-available'] = 1 if self.content_available
+
+      aps.merge!(self.other) if self.other
+      JSON.generate(aps)
+    end    
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: apns-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- awaw
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-05 00:00:00.000000000 Z
+dependencies: []
+description: APNS notifications sent properly with correct connection management and
+  error handling
+email: awawfumin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/apns.rb
+- lib/apns/connection.rb
+- lib/apns/notification.rb
+homepage: https://github.com/fumin/apns-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: APNS notifications sent properly
+test_files: []
+has_rdoc: