rack-cache 0.5 → 0.5.2

data/CHANGES

@@ -1,3 +1,18 @@
+## 0.6.0 / Unreleased
+
+  * Added support for memcached clusters and other advanced
+    configuration provided by the memcache-client and memcached
+    libraries. The "metastore" and "entitystore" options can now be
+    set to a MemCache object or Memcached object:
+
+    memcache = MemCache.new(['127.1.1.1', '127.1.1.2'], :namespace => "/foo")
+    use Rack::Cache,
+      :metastore => memcache,
+      :entitystore => memcache
+
+  * Fix "memcached://" metastore URL handling. The "memcached" variation
+    blew up, the "memcache" version was fine.
+
 ## 0.5.0 / May 2009
 
   * Added meta and entity store implementations based on the

data/Rakefile

@@ -110,13 +110,21 @@ file package('.tar.gz') => %w[dist/] + $spec.files do |f|
 end
 
 desc 'Upload gem and tar.gz distributables to rubyforge'
-task :release => [package('.gem'), package('.tar.gz')] do |t|
+task 'release:rubyforge' => [package('.gem'), package('.tar.gz')] do |t|
   sh <<-SH
     rubyforge add_release wink rack-cache #{$spec.version} #{package('.gem')} &&
     rubyforge add_file    wink rack-cache #{$spec.version} #{package('.tar.gz')}
   SH
 end
 
+desc 'Upload gem to gemcutter.org'
+task 'release:gemcutter' => [package('.gem')] do |t|
+  sh "gem push #{package('.gem')}"
+end
+
+desc 'Upload gem to gemcutter and rubyforge'
+task 'release' => ['release:gemcutter', 'release:rubyforge']
+
 # GEMSPEC ===================================================================
 
 file 'rack-cache.gemspec' => FileList['{lib,test}/**','Rakefile'] do |f|

data/doc/storage.markdown

@@ -62,10 +62,9 @@ deployments so explicit configuration is advised.
 The default metastore and entitystore values can be specified when the
 __Rack::Cache__ object is added to the Rack middleware pipeline as follows:
 
-    use Rack::Cache do
-      set :metastore, 'file:/var/cache/rack/meta'
-      set :entitystore, 'file:/var/cache/rack/body'
-    end
+    use Rack::Cache,
+      :metastore => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body'
 
 Alternatively, the `rack-cache.metastore` and `rack-cache.entitystore`
 variables may be set in the Rack environment by an upstream component.
@@ -82,8 +81,9 @@ use a specific storage implementation as well as pros and cons of each.
 
 Uses local process memory to store cached entries.
 
-    set :metastore,   'heap:/'
-    set :entitystore, 'heap:/'
+    use Rack::Cache,
+      :metastore   => 'heap:/',
+      :entitystore => 'heap:/'
 
 The heap storage backend is simple, fast, and mostly useless. All cache
 information is stored in each backend application's local process memory (using
@@ -102,8 +102,9 @@ is small and well understood.
 
 Stores cached entries on the filesystem.
 
-    set :metastore,   'file:/var/cache/rack/meta'
-    set :entitystore, 'file:/var/cache/rack/body'
+    use Rack::Cache,
+      :metastore   => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body'
 
 The URI may specify an absolute, relative, or home-rooted path:
 
@@ -132,18 +133,19 @@ collision.
 Stores cached entries in a remote [memcached](http://www.danga.com/memcached/)
 instance.
 
-    set :metastore,   'memcached://localhost:11211/meta'
-    set :entitystore, 'memcached://localhost:11211/body'
+    use Rack::Cache,
+      :metastore   => 'memcached://localhost:11211/meta',
+      :entitystore => 'memcached://localhost:11211/body'
 
 The URI must specify the host and port of a remote memcached daemon. The path
 portion is an optional (but recommended) namespace that is prepended to each
 cache key.
 
-The memcached storage backend requires [Evan Weaver's memcached client library][e].
-This is a [fast][f] client implementation built on the SWIG/[libmemcached][l] C
-library. The library may be installed from Gem as follows:
+The memcached storage backend requires either the `memcache-client` or
+`memcached` libraries. By default, the `memcache-client` library is used;
+require the `memcached` library explicitly to use it instead.
 
-    sudo gem install memcached --no-rdoc --no-ri
+    gem install memcache-client
 
 Memcached storage is reasonably fast and allows multiple backends to share a
 single cache. It is also the only storage implementation that allows the cache

data/lib/rack/cache/context.rb

@@ -133,8 +133,12 @@ module Rack::Cache
     # Invalidate POST, PUT, DELETE and all methods not understood by this cache
     # See RFC2616 13.10
     def invalidate
-      record :invalidate
       metastore.invalidate(@request, entitystore)
+    rescue Exception => e
+      log_error(e)
+      pass
+    else
+      record :invalidate
       pass
     end
 
@@ -147,18 +151,26 @@ module Rack::Cache
       if @request.no_cache? && allow_reload?
         record :reload
         fetch
-      elsif entry = metastore.lookup(@request, entitystore)
-        if fresh_enough?(entry)
-          record :fresh
-          entry.headers['Age'] = entry.age.to_s
-          entry
+      else
+        begin
+          entry = metastore.lookup(@request, entitystore)
+        rescue Exception => e
+          log_error(e)
+          return pass
+        end
+        if entry
+          if fresh_enough?(entry)
+            record :fresh
+            entry.headers['Age'] = entry.age.to_s
+            entry
+          else
+            record :stale
+            validate(entry)
+          end
         else
-          record :stale
-          validate(entry)
+          record :miss
+          fetch
         end
-      else
-        record :miss
-        fetch
       end
     end
 
@@ -225,9 +237,17 @@ module Rack::Cache
 
     # Write the response to the cache.
     def store(response)
-      record :store
       metastore.store(@request, response, entitystore)
       response.headers['Age'] = response.age.to_s
+    rescue Exception => e
+      log_error(e)
+      nil
+    else
+      record :store
+    end
+
+    def log_error(exception)
+      @env['rack.errors'].write("cache error: #{exception.message}\n#{exception.backtrace.join("\n")}\n")
     end
   end
 end

data/lib/rack/cache/entitystore.rb

@@ -182,19 +182,25 @@ module Rack::Cache
       end
 
       def self.resolve(uri)
-        server = "#{uri.host}:#{uri.port || '11211'}"
-        options = parse_query(uri.query)
-        options.keys.each do |key|
-          value =
-            case value = options.delete(key)
-            when 'true' ; true
-            when 'false' ; false
-            else value.to_sym
-            end
-          options[k.to_sym] = value
+        if uri.respond_to?(:scheme)
+          server = "#{uri.host}:#{uri.port || '11211'}"
+          options = parse_query(uri.query)
+          options.keys.each do |key|
+            value =
+              case value = options.delete(key)
+              when 'true' ; true
+              when 'false' ; false
+              else value.to_sym
+              end
+            options[k.to_sym] = value
+          end
+          options[:namespace] = uri.path.sub(/^\//, '')
+          new server, options
+        else
+          # if the object provided is not a URI, pass it straight through
+          # to the underlying implementation.
+          new uri
         end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
       end
     end
 

data/lib/rack/cache/metastore.rb

@@ -274,19 +274,27 @@ module Rack::Cache
       # Query parameter names and values are documented with the memcached
       # library: http://tinyurl.com/4upqnd
       def self.resolve(uri)
-        server = "#{uri.host}:#{uri.port || '11211'}"
-        options = parse_query(uri.query)
-        options.keys.each do |key|
-          value =
-            case value = options.delete(key)
-            when 'true' ; true
-            when 'false' ; false
-            else value.to_sym
-            end
-          options[k.to_sym] = value
+        if uri.respond_to?(:scheme)
+          server = "#{uri.host}:#{uri.port || '11211'}"
+          options = parse_query(uri.query)
+          options.keys.each do |key|
+            value =
+              case value = options.delete(key)
+              when 'true' ; true
+              when 'false' ; false
+              else value.to_sym
+              end
+            options[k.to_sym] = value
+          end
+
+          options[:namespace] = uri.path.to_s.sub(/^\//, '')
+
+          new server, options
+        else
+          # if the object provided is not a URI, pass it straight through
+          # to the underlying implementation.
+          new uri
         end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
       end
     end
 
@@ -359,7 +367,7 @@ module Rack::Cache
       else
         MemCache
       end
-    MEMCACHED = MemCache
+    MEMCACHED = MEMCACHE
 
     class GAEStore < MetaStore
       attr_reader :cache

data/lib/rack/cache/storage.rb

@@ -30,12 +30,25 @@ module Rack::Cache
 
   private
     def create_store(type, uri)
-      uri = URI.parse(uri) unless uri.respond_to?(:scheme)
-      if type.const_defined?(uri.scheme.upcase)
-        klass = type.const_get(uri.scheme.upcase)
-        klass.resolve(uri)
+      if uri.respond_to?(:scheme) || uri.respond_to?(:to_str)
+        uri = URI.parse(uri) unless uri.respond_to?(:scheme)
+        if type.const_defined?(uri.scheme.upcase)
+          klass = type.const_get(uri.scheme.upcase)
+          klass.resolve(uri)
+        else
+          fail "Unknown storage provider: #{uri.to_s}"
+        end
       else
-        fail "Unknown storage provider: #{uri.to_s}"
+        # hack in support for passing a MemCache or Memcached object
+        # as the storage URI.
+        case
+        when defined?(::MemCache) && uri.kind_of?(::MemCache)
+          type.const_get(:MemCache).resolve(uri)
+        when defined?(::Memcached) && uri.respond_to?(:stats)
+          type.const_get(:MemCached).resolve(uri)
+        else
+          fail "Unknown storage provider: #{uri.to_s}"
+        end
       end
     end
 

data/rack-cache.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'rack-cache'
-  s.version = '0.5'
-  s.date = '2009-05-25'
+  s.version = '0.5.2'
+  s.date = '2009-09-25'
 
   s.description = "HTTP Caching for Rack"
   s.summary     = "HTTP Caching for Rack"

data/test/context_test.rb

@@ -746,4 +746,29 @@ describe 'Rack::Cache::Context' do
       response['X-Response-Count'].should.equal '3'
     end
   end
+
+  it 'passes if there was a metastore exception' do
+    respond_with 200, 'Cache-Control' => 'max-age=10000' do |req,res|
+      res.body = ['Hello World']
+    end
+
+    get '/'
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+    cache.trace.should.include :store
+
+    get '/' do |cache|
+      cache.meta_def(:metastore) { raise Timeout::Error }
+    end
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+    cache.trace.should.include :pass
+
+    post '/' do |cache|
+      cache.meta_def(:metastore) { raise Timeout::Error }
+    end
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+    cache.trace.should.include :pass
+  end
 end

data/test/metastore_test.rb

@@ -272,7 +272,7 @@ describe 'Rack::Cache::MetaStore' do
       end
     end
   end
-  
+
   need_java 'entity store testing' do
     module Rack::Cache::AppEngine
       module MC
@@ -282,12 +282,12 @@ describe 'Rack::Cache::MetaStore' do
           def get(key); self[key]; end;
           def put(key, value, ttl = nil)
             self[key] = value
-          end  
+          end
 
         end
       end
     end
-  
+
     describe 'GAEStore' do
       it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
       before :each do
@@ -296,7 +296,7 @@ describe 'Rack::Cache::MetaStore' do
         @entity_store = Rack::Cache::EntityStore::Heap.new
       end
     end
-  
+
   end
 
 end

data/test/options_test.rb

@@ -74,5 +74,4 @@ describe 'Rack::Cache::Options' do
     @options.should.respond_to :verbose?
     @options.verbose.should.not.be.nil
   end
-
 end

data/test/spec_setup.rb

@@ -13,7 +13,7 @@ end
 
 # Set the MEMCACHED environment variable as follows to enable testing
 # of the MemCached meta and entity stores.
-ENV['MEMCACHED'] ||= 'localhost:11215'
+ENV['MEMCACHED'] ||= 'localhost:11211'
 $memcached = nil
 $memcache = nil
 
@@ -70,7 +70,6 @@ def need_memcache(forwhat)
 end
 
 def need_java(forwhat)
-  
   if RUBY_PLATFORM =~ /java/
     yield
   else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-cache
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: 0.5.2
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -07:00
+date: 2009-09-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -75,6 +75,8 @@ files:
 - test/storage_test.rb
 has_rdoc: true
 homepage: http://tomayko.com/src/rack-cache/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -100,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: wink
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
 specification_version: 2
 summary: HTTP Caching for Rack