superbolt 0.1.0

data/lib/superbolt/processor.rb

@@ -0,0 +1,33 @@
+module Superbolt
+  class Processor
+    attr_reader :message, :logger, :block
+    attr_accessor  :start_time, :exception
+
+    def initialize(message, logger, &block)
+      @message = message
+      @logger = logger
+      @block = block
+    end
+
+    def perform
+      start!
+      block.call(message.parse, logger)
+      finish!
+      true
+    rescue Exception => e
+      self.exception = e
+      logger.error("#{e.message}\n#{e.backtrace}")
+      false
+    end
+
+    def start!
+      self.start_time = Time.now
+      logger.info "[#{start_time}] Processing message: #{message.parse}"
+    end
+
+    def finish!
+      end_time = Time.now
+      logger.info "[#{end_time}] Finished message: #{message.parse}\n  in #{start_time - end_time} seconds"
+    end
+  end
+end

data/lib/superbolt/queue.rb

@@ -0,0 +1,93 @@
+module Superbolt
+  class Queue
+    attr_reader :name, :config
+
+    def initialize(name, config=nil)
+      @name = name
+      @config = config || Superbolt.config
+    end
+
+    def connection
+      @connection ||= Connection::Queue.new(name, config)
+    end
+
+    delegate :close, :closing, :exclusive?, :durable?, :auto_delete?,
+      :writer, :channel, :q,
+        to: :connection
+
+    def push(message)
+      closing do
+        writer.publish(message.to_json, routing_key: name)
+      end
+    end
+
+    def size
+      closing do
+        q.message_count
+      end
+    end
+
+    def clear
+      closing do
+        q.purge
+      end
+    end
+
+    # TODO: roll up some of these subscribe methods
+
+    def read
+      messages = []
+      closing do
+        q.subscribe(:ack => true) do |delivery_info, metadata, payload|
+          message = IncomingMessage.new(delivery_info, payload, channel)
+          messages << message
+        end
+      end
+      messages
+    end
+
+    def all
+      read.map(&:parse)
+    end
+
+    def peek
+      all.first
+    end
+
+    def pop
+      messages = []
+      closing do
+        popped = false
+        q.subscribe(:ack => false) do |delivery_info, metadata, message|
+          next if popped
+          messages << IncomingMessage.new(delivery_info, message, channel)
+          popped = true
+        end
+      end
+      message = messages.first
+      message && message.parse
+    end
+
+    delegate :slice, :[],
+      to: :all
+
+    def delete
+      messages = []
+      closing do
+        q.subscribe(:ack => true) do |delivery_info, metadata, payload|
+          message = IncomingMessage.new(delivery_info, payload, channel)
+          relevant = yield(message.parse)
+          if relevant
+            messages << message.parse
+            message.ack
+          end
+        end
+
+        # channel is closed by block before message ack can complete
+        # therefore we must sleep :(
+        sleep 0.02
+      end
+      messages
+    end
+  end
+end

data/lib/superbolt/version.rb

@@ -0,0 +1,3 @@
+module Superbolt
+  VERSION = "0.1.0"
+end

data/lib/superbolt.rb

@@ -0,0 +1,22 @@
+require 'json'
+
+require 'bunny'
+require 'amqp'
+require 'active_support/core_ext/module/delegation'
+
+require "superbolt/version"
+require "superbolt/config"
+require "superbolt/adapter/base"
+require "superbolt/adapter/bunny"
+require "superbolt/adapter/amqp"
+require "superbolt/connection/base"
+require "superbolt/connection/queue"
+require "superbolt/connection/app"
+require "superbolt/queue"
+require "superbolt/incoming_message"
+require "superbolt/app"
+require "superbolt/processor"
+require "superbolt/facade"
+require "superbolt/messenger"
+
+$stdout.sync = true

data/spec/app_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Superbolt::App do
+  let(:env)         { 'test' }
+  let(:name)        { 'superbolt' }
+  let(:logger)      { Logger.new('/dev/null') }
+  let(:app)         {
+                       Superbolt::App.new(name, {
+                         env: env,
+                         logger: logger
+                       })
+                    }
+  let(:queue)       { Superbolt::Queue.new("#{name}_#{env}") }
+  let(:quit_queue)  { Superbolt::Queue.new("#{name}_#{env}.quit") }
+  let(:error_queue) { Superbolt::Queue.new("#{name}_#{env}.error") }
+  let(:messages)    { [] }
+
+  before do
+    queue.clear
+    quit_queue.clear
+    error_queue.clear
+  end
+
+  describe '#run' do
+    it "shuts down with any message to the quit queue" do
+      queue.push({please: 'stop'})
+
+      app.run do |arguments|
+        quit_queue.push({message: 'just because'})
+      end
+
+      queue.size.should == 0
+      quit_queue.size.should == 0
+    end
+
+    it 'passes messages to the block for processing' do
+      queue.push({first: 1})
+      queue.push({last: 2})
+
+      app.run do |message, logger|
+        messages << message
+        quit_queue.push({message: 'quit'}) if message['last']
+      end
+
+      messages.size.should == 2
+      messages.should == [
+        {'first' => 1},
+        {'last' => 2}
+      ]
+    end
+
+    it 'removes messages from the queue on successful completion' do
+      queue.push({first: 1})
+      queue.push({last: 2})
+
+      app.run do |message, logger|
+        messages << message
+        quit_queue.push({message: 'quit'}) if message['last']
+      end
+
+      queue.size.should == 0
+    end
+
+
+    it "passes a logger to the block" do
+      mock_logger = double
+      app.logger = mock_logger
+
+      message_received = false
+      mock_logger.stub(:info) do |m|
+        if m == {'write' => 'out'}
+          message_received = true
+        end
+      end
+
+      queue.push({write: 'out'})
+
+      app.run do |message, logger|
+        logger.info(message)
+        quit_queue.push({message: 'stop!'})
+      end
+
+      message_received.should be_true
+    end
+
+    it "moves the message to an error queue if an exception is raised" do
+      queue.push({oh: 'noes'})
+
+      app.run do |message|
+        quit_queue.push({message: 'halt thyself'})
+        raise "something went wrong"
+      end
+
+      queue.size.should == 0
+      error_queue.size.should == 1
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Superbolt::Config do
+  let(:config) {
+    Superbolt::Config.new(options)
+  }
+
+  let(:options) {
+    {}
+  }
+
+  describe '#connection' do
+    context "environmental variables" do
+      context 'default behavior' do
+        let(:old_value) { ENV['RABBITMQ_URL'] }
+        let(:url) { 'http://cloudamqp-url.com' }
+
+        before do
+          old_value
+          ENV['RABBITMQ_URL'] = url
+        end
+
+        after do
+          ENV['RABBITMQ_URL'] = old_value
+        end
+
+        it "returns the RABBITMQ_URL" do
+          config.connection_params.should == url
+        end
+      end
+
+      context 'additional configuration passed in' do
+        let(:old_value) { ENV['SOMEOTHERURL'] }
+        let(:url) { 'http://someother-url.com' }
+        let(:options) {
+          {connection_key: 'SOMEOTHERURL'}
+        }
+
+        before do
+          old_value
+          ENV['SOMEOTHERURL'] = url
+        end
+
+        after do
+          ENV['SOMEOTHERURL'] = old_value
+        end
+
+        it "returns the url specified in the env" do
+          config.connection_params.should == url
+        end
+      end
+    end
+
+    context 'no environmental variables' do
+      context 'default' do
+        it "uses the default url" do
+          config.connection_params.should == {
+            :host => '127.0.0.1'
+          }
+        end
+      end
+
+      context 'connection params passed in' do
+        let(:options) {
+          {
+            connection_params: {
+              :host => 'hoo.com'
+            }
+          }
+        }
+
+        it "uses what it is given" do
+          config.connection_params.should == options[:connection_params]
+        end
+      end
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Superbolt::Adapter::Bunny do
+  let(:connection) { Superbolt::Adapter::Bunny.new }
+
+  it "has an underlying open connection via Bunny" do
+    connection.socket.should be_a Bunny::Session
+    connection.socket.should be_open
+    connection.should be_open
+  end
+
+  it "has a channel" do
+    connection.channel.should be_a Bunny::Channel
+  end
+
+  it "delegates queue creation to the channel" do
+    queue = connection.queue('changelica')
+    queue.should be_a Bunny::Queue
+    connection.queues.keys.should include('changelica')
+  end
+end

data/spec/messenger_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Superbolt::Messenger do
+  let(:env) { 'test' }
+  let(:name) { 'my_friend_app' }
+  let(:queue) { Superbolt::Queue.new("#{name}_#{env}") }
+
+  before do
+    queue.clear
+    Superbolt.env = env
+    Superbolt.app_name = nil
+  end
+
+  let(:messenger) { Superbolt::Messenger.new }
+
+  describe 'queue generation' do
+    it "can be instantiated with a queue destination" do
+      m = Superbolt::Messenger.new(to: name)
+      m.name.should == name
+      m.queue.name.should == "#{name}_#{env}"
+    end
+
+    it "destination queue can be set via #from" do
+      messenger.to('activator')
+      messenger.queue.name.should == "activator_#{env}"
+    end
+
+    it "raises an error if the name is nil" do
+      expect {
+        messenger.queue
+      }.to raise_error
+    end
+  end
+
+  describe 'underlying message' do
+    let(:message) { messenger.message }
+
+    it "starts its life with no interesting values" do
+      message[:origin].should == nil
+      message[:event].should == 'default'
+      message[:arguments].should == {}
+    end
+
+    it "calls to #from, set the origin on the message" do
+      messenger.from('linkticounter')
+      message[:origin].should == 'linkticounter'
+    end
+
+    it "passes event data to the message" do
+      messenger.re('zap')
+      message[:event].should == 'zap'
+    end
+
+    it "passes data to the message" do
+      messenger.data({foo: 'bar'})
+      message[:arguments].should == {foo: 'bar'}
+    end
+  end
+
+  describe 'send!' do
+    before do
+      messenger
+        .to(name)
+        .from('me')
+        .re('love')
+    end
+
+    it "returns a hash that gets sent to the right queue" do
+      messenger.send!('none')
+      queue.pop.should == {
+        'origin' => 'me',
+        'event' => 'love',
+        'arguments' => 'none'
+      }
+    end
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe 'Superbolt::Queue' do
+  let(:name) { 'superbolt_test' }
+  let(:connection) { Superbolt::Connection.new }
+  let(:queue) { Superbolt::Queue.new(name) }
+  let(:messages) { [] }
+
+  before do
+    queue.clear
+  end
+
+  it "has the right name" do
+    queue.name.should == name
+  end
+
+  it "is setup with the right defaults" do
+    queue.exclusive?.should be_false
+    queue.durable?.should be_true
+    queue.auto_delete?.should be_false
+  end
+
+  describe 'queue/array operations' do
+    let(:message) { {hello: 'insomniacs'} }
+    let(:decoded) { {'hello' => 'insomniacs'} }
+
+    describe '#push' do
+      let(:bunny_queue) {connection.queue(name, Superbolt::Queue.default_options)}
+      
+      it "writes to the queue" do
+        queue.push(message)
+        queue.size.should == 1
+      end
+    end
+
+    describe '#peek' do
+      it "returns the message but leaves it in the queue" do
+        queue.push(message)
+        queue.peek.should == decoded
+        queue.size.should == 1 
+      end
+    end
+
+    describe '#pop' do
+      it "returns the message and deletes it from the queue" do
+        queue.push(message)
+        queue.pop.should == decoded
+        queue.size.should == 0
+      end
+    end
+
+    describe '#all' do
+      before do
+        queue.push(message)
+        queue.push(message)
+        queue.push(message)
+      end
+
+      it "returns all the messages on the queue" do
+        messages = queue.all
+        messages.size.should == 3
+        messages.uniq.should == [decoded]
+      end
+
+      it "does not consume the messages" do
+        queue.size.should == 3
+      end
+    end
+
+    describe '#slice(offset, n)' do
+      before do
+        (0..9).to_a.each do |i|
+          queue.push(message.merge(i: i))
+        end
+      end
+
+      it "returns a set of messages determined by the offset and the number requested" do
+        messages = queue.slice(1,3)
+        messages.size.should == 3
+        messages.map{|json| json['i']}.should == [1,2,3]
+      end
+
+      it "does not consume messages" do
+        queue.slice(1,3)
+        queue.size.should == 10
+      end
+    end
+
+    describe '#[i]' do
+      before do
+        (0..9).to_a.each do |i|
+          queue.push(message.merge(i: i))
+        end
+      end
+
+      it "return the message at the i-th position without removing it from the queue" do
+        json = queue[3]
+        json['i'].should == 3
+      end
+    end
+
+    describe '#delete(&block)' do
+      before do
+        (0..9).to_a.each do |i|
+          queue.push(message.merge(i: i))
+        end
+      end
+
+      it "returns all messages where the block is true" do
+        messages = queue.delete{|json| json['i'] > 2 && json['i'] != 6 && json['i'] < 8 }
+        messages.map{|json| json['i']}.should == [3,4,5,7]
+      end
+
+      it "removes those messages from the queue" do
+        queue.delete{|json| json['i'] > 2 && json['i'] != 6 && json['i'] < 8 }
+        queue.size.should == 6
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+here = File.dirname(__FILE__)
+require "#{here}/../lib/superbolt"
+Dir["#{here}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.color = true
+  config.order = :rand
+end

data/spec/superbolt_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Superbolt, 'the facade' do
+  describe '.config' do
+    after do
+      Superbolt.instance_eval do
+        @config = nil
+      end
+    end
+
+    it "stores the default" do
+      Superbolt.config.should == Superbolt::Config.new
+    end
+
+    it "can be customized" do
+      Superbolt.config = {
+        connection_key: 'SOME_RABBITMQ_URL'
+      }
+
+      Superbolt.config.env_connection_key.should == 'SOME_RABBITMQ_URL'
+    end
+  end
+
+  describe '.queue' do
+    it "creates a queue with the default config" do
+      queue = double('queue')
+      Superbolt::Queue.should_receive(:new)
+        .with('queue_name', Superbolt.config)
+        .and_return(queue)
+      Superbolt.queue('queue_name').should == queue
+    end
+  end
+
+  describe '.message' do
+    it "sends messages via the messenger system" do
+      queue = Superbolt.queue('activator_test')
+      queue.clear
+      Superbolt.env = 'test'
+      Superbolt.app_name = 'bossanova'
+
+      Superbolt.message
+        .to('activator')
+        .re('update')
+        .send!({class: 'Advocate'})
+
+      queue.pop.should == {
+        'origin' => 'bossanova',
+        'event' => 'update',
+        'arguments' => {
+          'class' => 'Advocate'
+        }
+      }
+    end
+  end
+end

data/spec/support/queue_helpers.rb

@@ -0,0 +1,7 @@
+def queue_name
+  'superbolt_test'
+end
+
+def clear_queue(name=queue_name)
+  #Bunny.
+end

data/superbolt.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'superbolt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "superbolt"
+  spec.version       = Superbolt::VERSION
+  spec.authors       = ["socialchorus"]
+  spec.email         = ["developers@socialchorus.com"]
+  spec.description   = %q{Superbolt is comprised of a standalone app, and a queue-like queue for sending messages between services and applications.}
+  spec.summary       = %q{Superbolt is a gem that makes SOA intra-app communication easy, via RabbitMQ}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"
+  spec.add_dependency "amqp"
+  spec.add_dependency "bunny", "~> 0.9.0.rc1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end