classiccms 0.2.4.pre → 0.3.0

data/vendor/bundle/gems/redis-2.2.2/benchmarking/suite.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+def run_in_background(command)
+  fork { system command }
+end
+
+def with_all_segments(&block)
+  0.upto(9) do |segment_number|
+    block_size = 100000
+    start_index = segment_number * block_size
+    end_index = start_index + block_size - 1
+    block.call(start_index, end_index)
+  end
+end
+
+#with_all_segments do |start_index, end_index|
+#  puts "Initializing keys from #{start_index} to #{end_index}"
+#  system "ruby worker.rb initialize #{start_index} #{end_index} 0"
+#end
+
+with_all_segments do |start_index, end_index|
+  run_in_background "ruby worker.rb write #{start_index} #{end_index} 10"
+  run_in_background "ruby worker.rb read #{start_index} #{end_index} 1"
+end

data/vendor/bundle/gems/redis-2.2.2/benchmarking/thread_safety.rb

@@ -0,0 +1,38 @@
+# Run with
+#
+#   $ ruby -Ilib benchmarking/thread_safety.rb
+#
+
+begin
+  require "bench"
+rescue LoadError
+  $stderr.puts "`gem install bench` and try again."
+  exit 1
+end
+
+require "redis"
+
+def stress(redis)
+  redis.flushdb
+
+  n = (ARGV.shift || 2000).to_i
+
+  n.times do |i|
+    key = "foo:#{i}"
+    redis.set key, i
+    redis.get key
+  end
+end
+
+thread_unsafe = Redis.new(:thread_safe => false)
+thread_safe = Redis.new(:thread_safe => true)
+
+benchmark "Thread-unsafe" do
+  stress(thread_unsafe)
+end
+
+benchmark "Thread-safe" do
+  stress(thread_safe)
+end
+
+run 10

data/vendor/bundle/gems/redis-2.2.2/benchmarking/worker.rb

@@ -0,0 +1,71 @@
+BENCHMARK_ROOT = File.dirname(__FILE__)
+REDIS_ROOT = File.join(BENCHMARK_ROOT, "..", "lib")
+
+$: << REDIS_ROOT
+require 'redis'
+require 'benchmark'
+
+def show_usage
+  puts <<-EOL
+    Usage: worker.rb [read:write] <start_index> <end_index> <sleep_msec>
+  EOL
+end
+
+def shift_from_argv
+  value = ARGV.shift
+  unless value
+    show_usage
+    exit -1
+  end
+  value
+end
+
+operation = shift_from_argv.to_sym
+start_index = shift_from_argv.to_i
+end_index = shift_from_argv.to_i
+sleep_msec = shift_from_argv.to_i
+sleep_duration = sleep_msec/1000.0
+
+redis = Redis.new
+
+case operation
+  when :initialize
+
+    start_index.upto(end_index) do |i|
+      redis[i] = 0
+    end
+
+  when :clear
+
+    start_index.upto(end_index) do |i|
+      redis.delete(i)
+    end
+
+  when :read, :write
+
+    puts "Starting to #{operation} at segment #{end_index + 1}"
+
+    loop do
+      t1 = Time.now
+      start_index.upto(end_index) do |i|
+        case operation
+          when :read
+            redis.get(i)
+          when :write
+            redis.incr(i)
+          else
+            raise "Unknown operation: #{operation}"
+        end
+        sleep sleep_duration
+      end
+      t2 = Time.now
+
+      requests_processed = end_index - start_index
+      time = t2 - t1
+      puts "#{t2.strftime("%H:%M")} [segment #{end_index + 1}] : Processed #{requests_processed} requests in #{time} seconds - #{(requests_processed/time).round} requests/sec"
+    end
+
+  else
+    raise "Unknown operation: #{operation}"
+end
+

data/vendor/bundle/gems/redis-2.2.2/examples/basic.rb

@@ -0,0 +1,15 @@
+require 'redis'
+
+r = Redis.new
+
+r.del('foo')
+
+puts
+
+p'set foo to "bar"'
+r['foo'] = 'bar'
+
+puts
+
+p 'value of foo'
+p r['foo']

data/vendor/bundle/gems/redis-2.2.2/examples/dist_redis.rb

@@ -0,0 +1,43 @@
+require "redis"
+require "redis/distributed"
+
+r = Redis::Distributed.new %w[redis://localhost:6379 redis://localhost:6380 redis://localhost:6381 redis://localhost:6382]
+
+r.flushdb
+
+r['urmom'] = 'urmom'
+r['urdad'] = 'urdad'
+r['urmom1'] = 'urmom1'
+r['urdad1'] = 'urdad1'
+r['urmom2'] = 'urmom2'
+r['urdad2'] = 'urdad2'
+r['urmom3'] = 'urmom3'
+r['urdad3'] = 'urdad3'
+p r['urmom']
+p r['urdad']
+p r['urmom1']
+p r['urdad1']
+p r['urmom2']
+p r['urdad2']
+p r['urmom3']
+p r['urdad3']
+
+r.rpush 'listor', 'foo1'
+r.rpush 'listor', 'foo2'
+r.rpush 'listor', 'foo3'
+r.rpush 'listor', 'foo4'
+r.rpush 'listor', 'foo5'
+
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+
+puts "key distribution:"
+
+r.ring.nodes.each do |node|
+  p [node.client, node.keys("*")]
+end
+r.flushdb
+p r.keys('*')

data/vendor/bundle/gems/redis-2.2.2/examples/incr-decr.rb

@@ -0,0 +1,17 @@
+require 'redis'
+
+r = Redis.new
+
+puts
+p 'incr'
+r.del 'counter'
+
+p r.incr('counter')
+p r.incr('counter')
+p r.incr('counter')
+
+puts
+p 'decr'
+p r.decr('counter')
+p r.decr('counter')
+p r.decr('counter')

data/vendor/bundle/gems/redis-2.2.2/examples/list.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+r.del 'logs'
+
+puts
+
+p "pushing log messages into a LIST"
+r.rpush 'logs', 'some log message'
+r.rpush 'logs', 'another log message'
+r.rpush 'logs', 'yet another log message'
+r.rpush 'logs', 'also another log message'
+
+puts
+p 'contents of logs LIST'
+
+p r.lrange('logs', 0, -1)
+
+puts
+p 'Trim logs LIST to last 2 elements(easy circular buffer)'
+
+r.ltrim('logs', -2, -1)
+
+p r.lrange('logs', 0, -1)

data/vendor/bundle/gems/redis-2.2.2/examples/pubsub.rb

@@ -0,0 +1,31 @@
+require "redis"
+
+puts <<-EOS
+To play with this example use redis-cli from another terminal, like this:
+
+  $ redis-cli publish one hello
+
+Finally force the example to exit sending the 'exit' message with:
+
+  $ redis-cli publish two exit
+
+EOS
+
+redis = Redis.connect
+
+trap(:INT) { puts; exit }
+
+redis.subscribe(:one, :two) do |on|
+  on.subscribe do |channel, subscriptions|
+    puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+  end
+
+  on.message do |channel, message|
+    puts "##{channel}: #{message}"
+    redis.unsubscribe if message == "exit"
+  end
+
+  on.unsubscribe do |channel, subscriptions|
+    puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+  end
+end

data/vendor/bundle/gems/redis-2.2.2/examples/sets.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+r.del 'foo-tags'
+r.del 'bar-tags'
+
+puts
+p "create a set of tags on foo-tags"
+
+r.sadd 'foo-tags', 'one'
+r.sadd 'foo-tags', 'two'
+r.sadd 'foo-tags', 'three'
+
+puts
+p "create a set of tags on bar-tags"
+
+r.sadd 'bar-tags', 'three'
+r.sadd 'bar-tags', 'four'
+r.sadd 'bar-tags', 'five'
+
+puts
+p 'foo-tags'
+
+p r.smembers('foo-tags')
+
+puts
+p 'bar-tags'
+
+p r.smembers('bar-tags')
+
+puts
+p 'intersection of foo-tags and bar-tags'
+
+p r.sinter('foo-tags', 'bar-tags')

data/vendor/bundle/gems/redis-2.2.2/examples/unicorn/config.ru

@@ -0,0 +1,3 @@
+run lambda { |env|
+  [200, {"Content-Type" => "text/plain"}, [$redis.randomkey]]
+}

data/vendor/bundle/gems/redis-2.2.2/examples/unicorn/unicorn.rb

@@ -0,0 +1,20 @@
+require "redis"
+
+worker_processes 3
+
+# If you set the connection to Redis *before* forking,
+# you will cause forks to share a file descriptor.
+#
+# This causes a concurrency problem by which one fork
+# can read or write to the socket while others are
+# performing other operations.
+#
+# Most likely you'll be getting ProtocolError exceptions
+# mentioning a wrong initial byte in the reply.
+#
+# Thus we need to connect to Redis after forking the
+# worker processes.
+
+after_fork do |server, worker|
+  $redis = Redis.connect
+end

data/vendor/bundle/gems/redis-2.2.2/lib/redis/client.rb

@@ -0,0 +1,265 @@
+class Redis
+  class Client
+    attr_accessor :db, :host, :port, :path, :password, :logger
+    attr :timeout
+    attr :connection
+
+    def initialize(options = {})
+      @path = options[:path]
+      if @path.nil?
+        @host = options[:host] || "127.0.0.1"
+        @port = (options[:port] || 6379).to_i
+      end
+
+      @db = (options[:db] || 0).to_i
+      @timeout = (options[:timeout] || 5).to_f
+      @password = options[:password]
+      @logger = options[:logger]
+      @reconnect = true
+      @connection = Connection.drivers.last.new
+    end
+
+    def connect
+      establish_connection
+      call [:auth, @password] if @password
+      call [:select, @db] if @db != 0
+      self
+    end
+
+    def id
+      "redis://#{location}/#{db}"
+    end
+
+    def location
+      @path || "#{@host}:#{@port}"
+    end
+
+    # Starting with 2.2.1, assume that this method is called with a single
+    # array argument. Check its size for backwards compat.
+    def call(*args)
+      if args.first.is_a?(Array) && args.size == 1
+        command = args.first
+      else
+        command = args
+      end
+
+      reply = process([command]) { read }
+      raise reply if reply.is_a?(RuntimeError)
+      reply
+    end
+
+    # Assume that this method is called with a single array argument. No
+    # backwards compat here, since it was introduced in 2.2.2.
+    def call_without_reply(command)
+      process([command])
+      nil
+    end
+
+    # Starting with 2.2.1, assume that this method is called with a single
+    # array argument. Check its size for backwards compat.
+    def call_loop(*args)
+      if args.first.is_a?(Array) && args.size == 1
+        command = args.first
+      else
+        command = args
+      end
+
+      error = nil
+
+      result = without_socket_timeout do
+        process([command]) do
+          loop do
+            reply = read
+            if reply.is_a?(RuntimeError)
+              error = reply
+              break
+            else
+              yield reply
+            end
+          end
+        end
+      end
+
+      # Raise error when previous block broke out of the loop.
+      raise error if error
+
+      # Result is set to the value that the provided block used to break.
+      result
+    end
+
+    def call_pipelined(commands, options = {})
+      options[:raise] = true unless options.has_key?(:raise)
+
+      # The method #ensure_connected (called from #process) reconnects once on
+      # I/O errors. To make an effort in making sure that commands are not
+      # executed more than once, only allow reconnection before the first reply
+      # has been read. When an error occurs after the first reply has been
+      # read, retrying would re-execute the entire pipeline, thus re-issueing
+      # already succesfully executed commands. To circumvent this, don't retry
+      # after the first reply has been read succesfully.
+      first = process(commands) { read }
+      error = first if first.is_a?(RuntimeError)
+
+      begin
+        remaining = commands.size - 1
+        if remaining > 0
+          replies = Array.new(remaining) do
+            reply = read
+            error ||= reply if reply.is_a?(RuntimeError)
+            reply
+          end
+          replies.unshift first
+          replies
+        else
+          replies = [first]
+        end
+      rescue Exception
+        disconnect
+        raise
+      end
+
+      # Raise first error in pipeline when we should raise.
+      raise error if error && options[:raise]
+
+      replies
+    end
+
+    def call_without_timeout(*args)
+      without_socket_timeout do
+        call(*args)
+      end
+    rescue Errno::ECONNRESET
+      retry
+    end
+
+    def process(commands)
+      logging(commands) do
+        ensure_connected do
+          commands.each do |command|
+            connection.write(command)
+          end
+
+          yield if block_given?
+        end
+      end
+    end
+
+    def connected?
+      connection.connected?
+    end
+
+    def disconnect
+      connection.disconnect if connection.connected?
+    end
+
+    def reconnect
+      disconnect
+      connect
+    end
+
+    def read
+      begin
+        connection.read
+
+      rescue Errno::EAGAIN
+        # We want to make sure it reconnects on the next command after the
+        # timeout. Otherwise the server may reply in the meantime leaving
+        # the protocol in a desync status.
+        disconnect
+
+        raise Errno::EAGAIN, "Timeout reading from the socket"
+
+      rescue Errno::ECONNRESET
+        raise Errno::ECONNRESET, "Connection lost"
+      end
+    end
+
+    def without_socket_timeout
+      connect unless connected?
+
+      begin
+        self.timeout = 0
+        yield
+      ensure
+        self.timeout = @timeout if connected?
+      end
+    end
+
+    def without_reconnect
+      begin
+        original, @reconnect = @reconnect, false
+        yield
+      ensure
+        @reconnect = original
+      end
+    end
+
+  protected
+
+    def deprecated(old, new = nil, trace = caller[0])
+      message = "The method #{old} is deprecated and will be removed in 2.0"
+      message << " - use #{new} instead" if new
+      Redis.deprecate(message, trace)
+    end
+
+    def logging(commands)
+      return yield unless @logger && @logger.debug?
+
+      begin
+        commands.each do |name, *args|
+          @logger.debug("Redis >> #{name.to_s.upcase} #{args.join(" ")}")
+        end
+
+        t1 = Time.now
+        yield
+      ensure
+        @logger.debug("Redis >> %0.2fms" % ((Time.now - t1) * 1000))
+      end
+    end
+
+    def establish_connection
+      # Need timeout in usecs, like socket timeout.
+      timeout = Integer(@timeout * 1_000_000)
+
+      if @path
+        connection.connect_unix(@path, timeout)
+      else
+        connection.connect(@host, @port, timeout)
+      end
+
+      # If the timeout is set we set the low level socket options in order
+      # to make sure a blocking read will return after the specified number
+      # of seconds. This hack is from memcached ruby client.
+      self.timeout = @timeout
+
+    rescue Errno::ECONNREFUSED
+      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{location}"
+    end
+
+    def timeout=(timeout)
+      connection.timeout = Integer(timeout * 1_000_000)
+    end
+
+    def ensure_connected
+      tries = 0
+
+      begin
+        connect unless connected?
+        tries += 1
+
+        yield
+      rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL
+        disconnect
+
+        if tries < 2 && @reconnect
+          retry
+        else
+          raise Errno::ECONNRESET
+        end
+      rescue Exception
+        disconnect
+        raise
+      end
+    end
+  end
+end

data/vendor/bundle/gems/redis-2.2.2/lib/redis/compat.rb

@@ -0,0 +1,21 @@
+# This file contains core methods that are present in
+# Ruby 1.9 and not in earlier versions.
+
+unless [].respond_to?(:product)
+  class Array
+    def product(*enums)
+      enums.unshift self
+      result = [[]]
+      while [] != enums
+        t, result = result, []
+        b, *enums = enums
+        t.each do |a|
+          b.each do |n|
+            result << a + [n]
+          end
+        end
+      end
+      result
+    end
+  end
+end

data/vendor/bundle/gems/redis-2.2.2/lib/redis/connection/command_helper.rb

@@ -0,0 +1,45 @@
+class Redis
+  module Connection
+    module CommandHelper
+
+      COMMAND_DELIMITER = "\r\n"
+
+      def build_command(args)
+        command = []
+        command << "*#{args.size}"
+
+        args.each do |arg|
+          arg = arg.to_s
+          command << "$#{string_size arg}"
+          command << arg
+        end
+
+        # Trailing delimiter
+        command << ""
+        command.join(COMMAND_DELIMITER)
+      end
+
+    protected
+
+      if "".respond_to?(:bytesize)
+        def string_size(string)
+          string.to_s.bytesize
+        end
+      else
+        def string_size(string)
+          string.to_s.size
+        end
+      end
+
+      if defined?(Encoding::default_external)
+        def encode(string)
+          string.force_encoding(Encoding::default_external)
+        end
+      else
+        def encode(string)
+          string
+        end
+      end
+    end
+  end
+end