Push0r 0.2.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d9ef5534b21b4c6dbc74c585d5ecb12131cd49b4
+  data.tar.gz: 0e7497b14bed43b9fecfadf6020b36fce584325d
+SHA512:
+  metadata.gz: 150434b22df1f68d98001220b5967fb2b415af6cd87da31f1c9c4f2b816ee5b690eb401009b4fb5192dde925187ca1215be97c33c74fc497d9568999fb6444c8
+  data.tar.gz: bc059519ecc70f3838b0f9a2b2be51cb95ddebab81eca72ce9169fa9894d373468078d0ce3d73ade60d27ddf8d54689ce6ad789e795cd8541aafff059f4e6684

data/lib/push0r/APNS/ApnsPushMessage.rb

@@ -0,0 +1,26 @@
+module Push0r
+	class ApnsPushMessage < PushMessage		
+		def initialize(receiver_token, identifier = nil, time_to_live = nil)
+			if identifier.nil? ## make sure the message has an identifier (required for apns error handling)
+				identifier = Random.rand(2**32)
+			end
+			super(receiver_token, identifier, time_to_live)
+		end
+		
+		def simple(alert_text = nil, sound = nil, badge = nil)
+			new_payload = {aps: {}}
+			if alert_text
+				new_payload[:aps][:alert] = alert_text
+			end
+			if sound
+				new_payload[:aps][:sound] = sound
+			end
+			if badge
+				new_payload[:aps][:badge] = bade
+			end		
+			@payload.merge!(new_payload)
+			
+			return self
+		end
+	end
+end

data/lib/push0r/APNS/ApnsService.rb

@@ -0,0 +1,162 @@
+module Push0r
+	module ApnsErrorCodes
+		NO_ERROR 				= 0
+		PROCESSING_ERROR 		= 1
+		MISSING_DEVICE_TOKEN 	= 2
+		MISSING_TOPIC 			= 3
+		MISSING_PAYLOAD 		= 4
+		INVALID_TOKEN_SIZE 		= 5
+		INVALID_TOPIC_SIZE 		= 6
+		INVALID_PAYLOAD_SIZE 	= 7
+		INVALID_TOKEN 			= 8
+		SHUTDOWN 				= 10
+		NONE 					= 255
+	end
+	
+	class ApnsService < Service
+		def initialize(certificate_data, sandbox_environment = false)
+			@certificate_data = certificate_data
+			@sandbox_environment = sandbox_environment
+			@ssl = nil
+			@sock = nil
+			@messages = []
+		end
+	
+		def can_send?(message)
+			return message.is_a?(ApnsPushMessage)
+		end
+	
+		def send(message)
+			@messages << message
+		end
+		
+		def init_push
+			# not used for apns
+		end
+		
+		def end_push
+			failed_messages = []
+			begin
+				setup_ssl
+				(result, error_message, error_code) = transmit_messages
+				if result == false 
+					failed_messages << {:error_code => error_code, :message => error_message}
+					reset_message(error_identifier)
+					if @messages.empty? then result = true end
+				end
+			end while result != true
+		
+			unless @ssl.nil?
+				@ssl.close
+			end
+			unless @sock.nil?
+				@sock.close
+			end
+			
+			@messages = [] ## reset
+			return [failed_messages, []]
+		end
+	
+		private
+		def setup_ssl
+			ctx = OpenSSL::SSL::SSLContext.new
+		
+			ctx.key = OpenSSL::PKey::RSA.new(@certificate_data, '')
+			ctx.cert = OpenSSL::X509::Certificate.new(@certificate_data)
+				
+			@sock = TCPSocket.new(@sandbox_environment ? "gateway.sandbox.push.apple.com" : "gateway.push.apple.com", 2195)
+			@ssl = OpenSSL::SSL::SSLSocket.new(@sock, ctx)
+			@ssl.connect
+		end
+		
+		def reset_message(error_identifier)
+			index = @messages.find_index {|o| o.identifier == error_identifier}
+			
+			if index.nil? ## this should never happen actually
+				@messages = []
+			elsif index < @messages.length - 1 # reset @messages to contain all messages after the one that has failed
+				@messages = @messages[index+1, @messages.length]
+			else ## the very last message failed, so there's nothing left to be sent
+				@messages = []
+			end
+		end
+		
+		def create_push_frame(message)
+			receiver_token = message.receiver_token
+			payload = message.payload
+			identifier = message.identifier
+			time_to_live = (message.time_to_live.nil? || message.time_to_live.to_i < 0) ? 0 : message.time_to_live.to_i
+		
+			if receiver_token.nil? then raise(ArgumentError, "receiver_token is nil!") end
+			if payload.nil? then raise(ArgumentError, "payload is nil!") end	
+			
+			receiver_token = receiver_token.gsub(/\s+/, "")
+			if receiver_token.length != 64 then raise(ArgumentError, "invalid receiver_token length!") end			
+		
+			devicetoken = [receiver_token].pack('H*')
+			devicetoken_length = [32].pack("n")
+			devicetoken_item = "\1#{devicetoken_length}#{devicetoken}"
+		
+			identifier = [identifier.to_i].pack("N")
+			identifier_length = [4].pack("n")
+			identifier_item = "\3#{identifier_length}#{identifier}"
+		
+			expiration_date = [(time_to_live > 0 ? Time.now.to_i + time_to_live : 0)].pack("N")
+			expiration_date_length = [4].pack("n")
+			expiration_item = "\4#{expiration_date_length}#{expiration_date}"
+		
+			priority = "\xA" ## default: high priority
+			if payload[:aps] && payload[:aps]["content-available"] && payload[:aps]["content-available"].to_i != 0 && (payload[:aps][:alert].nil? && payload[:aps][:sound].nil? && payload[:aps][:badge].nil?)
+				priority = "\5" ## lower priority for content-available pushes without alert/sound/badge
+			end
+		
+			priority_length = [1].pack("n")
+			priority_item = "\5#{priority_length}#{priority}"
+		
+			payload = payload.to_json.force_encoding("BINARY")
+			payload_length = [payload.bytesize].pack("n")
+			payload_item = "\2#{payload_length}#{payload}"
+		
+			frame_length = [devicetoken_item.bytesize + payload_item.bytesize + identifier_item.bytesize + expiration_item.bytesize + priority_item.bytesize].pack("N")
+			frame = "\2#{frame_length}#{devicetoken_item}#{payload_item}#{identifier_item}#{expiration_item}#{priority_item}"
+		
+			return frame
+		end
+		
+		def transmit_messages
+			if @messages.empty? || @ssl.nil?
+				return [true, nil, nil]
+			end
+			
+			pushdata = ""
+			@messages.each do |message|
+				pushdata << create_push_frame(message)
+			end
+			
+			@ssl.write(pushdata)
+		
+			if IO.select([@ssl], nil, nil, 2)
+				read_buffer = @ssl.read(6)
+				if !read_buffer.nil?
+					#cmd = read_buffer[0].unpack("C").first
+					error_code = read_buffer[1].unpack("C").first
+					identifier = read_buffer[2,4].unpack("N").first
+					puts "ERROR: APNS returned error code #{error_code} #{identifier}"
+					return [false, message_for_identifier(identifier), error_code]
+				else
+					return [true, nil, nil]
+				end
+			end
+			return [true, nil, nil]
+		end
+		
+		def message_for_identifier(identifier)
+			index = @messages.find_index {|o| o.identifier == identifier}
+			if index.nil?
+				return nil
+			else
+				return @messages[index]
+			end
+		end
+	end
+end

data/lib/push0r/GCM/GcmPushMessage.rb

@@ -0,0 +1,21 @@
+module Push0r
+	class GcmPushMessage < PushMessage
+		def initialize(receiver_token, identifier = nil, time_to_live = nil)
+			if identifier.nil? ## make sure the message has an identifier
+				identifier = Random.rand(2**32)
+			end
+			
+			# for GCM the receiver_token is an array, so make sure we convert a single string to an array containing that string :-)
+			if receiver_token.is_a?(String)
+				receiver_token = [receiver_token]
+			end
+			
+			super(receiver_token, identifier, time_to_live)
+			
+			if time_to_live && time_to_live.to_i >= 0
+				self.attach({"time_to_live" => time_to_live.to_i})
+			end
+		end
+	end
+end
+

data/lib/push0r/GCM/GcmService.rb

@@ -0,0 +1,116 @@
+require 'net/http'
+
+module Push0r
+	
+	module GcmErrorCodes
+		NO_ERROR 				= 0
+		UNABLE_TO_PARSE_JSON	= 400
+		NOT_AUTHENTICATED		= 401
+		INTERNAL_ERROR			= 500
+		UNKNOWN_ERROR			= 1
+		INVALID_REGISTRATION	= 2
+		UNAVAILABLE				= 3
+		NOT_REGISTERED			= 4
+		MISMATCH_SENDER_ID		= 5
+		MISSING_REGISTRATION	= 6
+		MESSAGE_TOO_BIG			= 7
+		INVALID_DATA_KEY		= 8
+		INVALID_TTL				= 9
+		INVALID_PACKAGE_NAME	= 10
+		CONNECTION_ERROR		= 11
+	end
+	
+	class GcmService < Service
+		def initialize(api_key)
+			@api_key = api_key
+			@messages = []
+		end
+		
+		def can_send?(message)
+			return message.is_a?(GcmPushMessage)
+		end
+		
+		def send(message)
+			@messages << message
+		end
+		
+		def init_push
+			## not used for gcm
+		end
+		
+		def end_push
+			failed_messages = []
+			new_registration_messages = []
+			
+			uri = URI.parse("https://android.googleapis.com/gcm/send")
+			http = Net::HTTP.new(uri.host, uri.port)
+			http.use_ssl = true
+
+			@messages.each do |message|
+				begin
+					request = Net::HTTP::Post.new(uri.path, {"Content-Type" => "application/json", "Authorization" => "key=#{@api_key}"})
+					request.body = message.attach({"registration_ids" => message.receiver_token}).payload.to_json
+					response = http.request(request)
+				rescue SocketError
+					## connection error
+					failed_messages << {:error_code => Push0r::GcmErrorCodes::CONNECTION_ERROR, :message => message, :receivers => message.receiver_token}
+					next
+				end
+				
+				if response.code.to_i == 200
+					json = JSON.parse(response.body)
+					
+					if json["failure"].to_i > 0 || json["canonical_ids"].to_i > 0
+						error_receivers = {}
+						
+						json["results"].each_with_index do |result,i|
+							receiver_token = message.receiver_token[i]
+							error = result["error"]
+							message_id = result["message_id"]
+							registration_id = result["registration_id"]
+							
+							if message_id && registration_id
+								new_registration_messages << {:message => message, :receiver => receiver_token, :new_receiver => registration_id}
+							elsif error
+								error_code = Push0r::GcmErrorCodes::UNKNOWN_ERROR
+								if error == "InvalidRegistration"
+									error_code = Push0r::GcmErrorCodes::INVALID_REGISTRATION
+								elsif error == "Unavailable"
+									error_code = Push0r::GcmErrorCodes::UNAVAILABLE
+								elsif error == "NotRegistered"
+									error_code = Push0r::GcmErrorCodes::NOT_REGISTERED
+								elsif error == "MismatchSenderId"
+									error_code = Push0r::GcmErrorCodes::MISMATCH_SENDER_ID
+								elsif error == "MissingRegistration"
+									error_code = Push0r::GcmErrorCodes::MISSING_REGISTRATION
+								elsif error == "MessageTooBig"
+									error_code = Push0r::GcmErrorCodes::MESSAGE_TOO_BIG
+								elsif error == "InvalidDataKey"
+									error_code = Push0r::GcmErrorCodes::INVALID_DATA_KEY	
+								elsif error == "InvalidTtl"
+									error_code = Push0r::GcmErrorCodes::INVALID_TTL
+								elsif error == "InvalidPackageName"
+									error_code = Push0r::GcmErrorCodes::INVALID_PACKAGE_NAME
+								end
+								if error_receivers[error_code].nil? then error_receivers[error_code] = [] end
+								error_receivers[error_code] << receiver_token
+							end
+						end
+						
+						## if there are any receivers with errors: add a hash for every distinct error code and the related receivers to the failed_messages array
+						error_receivers.each do |error_code, receivers|
+							failed_messages << {:error_code => error_code, :message => message, :receivers => receivers}
+						end
+					end
+				elsif response.code.to_i >= 500 && response.code.to_i <= 599
+					failed_messages << {:error_code => Push0r::GcmErrorCodes::INTERNAL_ERROR, :message => message, :receivers => message.receiver_token}
+				else
+					failed_messages << {:error_code => response.code.to_i, :message => message, :receivers => message.receiver_token}
+				end
+			end
+				
+			@messages = [] ## reset	
+			return [failed_messages, new_registration_messages]
+		end
+	end
+end

data/lib/push0r/PushMessage.rb

@@ -0,0 +1,20 @@
+module Push0r
+	class PushMessage
+		attr_reader :payload, :identifier, :receiver_token, :time_to_live
+	
+		def initialize(receiver_token, identifier = nil, time_to_live = nil)
+			@receiver_token = receiver_token
+			@identifier = identifier
+			@time_to_live = time_to_live
+			@payload = {}
+		end
+	
+		def attach(payload = {})
+			@payload.merge!(payload)
+			return self
+		end
+	end
+end
+
+require_relative 'APNS/ApnsPushMessage'
+require_relative 'GCM/GcmPushMessage'

data/lib/push0r/Queue.rb

@@ -0,0 +1,44 @@
+module Push0r
+	class Queue
+		def initialize
+			@services = []
+			@queued_messages = {}
+		end
+	
+		def register_service(service)
+			unless @services.include?(service)
+				@services << service
+			end
+		end
+	
+		def add(message)
+			@services.each do |service|
+				if service.can_send?(message)
+					if @queued_messages[service].nil?
+						@queued_messages[service] = []
+					end
+					@queued_messages[service] << message
+					return true
+				end
+			end
+			return false
+		end
+	
+		def flush
+			failed_messages = []
+			new_registration_messages = []
+			
+			@queued_messages.each do |service, messages|
+				service.init_push
+				messages.each do |message|
+					service.send(message)
+				end
+				(failed, new_registration) = service.end_push
+				failed_messages += failed
+				new_registration_messages += new_registration
+			end
+			@queued_messages = {}
+			return [failed_messages, new_registration_messages]
+		end
+	end
+end

data/lib/push0r/Service.rb

@@ -0,0 +1,23 @@
+module Push0r
+	class Service
+		def can_send?(message)
+			return false
+		end
+	
+		def send(message)
+			## empty
+		end
+	
+		def init_push
+			## empty
+		end
+	
+		def end_push
+			## empty
+			return [[], []]
+		end
+	end
+end
+
+require_relative 'APNS/ApnsService'
+require_relative 'GCM/GcmService'

data/lib/push0r.rb

@@ -0,0 +1,7 @@
+require 'socket'
+require 'openssl'
+require 'json'
+
+require_relative 'push0r/Queue'
+require_relative 'push0r/Service'
+require_relative 'push0r/PushMessage'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: Push0r
+version: !ruby/object:Gem::Version
+  version: 0.2.6
+platform: ruby
+authors:
+- Kai Straßmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library to push messages using APNS and GCM
+email: derkai@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/push0r.rb
+- lib/push0r/APNS/ApnsPushMessage.rb
+- lib/push0r/APNS/ApnsService.rb
+- lib/push0r/GCM/GcmPushMessage.rb
+- lib/push0r/GCM/GcmService.rb
+- lib/push0r/PushMessage.rb
+- lib/push0r/Queue.rb
+- lib/push0r/Service.rb
+homepage: https://github.com/cbot/push0r
+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: Push0r gem
+test_files: []