sensu-transport 2.4.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3df64f00afb91830bb9b3c5fe13da6a9bca16609
-  data.tar.gz: d9819ca9cf5f0e06b4407b62fa1b8d9c51b18f58
+  metadata.gz: 517c32e4f19a39830cf6063c9ad922367c150606
+  data.tar.gz: 11096746935854892ef77ecac01e4e308e48808e
 SHA512:
-  metadata.gz: 47d968aa20315b67bf6bb2500bc3da092e1e33546a170146e85d2cbfffc37f5262c61d767340355ded4af5255d04eea3339077ef582b1d9eb21e63afb9fad47a
-  data.tar.gz: 5c6d272da0ccb3badc6a53f919d3c85b311a9883a7a7d2a95f05f71a01a51f2c633322a0636deff5b793258a7c78ec456cbb8a6ca5d0fae5d3247fb07c6e97f4
+  metadata.gz: bc8457b82d63f770d8ff504f924dbc9b624ea455420bdd5ed2cce8f666c9923ad49b4a53738869fdb331fb2be9c9569afb99fe5b44cbbbbfaad1b7609cd1fbf6
+  data.tar.gz: c30aefec4551ca98e5ca73ffc519e4afdaed37a91e8359691d4439c046651a75e25bb3d056d14ce46730aff30f69b6274e33833e3413647a9e60726e91036131

data/.travis.yml

@@ -8,10 +8,11 @@ rvm:
   - jruby
 services:
   - rabbitmq
+  - redis
 notifications:
   irc:
     - "irc.freenode.net#sensu"
-script: "rspec . --tag ~ssl"
+script: "bundle exec rspec . --tag ~ssl"
 addons:
   code_climate:
     repo_token: 629d024a848e2ebb1b0c0283c2046387c1b8c0d1cfd4d03289bef74a7b875d55

data/Gemfile

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

data/lib/sensu/transport/base.rb

@@ -48,7 +48,9 @@ module Sensu
       def connect(options={}); end
 
       # Reconnect to the transport.
-      def reconnect; end
+      #
+      # @param force [Boolean] the reconnect.
+      def reconnect(force=false); end
 
       # Indicates if connected to the transport.
       #

data/lib/sensu/transport/rabbitmq.rb

@@ -14,7 +14,7 @@ module Sensu
         connect_with_eligible_options
       end
 
-      def reconnect
+      def reconnect(force=false)
         unless @reconnecting
           @reconnecting = true
           @before_reconnect.call

data/lib/sensu/transport/redis.rb

@@ -0,0 +1,311 @@
+require "em-redis-unified"
+
+require File.join(File.dirname(__FILE__), "base")
+
+module Sensu
+  module Transport
+    class Redis < Base
+
+      # The Redis keyspace to use for the transport.
+      REDIS_KEYSPACE = "transport"
+
+      def initialize
+        @options = {}
+        @connections = {}
+        super
+      end
+
+      # Redis transport connection setup. This method sets `@options`
+      # and creates a named Redis connection "redis".
+      #
+      # @param options [Hash, String]
+      def connect(options={})
+        @options = options || {}
+        redis_connection("redis")
+      end
+
+      # Reconnect to the Redis transport. The Redis connections used
+      # by the transport have auto-reconnect disabled; if a single
+      # connection is unhealthy, all connections are closed, the
+      # transport is reset, and new connections are made. If the
+      # transport is not already reconnecting to Redis, the
+      # `@before_reconnect` transport callback is called.
+      #
+      # @param force [Boolean] the reconnect.
+      def reconnect(force=false)
+        @before_reconnect.call unless @reconnecting
+        unless @reconnecting && !force
+          @reconnecting = true
+          close
+          reset
+          connect(@options)
+        end
+      end
+
+      # Indicates if ALL Redis connections are connected.
+      #
+      # @return [TrueClass, FalseClass]
+      def connected?
+        !@connections.empty? && @connections.values.all? do |connection|
+          connection.connected?
+        end
+      end
+
+      # Close ALL Redis connections.
+      def close
+        @connections.each_value do |connection|
+          connection.close
+        end
+      end
+
+      # Publish a message to the Redis transport. The transport pipe
+      # type determines the method of sending messages to consumers
+      # using Redis, either using PubSub or a list. The appropriate
+      # publish method is call for the pipe type given. The Redis
+      # transport ignores publish options.
+      #
+      # @param type [Symbol] the transport pipe type, possible values
+      #   are: :direct and :fanout.
+      # @param pipe [String] the transport pipe name.
+      # @param message [String] the message to be published to the transport.
+      # @param options [Hash] IGNORED by this transport.
+      # @yield [info] passes publish info to an optional callback/block.
+      # @yieldparam info [Hash] contains publish information, which
+      #   may contain an error object.
+      def publish(type, pipe, message, options={}, &callback)
+        case type.to_sym
+        when :fanout
+          pubsub_publish(pipe, message, &callback)
+        when :direct
+          list_publish(pipe, message, &callback)
+        end
+      end
+
+      # Subscribe to a Redis transport pipe. The transport pipe
+      # type determines the method of consuming messages from Redis,
+      # either using PubSub or a list. The appropriate subscribe
+      # method is call for the pipe type given. The Redis transport
+      # ignores subscribe options and the funnel name.
+      #
+      # @param type [Symbol] the transport pipe type, possible values
+      #   are: :direct and :fanout.
+      # @param pipe [String] the transport pipe name.
+      # @param funnel [String] IGNORED by this transport.
+      # @param options [Hash] IGNORED by this transport.
+      # @yield [info, message] passes message info and content to
+      #   the consumer callback/block.
+      # @yieldparam info [Hash] contains message information.
+      # @yieldparam message [String] message.
+      def subscribe(type, pipe, funnel=nil, options={}, &callback)
+        case type.to_sym
+        when :fanout
+          pubsub_subscribe(pipe, &callback)
+        when :direct
+          list_subscribe(pipe, &callback)
+        end
+      end
+
+      # Unsubscribe from all transport pipes. This method iterates
+      # through the current named Redis connections, unsubscribing the
+      # "pubsub" connection from Redis channels, and closing/deleting
+      # BLPOP connections.
+      #
+      # @yield [info] passes info to an optional callback/block.
+      # @yieldparam info [Hash] empty hash.
+      def unsubscribe(&callback)
+        @connections.each do |name, connection|
+          case name
+          when "pubsub"
+            connection.unsubscribe
+          when /^#{REDIS_KEYSPACE}/
+            connection.close
+            @connections.delete(name)
+          end
+        end
+        super
+      end
+
+      # Redis transport pipe/funnel stats, such as message and
+      # consumer counts. This method is currently unable to determine
+      # the consumer count for a Redis list.
+      #
+      # @param funnel [String] the transport funnel to get stats for.
+      # @param options [Hash] IGNORED by this transport.
+      def stats(funnel, options={}, &callback)
+        redis_connection("redis").llen(funnel) do |messages|
+          info = {
+            :messages => messages,
+            :consumers => 0
+          }
+          callback.call(info)
+        end
+      end
+
+      private
+
+      # Reset instance variables, called when reconnecting.
+      def reset
+        @connections = {}
+      end
+
+      # Monitor current Redis connections, the connection "pool". A
+      # timer is used to check on the connections, every `3` seconds.
+      # If one or more connections is not connected, a forced
+      # `reconnect()` is triggered. If all connections are connected
+      # after reconnecting, the transport `@after_reconnect`
+      # callback is called. If a connection monitor (timer) already
+      # exists, it is canceled.
+      def monitor_connections
+        @connection_monitor.cancel if @connection_monitor
+        @connection_monitor = EM::PeriodicTimer.new(3) do
+          if !connected?
+            reconnect(true)
+          elsif @reconnecting
+            @after_reconnect.call
+            @reconnecting = false
+          end
+        end
+      end
+
+      # Return or setup a named Redis connection. This method creates
+      # a Redis connection object using the provided Redis transport
+      # options. Redis auto-reconnect is disabled as the connection
+      # "pool" is monitored as a whole. The transport `@on_error`
+      # callback is called when Redis errors are encountered. This
+      # method creates/replaces the connection monitor after setting
+      # up the connection and before adding it to the pool.
+      #
+      # @param name [String] the Redis connection name.
+      # @return [Object]
+      def redis_connection(name)
+        return @connections[name] if @connections[name]
+        connection = EM::Protocols::Redis.connect(@options)
+        connection.auto_reconnect = false
+        connection.reconnect_on_error = false
+        connection.on_error do |error|
+          @on_error.call(error)
+        end
+        monitor_connections
+        @connections[name] = connection
+        connection
+      end
+
+      # Create a Redis key within the defined Redis keyspace. This
+      # method is used to create keys that are unlikely to collide.
+      # The Redis connection database number is included in the Redis
+      # key as pubsub is not scoped to the selected database.
+      #
+      # @param type [String]
+      # @param name [String]
+      # @return [String]
+      def redis_key(type, name)
+        db = @options.is_a?(Hash) ? (@options[:db] || 0) : 0
+        [REDIS_KEYSPACE, db, type, name].join(":")
+      end
+
+      # Publish a message to a Redis channel (PubSub). The
+      # `redis_key()` method is used to create a Redis channel key,
+      # using the transport pipe name. The publish callback info
+      # includes the current subscriber count for the Redis channel.
+      #
+      # http://redis.io/topics/pubsub
+      #
+      # @param pipe [String] the transport pipe name.
+      # @param message [String] the message to be published to the transport.
+      # @yield [info] passes publish info to an optional callback/block.
+      # @yieldparam info [Hash] contains publish information.
+      # @yieldparam subscribers [String] current subscriber count.
+      def pubsub_publish(pipe, message, &callback)
+        channel = redis_key("channel", pipe)
+        redis_connection("redis").publish(channel, message) do |subscribers|
+          info = {:subscribers => subscribers}
+          callback.call(info) if callback
+        end
+      end
+
+      # Subscribe to a Redis channel (PubSub). The `redis_key()`
+      # method is used to create a Redis channel key, using the
+      # transport pipe name. The named Redis connection "pubsub" is
+      # used for the Redis SUBSCRIBE command set, as the Redis context
+      # is limited and enforced for the connection. The subscribe
+      # callback is called whenever a message is published to the
+      # Redis channel. Channel messages with the type "subscribe" and
+      # "unsubscribe" are ignored, only messages with type "message"
+      # are passsed to the provided consumer/method callback/block.
+      #
+      # http://redis.io/topics/pubsub
+      #
+      # @param pipe [String] the transport pipe name.
+      # @yield [info, message] passes message info and content to
+      #   the consumer/method callback/block.
+      # @yieldparam info [Hash] contains the channel name.
+      # @yieldparam message [String] message content.
+      def pubsub_subscribe(pipe, &callback)
+        channel = redis_key("channel", pipe)
+        redis_connection("pubsub").subscribe(channel) do |type, channel, message|
+          case type
+          when "subscribe"
+            @logger.debug("subscribed to redis channel: #{channel}") if @logger
+          when "unsubscribe"
+            @logger.debug("unsubscribed from redis channel: #{channel}") if @logger
+          when "message"
+            info = {:channel => channel}
+            callback.call(info, message)
+          end
+        end
+      end
+
+      # Push (publish) a message onto a Redis list. The `redis_key()`
+      # method is used to create a Redis list key, using the transport
+      # pipe name. The publish callback info includes the current list
+      # size (queued).
+      #
+      # @param pipe [String] the transport pipe name.
+      # @param message [String] the message to be published to the transport.
+      # @yield [info] passes publish info to an optional callback/block.
+      # @yieldparam info [Hash] contains publish information.
+      # @yieldparam queued [String] current list size.
+      def list_publish(pipe, message, &callback)
+        list = redis_key("list", pipe)
+        redis_connection("redis").rpush(list, message) do |queued|
+          info = {:queued => queued}
+          callback.call(info) if callback
+        end
+      end
+
+      # Shift a message off of a Redis list and schedule another shift
+      # on the next tick of the event loop (reactor). Redis BLPOP is a
+      # connection blocking Redis command, this method creates a named
+      # Redis connection for each list. Multiple Redis connections for
+      # BLPOP commands is far more efficient than timer or next tick
+      # polling with LPOP.
+      #
+      # @param list [String]
+      # @yield [info, message] passes message info and content to
+      #   the consumer/method callback/block.
+      # @yieldparam info [Hash] an empty hash.
+      # @yieldparam message [String] message content.
+      def list_blpop(list, &callback)
+        redis_connection(list).blpop(list, 0) do |_, message|
+          EM::next_tick {list_blpop(list, &callback)}
+          callback.call({}, message)
+        end
+      end
+
+      # Subscribe to a Redis list, shifting message off as they become
+      # available. The `redis_key()` method is used to create a Redis
+      # list key, using the transport pipe name. The `list_blpop()`
+      # method is used to do the actual work.
+      #
+      # @param pipe [String] the transport pipe name.
+      # @yield [info, message] passes message info and content to
+      #   the consumer/method callback/block.
+      # @yieldparam info [Hash] an empty hash.
+      # @yieldparam message [String] message content.
+      def list_subscribe(pipe, &callback)
+        list = redis_key("list", pipe)
+        list_blpop(list, &callback)
+      end
+    end
+  end
+end

data/sensu-transport.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "sensu-transport"
-  spec.version       = "2.4.0"
+  spec.version       = "3.0.0"
   spec.authors       = ["Sean Porter"]
   spec.email         = ["portertech@gmail.com"]
   spec.summary       = "The Sensu transport abstraction library"
@@ -17,9 +17,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency("sensu-em")
   spec.add_dependency("amqp", "1.5.0")
+  spec.add_dependency("em-redis-unified", ">= 1.0.0")
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "bouncy-castle-java" if RUBY_PLATFORM =~ /java/
+  spec.add_development_dependency "codeclimate-test-reporter" unless RUBY_VERSION < "1.9"
 end

data/spec/redis_spec.rb

@@ -0,0 +1,159 @@
+require File.join(File.dirname(__FILE__), "helpers")
+require "sensu/transport/redis"
+require "logger"
+
+describe "Sensu::Transport::Redis" do
+  include Helpers
+
+  before do
+    @transport = Sensu::Transport::Redis.new
+    @transport.logger = Logger.new(STDOUT)
+    @transport.logger.level = Logger::FATAL
+  end
+
+  it "provides a transport API" do
+    expect(@transport).to respond_to(:on_error, :before_reconnect, :after_reconnect,
+                                     :connect, :reconnect, :connected?, :close,
+                                     :publish, :subscribe, :unsubscribe,
+                                     :acknowledge, :ack, :stats)
+  end
+
+  it "can publish and subscribe to direct pipes" do
+    async_wrapper do
+      @transport.connect
+      callback = Proc.new do |info, message|
+        expect(info).to be_kind_of(Hash)
+        expect(message).to eq("msg")
+        timer(0.5) do
+          async_done
+        end
+      end
+      @transport.subscribe("direct", "foo", "baz", {}, &callback)
+      @transport.subscribe("direct", "bar", "baz", {}, &callback)
+      timer(1) do
+        @transport.publish("direct", "foo", "msg") do |info|
+          expect(info).to be_kind_of(Hash)
+          expect(info[:queued]).to eq(1)
+        end
+      end
+    end
+  end
+
+  it "can publish and subscribe to fanout pipes" do
+    async_wrapper do
+      @transport.connect
+      callback = Proc.new do |info, message|
+        expect(info).to be_kind_of(Hash)
+        expect(info[:channel]).to eq("transport:0:channel:foo")
+        expect(message).to eq("msg")
+        timer(0.5) do
+          async_done
+        end
+      end
+      @transport.subscribe("fanout", "foo", "baz", {}, &callback)
+      @transport.subscribe("fanout", "bar", "baz", {}, &callback)
+      timer(1) do
+        @transport.publish("fanout", "foo", "msg") do |info|
+          expect(info).to be_kind_of(Hash)
+          expect(info[:subscribers]).to eq(1)
+        end
+      end
+    end
+  end
+
+  it "can scope redis pubsub to the selected database" do
+    async_wrapper do
+      @transport.connect(:db => 1)
+      callback = Proc.new do |info, message|
+        expect(info).to be_kind_of(Hash)
+        expect(info[:channel]).to eq("transport:1:channel:foo")
+        async_done
+      end
+      @transport.subscribe("fanout", "foo", "baz", {}, &callback)
+      timer(1) do
+        @transport.publish("fanout", "foo", "msg")
+      end
+    end
+  end
+
+  it "can unsubscribe and close the connection" do
+    async_wrapper do
+      @transport.connect
+      @transport.subscribe("direct", "bar") do |info, message|
+        true
+      end
+      timer(1) do
+        @transport.unsubscribe do
+          @transport.close
+          timer(1) do
+            expect(@transport.connected?).to be(false)
+            async_done
+          end
+        end
+      end
+    end
+  end
+
+  it "can open and close the connection immediately" do
+    async_wrapper do
+      @transport.connect
+      @transport.close
+      timer(1) do
+        expect(@transport.connected?).to be(false)
+        async_done
+      end
+    end
+  end
+
+  it "can subscribe to a fanout pipe, reconnect, and subscribe to the same pipe again" do
+    async_wrapper do
+      @transport.connect
+      callback = Proc.new do |info, message|
+        expect(info).to be_kind_of(Hash)
+        expect(info[:channel]).to eq("transport:0:channel:foo")
+        expect(message).to eq("msg")
+        timer(0.5) do
+          async_done
+        end
+      end
+      @transport.subscribe("fanout", "foo", "baz", {}, &callback)
+      @transport.reconnect
+      @transport.subscribe("fanout", "foo", "baz", {}, &callback)
+      timer(1) do
+        @transport.publish("fanout", "foo", "msg") do |info|
+          expect(info).to be_kind_of(Hash)
+          expect(info[:subscribers]).to eq(1)
+        end
+      end
+    end
+  end
+
+  it "can get queue stats, message and consumer counts" do
+    async_wrapper do
+      @transport.connect
+      @transport.stats("bar") do |info|
+        expect(info).to be_kind_of(Hash)
+        expect(info[:messages]).to eq(0)
+        expect(info[:consumers]).to eq(0)
+        async_done
+      end
+    end
+  end
+
+  it "can fail to connect" do
+    async_wrapper do
+      @transport.connect(:port => 5555)
+      expect(@transport.connected?).to be(false)
+      async_done
+    end
+  end
+
+  it "will throw an error if it cannot resolve a hostname" do
+    async_wrapper do
+      expect {
+        @transport.connect(:host => "2def33c3-cfbb-4993-b5ee-08d47f6d8793")
+      }.to raise_error
+      async_done
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sensu-transport
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Sean Porter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-31 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sensu-em
@@ -38,6 +38,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: em-redis-unified
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -110,6 +124,7 @@ files:
 - lib/sensu/transport.rb
 - lib/sensu/transport/base.rb
 - lib/sensu/transport/rabbitmq.rb
+- lib/sensu/transport/redis.rb
 - sensu-transport.gemspec
 - spec/assets/rabbitmq.config
 - spec/assets/ssl/ca/cacert.pem
@@ -120,6 +135,7 @@ files:
 - spec/base_spec.rb
 - spec/helpers.rb
 - spec/rabbitmq_spec.rb
+- spec/redis_spec.rb
 - spec/transport_spec.rb
 homepage: https://github.com/sensu/sensu-transport
 licenses:
@@ -155,4 +171,5 @@ test_files:
 - spec/base_spec.rb
 - spec/helpers.rb
 - spec/rabbitmq_spec.rb
+- spec/redis_spec.rb
 - spec/transport_spec.rb