Class: MemCache
- Defined in:
- lib/active_support/vendor/memcache-client-1.6.5/memcache.rb
Overview
A Ruby client library for memcached.
Defined Under Namespace
Classes: MemCacheError, Server
Constant Summary collapse
- VERSION =
The version of MemCache you are using.
'1.6.4.99'
- DEFAULT_OPTIONS =
Default options for the cache object.
{ :namespace => nil, :readonly => false, :multithread => true, :failover => true, :timeout => 0.5, :logger => nil, }
- DEFAULT_PORT =
Default memcached port.
11211
- DEFAULT_WEIGHT =
Default memcached server weight.
1
- ONE_MB =
Add
key
to the cache with valuevalue
that expires inexpiry
seconds. Ifraw
is true,value
will not be Marshalled.Warning: Readers should not call this method in the event of a cache miss; see MemCache#add.
1024 * 1024
Instance Attribute Summary collapse
-
#failover ⇒ Object
readonly
Should the client try to failover to another server if the first server is down? Defaults to true.
-
#logger ⇒ Object
readonly
Log debug/info/warn/error to the given Logger, defaults to nil.
-
#multithread ⇒ Object
readonly
The multithread setting for this instance.
-
#namespace ⇒ Object
readonly
The namespace for this instance.
-
#servers ⇒ Object
The servers this client talks to.
-
#timeout ⇒ Object
readonly
Socket timeout limit with this client, defaults to 0.5 sec.
Instance Method Summary collapse
-
#[]=(key, value) ⇒ Object
Shortcut to save a value in the cache.
-
#active? ⇒ Boolean
Returns whether there is at least one active server for the object.
-
#add(key, value, expiry = 0, raw = false) ⇒ Object
Add
key
to the cache with valuevalue
that expires inexpiry
seconds, but only ifkey
does not already exist in the cache. -
#cache_decr(server, cache_key, amount) ⇒ Object
Performs a raw decr for
cache_key
fromserver
. -
#cache_get(server, cache_key) ⇒ Object
Fetches the raw data for
cache_key
fromserver
. -
#cache_get_multi(server, cache_keys) ⇒ Object
Fetches
cache_keys
fromserver
using a multi-get. -
#cache_incr(server, cache_key, amount) ⇒ Object
Performs a raw incr for
cache_key
fromserver
. - #check_multithread_status! ⇒ Object
- #create_continuum_for(servers) ⇒ Object
-
#decr(key, amount = 1) ⇒ Object
Decrements the value for
key
byamount
and returns the new value. -
#delete(key, expiry = 0) ⇒ Object
Removes
key
from the cache inexpiry
seconds. - #entry_count_for(server, total_servers, total_weight) ⇒ Object
-
#flush_all ⇒ Object
Flush the cache from all memcache servers.
-
#get(key, raw = false) ⇒ Object
(also: #[])
Retrieves
key
from memcache. -
#get_multi(*keys) ⇒ Object
Retrieves multiple values from memcached in parallel, if possible.
-
#get_server_for_key(key, options = {}) ⇒ Object
Pick a server to handle the request based on a hash of the key.
-
#handle_error(server, error) ⇒ Object
Handles
error
fromserver
. -
#hash_for(key) ⇒ Object
Returns an interoperable hash value for
key
. -
#incr(key, amount = 1) ⇒ Object
Increments the value for
key
byamount
and returns the new value. -
#initialize(*args) ⇒ MemCache
constructor
Accepts a list of
servers
and a list ofopts
. -
#inspect ⇒ Object
Returns a string representation of the cache object.
-
#make_cache_key(key) ⇒ Object
Create a key for the cache, incorporating the namespace qualifier if requested.
- #raise_on_error_response!(response) ⇒ Object
-
#readonly? ⇒ Boolean
Returns whether or not the cache object was created read only.
-
#request_setup(key) ⇒ Object
Performs setup for making a request with
key
from memcached. -
#reset ⇒ Object
Reset the connection to all memcache servers.
- #set(key, value, expiry = 0, raw = false) ⇒ Object
-
#stats ⇒ Object
Returns statistics for each memcached server.
- #with_server(key) ⇒ Object
-
#with_socket_management(server, &block) ⇒ Object
Gets or creates a socket connected to the given server, and yields it to the block, wrapped in a mutex synchronization if @multithread is true.
Constructor Details
#initialize(*args) ⇒ MemCache
Accepts a list of servers
and a list of opts
. servers
may be omitted. See servers=
for acceptable server list arguments.
Valid options for opts
are:
[:namespace] Prepends this value to all keys added or retrieved.
[:readonly] Raises an exception on cache writes when true.
[:multithread] Wraps cache access in a Mutex for thread safety.
[:failover] Should the client try to failover to another server if the
first server is down? Defaults to true.
[:timeout] Time to use as the socket read timeout. Defaults to 0.5 sec,
set to nil to disable timeouts (this is a major performance penalty in Ruby 1.8).
[:logger] Logger to use for info/debug output, defaults to nil
Other options are ignored.
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 90 def initialize(*args) servers = [] opts = {} case args.length when 0 then # NOP when 1 then arg = args.shift case arg when Hash then opts = arg when Array then servers = arg when String then servers = [arg] else raise ArgumentError, 'first argument must be Array, Hash or String' end when 2 then servers, opts = args else raise ArgumentError, "wrong number of arguments (#{args.length} for 2)" end opts = DEFAULT_OPTIONS.merge opts @namespace = opts[:namespace] @readonly = opts[:readonly] @multithread = opts[:multithread] @timeout = opts[:timeout] @failover = opts[:failover] @logger = opts[:logger] @mutex = Mutex.new if @multithread logger.info { "memcache-client #{VERSION} #{Array(servers).inspect}" } if logger Thread.current[:memcache_client] = self.object_id if !@multithread self.servers = servers end |
Instance Attribute Details
#failover ⇒ Object (readonly)
Should the client try to failover to another server if the first server is down? Defaults to true.
67 68 69 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 67 def failover @failover end |
#logger ⇒ Object (readonly)
Log debug/info/warn/error to the given Logger, defaults to nil.
72 73 74 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 72 def logger @logger end |
#multithread ⇒ Object (readonly)
The multithread setting for this instance
50 51 52 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 50 def multithread @multithread end |
#namespace ⇒ Object (readonly)
The namespace for this instance
45 46 47 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 45 def namespace @namespace end |
#servers ⇒ Object
The servers this client talks to. Play at your own peril.
55 56 57 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 55 def servers @servers end |
#timeout ⇒ Object (readonly)
Socket timeout limit with this client, defaults to 0.5 sec. Set to nil to disable timeouts.
61 62 63 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 61 def timeout @timeout end |
Instance Method Details
#[]=(key, value) ⇒ Object
Shortcut to save a value in the cache. This method does not set an expiration on the entry. Use set to specify an explicit expiry.
458 459 460 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 458 def []=(key, value) set key, value end |
#active? ⇒ Boolean
Returns whether there is at least one active server for the object.
137 138 139 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 137 def active? not @servers.empty? end |
#add(key, value, expiry = 0, raw = false) ⇒ Object
Add key
to the cache with value value
that expires in expiry
seconds, but only if key
does not already exist in the cache. If raw
is true, value
will not be Marshalled.
Readers should call this method in the event of a cache miss, not MemCache#set or MemCache#[]=.
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 316 def add(key, value, expiry = 0, raw = false) raise MemCacheError, "Update of readonly cache" if @readonly with_server(key) do |server, cache_key| value = Marshal.dump value unless raw logger.debug { "ADD #{key} to #{server}: #{value ? value.to_s.size : 'nil'}" } if logger command = "add #{cache_key} 0 #{expiry} #{value.to_s.size}\r\n#{value}\r\n" with_socket_management(server) do |socket| socket.write command result = socket.gets raise_on_error_response! result result end end end |
#cache_decr(server, cache_key, amount) ⇒ Object
Performs a raw decr for cache_key
from server
. Returns nil if not found.
511 512 513 514 515 516 517 518 519 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 511 def cache_decr(server, cache_key, amount) with_socket_management(server) do |socket| socket.write "decr #{cache_key} #{amount}\r\n" text = socket.gets raise_on_error_response! text return nil if text == "NOT_FOUND\r\n" return text.to_i end end |
#cache_get(server, cache_key) ⇒ Object
Fetches the raw data for cache_key
from server
. Returns nil on cache miss.
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 525 def cache_get(server, cache_key) with_socket_management(server) do |socket| socket.write "get #{cache_key}\r\n" keyline = socket.gets # "VALUE <key> <flags> <bytes>\r\n" if keyline.nil? then server.close raise MemCacheError, "lost connection to #{server.host}:#{server.port}" end raise_on_error_response! keyline return nil if keyline == "END\r\n" unless keyline =~ /(\d+)\r/ then server.close raise MemCacheError, "unexpected response #{keyline.inspect}" end value = socket.read $1.to_i socket.read 2 # "\r\n" socket.gets # "END\r\n" return value end end |
#cache_get_multi(server, cache_keys) ⇒ Object
Fetches cache_keys
from server
using a multi-get.
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 552 def cache_get_multi(server, cache_keys) with_socket_management(server) do |socket| values = {} socket.write "get #{cache_keys}\r\n" while keyline = socket.gets do return values if keyline == "END\r\n" raise_on_error_response! keyline unless keyline =~ /\AVALUE (.+) (.+) (.+)/ then server.close raise MemCacheError, "unexpected response #{keyline.inspect}" end key, data_length = $1, $3 values[$1] = socket.read data_length.to_i socket.read(2) # "\r\n" end server.close raise MemCacheError, "lost connection to #{server.host}:#{server.port}" # TODO: retry here too end end |
#cache_incr(server, cache_key, amount) ⇒ Object
Performs a raw incr for cache_key
from server
. Returns nil if not found.
580 581 582 583 584 585 586 587 588 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 580 def cache_incr(server, cache_key, amount) with_socket_management(server) do |socket| socket.write "incr #{cache_key} #{amount}\r\n" text = socket.gets raise_on_error_response! text return nil if text == "NOT_FOUND\r\n" return text.to_i end end |
#check_multithread_status! ⇒ Object
698 699 700 701 702 703 704 705 706 707 708 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 698 def check_multithread_status! return if @multithread if Thread.current[:memcache_client] != self.object_id raise MemCacheError, <<-EOM You are accessing this memcache-client instance from multiple threads but have not enabled multithread support. Normally: MemCache.new(['localhost:11211'], :multithread => true) In Rails: config.cache_store = [:mem_cache_store, 'localhost:11211', { :multithread => true }] EOM end end |
#create_continuum_for(servers) ⇒ Object
679 680 681 682 683 684 685 686 687 688 689 690 691 692 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 679 def create_continuum_for(servers) total_weight = servers.inject(0) { |memo, srv| memo + srv.weight } continuum = [] servers.each do |server| entry_count_for(server, servers.size, total_weight).times do |idx| hash = Digest::SHA1.hexdigest("#{server.host}:#{server.port}:#{idx}") value = Integer("0x#{hash[0..7]}") continuum << Continuum::Entry.new(value, server) end end continuum.sort { |a, b| a.value <=> b.value } end |
#decr(key, amount = 1) ⇒ Object
Decrements the value for key
by amount
and returns the new value. key
must already exist. If key
is not an integer, it is assumed to be
-
key
can not be decremented below 0.
180 181 182 183 184 185 186 187 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 180 def decr(key, amount = 1) raise MemCacheError, "Update of readonly cache" if @readonly with_server(key) do |server, cache_key| cache_decr server, cache_key, amount end rescue TypeError => err handle_error nil, err end |
#delete(key, expiry = 0) ⇒ Object
Removes key
from the cache in expiry
seconds.
335 336 337 338 339 340 341 342 343 344 345 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 335 def delete(key, expiry = 0) raise MemCacheError, "Update of readonly cache" if @readonly with_server(key) do |server, cache_key| with_socket_management(server) do |socket| socket.write "delete #{cache_key} #{expiry}\r\n" result = socket.gets raise_on_error_response! result result end end end |
#entry_count_for(server, total_servers, total_weight) ⇒ Object
694 695 696 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 694 def entry_count_for(server, total_servers, total_weight) ((total_servers * Continuum::POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor end |
#flush_all ⇒ Object
Flush the cache from all memcache servers.
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 350 def flush_all raise MemCacheError, 'No active servers' unless active? raise MemCacheError, "Update of readonly cache" if @readonly begin @servers.each do |server| with_socket_management(server) do |socket| socket.write "flush_all\r\n" result = socket.gets raise_on_error_response! result result end end rescue IndexError => err handle_error nil, err end end |
#get(key, raw = false) ⇒ Object Also known as: []
Retrieves key
from memcache. If raw
is false, the value will be unmarshalled.
193 194 195 196 197 198 199 200 201 202 203 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 193 def get(key, raw = false) with_server(key) do |server, cache_key| value = cache_get server, cache_key logger.debug { "GET #{key} from #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger return nil if value.nil? value = Marshal.load value unless raw return value end rescue TypeError => err handle_error nil, err end |
#get_multi(*keys) ⇒ Object
Retrieves multiple values from memcached in parallel, if possible.
The memcached protocol supports the ability to retrieve multiple keys in a single request. Pass in an array of keys to this method and it will:
-
map the key to the appropriate memcached server
-
send a single request to each server that has one or more key values
Returns a hash of values.
cache["a"] = 1
cache["b"] = 2
cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
Note that get_multi assumes the values are marshalled.
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 223 def get_multi(*keys) raise MemCacheError, 'No active servers' unless active? keys.flatten! key_count = keys.length cache_keys = {} server_keys = Hash.new { |h,k| h[k] = [] } # map keys to servers keys.each do |key| server, cache_key = request_setup key cache_keys[cache_key] = key server_keys[server] << cache_key end results = {} server_keys.each do |server, keys_for_server| keys_for_server_str = keys_for_server.join ' ' begin values = cache_get_multi server, keys_for_server_str values.each do |key, value| results[cache_keys[key]] = Marshal.load value end rescue IndexError => e # Ignore this server and try the others logger.warn { "Unable to retrieve #{keys_for_server.size} elements from #{server.inspect}: #{e.}"} if logger end end return results rescue TypeError => err handle_error nil, err end |
#get_server_for_key(key, options = {}) ⇒ Object
Pick a server to handle the request based on a hash of the key.
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 487 def get_server_for_key(key, = {}) raise ArgumentError, "illegal character in key #{key.inspect}" if key =~ /\s/ raise ArgumentError, "key too long #{key.inspect}" if key.length > 250 raise MemCacheError, "No servers available" if @servers.empty? return @servers.first if @servers.length == 1 hkey = hash_for(key) 20.times do |try| entryidx = Continuum.binary_search(@continuum, hkey) server = @continuum[entryidx].server return server if server.alive? break unless failover hkey = hash_for "#{try}#{key}" end raise MemCacheError, "No servers available" end |
#handle_error(server, error) ⇒ Object
Handles error
from server
.
654 655 656 657 658 659 660 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 654 def handle_error(server, error) raise error if error.is_a?(MemCacheError) server.close if server new_error = MemCacheError.new error. new_error.set_backtrace error.backtrace raise new_error end |
#hash_for(key) ⇒ Object
Returns an interoperable hash value for key
. (I think, docs are sketchy for down servers).
480 481 482 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 480 def hash_for(key) Zlib.crc32(key) end |
#incr(key, amount = 1) ⇒ Object
Increments the value for key
by amount
and returns the new value. key
must already exist. If key
is not an integer, it is assumed to be 0.
263 264 265 266 267 268 269 270 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 263 def incr(key, amount = 1) raise MemCacheError, "Update of readonly cache" if @readonly with_server(key) do |server, cache_key| cache_incr server, cache_key, amount end rescue TypeError => err handle_error nil, err end |
#inspect ⇒ Object
Returns a string representation of the cache object.
129 130 131 132 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 129 def inspect "<MemCache: %d servers, ns: %p, ro: %p>" % [@servers.length, @namespace, @readonly] end |
#make_cache_key(key) ⇒ Object
Create a key for the cache, incorporating the namespace qualifier if requested.
468 469 470 471 472 473 474 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 468 def make_cache_key(key) if namespace.nil? then key else "#{@namespace}:#{key}" end end |
#raise_on_error_response!(response) ⇒ Object
673 674 675 676 677 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 673 def raise_on_error_response!(response) if response =~ /\A(?:CLIENT_|SERVER_)?ERROR(.*)/ raise MemCacheError, $1.strip end end |
#readonly? ⇒ Boolean
Returns whether or not the cache object was created read only.
144 145 146 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 144 def readonly? @readonly end |
#request_setup(key) ⇒ Object
Performs setup for making a request with key
from memcached. Returns the server to fetch the key from and the complete key to use.
666 667 668 669 670 671 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 666 def request_setup(key) raise MemCacheError, 'No active servers' unless active? cache_key = make_cache_key key server = get_server_for_key cache_key return server, cache_key end |
#reset ⇒ Object
Reset the connection to all memcache servers. This should be called if there is a problem with a cache lookup that might have left the connection in a corrupted state.
373 374 375 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 373 def reset @servers.each { |server| server.close } end |
#set(key, value, expiry = 0, raw = false) ⇒ Object
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 281 def set(key, value, expiry = 0, raw = false) raise MemCacheError, "Update of readonly cache" if @readonly with_server(key) do |server, cache_key| value = Marshal.dump value unless raw logger.debug { "SET #{key} to #{server.inspect}: #{value ? value.to_s.size : 'nil'}" } if logger data = value.to_s raise MemCacheError, "Value too large, memcached can only store 1MB of data per key" if data.size > ONE_MB command = "set #{cache_key} 0 #{expiry} #{data.size}\r\n#{data}\r\n" with_socket_management(server) do |socket| socket.write command result = socket.gets raise_on_error_response! result if result.nil? server.close raise MemCacheError, "lost connection to #{server.host}:#{server.port}" end result end end end |
#stats ⇒ Object
Returns statistics for each memcached server. An explanation of the statistics can be found in the memcached docs:
code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
Example:
>> pp CACHE.stats
{"localhost:11211"=>
{"bytes"=>4718,
"pid"=>20188,
"connection_structures"=>4,
"time"=>1162278121,
"pointer_size"=>32,
"limit_maxbytes"=>67108864,
"cmd_get"=>14532,
"version"=>"1.2.0",
"bytes_written"=>432583,
"cmd_set"=>32,
"get_misses"=>0,
"total_connections"=>19,
"curr_connections"=>3,
"curr_items"=>4,
"uptime"=>1557,
"get_hits"=>14532,
"total_items"=>32,
"rusage_system"=>0.313952,
"rusage_user"=>0.119981,
"bytes_read"=>190619}}
=> nil
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 409 def stats raise MemCacheError, "No active servers" unless active? server_stats = {} @servers.each do |server| next unless server.alive? with_socket_management(server) do |socket| value = nil socket.write "stats\r\n" stats = {} while line = socket.gets do raise_on_error_response! line break if line == "END\r\n" if line =~ /\ASTAT ([\S]+) ([\w\.\:]+)/ then name, value = $1, $2 stats[name] = case name when 'version' value when 'rusage_user', 'rusage_system' then seconds, microseconds = value.split(/:/, 2) microseconds ||= 0 Float(seconds) + (Float(microseconds) / 1_000_000) else if value =~ /\A\d+\Z/ then value.to_i else value end end end end server_stats["#{server.host}:#{server.port}"] = stats end end raise MemCacheError, "No active servers" if server_stats.empty? server_stats end |
#with_server(key) ⇒ Object
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 635 def with_server(key) retried = false begin server, cache_key = request_setup(key) yield server, cache_key rescue IndexError => e logger.warn { "Server failed: #{e.class.name}: #{e.}" } if logger if !retried && @servers.size > 1 logger.info { "Connection to server #{server.inspect} DIED! Retrying operation..." } if logger retried = true retry end handle_error(nil, e) end end |
#with_socket_management(server, &block) ⇒ Object
Gets or creates a socket connected to the given server, and yields it to the block, wrapped in a mutex synchronization if @multithread is true.
If a socket error (SocketError, SystemCallError, IOError) or protocol error (MemCacheError) is raised by the block, closes the socket, attempts to connect again, and retries the block (once). If an error is again raised, reraises it as MemCacheError.
If unable to connect to the server (or if in the reconnect wait period), raises MemCacheError. Note that the socket connect code marks a server dead for a timeout period, so retrying does not apply to connection attempt failures (but does still apply to unexpectedly lost connections etc.).
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 |
# File 'lib/active_support/vendor/memcache-client-1.6.5/memcache.rb', line 604 def with_socket_management(server, &block) check_multithread_status! @mutex.lock if @multithread retried = false begin socket = server.socket # Raise an IndexError to show this server is out of whack. If were inside # a with_server block, we'll catch it and attempt to restart the operation. raise IndexError, "No connection to server (#{server.status})" if socket.nil? block.call(socket) rescue SocketError => err logger.warn { "Socket failure: #{err.}" } if logger server.mark_dead(err) handle_error(server, err) rescue MemCacheError, SystemCallError, IOError => err logger.warn { "Generic failure: #{err.class.name}: #{err.}" } if logger handle_error(server, err) if retried || socket.nil? retried = true retry end ensure @mutex.unlock if @multithread end |