roundhousekiq 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3d38ff3867de7878b149a1d42eec8cb890a8e56
+  data.tar.gz: b2b98a7563c1a9b1e5bf6710108f3fcd9f9f39ef
+SHA512:
+  metadata.gz: b3a50b8d5dbe7c744d4bcea0cf5a00bc7baf97a70c943dab37ff4b3876fd2ec4e3d7ce372a799f0235411e4494f0d3532445d3ee88c318474983e59fd539241d
+  data.tar.gz: e97745b71d28ded61c9197fefe0a6e93227413c0d82579ae36d0a025a2fe3e624d33a09a6a5bc2a29edaa3189e17434a47aee3f778b29efa4acc77ba271a6e42

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--format Nc
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+roundhousekiq

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+addons:
+  code_climate:
+    repo_token: f2f7c01bd01cde392292bbd6fea2e9aa64f6fc2dd6d599ff4f01123985d489cd

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,44 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Moritz Lawitschka
+
+MIT License
+
+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,120 @@
+![Chuck Norris](chuck-norris.png)
+
+# Roundhousekiq
+
+![Gem version](https://img.shields.io/gem/v/roundhousekiq.svg?style=flat)
+![Build Status](https://img.shields.io/travis/suitepad-gmbh/roundhousekiq.svg?style=flat)
+![License MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)
+![CC Score](https://img.shields.io/codeclimate/github/suitepad-gmbh/roundhousekiq.svg?style=flat)
+![Coverage](https://img.shields.io/codeclimate/coverage/github/suitepad-gmbh/roundhousekiq.svg?style=flat)
+
+Small AMQP to Sidekiq bridge, allowing Sidekiq jobs to be triggered via AMQP.
+You define your Sidekiq jobs as usual, but instead of manually invoking the
+jobs, you define to which AMQP event the worker should listen on.
+
+Take for example a fleet of services all reporting their current status every
+once in a while to your central monitoring service. Because these services do
+not care about when their status report is being processed and by whom, they
+simple send it via your AMQP server's `status` exchange and let others handle
+the rest.
+
+The monitoring service now uses Roundhousekiq to asynchronously process these
+status reports and to keep the load from the main server process, it does the
+processing in background using Sidekiq. Simply set up a new Sidekiq worker,
+specify the AMQP exchange and routing key to listen on, and let Roundhousekiq
+handle the AMQP bindings and finding the right worker for each message:
+
+```ruby
+class StatusWorker
+  include Sidekiq::Worker
+  include Roundhousekiq::Worker
+
+  # AMQP configuration
+  exchange_name 'status'
+  exchange_type :topic
+  queue_name    'roundhousekiq_status_worker'
+  routing_key   'status.*'
+
+  # Attributes:
+  #   payload: Parsed JSON payload directly from AMQP
+  def perform(payload)
+    # Heavy computing action...
+  end
+
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'roundhousekiq'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install roundhousekiq
+
+## Usage
+
+1. Create an initializer in _config/initializers/roundhousekiq.rb_ and specify
+your AMQP host.
+
+  ```ruby
+  Roundhousekiq.configure do |config|
+    # AMQP host address
+    # config.host = '127.0.0.1'
+
+    # AMQP host port
+    # config.port = '5672'
+
+    # AMQP vhost to be connected to
+    # config.vhost = '/'
+
+    # User credentials
+    # config.username = 'guest'
+    # config.password = 'guest'
+
+    # Prefetch count on all queues Roundhousekiq will subscribe to
+    # config.prefetch = 256
+  end
+  ```
+
+2. Create your first worker. This worker does only differ from a normal Sidekiq
+worker in the `Roundhousekiq::Worker` module being included and specifying which
+exchange and routing key to listen on:
+
+  ```ruby
+  class Worker
+    include Sidekiq::Worker
+    include Roundhousekiq::Worker
+
+    exchange_name 'amq.topic'
+    exchange_type :topic
+    queue_name    'worker'
+    routing_key   'work'
+
+    def perform(payload)
+      # ...
+    end
+  end
+  ```
+
+  A persistent queue named _worker_ bound to the _amq.topic_ exchange with the
+  routing key _work_ will be created. Each time a message arrives in that
+  queue, this worker will be triggered.
+
+  You do not have to specify a queue name, if you do not want to have a
+  persistent queue. AMQP will automatically create a queue for that worker,
+  which is being deleted once the Roundhousekiq daemon shuts down.
+
+3. Run the Roundhousekiq daemon from the root of your Rails project:
+
+  ```shell
+  $ bundle exec roundhousekiq
+  ```

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/spec`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'documentation']
+end
+
+task :default => :spec

data/bin/roundhousekiq

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# Load Rails environment
+ENV['RAILS_ENV'] ||= 'development'
+require File.expand_path('./config/boot')
+require File.expand_path('./config/environment')
+
+# Always pre-load Rails application
+::Rails.application.eager_load!
+
+runner = Roundhousekiq::Runner.new
+runner.run
+
+# Trap `Kill `
+Signal.trap("TERM") do
+  runner.shutdown
+end

data/lib/roundhousekiq/configuration.rb

@@ -0,0 +1,15 @@
+module Roundhousekiq
+  class Configuration < Struct.new(:host, :port, :vhost, :username, :password, :prefetch)
+    def initialize
+      # AMQP connection
+      self.host     = '127.0.0.1'
+      self.port     = '5672'
+      self.vhost    = '/'
+      self.prefetch = 256
+
+      # AMQP auth
+      self.username = 'guest'
+      self.password = 'guest'
+    end
+  end
+end

data/lib/roundhousekiq/runner.rb

@@ -0,0 +1,103 @@
+module Roundhousekiq
+  class Runner
+
+    attr_accessor :connection, :channel, :queue, :consumer, :shutdown_runner,
+                  :exchange, :error_exchange, :queues, :queue_worker_map
+
+    ##################################
+    # Public API
+    ##################################
+
+    def initialize
+      self.queues = []
+      self.queue_worker_map = {}
+    end
+
+    def run
+      establish_connection
+      create_channel
+      create_exchanges_and_queues
+      setup_subscribers
+    end
+
+    def shutdown
+      # Give runner time to finish its work
+      self.shutdown_runner = true
+      sleep 10
+
+      # Spawn new thread for closing the connection. Connection cannot be closed
+      # from current thread (being in TRAP context).
+      Thread.new { self.connection.try :close }
+
+      # Sleep again to wait for connection close
+      sleep 10
+    end
+
+    def shutdown?
+      self.shutdown_runner
+    end
+
+
+    ##################################
+    # Connection
+    ##################################
+
+    def establish_connection
+      options = { properties: self.class.client_settings }
+
+      self.connection = Bunny.new self.class.connection_settings, options
+      self.connection.start
+    end
+
+    def self.connection_settings
+      config = Roundhousekiq.config.to_h
+      config.select { |k, v| %i(host port vhost username password).include? k }
+    end
+
+    def self.client_settings
+      Bunny::Session::DEFAULT_CLIENT_PROPERTIES.merge product: 'Roundhousekiq'
+    end
+
+    def create_channel
+      self.channel = self.connection.create_channel
+      self.channel.prefetch Roundhousekiq.config.prefetch
+      self.channel
+    end
+
+    def create_exchanges_and_queues
+      Workers.definitions.each do |worker, definition|
+        exchange = self.channel.exchange(
+          definition.exchange[:name],
+          type: definition.exchange[:type],
+          durable: true
+        )
+
+        queue = self.channel.queue(
+          definition.queue[:name],
+          auto_delete: definition.queue[:auto_delete],
+          durable: definition.queue[:durable]
+        ).bind(exchange, routing_key: definition.queue[:routing_key])
+
+        self.queues << queue
+        self.queue_worker_map[queue] = worker
+      end
+    end
+
+    def setup_subscribers
+      self.queues.each do |queue|
+        queue.subscribe(manual_ack: true) do |delivery_info, metadata, payload|
+          self.channel.ack delivery_info.delivery_tag
+          process_message queue, payload
+        end
+      end
+
+      while not self.shutdown?
+        sleep 5
+      end
+    end
+
+    def process_message(queue, payload)
+      queue_worker_map[queue].perform_async JSON.parse(payload)
+    end
+  end
+end

data/lib/roundhousekiq/version.rb

@@ -0,0 +1,3 @@
+module Roundhousekiq
+  VERSION = "1.0.0"
+end

data/lib/roundhousekiq/worker.rb

@@ -0,0 +1,26 @@
+module Roundhousekiq
+  module Worker
+    def self.included(base)
+      Workers.register base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def exchange_name(name)
+        Workers.exchange_name_for self, name
+      end
+
+      def exchange_type(type)
+        Workers.exchange_type_for self, type
+      end
+
+      def queue_name(name)
+        Workers.queue_name_for self, name
+      end
+
+      def routing_key(key)
+        Workers.routing_key_for self, key
+      end
+    end
+  end
+end

data/lib/roundhousekiq/worker_definition.rb

@@ -0,0 +1,32 @@
+module Roundhousekiq
+  class WorkerDefinition
+
+    attr_reader :exchange, :queue
+
+    def initialize
+      @exchange = {}
+      @queue = {}
+    end
+
+    def exchange_name=(name)
+      exchange[:name] = name
+    end
+
+    def exchange_type=(type)
+      exchange[:type] = type
+    end
+
+    def queue_name=(name)
+      name ||= '' # Default name to empty string
+
+      queue[:name]        = name
+      queue[:durable]     = name != ''
+      queue[:auto_delete] = name == ''
+    end
+
+    def routing_key=(key)
+      queue[:routing_key] = key
+    end
+
+  end
+end

data/lib/roundhousekiq/workers.rb

@@ -0,0 +1,42 @@
+module Roundhousekiq
+  class Workers
+    class << self
+      def register(worker)
+        if definitions.key? worker
+          warn "Worker class #{worker.to_s} already registered"
+        end
+
+        definitions[worker] = WorkerDefinition.new
+      end
+
+      def definitions
+        @@definitions ||= {}
+      end
+
+      def exchange_name_for(worker, name)
+        definition = definitions[worker]
+        fail "Unknown worker class passed: #{worker}" unless definition
+        definition.exchange_name = name
+      end
+
+      def exchange_type_for(worker, type)
+        definition = definitions[worker]
+        fail "Unknown worker class passed: #{worker}" unless definition
+        definition.exchange_type = type
+      end
+
+      def queue_name_for(worker, name)
+        definition = definitions[worker]
+        fail "Unknown worker class passed: #{worker}" unless definition
+        definition.queue_name = name
+      end
+
+      def routing_key_for(worker, key)
+        definition = definitions[worker]
+        fail "Unknown worker class passed: #{worker}" unless definition
+        definition.routing_key = key
+      end
+    end
+
+  end
+end

data/lib/roundhousekiq.rb

@@ -0,0 +1,19 @@
+require 'bunny'
+require 'roundhousekiq/configuration'
+require 'roundhousekiq/runner'
+require 'roundhousekiq/version'
+require 'roundhousekiq/worker'
+require 'roundhousekiq/workers'
+require 'roundhousekiq/worker_definition'
+
+module Roundhousekiq
+  def self.configure
+    @config = Configuration.new
+    yield(@config) if block_given?
+    @config
+  end
+
+  def self.config
+    @config || configure
+  end
+end

data/roundhousekiq.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'roundhousekiq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "roundhousekiq"
+  spec.version       = Roundhousekiq::VERSION
+  spec.authors       = ["Moritz Lawitschka"]
+  spec.email         = ["moritz.lawitschka@suitepad.de"]
+  spec.summary       = %q{AMQP to Sidekiq bridge}
+  spec.description   = %q{Trigger Sidekiq jobs asynchronously over AMQP}
+  spec.homepage      = "https://github.com/suitepad-gmbh/roundhousekiq"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ['roundhousekiq']
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "bunny", "~> 1.7"
+  spec.add_dependency "sidekiq", "~> 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3.0"
+  spec.add_development_dependency "rspec-nc", "~> 0.2.0"
+  spec.add_development_dependency "guard", "~> 2.13.0"
+  spec.add_development_dependency "guard-rspec", "~> 4.6.4"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/spec/fixtures/dummy_worker.rb

@@ -0,0 +1,6 @@
+require 'sidekiq'
+
+class DummyWorker
+  include Sidekiq::Worker
+  include Roundhousekiq::Worker
+end

data/spec/roundhousekiq/configuration_spec.rb

@@ -0,0 +1,17 @@
+describe Roundhousekiq::Configuration do
+
+  # Method existence
+  it { should respond_to :host }
+  it { should respond_to :host= }
+  it { should respond_to :port }
+  it { should respond_to :port= }
+  it { should respond_to :vhost }
+  it { should respond_to :vhost= }
+  it { should respond_to :username }
+  it { should respond_to :username= }
+  it { should respond_to :password }
+  it { should respond_to :password= }
+  it { should respond_to :prefetch }
+  it { should respond_to :prefetch= }
+
+end