ruby-redis-portertech 0.0.3

data/lib/redis/logger.rb

@@ -0,0 +1,69 @@
+require 'logger'
+
+module Redis
+  class Logger < ::Logger
+
+    # Redis levels are: DEBUG < INFO < NOTICE < WARNING
+    # This logger inserts support for NOTICE
+    
+    def initialize(logdev, *args)
+      super
+      @raw_logdev = logdev
+      @default_formatter = proc { |severity, datetime, progname, msg|
+        mark = case severity
+        when 'DEBUG' then '.'
+        when 'INFO' then '-'
+        when 'NOTE' then '*'
+        when 'WARN' then '#'
+        else '!'
+        end
+        "[#{Process.pid}] #{datetime.strftime '%d %b %H:%H:%S'} #{mark} #{msg}\n"
+      }
+    end
+    
+    def flush
+      @raw_logdev.flush if @raw_logdev.respond_to? :flush
+    end
+    
+    module Severity
+      # logger.rb says "max 5 char" for labels
+      SEV_LABEL = %w(DEBUG INFO NOTE WARN ERROR FATAL ANY)
+      DEBUG = 0
+      INFO = 1
+      NOTICE = 2
+      WARN = 3
+      ERROR = 4
+      FATAL = 5
+      UNKNOWN = 6
+    end
+    include Severity
+
+    def notice(progname = nil, &block)
+      add(NOTICE, nil, progname, &block)
+    end
+    def warn(progname = nil, &block)
+      add(WARN, nil, progname, &block)
+    end
+    def error(progname = nil, &block)
+      add(ERROR, nil, progname, &block)
+    end
+    def fatal(progname = nil, &block)
+      add(FATAL, nil, progname, &block)
+    end
+    def unknown(progname = nil, &block)
+      add(UNKNOWN, nil, progname, &block)
+    end
+    
+    def notice?; @level <= NOTICE; end
+    def warn?; @level <= WARN; end
+    def error?; @level <= ERROR; end
+    def fatal?; @level <= FATAL; end
+        
+    private
+    
+    def format_severity(severity)
+      SEV_LABEL[severity] || 'ANY'
+    end
+    
+  end
+end

data/lib/redis/protocol.rb

@@ -0,0 +1,107 @@
+module Redis
+  module Protocol
+    
+    def initialize *args
+      @reader = Reader.new
+      @multi = nil
+      @deferred = nil
+      @watcher = nil
+      super
+    end
+    
+    def unbind
+      @deferred.unbind if @deferred
+      @watcher.unbind if @watcher
+      super
+    end
+    
+    # Process incoming redis protocol
+    def receive_data data
+      return unless @reader
+      @reader.feed data
+      until (strings = @reader.gets) == false
+        if @multi and !%w{WATCH DISCARD MULTI EXEC DEBUG}.include?(strings[0].upcase)
+          @multi << strings
+          send_redis :'+QUEUED'
+        else
+          result = __send__ "redis_#{strings[0].upcase}", *strings[1..-1]
+          if Integer === result
+            send_data ":#{result}\r\n"
+          elsif EventMachine::Deferrable === result
+            @deferred.unbind if @deferred and @deferred != result
+            @deferred = result
+          elsif result == :quit
+            @reader = nil
+            close_connection_after_writing
+            break
+          elsif result != :exec
+            send_redis result
+          end
+        end
+      end
+    rescue StandardError, LoadError, SyntaxError => e
+      # This sometimes comes in handy for the TCL tests
+      # @logger.warn "#{e.class}:/#{e.backtrace[0]} #{e.message}"
+      # e.backtrace[1..-1].each {|bt| @logger.warn bt}
+      send_data "-ERR #{e.class.name}: #{e.message}\r\n" 
+    end
+
+    def redis_WATCH *keys
+      raise 'WATCH inside MULTI is not allowed' if @multi
+      @watcher ||= Database::Watcher.new
+      @watcher.bind @database, *keys
+      :'+OK'
+    end
+    
+    def redis_UNWATCH
+      if @watcher
+        @watcher.unbind
+        @watcher = nil
+      end
+      :'+OK'
+    end
+
+    def redis_MULTI
+      raise 'MULTI nesting not allowed' if @multi
+      @multi = []
+      :'+OK'
+    end
+    
+    def redis_DISCARD
+      redis_UNWATCH
+      @multi = nil
+      :'+OK'
+    end
+
+    def redis_EXEC
+      if @watcher
+        still_bound = @watcher.bound
+        redis_UNWATCH
+        unless still_bound
+          @multi = nil
+          return :'*-1' 
+        end
+      end
+      send_data "*#{@multi.size}\r\n"
+      response = []
+      @multi.each do |strings|
+        begin
+          result = __send__ "redis_#{strings[0].upcase}", *strings[1..-1]
+        rescue StandardError, LoadError, SyntaxError => e
+          result = e
+        end
+        if EventMachine::Deferrable === result
+          result.unbind
+          send_redis nil
+        elsif Exception === result
+          send_data "-ERR #{result.class.name}: #{result.message}"
+        else
+          send_redis result
+        end
+      end
+      @multi = nil
+      :exec
+    end
+
+  end
+end

data/lib/redis/pubsub.rb

@@ -0,0 +1,150 @@
+require 'eventmachine'
+
+module Redis
+  module PubSub
+    
+    class Subscription
+      include EventMachine::Deferrable
+      
+      @@channels ||= {}
+      @@pchannels ||= {}
+      
+      def self.publish channel, message
+        subs = @@channels[channel] || []
+        subs.each do |sub|
+          sub.call channel, message
+        end
+        sent = subs.size
+        (@@pchannels || []).each do |pchannel, subs|
+          next unless File.fnmatch(pchannel, channel)
+          subs.each do |sub|
+            sub.pcall pchannel, channel, message
+          end
+          sent += subs.size
+        end
+        sent
+      end
+      
+      def initialize connection
+        @connection = connection
+        @subs = []
+        @psubs = []
+      end
+      
+      def bound
+        size > 0
+      end
+      
+      def size
+        @subs.size + @psubs.size
+      end
+      
+      def unbind
+        unbind_channels
+        unbind_patterns
+      end
+      
+      def unbind_channels
+        @subs.each do |channel|
+          (@@channels[channel] || []).delete self
+        end
+        @subs.clear
+      end
+      
+      def unbind_patterns
+        @psubs.each do |channel|
+          (@@pchannels[channel] || []).delete self
+        end
+        @psubs.clear
+      end
+      
+      def subscribe channel
+        c = (@@channels[channel] ||= [])
+        unless c.include? self
+          c << self 
+          @subs << channel
+        end
+        @connection.send_redis ['subscribe', channel, size]
+      end
+      
+      def psubscribe channel
+        c = (@@pchannels[channel] ||= [])
+        unless c.include? self
+          c << self 
+          @psubs << channel
+        end
+        @connection.send_redis ['psubscribe', channel, size]
+      end
+
+      def unsubscribe channel
+        c = (@@channels[channel] || [])
+        @subs.delete channel if c.delete self
+        @connection.send_redis ['unsubscribe', channel, size]
+      end
+      
+      def punsubscribe channel
+        c = (@@pchannels[channel] || [])
+        @psubs.delete channel if c.delete self
+        @connection.send_redis ['punsubscribe', channel, size]
+      end
+      
+      def call channel, message
+        @connection.send_redis ['message', channel, message]
+      end
+
+      def pcall pchannel, channel, message
+        @connection.send_redis ['pmessage', pchannel, channel, message]
+      end
+      
+    end
+    
+    def redis_SUBSCRIBE *channels
+      sub = @deferred
+      sub = Subscription.new self unless Subscription === sub
+      channels.each do |channel|
+        sub.subscribe channel
+      end
+      sub
+    end
+    
+    def redis_UNSUBSCRIBE *channels
+      sub = @deferred
+      sub = Subscription.new self unless Subscription === sub
+      if channels.empty?
+        sub.unbind_channels
+      else
+        channels.each do |channel|
+          sub.unsubscribe channel
+        end
+      end
+      sub
+    end
+    
+    def redis_PSUBSCRIBE *channels
+      sub = @deferred
+      sub = Subscription.new self unless Subscription === sub
+      channels.each do |channel|
+        sub.psubscribe channel
+      end
+      sub
+    end
+    
+    def redis_PUNSUBSCRIBE *channels
+      sub = @deferred
+      sub = Subscription.new self unless Subscription === sub
+      if channels.empty?
+        sub.unbind_patterns
+      else
+        channels.each do |channel|
+          sub.punsubscribe channel
+        end
+      end
+      sub
+    end
+    
+    def redis_PUBLISH channel, message
+      Subscription.publish channel, message
+    end
+    
+  end
+end

data/lib/redis/reader.rb

@@ -0,0 +1,175 @@
+module Redis
+  class Reader < Array
+
+    # Minimize the amount of memory copying. The primary
+    # performance trick is to String#split and work with that.
+    # This is almost as fast as hiredis/reader plus it supports servers
+
+    def initialize options={}
+      super()
+      @multibulk_limit = options[:multibulk_limit] || 1024*1024
+      @bulk_limit = options[:bulk_limit] || 512*1024*1024
+      @buffer_overflow = false
+      flush
+    end
+    
+    def feed data
+      return if @buffer_overflow
+      if reduce(0){|t,e|t+e.bytesize} > @bulk_limit + 2
+        @buffer_overflow = true
+        flush
+        return
+      end
+      push data
+    end
+    
+    def gets
+      raise 'buffer overflow' if @buffer_overflow
+      if @completed.empty?
+        unshift_split if @split
+        frame do |str|
+          @elements << str
+          if @remaining != 0
+            if @remaining < 0
+              @remaining = -@remaining
+              @elements = str
+            end
+            @remaining -= 1
+            if @remaining == 0 and !@stack.empty?
+              elements = @elements
+              @elements, @remaining = @stack.pop
+              @elements << elements
+              @remaining -= 1
+            end
+            next unless @remaining == 0
+            @completed << @elements
+          elsif !@elements.empty?
+            @completed << @elements[0]
+          end
+          @elements = []
+          @remaining = 0
+        end
+      end
+      return false if @completed.empty?
+      @completed.shift
+    end
+    
+    private
+    
+    def flush
+      @split = nil
+      @pending = nil
+      @binary_size = nil
+      @remaining = 0
+      @elements = []
+      @stack = []
+      @completed = []
+      clear
+    end
+    
+    def unshift_split
+      unshift @split.join "\n"
+      @split = nil
+    end
+        
+    # yields redis data until no more found in buffer
+    def frame
+      while true
+        if @binary_size
+          s = read_binary @binary_size
+          break unless s
+          @binary_size = nil
+          yield s
+        else
+          line = read_line
+          break unless line
+          case line[0..0]
+          when '-'
+            yield RuntimeError.new line[1..-1]
+          when '+'
+            yield line[1..-1]
+          when ':'
+            yield line[1..-1].to_i
+          when '*'
+            prev_remaining = @remaining
+            @remaining = line[1..-1].to_i
+            if @remaining == 0
+              @remaining = -1
+              yield []
+            elsif @remaining == -1
+              yield nil
+            elsif @remaining > @multibulk_limit
+              flush
+              raise 'invalid multibulk length'
+            elsif prev_remaining > 0
+              @stack << [@elements, prev_remaining]
+              @elements = []
+            end
+          when '$'
+            @binary_size = line[1..-1].to_i
+            if @binary_size == -1
+              @binary_size = nil
+              yield nil
+            elsif (@binary_size == 0 and line[1..1] != '0') or @binary_size < 0 or @binary_size > @bulk_limit
+              flush
+              raise 'invalid bulk length'
+            end
+          else
+            if @remaining > 0
+              flush
+              raise "expected \"$\", got #{line[0].chr.dump}" 
+            end
+            parts = line.split(' ')
+            @remaining = parts.size
+            parts.each {|l| yield l}
+          end
+        end
+      end
+    end
+    
+    # Read a binary redis token, nil if none available
+    def read_binary length
+      if @split
+        if @split.first.size >= length
+          result = @split.shift[0...length]
+          unshift_split if @split.size == 1
+          return result
+        end
+        unshift_split
+      end
+      unless @pending
+        size = reduce(0){|x,y|x+y.size}
+        return nil unless size >= length
+        @pending = dup
+        clear
+        remainder = size - length
+        if remainder > 0
+          last_string = @pending[-1]
+          @pending[-1] = last_string[0...-remainder]
+          push last_string[-remainder..-1]
+        end
+      end
+      # eat newline
+      return nil unless read_line
+      result = @pending.join
+      @pending = nil
+      result
+    end
+
+    # Read a newline terminated redis token, nil if none available
+    def read_line
+      unless @split
+        @split = join.split "\n", -1
+        clear
+      end
+      if @split.size > 1
+        result = @split.shift.chomp "\n"
+      else
+        result = nil
+      end
+      unshift_split if @split.size == 1
+      result
+    end
+    
+  end
+end