AdoccaMemcache 0.1.7 → 0.1.8

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems'
 require 'hoe'
 require './lib/adocca_memcache.rb'
 
-Hoe.new('AdoccaMemcache', '0.1.7') do |p|
+Hoe.new('AdoccaMemcache', '0.1.8') do |p|
   p.rubyforge_name = 'adocca-plugins'
   p.author = 'adocca Entertainment AB'
   p.summary = 'A client library to simplify using memcached with Ruby on Rails projects.'

data/lib/am_memcache.rb

@@ -1,5 +1,4 @@
 require 'socket'
-require 'thread'
 require 'digest/sha1'
 require 'timeout'
 require 'monitor'
@@ -71,7 +70,7 @@ module Adocca
       @namespace = opts[:namespace]
       @readonly  = opts[:readonly]
       if ActionController::Base.allow_concurrency
-        @mutex = Mutex.new
+        @mutex = Monitor.new
       else
         @mutex = NullMutex.new
       end
@@ -79,6 +78,16 @@ module Adocca
       @buckets   = []
     end
 
+    def self.log_error(e)
+      if defined?(RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER.error(e)
+        RAILS_DEFAULT_LOGGER.error(PP.pp(e.backtrace, ""))
+      else
+        puts e
+        pp e.backtrace
+      end
+    end
+
     # Return a string representation of the cache object.
     def inspect
       sprintf("<MemCache: %s servers, %s buckets, ns: %p, ro: %p>",
@@ -128,7 +137,7 @@ module Adocca
       rval = nil
       @mutex.synchronize do
         begin
-          response, sock, server = sock_send_command(cache_key, "get #{cache_key}")
+          response, sock, server = sock_send_command(cache_key, "get #{cache_key}", true)
           return :MemCache_no_such_entry if response =~ /^END/
 
           v, cache_key, flags, bytes = response.split(/ /)
@@ -136,11 +145,11 @@ module Adocca
 
           sock.gets
           sock.gets
-        rescue MemCacheError => e
-          raise e
         rescue Exception => err
           server.mark_dead(err.message)
-          raise MemCacheError, err.message
+          
+          self.class.log_error(err)
+          return :MemCache_no_such_entry
         end
       end
 
@@ -151,7 +160,8 @@ module Adocca
         begin
           Marshal.load(rval)
         rescue ArgumentError, TypeError => err
-          raise MemCacheError, err.message
+          self.class.log_error(err)
+          return :MemCache_no_such_entry
         end
       end
     end
@@ -168,10 +178,7 @@ module Adocca
     #
     def inc(key, amount = 1)
       cache_key = make_cache_key(key)
-      rval = nil
-      @mutex.synchronize do
-        rval = send_command(cache_key, "incr #{cache_key} #{amount}")
-      end
+      rval = send_command(cache_key, "incr #{cache_key} #{amount}")
       rval = rval.strip.to_i if rval =~ /^\d+/
       rval
     end
@@ -181,10 +188,7 @@ module Adocca
     #
     def dec(key, amount = 1)
       cache_key = make_cache_key(key)
-      rval = nil
-      @mutex.synchronize do
-        rval = send_command(cache_key, "decr #{cache_key} #{amount}")
-      end
+      rval = send_command(cache_key, "decr #{cache_key} #{amount}")
       rval = rval.strip.to_i if rval =~ /^\d+/
       rval
     end
@@ -204,9 +208,7 @@ module Adocca
       else
         marshaled_value = Marshal.dump(value)
       end
-      @mutex.synchronize do
-        send_command(cache_key, "add #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value) == ADD_STORED
-      end
+      send_command(cache_key, "add #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value) == ADD_STORED
     end
 
     # Add an entry to the cache.
@@ -218,18 +220,14 @@ module Adocca
       else
         marshaled_value = Marshal.dump(value)
       end
-      @mutex.synchronize do
-        send_command(cache_key, "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value)
-      end
+      send_command(cache_key, "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value)
     end
 
     # Remove an entry from the cache.
     # return true if it is deleted
     def delete(key, expiry = 0)
       cache_key = make_cache_key(key)
-      @mutex.synchronize do
-        send_command(cache_key, "delete #{cache_key} #{expiry}")
-      end
+      send_command(cache_key, "delete #{cache_key} #{expiry}")
     end
 
     # Reset the connection to all memcache servers.  This should be called if
@@ -247,7 +245,7 @@ module Adocca
       @mutex.synchronize do
 
         begin
-          response, sock, server = sock_send_command(cache_key, "get #{cache_key}")
+          response, sock, server = sock_send_command(cache_key, "get #{cache_key}", true)
           
           return false if response =~ /^END/
           
@@ -257,7 +255,8 @@ module Adocca
           sock.gets
         rescue Exception => err
           server.mark_dead(err.message)
-          raise MemCacheError, err.message
+          self.class.log_error(err)
+          return false
         end
         
         true
@@ -271,18 +270,16 @@ module Adocca
         @servers.each do |server|
 
           sock = server.socket
-          if sock.nil?
-            raise MemCacheError, "No connection to server"
-          end
-
-          begin
-            timeout(LIVELINESS_TIMEOUT) do
-              sock.write "flush_all\r\n"
-              sock.gets
+          unless sock.nil?
+            begin
+              timeout(LIVELINESS_TIMEOUT) do
+                sock.write "flush_all\r\n"
+                sock.gets
+              end
+            rescue Exception => err
+              server.mark_dead(err.message)
+              self.class.log_error(err)
             end
-          rescue Exception => err
-            server.mark_dead(err.message)
-            raise MemCacheError, err.message
           end
         end
       end
@@ -363,7 +360,7 @@ module Adocca
 
       # The amount of time to wait before attempting to re-establish a
       # connection with a server that is marked dead.
-      RETRY_DELAY = 10
+      RETRY_DELAY = 60
 
       # The host the memcached server is running on.
       attr_reader :host
@@ -430,6 +427,7 @@ module Adocca
               @status = "CONNECTED"
             rescue Exception => err
               self.mark_dead(err.message)
+              MemCache.log_error(err)
             end
           end
         end
@@ -499,25 +497,30 @@ module Adocca
     # Will send a command to the proper server for this key
     # and return the response, socket and server
     #
-    def sock_send_command(key, command)
-      raise MemCacheError, "No active servers" unless self.active?
-      raise MemCacheError, "Update of readonly cache" if @readonly
-      server = get_server_for_key(key)
-
-      sock = server.socket
-      if sock.nil?
-        raise MemCacheError, "No connection to server"
-      end
-
-      response = nil
-      begin
-        timeout(LIVELINESS_TIMEOUT) do
-          sock.write "#{command}\r\n"
-          [sock.gets, sock, server]
+    def sock_send_command(key, command, squash_errors = false)
+      @mutex.synchronize do
+        server = nil
+        begin
+          raise MemCacheError, "No active servers" unless self.active?
+          raise MemCacheError, "Update of readonly cache" if @readonly
+          server = get_server_for_key(key)
+          
+          sock = server.socket
+          raise MemCacheError, "No connection to server" if sock.nil?
+          
+          response = nil
+          
+          timeout(LIVELINESS_TIMEOUT) do
+            sock.write "#{command}\r\n"
+            [sock.gets, sock, server]
+          end
+          
+        rescue Exception => err
+          server.mark_dead(err.message) if server
+          self.class.log_error(err)
+          raise err unless squash_errors
+          return err.message
         end
-      rescue Exception => err
-        server.mark_dead(err.message)
-        raise MemCacheError, err.message
       end
     end
 

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: AdoccaMemcache
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.8
 date: 2007-02-12 00:00:00 +01:00
 summary: A client library to simplify using memcached with Ruby on Rails projects.
 require_paths: