bi-frost 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61a3243740e3d642efe0184d5c64d4ad11e72bff
+  data.tar.gz: 3834b3af2f9541dd7222a2ebf3e266f9430db2ea
+SHA512:
+  metadata.gz: 764a14af9175bf5ffd9f25d8e1d84aa6fd31988db87da0cca2db0bc262715d669b66e591892b6a7e7f017899ad6e870813781ac25dd98860e7c519faee77ecfa
+  data.tar.gz: 1319f4d4eb92d423485943ecdbdd941f68c78b9360b584213c442f1f8f5ea735e22e1f044e0a8e40e02d37c1f160ada2df9b96e89685ffdb2b22354a8a76b0a7

data/README.md

@@ -0,0 +1,144 @@
+# Bifrost
+
+Bifrost is a component which abstracts access to the Azure messaging bus. This is a lower level library which
+can be used to commuicate with Azure via the Azure SDK.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bi-frost'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+This component consists of 4 primary entities; Topic, Subscriber, Message and Listener.
+
+Message's are what we deliver across various applications via an asynchronous pub/sub architecture. Messages are
+posted to Topics. Topics are a collection of unique names which exist in a given Azure namespace. Each instance
+of the Bifrost can only operate in a single Azure namespace. Topic names support alpha numeric characters only.
+
+The architecture of this component is based on a fan out pub/sub model, i.e. a topic can have 1 or more subscribers,
+each subscriber registers their interest in receiving messages posted to the topic. For more information on service
+bus and how it works please refer to this [article](https://azure.microsoft.com/en-us/documentation/articles/service-bus-fundamentals-hybrid-solutions/#service-bus-fundamentals).
+
+### Configuration
+
+To begin using this gem we need to start by setting some environment variables. The gem in development and
+test environments supports .env files (i.e. .env.test and .env.development etc). The environment variables that
+require to be set prior to using the gem are; NAMESPACE, KEY_NAME and KEY_SECRET. The values for these variables
+can be obtained from your Azure management portal. For more information on how to obtain these values for your
+service bus please refer to this [article](https://azure.microsoft.com/en-us/documentation/articles/service-bus-authentication-and-authorization/).
+
+### Examples
+
+To define a topic to which messages can be delivered;
+
+```ruby
+topic = Bifrost::Topic.new('topic_name')
+topic.save
+```
+
+The `save` method returns a `true` or `false` to indicate if the topic was successfully saved. A topic may not save
+if it already exists.
+
+To add a subscriber to a particular topic;
+
+```ruby
+topic = Bifrost::Topic.new('topic_name')
+topic.save
+subscriber = Bifrost::Subscriber.new('new_subscriber')
+topic.add_subscriber(subscriber)
+```
+
+Each topic can only have a unique list of subscribers, a subscriber cannot be added to a topic more than once. When a subscriber is added to
+a topic this function will return a true or false indicating success of the add.
+
+To post a message to a topic;
+
+```ruby
+topic = Bifrost::Topic.new('topic_name')
+message = Bifrost::Message.new(content: 'some data')
+message.post_to(topic)
+```
+
+This function returns a `true` or `false` indicating the success of the message delivery. This method is synchronous. Each message has an
+identifier which gets sets upon successful delivery only.
+
+A message can also be optionally published with a subject;
+
+```ruby
+topic = Bifrost::Topic.new('topic_name')
+message = Bifrost::Message.new(content: 'some data', 'message subject')
+message.post_to(topic)
+```
+
+Subscribers in the Bifrost are [actors](http://http://doc.akka.io/docs/akka/2.4/general/actors.html), these actors run in
+their own threads. At present the Bifrost does not support thread pools, this is something we are investigating and are
+hoping to add at some point. In the Bifrost each actor is referred to as a `worker`. A worker is designed to receive
+messages published to a particular topic with a specific subscriber in mind (refer to the fan-out comment earlier).
+
+Workers are added to the Bifrost via the manager. The manager is what activates the workers in the Bifrost environment.
+You can use multiple managers if you like at any given point in time to orchestrate the workers. These managers and workers
+are only allowed to work in a single namespace at a time.
+
+To setup a single worker to receive messages sent to a particular topic and subscriber;
+
+```ruby
+manager = Bifrost::Manager.new
+manager.add('topic_name', 'subscriber_name', proc { |m| puts "Received: message #{m}" })
+manager.run
+```
+
+To setup multiple workers to receive messages;
+
+```ruby
+manager = Bifrost::Manager.new
+manager.add('topic_name', 'subscriber_name', proc { |m| puts "Received: message #{m}" })
+manager.add('another_topic_name', 'another_subscriber_name', proc { |m| puts "Received: message #{m}" })
+manager.run
+```
+
+Workers in the Bifrost are self healing, when an actor dies the manager receives a message alerting the manager
+to the failure, the worker then restarts after the failure.
+
+**We hope to introduce custom lambda functions in the future to support custom actions when a worker dies**
+
+#Is it any good?
+
+We are currently [dogfooding](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) this product in our production
+environment. We will no doubt find issues and rectify this over time.
+
+#Contributing
+
+We'd love to have you involved. Please read our [contributing guide]() for information on how to get stuck in.
+
+Contributors
+
+This project is managed by the Filmpond team.
+
+These individuals have come up with the ideas and written the code that made this possible:
+
+1. Shirren Premaratne
+2. Leslie Fung
+
+#Licence
+
+This program is free software: you can redistribute it and/or modify it under the terms of the MIT License.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MIT License for more details.
+
+The MIT License (MIT)
+
+Copyright (C) 2016 Filmpond Pty Ltd
+
+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/lib/bifrost.rb

@@ -0,0 +1,18 @@
+require 'bifrost/message'
+require 'bifrost/topic'
+require 'bifrost/subscriber'
+require 'bifrost/manager'
+require 'bifrost/worker'
+
+# Bifrost is a pub/sub gem built on top of the Azure MessageBus system
+module Bifrost
+  # Simple utlity that creates a topic and a single subscriber for the given
+  # topic. The topic is returned
+  def self.create_topic_with_subscriber(topic_name, sub_name)
+    topic = Bifrost::Topic.new(topic_name)
+    topic.save
+    subscriber = Bifrost::Subscriber.new(sub_name)
+    topic.add_subscriber(subscriber)
+    topic
+  end
+end

data/lib/bifrost/entity.rb

@@ -0,0 +1,16 @@
+require 'Azure'
+
+module Bifrost
+  # Types that require access to the message bus should inherit this type. We've chosen
+  # inheritance at this point, perhaps a mixin might be a better approach
+  class Entity
+    attr_reader :bus
+
+    def initialize
+      Azure.sb_namespace = ENV['NAMESPACE']
+      host = "https://#{Azure.sb_namespace}.servicebus.windows.net"
+      signer = Azure::ServiceBus::Auth::SharedAccessSigner.new(ENV['KEY_NAME'], ENV['KEY_SECRET'])
+      @bus ||= Azure::ServiceBus::ServiceBusService.new(host, signer: signer)
+    end
+  end
+end

data/lib/bifrost/exceptions/duplicate_subscriber_error.rb

@@ -0,0 +1,6 @@
+module Bifrost
+  module Exceptions
+    class DuplicateSubscriberError < StandardError
+    end
+  end
+end

data/lib/bifrost/exceptions/invalid_worker_definition_error.rb

@@ -0,0 +1,6 @@
+module Bifrost
+  module Exceptions
+    class InvalidWorkerDefinitionError < StandardError
+    end
+  end
+end

data/lib/bifrost/exceptions/unsupported_lambda_error.rb

@@ -0,0 +1,6 @@
+module Bifrost
+  module Exceptions
+    class UnsupportedLambdaError < StandardError
+    end
+  end
+end

data/lib/bifrost/manager.rb

@@ -0,0 +1,49 @@
+require 'azure'
+require 'celluloid/current'
+require_relative 'exceptions/invalid_worker_definition_error'
+
+module Bifrost
+  # This class is used to handle the setup and execution of multiple listeners
+  class Manager
+    include Celluloid
+
+    # The supervisor needs to be notified when a worker dies, it also needs to
+    # protect itself from harm
+    trap_exit :worker_died
+
+    # A supervised worker can be added to the current collection of supervised workers
+    # this also starts the actor
+    def add(topic_name, subscriber_name, proc)
+      if topic_name.nil? || subscriber_name.nil? || proc.nil?
+        raise InvalidWorkerDefinitionError, 'Invalid worker'
+      else
+        @supervisor = Worker.supervise(
+          as:   Worker.supervisor_handle(topic_name, subscriber_name),
+          args: [topic_name, subscriber_name, proc]
+        )
+        # Link the worker to the supervisor so if the worker misbehaves the supervisor is alerted
+        # to this poor behaviour, the supervisor decides how to handle recovery
+        link(@supervisor.actors.last)
+      end
+    end
+
+    # When we run all the workers as actors in their own threads. This run also blocks to make sure
+    # the spawned threads remain operational indefinitely
+    def run
+      @supervisor.actors.each { |w| w.async.run }
+      # Put the supervisor thread to sleep indefinitely # Better way?
+      loop do
+        # TODO: Better way?
+        sleep(5)
+      end
+    end
+
+    private
+
+    # This callback function fires when an worker dies
+    def worker_died(worker, reason)
+      # TODO: Log this instead
+      puts "#{worker.inspect} has died: #{reason.class}"
+    end
+  end
+end

data/lib/bifrost/message.rb

@@ -0,0 +1,46 @@
+require 'azure'
+require_relative 'entity'
+
+module Bifrost
+  # A message is a letter that we send to a topic. It must contain a subject and body
+  # The receiver can process both fields on receipt of the message
+  class Message < Bifrost::Entity
+    attr_reader :subject, :body, :status, :message_id
+
+    # A message must have a valid subject and body. The service
+    # bus is initialised in the Entity class
+    def initialize(body, subject = nil)
+      @subject = subject || SecureRandom.base64
+      @body ||= body
+      @status ||= :undelivered
+      super()
+    end
+
+    # A message can be posted to a particular topic
+    def post_to(topic)
+      if topic.exists?
+        message = create_brokered_message
+        bus.send_topic_message(topic.name, message)
+        update_message_state_to_delivered(message)
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    # Create the brokered message
+    def create_brokered_message
+      message = Azure::ServiceBus::BrokeredMessage.new(subject, message: body)
+      message.correlation_id = SecureRandom.hex
+      message
+    end
+
+    # Update the status of the message post delivery
+    def update_message_state_to_delivered(message)
+      @status = :delivered
+      @message_id ||= message.correlation_id
+    end
+  end
+end

data/lib/bifrost/subscriber.rb

@@ -0,0 +1,13 @@
+require 'azure'
+
+module Bifrost
+  # A subscriber is a type that registers interest in receiving messages posted to certain topics
+  class Subscriber
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name ||= name
+      @options ||= options
+    end
+  end
+end

data/lib/bifrost/topic.rb

@@ -0,0 +1,75 @@
+require 'azure'
+require_relative 'entity'
+require_relative 'exceptions/duplicate_subscriber_error'
+
+module Bifrost
+  # Topics are central to the pub/sub system in the Bifrost. All messages must be delivered
+  # to a topic. The topic is responsible for forwarding the message to registered subscribers
+  class Topic < Entity
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name ||= name
+      @options ||= options
+      super()
+    end
+
+    # If the topic has been defined this method returns true, if not
+    # it returns false
+    def exists?
+      bus.list_topics.each do |topic|
+        return true if topic.name == name
+      end
+      false
+    end
+
+    # If a topic has not been defined we can save it, so it becomes defined
+    def save
+      if exists?
+        false
+      else
+        bus.create_topic(name)
+        true
+      end
+    end
+
+    # If a topic is defined, we can remove the definition
+    def delete
+      if exists?
+        bus.delete_topic(name)
+        true
+      else
+        false
+      end
+    end
+
+    # A new subscriber can be added to a topic
+    def add_subscriber(subscriber)
+      if exists?
+        begin
+          bus.create_subscription(name, subscriber.name)
+        rescue Azure::Core::Http::HTTPError => e
+          raise Bifrost::Exceptions::DuplicateSubscriberError, "Duplicate subscriber for topic #{name}" if e.status_code == 409
+        end
+        true
+      else
+        false
+      end
+    end
+
+    # A topic subscriber can be removed from the topic if it exists
+    def remove_subscriber(subscriber)
+      if exists?
+        begin
+          bus.delete_subscription(name, subscriber.name)
+        rescue Azure::Core::Http::HTTPError => e
+          return false if e.status_code == 404
+          raise e
+        end
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/bifrost/version.rb

@@ -0,0 +1,16 @@
+# Major.Minor.Patch version numbering
+module Bifrost
+  # The major version of Sif, updated only for major changes that are
+  # likely to require modification to Filmpond apps.
+  MAJOR_VERSION = 0
+
+  # The minor version of Sif, updated for new feature releases.
+  MINOR_VERSION = 1
+
+  # The patch version of Sif, updated only for bug fixes from the last
+  # feature release.
+  PATCH_VERSION = 0
+
+  # The full version as a string.
+  VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}.#{PATCH_VERSION}".freeze
+end

data/lib/bifrost/worker.rb

@@ -0,0 +1,59 @@
+require 'azure'
+require 'celluloid/current'
+require_relative 'entity'
+require_relative 'exceptions/unsupported_lambda_error'
+
+module Bifrost
+  # This class is used to read messages from the subscriber, and process the messages one
+  # by one. This class is a worker/actor which focusses on processes a single topic/subscriber
+  # combination one at a time
+  class Worker < Bifrost::Entity
+    include Celluloid
+
+    attr_reader :topic_name, :subscriber_name, :callback
+
+    def initialize(topic_name, subscriber_name, callback)
+      raise Bifrost::Exceptions::UnsupportedLambdaError, 'not a proc' unless callback.respond_to?(:call)
+      @topic_name ||= topic_name
+      @subscriber_name ||= subscriber_name
+      @callback ||= callback
+      super()
+    end
+
+    # This method starts the actor, which runs in an infinite loop. This means the worker should
+    # not terminate, but if it does, the supervisor will make sure it restarts
+    def run
+      loop do
+        read_message
+        sleep(ENV['QUEUE_DELAY'] || 10)
+      end
+    end
+
+    # Workers have a friendly name which is a combination of the topic and subscriber name
+    # which in the operational environment should be unique
+    def to_s
+      Worker.supervisor_handle(topic_name, subscriber_name)
+    end
+
+    # Utlity method to get the name of the worker as a symbol
+    def to_sym
+      to_s.to_sym
+    end
+
+    # A worker can tell you what it's friendly name will be, this is in order for supervision
+    def self.supervisor_handle(topic_name, subscriber_name)
+      "#{topic_name}-#{subscriber_name}"
+    end
+
+    private
+
+    # Actual processing of the message
+    def read_message
+      message = bus.receive_subscription_message(topic_name, subscriber_name, timeout: ENV['TIMEOUT'] || 10)
+      if message
+        callback.call(message.properties['message'])
+        bus.delete_subscription_message(message)
+      end
+    end
+  end
+end

data/spec/bifrost/manager_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'bifrost'
+
+describe Bifrost::Manager do
+  let(:cb  )    { proc { |m| puts "Principle Received: message #{m}" } }
+  let(:worker)  { Bifrost::Worker.new('topic', 'subscriber', proc) }
+  let(:manager) { Bifrost::Manager.new }
+
+  skip 'should be able to help a faulty actor heal' do
+    manager.add('topicX', 'blah', proc { |m| puts "Secondary Received: message #{m}" })
+    manager.run
+  end
+end

data/spec/bifrost/message_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'bifrost/message'
+require 'bifrost/topic'
+require 'bifrost/subscriber'
+
+describe Bifrost::Message do
+  subject(:message) { Bifrost::Message.new({ content: 'some data' }, 'subscriber_name') }
+
+  it { is_expected.to respond_to(:subject) }
+  it { is_expected.to respond_to(:status) }
+  it { is_expected.to respond_to(:message_id) }
+  it { is_expected.to respond_to(:body) }
+  it { is_expected.to respond_to(:post_to) }
+
+  context 'which is initialized' do
+    it 'should be in an undelivered status' do
+      expect(message.status).to eq(:undelivered)
+    end
+  end
+
+  it 'should be able to auto generate a subject' do
+    new_message = Bifrost::Message.new(content: 'some data')
+    expect(new_message).to_not be_nil
+  end
+
+  it 'should be postable to a valid topic' do
+    topic = Bifrost::Topic.new('valid-topic')
+    topic.save
+    topic.add_subscriber(Bifrost::Subscriber.new('new_subscriber'))
+    expect(message.post_to(topic)).to be_truthy
+    expect(message.status).to eq(:delivered)
+    expect(message.message_id).not_to be_nil
+    topic.delete
+  end
+
+  it 'should not be postable to an invalid topic' do
+    topic = Bifrost::Topic.new('invalid-topic') # A topic that is neither saved, nor with no subscribers is semantically invalid
+    expect(message.post_to(topic)).to be_falsey
+  end
+end

data/spec/bifrost/subscriber_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'bifrost/subscriber'
+
+describe Bifrost::Subscriber do
+  subject(:subscriber) { Bifrost::Subscriber.new('subscriber_name') }
+
+  it { is_expected.to respond_to(:name) }
+end

data/spec/bifrost/topic_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'bifrost/topic'
+require 'bifrost/subscriber'
+
+describe Bifrost::Topic do
+  subject(:topic) { Bifrost::Topic.new('topic_name') }
+
+  it { is_expected.to respond_to(:name) }
+  it { is_expected.to respond_to(:exists?) }
+  it { is_expected.to respond_to(:save) }
+  it { is_expected.to respond_to(:delete) }
+  it { is_expected.to respond_to(:add_subscriber) }
+  it { is_expected.to respond_to(:remove_subscriber) }
+
+  it 'should not support blank topic names' do
+    invalid_topic = Bifrost::Topic.new(nil)
+    expect { invalid_topic.save }.to raise_error(TypeError)
+  end
+
+  context 'for an undefined topic' do
+    it 'should return false for defined?' do
+      expect(topic.exists?).to be_falsey
+    end
+
+    it 'should persist the topic' do
+      new_topic = Bifrost::Topic.new('new_topic_name')
+      expect(new_topic.save).to be_truthy
+      expect(new_topic.delete).to be_truthy
+    end
+
+    it 'should return false for delete' do
+      expect(topic.delete).to be_falsey
+    end
+
+    it 'should not be able to add a new subscriber' do
+      subscriber = Bifrost::Subscriber.new('new_subscriber')
+      expect(topic.add_subscriber(subscriber)).to be_falsey
+    end
+
+    it 'should not be able to remove a subscriber' do
+      subscriber = Bifrost::Subscriber.new('new_subscriber')
+      expect(topic.remove_subscriber(subscriber)).to be_falsey
+    end
+  end
+
+  context 'for a defined topic' do
+    let(:new_topic) { Bifrost::Topic.new('test_donotdelete') }
+
+    before(:all) do
+      tp = Bifrost::Topic.new('test_donotdelete')
+      tp.save unless tp.exists?
+    end
+
+    after(:all) do
+      tp = Bifrost::Topic.new('test_donotdelete')
+      tp.delete if tp.exists?
+    end
+
+    it 'should return true for defined?' do
+      expect(new_topic.exists?).to be_truthy
+    end
+
+    it 'should return false for save' do
+      expect(new_topic.save).to be_falsey
+    end
+
+    it 'should be able to add and remove a new subscriber' do
+      subscriber = Bifrost::Subscriber.new('new_subscriber')
+      expect(new_topic.add_subscriber(subscriber)).to be_truthy
+      expect(new_topic.remove_subscriber(subscriber)).to be_truthy
+    end
+
+    it 'should not be able to remove a non existent subscriber' do
+      subscriber = Bifrost::Subscriber.new('non_existent_subscriber')
+      expect(new_topic.remove_subscriber(subscriber)).to be_falsey
+    end
+
+    it 'should not be able to add a duplicate subscriber' do
+      subscriber = Bifrost::Subscriber.new('another_new_subscriber')
+      expect(new_topic.add_subscriber(subscriber)).to be_truthy
+      expect { new_topic.add_subscriber(subscriber) }.to raise_error(Bifrost::Exceptions::DuplicateSubscriberError)
+    end
+  end
+
+  it 'should not accept names with spaces in them' do
+    invalid_topic_name = Bifrost::Topic.new('topic name')
+    expect { invalid_topic_name.save }.to raise_error(URI::InvalidURIError)
+  end
+end

data/spec/bifrost/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Bifrost do
+  it 'should have a version number' do
+    expect(Bifrost::VERSION).not_to be nil
+  end
+end

data/spec/bifrost/worker_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'bifrost/exceptions/unsupported_lambda_error'
+require 'bifrost/message'
+require 'bifrost/topic'
+require 'bifrost/subscriber'
+require 'bifrost/worker'
+
+describe Bifrost::Worker do
+  let(:cb) { proc { |m| puts "Received: message #{m}" } }
+  subject(:worker) { Bifrost::Worker.new('topic', 'subscriber', cb) }
+
+  it { is_expected.to respond_to(:topic_name) }
+  it { is_expected.to respond_to(:subscriber_name) }
+
+  it 'should not except non procs in last argument' do
+    expect { Bifrost::Worker.new('topic', 'subscriber', 'x') }
+      .to raise_error(Bifrost::Exceptions::UnsupportedLambdaError)
+  end
+
+  it 'should have a friendly string name' do
+    expect(worker.to_s).to eq("#{worker.topic_name}-#{worker.subscriber_name}")
+  end
+
+  it 'should have a friendly symbol name' do
+    expect(worker.to_sym).to eq(worker.to_s.to_sym)
+  end
+
+  skip 'should be able to listen for messages' do
+    topic = Bifrost::Topic.new('topic')
+    topic.save
+    subscriber = Bifrost::Subscriber.new('subscriber')
+    topic.add_subscriber(subscriber)
+    msg = Bifrost::Message.new([item1: { data: 2 }, item2: { more_data: 3 }])
+    msg.post_to(topic)
+    expect(msg.status).to eq(:delivered)
+    expect(msg.message_id).not_to be_nil
+    worker.async.run
+    sleep
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'azure'
+require 'byebug'
+require 'dotenv'
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+RSpec.configure do |config|
+  # Load environment variables for Azure
+  Dotenv.load('.env.test')
+
+  # All specs use this pre-defined namespace in Azure
+  Azure.sb_namespace = ENV['NAMESPACE']
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: bi-frost
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shirren Premaratne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: azure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Topic definitions should occur via the Bifrost. Subscriptions should
+  take place via the Bifrost. Therefore all messages need to transit through the Bifrost
+email:
+- shirren@filmpond.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bifrost.rb
+- lib/bifrost/entity.rb
+- lib/bifrost/exceptions/duplicate_subscriber_error.rb
+- lib/bifrost/exceptions/invalid_worker_definition_error.rb
+- lib/bifrost/exceptions/unsupported_lambda_error.rb
+- lib/bifrost/manager.rb
+- lib/bifrost/message.rb
+- lib/bifrost/subscriber.rb
+- lib/bifrost/topic.rb
+- lib/bifrost/version.rb
+- lib/bifrost/worker.rb
+- spec/bifrost/manager_spec.rb
+- spec/bifrost/message_spec.rb
+- spec/bifrost/subscriber_spec.rb
+- spec/bifrost/topic_spec.rb
+- spec/bifrost/version_spec.rb
+- spec/bifrost/worker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/filmpond/bifrost
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Bifrost is a simple pub/sub messaging wrapper component.
+test_files:
+- spec/bifrost/manager_spec.rb
+- spec/bifrost/message_spec.rb
+- spec/bifrost/subscriber_spec.rb
+- spec/bifrost/topic_spec.rb
+- spec/bifrost/version_spec.rb
+- spec/bifrost/worker_spec.rb
+- spec/spec_helper.rb