apn 1.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in apn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Peter Hrbacik
+
+MIT License
+
+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.md

@@ -0,0 +1,74 @@
+# APN
+
+APN is a lightweight Apple Push Notification daemon for Ruby on Rails. APN runs as a daemon, works asynchronously using Redis and keeps persistent connection to Apple Push Notification Server.
+
+## Prerequisites
+
+APN works asynchronously, queueing messages from Redis, so you will need to have a running instance of the Redis server.
+
+[Installation guide for Redis server](http://redis.io/topics/quickstart)
+
+You will also need certificate file from Apple to be able to communicate with their server.
+There are many guides how to do that.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'apn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install apn
+
+## Daemon usage
+
+Run daemon within your root Rails directory with this command:
+
+```
+Usage: apn start|stop|run [options]
+    --cert_file=MANDATORY        Location of the cert pem file
+    --cert_password=OPTIONAL     Password for the cert pem file
+    --redis_host=OPTIONAL   Redis hostname
+    --redis_port=OPTIONAL   Redis port
+    --queue=OPTIONAL        Name of the Redis queue
+    --log_file=OPTIONAL          Log file (default STDOUT)
+    --help                  Show help
+```
+
+You can use ```apn stop``` instead of start in order to kill a running daemon with the options you provide.
+
+## Client usage
+
+```ruby
+require 'apn'
+
+message = {:alert => 'This is a test from APN!', :badge => 16}
+APN.queue(message)
+```
+
+If you want to configure APN, just add configuration block.
+
+```ruby
+require 'apn'
+
+APN.configure do |config|
+  config.redis_host = 'localhost'
+  config.redis_port = 6379
+end
+
+message = {:alert => 'This is a test from APN!', :badge => 16}
+APN.queue(message)
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/apn.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'apn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "apn"
+  spec.version       = APN::VERSION
+  spec.authors       = ["Peter Hrbacik"]
+  spec.email         = ["info@itrinity.com"]
+  spec.description   = 'APN is a lightweight Apple Push Notification daemon for Ruby on Rails. APN works asynchronously using Redis and run as a daemon.'
+  spec.summary       = 'Asynchronous Apple Push Notification daemon'
+  spec.homepage      = "http://github.com/itrinity/apn"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   << "apn"
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency(%q<redis>, ["~> 2.2.2"])
+  spec.add_dependency(%q<activesupport>, [">= 0"])
+  spec.add_dependency(%q<daemons>, ["= 1.1.6"])
+end

data/bin/apn

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+ARGV << '--help' if ARGV.empty?
+
+require 'optparse'
+require 'apn'
+require 'daemons'
+
+command = ARGV.shift
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: apn [options]"
+
+  opts.on("--cert_file=MANDATORY", "Location of the cert pem file") do |cert_file|
+    options[:cert] = cert_file
+  end
+
+  opts.on("--cert_password=OPTIONAL", "Password for the cert pem file") do |cert_password|
+    options[:password] = cert_password
+  end
+
+  opts.on("--redis_host=OPTIONAL", "Redis hostname") do |host|
+    options[:redis_host] = host
+  end
+
+  opts.on("--redis_port=OPTIONAL", "Redis port") do |port|
+    options[:redis_port] = port
+  end
+
+  opts.on("--redis_password=OPTIONAL", "Redis password") do |redis_password|
+    options[:redis_password] = redis_password
+  end
+
+  opts.on("--environment=OPTIONAL", "Specify sandbox or production") do |env|
+    if env == 'production'
+      options[:host] = 'gateway.push.apple.com'
+    else
+      options[:host] = 'gateway.sandbox.push.apple.com'
+    end
+  end
+
+  opts.on("--queue=OPTIONAL", "Name of the redis queue") do |queue|
+    options[:queue] = queue
+  end
+
+  opts.on("--dir=OPTIONAL", "Directory to start in") do |dir|
+    options[:dir] = dir
+  end
+
+  opts.on("--log_file=OPTIONAL", "Logfile to log in") do |log_file|
+    options[:logfile] = log_file
+  end
+
+  opts.on('--help', 'Show help') do |help|
+    puts opts
+  end
+end.parse!
+
+options[:queue] ||= 'apn_queue'
+
+pids_dir  = "tmp/pids"
+log_dir   = "log"
+
+case command
+  when 'start'
+    unless options[:foreground]
+      Daemons.daemonize(
+          :app_name => options[:queue],
+          :dir_mode => :normal,
+          :dir => pids_dir,
+          :log_dir => log_dir,
+          :backtrace => true,
+          :log_output => true
+      )
+    end
+
+    APN::Daemon.new(options).run!
+  when 'run'
+    APN::Daemon.new(options).run!
+  when 'stop'
+    unless options[:foreground]
+      files = Daemons::PidFile.find_files(pids_dir, options[:queue])
+      files.each do |file|
+        pid = File.open(file) {|h| h.read}.to_i
+        `kill -9 #{pid}`
+      end
+    end
+end

data/lib/apn.rb

@@ -0,0 +1,51 @@
+require 'apn/daemon'
+require 'apn/notification'
+require 'apn/config'
+require 'apn/feedback'
+require 'apn/client'
+#require 'apn/log'
+require 'apn/version'
+require 'redis'
+
+module APN
+  class << self
+    def queue(message, queue_name = 'apn_queue')
+      self.redis.lpush(queue_name, message.to_json)
+    end
+
+    def redis
+      @redis ||= Redis.new(:host => APN.config.redis_host, :port => APN.config.redis_port, :password => APN.config.redis_password)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger ||= Logger.new(logfile)
+    end
+
+    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
+
+    def log_and_die(msg)
+      logger.fatal(msg)
+      raise msg
+    end
+
+    def logfile
+      APN.config.logfile ? APN.config.logfile : STDOUT
+    end
+
+    def configure
+      block_given? ? yield(Config) : Config
+    end
+    alias :config :configure
+  end
+end
+
+require 'apn/railtie' if defined?(Rails)

data/lib/apn/client.rb

@@ -0,0 +1,85 @@
+require 'openssl'
+require 'socket'
+
+module APN
+  class Client
+    def initialize(options = {})
+      @cert = options[:cert]
+      @password = options[:password]
+      @host = options[:host]
+      @port = options[:port]
+    end
+
+    def connect!
+      APN.log(:info, 'Connecting...')
+
+      cert = self.setup_certificate
+      @socket = self.setup_socket(cert)
+
+      APN.log(:info, 'Connected!')
+
+      @socket
+    end
+
+    def setup_certificate
+      APN.log(:info, 'Setting up certificate...')
+      @context      = OpenSSL::SSL::SSLContext.new
+      @context.cert = OpenSSL::X509::Certificate.new(File.read(@cert))
+      @context.key  = OpenSSL::PKey::RSA.new(File.read(@cert), @password)
+      APN.log(:info, 'Certificate created!')
+
+      @context
+    end
+
+    def setup_socket(ctx)
+      APN.log(:info, 'Connecting...')
+
+      socket_tcp = TCPSocket.new(@host, @port)
+      OpenSSL::SSL::SSLSocket.new(socket_tcp, ctx).tap do |s|
+        s.sync = true
+        s.connect
+      end
+    end
+
+    def reset_socket
+      @socket.close if @socket
+      @socket = nil
+
+      connect!
+    end
+
+    def socket
+      @socket ||= connect!
+    end
+
+    def push(notification)
+      begin
+        APN.log(:info, "Sending #{notification.device_token}: #{notification.json_payload}")
+        socket.write(notification.to_bytes)
+        socket.flush
+
+        if IO.select([socket], nil, nil, 1) && error = socket.read(6)
+          error = error.unpack('ccN')
+          APN.log(:error, "Encountered error in push method: #{error}, backtrace #{error.backtrace}")
+          return false
+        end
+
+        APN.log(:info, 'Message sent')
+
+        true
+      rescue OpenSSL::SSL::SSLError, Errno::EPIPE => e
+        APN.log(:error, "Encountered error: #{e}, backtrace #{e.backtrace}")
+        APN.log(:info, 'Trying to reconnect...')
+        reset_socket
+        APN.log(:info, 'Reconnected')
+      end
+    end
+
+    def feedback
+      if bunch = socket.read(38)
+        f = bunch.strip.unpack('N1n1H140')
+        APN::FeedbackItem.new(Time.at(f[0]), f[2])
+      end
+    end
+  end
+end

data/lib/apn/config.rb

@@ -0,0 +1,38 @@
+module APN
+  module Config
+    extend self
+
+    def option(name, options = {})
+      defaults[name] = settings[name] = options[:default]
+
+      class_eval <<-RUBY
+        def #{name}
+          settings[#{name.inspect}]
+        end
+
+        def #{name}=(value)
+          settings[#{name.inspect}] = value
+        end
+
+        def #{name}?
+          #{name}
+        end
+      RUBY
+    end
+
+    def defaults
+      @defaults ||= {}
+    end
+
+    def settings
+      @settings ||= {}
+    end
+
+    option :redis_host, :default => 'localhost'
+    option :redis_port, :default => 6379
+    option :redis_password
+    option :logfile
+    option :cert_file
+    option :cert_password
+  end
+end

data/lib/apn/daemon.rb

@@ -0,0 +1,85 @@
+require 'redis'
+require 'logger'
+require 'active_support/ordered_hash'
+require 'active_support/json'
+require 'base64'
+require 'apn/client'
+require 'apn/notification'
+require 'apn/config'
+#require 'apn/log'
+
+module APN
+  class Daemon
+    attr_accessor :redis, :host, :apple, :cert, :queue, :connected, :logger, :airbrake
+
+    def initialize(options = {})
+      options[:redis_host]  ||= 'localhost'
+      options[:redis_port]  ||= '6379'
+      options[:host]        ||= 'gateway.sandbox.push.apple.com'
+      options[:port]        ||=  2195
+      options[:queue]       ||= 'apn_queue'
+      options[:password]    ||= ''
+      raise 'No cert provided!' unless options[:cert]
+
+      redis_options = { :host => options[:redis_host], :port => options[:redis_port] }
+      redis_options[:password] = options[:redis_password] if options.has_key?(:redis_password)
+
+      @redis = Redis.new(redis_options)
+      @queue = options[:queue]
+      @cert = options[:cert]
+      @password = options[:password]
+      @host = options[:host]
+      @port = options[:port]
+      @dir = options[:dir]
+
+      APN.configure do |config|
+        config.logfile = options[:logfile]
+      end
+
+      APN.log(:info, "Listening on queue: #{self.queue}")
+    end
+
+    def run!
+      @last_notification = nil
+
+      loop do
+        begin
+          message = @redis.blpop(self.queue, 1)
+          if message
+            @notification = APN::Notification.new(JSON.parse(message.last,:symbolize_names => true))
+
+            send_notification
+          end
+        rescue Exception => e
+          if e.class == Interrupt || e.class == SystemExit
+            APN.log(:info, 'Shutting down...')
+            exit(0)
+          end
+
+          APN.log(:error, "Encountered error: #{e}, backtrace #{e.backtrace}")
+
+          APN.log(:info, 'Trying to reconnect...')
+          client.connect!
+          APN.log(:info, 'Reconnected')
+
+          client.push(@notification)
+        end
+      end
+    end
+
+    def send_notification
+      if @last_notification.nil? || @last_notification < Time.now - 3600
+        APN.log(:info, 'Forced reconnection...')
+        client.connect!
+      end
+
+      client.push(@notification)
+
+      @last_notification = Time.now
+    end
+
+    def client
+      @client ||= APN::Client.new(host: @host, port: @port, cert: @cert, password: @password, dir: @dir, queue: @queue)
+    end
+  end
+end