banter 0.5.0 → 0.7.0

data/lib/banter/server/subscriber_server.rb

@@ -5,6 +5,7 @@ require 'awesome_print'
 require 'active_support/all'
 require 'optparse'
 require 'fileutils'
+require 'singleton'
 
 require_relative './client_queue_listener'
 
@@ -13,20 +14,57 @@ require_relative './client_queue_listener'
 
 module Banter
   module Server
-
     class SubscriberServer
       include Celluloid
 
-      def initialize(subscribers)
+      attr_reader :workers, :process_name, :pid, :hostname, :banter_worker_id
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def set_workers(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
+        set_information
+        register_workers
+        start_workers
+        handle_interrupts
+        handle_teardown
+      ensure
+        stop_worker
+      end
+
+      def register_workers
+        return unless Banter::Configuration.web_enabled
+        BanterWorker.worker_started
+      end
+
+      private
+
+      def handle_teardown
+        ::Banter::RabbitLogger.log_service("all_services", "Starting shutdown of all services")
+        unregister_current_worker
+
+        workers.each do |worker|
+          ::Banter::RabbitLogger.log_service("all_services", "Tearing down worker: #{worker.worker_class.name}")
+          begin
+            STDOUT.puts "Tearing down subscriber for #{worker.worker_class.name}"
+            worker.shutdown
+          rescue => e
+            ::Banter::RabbitLogger.log_service("all_services", "#{worker.worker_class.name} - did not tear down correctly.  Error - #{e.message}")
+          end
         end
+      end
 
+      def unregister_current_worker
+        return unless Banter::Configuration.web_enabled
+        BanterWorker.worker_stopped
+      end
+
+      def handle_interrupts
         thread     = Thread.current
         interrupts = ["HUP", "INT", "QUIT", "ABRT", "TERM"]
         interrupts.each do |signal_name|
@@ -37,30 +75,24 @@ module Banter
         end
 
         Thread.stop
+      end
 
-        ::Banter::RabbitLogger.log_service("all_services", "Starting shutdown of all services")
-
-        @workers.each do |worker|
-          ::Banter::RabbitLogger.log_service("all_services", "Tearing down worker: #{worker.worker_class.name}")
-          begin
-            STDOUT.puts "Tearing down subscriber for #{worker.worker_class.name}"
-            worker.shutdown
-          rescue => e
-            ::Banter::RabbitLogger.log_service("all_services", "#{worker.worker_class.name} - did not tear down correctly.  Error - #{e.message}")
-          end
+      def start_workers
+        workers.each do |worker|
+          puts "starting workers"
+          worker.start
         end
-      ensure
+      end
+
+      def stop_worker
         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
+      def set_information
+        @process_name = $0
+        @pid          = Process.pid
+        @hostname     = `hostname -f`.chomp
       end
 
       def create_queue_listeners(subscriber)

data/lib/banter/subscriber.rb

@@ -60,7 +60,6 @@ module Banter
     # @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
 

data/lib/banter/version.rb

@@ -1,3 +1,3 @@
 module Banter
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/banter/web.rb

@@ -0,0 +1,28 @@
+begin
+  require 'sinatra/base'
+rescue LoadError
+  raise "sinatra must be installed for banter/web to work. Add gem 'sinatra' to your Gemfile"
+end
+
+begin
+  require 'haml'
+rescue LoadError
+  raise "haml must be installed for banter/web to work. Add gem 'haml' to your Gemfile"
+end
+
+begin
+  require 'mongoid'
+rescue LoadError
+  raise "mongoid must be installed for banter/web to work. Add gem 'mongoid' to your Gemfile"
+end
+
+module Banter
+  module Web
+    autoload :Application, 'banter/web/application'
+    autoload :Helpers, 'banter/web/helpers'
+  end
+end
+
+require 'banter'
+require 'banter/web/models/banter_worker'
+require 'banter/web/models/banter_message'

data/lib/banter/web/application.rb

@@ -0,0 +1,36 @@
+module Banter
+  module Web
+    class Application < Sinatra::Base
+      set :root, File.expand_path(File.dirname(__FILE__) + "/../../../web")
+      set :public_folder, Proc.new { "#{root}/assets" }
+      set :views, Proc.new { "#{root}/views" }
+
+      helpers Banter::Web::Helpers
+
+      get '/' do
+        @workers = BanterWorker.running.ordered
+        haml :index, locals: { workers: @workers }
+      end
+
+      get '/workers/:id' do
+        worker = BanterWorker.find(params[:id])
+        haml :worker, locals: { worker: worker }
+      end
+
+      get '/messages/:id' do
+        message = BanterMessage.find(params[:id])
+        haml :message, locals: { message: message }
+      end
+
+      get '/workers/:worker_id/messages' do
+        messages = BanterMessage.where(worker_id:  Moped::BSON::ObjectId.from_string(params[:worker_id])).ordered
+        worker = BanterWorker.find(params[:worker_id])
+        haml :messages, locals: { messages: messages, worker: worker }
+      end
+
+      get '/subscribers' do
+        haml :subscribers
+      end
+    end
+  end
+end

data/lib/banter/web/helpers.rb

@@ -0,0 +1,9 @@
+module Banter
+  module Web
+    module Helpers
+      def root_path
+        "#{env['SCRIPT_NAME']}/"
+      end
+    end
+  end
+end

data/lib/banter/web/models/banter_message.rb

@@ -0,0 +1,82 @@
+class BanterMessage
+  include Mongoid::Document
+
+  field :subscriber_class, type: String
+  field :queue_name, type: String
+  field :subscribed_key, type: String
+  field :payload_key, type: String
+  field :routing_data
+  field :properties
+  field :payload
+  field :context
+  field :started_at, type: Time
+  field :done_at, type: Time
+  field :status, type: String
+  field :error_message, type: String
+  field :worker_id
+  # embeds_one :worker, class_name: 'BanterWorker'
+
+  STATUS_STARTED = 'started'
+  STATUS_SUCCESS = 'success'
+  STATUS_ERROR  = 'error'
+  STATUS_VALIDATION_FAILED  = 'validation_failed'
+
+  cattr_reader :current
+
+  scope :ordered, ->() { order_by(:started_at.desc) }
+
+  def self.message_received(subscriber_class, worker, payload)
+    return unless BanterWorker.current
+
+    obj = new(
+      subscriber_class: subscriber_class.name,
+      queue_name:       subscriber_class.subscribed_queue,
+      subscribed_key:   subscriber_class.subscribed_key,
+      payload_key:      worker.routing_key,
+      # routing_data:     worker.delivery_routing_data.to_hash,
+      # properties:       worker.delivery_properties.to_hash,
+      payload:          payload,
+      context:          worker.context,
+      started_at:       Time.now,
+      status:           STATUS_STARTED,
+      worker_id:        BanterWorker.current.id
+    )
+
+    obj.save!
+    @@current = obj
+    BanterWorker.record_current!(obj)
+  end
+
+  def self.message_successful
+    current.status  = STATUS_SUCCESS
+    current.done_at = Time.now
+    current.save!
+    BanterWorker.clear_current_message!(true)
+    @@current = nil
+  end
+
+  def self.message_failed(error_message, status)
+    current.status        = status
+    current.done_at       = Time.now
+    current.error_message = error_message
+    current.save!
+    BanterWorker.clear_current_message!(false)
+    @@current = nil
+  end
+
+  def executing?
+    self.status == STATUS_STARTED
+  end
+
+  def succeeded?
+    self.status == STATUS_SUCCESS
+  end
+
+  def failed?
+    self.status == STATUS_ERROR || self.status == STATUS_VALIDATION_FAILED
+  end
+
+  def worker
+    @worker ||= BanterWorker.find(self['worker_id'].to_s)
+  end
+end

data/lib/banter/web/models/banter_worker.rb

@@ -0,0 +1,68 @@
+class BanterWorker
+  include Mongoid::Document
+  field :process_name, type: String
+  field :pid, type: Integer
+  field :worker_classes
+  field :hostname, type: String
+  field :started_at, type: Time
+  field :stopped_at, type: Time
+  field :current_message
+  field :job_count, type: Integer, default: 0
+  field :success_count, type: Integer, default: 0
+  field :failed_count, type: Integer, default: 0
+
+  cattr_reader :current
+
+  scope :running, ->() { where(:stopped_at => nil) }
+  scope :ordered, ->() { order_by(:started_at.desc) }
+
+# @param [String] process_name
+# @param [String] process_pid
+# @param [String] hostname
+# @param [Array(Subscriber)] workers The subscriber classes that are being started by this worker
+  def self.worker_started
+    server_instance = Banter::Server::SubscriberServer.instance
+    worker = new(process_name:   server_instance.process_name,
+                 pid:            server_instance.pid,
+                 hostname:       server_instance.hostname,
+                 started_at:     Time.now,
+                 worker_classes: Array.wrap(server_instance.workers).map(&:worker_class).map(&:name))
+    worker.save!
+    @@current = worker
+    worker
+  end
+
+  def self.worker_stopped
+    current.try(:stop!)
+    @@current = nil
+  end
+
+  # @param [BanterMessage] banter_message Message that is currently being executed
+  def self.record_current!(banter_message)
+    current.current_message = banter_message.attributes
+
+    current.save!
+  end
+
+  # Clears the current message key for the worker
+  # @param [Boolean] success Indicate whether the job was successful or not
+  def self.clear_current_message!(success = true)
+    current.current_message = nil
+    current.job_count += 1
+    if success
+      current.success_count += 1
+    else
+      current.failed_count += 1
+    end
+    current.save!
+  end
+
+  def executing?
+    current_message.present?
+  end
+
+  def stop!
+    self.stopped_at = Time.now
+    save!
+  end
+end

data/spec/banter/cli_spec.rb

@@ -53,6 +53,26 @@ describe Banter::CLI do
       end
     end
 
+    context "process name" do
+      it "works when nothing is passed" do
+        expect(cli.process_name).to be_nil
+      end
+
+      context "passed in as -n" do
+        let(:options) { [ "-n", "dontkillme"]}
+        it "parses" do
+          expect(cli.process_name).to eq('dontkillme')
+        end
+      end
+
+      context "passed in as --name" do
+        let(:options) { [ "--name", "dontkillme"]}
+        it "parses" do
+          expect(cli.process_name).to eq('dontkillme')
+        end
+      end
+    end
+
     context "require" do
       it "works when nothing is passed" do
         expect(cli.require_path).to eq(".")
@@ -117,27 +137,29 @@ describe Banter::CLI do
     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)
+      allow(Banter::Server::SubscriberServer.instance).to receive(:set_workers)
+      allow(Banter::Server::SubscriberServer.instance).to receive(:start)
       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)
+        expect(Banter::Server::SubscriberServer.instance).to have_received(:set_workers).with(all_subscribers)
+        expect(Banter::Server::SubscriberServer.instance).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)
+        expect(Banter::Server::SubscriberServer.instance).to have_received(:set_workers).with([MyTestSubscriber1, MyTestSubscriber2])
+        expect(Banter::Server::SubscriberServer.instance).to have_received(:start)
       end
     end
   end

data/spec/banter/publisher_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'bunny'
+
+describe Banter::Publisher do
+  let(:routing_key) { "test/logger" }
+  let(:publisher) { Banter::Publisher.new }
+  let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
+  let(:channel_mocker) {
+    double("::Bunny::Channel",
+      :topic=> double("::Bunny::Exchange",
+        :publish=> true,
+        :on_return=> true )
+    )
+  }
+
+  before do
+    allow(Banter::RabbitLogger).to receive(:log_publish)
+    allow_any_instance_of(::Bunny::Session).to receive(:start).and_return(true)
+    allow_any_instance_of(::Bunny::Session).to receive(:create_channel) { channel_mocker }
+  end
+
+  describe "#delay_messages" do
+
+    context "no duplicates", :fixit=>true do
+      let(:result) {
+        publisher.delay_messages { operations } }
+
+      let(:operations) {
+        publisher.publish(context, "first", "one")
+        publisher.publish(context, "second", "two")
+        }
+
+      it "should attempt to publish twice" do
+        result
+        expect(Banter::RabbitLogger).to have_received(:log_publish).exactly(2).times
+      end
+
+    end
+
+    context "duplicate entries" do
+      let(:result) { publisher.delay_messages { operations } }
+
+      let(:operations) {
+        publisher.publish(context, "first", "one")
+        publisher.publish(context, "second", "two")
+        publisher.publish(context, "second", "three")
+        }
+
+      before do
+        result
+      end
+
+      it "should attempt to publish three times" do
+        expect(Banter::RabbitLogger).to have_received(:log_publish).exactly(3).times
+      end
+    end
+
+    describe "adds to the queue when delaying messages" do
+      let(:result) { publisher.delay_messages { operations } }
+      let(:operations) {
+        publisher.publish(context, "first", "one")
+        publisher.publish(context, "second", "two")
+      }
+
+      it "should have added to the message list twice that will be published last" do
+        expect_any_instance_of(Banter::Publisher).to receive(:add_message).exactly(2).times
+        result
+      end
+
+      it "should have added to the message list twice that will be published last" do
+        expect_any_instance_of(Banter::Publisher).to receive(:execute_publish).exactly(2).times
+        result
+      end
+
+    end
+
+  end
+end