dalli 0.10.0 → 0.10.1

data/History.md

@@ -1,6 +1,13 @@
 Dalli Changelog
 =====================
 
+0.10.1
+======
+
+ - Prefer server config from environment, fixes Heroku session store issues (thanks JoshMcKin)
+ - Better handling of non-ASCII values (size -> bytesize)
+ - Assert that keys are ASCII only
+
 0.10.0
 ======
 

data/README.md

@@ -59,7 +59,7 @@ In `config/environments/production.rb`:
 A more comprehensive example (note that we are setting a reasonable default for maximum cache entry lifetime (one day), enabling compression for large values, and namespacing all entries for this rails app.  Remove the namespace if you have multiple apps which share cached values):
 
     config.cache_store = :dalli_store, 'cache-1.example.com', 'cache-2.example.com',
-        :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true, :compress_threshold => 64.kilobytes
+        { :namespace => NAME_OF_RAILS_APP, :expires_in => 1.day, :compress => true, :compress_threshold => 64*1024 }
 
 To use Dalli for Rails session storage, in `config/initializers/session_store.rb`:
 
@@ -83,6 +83,14 @@ In `config/environments/production.rb`:
 In `config/initializers/session_store.rb`:
 
     # Session cache
+    ActionController::Base.session = {
+      :namespace   => 'sessions',
+      :expire_after => 20.minutes.to_i,
+      :memcache_server => ['server-1:11211', 'server-2:11211'],
+      :key         => ...,
+      :secret      => ...
+    }
+    
     require 'action_controller/session/dalli_store'
     ActionController::Base.session_store = :dalli_store
 

data/lib/action_controller/session/dalli_store.rb

@@ -17,6 +17,8 @@ begin
             :memcache_server => 'localhost:11211'
           }.merge(@default_options)
 
+          Rails.logger.debug("Using Dalli #{Dalli::VERSION} for session store at #{@default_options[:memcache_server].inspect}")
+
           @pool = Dalli::Client.new(@default_options[:memcache_server], @default_options)
           super
         end
@@ -27,6 +29,7 @@ begin
             begin
               session = @pool.get(sid) || {}
             rescue Dalli::DalliError
+              Rails.logger.warn("Session::DalliStore#get: #{$!.message}")
               session = {}
             end
             [sid, session]
@@ -38,6 +41,7 @@ begin
             @pool.set(sid, session_data, expiry)
             return true
           rescue Dalli::DalliError
+            Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
             return false
           end
           
@@ -46,6 +50,7 @@ begin
               @pool.delete(sid)
             end
           rescue Dalli::DalliError
+            Rails.logger.warn("Session::DalliStore#destroy: #{$!.message}")
             false
           end
           

data/lib/dalli.rb

@@ -4,6 +4,12 @@ require 'dalli/server'
 require 'dalli/version'
 require 'dalli/options'
 
+unless String.respond_to?(:bytesize)
+  class String
+    alias_method :bytesize, :size
+  end
+end
+
 module Dalli
   # generic error
   class DalliError < RuntimeError; end

data/lib/dalli/client.rb

@@ -16,7 +16,7 @@ module Dalli
     #   :threadsafe - ensure that only one thread is actively using a socket at a time. Default: true.
     #
     def initialize(servers=nil, options={})
-      @servers = servers || env_servers || 'localhost:11211'
+      @servers = env_servers || servers || 'localhost:11211'
       @options = options
     end
     
@@ -185,7 +185,9 @@ module Dalli
     end
     
     def validate_key(key)
-      raise ArgumentError, "illegal character in key #{key.inspect}" if key =~ /\s/
+      raise ArgumentError, "illegal character in key #{key}" if key.respond_to?(:ascii_only?) && !key.ascii_only?
+      raise ArgumentError, "illegal character in key #{key}" if key =~ /\s/
+      raise ArgumentError, "illegal character in key #{key}" if key =~ /[\x00-\x20\x80-\xFF]/
       raise ArgumentError, "key cannot be blank" if key.nil? || key.strip.size == 0
       raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
       @options[:namespace] ? "#{@options[:namespace]}:#{key}" : key

data/lib/dalli/server.rb

@@ -99,20 +99,20 @@ module Dalli
     ONE_MB = 1024 * 1024
 
     def get(key)
-      req = [REQUEST, OPCODES[:get], key.size, 0, 0, 0, key.size, 0, 0, key].pack(FORMAT[:get])
+      req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
       write(req)
       generic_response
     end
 
     def getkq(key)
-      req = [REQUEST, OPCODES[:getkq], key.size, 0, 0, 0, key.size, 0, 0, key].pack(FORMAT[:getkq])
+      req = [REQUEST, OPCODES[:getkq], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:getkq])
       write(req)
     end
 
     def set(key, value, ttl)
-      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.size > ONE_MB
+      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.bytesize > ONE_MB
 
-      req = [REQUEST, OPCODES[multi? ? :setq : :set], key.size, 8, 0, 0, value.size + key.size + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:set])
+      req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:set])
       write(req)
       generic_response unless multi?
     end
@@ -124,21 +124,21 @@ module Dalli
     end
 
     def add(key, value, ttl, cas)
-      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.size > ONE_MB
+      raise Dalli::DalliError, "Value too large, memcached can only store 1MB of data per key" if value.bytesize > ONE_MB
 
-      req = [REQUEST, OPCODES[multi? ? :addq : :add], key.size, 8, 0, 0, value.size + key.size + 8, 0, cas, 0, ttl, key, value].pack(FORMAT[:add])
+      req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, 0, ttl, key, value].pack(FORMAT[:add])
       write(req)
       generic_response unless multi?
     end
     
     def append(key, value)
-      req = [REQUEST, OPCODES[:append], key.size, 0, 0, 0, value.size + key.size, 0, 0, key, value].pack(FORMAT[:append])
+      req = [REQUEST, OPCODES[:append], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[:append])
       write(req)
       generic_response
     end
     
     def delete(key)
-      req = [REQUEST, OPCODES[multi? ? :deleteq : :delete], key.size, 0, 0, 0, key.size, 0, 0, key].pack(FORMAT[:delete])
+      req = [REQUEST, OPCODES[multi? ? :deleteq : :delete], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:delete])
       write(req)
       generic_response unless multi?
     end
@@ -148,7 +148,7 @@ module Dalli
       default ||= 0
       (h, l) = split(count)
       (dh, dl) = split(default)
-      req = [REQUEST, OPCODES[:decr], key.size, 20, 0, 0, key.size + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:decr])
+      req = [REQUEST, OPCODES[:decr], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:decr])
       write(req)
       body = generic_response
       body ? longlong(*body.unpack('NN')) : body
@@ -159,7 +159,7 @@ module Dalli
       default ||= 0
       (h, l) = split(count)
       (dh, dl) = split(default)
-      req = [REQUEST, OPCODES[:incr], key.size, 20, 0, 0, key.size + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:incr])
+      req = [REQUEST, OPCODES[:incr], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[:incr])
       write(req)
       body = generic_response
       body ? longlong(*body.unpack('NN')) : body
@@ -174,25 +174,25 @@ module Dalli
     end
 
     def prepend(key, value)
-      req = [REQUEST, OPCODES[:prepend], key.size, 0, 0, 0, value.size + key.size, 0, 0, key, value].pack(FORMAT[:prepend])
+      req = [REQUEST, OPCODES[:prepend], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[:prepend])
       write(req)
       generic_response
     end
 
     def replace(key, value, ttl)
-      req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.size, 8, 0, 0, value.size + key.size + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:replace])
+      req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, 0, ttl, key, value].pack(FORMAT[:replace])
       write(req)
       generic_response unless multi?
     end
 
     def stats(info='')
-      req = [REQUEST, OPCODES[:stat], info.size, 0, 0, 0, info.size, 0, 0, info].pack(FORMAT[:stat])
+      req = [REQUEST, OPCODES[:stat], info.bytesize, 0, 0, 0, info.bytesize, 0, 0, info].pack(FORMAT[:stat])
       write(req)
       keyvalue_response
     end
 
     def cas(key)
-      req = [REQUEST, OPCODES[:get], key.size, 0, 0, 0, key.size, 0, 0, key].pack(FORMAT[:get])
+      req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
       write(req)
       cas_response
     end
@@ -314,8 +314,8 @@ module Dalli
         value = ''
         begin
           loop do
-            value << socket.sysread(count - value.size)
-            break if value.size == count
+            value << socket.sysread(count - value.bytesize)
+            break if value.bytesize == count
           end
         rescue Errno::EAGAIN, Errno::EWOULDBLOCK
           if IO.select([socket], nil, nil, TIMEOUT)
@@ -449,7 +449,7 @@ module Dalli
       msg = sasl.start[1]
       mechanism = sasl.name
       #p [mechanism, msg]
-      req = [REQUEST, OPCODES[:auth_request], mechanism.size, 0, 0, 0, mechanism.size + msg.size, 0, 0, mechanism, msg].pack(FORMAT[:auth_request])
+      req = [REQUEST, OPCODES[:auth_request], mechanism.bytesize, 0, 0, 0, mechanism.bytesize + msg.bytesize, 0, 0, mechanism, msg].pack(FORMAT[:auth_request])
       socket.write(req)
 
       header = read(24, socket)

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '0.10.0'
+  VERSION = '0.10.1'
 end

data/test/test_encoding.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'helper'
+require 'memcached_mock'
+
+class TestEncoding < Test::Unit::TestCase
+
+  context 'using a live server' do
+    should 'support i18n content' do
+      memcached do |dc|
+        key = 'foo'
+        bad_key = utf8 = 'ƒ©åÍÎ'
+
+        assert dc.set(key, utf8)
+        assert_equal utf8, dc.get(key)
+
+        # keys must be ASCII
+        assert_raise ArgumentError, /illegal character/ do
+          dc.set(bad_key, utf8)
+        end
+      end
+    end
+
+    should 'support content expiry' do
+      memcached do |dc|
+        key = 'foo'
+        assert dc.set(key, 'bar', 1)
+        assert_equal 'bar', dc.get(key)
+        sleep 1.1
+        assert_equal nil, dc.get(key)
+      end
+    end
+
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 10
-  - 0
-  version: 0.10.0
+  - 1
+  version: 0.10.1
 platform: ruby
 authors: 
 - Mike Perham
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-16 00:00:00 -07:00
+date: 2010-10-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,7 @@ files:
 - test/memcached_mock.rb
 - test/test_active_support.rb
 - test/test_dalli.rb
+- test/test_encoding.rb
 - test/test_network.rb
 - test/test_session_store.rb
 has_rdoc: true
@@ -151,5 +152,6 @@ test_files:
 - test/memcached_mock.rb
 - test/test_active_support.rb
 - test/test_dalli.rb
+- test/test_encoding.rb
 - test/test_network.rb
 - test/test_session_store.rb