lunar 0.4.1 → 0.5.0

data/vendor/redis/benchmarking/worker.rb

@@ -1,71 +0,0 @@
-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/redis/bin/distredis

@@ -1,33 +0,0 @@
-require 'fileutils'
-
-class RedisCluster
-  
-  def initialize(opts={})
-    opts = {:port => 6379, :host => 'localhost', :basedir => "#{Dir.pwd}/rdsrv" }.merge(opts)
-    FileUtils.mkdir_p opts[:basedir]
-    opts[:size].times do |i|
-      port = opts[:port] + i
-      FileUtils.mkdir_p "#{opts[:basedir]}/#{port}"
-      File.open("#{opts[:basedir]}/#{port}.conf", 'w'){|f| f.write(make_config(port, "#{opts[:basedir]}/#{port}", "#{opts[:basedir]}/#{port}.log"))}
-      system(%Q{#{File.join(File.expand_path(File.dirname(__FILE__)), "../redis/redis-server #{opts[:basedir]}/#{port}.conf &" )}})
-    end  
-  end
-
-  def make_config(port=6379, data=port, logfile='stdout', loglevel='debug')
-    config = %Q{
-timeout 300
-save 900 1
-save 300 10
-save 60 10000
-dir #{data}
-loglevel #{loglevel}
-logfile #{logfile}
-databases 16
-port #{port}
-    }
-  end
-  
-end
-
-
-RedisCluster.new :size => 4

data/vendor/redis/examples/basic.rb

@@ -1,15 +0,0 @@
-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/redis/examples/dist_redis.rb

@@ -1,43 +0,0 @@
-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/redis/examples/incr-decr.rb

@@ -1,17 +0,0 @@
-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/redis/examples/list.rb

@@ -1,26 +0,0 @@
-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/redis/examples/pubsub.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-require 'redis'
-
-puts "To play with this example use redis-cli from another terminal, like this:"
-puts "  ./redis-cli publish one hello"
-puts "Finally force the example to exit sending the 'exit' message with"
-puts "  ./redis-cli publish two exit"
-puts ""
-
-@redis = Redis.new(:timeout => 0)
-
-@redis.subscribe('one','two') do |on|
-  on.subscribe {|klass, num_subs| puts "Subscribed to #{klass} (#{num_subs} subscriptions)" }
-  on.message do |klass, msg| 
-    puts "#{klass} received: #{msg}"
-    if msg == 'exit'
-      @redis.unsubscribe
-    end
-  end
-  on.unsubscribe {|klass, num_subs| puts "Unsubscribed to #{klass} (#{num_subs} subscriptions)" }
-end
-
-
-
-

data/vendor/redis/examples/sets.rb

@@ -1,36 +0,0 @@
-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/redis/lib/edis.rb

@@ -1,3 +0,0 @@
-# This file allows for the running of redis-rb with a nice
-# command line look-and-feel: irb -rubygems -redis foo.rb
-require 'redis'

data/vendor/redis/lib/redis.rb

@@ -1,496 +0,0 @@
-require 'socket'
-
-class Redis
-  VERSION = "2.0.0.rc2"
-
-  class ProtocolError < RuntimeError
-    def initialize(reply_type)
-      super("Protocol error, got '#{reply_type}' as initial reply byte")
-    end
-  end
-
-  def self.deprecate(message, trace = caller[0])
-    $stderr.puts "\n#{message} (in #{trace})"
-  end
-
-  attr :client
-
-  def self.connect(options = {})
-    require "uri"
-
-    url = URI(options.delete(:url) || ENV["REDIS_URL"] || "redis://127.0.0.1:6379/0")
-
-    options[:host]     = url.host
-    options[:port]     = url.port
-    options[:password] = url.password
-    options[:db]       = url.path[1..-1].to_i
-
-    new(options)
-  end
-
-  def initialize(options = {})
-    @client = Client.new(options)
-  end
-
-  def select(db)
-    @client.db = db
-    @client.call(:select, db)
-  end
-
-  def info
-    Hash[*@client.call(:info).split(/:|\r\n/)]
-  end
-
-  def flushdb
-    @client.call(:flushdb)
-  end
-
-  def save
-    @client.call(:save)
-  end
-
-  def bgsave
-    @client.call(:bgsave)
-  end
-
-  def get(key)
-    @client.call(:get, key)
-  end
-
-  def getset(key, value)
-    @client.call(:getset, key, value)
-  end
-
-  def mget(*keys)
-    @client.call(:mget, *keys)
-  end
-
-  def hgetall(key)
-    Hash[*@client.call(:hgetall, key)]
-  end
-
-  def hget(key, field)
-    @client.call(:hget, key, field)
-  end
-
-  def hdel(key, field)
-    @client.call(:hdel, key, field)
-  end
-
-  def hkeys(key)
-    @client.call(:hkeys, key)
-  end
-
-  def keys(pattern = "*")
-    @client.call(:keys, pattern)
-  end
-
-  def randomkey
-    @client.call(:randomkey)
-  end
-
-  def echo(value)
-    @client.call(:echo, value)
-  end
-
-  def ping
-    @client.call(:ping)
-  end
-
-  def lastsave
-    @client.call(:lastsave)
-  end
-
-  def dbsize
-    @client.call(:dbsize)
-  end
-
-  def exists(key)
-    _bool @client.call(:exists, key)
-  end
-
-  def llen(key)
-    @client.call(:llen, key)
-  end
-
-  def lrange(key, start, stop)
-    @client.call(:lrange, key, start, stop)
-  end
-
-  def ltrim(key, start, stop)
-    @client.call(:ltrim, key, start, stop)
-  end
-
-  def lindex(key, index)
-    @client.call(:lindex, key, index)
-  end
-
-  def lset(key, index, value)
-    @client.call(:lset, key, index, value)
-  end
-
-  def lrem(key, count, value)
-    @client.call(:lrem, key, count, value)
-  end
-
-  def rpush(key, value)
-    @client.call(:rpush, key, value)
-  end
-
-  def lpush(key, value)
-    @client.call(:lpush, key, value)
-  end
-
-  def rpop(key)
-    @client.call(:rpop, key)
-  end
-
-  def blpop(key, timeout)
-    @client.call_without_timeout(:blpop, key, timeout)
-  end
-
-  def brpop(key, timeout)
-    @client.call_without_timeout(:brpop, key, timeout)
-  end
-
-  def rpoplpush(source, destination)
-    @client.call(:rpoplpush, source, destination)
-  end
-
-  def lpop(key)
-    @client.call(:lpop, key)
-  end
-
-  def smembers(key)
-    @client.call(:smembers, key)
-  end
-
-  def sismember(key, member)
-    _bool @client.call(:sismember, key, member)
-  end
-
-  def sadd(key, value)
-    _bool @client.call(:sadd, key, value)
-  end
-
-  def srem(key, value)
-    _bool @client.call(:srem, key, value)
-  end
-
-  def smove(source, destination, member)
-    _bool @client.call(:smove, source, destination, member)
-  end
-
-  def spop(key)
-    @client.call(:spop, key)
-  end
-
-  def scard(key)
-    @client.call(:scard, key)
-  end
-
-  def sinter(*keys)
-    @client.call(:sinter, *keys)
-  end
-
-  def sinterstore(destination, *keys)
-    @client.call(:sinterstore, destination, *keys)
-  end
-
-  def sunion(*keys)
-    @client.call(:sunion, *keys)
-  end
-
-  def sunionstore(destination, *keys)
-    @client.call(:sunionstore, destination, *keys)
-  end
-
-  def sdiff(*keys)
-    @client.call(:sdiff, *keys)
-  end
-
-  def sdiffstore(destination, *keys)
-    @client.call(:sdiffstore, destination, *keys)
-  end
-
-  def srandmember(key)
-    @client.call(:srandmember, key)
-  end
-
-  def zadd(key, score, member)
-    _bool @client.call(:zadd, key, score, member)
-  end
-
-  def zincrby(key, increment, member)
-    @client.call(:zincrby, key, increment, member)
-  end
-
-  def zcard(key)
-    @client.call(:zcard, key)
-  end
-
-  def zrange(key, start, stop, with_scores = false)
-    if with_scores
-      @client.call(:zrange, key, start, stop, "WITHSCORES")
-    else
-      @client.call(:zrange, key, start, stop)
-    end
-  end
-
-  def zrangebyscore(key, min, max)
-    @client.call(:zrangebyscore, key, min, max)
-  end
-
-  def zrevrange(key, start, stop, with_scores = false)
-    if with_scores
-      @client.call(:zrevrange, key, start, stop, "WITHSCORES")
-    else
-      @client.call(:zrevrange, key, start, stop)
-    end
-  end
-
-  def zscore(key, member)
-    @client.call(:zscore, key, member)
-  end
-
-  def zrem(key, member)
-    _bool @client.call(:zrem, key, member)
-  end
-
-  def move(key, db)
-    _bool @client.call(:move, key, db)
-  end
-
-  def setnx(key, value)
-    _bool @client.call(:setnx, key, value)
-  end
-
-  def del(*keys)
-    _bool @client.call(:del, *keys)
-  end
-
-  def rename(old_name, new_name)
-    @client.call(:rename, old_name, new_name)
-  end
-
-  def renamenx(old_name, new_name)
-    _bool @client.call(:renamenx, old_name, new_name)
-  end
-
-  def expire(key, seconds)
-    _bool @client.call(:expire, key, seconds)
-  end
-
-  def ttl(key)
-    @client.call(:ttl, key)
-  end
-
-  def expireat(key, unix_time)
-    _bool @client.call(:expireat, key, unix_time)
-  end
-
-  def hset(key, field, value)
-    _bool @client.call(:hset, key, field, value)
-  end
-
-  def hmset(key, *attrs)
-    @client.call(:hmset, key, *attrs)
-  end
-
-  def hlen(key)
-    @client.call(:hlen, key)
-  end
-
-  def hvals(key)
-    @client.call(:hvals, key)
-  end
-
-  def discard
-    @client.call(:discard)
-  end
-
-  def hexists(key, field)
-    _bool @client.call(:hexists, key, field)
-  end
-
-  def monitor
-    raise NotImplementedError
-  end
-
-  def [](key)
-    get(key)
-  end
-
-  def []=(key,value)
-    set(key, value)
-  end
-
-  def set(key, value)
-    @client.call(:set, key, value)
-  end
-
-  def setex(key, ttl, value)
-    @client.call(:setex, key, ttl, value)
-  end
-
-  def mset(*args)
-    @client.call(:mset, *args)
-  end
-
-  def mapped_mset(hash)
-    mset(*hash.to_a.flatten)
-  end
-
-  def msetnx(*args)
-    @client.call(:msetnx, *args)
-  end
-
-  def mapped_msetnx(hash)
-    msetnx(*hash.to_a.flatten)
-  end
-
-  def mapped_mget(*keys)
-    result = {}
-    mget(*keys).each do |value|
-      key = keys.shift
-      result.merge!(key => value) unless value.nil?
-    end
-    result
-  end
-
-  def sort(key, options = {})
-    cmd = []
-    cmd << "SORT"
-    cmd << key
-    cmd += ["BY", options[:by]] if options[:by]
-
-    Array(options[:get]).each do |k|
-      cmd += ["GET", k]
-    end if options[:get]
-
-    cmd += options[:order].split(" ") if options[:order]
-    cmd += ["LIMIT", *options[:limit]] if options[:limit]
-    cmd += ["STORE", options[:store]] if options[:store]
-
-    @client.call(*cmd)
-  end
-
-  def incr(key)
-    @client.call(:incr, key)
-  end
-
-  def incrby(key, increment)
-    @client.call(:incrby, key, increment)
-  end
-
-  def decr(key)
-    @client.call(:decr, key)
-  end
-
-  def decrby(key, decrement)
-    @client.call(:decrby, key, decrement)
-  end
-
-  def type(key)
-    @client.call(:type, key)
-  end
-
-  def quit
-    @client.call(:quit)
-  rescue Errno::ECONNRESET
-  end
-
-  def pipelined
-    original, @client = @client, Pipeline.new
-    yield
-    original.call_pipelined(@client.commands) unless @client.commands.empty?
-  ensure
-    @client = original
-  end
-
-  def exec
-    @client.call(:exec)
-  end
-
-  def multi(&block)
-    result = @client.call :multi
-
-    return result unless block_given?
-
-    begin
-      yield(self)
-      exec
-    rescue Exception => e
-      discard
-      raise e
-    end
-  end
-
-  def publish(channel, message)
-    @client.call(:publish, channel, message)
-  end
-
-  def subscribed?
-    @client.kind_of? SubscribedClient
-  end
-
-  def unsubscribe(*channels)
-    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
-    @client.unsubscribe(*channels)
-  end
-
-  def punsubscribe(*channels)
-    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
-    @client.punsubscribe(*channels)
-  end
-
-  def subscribe(*channels, &block)
-    subscription(:subscribe, channels, block)
-  end
-
-  def psubscribe(*channels, &block)
-    subscription(:psubscribe, channels, block)
-  end
-
-  def id
-    @client.id
-  end
-
-  def method_missing(command, *args)
-    @client.call(command, *args)
-  end
-
-private
-
-  def _bool(value)
-    value == 1
-  end
-
-  def subscription(method, channels, block)
-    return @client.call(method, *channels) if subscribed?
-
-    begin
-      original, @client = @client, SubscribedClient.new(@client)
-      @client.send(method, *channels, &block)
-    ensure
-      @client = original
-    end
-  end
-
-end
-
-begin
-  if RUBY_VERSION >= '1.9'
-    require 'timeout'
-    Redis::Timer = Timeout
-  else
-    require 'system_timer'
-    Redis::Timer = SystemTimer
-  end
-rescue LoadError
-  Redis::Timer = nil
-end
-
-require 'redis/client'
-require 'redis/pipeline'
-require 'redis/subscribe'