rack-hard-copy 0.0.3

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+gem 'rack'
+gem 'mime-types'
+
+group :development do
+  gem 'rake'
+  gem 'pry'
+end
+

data/README.md

@@ -0,0 +1,106 @@
+# Rack::Hard::Copy
+
+This is a simple middleware to save and load static copies of
+rendered pages. So in other words, this is simple static cache
+which saves in a format that can be used as a backup, or to be
+loaded via a simple http server (e.g. Nginx).
+
+### Installation
+
+    echo "gem 'rack-static-copy'" >> Gemfile
+    bundle
+
+### Usage - Basic
+
+    # config.ru
+    require 'rack/hard/copy'
+    use Rack::Hard::Copy, :store   => "/tmp/hard_copy",
+                          :ignores => [ "search", "js", "png", "gif" ],
+                          :timeout => 600
+
+    run App
+
+
+> Note: This should probably be the last middleware loaded.
+
+#### Options
+
+* `:store`   - path to file store
+* `:ignores` - `Array` of keywords to be ignored
+* `:timeout` - `Fixnum` as seconds to expire stored files
+* `:headers` - `Boolean` can be set to `true` to insert custom http headers
+  * `X-Rack-Hard-Save => (true|false)`
+  * `X-Rack-Hard-Load => (true|false)`
+
+### Another Use
+
+Additionally, you can use Rack::Hard::Save alone to simple create a copy
+of your pages in rendered html format (other formats are supported).
+
+Exmaple:
+
+    # config.ru
+    require 'rack/hard/save'
+    use Rack::Hard::Save, :store   => "/path/to/nginx/root/static",
+                          :ignores => [ "search", "js", "png", "gif" ],
+                          :timeout => 600
+
+    run App
+
+
+From there you can use Nginx to first check and see if the static pages exist
+and if not, load your app normally, which will in turn generate the static
+content.
+
+Very large speed enhancments should be see doing this.
+
+
+##### Nginx example config:
+
+    # /etc/nginx/sites-enabled/my_site.conf
+    server {
+        #listen   80; ## listen for ipv4; this line is default and implied
+        #listen   [::]:80 default ipv6only=on; ## listen for ipv6
+
+        root /path/to/nginx/root;
+
+        server_name localhost;
+
+        location / {
+            try_files /static$uri/index.html /static$uri $uri @app;
+        }
+
+        location @app {
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header Host $http_host;
+            proxy_pass http://0.0.0.0:8080;
+        }
+    }
+
+The key to above lies in `/static$uri/index.html` and `/static$uri`.
+
+Rack::Hard::Copy turns `/foo` in to `/foo/index.html`, while simply
+copying anything with an extension. The above `try_files` will look
+for this pattner in your choosen root and store location.
+
+### Load
+
+You can also load static files, on your own. This might be good for
+pregenerating large sitemaps, error pages, etc. Why? Well, it might
+be nice to dynamically generate a page, sitemaps in particular, but
+store them staticly to reduce load on your host when they're rather
+large.
+
+    # config.ru
+    require 'rack/hard/load'
+    use Rack::Hard::Load, :store   => "./hard_copy",
+                          :timeout => false
+
+
+Pregeneration examples:
+
+    $ curl http://yoursite.com/sitemap.xml > ./hard_copy/sitemap.xml
+    $ curl http://yoursite.com/main.css > ./hard_copy/main.css
+
+> These could be automated as part of your startup.
+

data/lib/rack/hard/copy.rb

@@ -0,0 +1,37 @@
+require ::File.join(::File.dirname(__FILE__), "util")
+require ::File.join(::File.dirname(__FILE__), "save")
+require ::File.join(::File.dirname(__FILE__), "load")
+module Rack
+  class Hard
+    class Copy
+      include Util
+      autoload :VERSION, ::File.join(::File.dirname(__FILE__), "version")
+      def initialize(app, opts={})
+        @app             = app
+        opts[:store]   ||= "./static"
+        opts[:ignores] ||= []
+        opts[:headers] ||= false
+        opts[:timeout] ||= 600
+        @options         = opts
+
+        make_dir(@options[:store])
+      end
+
+      def call(env)
+        return @app.call(env) if     ignored?(@options[:ignores], env["PATH_INFO"].to_s)
+        return @app.call(env) unless env["REQUEST_METHOD"] == "GET"
+
+        logger = env['rack.logger']||nil
+        path   = generate_path_from(@options[:store], env['PATH_INFO'].to_s)
+
+        if @options[:timeout] === false || expired?(@options[:timeout], path)
+          logger.warn "Rack::Hard::Copy: Warning, Copy without timeout is just a Save." if @options[:timeout] === false
+          return Rack::Hard::Save.new(@app, @options).call(env)
+        else
+          return Rack::Hard::Load.new(@app, @options).call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/hard/load.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "util")
+module Rack
+  class Hard
+    class Load
+      include Util
+      def initialize(app, opts={})
+        @app     = app
+        setup_variables(opts)
+      end
+
+      def call(env)
+        return @app.call(env) if     ignored?(@ignores, env["PATH_INFO"].to_s)
+        return @app.call(env) unless env["REQUEST_METHOD"] == "GET"
+
+        logger    = env['rack.logger']||nil
+        path      = generate_path_from(@store, env['PATH_INFO'].to_s)
+
+        if ::File.exists?(path) && !ignored?(@ignores, path) && (@timeout === false || !expired?(@timeout, path))
+          logger.info "Rack::Hard::Load loading: #{path}" rescue nil
+          begin
+            status = 200
+            headers = http_headers(env)
+            headers['X-Rack-Hard-Load'] = 'true' if @headers
+            response = [ ::File.read(path) ]
+          rescue => e
+            logger.error "Rack::Hard::Load error creating: #{path}\n#{e}\n#{e.backtrace.join("\n")}" rescue nil
+            status, headers, response = @app.call(env)
+            headers['X-Rack-Hard-Load'] = "error" if @headers
+          end
+        else
+          logger.info "Rack::Hard::Load passing" rescue nil
+          status, headers, response = @app.call(env)
+          headers['X-Rack-Hard-Load'] = "false" if @headers
+        end
+        return Rack::Response.new(response, status, headers)
+      end
+    end
+  end
+end
+

data/lib/rack/hard/save.rb

@@ -0,0 +1,46 @@
+require ::File.join(::File.dirname(__FILE__), "util")
+module Rack
+  class Hard
+    class Save
+      include Util
+      def initialize(app, opts={})
+        @app     = app
+        setup_variables(opts)
+      end
+
+      def call(env)
+        return @app.call(env) if     ignored?(@ignores, env["PATH_INFO"].to_s)
+        return @app.call(env) unless env["REQUEST_METHOD"] == "GET"
+
+        logger    = env['rack.logger']||nil
+        path      = generate_path_from(@store, env['PATH_INFO'].to_s)
+
+        status, headers, response  = @app.call(env)
+
+        if (@timeout === false || expired?(@timeout, path)) && !ignored?(@ignores, path) && status == 200
+          begin
+            make_dir(::File.dirname(path))
+            create(path, response.first)
+            headers['X-Rack-Hard-Save'] = 'true' if @headers
+            logger.info "Rack::Hard::Save creating: #{path}" rescue nil
+          rescue => e
+            headers['X-Rack-Hard-Save'] = 'error' if @headers
+            logger.error "Rack::Hard::Save error creating: #{path}\n#{e}\n#{e.backtrace.join("\n")}" rescue nil
+          end
+        end
+
+        headers['X-Rack-Hard-Save'] ||= 'false' if @headers
+
+        return Rack::Response.new(response, status, headers)
+      end
+
+      private
+      def create(f, body)
+        ::File.open(f, ::File::WRONLY|::File::TRUNC|::File::CREAT, 0664) do |file|
+          file.flock(::File::LOCK_EX)
+          file.write(body)
+        end
+      end
+    end
+  end
+end

data/lib/rack/hard/util.rb

@@ -0,0 +1,46 @@
+require 'fileutils'
+require 'mime/types'
+
+module Rack
+  class Hard
+    module Util
+      def setup_variables(opts={})
+        @store   ||= opts[:store]   || "./static"
+        @ignores ||= opts[:ignores] || []
+        @headers ||= opts[:headers] || false
+        @timeout ||= opts[:timeout] || false
+        make_dir(@store)
+      end
+
+      def ignored?(ignores, path)
+        ignores.each { |ignore| return true if path.end_with?(ignore) } unless ignores.empty?
+        return false
+      end
+
+      def generate_path_from store, path_info
+        path = ::File.join(store, path_info)
+        return ( MIME::Types.type_for("try."+path.split("/").last.split(".").last).empty? ? path.gsub(/\/$/, '')+"/index.html" : path )
+      end
+
+      def http_headers env
+        http_headers = {}
+        env.select { |k,v| k.start_with?("HTTP_") }.each do |k,v|
+          http_headers[k.gsub(/^HTTP_/, '')] = v
+        end
+        http_headers
+      end
+
+      def expired? timeout, path
+        return false if timeout === false
+        return true  if timeout === true
+        return true  unless ::File.exists?(path)
+        (::File.mtime(path)+timeout) < Time.now
+      end
+
+      def make_dir path
+        FileUtils.mkdir_p(path) unless ::File.directory?(path)
+      end
+    end
+  end
+end
+

data/lib/rack/hard/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Hard::Copy
+    VERSION = "0.0.3"
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rack-hard-copy
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Joshua Mervine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.22'
+description: Rack Middle to creating static copies of rendered endpoints and reload
+  them. It equates to a static file cache with other possible uses. See rubyops.net/gems/rack-hard-copy
+  for details.
+email:
+- joshua@mervine.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/hard/save.rb
+- lib/rack/hard/copy.rb
+- lib/rack/hard/util.rb
+- lib/rack/hard/version.rb
+- lib/rack/hard/load.rb
+- README.md
+- Gemfile
+homepage: http://www.rubyops.net/gems/rack-hard-copy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Rack Middle to creating static copies of rendered endpoints and reload them.
+test_files: []