basquiat 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d297e7591c1ea6247edd40cf816fd9886c9f8d7
+  data.tar.gz: 93b240d5a7353ed4ceb65ded88e3de66f64a18d9
+SHA512:
+  metadata.gz: 2fffd158b4d20998d28e100351892571bd952874affb8a18fb83b7cf64d3815b6fbad980ea2826905eda70c88afa33249b10b23d3025a18697e1a1478ed67368
+  data.tar.gz: 45366c9864d178391f97ba52caad3bc6a2c77375a2c360ee66da325a37a3fb75c5066703582f50074acfb5bc2e1a29ab64a0b82168c0d22ed491c437242e2d8a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea
+bin

data/.metrics

@@ -0,0 +1,5 @@
+MetricFu::Configuration.run do |config|
+  config.configure_metric(:cane) do |cane|
+    cane.line_length = 110
+  end
+end

data/.rspec

@@ -0,0 +1,4 @@
+--format documentation
+--color
+--fail-fast
+--order rand

data/.rubocop.yml

@@ -0,0 +1,12 @@
+AllCops:
+  Exclude:
+    - 'bin/*'
+    - 'docker/*'
+Style/LineLength:
+  Max: 109
+
+Style/AlignHash:
+  EnforcedHashRocketStyle: table
+
+Style/Documentation:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+basquiat

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.5

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,17 @@
+guard :bundler do
+  watch('Gemfile')
+  watch('basquiat.gemspec')
+end
+
+guard :rspec, { all_on_start: true, keep: true, all_after_pass: true, run_all: { cmd: 'rspec -f progress'} } do
+  watch(%r{^spec/.+_spec.rb$})
+  watch(%r{^spec/lib/.+_spec.rb$})
+  watch(%r{^lib/basquiat/(.+)\.rb$}) { |matchdata| "spec/lib/#{matchdata[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')       { 'spec' }
+  watch(%r{spec/support/.+\.rb})     { 'spec' }
+end
+
+guard :rubocop, { cli: '-fs -c./.rubocop.yml'} do
+  #watch(%r{.+\.rb$})
+  #watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Marcello Rocha
+
+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,95 @@
+# Basquiat
+
+**Basquiat** is intended to hide (almost) all the complexity of working with some kind of message queue from the application internals.
+
+All the exchanges, connections, queues and sessions declarations are swept under rug. The main aim is to provide a simple yet flexible interface to work with message queues.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'basquiat'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install basquiat
+
+You will also need the right gem for your MQ system. Bundled in this gem you will find 2 adapters for RabbitMQ and ActiveMQ which depends on the gems _bunny_ and _ruby-stomp_ respectively.
+
+## Basic Usage
+
+First of all require the gem, the dependecy for the adapter and the adapter itself
+
+    require 'basquiat'
+    require 'bunny'
+    require 'basquiat/adapters/rabbitmq_adapter'
+
+Then you can extend the class that you will use for communicating with the MQ
+
+    class TownCrier
+      extend Basquiat::Base
+    end
+
+From here you can publish events to the queue
+
+    TownCrier.publish('some.nifty.event', {a: 'hash', of: 'values'})
+
+And you can subscribe to one or more events using a proc that will get called when the message is received:
+
+    class TownCrier
+      extend Basquiat::Base
+
+      subscribe_to 'some.nifty.event', ->(msg) { msg.fetch(:of, '').upcase }
+    end
+
+## Configuration
+
+You can setup Basquiat using the configure method. This method will yield a Configuration object:
+
+    Basquiat.configure do |config|
+      config.exchange_name = 'my_exchange'
+    end
+
+The available options are:
+
+- config_file= Receive a path to an YAML file (example here)
+- queue_name= The default queue name
+- exchange_name= The default exchange name
+- environment= Forces the environment to something other than the value of BASQUIAT_ENV
+- logger= The logger to be used. Defaults to a null logger.
+
+The configuration can be reset using the Basquiat.reset method.
+
+Yaml File configuration example:
+
+    test:                                       #environment
+      exchange_name: 'my.test_exchange'         #required
+      queue_name: 'my.nice_queue'               #required
+      default_adapter: Basquiat::Adapters::Test #it will overwrite the adapter on all classes that extend Basquiat::Base
+      adapter_options:                          #Adapter specific options
+        :servers:
+          -
+            :host: 'localhost'
+            :port: '5672'
+    development:                                #full example of the RabbitMq options 
+      exchange_name: 'my.exchange'
+      queue_name: 'my.queue'
+      default_adapter: Basquiat::Adapters::RabbitMq
+      adapter_options:
+        :servers:
+          -
+            :host: 'localhost'
+            :port: '5672'
+        :failover:
+          :default_timeout: 5
+          :max_retries: 5
+        :publisher: 
+          :confirm: true
+          :persistent: true
+        :auth:
+          :user: 'guest'
+          :password: 'guest' 

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:spec)
+
+task default: :spec
+
+desc 'Loads IRB with the gem already required'
+task :console do
+  system 'irb -I./lib -rbasquiat'
+end

data/basquiat.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'basquiat/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'basquiat'
+  spec.version       = Basquiat::VERSION
+  spec.authors       = ['Marcello "mereghost" Rocha']
+  spec.email         = %w(marcello.rocha@gmail.com.br)
+  spec.description   = <<EOD
+Basquiat is a library that intends to abstract all the complexity of working with message queues
+EOD
+  spec.summary       = 'A pluggable library that aims to hide message queue complexity'
+  spec.homepage      = 'http://www.vagas.com.br/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-bundler'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'guard-rubocop'
+  spec.add_development_dependency 'bunny'
+  spec.add_development_dependency 'stomp'
+  spec.add_development_dependency 'yajl-ruby'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'metric_fu'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_dependency 'multi_json'
+  spec.add_dependency 'naught'
+end

data/docker/Dockerfile

@@ -0,0 +1,11 @@
+FROM mereghost/ruby:latest
+
+RUN useradd -m -g users dev
+
+VOLUME /basquiat
+WORKDIR /basquiat
+
+USER dev
+ENV REFRESHED_AT 2015-03-29
+COPY ../Gemfile /tmp/Gemfile
+RUN bundle install

data/docker/basquiat_start.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/bash
+echo '#### Installing bundle ####'
+bundle install --binstubs
+
+echo '#### Starting guard ####'
+(
+  cd /basquiat
+  bin/guard start -c --no-notify -p
+)

data/docker-compose.yml

@@ -0,0 +1,11 @@
+basquiat:
+  build: docker
+  command: /basquiat/docker/basquiat_start.sh
+  volumes:
+    - ./:/basquiat
+  links:
+    - rabbitmq
+  tty: true
+
+rabbitmq:
+  image: mereghost/rabbitmq:latest

data/lib/basquiat/adapters/base_adapter.rb

@@ -0,0 +1,54 @@
+module Basquiat
+  module Adapters
+    # Base implementation for an adapter
+    module Base
+      using Basquiat::HashRefinements
+
+      def initialize
+        @options = base_options
+        @procs   = {}
+        @retries = 0
+      end
+
+      # Used to set the options for the adapter. It is merged in
+      # to the default_options hash.
+      # @param [Hash] opts an adapter dependant hash of options
+      def adapter_options(opts)
+        @options.deep_merge(opts)
+      end
+
+      # Default options for the adapter
+      # @return [Hash]
+      def base_options
+        default_options.merge(Basquiat.configuration.adapter_options)
+      end
+
+      def default_options
+        {}
+      end
+
+      def update_config
+      end
+
+      def publish
+      end
+
+      def subscribe_to
+      end
+
+      def disconnect
+      end
+
+      def disconnected?
+      end
+
+      private
+
+      attr_reader :procs, :options
+
+      def logger
+        Basquiat.configuration.logger
+      end
+    end
+  end
+end

data/lib/basquiat/adapters/rabbitmq_adapter.rb

@@ -0,0 +1,130 @@
+require 'bunny'
+
+module Basquiat
+  module Adapters
+    # The RabbitMQ adapter for Basquiat
+    class RabbitMq
+      include Basquiat::Adapters::Base
+
+      def default_options
+        { failover:  { default_timeout: 5, max_retries: 5 },
+          servers:   [{ host: 'localhost', port: 5672 }],
+          queue:     { name: Basquiat.configuration.queue_name, options: { durable: true } },
+          exchange:  { name: Basquiat.configuration.exchange_name, options: { durable: true } },
+          publisher: { confirm: true, persistent: false },
+          auth:      { user: 'guest', password: 'guest' } }
+      end
+
+      def subscribe_to(event_name, proc)
+        procs[event_name] = proc
+      end
+
+      def publish(event, message, persistent: options[:publisher][:persistent])
+        with_network_failure_handler do
+          channel.confirm_select if options[:publisher][:confirm]
+          exchange.publish(Basquiat::Json.encode(message), routing_key: event)
+          disconnect unless persistent
+        end
+      end
+
+      def listen(block: true)
+        with_network_failure_handler do
+          procs.keys.each { |key| bind_queue(key) }
+          queue.subscribe(block: block) do |di, _, msg|
+            message = Basquiat::Json.decode(msg)
+            procs[di.routing_key].call(message)
+          end
+        end
+      end
+
+      def connect
+        with_network_failure_handler do
+          connection.start
+          current_server[:retries] = 0
+        end
+      end
+
+      def connection_uri
+        current_server_uri
+      end
+
+      def disconnect
+        connection.close_all_channels
+        connection.close
+        reset_connection
+      end
+
+      def connected?
+        @connection
+      end
+
+      private
+      def with_network_failure_handler
+        yield if block_given?
+      rescue Bunny::ConnectionForced, Bunny::TCPConnectionFailed, Bunny::NetworkFailure => error
+        if current_server.fetch(:retries, 0) <= failover_opts[:max_retries]
+          handle_network_failures
+          retry
+        else
+          raise(error)
+        end
+      end
+
+      def failover_opts
+        options[:failover]
+      end
+
+      def bind_queue(event_name)
+        queue.bind(exchange, routing_key: event_name)
+      end
+
+      def reset_connection
+        @connection, @channel, @exchange, @queue = nil, nil, nil, nil
+      end
+
+      def rotate_servers
+        return unless options[:servers].any? { |server| server.fetch(:retries, 0) < failover_opts[:max_retries] }
+        options[:servers].rotate!
+      end
+
+      def handle_network_failures
+        logger.warn "[WARN] Handling connection to #{current_server_uri}"
+        retries                  = current_server.fetch(:retries, 0)
+        current_server[:retries] = retries + 1
+        if retries < failover_opts[:max_retries]
+          logger.warn("[WARN] Connection failed retrying in #{failover_opts[:default_timeout]} seconds")
+          sleep(failover_opts[:default_timeout])
+        else
+          rotate_servers
+        end
+        reset_connection
+      end
+
+      def connection
+        @connection ||= Bunny.new(current_server_uri)
+      end
+
+      def channel
+        connect
+        @channel ||= connection.create_channel
+      end
+
+      def queue
+        @queue ||= channel.queue(options[:queue][:name], options[:queue][:options])
+      end
+
+      def exchange
+        @exchange ||= channel.topic(options[:exchange][:name], options[:exchange][:options])
+      end
+
+      def current_server
+        options[:servers].first
+      end
+
+      def current_server_uri
+        auth = current_server[:auth] || options[:auth]
+        "amqp://#{auth[:user]}:#{auth[:password]}@#{current_server[:host]}:#{current_server[:port]}"
+      end
+    end
+  end
+end

data/lib/basquiat/adapters/test_adapter.rb

@@ -0,0 +1,52 @@
+module Basquiat
+  module Adapters
+    # An adapter to be used in testing
+    class Test
+      include Basquiat::Adapters::Base
+
+      class << self
+        def events
+          @events ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def clean
+          @events.clear if @events
+        end
+      end
+
+      attr_reader :options
+
+      def default_options
+        @event_names = []
+        { host: '127.0.0.1', port: 123_456, durable: true }
+      end
+
+      def publish(event, message, _single_message = true)
+        self.class.events[event] << Basquiat::Json.encode(message)
+      end
+
+      def events(key)
+        self.class.events[key]
+      end
+
+      def subscribe_to(event_name, proc)
+        @event_names << event_name
+        procs[event_name] = proc
+      end
+
+      def listen(*)
+        event = subscribed_event
+        msg   = self.class.events[event].shift
+        msg ? procs[event].call(Basquiat::Json.decode(msg)) : nil
+      end
+
+      private
+
+      def subscribed_event
+        event = @event_names.first
+        @event_names.rotate!
+        event
+      end
+    end
+  end
+end

data/lib/basquiat/adapters.rb

@@ -0,0 +1,2 @@
+require 'basquiat/adapters/base_adapter'
+require 'basquiat/adapters/test_adapter'

data/lib/basquiat/interfaces/base.rb

@@ -0,0 +1,62 @@
+require 'set'
+
+module Basquiat
+  # base module extend the classes that will use the event infrastructure
+  module Base
+    class << self
+      def extended(klass)
+        descendants.push klass
+      end
+
+      def descendants
+        @descendants ||= []
+      end
+    end
+
+    def reload_adapter_from_configuration
+      @adapter = Kernel.const_get(Basquiat.configuration.default_adapter).new
+      @adapter.adapter_options Basquiat.configuration.adapter_options
+    end
+
+
+    def event_adapter=(adapter)
+      @adapter = adapter.new
+    end
+
+    def adapter
+      @adapter ||= Kernel.const_get(Basquiat.configuration.default_adapter).new
+    end
+
+    def adapter_options(opts = Basquiat.configuration.adapter_options)
+      adapter.adapter_options(opts)
+    end
+
+    def publish(event, message)
+      adapter.publish(event, message)
+    end
+
+    def subscribe_to(event_name, proc)
+      proc = make_callable(proc)
+      adapter.subscribe_to(event_name, proc)
+    end
+
+    def disconnect
+      adapter.disconnect
+    end
+
+    def connected?
+      adapter.connected?
+    end
+
+    def listen(block: true)
+      adapter.listen(block: block)
+    end
+
+    private
+
+    def make_callable(proc)
+      return proc if proc.respond_to? :call
+      method(proc)
+    end
+  end
+end

data/lib/basquiat/rails/railtie.rb

@@ -0,0 +1,14 @@
+module Basquiat
+  class Railtie < ::Rails::Railtie
+    initializer 'load_basquiat_configuration' do
+      ENV['BASQUIAT_ENV'] = Rails.env
+      Basquiat.configure do |config|
+        config.config_file = Rails.root + 'config/basquiat.yml'
+      end
+    end
+
+    config.after_initialize do
+      Basquiat.configuration.reload_classes
+    end
+  end
+end

data/lib/basquiat/support/configuration.rb

@@ -0,0 +1,62 @@
+require 'basquiat/support/hash_refinements'
+require 'naught'
+require 'erb'
+
+module Basquiat
+  DefaultLogger = Naught.build { |config| config.mimic Logger }
+
+  class Configuration
+    using HashRefinements
+
+    attr_writer :queue_name, :exchange_name, :logger, :environment
+
+    def queue_name
+      @queue_name || 'basquiat.queue'
+    end
+
+    def exchange_name
+      @exchange_name || 'basquiat.exchange'
+    end
+
+    def logger
+      @logger || DefaultLogger.new
+    end
+
+    def environment
+      (@environment || ENV['BASQUIAT_ENV'] || 'development').to_sym
+    end
+
+    def config_file=(path)
+      load_yaml(path)
+      setup_basic_options
+    end
+
+    def adapter_options
+      config.fetch(:adapter_options) { Hash.new }
+    end
+
+    def default_adapter
+      config.fetch(:default_adapter) { Basquiat::Adapter::Test }
+    end
+
+    def reload_classes
+      Basquiat::Base.descendants.each do |klass|
+        klass.reload_adapter_from_configuration
+      end
+    end
+
+    private
+    def config
+      @yaml.fetch(environment)
+    end
+
+    def load_yaml(path)
+      @yaml     = YAML.load(ERB.new(IO.readlines(path).join).result).symbolize_keys
+    end
+
+    def setup_basic_options
+      @queue_name    ||= config.fetch(:queue_name) { 'basquiat.exchange' }
+      @exchange_name ||= config.fetch(:exchange_name) { 'basquiat.queue' }
+    end
+  end
+end