banter 0.4.0

data/lib/banter/server/subscriber_server.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'celluloid/autostart'
+require 'celluloid/io'
+require 'awesome_print'
+require 'active_support/all'
+require 'optparse'
+require 'fileutils'
+
+require_relative './client_queue_listener'
+
+# In order to use the server, the caller must be able to bring in the necessary
+# classes for require before instantiating the instance.
+
+module Banter
+  module Server
+
+    class SubscriberServer
+      include Celluloid
+
+      def initialize(subscribers)
+        @workers = subscribers.map { |subscriber| create_queue_listeners(subscriber) }
+      end
+
+      def start
+        @workers.each do |worker|
+          puts "Starting worker: #{worker.worker_class.name}"
+          worker.start
+        end
+
+        thread     = Thread.current
+        interrupts = ["HUP", "INT", "QUIT", "ABRT", "TERM"]
+        interrupts.each do |signal_name|
+          Signal.trap(signal_name) {
+            puts "Processing #{signal_name}"
+            thread.run
+          }
+        end
+
+        Thread.stop
+
+        ::Banter::Logger.new.log_service("all_services", :warn, "Starting shutdown of all services")
+
+        @workers.each do |worker|
+          ::Banter::Logger.new.log_service("all_services", :warn, "Tearing down worker: #{worker.worker_class.name}")
+          begin
+            STDOUT.puts "Tearing down subscriber for #{worker.worker_class.name}"
+            worker.shutdown
+          rescue => e
+            ::Banter::Logger.new.log_service("all_services", :warn, "#{worker.worker_class.name} - did not tear down correctly.  Error - #{e.message}")
+          end
+        end
+      ensure
+        Banter::CLI.instance.remove_pid
+      end
+
+      private
+
+      def warn(message)
+        old_behavior = ActiveSupport::Deprecation.behavior
+        ActiveSupport::Deprecation.behavior = [:stderr, :log]
+        ActiveSupport::Deprecation.warn(message)
+      ensure
+        ActiveSupport::Deprecation.behavior = old_behavior
+      end
+
+      def create_queue_listeners(subscriber)
+        routing_key           = subscriber.subscribed_key
+        subscribed_queue_name = subscriber.subscribed_queue
+
+        if routing_key.blank?
+          raise ArgumentError.new("Routing key must be provided in #{subscriber.name} using `subscribe_to routing_key`")
+        end
+
+        if subscribed_queue_name.blank?
+          raise ArgumentError.new("Queue Name must be provided in #{subscriber.name} using `subscribe_to routing_key, on: queue_name`")
+        end
+
+        STDOUT.puts "Setting up listener for request_key: #{routing_key} and queue:#{subscribed_queue_name}"
+        ClientQueueListener.new(subscriber, routing_key, subscribed_queue_name)
+      end
+    end
+  end
+end
+

data/lib/banter/subscriber.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'active_support/core_ext'
+
+# This class provders the worker for executing the subscriber. It receives a message from rabbitmq and
+# creates an instance of the subscriber to execute with the message and context
+
+module Banter
+  class Subscriber
+    @@registered_subscribers = []
+
+    class_attribute :payload_validators, :error_handlers, :subscribed_key, :subscribed_queue
+    attr_accessor :delivery_routing_data, :delivery_properties, :context
+
+    def self.inherited(klass)
+      @@registered_subscribers << klass
+    end
+
+    # Specify the routing key that the subscriber class should listen to.
+    # @param [String] routing_key_name The routing key to subscribe to. Must be characters only separated by periods (.)
+    # @param [Hash] options Allowed option is :on to optionally specify a queue. If not provided, queue name is generated from the routing key
+    def self.subscribe_to(routing_key_name, options = {})
+      options.assert_valid_keys(:on)
+      unless validate_routing_key_name(routing_key_name)
+        raise ArgumentError.new("#{routing_key_name} is not supported. Only lower case characters separated by periods are allowed.")
+      end
+      self.subscribed_key   = routing_key_name
+      self.subscribed_queue = generated_queue_name(routing_key_name, options[:on])
+    end
+
+    # Sets the validator for payload
+    #
+    # @param validator The validator to use for validating the payload.
+    #                  Returns false if the payload is not valid.
+    #                  Proc must accept a payload as an argument.
+    def self.validates_payload_with(*validators)
+      self.payload_validators ||= []
+      self.payload_validators += validators
+    end
+
+    # Sets an error handler for the class
+    def self.handle_errors_with(handler)
+      error_handler = handler
+    end
+
+    # @param [Hash] context Context from invocation
+    # @param [Object] delivery_routing_data Contains routing information like originator and routing key
+    # @param [Object] delivery_properties
+    def initialize(delivery_routing_data, delivery_properties, context)
+      @delivery_routing_data = delivery_routing_data
+      @delivery_properties   = delivery_properties
+      @context               = context
+    end
+
+    # Performs validation if validates_payload_with is defined and then calls the perform method
+    # @param [Object] payload Payload of the message
+    def perform!(payload)
+      if !valid_payload?(payload)
+        Banter.logger.error("Payload validation failed for #{self.class.name}")
+        raise ::Banter::PayloadValidationError.new("Invalid Payload for #{self.class.name}")
+      end
+
+      perform(context, payload)
+    end
+
+    # Actual subscribers need to implement perform method. This is the method where the message is actually processed.
+    # @param [Object] payload Payload of the message
+    def perform(payload)
+      raise "Need implementation for your worker."
+    end
+
+    # @return [String] The original routing key with which the current message was published
+    def routing_key
+      delivery_routing_data[:routing_key]
+    end
+
+    # Iterates over all the payload validators and returns false if any of them are false
+    # @param [Object] payload The payload/arguments of the message
+    # @return [Boolen] Should return true or false value - If no validators are specified, then returns true
+    def valid_payload?(payload)
+      return true unless payload_validators.present?
+
+      payload_validators.inject(true) { |is_valid, validator|
+        is_valid && (validator.respond_to?(:call) ? validator.call(payload) : send(validator, payload))
+      }
+    end
+
+    private
+
+    def self.validate_routing_key_name(key)
+      return true if key.blank?
+      key.match(/\A([a-z]+\.?)*([a-z]+)\Z/).present?
+    end
+
+    def self.generated_queue_name(routing_key, queue_name)
+      return queue_name if queue_name.present?
+      [Banter::Configuration.application_name.to_s.gsub(/[^\w\_]/, ''), routing_key.gsub(".", '_')].reject(&:blank?).join('_')
+    end
+
+  end
+end

data/lib/banter/version.rb

@@ -0,0 +1,3 @@
+module Banter
+  VERSION = "0.4.0"
+end

data/spec/banter/cli_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'banter/cli'
+
+describe Banter::CLI do
+  let(:cli) { Banter::CLI.instance }
+  after(:each) do
+    cli.instance_variable_set(:@subscribers, nil)
+    cli.instance_variable_set(:@pidfile, nil)
+    cli.instance_variable_set(:@require_path, nil)
+  end
+
+  describe '#parse' do
+    let(:options) { [] }
+    before { cli.parse(options) }
+
+    context "pidfile" do
+      it "works when nothing is passed" do
+        expect(cli.pidfile).to be_nil
+      end
+
+      context "passed in as -P" do
+        let(:options) { [ "-P", "mypidfile.pid"]}
+        it "parses" do
+          expect(cli.pidfile).to eq('mypidfile.pid')
+        end
+      end
+
+      context "passed in as --pidfile" do
+        let(:options) { [ "--pidfile", "mypidfile.pid"]}
+        it "parses" do
+          expect(cli.pidfile).to eq('mypidfile.pid')
+        end
+      end
+    end
+
+    context "only" do
+      it "works when nothing is passed" do
+        expect(cli.subscribers).to be_nil
+      end
+
+      context "passed in as -o" do
+        let(:options) { [ "-o", "Foobar,Doobar"]}
+        it "parses" do
+          expect(cli.subscribers).to eq([ 'Foobar', 'Doobar'])
+        end
+      end
+
+      context "passed in as --only" do
+        let(:options) { [ "--only", "Foobar,Doobar"]}
+        it "parses" do
+          expect(cli.subscribers).to eq([ 'Foobar', 'Doobar'])
+        end
+      end
+    end
+
+    context "require" do
+      it "works when nothing is passed" do
+        expect(cli.require_path).to eq(".")
+      end
+
+      context "passed in as -r" do
+        let(:options) { [ "-r", "/path/to/my/file"]}
+        it "parses" do
+          expect(cli.require_path).to eq("/path/to/my/file")
+        end
+      end
+
+      context "passed in as --require" do
+        let(:options) { [ "--require", "/path/to/my/file"]}
+        it "parses" do
+          expect(cli.require_path).to eq("/path/to/my/file")
+        end
+      end
+    end
+  end
+
+  describe '#run' do
+    describe "high-level steps to be completed" do
+      before {
+        allow(cli).to receive(:load_environment)
+        allow(cli).to receive(:write_pidfile)
+        allow(cli).to receive(:load_subscribers)
+        cli.run
+      }
+
+      it "runs" do
+        expect(cli).to have_received(:load_environment)
+        expect(cli).to have_received(:write_pidfile)
+        expect(cli).to have_received(:load_subscribers)
+      end
+    end
+  end
+
+  describe '#write_pidfile' do
+    before {
+      cli.pidfile = pidfile
+      allow(File).to receive(:open)
+      cli.send(:write_pidfile)
+    }
+    context "no pidfile passed" do
+      let(:pidfile) { nil }
+      it "doesn't create a pidfile" do
+        expect(File).to_not have_received(:open)
+      end
+    end
+
+    context "pidfile path is supplied" do
+      let(:pidfile) { "/path/to/pidfile" }
+      it 'creates file' do
+        expect(File).to have_received(:open).with(pidfile, 'w')
+      end
+    end
+  end
+
+  describe '#load_subscribers' do
+    let(:subscribers) { nil }
+    let(:subscriber_server) { double('subscriber_server')}
+    before {
+      cli.subscribers = subscribers
+      allow(subscriber_server).to receive(:start)
+      allow(Banter::Server::SubscriberServer).to receive(:new).and_return(subscriber_server)
+      cli.send(:load_subscribers)
+    }
+
+    context "No subscribers passed through CLI" do
+      let(:all_subscribers) { Banter::Subscriber.class_variable_get(:@@registered_subscribers) }
+      it "loads all subscribers" do
+        expect(all_subscribers).to include(MyTestSubscriber1)
+        expect(all_subscribers).to include(MyTestSubscriber2)
+        expect(all_subscribers).to include(MyTestSubscriber3)
+        expect(Banter::Server::SubscriberServer).to have_received(:new).with(all_subscribers)
+        expect(subscriber_server).to have_received(:start)
+      end
+    end
+
+    context "Subscribers passed through CLI" do
+      let(:subscribers) { ['MyTestSubscriber1', 'MyTestSubscriber2'] }
+      it "loads all subscribers" do
+        expect(Banter::Server::SubscriberServer).to have_received(:new).with([MyTestSubscriber1, MyTestSubscriber2])
+        expect(subscriber_server).to have_received(:start)
+      end
+    end
+  end
+
+end

data/spec/banter/server/client_queue_listener_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Banter::Server::ClientQueueListener do
+  describe "#message_received" do
+
+    subject { -> { queue_listener.message_received( {}, {routing_key: routing_key}, {context: context, payload: payload}) } }
+    let(:queue_listener) { Banter::Server::ClientQueueListener.new(Klass, routing_key, 'queue') }
+    let(:routing_key) { 'some.test.key' }
+    let(:context) { {} }
+    let(:payload) { {hello: 'moto'} }
+    let(:context_before){}
+    let(:validators){ [] }
+
+    before do
+      context_before
+      Object.const_set :Klass, Class.new(Banter::Subscriber)
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+
+      klass_instance
+
+      allow(Klass).to receive(:new).and_return(klass_instance)
+      subject.call unless respond_to? :no_call
+    end
+
+    after do
+      Object.send :remove_const, :Klass
+    end
+
+    context "Normal execution" do
+      let!(:klass_instance){
+        instance = Klass.new({},{}, {})
+        allow(instance).to receive(:perform)
+        instance
+      }
+
+      context "test exception" do
+        let(:no_call) { true }
+
+        it { should_not raise_exception }
+      end
+
+      context "call" do
+        it { expect(klass_instance).to have_received(:perform).with({}, payload) }
+      end
+    end
+
+    context "Exception during execution" do
+      let!(:klass_instance) {
+        instance = Klass.new({},{}, {})
+        allow(instance).to receive(:perform){
+          raise StandardError.new("test")
+        }
+        instance
+      }
+      let(:no_call) { true }
+
+      it { should_not raise_exception }
+    end
+
+    context "Payload error" do
+      let!(:klass_instance) {
+        instance = Klass.new({},{}, {})
+        allow(instance).to receive(:perform)
+        instance
+      }
+
+      let!(:validators) { [lambda{ |payload| false }]  }
+
+      let(:context_before){ allow(Airbrake).to receive(:notify)}
+
+      it {expect(Airbrake).to have_received(:notify)}
+    end
+  end
+end

data/spec/banter/server/client_worker_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Banter::Subscriber do
+  before(:each) { Object.const_set :Klass, Class.new(Banter::Subscriber) }
+  after(:each) { Object.send :remove_const, :Klass }
+
+  describe "#routing_key" do
+    subject { Banter::Subscriber.new(routing_data, properties, {}).routing_key }
+
+    let(:properties) { {} }
+
+    context "Routing key is 'honest.test.route'" do
+      let(:routing_data) { {routing_key: "honest.test.route"} }
+      
+      it { should eq "honest.test.route" }
+    end
+  end
+
+  describe "self.validates_payload_with" do
+    before do
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+    end
+
+    context "One validator" do
+      let(:validators){ [lambda{|payload| true}] }
+      it {
+        expect(Klass.new({},{}, {}).payload_validators.length).to eq 1 }
+    end
+
+    context "Two validators" do
+      let(:validators){ [lambda{|payload| true}, lambda{|payload| true}] }
+      it { expect(Klass.new({},{}, {}).payload_validators.length).to eq 2  }
+    end
+  end
+
+  describe '#valid_payload?' do
+    context
+    subject { Klass.new({},{}, {}).valid_payload?({}) }
+
+    before do
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+    end
+
+    context "Two validators returning true" do
+      let(:validators){ [lambda{|payload| true}, lambda{|payload| true}] }
+      it { should be true }
+    end
+
+    context "One validator returning true one returning false" do
+      let(:validators){ [lambda{|payload| false}, lambda{|payload| true}] }
+      it { should be false }
+    end
+
+    context "No validators" do
+      let(:validators){ [] }
+      it { should be true }
+    end
+
+    context "validators as symbol" do
+      context "method returns true" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            true
+          end
+        }
+        let(:validators) { [lambda{|payload| true}, :foo_bar] }
+        it {
+          should be true
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be true
+        }
+
+      end
+
+      context "method returns false" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            false
+          end
+        }
+        let(:validators) { [lambda{|payload| true}, :foo_bar] }
+        it {
+          should be false
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be true
+        }
+
+      end
+
+      context "proc returns false" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            true
+          end
+        }
+        let(:validators) { [lambda{|payload| false}, :foo_bar] }
+        it "method shouldn't be called" do
+          should be false
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be false
+        end
+
+      end
+    end
+  end
+
+  describe "#validate_routing_key_name" do
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, '')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef.asd')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef/')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef.a123')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcAf')).to eq(false) }
+  end
+
+  describe "#generated_queue_name" do
+    before(:each) { allow(Banter::Configuration).to receive(:application_name).and_return("app_name")}
+
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', 'queue_name')).to eq('queue_name') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', nil)).to eq('app_name_abcdef') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef.abcd', nil)).to eq('app_name_abcdef_abcd') }
+    it { expect(Klass.send(:generated_queue_name, 'a.b.c', nil)).to eq('app_name_a_b_c') }
+  end
+
+  describe '.subscribe_to' do
+    before(:each) { allow(Banter::Configuration).to receive(:application_name).and_return("app_name")}
+    context 'routing_key without queue_name' do
+      before { Klass.subscribe_to 'a.b.c' }
+      it 'sets the routing key and queue name' do
+        expect(Klass.subscribed_key).to eq('a.b.c')
+        expect(Klass.subscribed_queue).to eq('app_name_a_b_c')
+      end
+    end
+
+    context 'routing_key with queue_name' do
+      before { Klass.subscribe_to 'a.b.c', on: 'foo_bar' }
+      it 'sets the routing key and queue name' do
+        expect(Klass.subscribed_key).to eq('a.b.c')
+        expect(Klass.subscribed_queue).to eq('foo_bar')
+      end
+    end
+
+    context 'invalid routing key' do
+      before {  }
+      it 'sets the routing key and queue name' do
+        expect {
+          Klass.subscribe_to 'a.b.c.', on: 'foo_bar'
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end