mob-dalli 1.1.4

data/lib/dalli/socket.rb

@@ -0,0 +1,170 @@
+begin
+  require 'kgio'
+  puts "Using kgio socket IO" if defined?($TESTING) && $TESTING
+
+  class Dalli::Server::KSocket < Kgio::Socket
+    attr_accessor :options
+
+    def kgio_wait_readable
+      IO.select([self], nil, nil, options[:timeout]) || raise(Timeout::Error, "IO timeout")
+    end
+
+    def kgio_wait_writable
+      IO.select(nil, [self], nil, options[:timeout]) || raise(Timeout::Error, "IO timeout")
+    end
+
+    def self.open(host, port, options = {})
+      addr = Socket.pack_sockaddr_in(port, host)
+      sock = start(addr)
+      sock.options = options
+      sock.kgio_wait_writable
+      sock
+    end
+
+    alias :write :kgio_write
+
+    def readfull(count)
+      value = ''
+      loop do
+        value << kgio_read!(count - value.bytesize)
+        break if value.bytesize == count
+      end
+      value
+    end
+
+  end
+
+
+
+  if ::Kgio.respond_to?(:wait_readable=)
+    ::Kgio.wait_readable = :kgio_wait_readable
+    ::Kgio.wait_writable = :kgio_wait_writable
+  end
+
+rescue LoadError
+
+  puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+    class Dalli::Server::KSocket < TCPSocket
+      attr_accessor :options
+
+      def self.open(host, port, options = {})
+        sock = new(host, port)
+        sock.options = { :host => host, :port => port }.merge(options)
+        sock
+      end
+
+      def readfull(count)
+        value = ''
+        begin
+          loop do
+            value << read_nonblock(count - value.bytesize)
+            break if value.bytesize == count
+          end
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          if IO.select([self], nil, nil, options[:timeout])
+            retry
+          else
+            raise Timeout::Error, "IO timeout: #{options.inspect}"
+          end
+        end
+        value
+      end
+
+    end
+
+  else
+
+    class Dalli::Server::KSocket < Socket
+      attr_accessor :options
+
+      def self.open(host, port, options = {})
+        # All this ugly code to ensure proper Socket connect timeout
+        addr = Socket.getaddrinfo(host, nil)
+        sock = new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+        sock.options = { :host => host, :port => port }.merge(options)
+        begin
+          sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+        rescue Errno::EINPROGRESS
+          resp = IO.select(nil, [sock], nil, sock.options[:timeout])
+          begin
+            sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+          rescue Errno::EISCONN
+          end
+        end
+        sock
+      end
+
+      def readfull(count)
+        value = ''
+        begin
+          loop do
+            value << sysread(count - value.bytesize)
+            break if value.bytesize == count
+          end
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          if IO.select([self], nil, nil, options[:timeout])
+            retry
+          else
+            raise Timeout::Error, "IO timeout: #{options.inspect}"
+          end
+        end
+        value
+      end
+    end
+
+  end
+end
+
+begin
+  require 'em-synchrony'
+  puts "Defining alternate em-synchrony socket IO" if defined?($TESTING) && $TESTING
+
+  class Dalli::Server::AsyncSocket < EventMachine::Synchrony::TCPSocket
+    # XXX. need to somehow implement the timeout option.
+    # EM::Synchrony::TCPsocket does give you any timeouts. To implement it we'd have
+    # to change that class to take a timeout parameter that it would then set on
+    # the Deferrable objects it waits on.
+    attr_accessor :options
+
+    def self.open(host, port, options = {})
+      sock = new(host, port)
+      sock.options = { :host => host, :port => port }.merge(options)
+      sock
+    end
+
+    def readfull(count)
+      value = ''
+      loop do
+        value << read(count - value.bytesize)
+        break if value.bytesize == count
+      end
+      value
+    end
+
+  end
+
+rescue LoadError
+  puts "Could not define alternate em-synchrony socket IO" if defined?($TESTING) && $TESTING
+end
+
+require 'rbconfig'
+if RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
+  class Dalli::Server::USocket
+    def initialize(*args)
+      raise Dalli::DalliError, "Unix sockets are not supported on Windows platform."
+    end
+  end
+else
+  class Dalli::Server::USocket < UNIXSocket
+    def readfull(count)
+      value = ''
+      loop do
+        value << read(count - value.bytesize)
+        break if value.bytesize == count
+      end
+      value
+    end
+  end
+end

data/lib/dalli/version.rb

@@ -0,0 +1,3 @@
+module Dalli
+  VERSION = '1.1.4'
+end

data/lib/mob-dalli.rb

@@ -0,0 +1,47 @@
+require 'dalli/client'
+require 'dalli/ring'
+require 'dalli/server'
+require 'dalli/socket'
+require 'dalli/version'
+require 'dalli/options'
+
+unless ''.respond_to?(:bytesize)
+  class String
+    alias_method :bytesize, :size
+  end
+end
+
+module Dalli
+  # generic error
+  class DalliError < RuntimeError; end
+  # socket/server communication error
+  class NetworkError < DalliError; end
+  # no server available/alive error
+  class RingError < DalliError; end
+  # application error in marshalling
+  class MarshalError < DalliError; end
+
+  def self.logger
+    @logger ||= (rails_logger || default_logger)
+  end
+
+  def self.rails_logger
+    (defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger) ||
+    (defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:debug) && RAILS_DEFAULT_LOGGER)
+  end
+
+  def self.default_logger
+    require 'logger'
+    l = Logger.new(STDOUT)
+    l.level = Logger::INFO
+    l
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+if defined?(RAILS_VERSION) && RAILS_VERSION < '3'
+  raise Dalli::DalliError, "Dalli #{Dalli::VERSION} does not support Rails version < 3.0"
+end

data/lib/rack/session/dalli.rb

@@ -0,0 +1,52 @@
+require 'rack/session/abstract/id'
+require 'dalli'
+
+module Rack
+  module Session
+    class Dalli < Abstract::ID
+      attr_reader :pool
+
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+        :namespace => 'rack:session',
+        :memcache_server => 'localhost:11211'
+
+      def initialize(app, options={})
+        super
+        mserv = @default_options[:memcache_server]
+        mopts = @default_options.reject{|k,v| !MemCache::DEFAULT_OPTIONS.include? k }
+        @pool = options[:cache] || Dalli::Client.new(mserv, mopts)
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        unless sid and session = @pool.get(sid)
+          sid, session = generate_sid, {}
+          unless @pool.add(sid, session)
+            raise "Session collision on '#{sid.inspect}'"
+          end
+        end
+        [sid, session]
+      end
+
+      def set_session(env, session_id, new_session, options)
+        expiry = options[:expire_after]
+        expiry = expiry.nil? ? 0 : expiry + 1
+
+        @pool.set session_id, new_session, expiry
+        session_id
+      end
+
+      def destroy_session(env, session_id, options)
+        @pool.delete(session_id)
+        generate_sid unless options[:drop]
+      end
+
+    end
+  end
+end

data/mob-dalli.gemspec

@@ -0,0 +1,31 @@
+require './lib/dalli/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{mob-dalli}
+  s.version = Dalli::VERSION
+
+  s.authors = ["Mike Perham", "Aaron Daniel"]
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.description = %q{High performance memcached client for Ruby}
+  s.email = %q{mperham@gmail.com}
+  s.files = Dir.glob("lib/**/*") + [
+     "LICENSE",
+     "README.md",
+     "History.md",
+     "Rakefile",
+     "Gemfile",
+     "mob-dalli.gemspec",
+     "Performance.md",
+     "Upgrade.md",
+  ]
+  s.homepage = %q{http://github.com/amdtech/dalli}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.summary = %q{High performance memcached client for Ruby}
+  s.test_files = Dir.glob("test/**/*")
+  s.add_development_dependency(%q<shoulda>, [">= 0"])
+  s.add_development_dependency(%q<mocha>, [">= 0"])
+  s.add_development_dependency(%q<rails>, [">= 3.0.0"])
+  s.add_development_dependency(%q<memcache-client>, [">= 1.8.5"])
+end
+

data/test/abstract_unit.rb

@@ -0,0 +1,282 @@
+# Used to test the full Rails stack.
+# Stolen from the Rails 3.0 source.
+# Needed for the session store tests.
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/string/encoding'
+if "ruby".encoding_aware?
+  # These are the normal settings that will be set up by Railties
+  # TODO: Have these tests support other combinations of these values
+  silence_warnings do
+    Encoding.default_internal = "UTF-8"
+    Encoding.default_external = "UTF-8"
+  end
+end
+
+require 'test/unit'
+require 'abstract_controller'
+require 'action_controller'
+require 'action_view'
+require 'action_dispatch'
+require 'active_support/dependencies'
+require 'action_controller/caching'
+require 'action_controller/caching/sweeping'
+
+require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
+
+module Rails
+  def self.logger
+    @logger ||= begin
+      l = Logger.new(STDOUT)
+      l.level = Logger::INFO; l
+    end
+  end
+end
+
+# Monkey patch the old routes initialization to be silenced.
+class ActionDispatch::Routing::DeprecatedMapper
+  def initialize_with_silencer(*args)
+    ActiveSupport::Deprecation.silence { initialize_without_silencer(*args) }
+  end
+  alias_method_chain :initialize, :silencer
+end
+
+ActiveSupport::Dependencies.hook!
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
+
+module RackTestUtils
+  def body_to_string(body)
+    if body.respond_to?(:each)
+      str = ""
+      body.each {|s| str << s }
+      str
+    else
+      body
+    end
+  end
+  extend self
+end
+
+module SetupOnce
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :setup_once_block
+    self.setup_once_block = nil
+
+    setup :run_setup_once
+  end
+
+  module ClassMethods
+    def setup_once(&block)
+      self.setup_once_block = block
+    end
+  end
+
+  private
+    def run_setup_once
+      if self.setup_once_block
+        self.setup_once_block.call
+        self.setup_once_block = nil
+      end
+    end
+end
+
+SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+
+module ActiveSupport
+  class TestCase
+    include SetupOnce
+    # Hold off drawing routes until all the possible controller classes
+    # have been loaded.
+    setup_once do
+      SharedTestRoutes.draw do
+        match ':controller(/:action(/:id))'
+      end
+
+      ActionController::IntegrationTest.app.routes.draw do
+        match ':controller(/:action(/:id))'
+      end
+    end
+  end
+end
+
+class RoutedRackApp
+  attr_reader :routes
+
+  def initialize(routes, &blk)
+    @routes = routes
+    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
+  end
+
+  def call(env)
+    @stack.call(env)
+  end
+end
+
+class BasicController
+  attr_accessor :request
+
+  def config
+    @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config).tap do |config|
+      # VIEW TODO: View tests should not require a controller
+      public_dir = File.expand_path("../fixtures/public", __FILE__)
+      config.assets_dir = public_dir
+      config.javascripts_dir = "#{public_dir}/javascripts"
+      config.stylesheets_dir = "#{public_dir}/stylesheets"
+      config
+    end
+  end
+end
+
+class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
+  setup do
+    @routes = SharedTestRoutes
+  end
+end
+
+class ActionController::IntegrationTest < ActiveSupport::TestCase
+  def self.build_app(routes = nil)
+    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
+      middleware.use "ActionDispatch::ShowExceptions"
+      middleware.use "ActionDispatch::Callbacks"
+      middleware.use "ActionDispatch::ParamsParser"
+      middleware.use "ActionDispatch::Cookies"
+      middleware.use "ActionDispatch::Flash"
+      middleware.use "ActionDispatch::Head"
+      yield(middleware) if block_given?
+    end
+  end
+
+  self.app = build_app
+
+  # Stub Rails dispatcher so it does not get controller references and
+  # simply return the controller#action as Rack::Body.
+  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
+    protected
+    def controller_reference(controller_param)
+      controller_param
+    end
+
+    def dispatch(controller, action, env)
+      [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
+    end
+  end
+
+  def self.stub_controllers
+    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
+    yield ActionDispatch::Routing::RouteSet.new
+  ensure
+    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
+    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
+  end
+
+  def with_routing(&block)
+    temporary_routes = ActionDispatch::Routing::RouteSet.new
+    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
+    old_routes = SharedTestRoutes
+    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
+
+    yield temporary_routes
+  ensure
+    self.class.app = old_app
+    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
+  end
+
+  def with_autoload_path(path)
+    path = File.join(File.dirname(__FILE__), "fixtures", path)
+    if ActiveSupport::Dependencies.autoload_paths.include?(path)
+      yield
+    else
+      begin
+        ActiveSupport::Dependencies.autoload_paths << path
+        yield
+      ensure
+        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
+        ActiveSupport::Dependencies.clear
+      end
+    end
+  end
+end
+
+# Temporary base class
+class Rack::TestCase < ActionController::IntegrationTest
+  def self.testing(klass = nil)
+    if klass
+      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, '')
+    else
+      @testing
+    end
+  end
+
+  def get(thing, *args)
+    if thing.is_a?(Symbol)
+      super("#{self.class.testing}/#{thing}", *args)
+    else
+      super
+    end
+  end
+
+  def assert_body(body)
+    assert_equal body, Array.wrap(response.body).join
+  end
+
+  def assert_status(code)
+    assert_equal code, response.status
+  end
+
+  def assert_response(body, status = 200, headers = {})
+    assert_body   body
+    assert_status status
+    headers.each do |header, value|
+      assert_header header, value
+    end
+  end
+
+  def assert_content_type(type)
+    assert_equal type, response.headers["Content-Type"]
+  end
+
+  def assert_header(name, value)
+    assert_equal value, response.headers[name]
+  end
+end
+
+class ActionController::Base
+  def self.test_routes(&block)
+    routes = ActionDispatch::Routing::RouteSet.new
+    routes.draw(&block)
+    include routes.url_helpers
+  end
+end
+
+class ::ApplicationController < ActionController::Base
+end
+
+module ActionController
+  class Base
+    include ActionController::Testing
+  end
+
+  Base.view_paths = []
+
+  class TestCase
+    include ActionDispatch::TestProcess
+
+    setup do
+      @routes = SharedTestRoutes
+    end
+  end
+end
+
+# This stub emulates the Railtie including the URL helpers from a Rails application
+module ActionController
+  class Base
+    include SharedTestRoutes.url_helpers
+  end
+end