jashmenn-dalli 1.0.3

data/lib/dalli/socket.rb

@@ -0,0 +1,37 @@
+    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

data/lib/dalli/version.rb

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

data/test/abstract_unit.rb

@@ -0,0 +1,284 @@
+# 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 |map|
+        # FIXME: match ':controller(/:action(/:id))'
+        map.connect ':controller/:action/:id'
+      end
+
+      ActionController::IntegrationTest.app.routes.draw do |map|
+        # FIXME: match ':controller(/:action(/:id))'
+        map.connect ':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

data/test/benchmark_test.rb

@@ -0,0 +1,170 @@
+require 'helper'
+require 'benchmark'
+
+class TestBenchmark < Test::Unit::TestCase
+
+  def setup
+    puts "Testing #{Dalli::VERSION} with #{RUBY_DESCRIPTION}"
+    # We'll use a simple @value to try to avoid spending time in Marshal,
+    # which is a constant penalty that both clients have to pay
+    @value = []
+    @marshalled = Marshal.dump(@value)
+
+    @servers = ['127.0.0.1:19122', 'localhost:19122']
+    @key1 = "Short"
+    @key2 = "Sym1-2-3::45"*8
+    @key3 = "Long"*40
+    @key4 = "Medium"*8
+    # 5 and 6 are only used for multiget miss test
+    @key5 = "Medium2"*8
+    @key6 = "Long3"*40
+    @counter = 'counter'
+  end
+  
+  def test_benchmark
+    memcached do
+    
+      Benchmark.bm(31) do |x|
+
+        n = 2500
+
+        @m = Dalli::Client.new(@servers)
+        x.report("set:plain:dalli") do
+          n.times do
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("setq:plain:dalli") do
+          @m.multi do
+            n.times do
+              @m.set @key1, @marshalled, 0, :raw => true
+              @m.set @key2, @marshalled, 0, :raw => true
+              @m.set @key3, @marshalled, 0, :raw => true
+              @m.set @key1, @marshalled, 0, :raw => true
+              @m.set @key2, @marshalled, 0, :raw => true
+              @m.set @key3, @marshalled, 0, :raw => true
+            end
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("set:ruby:dalli") do
+          n.times do
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("get:plain:dalli") do
+          n.times do
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("get:ruby:dalli") do
+          n.times do
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("multiget:ruby:dalli") do
+          n.times do
+            # We don't use the keys array because splat is slow
+            @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("missing:ruby:dalli") do
+          n.times do
+            begin @m.delete @key1; rescue; end
+            begin @m.get @key1; rescue; end
+            begin @m.delete @key2; rescue; end
+            begin @m.get @key2; rescue; end
+            begin @m.delete @key3; rescue; end
+            begin @m.get @key3; rescue; end
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("mixed:ruby:dalli") do
+          n.times do
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+            @m.set @key1, @value
+            @m.get @key1
+            @m.set @key2, @value
+            @m.get @key2
+            @m.set @key3, @value
+            @m.get @key3
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("mixedq:ruby:dalli") do
+          @m.multi do
+            n.times do
+              @m.set @key1, @value
+              @m.set @key2, @value
+              @m.set @key3, @value
+              @m.get @key1
+              @m.get @key2
+              @m.get @key3
+              @m.set @key1, @value
+              @m.get @key1
+              @m.set @key2, @value
+              @m.replace @key2, @value
+              @m.delete @key3
+              @m.add @key3, @value
+              @m.get @key2
+              @m.set @key3, @value
+              @m.get @key3
+            end
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("incr:ruby:dalli") do
+          n.times do
+            @m.incr @counter, 1, 0, 1
+          end
+          n.times do
+            @m.decr @counter, 1
+          end
+
+          assert_equal 0, @m.incr(@counter, 0)
+        end
+
+      end
+    end
+
+  end
+end