hivent 1.0.1

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.simplecov.template

@@ -0,0 +1 @@
+SimpleCov.start 'test_frameworks'

data/.travis.yml

@@ -0,0 +1,23 @@
+sudo: false # http://docs.travis-ci.com/user/migrating-from-legacy/
+
+services:
+  - redis-server
+
+addons:
+  code_climate:
+    repo_token: fef398071a8b9a86caa653c05372f91be29cd3d31548bd6f9950cb1c4f324ff6
+
+language: ruby
+
+rvm:
+  - 2.3.1
+  - 2.2.5
+
+env:
+  - >
+    REDIS_URL=redis://localhost:6379
+
+cache: bundler
+
+script:
+  - bundle exec rspec

data/.version

@@ -0,0 +1 @@
+1.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Bruno Abrantes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,196 @@
+# Hivent
+
+An event stream implementation that aggregates facts about your application.
+
+## Configuration
+
+### Redis Backend
+
+```ruby
+Hivent.configure do |config|
+  config.backend                  = :redis
+  config.endpoint                 = "redis://localhost:6379/0"
+  config.partition_count          = 4                  
+  config.life_cycle_event_handler = MyHandler.new
+  config.client_id                = "my_app_name"               
+end
+```
+
+## Usage
+
+### Receive
+
+Receiving works on an instance of a `Signal`. For each event received, the given block will be executed once.
+You may either specify a version to receive or decide to receive all events for that signal regardless of their version.
+
+```ruby
+signal = Hivent::Signal.new("model_name:created")
+
+# Handle all events for this signal
+signal.receive do |event|
+  # Do something with the event
+  # event['payload'] contains the payload
+  # event['meta'] contains information about the event
+end
+
+# Handle version 2 events for this signal
+signal.receive(version: 2) do |event|
+  # Do something with the event
+  # event['payload'] contains the payload
+  # event['meta'] contains information about the event
+end
+```
+
+#### Wildcard signals
+
+You can receive all events as well by using the `*` wildcard. Partial wildcards (such as `my_event:*`) are not supported at this time.
+
+```ruby
+signal = Hivent::Signal.new("*")
+
+# Handle all events
+signal.receive do |event|
+  # Do something with the event
+  # event['payload'] contains the payload
+  # event['meta'] contains information about the event
+end
+```
+
+#### Worker process
+
+To receive events, a consumer process needs to be started using the provided CLI.
+
+Start the consumer:
+
+```bash
+bundle exec hivent start -r app/events.rb
+```
+
+For more details on the available options see:
+
+```bash
+bundle exec hivent --help
+bundle exec hivent start --help
+```
+
+##### Daemonization
+The library does not offer any options to daemonize or parallelize your consumers. You are encouraged to use other tools such as [Foreman](https://ddollar.github.io/foreman/) and [Upstart](http://upstart.ubuntu.com) to achieve this.
+
+With these two tools, you can set up a `Procfile` for the consumer:
+
+```
+consumer: bundle exec hivent start -r app/events.rb
+```
+
+And then use Foreman's `export` feature to convert it to an upstart job:
+
+```bash
+foreman export upstart -a myapp -m consumer=4 -u myuser /etc/init
+
+service myapp start
+```
+
+This will start 4 consumer processes running under the `myuser` user. The processes will be daemonized and monitored by upstart.
+If your consumers need environment variables, Foreman can [pick them up from a `.env` file](https://ddollar.github.io/foreman/#ENVIRONMENT) placed next to your `Procfile`:
+
+```
+APP_ENV=production
+REDIS_URL=redis://something:6379
+```
+
+##### Callbacks for Life Cycle Events
+
+To add error reporting or logging of consumed events you can configure an handler that is invoked by the consumer when certain lifecycle events occur.
+To implement this handler create a class that inherits from [`Hivent::LifeCycleEventHandler`](lib/hivent/life_cycle_event_handler.rb) and overwrite one or more of it's methods.
+
+```ruby
+class MyHandler < Hivent::LifeCycleEventHandler
+
+  def application_registered(client_id, events, partition_count)
+    # log info to logging service
+  end
+
+  def event_processing_succeeded(event_name, event_version, payload)
+    # log event processing
+  end
+
+  def event_processing_failed(exception, payload, raw_payload, dead_letter_queue_name)
+    # report to some exception notification service
+  end
+
+end
+```
+
+The handler needs to be configured in the gem's configuration block. The default handler ignores all life cycle events.
+
+### Emit
+
+You can use any name to identify your signals.
+
+All signals are versioned. The version has to be specified as the second parameter of `emit` and will be part of the events meta data.
+
+```ruby
+Hivent::Signal.new("model_name:created").emit({ key: "value" }, version: 1)
+# => Signal name is added as meta attribute "name"
+```
+
+#### Meta Data
+
+Each emitted event will automatically be enriched with meta data containing the correlation ID (`cid`), the `producer` of the event (the `client_id` provided in the configuration block) and the `created_at` timestamp.
+
+The event name and version will be added to the events meta data.
+
+##### Correlation ID
+
+To pass in a correlation ID (e.g. from a previously consumed message) use:
+
+```ruby
+cid = event['meta']['cid']
+Hivent::Signal.new("model_name:created").emit({ key: "value" }, version: 1, cid: cid)
+```
+
+#### Keyed Messages
+
+Sometimes it's required to pass a key alongside the message that is used to assign the message to a specific partition (which ensures order of events within this partition).
+
+```ruby
+signal = Hivent::Signal.new("model_name:created")
+signal.emit({ key: "value" }, key: "my_custom_key")
+```
+
+## Run the Tests
+
+The test suite requires a running Redis server (default: `redis://localhost:6379/15`). To point to a different Redis pass in an environment variable when starting the tests.
+
+```ruby
+REDIS_URL=redis://path_to_redis:port/database bundle exec rspec
+```
+
+## Test Helpers
+
+To help you write awesome tests, an RSpec helper is provided. To use it, require 'hivent/rspec' before running your test suite:
+
+```ruby
+# in spec_helper.rb
+
+require 'hivent/rspec'
+```
+
+### Matchers
+
+#### Emit
+
+Test whether a signal has been emitted. Optionally, you can define a version.
+
+```ruby
+expect { a_method }.to emit('a:signal')
+expect { another_method }.not_to emit('another:signal')
+expect { another_method }.to emit('a:signal', version: 2)
+```
+
+You may also assert whether a signal was emitted with a given payload.
+This matcher asserts that the signal's payload contains the given hash.
+
+```ruby
+expect { subject }.to emit(:event_name).with({ foo: 'bar' })
+```

data/bin/hivent

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require_relative "../lib/hivent/cli/runner"
+
+Hivent::CLI::Runner.new(ARGV.dup).run

data/hivent.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hivent/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hivent"
+  spec.version       = Hivent::VERSION
+  spec.authors       = ["Bruno Abrantes"]
+  spec.email         = ["bruno@brunoabrantes.com"]
+  spec.summary       = "An event stream implementation that aggregates facts about your application"
+  spec.description   = ""
+  spec.homepage      = "https://github.com/inf0rmer/hivent-ruby"
+  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 "activesupport", "~> 5.0"
+  spec.add_dependency "retryable", "~> 2.0"
+  spec.add_dependency "redis", "~> 3.3"
+  spec.add_dependency "event_emitter", "~> 0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "rspec-its", "~> 1.2"
+  spec.add_development_dependency "pry-byebug", "~> 3.4"
+  spec.add_development_dependency "simplecov", "~> 0.12"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.6"
+  spec.add_development_dependency "rubocop", "~> 0.43"
+end

data/lib/hivent.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require "active_support"
+require "active_support/core_ext"
+require "retryable"
+require "json"
+require "event_emitter"
+
+require "hivent/config"
+
+require "hivent/signal"
+require "hivent/abstract_signal"
+require "hivent/emitter"
+
+require "hivent/redis/redis"
+require "hivent/redis/extensions"
+require "hivent/redis/signal"
+require "hivent/life_cycle_event_handler"
+require "hivent/redis/consumer"
+
+module Hivent
+
+  extend self
+
+  def configure
+    block_given? ? yield(Hivent::Config) : Hivent::Config
+  end
+
+  def self.emitter
+    @emitter ||= Emitter.new
+  end
+
+end

data/lib/hivent/abstract_signal.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Hivent
+
+  class AbstractSignal
+
+    attr_reader :name, :producer, :client_id
+
+    def initialize(name)
+      @name        = name
+      @producer    = nil
+      @client_id   = Hivent::Config.client_id
+    end
+
+    def emit(payload, version:, cid: nil, key: nil)
+      build_message(payload, cid, version).tap do |message|
+        send_message(message, partition_key(key, message), version)
+      end
+    end
+
+    def receive(version: nil, &block)
+      Hivent.emitter.on(event_name(version), &block)
+      Hivent.emitter.events << { name: name, version: version }
+    end
+
+    private
+
+    def partition_key(key, message)
+      key = key || message[:payload].to_json
+
+      Zlib.crc32(key)
+    end
+
+    def send_message(_message, _key, _version)
+      raise NotImplementedError
+    end
+
+    def build_message(payload, cid, version)
+      {
+        payload: payload,
+        meta: meta_data(cid, version)
+      }
+    end
+
+    def meta_data(cid, version)
+      {
+        event_uuid: SecureRandom.hex,
+        name:       name,
+        version:    version,
+        cid:        (cid || SecureRandom.hex),
+        producer:   client_id,
+        created_at: Time.now.utc
+      }
+    end
+
+    def event_name(version = nil)
+      return Emitter::WILDCARD if name.to_sym == :*
+
+      version ? "#{name}:#{version}" : name
+    end
+
+  end
+
+end

data/lib/hivent/cli/consumer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "socket"
+require "fileutils"
+require "pathname"
+require "timeout"
+
+module Hivent
+
+  module CLI
+
+    class Consumer
+
+      def self.run!(args)
+        new(args).run!
+      end
+
+      def initialize(options)
+        @options = options
+      end
+
+      def run!
+        configure
+        register_service
+
+        worker_name = "#{Socket.gethostname}:#{Process.pid}"
+        @worker = Hivent::Redis::Consumer.new(@redis, @service_name, worker_name, @life_cycle_event_handler)
+
+        @worker.run!
+      end
+
+      private
+
+      def configure
+        # use load instead of require to allow multiple runs of this method in specs
+        load @options[:require]
+
+        @service_name             = Hivent::Config.client_id
+        @partition_count          = Hivent::Config.partition_count
+        @life_cycle_event_handler = Hivent::Config.life_cycle_event_handler ||
+                                      Hivent::LifeCycleEventHandler.new
+        @events                   = Hivent.emitter.events
+        @redis                    = Hivent::Redis.redis
+      end
+
+      def register_service
+        # TODO: cleanup unused events for this service from the registry
+        @redis.set("#{@service_name}:partition_count", @partition_count)
+
+        @events.each do |event|
+          @redis.sadd(event[:name], @service_name)
+        end
+
+        @life_cycle_event_handler.application_registered(@service_name, @events.deep_dup, @partition_count)
+      end
+
+    end
+
+  end
+
+end