em_apn_manager 0.0.1

data/lib/em_apn_manager/apn_server.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+# Mock Apple push server for testing.
+module EventMachine
+  module ApnManager
+    module ApnServer
+      def post_init
+        EM::ApnManager.logger.info("Received a new connection")
+        @data  = ""
+
+        start_tls(
+          :cert_chain_file  => ENV["APN_CERT"],
+          :private_key_file => ENV["APN_CERT"],
+          :verify_peer      => false
+        )
+      end
+
+      def ssl_handshake_completed
+        EM::ApnManager.logger.info("SSL handshake completed")
+      end
+
+      def receive_data(data)
+        @data << data
+
+        # Try to extract the payload header
+        headers = @data.unpack("cNNnH64n")
+        return if headers.last.nil?
+
+        # Try to grab the payload
+        payload_size = headers.last
+        payload = @data[45, payload_size]
+        return if payload.length != payload_size
+
+        @data = @data[45 + payload_size, -1] || ""
+
+        process(headers, payload)
+      end
+
+      def process(headers, payload)
+        message = "APN RECV #{headers[4]} #{payload}"
+        EM::ApnManager.logger.info(message)
+
+        args = Yajl::Parser.parse(payload)
+
+        # If the alert is 'DISCONNECT', then we fake a bad payload by replying
+        # with an error and disconnecting.
+        if args["aps"]["alert"] == "DISCONNECT"
+          EM::ApnManager.logger.info("Disconnecting")
+          send_data([8, 1, 0].pack("ccN"))
+          close_connection_after_writing
+        end
+      end
+
+      def unbind
+        EM::ApnManager.logger.info("Connection closed")
+      end
+    end
+  end
+end

data/lib/em_apn_manager/cli.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+require 'thor'
+require 'redis'
+require 'yaml'
+require 'yajl'
+require 'yajl/json_gem'
+require 'em_apn_manager'
+require "em_apn_manager/manager"
+require "em_apn_manager/apn_server"
+
+ENV["APN_CERT"] ||= File.join(File.dirname(__FILE__), "..", "..", "certs", "cert.pem")
+
+$apn_manager_redis = nil
+
+module EventMachine
+  module ApnManager
+    class CLI < Thor
+      class_option :config, :aliases => ["-c"], :type => :string
+      class_option :environment, :aliases => ["-e"], :type => :string
+
+      def initialize(args = [], opts = [], config = {})
+        super(args, opts, config)
+
+        # Read config option, or use default config yml
+        config_path = options[:config] || File.join(".", "config", "em_apn_manager.yml")
+        if config_path && File.exists?(config_path)
+          EM::ApnManager.config = Thor::CoreExt::HashWithIndifferentAccess.new(YAML.load_file(config_path))
+        else
+          raise "No config file is specified or specified config file doesn't exist."
+        end
+
+        # read the environment var.
+        @environment = "test"
+        @environment = options[:environment] if %w{test development production}.include? options[:environment]
+
+        # create redis connection
+        $apn_manager_redis = Redis.new EM::ApnManager.config[@environment] || { host:"127.0.0.1", port:6379 }
+      end
+
+      desc "server", "Start manager server."
+      # option :daemon,       :aliases => ["-d"], :type => :boolean
+      # option :pid_file,     :aliases => ["-p"], :type => :string
+      def server
+        EM::ApnManager.logger.info("Starting APN Manager")
+        EM.run { EM::ApnManager::Manager.run env: @environment }
+      end
+
+      ### For Testing ##################################################
+      desc "push_test_message", "Push test messages to server."
+      # if message is DISCONNECT, mock apns will disconnect.
+      def push_test_message
+        10.times do |i|
+          EM::ApnManager.push_notification({
+            cert: File.read(ENV["APN_CERT"]),
+            token: ["0F93C49EAAF3544B5218D2BAE893608C515F69B445279AB2B17511C37046C52B","D42A6795D0C6C0E5F3CC762F905C3654D2A07E72D64CDEC1E2F74AC43C4CC440"].sample,
+            message: "Hahahaha I am going to spam you. #{i}-#{rand * 100}"
+          })
+        end
+      end
+
+      desc "mock_apn_server", "Start a mock apple APNS Server."
+      def mock_apn_server
+        EM::ApnManager.logger.info("Starting Mock APN Server")
+        EM.run { EM.start_server("127.0.0.1", 2195, EM::ApnManager::ApnServer) }
+      end
+    end
+  end
+end

data/lib/em_apn_manager/client.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+require "em_apn_manager/connection"
+
+module EventMachine
+  module ApnManager
+    class Client
+      SANDBOX_GATEWAY    = "gateway.sandbox.push.apple.com"
+      PRODUCTION_GATEWAY = "gateway.push.apple.com"
+      TEST_GATEWAY       = "127.0.0.1"
+      PORT               = 2195
+
+      attr_reader :gateway, :port, :cert, :connection, :error_callback, :close_callback, :open_callback
+
+      # A convenience method for creating and connecting.
+      def self.connect(options = {})
+        new(options).tap do |client|
+          client.connect
+        end
+      end
+
+      def initialize(options = {})
+        @cert = options[:cert] || ENV["APN_CERT"]
+        @port = options[:port] || PORT
+        @environment = options[:env]
+        @gateway = options[:gateway] || ENV["APN_GATEWAY"]
+        @gateway ||=  case @environment
+                      when "test"
+                        TEST_GATEWAY
+                      when "development"
+                        SANDBOX_GATEWAY
+                      when "production"
+                        PRODUCTION_GATEWAY
+                      else
+                        TEST_GATEWAY
+                      end
+        @connection = nil
+      end
+
+      def connect
+        @connection = EM.connect(gateway, port, Connection, self)
+      end
+
+      def connected?
+        !connection.nil? && !connection.disconnected?
+      end
+
+      def deliver(notification)
+        if !connected?
+          puts "No connection."
+          return
+        end
+        notification.validate!
+        log(notification)
+        connection.send_data(notification.data)
+      end
+
+      def on_error(&block)
+        @error_callback = block
+      end
+
+      def on_close(&block)
+        @close_callback = block
+      end
+
+      def on_open(&block)
+        @open_callback = block
+      end
+
+      def log(notification)
+        EM::ApnManager.logger.info("TOKEN=#{notification.token} PAYLOAD=#{notification.payload.inspect}")
+      end
+    end
+  end
+end

data/lib/em_apn_manager/connection.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require "em_apn_manager/error_response"
+
+module EventMachine
+  module ApnManager
+    class Connection < EM::Connection
+      attr_reader :client
+
+      def initialize(*args)
+        super
+        @client = args.last
+        @disconnected = false
+      end
+
+      def disconnected?
+        @disconnected
+      end
+
+      def post_init
+        EM::ApnManager.logger.info("Connecting...")
+
+        start_tls(
+          :private_key_file => client.cert,
+          :cert_chain_file  => client.cert,
+          :verify_peer      => false
+        )
+      end
+
+      def connection_completed
+        EM::ApnManager.logger.info("Connection completed")
+
+        client.open_callback.call if client.open_callback
+      end
+
+      def receive_data(data)
+        data_array = data.unpack("ccN")
+        error_response = ErrorResponse.new(*data_array)
+        EM::ApnManager.logger.warn(error_response.to_s)
+        client.error_callback.call(error_response) if client.error_callback
+      end
+
+      def unbind
+        EM::ApnManager.logger.info("Connection closed")
+
+        @disconnected = true
+        client.close_callback.call if client.close_callback
+      end
+    end
+  end
+end

data/lib/em_apn_manager/engine.rb

@@ -0,0 +1,9 @@
+module EventMachine
+  module ApnManager
+    class Engine < ::Rails::Engine
+      generators do
+        require 'em_apn_manager/generators/install.rb'
+      end
+    end
+  end
+end

data/lib/em_apn_manager/error_response.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+
+module EventMachine
+  module ApnManager
+    class ErrorResponse
+      DESCRIPTION = {
+        0   => "No errors encountered",
+        1   => "Processing error",
+        2   => "Missing device token",
+        3   => "Missing topic",
+        4   => "Missing payload",
+        5   => "Invalid token size",
+        6   => "Invalid topic size",
+        7   => "Invalid payload size",
+        8   => "Invalid token",
+        255 => "None (unknown)"
+      }
+
+      attr_reader :command, :status_code, :identifier
+
+      def initialize(command, status_code, identifier)
+        @command     = command
+        @status_code = status_code
+        @identifier  = identifier
+      end
+
+      def to_s
+        "CODE=#{@status_code} ID=#{@identifier} DESC=#{description}"
+      end
+
+      def description
+        DESCRIPTION[@status_code] || "Missing description"
+      end
+    end
+  end
+end

data/lib/em_apn_manager/generators/install.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module EventMachine
+  module ApnManager
+    class Install < Rails::Generators::Base
+      desc "Install EventMachine APN Manager."
+      source_root File.expand_path('../templates', __FILE__)
+      def create_config
+        say "Create Configure file to project...", :yellow
+        copy_file "em_apn_manager.yml", "config/em_apn_manager.yml"
+      end
+    end
+  end
+end

data/lib/em_apn_manager/generators/templates/em_apn_manager.yml

@@ -0,0 +1,13 @@
+production:
+  host: localhost
+  port: 6379
+  db: YOUR_PRODUCTION_REDIS
+  password: PASSWORD
+
+development:
+  host: localhost
+  port: 6379
+
+test:
+  host: localhost
+  port: 6379

data/lib/em_apn_manager/logger.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'logger'
+
+module EventMachine
+  module ApnManager
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def self.logger=(new_logger)
+      @logger = new_logger
+    end
+  end
+end

data/lib/em_apn_manager/manager.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+require 'base64'
+require 'yajl'
+require 'yajl/json_gem'
+require 'em-hiredis'
+require "em_apn_manager/client"
+require "em_apn_manager/notification"
+
+module EventMachine
+  module ApnManager
+    class Manager
+      $connection_pool = {}
+
+      def self.run options = {}
+        self.new.tap do |manager|
+          manager.run options
+        end
+      end # end of run
+
+      # options = {gateway, port}
+      def run options = {}
+        @redis = EM::Hiredis.connect
+
+        ### launch a new connect to apple when detected any pushs.
+        @redis.pubsub.subscribe('push-notification') do |msg|
+          msg_hash = Yajl::Parser.parse(msg) # might be some wrong json
+          # save the cert to local first, since the start_tls read from file.
+          cert_filename = save_cert_to_file msg_hash["cert"]
+          # cert filename is a key for connection pool
+          client = $connection_pool[cert_filename]
+
+          ### Create client connection if doesn't exist in pool.
+          if client.nil?
+            client = EM::ApnManager::Client.new(options.merge!({cert: cert_filename}))
+            # Store the connection to pool
+            $connection_pool[cert_filename] = client
+          end
+
+          ### send message directly if connection was connected.
+          ### TODO you can bind on_close, on_open, on_error events.
+          notification = EM::ApnManager::Notification.new(msg_hash["token"], :alert => msg_hash["message"])
+          if client.connected?
+            client.deliver(notification)
+          else
+            # if connection not connected, set callback block to deliver notification, and connect to apple server.
+            client.on_open do
+              client.deliver(notification)
+            end
+            client.connect
+          end
+        end
+      end
+
+      private
+
+      def save_cert_to_file cert_content
+        # TODO, should store Rails.root/tmp/certs and this folder should be protected.
+        FileUtils.mkdir_p "certs"
+        filename = Base64.encode64(cert_content)[0..50]
+        filename = File.join "certs", filename
+        return filename if File.exist?(filename)
+
+        File.open filename, "w+" do |f|
+          f.write cert_content
+        end
+        filename
+      end
+    end
+  end
+end

data/lib/em_apn_manager/notification.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+module EventMachine
+  module ApnManager
+    class Notification
+      DATA_MAX_BYTES    = 256
+
+      class PayloadTooLarge < StandardError;end
+
+      attr_reader :token
+      attr_accessor :identifier, :expiry
+
+      def initialize(token, aps = {}, custom = {}, options = {})
+        raise "Bad push token: #{token}" if token.nil? || (token.length != 64)
+
+        @token  = token
+        @aps    = aps
+        @custom = custom
+
+        self.identifier = options[:identifier] if options[:identifier]
+        self.expiry = options[:expiry] if options[:expiry]
+      end
+
+      def payload
+        Yajl::Encoder.encode(@custom.merge(:aps => @aps))
+      end
+
+      # Documentation about this format is here:
+      # http://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingWIthAPS/CommunicatingWIthAPS.html
+      def data
+        identifier = @identifier || 0
+        expiry     = @expiry || 0
+        size = [payload].pack("a*").size
+        data_array = [1, identifier, expiry, 32, token, size, payload]
+        data_array.pack("cNNnH*na*")
+      end
+
+      def validate!
+        if data.size > DATA_MAX_BYTES
+          error = "max is #{DATA_MAX_BYTES} bytes, but got #{data.size}: #{payload.inspect}"
+          raise PayloadTooLarge.new(error)
+        else
+          true
+        end
+      end
+
+      def identifier=(new_identifier)
+        @identifier = new_identifier.to_i
+      end
+
+      def truncate_alert!
+        while data.size > DATA_MAX_BYTES && !@aps["alert"].nil? && @aps["alert"].size > 0
+          @aps["alert"] = @aps["alert"][0..-2]
+        end
+      end
+    end
+  end
+end