lowdown 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bae6b12ffe8101e10ab41c87a7e58f191d1c9e6
-  data.tar.gz: c34a58e8561c4c65c2292b207800b63237fcd038
+  metadata.gz: 044f0dfd72c7b5a984abac1cd844e06b71b1fac1
+  data.tar.gz: 68eae4bb641cf6d39edaf59681060f6b7ded8089
 SHA512:
-  metadata.gz: 13de1cb6266a8a507228b3ded7443c098fd7582d4df3c52c6dfaaba71c6cd1ec7b7db31d365a441187d3ecf88bbbe9485379d68377ae0b1563fc17373f857c4a
-  data.tar.gz: 32b3ae325cf9029554044f7bc63e5dd2a84b00a529b861c430084eb3d0904e2f30fc8d6ffacaeb2547457d972619aefbefbb7299124072ae175b329223c95bb0
+  metadata.gz: 65c0917420183c3408930d60645e00d54ffcf653bb3f28aa61aa00a8a85f623213652fbb7b8eded3c6524caa8025c57e488f8c5a58cd7786333e8b3eba0fed23
+  data.tar.gz: 2e20f00c914f2a95efff4a0a017f768004c892fdce49549b8aa269d30d2e431575c7b66e83103a4f3beb7af3a1c63dff6144955f6130e46b209677cbbf0df5f2

data/.yardopts

@@ -1,3 +1,4 @@
+--protected
 --no-private
 --markup markdown
 --main README.md

data/Rakefile

@@ -19,6 +19,7 @@ begin
 
   require "rake/testtask"
   Rake::TestTask.new(:test) do |t|
+    t.options = "--verbose"
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList['test/**/*_test.rb']

data/lib/lowdown/client.rb

@@ -160,8 +160,14 @@ module Lowdown
     # @param  [Notification] notification
     #         the notification object whose data to send to the service.
     #
-    # @yield  (see Connection#post)
-    # @yieldparam (see Connection#post)
+    # @yield  [response, notification]
+    #         called when the request is finished and a response is available.
+    #
+    # @yieldparam [Response] response
+    #         the Response that holds the status data that came back from the service.
+    #
+    # @yieldparam [Notification] notification
+    #         the originally passed in notification object.
     #
     # @raise  [ArgumentError]
     #         raised if the Notification is not {Notification#valid?}.
@@ -180,7 +186,10 @@ module Lowdown
 
       body = notification.formatted_payload.to_json
 
-      @connection.post("/3/device/#{notification.token}", headers, body, &callback)
+      # No need to keep a strong reference to the notification object, unless the user really wants it.
+      actual_callback = callback.arity < 2 ? callback : lambda { |response| callback.call(response, notification) }
+
+      @connection.post("/3/device/#{notification.token}", headers, body, &actual_callback)
     end
   end
 end

data/lib/lowdown/connection.rb

@@ -104,7 +104,7 @@ module Lowdown
       Timeout.timeout(timeout) do
         caller_thread = Thread.current
         @worker.enqueue do |http|
-          http.ping('12345678') { caller_thread.run }
+          http.ping('whatever') { caller_thread.run }
         end
         Thread.stop
       end
@@ -120,7 +120,7 @@ module Lowdown
     #
     def flush
       return unless @worker
-      sleep 0.1 until !@worker.alive? || @worker.empty? && @requests.zero?
+      sleep 0.1 until !@worker.working? && @requests.zero?
     end
 
     # Sends the provided data as a `POST` request to the service.
@@ -137,10 +137,10 @@ module Lowdown
     #         the (JSON) encoded payload data to send to the service.
     #
     # @yield  [response]
-    #         Called when the request is finished and a response is available.
+    #         called when the request is finished and a response is available.
     #
     # @yieldparam [Response] response
-    #         The Response that holds the status data that came back from the service.
+    #         the Response that holds the status data that came back from the service.
     #
     # @return [void]
     #
@@ -169,7 +169,7 @@ module Lowdown
         end
 
         stream.on(:close) do
-          callbacks << lambda do
+          callbacks.enqueue do
             callback.call(response)
             @requests.decrement!
           end
@@ -187,75 +187,49 @@ module Lowdown
     # * HTTP2 client
     # * Another thread from where request callbacks are ran
     #
-    class Worker < Thread
+    class Worker < Threading::Consumer
       def initialize(uri, ssl_context)
         @uri, @ssl_context = uri, ssl_context
 
+        # Start the worker thread.
+        #
         # Because a max size of 0 is not allowed, create with an initial max size of 1 and add a dummy job. This is so
         # that any attempt to add a new job to the queue is going to halt the calling thread *until* we change the max.
-        @queue = SizedQueue.new(1)
-        @queue << lambda { |*_| }
-
-        # Setup the consumer that performs the callbacks passed to Connection#request
-        @callback_queue = Queue.new
-        @callback_thread = Thread.new(@callback_queue) { |q| loop { q.pop.call } }
-
-        # Store the caller thread to be able to resume it once connected and to send exceptions to.
-        @caller_thread = Thread.current
-        # Start the worker thread.
-        super(&method(:main))
+        super(queue: Thread::SizedQueue.new(1))
         # Put caller thread into sleep until connected.
         Thread.stop
       end
 
-      # @yield  [http, callbacks_queue]
-      #
-      # @yieldparam [HTTP2::Client] http
-      #         the HTTP2 client instance.
-      #
-      # @yieldparam [Queue] callbacks_queue
-      #         the queue on which request callbacks should be performed.
+      # Tells the runloop to stop and halts the caller until finished.
       #
       # @return [void]
       #
-      def enqueue(&job)
-        @queue << job
+      def stop
+        thread[:should_exit] = true
+        thread.join
       end
 
       # @return [Boolean]
-      #         whether or not the work queue is empty.
-      #
-      def empty?
-        @queue.empty?
-      end
-
-      # Tells the runloop to stop and halts the caller until finished.
+      #         whether or not the worker is still alive and kicking.
       #
-      # @return [void]
-      #
-      def stop
-        self[:should_exit] = true
-        join
+      def working?
+        alive? && !empty? && !@callbacks.empty?
       end
 
       private
 
-      def main
-        connect
-        runloop
-      rescue Exception => exception
-        # Send any unexpected exceptions back to the thread that started the loop.
-        @caller_thread.raise(exception)
-      ensure
-        cleanup
-      end
-
-      def cleanup
-        @callback_thread.kill
+      def post_runloop
+        @callbacks.kill
         @ssl.close
+        super
       end
 
-      def connect
+      def pre_runloop
+        super
+
+        # Setup the request callbacks consumer here so its parent thread will be this worker thread.
+        @callbacks = Threading::Consumer.new
+
         @ssl = OpenSSL::SSL::SSLSocket.new(TCPSocket.new(@uri.host, @uri.port), @ssl_context)
         @ssl.sync_close = true
         @ssl.hostname = @uri.hostname
@@ -270,31 +244,36 @@ module Lowdown
         end
       end
 
+      # Called when the HTTP client changes its state to `:connected` and lets the parent thread (which was stopped in
+      # `#initialize`) continue.
+      #
+      # @return [void]
+      #
       def change_to_connected_state
-        @queue.max = @http.remote_settings[:settings_max_concurrent_streams]
+        queue.max = @http.remote_settings[:settings_max_concurrent_streams]
         @connected = true
-        @caller_thread.run
+        parent_thread.run
       end
 
       # @note Only made into a method so it can be overriden from the tests, because our test setup doesn’t behave the
       #       same as the real APNS service.
       #
+      # @return [Boolean]
+      #         whether or not the HTTP client’s state is `:connected`.
+      #
       def http_connected?
         @http.state == :connected
       end
 
       # Start the main IO and HTTP processing loop.
       def runloop
-        until self[:should_exit] || @ssl.closed?
+        until thread[:should_exit] || @ssl.closed?
           # Once connected, add requests while the max stream count has not yet been reached.
           if !@connected
             change_to_connected_state if http_connected?
-          elsif @http.active_stream_count < @queue.max
-            begin
-              # Run dispatched jobs that add new requests.
-              @queue.pop(true).call(@http, @callback_queue)
-            rescue ThreadError
-            end
+          elsif @http.active_stream_count < queue.max
+            # Run dispatched jobs that add new requests.
+            perform_job(non_block: true, arguments: [@http, @callbacks])
           end
           # Try to read data from the SSL socket without blocking and process it.
           begin

data/lib/lowdown/mock.rb

@@ -1,6 +1,7 @@
 require "lowdown/certificate"
 require "lowdown/client"
 require "lowdown/response"
+require "lowdown/threading"
 
 module Lowdown
   # Provides a collection of test helpers.
@@ -122,17 +123,18 @@ module Lowdown
 
       # @!group Real API: Instance Method Summary
 
-      # Yields stubbed {#responses} or if none are available defaults to success responses.
+      # Yields stubbed {#responses} or if none are available defaults to success responses. It does this on a different
+      # thread, just like the real API does.
       #
       # @param (see Lowdown::Connection#post)
       # @yield (see Lowdown::Connection#post)
       # @yieldparam (see Lowdown::Connection#post)
       # @return (see Lowdown::Connection#post)
       #
-      def post(path, headers, body)
+      def post(path, headers, body, &callback)
         response = @responses.shift || Response.new(":status" => "200", "apns-id" => (headers["apns-id"] || generate_id))
         @requests << Request.new(path, headers, body, response)
-        yield response
+        @callbacks.enqueue { callback.call(response) }
       end
 
       # Changes {#open?} to return `true`.
@@ -140,6 +142,7 @@ module Lowdown
       # @return [void]
       #
       def open
+        @callbacks = Threading::Consumer.new
         @open = true
       end
 
@@ -148,6 +151,9 @@ module Lowdown
       # @return [void]
       #
       def close
+        flush
+        @callbacks.kill
+        @callbacks = nil
         @open = false
       end
 
@@ -156,6 +162,12 @@ module Lowdown
       # @return [void]
       #
       def flush
+        caller_thread = Thread.current
+        @callbacks.enqueue do
+          sleep 0.1
+          caller_thread.run
+        end
+        Thread.stop
       end
 
       # @return (see Lowdown::Connection#open?)

data/lib/lowdown/threading.rb

@@ -4,6 +4,132 @@ module Lowdown
   # A collection of internal threading related helpers.
   #
   module Threading
+    # This class performs jobs on a private thread, provides lifecycle callbacks, and sends exceptions onto its parent
+    # thread.
+    #
+    class Consumer
+      # @param  [Thread::Queue] queue
+      #         a queue instance. Provide a `Thread::SizedQueue` if you want queue of a max size.
+      #
+      # @param  [Thread] parent_thread
+      #         the thread to send exceptions to.
+      #
+      def initialize(queue: Thread::Queue.new, parent_thread: Thread.current)
+        @queue, @parent_thread = queue, parent_thread
+        @thread = Thread.new(&method(:main))
+      end
+
+      # Schedules a job to be performed.
+      #
+      # @return [void]
+      #
+      def enqueue(&job)
+        queue << job
+      end
+
+      # Kills the private thread.
+      #
+      # @return [void]
+      #
+      def kill
+        thread.kill
+      end
+
+      # @return [Boolean]
+      #         whether or not the private thread is still alive.
+      #
+      def alive?
+        thread.alive?
+      end
+
+      # @return [Boolean]
+      #         whether or not there are any scheduled jobs left in the queue.
+      #
+      def empty?
+        queue.empty?
+      end
+
+      protected
+
+      # @return [Thread]
+      #         the private thread.
+      #
+      attr_reader :thread
+
+      # @return [Thread]
+      #         the thread to send exceptions to.
+      #
+      attr_reader :parent_thread
+
+      # @return [Thread::Queue]
+      #         the jobs queue.
+      #
+      attr_reader :queue
+
+      # This represents the full lifecycle of the consumer thread. It performs the individual events, catches uncaught
+      # exceptions and sends those to the parent thread, and performs cleanup.
+      #
+      # Subclasses should override the individual events.
+      #
+      # @note This method is ran on the private thread.
+      #
+      # @return [void]
+      #
+      def main
+        pre_runloop
+        runloop
+      rescue Exception => exception
+        parent_thread.raise(exception)
+      ensure
+        post_runloop
+      end
+
+      # Ran _before_ any jobs are performed.
+      #
+      # @note (see #main)
+      #
+      # @return [void]
+      #
+      def pre_runloop
+      end
+
+      # The loop that performs scheduled jobs.
+      #
+      # @note (see #main)
+      #
+      # @return [void]
+      #
+      def runloop
+        loop { perform_job(non_block: false) }
+      end
+
+      # Ran when the thread is killed or an uncaught exception occurred.
+      #
+      # This kills the consumer thread, which means that any cleanup you need to perform should be done *before* calling
+      # this `super` implementation.
+      #
+      # @note (see #main)
+      #
+      # @return [void]
+      #
+      def post_runloop
+        thread.kill
+      end
+
+      # @param  [Boolean] non_block
+      #         whether or not the thread should be halted if there are no jobs to perform.
+      #
+      # @param  [Array<Object>] arguments
+      #         arguments that should be passed to the invoked job.
+      #
+      # @return [void]
+      #
+      def perform_job(non_block:, arguments: nil)
+        queue.pop(non_block).call(*arguments)
+      rescue ThreadError
+      end
+    end
+
     # A simple thread-safe counter.
     #
     class Counter

data/lib/lowdown/version.rb

@@ -1,3 +1,3 @@
 module Lowdown
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lowdown
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Eloy Durán
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-17 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A Ruby client for the HTTP/2 version of the Apple Push Notification Service.