sensu-redis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1dd63d72bb8617b4a11636fc4f49f601fdc58f97
+  data.tar.gz: 1ecffe0185d61f8b98cdbb485c1d56d5d1da9e52
+SHA512:
+  metadata.gz: b29df8a599bb52c350a4fd0aacdde00b1472ad58ef77782d02ba06878ab0b43dbec9ef2c0c514fcf9ec9b63a2c760f92f6de155a0bf9b8dfbdfe00d31bd5afeb
+  data.tar.gz: d6d503398789220f4433ffacd6cf18d20b5a5930bfd3bf0acee9743e5d6c31f169b8235198f2b92b5fd8c2805b45029cbca4c83aba9a319b2e70d91d7d2ae3ee

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sensu-redis.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# Sensu::Redis
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sensu/redis`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sensu-redis'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sensu-redis
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sensu-redis.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sensu/redis"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sensu/redis.rb

@@ -0,0 +1,43 @@
+require "rubygems"
+require "sensu/redis/parser"
+require "sensu/redis/processor"
+require "sensu/redis/commands"
+require "sensu/redis/connection"
+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
+        end
+
+        def connect(options={})
+          if options.is_a?(String)
+            options = parse_url(options)
+          end
+          options[:host] ||= "127.0.0.1"
+          options[:port] = (options[:port] || 6379).to_i
+          EM.connect(options[:host], options[:port], self, options)
+        end
+      end
+    end
+  end
+end

data/lib/sensu/redis/commands.rb

@@ -0,0 +1,93 @@
+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 is
+      # called by the Redis command methods, which are created by
+      # `create_command_methods()`, it simply implements RESP and
+      # sends commands to Redis via EM connection `send_data()`.
+      def send_command(*arguments)
+        command = "*#{arguments.size}#{DELIM}"
+        arguments.each do |value|
+          value = value.to_s
+          command << "$#{get_size(value)}#{DELIM}#{value}#{DELIM}"
+        end
+        if @deferred_status
+          send_data(command)
+        else
+          callback { send_data(command) }
+        end
+      end
+
+      # Create Redis command methods. Command methods just wrap
+      # `send_command()` and enqueue a response callback. This method
+      # MUST be called in the connection object's `initialize()`.
+      def create_command_methods!
+        @response_callbacks ||= []
+        REDIS_COMMANDS.each do |command|
+          self.class.send(:define_method, command.to_sym) do |*arguments, &block|
+            send_command(command, *arguments)
+            @response_callbacks << [RESPONSE_PROCESSORS[command], block]
+          end
+        end
+      end
+
+      # Authenticate to Redis and select the correct DB, when
+      # applicable. The auth and select Redis commands must be the
+      # first commands (& callbacks) to run.
+      #
+      # @param password [String]
+      # @param db [Integer]
+      def auth_and_select_db(password=nil, db=nil)
+        callbacks = @callbacks || []
+        @callbacks = []
+        send_command(AUTH_COMMAND, password) if password
+        send_command(SELECT_COMMAND, db) if db
+        callbacks.each { |block| callback(&block) }
+      end
+
+      # Subscribe to a Redis PubSub channel.
+      #
+      # @param channel [String]
+      def subscribe(channel, &block)
+        @pubsub_callbacks ||= Hash.new([])
+        @pubsub_callbacks[channel] << block
+        send_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]
+      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
+        send_command(arguments)
+      end
+    end
+  end
+end

data/lib/sensu/redis/connection.rb

@@ -0,0 +1,112 @@
+require "sensu/redis/constants"
+require "sensu/redis/errors"
+
+module Sensu
+  module Redis
+    # Sensu Module connecting to Redis.
+    module Connection
+      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 on error callback.
+      def on_error(&block)
+        @error_callback = block
+      end
+
+      # Set the before reconnect callback.
+      def before_reconnect(&block)
+        @reconnect_callbacks[:before] = block
+      end
+
+      # Set the after reconnect callback.
+      def after_reconnect(&block)
+        @reconnect_callbacks[:after] = block
+      end
+
+      # Create an error and pass it to the 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 connected to Redis.
+      def connected?
+        @connected || false
+      end
+
+      # Reconnect to Redis. The before reconnect callback is first
+      # call 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
+      # command/data.
+      def close
+        @closing = true
+        close_connection_after_writing
+      end
+
+      # Called by EM when the connection closes, either intentionally
+      # or unexpectedly.
+      def unbind
+        @deferred_status = nil
+        @response_callbacks = []
+        @multibulk_count = false
+        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
+
+      # Validate the connection, ensuring that the Redis release
+      # supports Sensu's required Redis commands. A connection error
+      # is thrown if Redis's version does not meet the requirement.
+      def validate_connection!
+        info do |redis_info|
+          if redis_info[:redis_version] < "1.3.14"
+            error(ConnectionError, "redis version must be >= 2.0 RC 1")
+          end
+        end
+      end
+
+      # Called by EM when the connection is established.
+      def connection_completed
+        @connected = true
+        auth_and_select_db(@password, @db)
+        validate_connection!
+        @reconnect_callbacks[:after].call if @reconnecting
+        @reconnecting = false
+        succeed
+      end
+    end
+  end
+end

data/lib/sensu/redis/constants.rb

@@ -0,0 +1,96 @@
+module Sensu
+  module Redis
+    # RESP (REdis Serialization Protocol) response type characters and
+    # delimiter (http://redis.io/topics/protocol).
+    OK = "OK".freeze
+    MINUS = "-".freeze
+    PLUS = "+".freeze
+    COLON = ":".freeze
+    DOLLAR = "$".freeze
+    ASTERISK = "*".freeze
+    DELIM = "\r\n".freeze
+
+    # Redis response line parser incomplete data return value.
+    INCOMPLETE = "incomp".freeze
+
+    # Used to return empty array reponses.
+    EMPTY_ARRAY = [].freeze
+
+    # Redis response boolean values.
+    TRUE_VALUES = %w[1 OK].freeze
+
+    # Redis pubsub response type values.
+    PUBSUB_RESPONSES = %w[message unsubscribe].freeze
+
+    # Redis commands that are supported by this library.
+    REDIS_COMMANDS = [
+      "set",
+      "setnx",
+      "get",
+      "getset",
+      "del",
+      "info",
+      "sadd",
+      "smembers",
+      "sismembers",
+      "srem",
+      "scard",
+      "hset",
+      "hsetnx",
+      "hget",
+      "hgetall",
+      "hdel",
+      "hincrby",
+      "rpush",
+      "lpush",
+      "ltrim",
+      "lrange",
+      "exists",
+      "ttl",
+      "expire",
+      "flushdb",
+      "incr"
+    ].freeze
+
+    # Redis DB select command.
+    SELECT_COMMAND = "select".freeze
+
+    # Redis authentication command.
+    AUTH_COMMAND = "auth".freeze
+
+    # Redis PubSub subscribe command.
+    SUBSCRIBE_COMMAND = "subscribe".freeze
+
+    # Redis PubSub unsubscribe command.
+    UNSUBSCRIBE_COMMAND = "unsubscribe".freeze
+
+    # Boolean Redis response value processor.
+    BOOLEAN_PROCESSOR = lambda{|r| TRUE_VALUES.include?(r.to_s)}
+
+    # Redis response value processors.
+    RESPONSE_PROCESSORS = {
+      "exists" => BOOLEAN_PROCESSOR,
+      "sadd" => BOOLEAN_PROCESSOR,
+      "srem" => BOOLEAN_PROCESSOR,
+      "setnx" => BOOLEAN_PROCESSOR,
+      "del" => BOOLEAN_PROCESSOR,
+      "expire" => BOOLEAN_PROCESSOR,
+      "select" => BOOLEAN_PROCESSOR,
+      "hset" => BOOLEAN_PROCESSOR,
+      "hdel" => BOOLEAN_PROCESSOR,
+      "hsetnx" => BOOLEAN_PROCESSOR,
+      "hgetall" => lambda{|r| Hash[*r]},
+      "info" => lambda{|r|
+        info = {}
+        r.each_line do |line|
+          line.chomp!
+          unless line.empty?
+            k, v = line.split(":", 2)
+            info[k.to_sym] = v
+          end
+        end
+        info
+      }
+    }
+  end
+end

data/lib/sensu/redis/errors.rb

@@ -0,0 +1,19 @@
+module Sensu
+  module Redis
+    # Error class for Redis connection errors.
+    class ConnectionError < StandardError; end
+
+    # Error class for Redis protocol (RESP) errors.
+    class ProtocolError < StandardError; end
+
+    # Error class for Redis command errors.
+    class CommandError < StandardError
+      attr_accessor :code
+
+      def initialize(*args)
+        args[0] = "redis returned error code: #{args[0]}"
+        super
+      end
+    end
+  end
+end

data/lib/sensu/redis/parser.rb

@@ -0,0 +1,66 @@
+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(EMPTY_ARRAY)
+          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

@@ -0,0 +1,79 @@
+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

data/sensu-redis.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "sensu-redis"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Sean Porter"]
+  spec.email         = ["portertech@gmail.com"]
+  spec.summary       = "The Sensu Redis client library"
+  spec.description   = "The Sensu Redis client library"
+  spec.homepage      = "https://github.com/sensu/sensu-redis"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "eventmachine"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "10.5.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "codeclimate-test-reporter" unless RUBY_VERSION < "1.9"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: sensu-redis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean Porter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Sensu Redis client library
+email:
+- portertech@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- 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
+- sensu-redis.gemspec
+homepage: https://github.com/sensu/sensu-redis
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: The Sensu Redis client library
+test_files: []