dispatch-rider 0.0.3

data/lib/dispatch-rider/notification_services.rb

@@ -0,0 +1,9 @@
+# The namespace that holds the notification services services
+module DispatchRider
+  module NotificationServices
+  end
+end
+
+require "dispatch-rider/notification_services/base"
+require "dispatch-rider/notification_services/aws_sns"
+require "dispatch-rider/notification_services/file_system"

data/lib/dispatch-rider/notification_services/aws_sns.rb

@@ -0,0 +1,23 @@
+# This is a basic implementation of the Notification service using Amazon SNS.
+# The expected usage is as follows :
+#   notification_service = DispatchRider::NotificationServices::AwsSns.new
+#   notification_service.publish(:to => [:foo, :oof], :message => {:subject => "bar", :body => "baz"})
+module DispatchRider
+  module NotificationServices
+    class AwsSns < Base
+      def notifier_builder
+        AWS::SNS
+      rescue NameError
+        raise AdapterNotFoundError.new(self.class.name, 'aws-sdk')
+      end
+
+      def channel_registrar_builder
+        Registrars::SnsChannel
+      end
+
+      def channel(name)
+        notifier.topics[self.fetch(name)]
+      end
+    end
+  end
+end

data/lib/dispatch-rider/notification_services/base.rb

@@ -0,0 +1,57 @@
+# This base class provides an interface that we can implement
+# to generate a wrapper around a notification service.
+# The expected usage is as follows :
+#   notification_service = DispatchRider::NotificationServices::Base.new
+#   notification_service.publish(:to => [:foo, :oof], :message => {:subject => "bar", :body => "baz"})
+module DispatchRider
+  module NotificationServices
+    class Base
+      extend Forwardable
+
+      attr_reader :notifier, :channel_registrar
+
+      def_delegators :channel_registrar, :register, :fetch, :unregister
+
+      def initialize(options = {})
+        @notifier = notifier_builder.new(options)
+        @channel_registrar = channel_registrar_builder.new
+      end
+
+      def notifier_builder
+        raise NotImplementedError
+      end
+
+      def channel_registrar_builder
+        raise NotImplementedError
+      end
+
+      def publish(options)
+        channels(options[:to]).each do |channel|
+          channel.publish(serialize(message(options[:message])))
+        end
+      end
+
+      def channels(names)
+        Array(names).map { |name| channel(name) }
+      end
+
+      def channel(name)
+        raise NotImplementedError
+      end
+
+      def message_builder
+        DispatchRider::Message
+      end
+
+      private
+
+      def message(attrs)
+        message_builder.new(attrs)
+      end
+
+      def serialize(item)
+        item.to_json
+      end
+    end
+  end
+end

data/lib/dispatch-rider/notification_services/file_system.rb

@@ -0,0 +1,22 @@
+# this is a basic notification service which uses a filesystem folder to handle notifications
+
+module DispatchRider
+  module NotificationServices
+    class FileSystem < Base
+      def notifier_builder
+        Notifier
+      end
+
+      def channel_registrar_builder
+        DispatchRider::Registrars::FileSystemChannel
+      end
+
+      def channel(name)
+        notifier.channel(self.fetch(name))
+      end
+    end
+  end
+end
+
+require 'dispatch-rider/notification_services/file_system/channel'
+require 'dispatch-rider/notification_services/file_system/notifier'

data/lib/dispatch-rider/notification_services/file_system/channel.rb

@@ -0,0 +1,16 @@
+# this represents a FileSystem queue channel (or basically a folder)
+
+module DispatchRider
+  module NotificationServices
+    class FileSystem::Channel
+
+      def initialize(path)
+        @file_system_queue = DispatchRider::QueueServices::FileSystem::Queue.new(path)
+      end
+
+      def publish(message)
+        @file_system_queue.add(message.to_json)
+      end
+    end
+  end
+end

data/lib/dispatch-rider/notification_services/file_system/notifier.rb

@@ -0,0 +1,17 @@
+# This is abstraction around a notifier service for FileSystem based queue services
+
+module DispatchRider
+  module NotificationServices
+    class FileSystem::Notifier
+
+      def initialize(options)
+        # nothing to do here
+      end
+
+      def channel(path)
+        FileSystem::Channel.new(path)
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/publisher.rb

@@ -0,0 +1,65 @@
+# This class takes care of the publishing side of the messaging system.
+module DispatchRider
+  class Publisher
+    attr_reader :service_channel_mapper, :notification_service_registrar, :publishing_destination_registrar, :sns_channel_registrar
+
+    def initialize
+      @notification_service_registrar = DispatchRider::Registrars::NotificationService.new
+      @publishing_destination_registrar = DispatchRider::Registrars::PublishingDestination.new
+      @service_channel_mapper = ServiceChannelMapper.new(publishing_destination_registrar)
+    end
+
+    def register_notification_service(name, options = {})
+      notification_service_registrar.register(name, options)
+      self
+    end
+
+    def register_destination(name, service, channel, options = {})
+      register_channel(service, channel, options)
+      publishing_destination_registrar.register(name, :service => service, :channel => channel)
+      self
+    end
+
+    def register_channel(service, name, options = {})
+      notification_service = notification_service_registrar.fetch(service)
+      notification_service.register(name, options)
+      self
+    end
+
+    def publish(opts = {})
+      options = opts.dup
+      service_channel_mapper.map(options.delete(:destinations)).each do |(service, channels)|
+        notification_service_registrar.fetch(service).publish(options.merge(:to => channels))
+      end
+    end
+
+    class ServiceChannelMapper
+      attr_reader :destination_registrar
+
+      def initialize(destination_registrar)
+        @destination_registrar = destination_registrar
+      end
+
+      def map(names)
+        services_and_channels_map(publishing_destinations(names))
+      end
+
+      private
+
+      def publishing_destinations(names)
+        Array(names).map { |name| destination_registrar.fetch(name) }
+      end
+
+      def services_and_channels_map(destinations)
+        destinations.reduce({}) do |result, destination|
+          if result.has_key?(destination.service)
+            result[destination.service] << destination.channel
+          else
+            result[destination.service] = [destination.channel]
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/dispatch-rider/queue_services.rb

@@ -0,0 +1,10 @@
+# The namespace that holds the queue services
+module DispatchRider
+  module QueueServices
+  end
+end
+
+require "dispatch-rider/queue_services/base"
+require "dispatch-rider/queue_services/simple"
+require "dispatch-rider/queue_services/aws_sqs"
+require "dispatch-rider/queue_services/file_system"

data/lib/dispatch-rider/queue_services/aws_sqs.rb

@@ -0,0 +1,39 @@
+# This queue service is based on aws sqs.
+# To make this queue service work, one would need the aws sqs gem to be installed.
+module DispatchRider
+  module QueueServices
+    class AwsSqs < Base
+      require "dispatch-rider/queue_services/aws_sqs/message_body_extractor"
+
+      def assign_storage(attrs)
+        begin
+          AWS::SQS.new.queues.named(attrs.fetch(:name))
+        rescue NameError
+          raise AdapterNotFoundError.new(self.class.name, 'aws-sdk')
+        rescue IndexError
+          raise RecordInvalid.new(self, ["Name can not be blank"])
+        end
+      end
+
+      def insert(item)
+        queue.send_message(item)
+      end
+
+      def raw_head
+        queue.receive_message
+      end
+
+      def construct_message_from(item)
+        deserialize(MessageBodyExtractor.new(item).extract)
+      end
+
+      def delete(item)
+        item.delete
+      end
+
+      def size
+        queue.approximate_number_of_messages
+      end
+    end
+  end
+end

data/lib/dispatch-rider/queue_services/aws_sqs/message_body_extractor.rb

@@ -0,0 +1,17 @@
+module DispatchRider
+  module QueueServices
+    class AwsSqs < Base
+      class MessageBodyExtractor
+        attr_reader :parsed_message
+
+        def initialize(raw_message)
+          @parsed_message = JSON.parse(raw_message.body)
+        end
+
+        def extract
+          parsed_message.has_key?("Message") ? parsed_message["Message"] : parsed_message.to_json
+        end
+      end
+    end
+  end
+end

data/lib/dispatch-rider/queue_services/base.rb

@@ -0,0 +1,74 @@
+# This is the base class that provides the template for all queue services.
+# The child classes must implement the following methods to become a concrete class :
+# assign_storage, insert, raw_head, construct_message_from, delete and size.
+# The instances of this class or it's child classes are supposed to perform the following actions on the queue service :
+# initialize, push, pop and empty?
+module DispatchRider
+  module QueueServices
+    class Base
+      attr_accessor :queue
+
+      def initialize(options = {})
+        @queue = assign_storage(options.symbolize_keys)
+      end
+
+      def assign_storage(attrs)
+        raise NotImplementedError
+      end
+
+      def push(item)
+        message = serialize(item)
+        insert(message)
+        message
+      end
+
+      def insert(item)
+        raise NotImplementedError
+      end
+
+      def pop(&block)
+        obj = head
+        if obj
+          block.call(obj.message) && delete(obj.item)
+          obj.message
+        end
+      end
+
+      def head
+        raw_item = raw_head
+        raw_item && OpenStruct.new(:item => raw_item, :message => construct_message_from(raw_item))
+      end
+
+      def raw_head
+        raise NotImplementedError
+      end
+
+      def construct_message_from(item)
+        raise NotImplementedError
+      end
+
+      def delete(item)
+        raise NotImplementedError
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def size
+        raise NotImplementedError
+      end
+
+      protected
+
+      def serialize(item)
+        item.to_json
+      end
+
+      def deserialize(item)
+        attrs = JSON.parse(item).symbolize_keys
+        DispatchRider::Message.new(attrs)
+      end
+    end
+  end
+end

data/lib/dispatch-rider/queue_services/file_system.rb

@@ -0,0 +1,39 @@
+# This is a rudementary queue service that uses file system instead of
+# AWS::SQS or SimpleQueue. It addresses SimpleQueue's inability to be used
+# by only one application instance while avoiding the cost of setting up AWS::SQS.
+# This is ideal to be used in development mode between multiple applications.
+module DispatchRider
+  module QueueServices
+    require "dispatch-rider/queue_services/file_system/queue"
+    class FileSystem < Base
+      def assign_storage(attrs)
+        begin
+          path = attrs.fetch(:path)
+          Queue.new(path)
+        rescue IndexError
+          raise RecordInvalid.new(self, ["Path can not be blank"])
+        end
+      end
+
+      def insert(item)
+        queue.add item
+      end
+
+      def raw_head
+        queue.pop
+      end
+
+      def construct_message_from(item)
+        deserialize(item.read)
+      end
+
+      def delete(item)
+        queue.remove item
+      end
+
+      def size
+        queue.size
+      end
+    end
+  end
+end

data/lib/dispatch-rider/queue_services/file_system/queue.rb

@@ -0,0 +1,42 @@
+# This is a queue implementation for the queue service based on file systems
+module DispatchRider
+  module QueueServices
+    class FileSystem < Base
+      class Queue
+        def initialize(path)
+          FileUtils.mkdir_p(path)
+          @path = path
+        end
+
+        def add(item)
+          name_base = "#{@path}/#{Time.now.to_f}"
+          File.open("#{name_base}.inprogress", "w"){ |f| f.write(item) }
+          FileUtils.mv("#{name_base}.inprogress", "#{name_base}.ready")
+        end
+
+        def pop
+          file_path = file_paths.first
+          return nil unless file_path
+          file_path_inflight = file_path.gsub(/\.ready$/, '.inflight')
+          FileUtils.mv(file_path, file_path_inflight)
+          File.new(file_path_inflight)
+        end
+
+        def remove(item)
+          item.close
+          File.unlink(item.path)
+        end
+
+        def size
+          file_paths.size
+        end
+
+        private
+
+        def file_paths
+          Dir["#{@path}/*.ready"]
+        end
+      end
+    end
+  end
+end