hivent 1.0.1

data/lib/hivent/redis/lua/producer.lua

@@ -0,0 +1,27 @@
+local event        = ARGV[1]
+local payload      = ARGV[2]
+local partition_id = ARGV[3]
+
+local function concat_tables_uniq(table1, table2)
+  for i=1, #table2 do table.insert(table1, table2[i]) end
+  local set = {}
+  for _, l in ipairs(table1) do set[l] = true end
+  local uniq = {}
+  for i, _ in pairs(set) do table.insert(uniq, i) end
+  return uniq
+end
+
+local function produce(event, payload, partition_id)
+  local consumers = concat_tables_uniq(redis.call("SMEMBERS", event), redis.call("SMEMBERS", "*"))
+
+  for _, consumer in ipairs(consumers) do
+    local partition_count = tonumber(redis.call("GET", consumer .. ":partition_count"))
+    local partition = partition_id % partition_count
+    local queue = consumer .. ":" .. partition
+
+    redis.call("LPUSH", queue, payload)
+  end
+
+end
+
+produce(event, payload, tonumber(partition_id))

data/lib/hivent/redis/producer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Hivent
+
+  module Redis
+
+    class Producer
+
+      include Hivent::Redis::Extensions
+
+      LUA_PRODUCER = File.expand_path("../lua/producer.lua", __FILE__)
+
+      def initialize(redis)
+        @redis = redis
+      end
+
+      def write(name, payload, partition_key)
+        script(LUA_PRODUCER, name, payload, partition_key)
+      end
+
+    end
+
+  end
+
+end

data/lib/hivent/redis/redis.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'redis'
+
+module Hivent
+
+  module Redis
+
+    def self.redis
+      @@redis ||= ::Redis.new(url: Hivent::Config.endpoint)
+    end
+
+  end
+
+end

data/lib/hivent/redis/signal.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'zlib'
+require 'hivent/redis/producer'
+
+module Hivent
+
+  module Redis
+
+    class Signal < AbstractSignal
+
+      MAX_TRIES   = 4
+      SLEEP       = ->(n) { (n**4) * 0.01 }
+
+      def initialize(*args)
+        super
+
+        @producer = Producer.new(redis)
+      end
+
+      private
+
+      def send_message(message, key, _version)
+        Retryable.retryable(tries: MAX_TRIES, sleep: SLEEP) do
+          producer.write(name, message.to_json, key)
+        end
+      end
+
+      def redis
+        Hivent::Redis.redis
+      end
+
+    end
+
+  end
+
+end

data/lib/hivent/rspec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'hivent/spec'
+
+RSpec.configure do |config|
+  config.include Hivent::Spec
+
+  config.before :each do |_example|
+    Hivent::Spec::Signal.reset!
+  end
+
+end

data/lib/hivent/signal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Hivent
+
+  module Signal
+
+    # pretend Signal is a class so that using backends is transparent
+    def self.new(*args)
+      klass = "Hivent::#{Hivent::Config.backend.to_s.camelize}::Signal"
+      klass.constantize.new(*args)
+    end
+
+  end
+
+end

data/lib/hivent/spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'hivent/spec/signal'
+require 'hivent/spec/matchers'
+
+module Hivent
+
+  module Spec
+
+  end
+
+end

data/lib/hivent/spec/matchers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'hivent/spec/matchers/emit'
+
+module Hivent
+
+  module Spec
+
+    module Matchers
+
+    end
+
+  end
+
+end

data/lib/hivent/spec/matchers/emit.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+module Hivent
+
+  module Spec
+
+    module Matchers
+
+      class Emit
+
+        def initialize(name, meta)
+          @name = name
+          @meta = meta
+        end
+
+        def emitted?
+          before = signals.length
+
+          yield
+
+          signals.length > before
+        end
+
+        def emitted_with_payload?(payload)
+          before = signals_with_payload(payload).length
+
+          yield
+
+          signals_with_payload(payload).length > before
+        end
+
+        def signals
+          messages
+            .lazy
+            .select { |signal| signal[:name] == @name }
+            .select do |signal|
+              @meta.all? do |key, value|
+                !value.present? ||
+                value == signal[:message][:meta][key]
+              end
+            end
+            .to_a
+        end
+
+        def signals_with_payload(payload)
+          signals.select { |signal| deep_include?(signal[:message][:payload], payload) }
+        end
+
+        private
+
+        def messages
+          Signal.messages
+        end
+
+        def deep_include?(hash, sub_hash)
+          sub_hash.keys.all? do |key|
+            if hash.has_key?(key) && sub_hash[key].is_a?(Hash) && hash[key].is_a?(Hash)
+              deep_include?(hash[key], sub_hash[key])
+            else
+              hash[key] == sub_hash[key]
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+RSpec::Matchers.define :emit do |name, meta = {}|
+  matcher = Hivent::Spec::Matchers::Emit.new(name, meta)
+
+  match do |actual|
+    if actual.is_a?(Proc)
+      if payload.present?
+        matcher.emitted_with_payload?(payload, &actual)
+      else
+        matcher.emitted?(&actual)
+      end
+    end
+  end
+
+  chain :with, :payload
+
+  failure_message do |_actual|
+    message = %{expected to have emitted a signal with name "#{name}"}
+
+    unless meta.empty?
+      message += ", meta #{meta.inspect}"
+    end
+
+    if payload.present?
+      message += " and payload #{payload.inspect}"
+    end
+
+    message
+  end
+
+  failure_message_when_negated do |_actual|
+    message = %{expected not to have emitted a signal with name "#{name}"}
+
+    unless meta.empty?
+      message += ", meta #{meta.inspect}"
+    end
+
+    if payload.present?
+      message += " and payload #{payload.inspect}"
+    end
+
+    message
+  end
+
+  supports_block_expectations
+end

data/lib/hivent/spec/signal.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'hivent/abstract_signal'
+
+module Hivent
+
+  module Spec
+
+    class Signal < AbstractSignal
+
+      def self.reset!
+        @store = []
+      end
+
+      def self.messages
+        @store ||= []
+      end
+
+      def initialize(*args)
+        super
+      end
+
+      def messages
+        self.class.messages
+      end
+
+      def emit(_payload, version:, cid: nil, key: nil)
+        super.tap do |message|
+          begin
+            Hivent.emitter.broadcast(message)
+
+            report_success(name, version, message)
+          rescue => e
+            report_failure(e, message)
+          end
+        end
+      end
+
+      private
+
+      def life_cycle_event_handler
+        Hivent::Config.life_cycle_event_handler
+      end
+
+      def report_success(name, version, message)
+        life_cycle_event_handler.try(:event_processing_succeeded, name, version, message)
+      end
+
+      def report_failure(e, message)
+        life_cycle_event_handler.try(:event_processing_failed, e, message, message.to_json, "queue")
+      end
+
+      def send_message(message, _key, _version)
+        messages << { name: @name, message: message }
+      end
+
+    end
+
+  end
+
+end

data/lib/hivent/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Hivent
+
+  VERSION = File.read(File.expand_path('../../../.version', __FILE__)).strip.freeze
+
+end

data/spec/codeclimate_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end

data/spec/fixtures/cli/bootstrap_consumers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+Hivent.configure do |config|
+  config.backend         = :redis
+  config.endpoint        = REDIS_URL
+  config.partition_count = 2
+  config.client_id       = "test"
+end

data/spec/fixtures/cli/life_cycle_event_test.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+Hivent.configure do |config|
+  config.backend                  = :redis
+  config.endpoint                 = REDIS_URL
+  config.partition_count          = 2
+  config.client_id                = "test"
+  config.life_cycle_event_handler = MyHandler.new
+end

data/spec/hivent/abstract_signal_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Hivent::AbstractSignal do
+
+  class MySignal < Hivent::AbstractSignal
+
+    private
+
+    def send_message(message, key, version)
+      # do nothing
+    end
+
+  end
+
+  let(:signal) do
+    MySignal.new(name)
+  end
+  let(:name)          { "my_signal" }
+  let(:payload)       { { key: "value" } }
+  let(:version)       { 1 }
+  let(:cid)           { nil }
+  let(:partition_key) { nil }
+  let(:client_id)     { "my_client_id" }
+
+  before :each do
+    Hivent.configure do |config|
+      config.backend = :redis
+      config.client_id = client_id
+    end
+  end
+
+  describe "#emit" do
+
+    subject { signal.emit(payload, version: version, cid: cid, key: partition_key) }
+
+    its([:meta]) { is_expected.to be_present }
+    its([:payload]) { is_expected.to be_present }
+    its([:payload, :key]) { is_expected.to eq("value") }
+
+    context "contains meta data with" do
+
+      context "when correlation ID is omitted" do
+        its([:meta, :cid]) { is_expected.to be_present }
+      end
+
+      context "when correlation ID is passed" do
+        let(:cid)          { "cid" }
+        its([:meta, :cid]) { is_expected.to eq(cid) }
+      end
+
+      its([:meta, :producer])   { is_expected.to eq(client_id) }
+      its([:meta, :created_at]) { is_expected.to be_present }
+      its([:meta, :name])       { is_expected.to eq(name) }
+      its([:meta, :version])    { is_expected.to eq(version) }
+      its([:meta, :event_uuid]) { is_expected.to be_present }
+
+    end
+
+    context "when a key is provided" do
+      let(:partition_key) { SecureRandom.hex }
+
+      it "sends the message using the given key as the partition key" do
+        expect(signal).to receive(:send_message).once
+          .with(anything, Zlib.crc32(partition_key), anything)
+
+        subject
+      end
+    end
+
+    context "when a key is not provided" do
+      let(:partition_key) { nil }
+
+      it "sends the message using a partition key derived from the message" do
+        allow(signal).to receive(:send_message).once
+          .with(anything, Zlib.crc32(payload.to_json), anything)
+
+        subject
+      end
+    end
+
+  end
+
+  describe "#receive" do
+    after :each do
+      Hivent.emitter.remove_listener name
+      Hivent.emitter.events.clear
+    end
+
+    it "receives events for this signal with their payload" do
+      emitted_payload  = { foo: "bar" }
+      received_payload = nil
+
+      signal.receive do |payload|
+        received_payload = payload
+      end
+
+      Hivent.emitter.emit(name, emitted_payload)
+
+      expect(received_payload).to equal(emitted_payload)
+    end
+
+    context "when a version is not specified" do
+      let(:version) { nil }
+
+      it "receives events transmitted using only the signal's name" do
+        counter = 0
+
+        signal.receive { counter += 1 }
+
+        expect { Hivent.emitter.emit name }.to change { counter }.by(1)
+      end
+
+      it "stores the event in the consumer" do
+        signal.receive {}
+        expect(Hivent.emitter.events).to include(name: name, version: version)
+      end
+
+    end
+
+    context "when a version is specified" do
+      let(:version) { 2 }
+
+      it "receives events transmitted using the signal's name and version" do
+        counter = 0
+
+        signal.receive(version: version) { counter += 1 }
+
+        expect { Hivent.emitter.emit "#{name}:#{version}" }.to change { counter }.by(1)
+      end
+
+      it "stores the event in the consumer" do
+        signal.receive(version: version) {}
+        expect(Hivent.emitter.events).to include(name: name, version: version)
+      end
+
+    end
+
+    context "with a wildcard signal" do
+      let(:signal) do
+        MySignal.new("*")
+      end
+
+      it "receives events for all signals signal with their payloads" do
+        received_payloads = []
+
+        signal.receive do |payload|
+          received_payloads << payload
+        end
+
+        Hivent.emitter.emit(Hivent::Emitter::WILDCARD, foo: "bar")
+        Hivent.emitter.emit(Hivent::Emitter::WILDCARD, foo: "baz")
+
+        expect(received_payloads).to eq([{ foo: "bar" }, { foo: "baz" }])
+      end
+
+    end
+
+  end
+
+end