rack-downtime 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdd5cb910c23cd91f064883334d4e56c25124deb
+  data.tar.gz: 106113c2a731759876a1aadc4c5aa9b031149862
+SHA512:
+  metadata.gz: 2bd6d11b99494837a1b4f857a9894a4f38a9c839182ca78f41c3eae7ac1c62cad46275a97418a4a5f7d82b43a282b23915f7dba5da3f3ec8560dbad674c45045
+  data.tar.gz: cc874fd53780e82e4ec467f364aa2fa08b964a6af6370a9882301bfcc9aa123a7992a0ba0ec6003f705e05f7464d84c1d475596b336059518bec0787e7d0dcf4

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - 2.0
+  - 2.1
+
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 sshaw
+
+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,190 @@
+# Rack::Downtime
+
+Planned downtime management for Rack applications
+
+[![Build Status](https://travis-ci.org/sshaw/rack-downtime.svg?branch=master)](https://travis-ci.org/sshaw/rack-dowmtime)
+[![Code Climate](https://codeclimate.com/github/sshaw/rack-downtime/badges/gpa.svg)](https://codeclimate.com/github/sshaw/rack-downtime)
+
+## Overview
+
+`Rack::Dowtime` **does not** add a maintenance page -there are *plenty* of ways to do this already. Instead,
+it provides one with a variety of simple ways to trigger and takedown planned maintenance notifications while a site
+**is still up**.
+
+### Examples
+
+```ruby
+require "rack/downtime"
+
+use Rack::Downtime
+```
+
+In your layout:
+
+```erb
+<% if ENV.include?("rack.downtime") %>
+  <div>
+    <p>
+      We will be down for maintenance on
+	  <%= ENV["rack.downtime"][0].strftime("%b %e") %> from
+	  <%= ENV["rack.downtime"][0].strftime("%l:%M %p") %> to
+	  <%= ENV["rack.downtime"][1].strftime("%l:%M %p") %> EST.
+	</p>
+  </div>
+<% end %>
+```
+
+Now set the downtime using the `:file` strategy:
+
+```
+# 1 to 4 AM
+> echo '2014-11-15T01:00/2014-11-15T04:00' > downtime.txt
+```
+
+If you prefer, `Rack::Downtime` can insert the message for you:
+
+```ruby
+# Inserts a downtime message
+use Rack::Downtime, :insert => "my_template.erb"
+
+# Specify where to insert message
+use Rack::Downtime, :insert => "my_template.erb", :insert_at => "body #container"
+```
+
+The downtime can be set various ways:
+
+```ruby
+# From the HTTP header X-Downtime
+use Rack::Downtime, :strategy => :header
+use Rack::Downtime, :strategy => { :header => "X-MyHeader" }
+
+# Or from the query string
+use Rack::Downtime, :strategy => :query
+use Rack::Downtime, :strategy => { :query => "dwn__" }
+```
+
+Alternate configuration:
+
+```ruby
+Rack::Downtime.strategy = :file
+Rack::Downtime::Strategy::File.path = Rails.root.join("downtime.txt")
+```
+
+Control its behavior via environment variables:
+
+```
+SetEnv RACK_DOWNTIME 2014-11-15T01:00:00-05/2014-11-15T04:00:00-05
+
+# Disable
+SetEnv RACK_DOWNTIME_DISABLE 1
+
+# Or, just turn of insertion
+SetEnv RACK_DOWNTIME_INSERT  0
+```
+
+## Usage
+
+Downtime can be retrieved from various locations via a [downtime strategy](#downtime-strategies). When downtime is detected,
+it's turned into 2 instances of `DateTime` and added to the Rack environment at `rack.downtime`. The 0th
+element is the start time and the 1st element is the end time.
+
+The dates must be given as an [ISO 8601 time interval](https://en.wikipedia.org/wiki/ISO_8601#Time_intervals)
+in `start/end` format. If no dates are found `rack.downtime` will not be set.
+
+Downtime messages can also be added to the response's body. See *[Inserting a Downtime Message](#inserting-a-downtime-message)*.
+
+### Downtime Strategies
+
+Strategies are given via the `:strategy` option. If none is provided then `Rack::Downtime.strategy`
+is used, which defaults to `:file`.
+
+#### `:file`
+
+Looks in the current directory for a file named `downtime.txt`. 
+
+```ruby
+use Rack::Downtime :strategy => :file
+```
+
+To use a file named `my_file.txt`:
+
+```ruby
+use Rack::Downtime :strategy => { :file => "my_file.txt" }
+```
+
+#### `:query`
+
+Looks for a query string parameter named `__dt__`.
+
+```ruby
+use Rack::Downtime :strategy => :query
+```
+
+To use a query string named `q`:
+
+```ruby
+use Rack::Downtime :strategy => { :query => "q" }
+```
+
+#### `:header`
+
+Looks for an HTTP header named `X-Downtime`.
+
+```ruby
+use Rack::Downtime :strategy => :header
+```
+To look for a header named `X-DT-4SHO`:
+
+```ruby
+use Rack::Downtime :strategy => { :header => "X-DT-4SHO" }
+```
+
+Internally the header will be converted to match
+[what rack generates](http://www.rubydoc.info/github/rack/rack/master/file/SPEC#The_Environment), e.g., `HTTP_*`.
+
+#### `:env`
+
+Looks for an environment variable named `RACK_DOWNTIME`.
+
+#### `:cookie`
+
+Looks for cookie named `__dt__`.
+
+```ruby
+use Rack::Downtime :strategy => :cookie
+```
+To use a cookie named `oreo`:
+
+```ruby
+use Rack::Downtime :strategy => { :cookie => "oreo" }
+```
+
+#### Custom
+
+Just pass in something that responds to `:call`, accepts a rack environment, and returns a [downtime array](#usage).
+
+```ruby
+use Rack::Downtime :strategy => ->(env) { YourDownTimeConfig.find_dowmtime }
+```
+
+### Inserting a Downtime Message
+
+A message can be inserted by `Rack::Downtime` into your response's body whenever downtime is scheduled.
+Just provide a path to an ERB template to the `:insert` option. The downtime will be passed to the template
+as `start_time` and `end_time`.
+
+By default the template will be inserted after the `body` tag. This can be changed by providing the
+desired location to the `:insert_at` option. The location can be given as a CSS selector or an XPath location.
+
+Messages are only inserted into HTML responses with a `200` status code.
+
+**Note that when `Rack::Downtime` inserts a message it will turn a streaming response into a buffered one**.
+If this is a problem you can always check for and insert the downtime yourself in your application.
+
+## TODO
+
+Don't invalidate XHTML responses when inserting a downtime message.
+
+## Author
+
+Skye Shaw [sshaw AT gmail.com]

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => "spec"
+

data/lib/rack/downtime.rb

@@ -0,0 +1,148 @@
+require "rack/utils"
+require "erb"
+require "nokogiri"
+
+require "rack/downtime/strategy"
+require "rack/downtime/version"
+
+module Rack
+  ##
+  # For the full documentation see README.md
+
+  class Downtime
+
+    DOWNTIME_DISABLE = "RACK_DOWNTIME_DISABLE".freeze
+    DOWNTIME_INSERT = "RACK_DOWNTIME_INSERT".freeze
+
+    ENV_KEY = "rack.downtime".freeze
+    DEFAULT_INSERT_AT = "html body".freeze
+
+    # Newer versions of Rack should have these
+    CONTENT_TYPE = "Content-Type".freeze
+    CONTENT_LENGTH = "Content-Length".freeze
+
+    class << self
+      attr_writer :strategy
+
+      ##
+      # Set the default downtime strategy
+      def strategy
+        @strategy ||= :file
+      end
+    end
+
+    ##
+    # Create an instance of the Rack middleware to manage downtime notifications
+    #
+    # === Arguments
+    #
+    # [options (Hash)] downtime detection and insertion options; optional
+    #
+    # === Options
+    #
+    # [:strategy (Symbol|Hash)] Set the downtime detection strategy; defaults to Rack::Downtime::strategy. If a +Hash+ its first value is passed as an argument to the strategy class.
+    # [:insert (String)] Path to an ERB template to insert when downtime is planned. Downtimes are given to the template as +start_time+ and +end_time+.
+    # [:insert_at (String)] Where to insert the ERB template given by +:insert+. Can be given as a CSS selector or an XPath location.
+    #
+    # === Errors
+    #
+    # [ArgumentError] If the strategy is unknown
+
+    def initialize(app, options = {})
+      @app = app
+
+      @strategy = options[:strategy] || self.class.strategy
+      @strategy = load_strategy(@strategy) unless @strategy.respond_to?(:call)
+
+      @insert = options[:insert]
+      @insert = load_template(@insert) if @insert
+
+      @insert_at = options[:insert_at] || DEFAULT_INSERT_AT
+    end
+
+    def call(env)
+      return @app.call(env) if env[DOWNTIME_DISABLE] == "1"
+
+      downtime = get_downtime(env)
+      env[ENV_KEY] = downtime if downtime
+
+      response = @app.call(env)
+      return response unless downtime && insert_downtime?(env, response)
+
+      old_body = response[2]
+      new_body = insert_downtime(old_body, downtime)
+
+      old_body.close if old_body.respond_to?(:close)
+      response[1][CONTENT_LENGTH] = Rack::Utils.bytesize(new_body).to_s
+      response[2] = [new_body]
+
+      response
+    end
+
+    private
+
+    def load_strategy(options)
+      config = nil
+      strategy = options
+      strategy, config = strategy.first if strategy.is_a?(Hash)
+
+      case strategy
+      when :cookie
+        Strategy::Cookie.new(config)
+      when :env, :environment
+        Strategy::Env.new(config)
+      when :file
+        Strategy::File.new(config)
+      when :header
+        Strategy::Header.new(config)
+      when :query
+        Strategy::Query.new(config)
+      else
+        raise ArgumentError, "unknown strategy: #{strategy}"
+      end
+    end
+
+    def load_template(template)
+      Class.new do
+        include ERB.new(::File.read(template), nil, "<>%-").def_module("render(start_time, end_time)")
+      end.new
+    end
+
+    def get_downtime(env)
+      @strategy.call(env)
+    rescue => e
+      message = "Rack::Downtime failed: #{e}"
+
+      if env["rack.logger"].respond_to?(:error)
+        env["rack.logger"].error(message)
+      else
+        env["rack.errors"].puts(message)
+      end
+
+      nil
+    end
+
+    def insert_downtime?(env, response)
+      @insert && env[DOWNTIME_INSERT] != "0" && response[0] == 200 && response[1][CONTENT_TYPE] =~ /html/
+    end
+
+    def insert_downtime(old_body, times)
+      new_body = ""
+      old_body.each { |line| new_body << line }
+
+      doc = Nokogiri::HTML(new_body)
+      e = doc.at(@insert_at)
+      return new_body unless e
+
+      message = @insert.render(*times)
+
+      if e.child
+        e.child.before(message)
+      else
+        e.add_child(message)
+      end
+
+      doc.to_html
+    end
+  end
+end

data/lib/rack/downtime/strategy.rb

@@ -0,0 +1,111 @@
+require "rack/request"
+require "rack/utils"
+require "rack/downtime/utils"
+
+class Rack::Downtime
+  module Strategy
+    class Cookie
+      include Rack::Utils
+
+      class << self
+        attr_writer :named
+
+        def named
+          @named ||= "__dt__"
+        end
+      end
+
+      def initialize(named = nil)
+        @named = named || self.class.named
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        Rack::Downtime::Utils.parse_downtime(req.cookies[@named])
+        #delete_cookie_header!(env, @named) if downtime
+        #downtime
+      end
+    end
+
+    class Env
+      class << self
+        attr_writer :named
+
+        def named
+          @named ||= "RACK_DOWNTIME"
+        end
+      end
+
+      def initialize(named = nil)
+        @named = named || self.class.named
+      end
+
+      def call(env)
+        Rack::Downtime::Utils.parse_downtime(env[@named])
+      end
+    end
+
+    class Header < Env
+      def self.named
+        @named ||= "X-Downtime"
+      end
+
+      def initialize(named = nil)
+        @named = (named || self.class.named).upcase.tr!("-", "_")
+        @named.prepend "HTTP_" unless @named.start_with?("HTTP_")
+      end
+    end
+
+    class Query
+      class << self
+        attr_writer :param
+
+        def param
+          @param ||= "__dt__"
+        end
+      end
+
+      def initialize(param = nil)
+        @param = param || self.class.param
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        Rack::Downtime::Utils.parse_downtime(req[@param])
+      end
+    end
+
+    class File
+      class << self
+        attr_writer :path
+
+        def path
+          @path ||= "downtime.txt"
+        end
+      end
+
+      def initialize(path = nil)
+        @path  = path || self.class.path
+        @mtime = 0
+      end
+
+      def call(env)
+        return unless ::File.exists?(@path)
+
+        new_mtime = ::File.mtime(@path).to_i
+        if new_mtime > @mtime
+          @downtime = parse_downtime(@path)
+          @mtime = new_mtime
+        end
+
+        @downtime
+      end
+
+      private
+
+      def parse_downtime(path)
+        Rack::Downtime::Utils.parse_downtime(::File.read(path))
+      end
+    end
+  end
+end

data/lib/rack/downtime/utils.rb

@@ -0,0 +1,14 @@
+require "date"
+
+class Rack::Downtime
+  module Utils
+    def parse_downtime(data)
+      return unless data
+
+      downtime = data.split("/", 2).map { |date| DateTime.iso8601(date) }
+      downtime.empty? ? nil : downtime
+    end
+
+    module_function :parse_downtime
+  end
+end

data/lib/rack/downtime/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Downtime  
+    VERSION = "0.0.1".freeze
+  end
+end

data/rack-downtime.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/downtime/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-downtime"
+  spec.version       = Rack::Downtime::VERSION
+  spec.authors       = ["Skye Shaw"]
+  spec.email         = ["skye.shaw@gmail.com"]
+  spec.summary       = %q{Planned downtime management for Rack applications}
+  spec.description   =<<DOC
+Rack::Downtime provides a variety of ways to easily trigger and display planned maintenance notifications to users
+while a site is still up. Various strategies are provided that will work with sites of all sizes.
+DOC
+
+  spec.homepage      = "https://github.com/sshaw/rack-downtime"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "rack", "~> 1"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/downtime_spec.rb

@@ -0,0 +1,244 @@
+require "spec_helper"
+require "fileutils"
+
+describe Rack::Downtime do
+
+  before do
+    @tmp = Dir.mktmpdir
+    Dir.chdir(@tmp)
+
+    @dates = [ DateTime.new(2014,11,11,0,0), DateTime.new(2014,11,11,2,0) ]
+    @downtime = time_interval(@dates)
+    File.write("downtime.txt", @downtime)
+  end
+
+  after { FileUtils.rm_rf(@tmp) }
+
+  it "sets the environment's rack.downtime to the downtime" do
+    set_dates = nil
+    app = new_app { |env| set_dates = env["rack.downtime"] }
+    req = Rack::Test::Session.new(described_class.new(app))
+    req.get "/"
+
+    expect(set_dates).to eq @dates
+  end
+
+  # context "when no downtime has been specified" do
+  #   it "does not insert the alert"
+  #   it "does not assign any dates to rack.downtime"
+  # end
+
+  context "given a downtime message template" do
+    before do
+      @template = File.join(@tmp, "alert.erb")
+      File.write(@template, "__HERE__")
+    end
+
+    #it "sets the environment's rack.downtime to the downtime"
+
+    context "with a non-200 response" do
+      it "does not insert the template" do
+        app = new_app(:code => 302)
+
+        req = Rack::Test::Session.new(described_class.new(app, :insert => @template))
+        req.get "/"
+
+        expect(req.last_response.body).to_not match("__HERE__")
+      end
+    end
+
+    context "with a non-HTML content type" do
+      it "does not insert the template" do
+        app = new_app(:headers => {"Content-Type" => "text/plain"})
+
+        req = Rack::Test::Session.new(described_class.new(app, :insert => @template))
+        req.get "/"
+
+        expect(req.last_response.body).to_not match("__HERE__")
+      end
+    end
+
+    context "when RACK_DOWNTIME_INSERT = 0" do
+      it "does not insert the template" do
+        req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template))
+        req.get "/", nil, "RACK_DOWNTIME_INSERT" => "0"
+
+        expect(req.last_response.body).to_not match("__HERE__")
+      end
+
+      #it "sets the environment's rack.downtime to the downtime"
+    end
+
+    context "when RACK_DOWNTIME_DISABLE = 1" do
+      it "does not insert the template" do
+        req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template))
+        req.get "/", nil, "RACK_DOWNTIME_DISABLE" => "1"
+
+        expect(req.last_response.body).to_not match("__HERE__")
+      end
+
+      it "does not set rack.downtime" do
+        set_dates = nil
+        app = new_app { |env| set_dates = env["rack.downtime"] }
+
+        req = Rack::Test::Session.new(described_class.new(new_app))
+        req.get "/", nil, "RACK_DOWNTIME_DISABLE" => "1"
+
+        expect(set_dates).to be_nil
+      end
+    end
+
+    it "inserts the template into the response" do
+      req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template))
+      req.get "/"
+
+      expect(req.last_response.body).to eq_html "<!doctype html><html><body>__HERE__<p>Content!</p></body></html>"
+    end
+
+    it "passes downtime times to the template" do
+      File.write(@template, "<%= start_time.hour %>/<%= end_time.hour %>")
+
+      req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template))
+      req.get "/"
+
+      expect(req.last_response.body).to eq_html "<!doctype html><html><body>0/2<p>Content!</p></body></html>"
+    end
+
+    describe "the :insert_at option" do
+      [["CSS", "body p"], ["xpath", "//body/p"]].each do |format, location|
+        it "inserts the template at the given #{format} location" do
+          req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template, :insert_at => location))
+          req.get "/"
+
+          expect(req.last_response.body).to match("<body><p>__HERE__Content!</p>")
+        end
+      end
+
+      context "given an invalid location" do
+        it "does not insert the template into response" do
+          req = Rack::Test::Session.new(described_class.new(new_app, :insert => @template, :insert_at => "div span a"))
+          req.get "/"
+
+          expect(req.last_response.body).to_not match("__HERE__")
+        end
+      end
+    end
+  end
+
+  describe "strategies" do
+    before do
+      @app = lambda { |env|
+        body = env["rack.downtime"].map { |t| t.strftime("%s") }.join("/")
+        headers = {"Content-Type" => "text/plain"}
+        headers["Content-Length"] = body.size
+
+        [ 200, headers, [body] ]
+      }
+      @body = @dates.map { |d| d.strftime("%s") }.join("/")
+    end
+
+    it "raises an ArgumentError when the strategy is unknown" do
+      expect { described_class.new(@app, :strategy => :g_code) }.to raise_error(ArgumentError, /unknown/)
+    end
+
+    describe ":cookie" do
+      before { @downtime = Rack::Utils.escape(@downtime) }
+
+      it "sets the downtime from the default cookie name" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => :cookie))
+        req.set_cookie "__dt__=#@downtime"
+        req.get "/"
+
+        expect(req.last_response.body).to eq(@body)
+      end
+
+      it "sets the downtime from the given cookie name" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => { :cookie => "QWERTY" }))
+        req.set_cookie "QWERTY=#@downtime"
+        req.get "/"
+
+        expect(req.last_response.body).to eq(@body)
+      end
+
+
+      # context "with a new default name" do
+      #   before { Rack::Downtime::Strategy::Cookie.named = "xxx" }
+      #   after  { Rack::Downtime::Strategy::Cookie.named = nil }
+
+
+      #     req = Rack::Test::Session.new(described_class.new(@app, :strategy => :cookie))
+      #     req.set_cookie "__dt__=#@downtime" # esc?
+      #     req.get "/"
+
+      #     expect(req.last_response.body).to eq(@body)
+      #   end
+      # end
+    end
+
+    describe ":env" do
+      it "sets the downtime from the RACK_DOWNTIME environment variable" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => :env))
+        req.get "/", nil, "RACK_DOWNTIME" => @downtime
+
+        expect(req.last_response.body).to eq(@body)
+      end
+    end
+
+    describe ":header" do
+      it "sets the downtime from the X-Downtime HTTP header" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => :header))
+        req.header "X-Downtime", @downtime
+        req.get "/"
+
+        expect(req.last_response.body).to eq(@body)
+      end
+    end
+
+    describe ":query" do
+      it "sets the downtime from the default query string param" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => :query))
+        req.get "/", :__dt__ => @downtime
+
+        expect(req.last_response.body).to eq(@body)
+      end
+
+      it "sets the downtime from the given query string param" do
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => { :query => "param" }))
+        req.get "/", :param => @downtime
+
+        expect(req.last_response.body).to eq(@body)
+      end
+    end
+
+    describe ":file" do
+      it "sets the downtime from the given downtime file" do
+        path = File.join(@tmp, "im_goin_dooooown.txt")
+        File.write(path, @downtime)
+
+        req = Rack::Test::Session.new(described_class.new(@app, :strategy => { :file => path }))
+        req.get "/"
+
+        expect(req.last_response.body).to eq(@body)
+      end
+
+      describe "when the downtime is updated" do
+        it "detects the new downtime" do
+          req = Rack::Test::Session.new(described_class.new(@app, :strategy => { :file => "downtime.txt" }))
+          req.get "/"
+
+          @dates[1] = DateTime.new(2014,12,31)
+          new_body = @dates.map { |d| d.strftime("%s") }.join("/")
+          new_downtime = time_interval(@dates)
+
+          # So we have a different mtime
+          sleep 1
+          File.write("downtime.txt", new_downtime)
+
+          req.get "/"
+
+          expect(req.last_response.body).to eq(new_body)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require "rspec"
+require "nokogiri"
+require "rack/test"
+require "rack/downtime"
+
+RSpec.configure do |c|
+  c.include Module.new {
+    def time_interval(times)
+      times.map { |d| d.strftime("%FT%X%Z") }.join("/")
+    end
+      
+    def new_app(response = {})  
+      code    = response[:code]    || 200
+      headers = response[:headers] || {}
+      body    = response[:body]    || "<!DOCTYPE html><html><body><p>Content!</p></body></html>"
+
+      headers["Content-Length"]||= body.size
+      headers["Content-Type"]  ||= "text/html"
+      
+      ->(env) do
+        yield env if block_given?
+
+        [code, headers, [body]]
+      end
+    end
+  }
+end
+
+# Poor man's TestXml
+RSpec::Matchers.define :eq_html do |expect|  
+  match do |actual|
+    Nokogiri::HTML(expect).to_html == Nokogiri::HTML(actual).to_html
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: rack-downtime
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Skye Shaw
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Rack::Downtime provides a variety of ways to easily trigger and display planned maintenance notifications to users
+  while a site is still up. Various strategies are provided that will work with sites of all sizes.
+email:
+- skye.shaw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rack/downtime.rb
+- lib/rack/downtime/strategy.rb
+- lib/rack/downtime/utils.rb
+- lib/rack/downtime/version.rb
+- rack-downtime.gemspec
+- spec/downtime_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sshaw/rack-downtime
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Planned downtime management for Rack applications
+test_files:
+- spec/downtime_spec.rb
+- spec/spec_helper.rb