fake_servicebus 0.0.2

data/lib/fake_servicebus/actions/list_queues.rb

@@ -0,0 +1,28 @@
+module FakeServiceBus
+  module Actions
+    class ListQueues
+
+      def initialize(options = {})
+        @server    = options.fetch(:server)
+        @queues    = options.fetch(:queues)
+        @responder = options.fetch(:responder)
+        @request   = options.fetch(:request)
+      end
+
+      def call(params)
+        found = @queues.list(params)
+        xml = Builder::XmlMarkup.new()
+        xml.tag! "feed", :xmlns=>"http://www.w3.org/2005/Atom" do
+          xml.title "Queues", :type=>"text"
+          xml.id "https://fake_servicebus/$Resources/Queues"
+          xml.updated Time.now.utc.iso8601
+          xml.link :rel=>"self", :href=>"fake_servicebus/$Resources/Queues"
+          found.each do |queue|
+            @responder.queue xml, queue
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fake_servicebus/actions/receive_message.rb

@@ -0,0 +1,44 @@
+module FakeServiceBus
+  module Actions
+    class ReceiveMessage
+
+      MAX_WAIT_TIME_SECONDS = 20
+
+      def initialize(options = {})
+        @server    = options.fetch(:server)
+        @queues    = options.fetch(:queues)
+        @start_ts  = Time.now.to_f
+        @satisfied = false
+      end
+
+      def call(queue_name, params)
+        queue = @queues.get(queue_name)
+        message = queue.receive_message(params.merge(queues: @queues))
+        @satisfied = !message.nil? || expired?(queue, params)
+        if !message.nil?
+          [201,
+           {'location'=>message.location,
+            'BrokerProperties'=>{'SequenceNumber'=>message.sequence_number,
+                                 'LockToken'=>message.lock_token}.to_json},
+           message.body]
+        end
+      end
+
+      def satisfied?
+        @satisfied
+      end
+
+      protected
+      def elapsed
+        Time.now.to_f - @start_ts
+      end
+
+      def expired?(queue, params)
+        wait_time_seconds = Integer params.fetch("timeout") { 0 }
+        wait_time_seconds <= 0 ||
+        elapsed >= wait_time_seconds ||
+        elapsed >= MAX_WAIT_TIME_SECONDS
+      end
+    end
+  end
+end

data/lib/fake_servicebus/actions/renew_lock_message.rb

@@ -0,0 +1,19 @@
+module FakeServiceBus
+  module Actions
+    class RenewLockMessage
+
+      def initialize(options = {})
+        @server    = options.fetch(:server)
+        @queues    = options.fetch(:queues)
+      end
+
+      def call(queue_name, lock_token, params)
+        queue = @queues.get(queue_name)
+
+        queue.renew_lock_message(lock_token)
+        200
+      end
+
+    end
+  end
+end

data/lib/fake_servicebus/actions/send_message.rb

@@ -0,0 +1,22 @@
+module FakeServiceBus
+  module Actions
+    class SendMessage
+
+      def initialize(options = {})
+        @server    = options.fetch(:server)
+        @queues    = options.fetch(:queues)
+        @request   = options.fetch(:request)
+      end
+
+      def call(queue_name, params)
+        queue = @queues.get(queue_name)
+        message = queue.send_message(params.merge(
+            {'queue_name'=>queue_name,
+             'body'=>@request.body.read})
+        )
+        201
+      end
+
+    end
+  end
+end

data/lib/fake_servicebus/actions/unlock_message.rb

@@ -0,0 +1,19 @@
+module FakeServiceBus
+  module Actions
+    class UnlockMessage
+
+      def initialize(options = {})
+        @server    = options.fetch(:server)
+        @queues    = options.fetch(:queues)
+      end
+
+      def call(queue_name, lock_token, params)
+        queue = @queues.get(queue_name)
+
+        queue.unlock_message(lock_token)
+        200
+      end
+
+    end
+  end
+end

data/lib/fake_servicebus/api.rb

@@ -0,0 +1,71 @@
+require 'fake_servicebus/actions/create_queue'
+require 'fake_servicebus/actions/delete_queue'
+require 'fake_servicebus/actions/list_queues'
+require 'fake_servicebus/actions/get_queue'
+require 'fake_servicebus/actions/send_message'
+require 'fake_servicebus/actions/receive_message'
+require 'fake_servicebus/actions/unlock_message'
+require 'fake_servicebus/actions/renew_lock_message'
+require 'fake_servicebus/actions/delete_message'
+
+module FakeServiceBus
+
+  InvalidAction = Class.new(ArgumentError)
+
+  class API
+
+    attr_reader :queues, :options
+
+    def initialize(options = {})
+      @queues    = options.fetch(:queues)
+      @options   = options
+      @halt      = false
+      @timer     = Thread.new do
+        until @halt
+          queues.timeout_messages!
+          sleep(0.1)
+        end
+      end
+    end
+
+    def call(action, request, *args)
+      if FakeServiceBus::Actions.const_defined?(action)
+        action = FakeServiceBus::Actions.const_get(action).new(options.merge({:request => request}))
+        if action.respond_to?(:satisfied?)
+          result = nil
+          until @halt
+            result = attempt_once(action, *args)
+            break if action.satisfied?
+            sleep(0.1)
+          end
+          result
+        else
+          attempt_once(action, *args)
+        end
+      else
+        fail InvalidAction, "Unknown (or not yet implemented) action: #{action}"
+      end
+    end
+
+    def attempt_once(action, *args)
+      queues.transaction do
+        action.call(*args)
+      end
+    end
+
+    # Fake actions
+
+    def reset
+      queues.reset
+    end
+
+    def expire
+      queues.expire
+    end
+
+    def stop
+      @halt = true
+    end
+
+  end
+end

data/lib/fake_servicebus/catch_errors.rb

@@ -0,0 +1,19 @@
+require 'securerandom'
+
+module FakeServiceBus
+  class CatchErrors
+
+    def initialize(app, options = {})
+      @app = app
+      @response = options.fetch(:response)
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue => error
+      response = @response.new(error)
+      [ response.status, {}, [ response.body ] ]
+    end
+
+  end
+end

data/lib/fake_servicebus/collection_view.rb

@@ -0,0 +1,20 @@
+require 'forwardable'
+
+module FakeServiceBus
+  class CollectionView
+    include Enumerable
+    extend Forwardable
+    def_delegators :@original, :[], :each, :empty?, :size, :length
+
+    UnmodifiableObjectError = Class.new(StandardError)
+
+    def initialize( original )
+      @original = original
+    end
+
+    def []=(key_or_index,value)
+      raise UnmodifiableObjectError.new("This is a collection view and can not be modified - #{key_or_index} => #{value}")
+    end
+
+  end
+end

data/lib/fake_servicebus/daemonize.rb

@@ -0,0 +1,30 @@
+module FakeServiceBus
+  class Daemonize
+
+    attr_reader :pid
+
+    def initialize(options)
+      @pid = options.fetch(:pid) {
+        warn "No PID file specified while daemonizing!"
+        exit 1
+      }
+    end
+
+    def call
+      Process.daemon(true, true)
+
+      if File.exist?(pid)
+        existing_pid = File.open(pid, 'r').read.chomp.to_i
+        running = Process.getpgid(existing_pid) rescue false
+        if running
+          warn "Error, Process #{existing_pid} already running"
+          exit 1
+        else
+          warn "Cleaning up stale pid at #{pid}"
+        end
+      end
+      File.open(pid, 'w') { |f| f.write(Process.pid) }
+    end
+
+  end
+end

data/lib/fake_servicebus/databases/file.rb

@@ -0,0 +1,129 @@
+require "yaml/store"
+
+module FakeServiceBus
+  class FileDatabase
+
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = filename
+      @queue_objects = {}
+      unless thread_safe_store?
+        # before ruby 2.4, YAML::Store cannot be declared thread safe
+        #
+        # without that declaration, attempting to have some thread B enter a
+        # store.transaction on the store while another thread A is in one
+        # already will raise an error unnecessarily.
+        #
+        # to prevent this, we'll use our own mutex around store.transaction,
+        # so only one thread can even _try_ to enter the transaction at a
+        # time.
+        @store_mutex = Mutex.new
+        @store_mutex_owner = nil
+      end
+    end
+
+    def load
+      transaction do
+        store["queues"] ||= {}
+      end
+    end
+
+    def transaction
+      if thread_safe_store? || store_mutex_owned?
+        # if we already own the store mutex, we can expect the next line to
+        # raise (appropriately) when we try to nest transactions in the store.
+        # but if we took the other branch, the # @store_mutex.synchronize call
+        # would self-deadlock before we could raise the error.
+        store.transaction do
+          yield
+        end
+      else
+        # we still need to use an inner store.transaction block because it does
+        # more than just lock synchronization. it's unfortunately inefficient,
+        # but this isn't a production-oriented library.
+        @store_mutex.synchronize do
+          begin
+            # allows us to answer `store_mutex_owned?` above
+            @store_mutex_owner = Thread.current
+            store.transaction do
+              yield
+            end
+          ensure
+            @store_mutex_owner = nil
+          end
+        end
+      end
+    end
+
+    def reset
+      transaction do
+        store["queues"] = {}
+      end
+      @queue_objects = {}
+    end
+
+    def []=(key, value)
+      storage[key] = value.to_yaml
+    end
+
+    def [](key)
+      value = storage[key]
+      if value
+        deserialize(key)
+      else
+        value
+      end
+    end
+
+    def each(&block)
+      storage.each do |key, value|
+        yield key, deserialize(key)
+      end
+    end
+
+    def select(&block)
+      new_list = storage.select do |key, value|
+        yield key, deserialize(key)
+      end
+      Hash[new_list.map { |key, value| [key, deserialize(key)] }]
+    end
+
+    def delete(key)
+      @queue_objects.delete(key)
+      storage.delete(key)
+    end
+
+    def values
+      storage.map { |key, value|
+        deserialize(key)
+      }
+    end
+
+    private
+
+    def deserialize(key)
+      @queue_objects[key] ||= Queue.new(storage[key].merge(name: key, message_factory: Message))
+    end
+
+    def storage
+      store["queues"]
+    end
+
+    def thread_safe_store?
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.4")
+    end
+
+    def store_mutex_owned?
+      # this could be just "@store_mutex && @store_mutex.owned?" in ruby 2.x,
+      # but we still support 1.9.3 which doesn't have the "owned?" method
+      @store_mutex_owner == Thread.current
+    end
+
+    def store
+      @store ||= thread_safe_store? ?
+        YAML::Store.new(filename, true) :
+        YAML::Store.new(filename)
+    end
+  end
+end

data/lib/fake_servicebus/databases/memory.rb

@@ -0,0 +1,30 @@
+require "forwardable"
+require "thread"
+
+module FakeServiceBus
+  class MemoryDatabase
+    extend Forwardable
+
+    def_delegators :@queues,
+      :[], :[]=, :delete, :each, :select, :values
+
+    def initialize
+      @semaphore = Mutex.new
+    end
+
+    def load
+      @queues = {}
+    end
+
+    def transaction
+      @semaphore.synchronize do
+        yield
+      end
+    end
+
+    def reset
+      @queues = {}
+    end
+
+  end
+end

data/lib/fake_servicebus/error_response.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+require 'builder'
+require 'securerandom'
+
+module FakeServiceBus
+  class ErrorResponse
+
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    def status
+      @status ||= statuses.fetch(code)
+    end
+
+    def body
+      xml = Builder::XmlMarkup.new()
+      xml.ErrorResponse do
+        xml.Error do
+          xml.Type type
+          xml.Code code
+          xml.Message error.to_s
+          xml.Detail
+        end
+        xml.RequestId SecureRandom.uuid
+      end
+    end
+
+    private
+
+    def code
+      code = error.class.name.sub(/^FakeServiceBus::/, '')
+      if statuses.has_key?(code)
+        code
+      else
+        "InternalError"
+      end
+    end
+
+    def type
+      if status < 500
+        "Sender"
+      else
+        "Receiver"
+      end
+    end
+
+    def statuses
+      @statuses ||= YAML.load_file(File.expand_path('../error_responses.yml', __FILE__))
+    end
+
+  end
+end