sensu-redis 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcfdf0b6608146e540e20c6f387455d0a34a4b5d
-  data.tar.gz: 522e12100ed683a303de2003ac92588327e4b23b
+  metadata.gz: 79f8dbe376c6ccdf3c2116339f85c2b6553ed6fb
+  data.tar.gz: 01c24f59bb0ab213c92fe66ce893633698cf76ee
 SHA512:
-  metadata.gz: 9e0c01fc853d422b50389602cf1f4c201e6144ba278719d120117fc3c386365e802f5b94bb343df2ee1b21e4a3e36786b8ccd8d68bebb5fc0e491e46a88ca18c
-  data.tar.gz: 8db45541c882d821c500cd570faac609630c4c35be0d339fbf1fb5d665cc69cb401497f1e7f095c103a913b39fed7a2b3f5f51b7c6d89ac049545c5480b9e703
+  metadata.gz: f35de6079773cfde302fd3e501469fa56f4b687afb971469c4cc2f9ac729c2e41a8caa608721365ec251107748addcd51875791e03e69486437c99b526d1b871
+  data.tar.gz: 5c4877df053f59c9af1aa277b3d9bf8ef595e1b88163c9c5a00a1e4585356efa221e80019864e89d6753e7e2c5c2626da40de09afcedd2666433ee4d956e8923

data/lib/sensu/redis/{constants.rb → client/constants.rb}

@@ -20,7 +20,7 @@ module Sensu
     PUBSUB_RESPONSES = %w[message unsubscribe].freeze
 
     # Redis commands that are supported by this library.
-    REDIS_COMMANDS = [
+    COMMANDS = [
       "set",
       "setnx",
       "get",

data/lib/sensu/redis/client.rb

@@ -0,0 +1,361 @@
+require "sensu/redis/client/constants"
+require "sensu/redis/client/errors"
+require "eventmachine"
+
+module Sensu
+  module Redis
+    class Client < EM::Connection
+      include EM::Deferrable
+
+      # Initialize the connection, creating the Redis command methods,
+      # and setting the default connection options and callbacks.
+      def initialize(options={})
+        create_command_methods!
+        @host = options[:host]
+        @port = options[:port]
+        @db = (options[:db] || 0).to_i
+        @password = options[:password]
+        @auto_reconnect = options.fetch(:auto_reconnect, true)
+        @reconnect_on_error = options.fetch(:reconnect_on_error, true)
+        @error_callback = lambda do |error|
+          raise(error)
+        end
+        @reconnect_callbacks = {
+          :before => lambda {},
+          :after => lambda {}
+        }
+      end
+
+      # Set the connection error callback. This callback is called
+      # when the connection encounters either a connection, protocol,
+      # or command error.
+      def on_error(&block)
+        @error_callback = block
+      end
+
+      # Set the connection before reconnect callback. This callback is
+      # called after the connection closes but before a reconnect is
+      # attempted.
+      def before_reconnect(&block)
+        @reconnect_callbacks[:before] = block
+      end
+
+      # Set the connection after reconnect callback. This callback is
+      # called after a successful reconnect, after the connection has
+      # been validated.
+      def after_reconnect(&block)
+        @reconnect_callbacks[:after] = block
+      end
+
+      # Create an error and pass it to the connection error callback.
+      #
+      # @param klass [Class]
+      # @param message [String]
+      def error(klass, message)
+        redis_error = klass.new(message)
+        @error_callback.call(redis_error)
+      end
+
+      # Determine if the connection is connected to Redis.
+      def connected?
+        @connected || false
+      end
+
+      # Reconnect to Redis. The before reconnect callback is first
+      # called if not already reconnecting. This method uses a 1
+      # second delay before attempting a reconnect.
+      def reconnect!
+        @reconnect_callbacks[:before].call unless @reconnecting
+        @reconnecting = true
+        EM.add_timer(1) do
+          reconnect(@host, @port)
+        end
+      end
+
+      # Close the Redis connection after writing the current
+      # Redis command data.
+      def close
+        @closing = true
+        close_connection_after_writing
+      end
+
+      # This method is called by EM when the connection closes, either
+      # intentionally or unexpectedly. This method is reponsible for
+      # starting the reconnect process when appropriate.
+      def unbind
+        @deferred_status = nil
+        if @closing
+          @reconnecting = false
+        elsif ((@connected || @reconnecting) && @auto_reconnect) || @reconnect_on_error
+          reconnect!
+        elsif @connected
+          error(ConnectionError, "connection closed")
+        else
+          error(ConnectionError, "unable to connect to redis server")
+        end
+        @connected = false
+      end
+
+      # Determine the byte size of a string.
+      #
+      # @param string [String]
+      # @return [Integer] string byte size.
+      def get_size(string)
+        string.respond_to?(:bytesize) ? string.bytesize : string.size
+      end
+
+      # Send a Redis command using RESP multi bulk. This method sends
+      # data to Redis using EM connection `send_data()`.
+      #
+      # @params [Array<Object>] *arguments
+      def send_command_data(*arguments)
+        data = "*#{arguments.size}#{DELIM}"
+        arguments.each do |value|
+          value = value.to_s
+          data << "$#{get_size(value)}#{DELIM}#{value}#{DELIM}"
+        end
+        send_data(data)
+      end
+
+      # Send a Redis command and queue the associated response
+      # callback. This method calls `send_command_data()` for RESP
+      # multi bulk and transmission.
+      #
+      # @params command [String]
+      # @params [Array<Object>] *arguments
+      # @yield command reponse callback
+      def send_command(command, *arguments, &block)
+        send_command_data(command, *arguments)
+        @response_callbacks << [RESPONSE_PROCESSORS[command], block]
+      end
+
+      # Send a Redis command once the Redis connection has been
+      # established (EM Deferable succeeded).
+      #
+      # @params command [String]
+      # @params [Array<Object>] *arguments
+      # @yield command reponse callback
+      def redis_command(command, *arguments, &block)
+        if @deferred_status == :succeeded
+          send_command(command, *arguments, &block)
+        else
+          callback do
+            send_command(command, *arguments, &block)
+          end
+        end
+      end
+
+      # Create Redis command methods. Command methods wrap
+      # `redis_command()`. This method is called by `initialize()`.
+      def create_command_methods!
+        COMMANDS.each do |command|
+          self.class.send(:define_method, command.to_sym) do |*arguments, &block|
+            redis_command(command, *arguments, &block)
+          end
+        end
+      end
+
+      # Subscribe to a Redis PubSub channel.
+      #
+      # @param channel [String]
+      # @yield channel message callback
+      def subscribe(channel, &block)
+        @pubsub_callbacks ||= Hash.new([])
+        @pubsub_callbacks[channel] << block
+        redis_command(SUBSCRIBE_COMMAND, channel, &block)
+      end
+
+      # Unsubscribe to one or more Redis PubSub channels. If a channel
+      # is provided, this method will unsubscribe from it. If a
+      # channel is not provided, this method will unsubscribe from all
+      # Redis PubSub channels.
+      #
+      # @param channel [String]
+      # @yield unsubscribe callback
+      def unsubscribe(channel=nil, &block)
+        @pubsub_callbacks ||= Hash.new([])
+        arguments = [UNSUBSCRIBE_COMMAND]
+        if channel
+          @pubsub_callbacks[channel] = [block]
+          arguments << channel
+        else
+          @pubsub_callbacks.each_key do |key|
+            @pubsub_callbacks[key] = [block]
+          end
+        end
+        redis_command(arguments)
+      end
+
+      # Authenticate to Redis if a password has been set in the
+      # connection options. This method uses `send_command()`
+      # directly, as it assumes that the connection has been
+      # established. Redis authentication must be done prior to
+      # issuing other Redis commands.
+      #
+      # @yield the callback called once authenticated.
+      def authenticate
+        if @password
+          send_command(AUTH_COMMAND, @password) do |authenticated|
+            if authenticated
+              yield if block_given?
+            else
+              error(ConnectionError, "redis authenticate failed")
+            end
+          end
+        else
+          yield if block_given?
+        end
+      end
+
+      # Select a Redis DB if a DB has been set in the connection
+      # options. This method (& Redis command) does not require a
+      # response callback.
+      def select_db
+        send_command(SELECT_COMMAND, @db) if @db
+      end
+
+      # Verify the version of Redis. Redis >= 2.0 RC 1 is required for
+      # certain Redis commands that Sensu uses. A connection error is
+      # created if the Redis version does not meet the requirements.
+      #
+      # @yield the callback called once verified.
+      def verify_version
+        send_command(INFO_COMMAND) do |redis_info|
+          if redis_info[:redis_version] < "1.3.14"
+            error(ConnectionError, "redis version must be >= 2.0 RC 1")
+          else
+            yield if block_given?
+          end
+        end
+      end
+
+      # This method is called by EM when the connection is
+      # established. This method is reponsible for validating the
+      # connection before Redis commands can be sent.
+      def connection_completed
+        @response_callbacks = []
+        @multibulk_count = false
+        @connected = true
+        authenticate do
+          select_db
+          verify_version do
+            succeed
+            @reconnect_callbacks[:after].call if @reconnecting
+            @reconnecting = false
+          end
+        end
+      end
+
+      # Begin a multi bulk response array for an expected number of
+      # responses. Using this method causes `dispatch_response()` to
+      # wait until all of the expected responses have been added to
+      # the array, before the Redis command reponse callback is
+      # called.
+      #
+      # @param multibulk_count [Integer] number of expected responses.
+      def begin_multibulk(multibulk_count)
+        @multibulk_count = multibulk_count
+        @multibulk_values = []
+      end
+
+      # Dispatch a Redis error, dropping the associated Redis command
+      # response callback, and passing a Redis error object to the
+      # error callback (if set).
+      #
+      # @param code [String] Redis error code.
+      def dispatch_error(code)
+        @response_callbacks.shift
+        error(CommandError, code)
+      end
+
+      # Dispatch a response. If a multi bulk response has begun, this
+      # method will build the completed response array before the
+      # associated Redis command response callback is called. If one
+      # or more pubsub callbacks are defined, the approprate pubsub
+      # callbacks are called, provided with the pubsub response. Redis
+      # command response callbacks may have an optional processor
+      # block, responsible for producing a value with the correct
+      # type, e.g. "1" -> true (boolean).
+      #
+      # @param value [Object]
+      def dispatch_response(value)
+        if @multibulk_count
+          @multibulk_values << value
+          @multibulk_count -= 1
+          if @multibulk_count == 0
+            value = @multibulk_values
+            @multibulk_count = false
+          else
+            return
+          end
+        end
+        if @pubsub_callbacks && value.is_a?(Array)
+          if PUBSUB_RESPONSES.include?(value[0])
+            @pubsub_callbacks[value[1]].each do |block|
+              block.call(*value) if block
+            end
+            return
+          end
+        end
+        processor, block = @response_callbacks.shift
+        if block
+          value = processor.call(value) if processor
+          block.call(value)
+        end
+      end
+
+      # Parse a RESP line. This method is called by `receive_data()`.
+      # You can read about RESP @ http://redis.io/topics/protocol
+      #
+      # @param line [String]
+      def parse_resp_line(line)
+        # Trim off the response type and delimiter (\r\n).
+        response = line.slice(1..-3)
+        # First character indicates response type.
+        case line[0, 1]
+        when MINUS # Error, e.g. -ERR
+          dispatch_error(response)
+        when PLUS # String, e.g. +OK
+          dispatch_response(response)
+        when DOLLAR # Bulk string, e.g. $3\r\nfoo\r\n
+          response_size = Integer(response)
+          if response_size == -1 # No data, return nil.
+            dispatch_response(nil)
+          elsif @buffer.size >= response_size + 2 # Complete data.
+            dispatch_response(@buffer.slice!(0, response_size))
+            @buffer.slice!(0,2) # Discard delimeter (\r\n).
+          else # Incomplete, have data pushed back into buffer.
+            return INCOMPLETE
+          end
+        when COLON # Integer, e.g. :8
+          dispatch_response(Integer(response))
+        when ASTERISK # Array, e.g. *2\r\n$3\r\foo\r\n$3\r\nbar\r\n
+          multibulk_count = Integer(response)
+          if multibulk_count == -1 || multibulk_count == 0 # No data, return [].
+            dispatch_response([])
+          else
+            begin_multibulk(multibulk_count) # Accumulate responses.
+          end
+        else
+          error(ProtocolError, "response type not recognized: #{line.strip}")
+        end
+      end
+
+      # This method is called by EM when the connection receives data.
+      # This method assumes that the incoming data is using RESP and
+      # it is parsed by `parse_resp_line()`.
+      #
+      # @param data [String]
+      def receive_data(data)
+        (@buffer ||= '') << data
+        while index = @buffer.index(DELIM)
+          line = @buffer.slice!(0, index+2)
+          if parse_resp_line(line) == INCOMPLETE
+            @buffer[0...0] = line
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/redis.rb

@@ -1,45 +1,34 @@
 require "rubygems"
-require "sensu/redis/parser"
-require "sensu/redis/processor"
-require "sensu/redis/commands"
-require "sensu/redis/connection"
+require "sensu/redis/client"
 require "eventmachine"
 require "uri"
 
 module Sensu
   module Redis
-    class Client < EM::Connection
-      include EM::Deferrable
-      include Parser
-      include Processor
-      include Commands
-      include Connection
-
-      class << self
-        def parse_url(url)
-          begin
-            uri = URI.parse(url)
-            {
-              :host => uri.host,
-              :port => uri.port,
-              :password => uri.password
-            }
-          rescue
-            raise ArgumentError, "invalid redis url"
-          end
+    class << self
+      def parse_url(url)
+        begin
+          uri = URI.parse(url)
+          {
+            :host => uri.host,
+            :port => uri.port,
+            :password => uri.password
+          }
+        rescue
+          raise ArgumentError, "invalid redis url"
         end
+      end
 
-        def connect(options={})
-          case options
-          when String
-            options = parse_url(options)
-          when nil
-            options = {}
-          end
-          options[:host] ||= "127.0.0.1"
-          options[:port] = (options[:port] || 6379).to_i
-          EM.connect(options[:host], options[:port], self, options)
+      def connect(options={})
+        case options
+        when String
+          options = parse_url(options)
+        when nil
+          options = {}
         end
+        options[:host] ||= "127.0.0.1"
+        options[:port] = (options[:port] || 6379).to_i
+        EM.connect(options[:host], options[:port], Sensu::Redis::Client, options)
       end
     end
   end

data/sensu-redis.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "sensu-redis"
-  spec.version       = "0.1.6"
+  spec.version       = "0.1.7"
   spec.authors       = ["Sean Porter"]
   spec.email         = ["portertech@gmail.com"]
   spec.summary       = "The Sensu Redis client library"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sensu-redis
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Sean Porter
@@ -97,12 +97,9 @@ files:
 - bin/console
 - bin/setup
 - lib/sensu/redis.rb
-- lib/sensu/redis/commands.rb
-- lib/sensu/redis/connection.rb
-- lib/sensu/redis/constants.rb
-- lib/sensu/redis/errors.rb
-- lib/sensu/redis/parser.rb
-- lib/sensu/redis/processor.rb
+- lib/sensu/redis/client.rb
+- lib/sensu/redis/client/constants.rb
+- lib/sensu/redis/client/errors.rb
 - sensu-redis.gemspec
 homepage: https://github.com/sensu/sensu-redis
 licenses:
@@ -129,4 +126,3 @@ signing_key:
 specification_version: 4
 summary: The Sensu Redis client library
 test_files: []
-has_rdoc: 

data/lib/sensu/redis/commands.rb

@@ -1,104 +0,0 @@
-require "sensu/redis/constants"
-require "sensu/redis/errors"
-
-module Sensu
-  module Redis
-    # Sensu Module for requesting Redis commands, intended to be
-    # included by Sensu::Redis::Client.
-    #
-    # You can read about RESP @ http://redis.io/topics/protocol
-    module Commands
-      # Determine the byte size of a string.
-      #
-      # @param string [String]
-      # @return [Integer] string byte size.
-      def get_size(string)
-        string.respond_to?(:bytesize) ? string.bytesize : string.size
-      end
-
-      # Send a Redis command using RESP multi bulk. This method sends
-      # data to Redis using EM connection `send_data()`.
-      #
-      # @params [Array<Object>] *arguments
-      def send_command_data(*arguments)
-        data = "*#{arguments.size}#{DELIM}"
-        arguments.each do |value|
-          value = value.to_s
-          data << "$#{get_size(value)}#{DELIM}#{value}#{DELIM}"
-        end
-        send_data(data)
-      end
-
-      # Send a Redis command and queue the associated response
-      # callback. This method calls `send_command_data()` for RESP
-      # multi bulk and transmission.
-      #
-      # @params command [String]
-      # @params [Array<Object>] *arguments
-      # @yield command reponse callback
-      def send_command(command, *arguments, &block)
-        @response_callbacks ||= []
-        send_command_data(command, *arguments)
-        @response_callbacks << [RESPONSE_PROCESSORS[command], block]
-      end
-
-      # Send a Redis command once the Redis connection has been
-      # established (EM Deferable succeeded).
-      #
-      # @params command [String]
-      # @params [Array<Object>] *arguments
-      # @yield command reponse callback
-      def redis_command(command, *arguments, &block)
-        if @deferred_status == :succeeded
-          send_command(command, *arguments, &block)
-        else
-          callback do
-            send_command(command, *arguments, &block)
-          end
-        end
-      end
-
-      # Create Redis command methods. Command methods wrap
-      # `redis_command()`. This method MUST be called in
-      # `initialize()`.
-      def create_command_methods!
-        REDIS_COMMANDS.each do |command|
-          self.class.send(:define_method, command.to_sym) do |*arguments, &block|
-            redis_command(command, *arguments, &block)
-          end
-        end
-      end
-
-      # Subscribe to a Redis PubSub channel.
-      #
-      # @param channel [String]
-      # @yield channel message callback
-      def subscribe(channel, &block)
-        @pubsub_callbacks ||= Hash.new([])
-        @pubsub_callbacks[channel] << block
-        redis_command(SUBSCRIBE_COMMAND, channel, &block)
-      end
-
-      # Unsubscribe to one or more Redis PubSub channels. If a channel
-      # is provided, this method will unsubscribe from it. If a
-      # channel is not provided, this method will unsubscribe from all
-      # Redis PubSub channels.
-      #
-      # @param channel [String]
-      # @yield unsubscribe callback
-      def unsubscribe(channel=nil, &block)
-        @pubsub_callbacks ||= Hash.new([])
-        arguments = [UNSUBSCRIBE_COMMAND]
-        if channel
-          @pubsub_callbacks[channel] = [block]
-          arguments << channel
-        else
-          @pubsub_callbacks.each_key do |key|
-            @pubsub_callbacks[key] = [block]
-          end
-        end
-        redis_command(arguments)
-      end
-    end
-  end
-end

data/lib/sensu/redis/connection.rb

@@ -1,158 +0,0 @@
-require "sensu/redis/constants"
-require "sensu/redis/errors"
-
-module Sensu
-  module Redis
-    # Sensu Module connecting to Redis.
-    module Connection
-      # Initialize the connection, creating the Redis command methods,
-      # and setting the default connection options and callbacks.
-      def initialize(options={})
-        create_command_methods!
-        @host = options[:host]
-        @port = options[:port]
-        @db = (options[:db] || 0).to_i
-        @password = options[:password]
-        @auto_reconnect = options.fetch(:auto_reconnect, true)
-        @reconnect_on_error = options.fetch(:reconnect_on_error, true)
-        @error_callback = lambda do |error|
-          raise(error)
-        end
-        @reconnect_callbacks = {
-          :before => lambda{},
-          :after  => lambda{}
-        }
-      end
-
-      # Set the connection error callback. This callback is called
-      # when the connection encounters either a connection, protocol,
-      # or command error.
-      def on_error(&block)
-        @error_callback = block
-      end
-
-      # Set the connection before reconnect callback. This callback is
-      # called after the connection closes but before a reconnect is
-      # attempted.
-      def before_reconnect(&block)
-        @reconnect_callbacks[:before] = block
-      end
-
-      # Set the connection after reconnect callback. This callback is
-      # called after a successful reconnect, after the connection has
-      # been validated.
-      def after_reconnect(&block)
-        @reconnect_callbacks[:after] = block
-      end
-
-      # Create an error and pass it to the connection error callback.
-      #
-      # @param klass [Class]
-      # @param message [String]
-      def error(klass, message)
-        redis_error = klass.new(message)
-        @error_callback.call(redis_error)
-      end
-
-      # Determine if the connection is connected to Redis.
-      def connected?
-        @connected || false
-      end
-
-      # Reconnect to Redis. The before reconnect callback is first
-      # called if not already reconnecting. This method uses a 1
-      # second delay before attempting a reconnect.
-      def reconnect!
-        @reconnect_callbacks[:before].call unless @reconnecting
-        @reconnecting = true
-        EM.add_timer(1) do
-          reconnect(@host, @port)
-        end
-      end
-
-      # Close the Redis connection after writing the current
-      # Redis command data.
-      def close
-        @closing = true
-        close_connection_after_writing
-      end
-
-      # This method is called by EM when the connection closes, either
-      # intentionally or unexpectedly. This method is reponsible for
-      # starting the reconnect process when appropriate.
-      def unbind
-        @deferred_status = nil
-        if @closing
-          @reconnecting = false
-        elsif ((@connected || @reconnecting) && @auto_reconnect) || @reconnect_on_error
-          reconnect!
-        elsif @connected
-          error(ConnectionError, "connection closed")
-        else
-          error(ConnectionError, "unable to connect to redis server")
-        end
-        @connected = false
-      end
-
-      # Authenticate to Redis if a password has been set in the
-      # connection options. This method uses `send_command()`
-      # directly, as it assumes that the connection has been
-      # established. Redis authentication must be done prior to
-      # issuing other Redis commands.
-      #
-      # @yield the callback called once authenticated.
-      def authenticate
-        if @password
-          send_command(AUTH_COMMAND, @password) do |authenticated|
-            if authenticated
-              yield if block_given?
-            else
-              error(ConnectionError, "redis authenticate failed")
-            end
-          end
-        else
-          yield if block_given?
-        end
-      end
-
-      # Select a Redis DB if a DB has been set in the connection
-      # options. This method (& Redis command) does not require a
-      # response callback.
-      def select_db
-        send_command(SELECT_COMMAND, @db) if @db
-      end
-
-      # Verify the version of Redis. Redis >= 2.0 RC 1 is required for
-      # certain Redis commands that Sensu uses. A connection error is
-      # created if the Redis version does not meet the requirements.
-      #
-      # @yield the callback called once verified.
-      def verify_version
-        send_command(INFO_COMMAND) do |redis_info|
-          if redis_info[:redis_version] < "1.3.14"
-            error(ConnectionError, "redis version must be >= 2.0 RC 1")
-          else
-            yield if block_given?
-          end
-        end
-      end
-
-      # This method is called by EM when the connection is
-      # established. This method is reponsible for validating the
-      # connection before Redis commands can be sent.
-      def connection_completed
-        @response_callbacks = []
-        @multibulk_count = false
-        @connected = true
-        authenticate do
-          select_db
-          verify_version do
-            succeed
-            @reconnect_callbacks[:after].call if @reconnecting
-            @reconnecting = false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sensu/redis/parser.rb

@@ -1,66 +0,0 @@
-require "sensu/redis/constants"
-require "sensu/redis/errors"
-
-module Sensu
-  module Redis
-    # Sensu Module for parsing RESP (REdis Serialization Protocol).
-    # You can read about RESP @ http://redis.io/topics/protocol
-    # This module calls methods provided by other Sensu Redis modules:
-    #   Sensu::Redis::Processor.dispatch_error()
-    #   Sensu::Redis::Processor.dispatch_response()
-    #   Sensu::Redis::Processor.begin_multibulk()
-    #   Sensu::Redis::Connection.error()
-    module Parser
-      # Parse a RESP line.
-      #
-      # @param line [String]
-      def parse_line(line)
-        # Trim off the response type and delimiter (\r\n).
-        response = line.slice(1..-3)
-        # First character indicates response type.
-        case line[0, 1]
-        when MINUS # Error, e.g. -ERR
-          dispatch_error(response)
-        when PLUS # String, e.g. +OK
-          dispatch_response(response)
-        when DOLLAR # Bulk string, e.g. $3\r\nfoo\r\n
-          response_size = Integer(response)
-          if response_size == -1 # No data, return nil.
-            dispatch_response(nil)
-          elsif @buffer.size >= response_size + 2 # Complete data.
-            dispatch_response(@buffer.slice!(0, response_size))
-            @buffer.slice!(0,2) # Discard delimeter (\r\n).
-          else # Incomplete, have data pushed back into buffer.
-            return INCOMPLETE
-          end
-        when COLON # Integer, e.g. :8
-          dispatch_response(Integer(response))
-        when ASTERISK # Array, e.g. *2\r\n$3\r\foo\r\n$3\r\nbar\r\n
-          multibulk_count = Integer(response)
-          if multibulk_count == -1 || multibulk_count == 0 # No data, return [].
-            dispatch_response([])
-          else
-            begin_multibulk(multibulk_count) # Accumulate responses.
-          end
-        else
-          error(ProtocolError, "response type not recognized: #{line.strip}")
-        end
-      end
-
-      # EM connection receive data, parse incoming data using RESP
-      # (`parse_line()`).
-      #
-      # @param data [String]
-      def receive_data(data)
-        (@buffer ||= '') << data
-        while index = @buffer.index(DELIM)
-          line = @buffer.slice!(0, index+2)
-          if parse_line(line) == INCOMPLETE
-            @buffer[0...0] = line
-            break
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sensu/redis/processor.rb

@@ -1,79 +0,0 @@
-require "sensu/redis/constants"
-require "sensu/redis/errors"
-
-module Sensu
-  module Redis
-    # Sensu Module for processing Redis responses.
-    # This module calls methods provided by other Sensu Redis modules:
-    #   Sensu::Redis::Connection.error()
-    module Processor
-      # Fetch the next Redis command response callback. Response
-      # callbacks may include an optional response processor block,
-      # i.e. "1" -> true.
-      #
-      # @return [Array] processor, callback.
-      def fetch_response_callback
-        @response_callbacks ||= []
-        @response_callbacks.shift
-      end
-
-      # Begin a multi bulk response array for an expected number of
-      # responses. Using this method causes `dispatch_response()` to
-      # wait until all of the expected responses have been added to
-      # the array, before the Redis command reponse callback is
-      # called.
-      #
-      # @param multibulk_count [Integer] number of expected responses.
-      def begin_multibulk(multibulk_count)
-        @multibulk_count = multibulk_count
-        @multibulk_values = []
-      end
-
-      # Dispatch a Redis error, dropping the associated Redis command
-      # response callback, and passing a Redis error object to the
-      # error callback (if set).
-      #
-      # @param code [String] Redis error code.
-      def dispatch_error(code)
-        fetch_response_callback
-        error(CommandError, code)
-      end
-
-      # Dispatch a response. If a multi bulk response has begun, this
-      # method will build the completed response array before the
-      # associated Redis command response callback is called. If one
-      # or more pubsub callbacks are defined, the approprate pubsub
-      # callbacks are called, provided with the pubsub response. Redis
-      # command response callbacks may have an optional processor
-      # block, responsible for producing a value with the correct
-      # type, e.g. "1" -> true (boolean).
-      #
-      # @param value [Object]
-      def dispatch_response(value)
-        if @multibulk_count
-          @multibulk_values << value
-          @multibulk_count -= 1
-          if @multibulk_count == 0
-            value = @multibulk_values
-            @multibulk_count = false
-          else
-            return
-          end
-        end
-        if @pubsub_callbacks && value.is_a?(Array)
-          if PUBSUB_RESPONSES.include?(value[0])
-            @pubsub_callbacks[value[1]].each do |block|
-              block.call(*value) if block
-            end
-            return
-          end
-        end
-        processor, block = fetch_response_callback
-        if block
-          value = processor.call(value) if processor
-          block.call(value)
-        end
-      end
-    end
-  end
-end