typo 4.0.3 → 4.1

data/vendor/flickr/flickr.rb

@@ -53,7 +53,7 @@ class Flickr
   attr_accessor :user
 
   # Replace this API key with your own (see http://www.flickr.com/services/api/misc.api_keys.html)
-  def initialize(api_key='86e18ef2a064ff2255845e029208d7f4', email=nil, password=nil)
+  def initialize(api_key=FLICKR_KEY, email=nil, password=nil)
     @api_key = api_key
     @host = 'http://flickr.com'
     @api = '/services/rest'

data/vendor/memcache-client/History.txt

@@ -0,0 +1,25 @@
+= 1.2.0
+
+NOTE: This version will store keys in different places than previous
+versions!  Be prepared for some thrashing while memcached sorts itself
+out!
+
+* Fixed multithreaded operations, bug 5994 and 5989.
+  Thanks to Blaine Cook, Erik Hetzner, Elliot Smith, Dave Myron (and
+  possibly others I have forgotten).
+* Made memcached interoperable with other memcached libraries, bug
+  4509.  Thanks to anonymous.
+* Added get_multi to match Perl/etc APIs
+
+= 1.1.0
+
+* Added some tests
+* Sped up non-multithreaded and multithreaded operation
+* More Ruby-memcache compatibility
+* More RDoc
+* Switched to Hoe
+
+= 1.0.0
+
+Birthday!
+

data/vendor/memcache-client/LICENSE.txt

@@ -0,0 +1,30 @@
+All original code copyright 2005, 2006 Bob Cottrell, Eric Hodel, The
+Robot Co-op.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+4. Redistribution in Rails or any sub-projects of Rails is not allowed
+   until Rails runs without warnings with the ``-w'' flag enabled.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/vendor/memcache-client/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+LICENSE.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/memcache.rb
+lib/memcache_util.rb
+test/test_mem_cache.rb

data/vendor/memcache-client/README.txt

@@ -0,0 +1,46 @@
+= memcache-client
+
+Rubyforge Project:
+
+http://rubyforge.org/projects/rctools/
+
+== About
+
+memcache-client is a fast memcached client.
+
+== Installing memcache-client
+
+Just install the gem:
+
+  $ sudo gem install memcache-client
+
+== Using memcache-client
+
+With one server:
+
+  CACHE = MemCache.new 'localhost:11211', :namespace => 'my_namespace'
+
+Or with multiple servers:
+
+  CACHE = MemCache.new %w[one.example.com:11211 two.example.com:11211],
+                       :namespace => 'my_namespace'
+
+See MemCache.new for details.
+
+=== Using memcache-client with Rails
+
+Rails will automatically load the memcache-client gem, but you may
+need to uninstall Ruby-memcache, I don't know which one it will pick
+by default.
+
+Add your environment-specific caches to config/environment/*.  If you run both
+development and production on the same machine be sure to use different
+namespaces.  Be careful when running tests using memcache, you may get strange
+results.  It will be less of a headache to simply use a readonly memcache when
+testing.
+
+memcache-client also comes with a wrapper called Cache in memcache_util.rb for
+use with Rails.  To use it be sure to assign your memcache connection to
+CACHE.  Cache returns nil on all memcache errors so you don't have to rescue
+the errors yourself.  It has #get, #put and #delete module functions.
+

data/vendor/memcache-client/Rakefile

@@ -0,0 +1,23 @@
+# vim: syntax=Ruby
+
+require 'hoe'
+
+DEV_DOC_PATH = "Libraries/memcache-client"
+
+hoe = Hoe.new 'memcache-client', '1.2.0' do |p|
+  p.summary = 'A Ruby memcached client'
+  p.description = 'memcache-client is a pure-ruby client to Danga\'s memcached.'
+  p.author = ['Eric Hodel', 'Robert Cottrell']
+  p.email = 'eric@robotcoop.com'
+  p.url = "http://dev.robotcoop.com/#{DEV_DOC_PATH}"
+
+  p.rubyforge_name = 'rctools'
+end
+
+SPEC = hoe.spec
+
+begin
+  require '../tasks'
+rescue LoadError
+end
+

data/vendor/memcache-client/lib/memcache.rb

@@ -0,0 +1,491 @@
+$TESTING = defined? $TESTING
+
+require 'socket'
+require 'thread'
+require 'timeout'
+require 'rubygems'
+
+class String
+
+  ##
+  # Uses the ITU-T polynomial in the CRC32 algorithm.
+
+  def crc32_ITU_T
+    n = length
+    r = 0xFFFFFFFF
+
+    n.times do |i|
+      r ^= self[i]
+      8.times do
+        if (r & 1) != 0 then
+          r = (r>>1) ^ 0xEDB88320
+        else
+          r >>= 1
+        end
+      end
+    end
+
+    r ^ 0xFFFFFFFF
+  end
+
+end
+
+##
+# A Ruby client library for memcached.
+#
+# This is intended to provide access to basic memcached functionality.  It
+# does not attempt to be complete implementation of the entire API.
+
+class MemCache
+
+  ##
+  # Default options for the cache object.
+
+  DEFAULT_OPTIONS = {
+    :namespace   => nil,
+    :readonly    => false,
+    :multithread => false,
+  }
+
+  ##
+  # Default memcached port.
+
+  DEFAULT_PORT = 11211
+
+  ##
+  # Default memcached server weight.
+
+  DEFAULT_WEIGHT = 1
+
+  ##
+  # The amount of time to wait for a response from a memcached server.  If a
+  # response is not completed within this time, the connection to the server
+  # will be closed and an error will be raised.
+
+  attr_accessor :request_timeout
+
+  ##
+  # The namespace for this instance
+
+  attr_reader :namespace
+
+  ##
+  # The multithread setting for this instance
+
+  attr_reader :multithread
+
+  ##
+  # 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 exeception on cache writes when true.
+  #   [:multithread] Wraps cache access in a Mutex for thread safety.
+
+  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]
+    @mutex       = Mutex.new if @multithread
+    self.servers = servers
+    @buckets     = []
+  end
+
+  ##
+  # Return a string representation of the cache object.
+
+  def inspect
+    sprintf("<MemCache: %s servers, %s buckets, ns: %p, ro: %p>",
+            @servers.length, @buckets.length, @namespace, @readonly)
+  end
+
+  ##
+  # Returns whether there is at least one active server for the object.
+
+  def active?
+    not @servers.empty?
+  end
+
+  ##
+  # Returns whether the cache was created read only.
+
+  def readonly?
+    @readonly
+  end
+
+  ##
+  # Set the servers that the requests will be distributed between.  Entries
+  # can be either strings of the form "hostname:port" or
+  # "hostname:port:weight" or MemCache::Server objects.
+
+  def servers=(servers)
+    # Create the server objects.
+    @servers = servers.collect do |server|
+      case server
+      when String
+        host, port, weight = server.split ':', 3
+        port ||= DEFAULT_PORT
+        weight ||= DEFAULT_WEIGHT
+        Server.new self, host, port, weight
+      when Server
+        if server.memcache.multithread != @multithread then
+          raise ArgumentError, "can't mix threaded and non-threaded servers"
+        end
+        server
+      else
+        raise TypeError, "Cannot convert %s to MemCache::Server" %
+        svr.class.name
+      end
+    end
+
+    # Create an array of server buckets for weight selection of servers.
+    @buckets = []
+    @servers.each do |server|
+      server.weight.times { @buckets.push(server) }
+    end
+  end
+
+  ##
+  # Retrieves +key+ from memcache.
+
+  def get(key)
+    raise MemCacheError, 'No active servers' unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+
+    raise MemCacheError, 'No connection to server' if server.socket.nil?
+
+    value = if @multithread then
+              threadsafe_cache_get server, cache_key
+            else
+              cache_get server, cache_key
+            end
+
+    return nil if value.nil?
+
+    # Return the unmarshaled value.
+    return Marshal.load(value)
+  rescue ArgumentError, TypeError, SystemCallError, IOError => err
+    server.close
+    new_err = MemCacheError.new err.message
+    new_err.set_backtrace err.backtrace
+    raise new_err
+  end
+
+  ##
+  # Retrieves +keys+ and returns a Hash mapping keys to values.
+
+  def get_multi(*keys)
+    values = {}
+    keys.flatten.each { |key| values[key] = get key }
+    values
+  end
+
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds.
+
+  def set(key, value, expiry = 0)
+    @mutex.lock if @multithread
+
+    raise MemCacheError, "No active servers" unless self.active?
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    cache_key = make_cache_key(key)
+    server = get_server_for_key(cache_key)
+
+    sock = server.socket
+    raise MemCacheError, "No connection to server" if sock.nil?
+
+    marshaled_value = Marshal.dump value
+    command = "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n#{marshaled_value}\r\n"
+
+    begin
+      sock.write command
+      sock.gets
+    rescue SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    end
+  ensure
+    @mutex.unlock if @multithread
+  end
+
+  ##
+  # Removes +key+ from the cache in +expiry+ seconds.
+
+  def delete(key, expiry = 0)
+    @mutex.lock if @multithread
+
+    raise MemCacheError, "No active servers" unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+
+    sock = server.socket
+    raise MemCacheError, "No connection to server" if sock.nil?
+
+    begin
+      sock.write "delete #{cache_key} #{expiry}\r\n"
+      sock.gets
+    rescue SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    end
+  ensure
+    @mutex.unlock if @multithread
+  end
+
+  ##
+  # 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.
+
+  def reset
+    @servers.each { |server| server.close }
+  end
+
+  ##
+  # Shortcut to get a value from the cache.
+
+  alias [] get
+
+  ##
+  # 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.
+
+  def []=(key, value)
+    set key, value
+  end
+
+  protected unless $TESTING
+
+  ##
+  # Create a key for the cache, incorporating the namespace qualifier if
+  # requested.
+
+  def make_cache_key(key)
+    if namespace.nil? then
+      key
+    else
+      "#{@namespace}:#{key}"
+    end
+  end
+
+  ##
+  # Pick a server to handle the request based on a hash of the key.
+
+  def get_server_for_key(key)
+    raise MemCacheError, "No servers available" if @servers.empty?
+    return @servers.first if @servers.length == 1
+
+    hkey = hash_for key
+
+    20.times do |try|
+      server = @buckets[hkey % @buckets.nitems]
+      return server if server.alive?
+      hkey += hash_for "#{try}#{key}"
+    end
+
+    raise MemCacheError, "No servers available"
+  end
+
+  ##
+  # Returns an interoperable hash value for +key+.  (I think, docs are
+  # sketchy for down servers).
+
+  def hash_for(key)
+    (key.crc32_ITU_T >> 16) & 0x7fff
+  end
+
+  ##
+  # Fetches the raw data for +cache_key+ from +server+.  Returns nil on cache
+  # miss.
+
+  def cache_get(server, cache_key)
+    socket = server.socket
+    socket.write "get #{cache_key}\r\n"
+    text = socket.gets # "VALUE <key> <flags> <bytes>\r\n"
+    return nil if text == "END\r\n"
+
+    text =~ /(\d+)\r/
+    value = socket.read $1.to_i
+    socket.read 2 # "\r\n"
+    socket.gets   # "END\r\n"
+    return value
+  end
+
+  def threadsafe_cache_get(socket, cache_key) # :nodoc:
+    @mutex.lock
+    cache_get socket, cache_key
+  ensure
+    @mutex.unlock
+  end
+
+  ##
+  # This class represents a memcached server instance.
+
+  class Server
+
+    ##
+    # The amount of time to wait to establish a connection with a memcached
+    # server.  If a connection cannot be established within this time limit,
+    # the server will be marked as down.
+
+    CONNECT_TIMEOUT = 0.25
+
+    ##
+    # The amount of time to wait before attempting to re-establish a
+    # connection with a server that is marked dead.
+
+    RETRY_DELAY = 30.0
+
+    ##
+    # The host the memcached server is running on.
+
+    attr_reader :host
+
+    ##
+    # The port the memcached server is listening on.
+
+    attr_reader :port
+
+    ##
+    # The weight given to the server.
+
+    attr_reader :weight
+
+    ##
+    # The time of next retry if the connection is dead.
+
+    attr_reader :retry
+
+    ##
+    # A text status string describing the state of the server.
+
+    attr_reader :status
+
+    ##
+    # Create a new MemCache::Server object for the memcached instance
+    # listening on the given host and port, weighted by the given weight.
+
+    def initialize(memcache, host, port = DEFAULT_PORT, weight = DEFAULT_WEIGHT)
+      raise ArgumentError, "No host specified" if host.nil? or host.empty?
+      raise ArgumentError, "No port specified" if port.nil? or port.to_i.zero?
+
+      @memcache = memcache
+      @host   = host
+      @port   = port.to_i
+      @weight = weight.to_i
+
+      @multithread = @memcache.multithread
+      @mutex = Mutex.new
+
+      @sock   = nil
+      @retry  = nil
+      @status = 'NOT CONNECTED'
+    end
+
+    ##
+    # Return a string representation of the server object.
+
+    def inspect
+      sprintf("<MemCache::Server: %s:%d [%d] (%s)>",
+              @host, @port, @weight, @status)
+    end
+
+    ##
+    # Check whether the server connection is alive.  This will cause the
+    # socket to attempt to connect if it isn't already connected and or if
+    # the server was previously marked as down and the retry time has
+    # been exceeded.
+
+    def alive?
+      !self.socket.nil?
+    end
+
+    ##
+    # Try to connect to the memcached server targeted by this object.
+    # Returns the connected socket object on success or nil on failure.
+
+    def socket
+      @mutex.lock if @multithread
+      return @sock if @sock and not @sock.closed?
+
+      @sock = nil
+
+      # If the host was dead, don't retry for a while.
+      return if @retry and @retry > Time.now
+
+      # Attempt to connect if not already connected.
+      begin
+        @sock = timeout CONNECT_TIMEOUT do
+          TCPSocket.new @host, @port
+        end
+        @retry  = nil
+        @status = 'CONNECTED'
+      rescue SocketError, SystemCallError, IOError, Timeout::Error => err
+        mark_dead err.message
+      end
+
+      return @sock
+    ensure
+      @mutex.unlock if @multithread
+    end
+
+    ##
+    # Close the connection to the memcached server targeted by this
+    # object.  The server is not considered dead.
+
+    def close
+      @mutex.lock if @multithread
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = nil
+      @status = "NOT CONNECTED"
+    ensure
+      @mutex.unlock if @multithread
+    end
+
+    private
+
+    ##
+    # Mark the server as dead and close its socket.
+
+    def mark_dead(reason = "Unknown error")
+      @sock.close if @sock && !@sock.closed?
+      @sock   = nil
+      @retry  = Time.now + RETRY_DELAY
+
+      @status = sprintf "DEAD: %s, will retry at %s", reason, @retry
+    end
+
+  end
+
+  ##
+  # Base MemCache exception class.
+
+  class MemCacheError < RuntimeError; end
+
+end
+