resque-aps 0.9.15 → 0.9.17

data/HISTORY.md

@@ -1,3 +1,19 @@
+## 0.9.17 (2011-08-09)
+
+* Add aps_retry flag to stop a daemon from looping back after the queue is empty
+* Added daemon class to handle queuing applications. This should be scheduled to run every minute.
+* Added new rake task to clear the APS application queued count.
+* Changed the APS tab view for performance
+* Added created_at attribute to Notification
+* 
+
+## 0.9.16 (2011-06-02)
+
+* Add previous notification to the failed_aps_write call
+* Fixed aps_nil_notification_retry? call
+* Fixed Application perform
+* Improved web view
+
 ## 0.9.15 (2010-10-18)
 
 * Move the application enqueue/dequeue methods to the Application class

data/README.markdown

@@ -13,7 +13,7 @@ To install:
 
 You'll need to add this to your Rails rakefile to see the queue lengths:
 
-    require 'resque_aps/tasks'
+    require 'resque/plugins/aps/tasks'
     task "resque:setup" => :environment
 
     $ rake resque:aps:queue_lengths 

data/lib/resque/plugins/aps/application.rb

@@ -1,4 +1,5 @@
 require 'openssl'
+require 'benchmark'
 
 module Resque
   module Plugins
@@ -9,54 +10,91 @@ module Resque
 
         attr_accessor :name, :cert_file, :cert_passwd
 
-        @queue = "apple_push_service"
+        @queue   = "apple_push_service"
+        @@CAFile = nil
 
         def inspect
           "#<#{self.class.name} #{name.inspect}, #{cert_passwd.inspect}, #{cert_file.inspect}>"
         end
-    
+
         def self.perform(*args)
+          app_name = args[0]
+          @aps_retry = args[1] || false
+          begin
+            Resque.enqueue_aps_application(app_name) if @aps_retry
+            count, duration, ex = Resque::Plugins::Aps::Application.perform_no_fail(app_name)
+            logger.info("Sent #{count} #{app_name} notifications in batch over #{duration} sec.") if logger
+            Resque.dequeue_aps_application(app_name) if @aps_retry
+            raise ex if ex
+          rescue
+            Resque.dequeue_aps_application(app_name) if @aps_retry
+            raise $!
+          end
+        end
+
+        def self.perform_clear(app_name)
+          while true
+            count, duration, ex = Resque::Plugins::Aps::Application.perform_no_fail(app_name, false, true)
+            p "Sent #{count} #{app_name} notifications in batch over #{duration} sec. Returned #{ex.inspect}"
+            break if ex.nil?
+          end
+        end
+
+        def self.perform_no_fail(app_name, requeue = true, read_response = false)
           count = 0
           start = Time.now
-          app_name = args[0]
-          Resque.aps_application(app_name).socket do |socket, app|
-            while true
-              n = Resque.dequeue_aps(app_name)
-              if n.nil?
-                if app.aps_nil_notification_retry? count, start
-                  next
-                else
-                  break
+          excep = nil
+          duration = Benchmark.realtime do
+            Resque.aps_application(app_name).socket do |socket, app|
+              n_old = nil
+              while true
+                n = Resque.dequeue_aps(app_name)
+                if n.nil?
+                  if @aps_retry && app.aps_nil_notification_retry?(count, start)
+                    next
+                  else
+                    break
+                  end
                 end
-              end
 
-              app.before_aps_write n
-              begin
-                n.batch_id = count + 1
-                n.expiry   = Time.now.utc.to_i + 3600
-                socket.write(n.formatted)
-                app.after_aps_write n
-                count += 1
-                # resp = socket.read
-                # if resp && resp != ""
-                #   # logger.error "Failure response: #{resp.inspect}" if logger
-                #   logger.error "Failure response: #{resp.bytes.to_a.map{|i| i.to_s(16)}.join}" if logger
-                #   break
-                # end
-              rescue
-                logger.error Application.application_exception($!, app_name) if logger
-                app.failed_aps_write n, $!
-                logger.error "#{$!}: Sent #{count} notifications before failure." if logger
-                Resque.enqueue_aps(app_name, n)
-                break
+                app.before_aps_write n
+                begin
+                  n.batch_id = count + 1
+                  n.expiry   = Time.now.utc.to_i + 3600
+                  socket.write(n.formatted)
+                  app.after_aps_write n
+                  count += 1
+                  if read_response
+                    resp = socket.read
+                    if resp && resp != ""
+                      # logger.error "Failure response: #{resp.inspect}" if logger
+                      logger.error "Failure response: #{resp.bytes.to_a.map{|i| i.to_s(16)}.join}" if logger
+                      break
+                    end
+                  end
+                rescue
+                  # logger.error Application.application_exception($!, app_name) if logger
+                  app.failed_aps_write n, $!, n_old
+                  logger.error "#{$!}: Sent #{count} notifications before failure." if logger
+                  Resque.enqueue_aps(app_name, n) if requeue
+                  excep = $!
+                  break
+                end
+                n_old = n
               end
             end
           end
-          logger.info("Sent #{count} #{app_name} notifications in batch over #{Time.now - start} sec.") if logger
-        ensure
-          Resque.dequeue_aps_application(app_name)
+          return count, duration, excep
         end
     
+        def self.verify_ssl_certificate(preverify_ok, ssl_context)
+          if preverify_ok != true || ssl_context.error != 0
+            err_msg = "SSL Verification failed -- Preverify: #{preverify_ok}, Error: #{ssl_context.error_string} (#{ssl_context.error})"
+            raise OpenSSL::SSL::SSLError.new(err_msg)
+          end
+          true
+        end
+
         #
         # Create the TCP and SSL sockets for sending the notification
         #
@@ -65,6 +103,16 @@ module Resque
           ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
           ctx.cert = OpenSSL::X509::Certificate.new(cert)
 
+          if @@CAFile && File.exists?(@@CAFile)
+            ctx.ca_file = @@CAFile
+          end
+          if defined?(ROOT_CA) && ROOT_CA && File.directory?(ROOT_CA)
+            ctx.ca_path = ROOT_CA
+          end
+          ctx.verify_callback = proc do |preverify_ok, ssl_context|
+            Resque::Plugins::Aps::Application.verify_ssl_certificate(preverify_ok, ssl_context)
+          end
+
           s = TCPSocket.new(host, port)
           ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)
           ssl.sync = true
@@ -98,13 +146,13 @@ module Resque
           exc.set_backtrace(exception.backtrace)
           return exc
         end
-    
+
         def initialize(attributes)
           attributes.each do |k, v|
             respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
           end
         end
-    
+
         def socket(cert = nil, certp = nil, host = nil, port = nil, &block)
           logger.debug("resque-aps: ssl_socket(#{name})") if logger
           exc = nil
@@ -117,13 +165,13 @@ module Resque
           rescue
             raise Application.application_exception($!, name)
           end
-      
+
           begin
             ssl_socket.connect
             yield ssl_socket, self if block_given?
           rescue
             exc = Application.application_exception($!, name)
-            if $!.message =~ /^SSL_connect .* certificate (expired|revoked)/
+            if $!.message =~ /^SSL_connect .* certificate (expired|revoked)/ || $!.message =~ /^SSL Verification failed/
               notify_aps_admin exc
             end
             raise exc
@@ -137,7 +185,7 @@ module Resque
         def to_hash
           {'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}
         end
-    
+
         def to_json
           to_hash.to_json
         end
@@ -150,7 +198,7 @@ module Resque
           logger.debug("ResqueAps[after_write]: #{notification}") if logger
         end
 
-        def failed_aps_write(notification, exception)
+        def failed_aps_write(notification, exception, previous_notification = nil)
           logger.error("ResqueAps[write_failed]: #{exception} (#{notification}): #{exception.backtrace.join("\n")}") if logger
         end
 
@@ -177,63 +225,6 @@ module Resque
           logger.error("ResqueAps[read_failed]: Bad data on the socket (#{name})") if logger
         end
 
-
-
-
-
-        def queued_count
-          (redis.get(Resque.aps_application_queued_key(name)) || 0).to_i
-        end
-
-        def lock_key
-          @lock_key ||= "#{Resque.aps_application_key(name)}:lock"
-        end
-        
-        def redis
-          Resque.redis
-        end
-        
-        def acquire_lock
-          if redis.setnx(lock_key, Time.now.utc.to_i + 1)
-            true
-          elsif Time.at(redis.get(lock_key).to_i) > Time.now
-            delete_lock
-            acquire_lock
-          else
-            false
-          end
-        end
-
-        def delete_lock
-          redis.del(lock_key)
-        end
-
-        def enqueue(override = false)
-          count_apps = 0
-          count_not  = 0
-          locked     = false
-
-          unless override
-            count_apps = queued_count
-            if count_apps == 0
-              locked     = acquire_lock
-              return unless locked
-              count_apps = queued_count
-            end
-            count_not  = Resque.aps_notification_count_for_application(name)
-          end
-
-          if count_apps <= 0 || (count_apps < Resque.aps_application_job_limit && (count_not > Resque.aps_queue_size_upper && count_not % (Resque.aps_queue_size_upper / 10) == 0))
-            enqueue(Resque::Plugins::Aps::Application, name)
-            redis.incr(Resque.aps_application_queued_key(name))
-            delete_lock if locked
-          end
-        end
-
-        def dequeue
-          redis.decr(Resque.aps_application_queued_key(name))
-        end
-
       end
     end
   end

data/lib/resque/plugins/{aps.rb → aps/aps.rb}

@@ -61,18 +61,48 @@ module Resque
       def aps_application_job_limit
         @aps_application_job_limit ||= 5
       end
-        
+
+      def aps_applications_queued_count(application_name)
+        (redis.get(Resque.aps_application_queued_key(name)) || 0).to_i
+      end
+
+      # Increase the count of queued application workers
+      def enqueue_aps_application(application_name, override = false)
+        res = redis.incr(aps_application_queued_key(application_name))
+      end
+
+      # Decrease the count of queued application workers
+      def dequeue_aps_application(application_name)
+        res = redis.decr(aps_application_queued_key(application_name))
+      end
+
+      # Push the given notification onto the given application queue
+      # returns true
       def enqueue_aps(application_name, notification)
+        create_aps_application(application_name, nil, nil) unless aps_application_exists?(application_name)
         redis.rpush(aps_application_queue_key(application_name), encode(notification.to_hash))
-        Resque::Plugins::Aps::Application.new('name' => application_name).enqueue
+        if inline?
+          Resque::Plugins::Aps::Application.perform(application_name, false)
+        end
         true
       end
 
+      # Pop the oldest notification off the given application queue
+      # returns nil - if there are none on the queue
       def dequeue_aps(application_name)
         h = decode(redis.lpop(aps_application_queue_key(application_name)))
         h ? Resque::Plugins::Aps::Notification.new(h) : nil
       end
-  
+
+
+      # Age of the oldest notification in the given application queue, in seconds
+      # returns 0 - if there are no notifications on the queue or the oldest has no create time
+      def aps_age(application_name)
+        h = decode(redis.lindex(aps_application_queue_key(application_name), 0))
+        res = h ? h['created_at'] ? Time.now.utc - Time.parse(h['created_at']) : 0 : 0
+        return res
+      end
+
       # Returns the number of queued notifications for a given application
       def aps_notification_count_for_application(application_name)
         redis.llen(aps_application_queue_key(application_name)).to_i
@@ -88,7 +118,17 @@ module Resque
         redis.set(aps_application_key(name), encode({'name' => name, 'cert_file' => cert_file, 'cert_passwd' => cert_passwd}))
         redis.sadd(:aps_applications, name)
       end
-  
+
+      def delete_aps_application(name)
+        redis.del(aps_application_key(name))
+        redis.srem(:aps_applications, name)
+        redis.del(aps_application_queue_key(name))
+      end
+
+      def aps_application_exists?(name)
+        redis.exists(aps_application_key(name)) == 1
+      end
+
       def aps_application(name)
         h = decode(redis.get(aps_application_key(name)))
         h ? Resque::Plugins::Aps::Application.new(h) : nil

data/lib/resque/plugins/aps/daemon.rb

@@ -0,0 +1,77 @@
+require 'logger'
+
+module Resque
+  module Plugins
+    module Aps
+      class Daemon
+        include Resque::Plugins::Aps::Helper
+        extend Resque::Plugins::Aps::Helper
+
+        class << self
+
+          # Schedule all jobs and continually look for delayed jobs (never returns)
+          def run
+            # trap signals
+            register_signal_handlers
+
+            # Now start the scheduling part of the loop.
+            loop do
+              handle_aps_queues(30)
+              poll_sleep
+            end
+
+            # never gets here.
+          rescue
+            logger.error "#{$!}: #{$!.backtrace.join("\n")}"
+          end
+
+          def handle_aps_queues(max_age = 60)
+            Resque.aps_application_names(0, 0).each do |app_name|
+              count_not = Resque.aps_notification_count_for_application(app_name)
+              if count_not > 0
+                count_apps = Resque.aps_applications_queued_count(app_name).to_i
+                if count_apps == 0
+                  Resque.enqueue(Resque::Plugins::Aps::Application, app_name, true)
+                elsif Resque.aps_age(app_name) >= max_age
+                  Resque.enqueue(Resque::Plugins::Aps::Application, app_name, false)
+                else
+                  logger.error "Unable to queue APS application: #{app_name}"
+                end
+              end
+            end
+          end
+
+          # For all signals, set the shutdown flag and wait for current
+          # poll/enqueing to finish (should be almost istant).  In the
+          # case of sleeping, exit immediately.
+          def register_signal_handlers
+            trap("TERM") { shutdown }
+            trap("INT")  { shutdown }
+            trap('QUIT') { shutdown } unless defined? JRUBY_VERSION
+          end
+
+          def handle_shutdown
+            exit if @shutdown
+            yield
+            exit if @shutdown
+          end
+
+          # Sleeps and returns true
+          def poll_sleep
+            @sleeping = true
+            handle_shutdown { sleep 5 }
+            @sleeping = false
+            true
+          end
+
+          # Sets the shutdown flag, exits if sleeping
+          def shutdown
+            @shutdown = true
+            exit if @sleeping
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/aps/notification.rb

@@ -5,12 +5,14 @@ module Resque
         include Resque::Plugins::Aps::Helper
         extend Resque::Plugins::Aps::Helper
 
-        attr_accessor :application_name, :device_token, :payload, :batch_id, :expiry
+        attr_accessor :application_name, :device_token, :payload, :batch_id, :expiry, :created_at
 
         def initialize(attributes)
           attributes.each do |k, v|
             respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(Resque::Plugins::Aps::UnknownAttributeError, "unknown attribute: #{k}")
           end
+          @created_at = Time.now.utc unless @created_at
+          @created_at = Time.parse(@created_at) if @created_at.kind_of?(String)
         end
         
         def inspect

data/lib/resque/plugins/aps/server.rb

@@ -10,19 +10,31 @@ module Resque
 
           base.class_eval do
 
+            aps_dir = File.dirname(File.expand_path(__FILE__)) + "/server/views"
+
             get "/aps" do
               # Is there a better way to specify alternate template locations with sinatra?
-              erb File.read(File.join(File.dirname(__FILE__), 'server/views/aps_applications.erb'))
+              erb File.read("#{aps_dir}/aps_applications.erb"), :resque => Resque
             end
 
             get "/aps/:application_name" do
               # Is there a better way to specify alternate template locations with sinatra?
-              erb File.read(File.join(File.dirname(__FILE__), 'server/views/notifications.erb'))
+              erb File.read("#{aps_dir}/notifications.erb"), :resque => Resque
             end
         
             post "/aps/:application_name" do
               Resque.enqueue(Resque::Plugins::Aps::Application, params[:application_name])
-              redirect url("/aps")
+              redirect url("/aps?page_size=0")
+            end
+            
+            post "/aps/:application_name/reset" do
+              Resque.redis.set(Resque.aps_application_queued_key(params[:application_name]), 0)
+              redirect url("/aps?page_size=0")
+            end
+            
+            post "/aps/:application_name/delete" do
+              Resque.delete_aps_application(params[:application_name])
+              redirect url("/aps?page_size=0")
             end
           end
 

data/lib/resque/plugins/aps/server/views/aps_applications.erb

@@ -5,26 +5,49 @@
 </p>
 
 <p class='sub'>
-  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.aps_applications_count %></b> applications.
+  Showing <b><%=size = Resque.aps_applications_count %></b> applications.
 </p>
 
 <table>
   <tr>
     <th>Application</th>
     <th>Notification Count</th>
+    <th>Queued Count</th>
     <th></th>
   </tr>
-  <% resque.aps_application_names(start, 20).each do |application_name| %>
+  <%   
+       application_names = Resque.aps_application_names(0, 0)
+       application_data  = {}
+       application_names.each do |app_name|
+         application_data[app_name] = [
+           Resque.aps_notification_count_for_application(app_name),
+           Resque.aps_applications_queued_count(app_name).to_i
+         ]
+       end
+       application_names.sort! { |x,y|
+         ret = application_data[y][0] <=> application_data[x][0]
+         ret = application_data[y][1] <=> application_data[x][1] if ret == 0
+         ret = x                      <=> y                      if ret == 0
+         ret
+       }
+  %>
+  <% application_names.each do |application_name| %>
     <tr>
       <td><a href="<%= url "aps/#{application_name}" %>"><%= application_name %></a></td>
-      <td><%= resque.aps_notification_count_for_application(application_name) %></td>
+      <td><%= application_data[application_name][0] %></td>
+      <td><%= application_data[application_name][1] %></td>
       <td>
         <form action="<%= url "/aps/#{application_name}" %>" method="post">
           <input type="submit" value="Queue worker">
         </form>
+        <form action="<%= url "/aps/#{application_name}/reset" %>" method="post">
+          <input type="submit" value="Reset queued count">
+        </form>
+        <form action="<%= url "/aps/#{application_name}/delete" %>" method="post">
+          <input type="submit" value="Remove queue">
+        </form>
       </td>
     </tr>
   <% end %>
 </table>
 
-<%= partial :next_more, :start => start, :size => size %>

data/lib/resque/plugins/aps/tasks.rb

@@ -19,6 +19,17 @@ namespace :resque do
         abort "None"
       end
     end
+
+    desc "Reset the queued worker counts"
+    task :reset_queue_workers => :setup do
+      require 'resque'
+      require 'resque_aps'
+
+      application_names = Resque.aps_application_names(0, 0)
+      application_names.each do |application_name|
+        Resque.redis.set(Resque.aps_application_queued_key(application_name), 0)
+      end      
+    end
   end
 
 end

data/lib/resque/plugins/aps/version.rb

@@ -1,7 +1,7 @@
 module Resque
   module Plugins
     module Aps
-      Version = '0.9.15'
+      Version = '0.9.17'
     end
   end
 end

data/lib/resque_aps.rb

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'resque'
 require 'logger'
 require 'resque/server'
-require 'resque/plugins/aps'
+require 'resque/plugins/aps/aps'
 require 'resque/plugins/aps/helper'
 require 'resque/plugins/aps/version'
 require 'resque/plugins/aps/server'

data/test/test_helper.rb

@@ -3,15 +3,17 @@
 # to do all the same stuff
 
 dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$: << (File.dirname(__FILE__) + '/../lib')
 
 require 'rubygems'
 require 'test/unit'
 require 'mocha'
 require 'resque'
 require 'ruby-debug'
-require File.join(dir, '../lib/resque_aps')
-$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__)) + '/../lib'
+require 'resque_aps'
 
+ROOT_CA = '/etc/ssl/certs'
 
 #
 # make sure we can run redis

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: resque-aps
 version: !ruby/object:Gem::Version 
-  hash: 37
   prerelease: false
   segments: 
   - 0
   - 9
-  - 15
-  version: 0.9.15
+  - 17
+  version: 0.9.17
 platform: ruby
 authors: 
 - Ashley Martens
@@ -15,18 +14,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 -07:00
+date: 2011-08-09 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: jeweler
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -36,11 +33,9 @@ dependencies:
   name: mocha
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -50,11 +45,9 @@ dependencies:
   name: rack-test
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -73,13 +66,13 @@ extra_rdoc_files:
 - LICENSE
 - README.markdown
 files: 
-- .gitignore
 - HISTORY.md
 - LICENSE
 - README.markdown
 - Rakefile
-- lib/resque/plugins/aps.rb
 - lib/resque/plugins/aps/application.rb
+- lib/resque/plugins/aps/aps.rb
+- lib/resque/plugins/aps/daemon.rb
 - lib/resque/plugins/aps/feedback.rb
 - lib/resque/plugins/aps/helper.rb
 - lib/resque/plugins/aps/notification.rb
@@ -104,32 +97,28 @@ homepage: http://github.com/ashleym1972/resque-aps
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Queuing system for Apple's Push Service on top of Resque

data/.gitignore

@@ -1 +0,0 @@
-*.pem