rack-nackmode 0.1.0 → 0.1.1

data/README.markdown

@@ -60,4 +60,27 @@ The `use` statement to initialise the middleware takes the following options:
    balancer it's going down before it can safely do so.  Defaults to 3, which
    matches e.g. haproxy's default for how many failed checks it needs before
    marking a backend as down.
+ * `:healthcheck_timeout` – how long (in seconds) the app should wait for
+   the first health check request.  This is to avoid the app refusing to shut
+   down if the load balancer is misconfigured (or absent); if it waits this
+   long without seeing a single health check, it will simply shut down.  Should
+   be significantly longer than your load balancer's health check interval.
+   Defaults to 15 seconds, which is conservatively longer than
+   haproxy's default interval.
  * `:logger` – middleware will log progress to this object if supplied.
+
+## Testing
+
+The RSpec specs cover most of the functionality:
+
+    $ bundle exec rspec
+
+### Integration testing
+
+To really verify this works, we need to set up two instances of an app using
+this middleware behind a load balancer, and fire requests at the load balancer
+while taking down one of the instances.
+
+    $ bundle exec kitchen test
+
+You'll need [Vagrant](http://www.vagrantup.com/) installed.

data/lib/rack/nack_mode.rb

@@ -38,6 +38,11 @@ module Rack
     # marking a backend as down.
     DEFAULT_NACKS_BEFORE_SHUTDOWN = 3
 
+    # Default time (in seconds) during shutdown to wait for the first
+    # healthcheck request before concluding that the healthcheck is missing or
+    # misconfigured, and shutting down anyway.
+    DEFAULT_HEALTHCHECK_TIMEOUT = 15
+
     def initialize(app, options = {})
       @app = app
 
@@ -45,6 +50,7 @@ module Rack
                                 :healthy_if,
                                 :sick_if,
                                 :nacks_before_shutdown,
+                                :healthcheck_timeout,
                                 :logger
       @path = options[:path] || '/admin'
       @health_callback = if options[:healthy_if] && options[:sick_if]
@@ -58,6 +64,7 @@ module Rack
       end
       @nacks_before_shutdown = options[:nacks_before_shutdown] || DEFAULT_NACKS_BEFORE_SHUTDOWN
       raise ArgumentError, ":nacks_before_shutdown must be at least 1" unless @nacks_before_shutdown >= 1
+      @healthcheck_timeout = options[:healthcheck_timeout] || DEFAULT_HEALTHCHECK_TIMEOUT
       @logger = options[:logger]
 
       yield self if block_given?
@@ -65,6 +72,7 @@ module Rack
 
     def call(env)
       if health_check?(env)
+        clear_healthcheck_timeout
         health_check_response(env)
       else
         @app.call(env)
@@ -74,9 +82,26 @@ module Rack
     def shutdown(&block)
       info "Shutting down after NACKing #@nacks_before_shutdown health checks"
       @shutdown_callback = block
+
+      install_healthcheck_timeout { do_shutdown }
+
+      nil
     end
 
     private
+    def install_healthcheck_timeout
+      @healthcheck_timer = Timer.new(@healthcheck_timeout) do
+        warn "Gave up waiting for a health check after #{@healthcheck_timeout}s; bailing out."
+        yield
+      end
+    end
+
+    def clear_healthcheck_timeout
+      return unless @healthcheck_timer
+      @healthcheck_timer.cancel
+      @healthcheck_timer = nil
+    end
+
     def health_check?(env)
       env['PATH_INFO'] == @path && env['REQUEST_METHOD'] == 'GET'
     end
@@ -87,12 +112,10 @@ module Rack
         if @nacks_before_shutdown <= 0
           if defined?(EM)
             EM.next_tick do
-              info 'Shutting down'
-              @shutdown_callback.call
+              do_shutdown
             end
           else
-            info 'Shutting down'
-            @shutdown_callback.call
+            do_shutdown
           end
         else
           info "Waiting for #@nacks_before_shutdown more health checks"
@@ -109,6 +132,11 @@ module Rack
       @shutdown_callback
     end
 
+    def do_shutdown
+      info 'Shutting down'
+      @shutdown_callback.call
+    end
+
     def healthy?
       @health_callback.call
     end
@@ -125,5 +153,45 @@ module Rack
     def info(*args)
       @logger.info(*args) if @logger
     end
+
+    def warn(*args)
+      @logger.warn(*args) if @logger
+    end
+
+    module Timer
+      def self.new(timeout)
+        if defined?(EM)
+          EMTimer.new(timeout) { yield }
+        else
+          ThreadTimer.new(timeout) { yield }
+        end
+      end
+
+      class EMTimer
+        def initialize(timeout)
+          @timer = EM.add_timer(timeout) { yield }
+        end
+
+        def cancel
+          EM.cancel_timer(@timer)
+        end
+      end
+
+      class ThreadTimer
+        def initialize(timeout)
+          @thread = Thread.new do
+            waited = sleep(timeout)
+            # if we woke up early, waited < timeout
+            if waited >= timeout
+              yield
+            end
+          end
+        end
+
+        def cancel
+          @thread.run # will wake up early from sleep
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-nackmode
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-12 00:00:00.000000000 Z
+date: 2013-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -135,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.19
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Middleware for zero-downtime maintenance behind a load balancer