banter 1.4.0 → 2.0.0

data/.ruby-version

@@ -1 +0,0 @@
-2.0

data/lib/banter/web.rb

@@ -1,34 +0,0 @@
-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'
-
-    module Serializers
-      autoload :BanterWorkerSerializer, 'banter/web/serializers/banter_worker_serializer'
-      autoload :BanterMessageSerializer, 'banter/web/serializers/banter_message_serializer'
-      autoload :SubscriberSerializer, 'banter/web/serializers/subscriber_serializer'
-    end
-  end
-end
-
-require 'banter'
-require 'banter/web/models/banter_worker'
-require 'banter/web/models/banter_message'

data/lib/banter/web/application.rb

@@ -1,85 +0,0 @@
-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
-        redirect "#{root_path}dashboard"
-      end
-
-      get '/dashboard*', provides: :html do
-        haml :index
-      end
-
-      get '/workers.json' do
-        content_type :json
-        workers = BanterWorker.running.ordered.map { |w| serialize_worker(w) }
-        { workers: workers }.to_json
-      end
-
-      get '/workers/:id.json' do
-        content_type :json
-        worker = BanterWorker.find(params[:id])
-        { worker: serialize_worker(worker) }.to_json
-      end
-
-      get '/messages/:message_id.json' do
-        content_type :json
-        message = BanterMessage.find(params[:message_id])
-        {
-          message: serialize_message(message, true)
-        }.to_json
-      end
-
-      get '/messages.json' do
-        content_type :json
-        offset   = 0
-        worker   = nil
-        offset   = 50 * (params[:page].to_i - 1) if params[:page]
-        messages = BanterMessage.ordered.limit(50).offset(offset)
-        if params[:worker_id].present?
-          worker   = BanterWorker.find(params[:worker_id])
-          messages = messages.where(worker_id: worker.id).ordered
-        end
-
-        if params[:subscriber].present?
-          messages = messages.where(subscriber_class: params[:subscriber])
-        end
-
-        hash          = {
-          messages: messages.map { |m| serialize_message(m, true) }
-        }
-        hash[:worker] = serialize_worker(worker) if worker
-        hash.to_json
-      end
-
-      get '/subscribers.json' do
-        content_type :json
-        {
-          subscribers: BanterWorker.subscribers.map { |s| serialize_subscriber(s) }
-        }.to_json
-      end
-
-      private
-
-      def serialize_message(message, include_worker = false)
-        Banter::Web::Serializers::BanterMessageSerializer.new(message).to_hash.tap do |hash|
-          hash[:worker] = serialize_worker(message.worker) if include_worker
-        end
-      end
-
-      def serialize_worker(worker)
-        Banter::Web::Serializers::BanterWorkerSerializer.new(worker).to_hash
-      end
-
-      def serialize_subscriber(subscriber)
-        Banter::Web::Serializers::SubscriberSerializer.new(subscriber).to_hash
-      end
-
-    end
-  end
-end

data/lib/banter/web/helpers.rb

@@ -1,13 +0,0 @@
-module Banter
-  module Web
-    module Helpers
-      def root_path(path = nil)
-        "#{env['SCRIPT_NAME']}/#{path}"
-      end
-
-      def dashboard_path(path = nil)
-        root_path("dashboard/#{path}")
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-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 :error_backtrace
-  field :worker_id
-  field :progress_at, type: Integer
-  field :progress_total, type: Integer
-  field :progress
-
-  STATUS_STARTED           = 'started'
-  STATUS_SUCCESS           = 'success'
-  STATUS_ERROR             = 'error'
-  STATUS_VALIDATION_FAILED = 'validation_failed'
-
-  cattr_reader :current
-
-  scope :ordered, ->() { order_by(:started_at.desc) }
-  scope :for_subscriber, ->(subscriber) { where(subscriber_class: subscriber) }
-  scope :successful, ->() { where(status: STATUS_SUCCESS) }
-  scope :errored, ->() { where(status: STATUS_ERROR) }
-  scope :validation_failed, ->() { where(status: STATUS_VALIDATION_FAILED) }
-  scope :started, ->() { where(status: STATUS_STARTED) }
-
-  # Creates a BanterMessage to record a message that is received by a subscriber.
-  # It records the created message as BanterMessage.current
-  # @param [Subscriber] subscriber_class
-  # @param [Banter::Server::ClientQueueListener] worker
-  # @param [Object] payload
-  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
-
-  # Records the current message as successful. Clears the BanterMessage.current
-  def self.message_successful
-    current.status  = STATUS_SUCCESS
-    current.done_at = Time.now
-    current.save!
-    BanterWorker.clear_current_message!(true)
-    @@current = nil
-  end
-
-  # Records the current message as errored or validation failed with error message. Clears the BanterMessage.current
-  # @param [String] error_message
-  # @param [String] status
-  def self.message_failed(error, status)
-    current.status          = status
-    current.done_at         = Time.now
-    current.error_message   = error.message
-    current.error_backtrace = error.backtrace
-    current.save!
-    BanterWorker.clear_current_message!(false)
-    @@current = nil
-  end
-
-  # Records the current progress as a number for the current message.
-  # @param [Integer] num Current progress
-  def self.update_progress_at(num)
-    return unless current
-    current.progress_at = num
-    current.save!
-  end
-
-  # Records the number of objects expected to be processed for the current message.
-  # @param [Integer] num Total number of objects expected to be processed.
-  def self.update_progress_total(num)
-    return unless current
-    current.progress_total = num
-    current.save!
-  end
-
-  # @param [Object] object Any object that indicates the progress of the message
-  def self.update_progress(object)
-    return unless current
-    current.progress = object
-    current.save!
-  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
-
-  # @return [BanterWorker] The worker that is responsible for executing the current message
-  def worker
-    @worker ||= BanterWorker.find(self['worker_id'].to_s)
-  end
-end

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

@@ -1,72 +0,0 @@
-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
-
-  # @return [Array] Unique subscriber classes
-  def self.subscribers
-    distinct("worker_classes")
-  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/lib/banter/web/serializers/banter_message_serializer.rb

@@ -1,35 +0,0 @@
-module Banter
-  module Web
-
-    module Serializers
-      class BanterMessageSerializer
-        attr_accessor :message
-
-        def initialize(message)
-          @message = message
-        end
-
-        def to_hash
-          {
-            id:               message.id.to_s,
-            subscriber_class: message.subscriber_class,
-            queue_name:       message.queue_name,
-            subscribed_key:   message.subscribed_key,
-            payload_key:      message.payload_key,
-            payload:          message.payload,
-            context:          message.context,
-            started_at:       message.started_at,
-            done_at:          message.done_at,
-            status:           message.status,
-            error_message:    message.error_message,
-            error_backtrace:  message.error_backtrace,
-            worker_id:        message.worker_id,
-            progress_total:   message.progress_total,
-            progress_at:      message.progress_at,
-            progress:         message.progress
-          }
-        end
-      end
-    end
-  end
-end

data/lib/banter/web/serializers/banter_worker_serializer.rb

@@ -1,40 +0,0 @@
-module Banter
-  module Web
-
-    module Serializers
-      class BanterWorkerSerializer
-        attr_accessor :worker
-
-        def initialize(worker)
-          @worker = worker
-        end
-
-        def to_hash
-          {
-            id:              worker.id.to_s,
-            process_name:    worker.process_name,
-            pid:             worker.pid,
-            started_at:      worker.started_at,
-            stopped_at:      worker.stopped_at,
-            worker_classes:  Array.wrap(worker.worker_classes),
-            hostname:        worker.hostname,
-            current_message: current_message_serialized,
-            job_count:       worker.job_count,
-            success_count:   worker.success_count,
-            failed_count:    worker.failed_count
-          }
-        end
-
-        def current_message_serialized
-          return if worker.current_message.blank?
-          worker.current_message.tap do |hash|
-            _id = hash.delete('_id')
-            if _id
-              hash["id"] = _id.to_s
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/banter/web/serializers/subscriber_serializer.rb

@@ -1,26 +0,0 @@
-module Banter
-  module Web
-
-    module Serializers
-      class SubscriberSerializer
-        attr_accessor :subscriber_class_name
-
-        def initialize(subscriber_class_name)
-          @subscriber_class_name = subscriber_class_name
-        end
-
-        def to_hash
-          messages = BanterMessage.for_subscriber(subscriber_class_name)
-          {
-            class_name:              subscriber_class_name,
-            total:                   messages.count,
-            success_count:           messages.successful.count,
-            started_count:           messages.started.count,
-            errored_count:           messages.errored.count,
-            validation_failed_count: messages.validation_failed.count
-          }
-        end
-      end
-    end
-  end
-end

data/spec/banter/web/application_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-describe Banter::Web::Application do
-  let(:response_json) { JSON.parse(last_response.body) }
-  describe 'GET /' do
-    before { get '/' }
-    it 'redirects to dashboard' do
-      expect(last_response.status).to eq 302
-    end
-
-    it { expect(last_response.location).to include("/dashboard") }
-  end
-
-  describe "GET /dashboard*" do
-    context "GET /dashboard" do
-      before { get '/dashboard' }
-      it "is successful" do
-        expect(last_response.status).to be(200)
-      end
-      it "includes dashboardApp" do
-        expect(last_response.body).to include('dashboardApp')
-      end
-    end
-
-    context "GET /dashboard/workers/123" do
-      before { get '/dashboard/workers/123' }
-      it "is successful" do
-        expect(last_response.status).to be(200)
-      end
-      it "includes dashboardApp" do
-        expect(last_response.body).to include('dashboardApp')
-      end
-    end
-
-    context "GET /dashboard/wtf" do
-      before { get '/dashboard/wtf' }
-      it "is successful" do
-        expect(last_response.status).to be(200)
-      end
-      it "includes dashboardApp" do
-        expect(last_response.body).to include('dashboardApp')
-      end
-    end
-  end
-
-  describe "GET /workers.json" do
-    let!(:worker_1) { FactoryGirl.create(:banter_worker) }
-    let!(:worker_2) { FactoryGirl.create(:banter_worker) }
-    let!(:worker_3) { FactoryGirl.create(:banter_worker, :stopped) }
-    let(:workers_json) { response_json['workers'] }
-
-    before { get "/workers.json" }
-    it 'is successful' do
-      expect(last_response.status).to be(200)
-    end
-
-    it "includes only running workers" do
-      expect(workers_json.size).to eq(2)
-    end
-
-    it do
-      worker_ids = workers_json.map { |worker| worker['id'] }
-      expect(worker_ids).to match_array([worker_1.id.to_s, worker_2.id.to_s])
-    end
-  end
-
-  describe "GET /workers/:worker_id.json" do
-    let(:worker_json) { response_json['worker'] }
-
-    def self.it_works
-      before { get "/workers/#{worker.id.to_s}.json" }
-      it 'is successful' do
-        expect(last_response.status).to be 200
-      end
-
-      it 'includes worker data' do
-        expect(worker_json['id']).to eq(worker.id.to_s)
-      end
-    end
-
-    describe "alive worker" do
-      let(:worker) { FactoryGirl.create(:banter_worker) }
-      it_works
-    end
-
-    describe "dead worker" do
-      let(:worker) { FactoryGirl.create(:banter_worker, :stopped) }
-      it_works
-    end
-  end
-
-  describe "GET /messages/:message_id.json" do
-    let(:message_json) { response_json['message'] }
-    let(:message) { FactoryGirl.create(:banter_message) }
-
-    before { get "/messages/#{message.id.to_s}.json" }
-
-    it 'is successful' do
-      expect(last_response.status).to be 200
-    end
-
-    it 'includes message' do
-      expect(message_json['id']).to eq(message.id.to_s)
-    end
-  end
-
-  describe "GET /messages.json" do
-    let(:messages_json) { response_json['messages'] }
-    let(:worker_id) { nil }
-
-    def includes_messages(*messages)
-      message_ids = messages_json.map { |m| m['id']}
-      expect(message_ids).to match_array(messages.map(&:id).map(&:to_s))
-    end
-
-    context "all messages" do
-      let!(:message_1) { FactoryGirl.create(:banter_message) }
-      let!(:message_2) { FactoryGirl.create(:banter_message) }
-      let!(:message_3) { FactoryGirl.create(:banter_message, :errored) }
-      before { get "/messages.json?worker_id=#{worker_id}" }
-
-      it 'is successful' do
-        expect(last_response.status).to be 200
-      end
-
-      it 'includes messages' do
-        includes_messages(message_1, message_2, message_3)
-      end
-    end
-
-    context "by worker" do
-      let(:worker) { FactoryGirl.create(:banter_worker) }
-      let(:worker_id) { worker.id }
-      let!(:message_1) { FactoryGirl.create(:banter_message, worker_id: worker.id ) }
-      let!(:message_2) { FactoryGirl.create(:banter_message, worker_id: worker.id) }
-      let!(:message_3) { FactoryGirl.create(:banter_message, :errored, worker_id: worker.id) }
-      let!(:message_4) { FactoryGirl.create(:banter_message) }
-      before { get "/messages.json?worker_id=#{worker_id}" }
-      it 'is successful' do
-        expect(last_response.status).to be 200
-      end
-
-      it 'includes messages' do
-        includes_messages(message_1, message_2, message_3)
-      end
-    end
-
-    context "by subscriber" do
-      let(:subscriber) { 'MyTestClass' }
-      let!(:message_1) { FactoryGirl.create(:banter_message, subscriber_class: subscriber ) }
-      let!(:message_2) { FactoryGirl.create(:banter_message, subscriber_class: subscriber) }
-      let!(:message_3) { FactoryGirl.create(:banter_message, :errored) }
-      let!(:message_4) { FactoryGirl.create(:banter_message, :errored, subscriber_class: subscriber) }
-      before { get "/messages.json?subscriber=#{subscriber}" }
-      it 'is successful' do
-        expect(last_response.status).to be 200
-      end
-
-      it 'includes messages' do
-        includes_messages(message_1, message_2, message_4)
-      end
-    end
-  end
-
-  describe "GET /subscribers.json" do
-    let!(:worker_1) { FactoryGirl.create(:banter_worker, worker_classes: [ 'FooWorker1', 'BarWorker2'])}
-    let!(:worker_2) { FactoryGirl.create(:banter_worker, :stopped, worker_classes: [ 'FooWorker2', 'BarWorker1'])}
-
-    let(:subscribers_json) { response_json['subscribers'] }
-
-    before { get '/subscribers.json'}
-    it 'is successful' do
-      expect(last_response.status).to be 200
-    end
-
-    it 'includes message' do
-      subscribers = subscribers_json.map { |s| s['class_name']}.sort
-      expect(subscribers).to eq(['BarWorker1', 'BarWorker2', 'FooWorker1', 'FooWorker2'])
-    end
-  end
-end