ruby-redis-portertech 0.0.3

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2011, David Turnbull et al
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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/README.md

@@ -0,0 +1,80 @@
+This project was started because I needed an authenticating and routable
+proxy for Redis.  The main feature is a high performance, eventable, pure Ruby
+implementation of the complete Redis wire protocol using the same interface as
+hiredis/reader.
+
+### Ruby Gem
+
+    # Best with Ruby 1.9.2; works with 1.8.7, JRuby, and Rubinius.
+    gem install ruby-redis
+    # Runs a server that looks and feels like the C redis-server
+    ruby-redis
+
+### Client example
+
+    require 'redis'
+    EventMachine.run {
+      redis = EventMachine.connect '127.0.0.1', 6379, Redis::Client
+      # Subscribe and publish messages will call here
+      redis.on_pubsub do |message|
+        # case message[0]
+        # when 'psubscribe' ...
+      end
+      # All commands implemented uniformly with method_missing
+      # Returns instance of Redis::Command < EventMachine::Deferrable 
+      # Pipelining is implicit
+      redis.set :pi, 3.14159
+      redis.get('pi') do |result|
+        p result
+      end
+      redis.blpop('mylist', 1).callback do |result|
+        p result
+        EM.stop
+      end.errback do |e|
+        EM.stop
+        raise e
+      end
+    }
+
+
+### Using hiredis/reader (only affects clients)
+
+    # require it before you connect
+    require 'hiredis/reader'
+
+### Fibers example (compatible with em-synchrony)
+
+    require 'redis/synchrony'
+    Redis.synchrony {
+      # Be sure to pipeline commands when you can
+      redis = EventMachine.connect '127.0.0.1', 6379, Redis::Client
+      # synchronized requests will return result or raise exception
+      sync = redis.synchrony
+      # repeat transaction until success
+      reply = check = nil
+      until reply
+        redis.watch 'mykey'
+        x = sync.get('mykey').to_i
+        redis.multi
+        redis.set 'mykey', x + 1
+        redis.badcmd
+        redis.get('mykey') {|result| check=result}
+        reply = sync.exec
+      end
+      redis.close
+      EM.stop
+      p reply, check # ["OK", #<RuntimeError>, "4"], "4"
+    }
+
+
+### Ruby to Redis type conversions
+
+          String === Status reply
+    RuntimeError === Error reply
+          String === Bulk reply
+         Integer === Integer reply
+           Array === Multi-bulk reply
+            Hash === Multi-bulk reply to hgetall
+        NilClass === Nil element or nil multi-bulk
+       TrueClass === :1
+      FalseClass === :0

data/bin/ruby-redis

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+begin
+  require 'rubygems'
+rescue LoadError
+end
+direct_bin_filename = File.expand_path '../lib/redis/bin', File.dirname(__FILE__)
+if File.exist? direct_bin_filename + '.rb'
+  require direct_bin_filename
+else
+  require 'redis/bin'
+end
+Redis::Bin.server

data/lib/redis.rb

@@ -0,0 +1,13 @@
+%w{redis/version redis/client}.each do |file|
+  require File.expand_path file, File.dirname(__FILE__)
+end
+
+module Redis
+  
+  # This space intentionally blank
+
+  # Server entry in redis/bin.rb
+  # Client entry in redis/client.rb
+  
+end
+

data/lib/redis/bin.rb

@@ -0,0 +1,127 @@
+%w{reader sender version config logger strict connection protocol database 
+   server keys strings lists sets zsets hashes pubsub}.each do |file|
+     require File.expand_path file, File.dirname(__FILE__)
+end
+
+module Redis
+  class Bin
+
+    class RubyRedisServer < EventMachine::Connection
+
+      include Strict
+      include Connection
+      include Protocol
+      include Sender
+      
+      def initialize logger, databases, config={}
+        @logger = logger
+        @databases = databases
+        @database = databases[0]
+        @config = config
+        super
+      end
+      
+      def post_init
+        authorized nil
+        set_comm_inactivity_timeout @config[:timeout]
+      end
+      
+      def authorized password
+        return true if @authorized
+        return false unless @config[:requirepass] == password
+        extend Server
+        extend Keys
+        extend Strings
+        extend Lists
+        extend Sets
+        extend ZSets
+        extend Hashes
+        extend PubSub
+        @authorized = true
+      end
+      
+    end
+    
+    def self.server
+
+      if ARGV==['-v'] or ARGV==['--version']
+        print "Redis server version %s (Ruby)\n" % Redis::VERSION
+        exit 0
+      end
+
+      if ARGV==['--help'] or ARGV.size > 1
+        STDERR.print "Usage: ruby-redis [/path/to/redis.conf]\n"
+        STDERR.print "       ruby-redis - (read config from stdin)\n"
+        exit 1
+      end
+
+      show_no_config_warning = (ARGV.size == 0)
+
+      config = Config.new(ARGV.empty? ? [] : ARGF)
+
+      Dir.chdir config[:dir]
+      
+      if config[:logfile] == 'stdout'
+        logger = Logger.new STDOUT
+      else
+        logger = Logger.new config[:logfile] 
+      end
+
+      if config[:loglevel] == 'debug'
+        logger.level = Logger::DEBUG
+      elsif config[:loglevel] == 'notice'
+        logger.level = Logger::NOTICE
+      elsif config[:loglevel] == 'warning'
+        logger.level = Logger::WARNING
+      elsif config[:loglevel] != 'verbose'
+        raise "Invalid log level. Must be one of debug, notice, warning, verbose."
+      else
+        logger.level = Logger::INFO
+      end
+
+      if show_no_config_warning
+        logger.warn "Warning: no config file specified, using the default config. In order to specify a config file use 'ruby-redis /path/to/redis.conf'"
+      end
+      
+      if config[:daemonize]
+        exit!(0) if fork
+        Process::setsid
+        exit!(0) if fork
+        STDIN.reopen("/dev/null")
+        STDOUT.reopen("/dev/null", "w")
+        STDERR.reopen("/dev/null", "w")
+        begin
+          File.open(config[:pidfile], 'w') do |io|
+            io.write "%d\n" % Process.pid
+          end
+          at_exit do
+            File.delete config[:pidfile] if File.exist? config[:pidfile]
+          end
+        rescue StandardError => e
+          logger.error e.message
+        end
+      end
+      
+      EventMachine.run {
+
+        databases = Array.new(config[:databases]) {Database.new}
+        started_message = "Server started, Ruby Redis version %s" % Redis::VERSION
+  
+        if config[:unixsocket]
+          EventMachine::start_server config[:unixsocket], RubyRedisServer, logger, databases, config
+          logger.notice started_message
+          logger.notice "The server is now ready to accept connections at %s" % config[:unixsocket]
+        else
+          EventMachine::start_server config[:bind], config[:port], RubyRedisServer, logger, databases, config
+          logger.notice started_message
+          logger.notice "The server is now ready to accept connections on port %d" % config[:port]
+        end
+        
+        # The test suite blocks until it gets the pid from the log.
+        logger.flush
+
+      }
+      
+    end
+  end
+end

data/lib/redis/client.rb

@@ -0,0 +1,213 @@
+require 'eventmachine'
+%w{reader sender}.each do |file|
+  require File.expand_path file, File.dirname(__FILE__)
+end
+
+module Redis
+  class Client < EventMachine::Connection
+
+    include Sender
+
+    class Command
+      include EventMachine::Deferrable
+      # EventMachine::Deferrable older than 1.0.0.beta.4 doesn't return self
+      # EventMachine::Completion doesn't return self in any version
+      test = self.new
+      unless self === test.callback{}
+        def callback; super; self; end
+        def errback; super; self; end
+      end
+    end
+
+    def initialize *ignore_args
+      if defined? Hiredis and defined? Hiredis::Reader
+        @reader = Hiredis::Reader.new
+      else
+        @reader = Reader.new
+      end
+      @queue = []
+      @multi = nil
+      @pubsub_callback = proc{}
+    end
+
+    def connection_completed
+      @connected = true
+      @port, @host = Socket.unpack_sockaddr_in(get_peername)
+    end
+
+    def close
+      @closing_connection = true
+      close_connection_after_writing
+    end
+
+    def unbind
+      unless !@connected || @closing_connection
+        EM.add_timer(1) do
+          reconnect(@host, @port)
+        end
+      else
+        until @queue.empty?
+          @queue.shift.fail RuntimeError.new 'connection closed'
+        end
+      end
+    end
+
+    # This is simple and fast but doesn't test for programming errors.
+    # Don't send non-pubsub commands while subscribed and you're fine.
+    # Subclass Client and/or create a defensive layer if you need to.
+    def on_pubsub &block
+      @pubsub_callback = block
+    end
+
+    def receive_data data
+      @reader.feed data
+      until (
+        begin
+          data = @reader.gets
+        rescue StandardError => e
+          @queue.shift.fail e unless @queue.empty?
+          close_connection
+          data = false
+        end
+      ) == false
+        deferrable = @queue.shift
+        if deferrable
+          if Exception === data
+            deferrable.fail data
+          else
+            deferrable.succeed data
+          end
+        else
+          @pubsub_callback.call data
+        end
+      end
+    end
+
+    def method_missing method, *args, &block
+      if @multi
+        for_queue = new_command true, false, method, *args
+        command = new_command false, true, method, &block
+        callback_multi = @multi
+        for_queue.callback do |status|
+          callback_multi << command
+        end
+        for_queue.errback do |err|
+          callback_multi << err
+          command.fail err
+        end
+      else
+        command = new_command true, true, method, *args, &block
+      end
+      command
+    end
+
+    def in_multi?
+      !!@multi
+    end
+
+    def multi *args, &block
+      @multi ||= []
+      new_command true, true, :multi, *args, &block
+    end
+
+    def exec *args, &block
+      redis_exec = new_command true, true, :exec, *args
+      callback_multi = @multi
+      @multi = nil
+      redis_exec.callback do |results|
+        if results
+          normalized_results = []
+          callback_multi.each do |command|
+            if Exception === command
+              normalized_results << command
+            else
+              result = results.shift
+              normalized_results << result
+              if Exception === result
+                command.fail result
+              else
+                command.succeed result
+              end
+            end
+          end
+          redis_exec.succeed normalized_results
+        end
+      end
+      redis_exec.callback &block if block_given?
+      redis_exec
+    end
+
+    # Some data is best transformed into a Ruby type.  You can set up global
+    # transforms here that are automatically attached to command callbacks.
+    #   Redis::Client.transforms[:mycustom1] = Redis::Client.transforms[:exists] # boolean
+    #   Redis::Client.transforms[:mycustom2] = proc { |data| MyType.new data }
+    #   Redis::Client.transforms.delete :hgetall # if you prefer the array
+    def self.transforms
+      @@transforms ||= lambda {
+        boolean = lambda { |tf| tf[0] == 1 ? true : false }
+        hash = lambda { |hash| Hash[*hash] }
+        pubsub = lambda { |msg| lambda { msg } }
+        {
+          #pubsub
+          :subscribe => pubsub,
+          :psubscribe => pubsub,
+          :unsubscribe => pubsub,
+          :punsubscribe => pubsub,
+          #keys
+          :exists => boolean,
+          :expire => boolean,
+          :expireat => boolean,
+          :move => boolean,
+          :persist => boolean,
+          :renamenx => boolean,
+          #strings
+          :msetnx => boolean,
+          :setnx => boolean,
+          #hashes
+          :hexists => boolean,
+          :hgetall => hash,
+          :hset => boolean,
+          :hsetnx => boolean,
+          #sets
+          :sismember => boolean,
+          :smove => boolean,
+          :srem => boolean,
+          #zsets
+          :zrem => boolean,
+        }
+      }.call
+    end
+
+    private
+
+    def new_command do_send, do_transform, method, *args, &block
+      command = Command.new
+      if do_send
+        send_redis args.reduce([method]){ |arr, arg|
+          if Hash === arg
+            arr += arg.to_a.flatten 1
+          else
+            arr << arg
+          end
+        }
+        @queue.push command
+      end
+      if do_transform
+        if transform = self.class.transforms[method]
+          command.callback do |data|
+            result = transform.call data
+            if Proc === result
+              command.succeed nil
+              @pubsub_callback.call result.call
+            else
+              command.succeed result
+            end
+          end
+        end
+      end
+      command.callback &block if block_given?
+      command
+    end
+
+  end
+end