eventq 2.0.0.rc1

data/lib/eventq/eventq_aws/sns.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module EventQ
+  module Amazon
+    # Helper SNS class to handle the API calls
+    class SNS
+      @@topic_arns = Concurrent::Hash.new
+
+      attr_reader :sns
+
+      def initialize(client)
+        @sns = client
+      end
+
+      # Create a TopicArn. if one already exists, it will return a pre-existing ARN from the cache.
+      # Even in the event of multiple threads trying to create one with AWS, AWS is idempotent and won't create
+      # duplicates
+      def create_topic_arn(event_type)
+        _event_type = EventQ.create_event_type(event_type)
+
+        arn = get_topic_arn(event_type)
+        unless arn
+          response = sns.create_topic(name: aws_safe_name(_event_type))
+          arn = response.topic_arn
+          @@topic_arns[_event_type] = arn
+        end
+
+        arn
+      end
+
+      # Check if a TopicArn exists.  This will check with AWS if necessary and cache the results if one is found
+      # @return TopicArn [String]
+      def get_topic_arn(event_type)
+        _event_type = EventQ.create_event_type(event_type)
+
+        arn = @@topic_arns[_event_type]
+        unless arn
+          response = sns.list_topics
+          arn = response.topics.detect { |topic| topic.topic_arn.end_with?(_event_type) }&.topic_arn
+
+          @@topic_arns[_event_type] = arn if arn
+        end
+
+        arn
+      end
+
+      def drop_topic(event_type)
+        topic_arn = get_topic_arn(event_type)
+        sns.delete_topic(topic_arn: topic_arn)
+
+        _event_type = EventQ.create_event_type(event_type)
+        @@topic_arns.delete(_event_type)
+
+        true
+      end
+
+      def aws_safe_name(name)
+        return name[0..79].gsub(/[^a-zA-Z\d_\-]/,'')
+      end
+    end
+  end
+end

data/lib/eventq/eventq_aws/sqs.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module EventQ
+  module Amazon
+    # Helper SQS class to handle the API calls
+    class SQS
+      @@queue_arns = Concurrent::Hash.new
+      @@queue_urls = Concurrent::Hash.new
+
+      attr_reader :sqs
+
+      def initialize(client)
+        @sqs = client
+      end
+
+      # Create a new queue.
+      def create_queue(queue, attributes = {})
+        _queue_name = EventQ.create_queue_name(queue.name)
+
+        url = get_queue_url(queue)
+        unless url
+          response = sqs.create_queue(
+            {
+              queue_name: aws_safe_name(_queue_name),
+              attributes: attributes
+            }
+          )
+          url = response.queue_url
+          @@queue_urls[_queue_name] = url
+        end
+
+        url
+      end
+
+      # Update a queue
+      def update_queue(queue, attributes = {})
+        url = get_queue_url(queue)
+        sqs.set_queue_attributes(
+          {
+            queue_url: url, # required
+            attributes: attributes
+          }
+        )
+
+        url
+      end
+
+      # Returns the ARN of a queue.  If none exists, nil will be returned.
+      #
+      # @param queue [EventQ::Queue]
+      # @return ARN [String]
+      def get_queue_arn(queue)
+        _queue_name = EventQ.create_queue_name(queue.name)
+
+        arn = @@queue_arns[_queue_name]
+        unless arn
+          url = get_queue_url(queue)
+          if url
+            response = sqs.get_queue_attributes(
+              {
+                queue_url: url,
+                attribute_names: ['QueueArn']
+              }
+            )
+            arn = response.attributes['QueueArn']
+          end
+        end
+
+        arn
+      end
+
+      # Returns the URL of the queue. If none exists, nil will be returned.
+      #
+      # @param queue [EventQ::Queue]
+      # @return URL [String]
+      def get_queue_url(queue)
+        _queue_name = EventQ.create_queue_name(queue.name)
+
+        url = @@queue_urls[_queue_name]
+        unless url
+          begin
+            response= sqs.get_queue_url(
+                queue_name: aws_safe_name(_queue_name)
+            )
+            url = response.queue_url
+          rescue Aws::SQS::Errors::NonExistentQueue
+            # Only want to return nil for this method when not found.
+          end
+
+          @@queue_urls[_queue_name] = url if url
+        end
+
+        url
+      end
+
+      def drop_queue(queue)
+        q = get_queue_url(queue)
+        sqs.delete_queue(queue_url: q)
+
+        _queue_name = EventQ.create_queue_name(queue.name)
+        @@queue_urls.delete(_queue_name)
+        @@queue_arns.delete(_queue_name)
+
+        true
+      end
+
+      def aws_safe_name(name)
+        return name[0..79].gsub(/[^a-zA-Z\d_\-]/,'')
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/configuration.rb

@@ -0,0 +1,33 @@
+module EventQ
+  class Configuration
+
+    def self.serialization_provider=(value)
+      @serialization_provider = value
+    end
+
+    def self.serialization_provider
+      if RUBY_PLATFORM =~ /java/
+        @serialization_provider ||= EventQ::SerializationProviders::JSON_PROVIDER
+      else
+        @serialization_provider ||= EventQ::SerializationProviders::OJ_PROVIDER
+      end
+    end
+
+    def self.signature_provider=(value)
+      @signature_provider = value
+    end
+
+    def self.signature_provider
+      @signature_provider ||= EventQ::SignatureProviders::SHA256
+    end
+
+    def self.signature_secret=(value)
+      @signature_secret = value
+    end
+
+    def self.signature_secret
+      @signature_secret
+    end
+
+  end
+end

data/lib/eventq/eventq_base/event_raised_exchange.rb

@@ -0,0 +1,7 @@
+module EventQ
+  class EventRaisedExchange < Exchange
+    def initialize
+      @name = 'eventq.eventraised.ex'
+    end
+  end
+end

data/lib/eventq/eventq_base/event_raised_queue.rb

@@ -0,0 +1,7 @@
+module EventQ
+  class EventRaisedQueue < Queue
+    def initialize
+      @name = 'eventq.eventraised'
+    end
+  end
+end

data/lib/eventq/eventq_base/eventq_client_contract.rb

@@ -0,0 +1,9 @@
+module EventQ
+  class EventQClientContract
+
+    def raise_event(event_type, event)
+
+    end
+
+  end
+end

data/lib/eventq/eventq_base/eventq_logger.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module EventQ
+
+  def self.logger
+    return @@logger
+  end
+
+  def self.set_logger(logger)
+    @@logger = logger
+  end
+
+  def self.log(type, message)
+    case type
+      when :info
+        logger.info(message)
+      when :debug
+        logger.debug(message)
+      when :error
+        logger.error(message)
+    end
+  rescue
+    #do nothing
+  end
+
+  EventQ.set_logger(Logger.new(STDOUT))
+
+end

data/lib/eventq/eventq_base/exceptions/invalid_signature_exception.rb

@@ -0,0 +1,9 @@
+module EventQ
+  module Exceptions
+    class InvalidSignatureException < StandardError
+      def initialize(message = "Invalid message signature.")
+        super(message)
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/exceptions/worker_thread_error.rb

@@ -0,0 +1,10 @@
+module EventQ
+  module Exceptions
+    # General thread error that signifies a thread about to shutdown.
+    class WorkerThreadError < StandardError
+      def initialize(message = 'Worker thread error')
+        super(message)
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/exceptions.rb

@@ -0,0 +1,2 @@
+require_relative 'exceptions/invalid_signature_exception'
+require_relative 'exceptions/worker_thread_error'

data/lib/eventq/eventq_base/exchange.rb

@@ -0,0 +1,5 @@
+module EventQ
+  class Exchange
+    attr_accessor :name
+  end
+end

data/lib/eventq/eventq_base/message_args.rb

@@ -0,0 +1,23 @@
+module EventQ
+  class MessageArgs
+    attr_reader :type
+    attr_reader :content_type
+    attr_reader :retry_attempts
+    attr_accessor :abort
+    attr_accessor :drop
+    attr_reader :context
+    attr_reader :id
+    attr_reader :sent
+
+    def initialize(type:, retry_attempts:, context: {}, content_type:, id: nil, sent: nil)
+      @type = type
+      @retry_attempts = retry_attempts
+      @abort = false
+      @drop = false
+      @context = context
+      @content_type = content_type
+      @id = id
+      @sent = sent
+    end
+  end
+end

data/lib/eventq/eventq_base/nonce_manager.rb

@@ -0,0 +1,57 @@
+module EventQ
+  class NonceManager
+
+    def self.configure(server:,timeout:10000,lifespan:3600000)
+      @server_url = server
+      @timeout = timeout
+      @lifespan = lifespan
+    end
+
+    def self.server_url
+      @server_url
+    end
+
+    def self.timeout
+      @timeout
+    end
+
+    def self.lifespan
+      @lifespan
+    end
+
+    def self.is_allowed?(nonce)
+      if @server_url == nil
+        return true
+      end
+
+      require 'redlock'
+      lock = Redlock::Client.new([ @server_url ]).lock(nonce, @timeout)
+      if lock == false
+        EventQ.log(:info, "[#{self.class}] - Message has already been processed: #{nonce}")
+        return false
+      end
+
+      return true
+    end
+
+    def self.complete(nonce)
+      if @server_url != nil
+        Redis.new(url: @server_url).expire(nonce, @lifespan)
+      end
+      return true
+    end
+
+    def self.failed(nonce)
+      if @server_url != nil
+        Redis.new(url: @server_url).del(nonce)
+      end
+      return true
+    end
+
+    def self.reset
+      @server_url = nil
+      @timeout = nil
+      @lifespan = nil
+    end
+  end
+end

data/lib/eventq/eventq_base/queue.rb

@@ -0,0 +1,27 @@
+module EventQ
+  class Queue
+    attr_accessor :allow_retry
+    attr_accessor :allow_retry_back_off
+    attr_accessor :dlq
+    attr_accessor :max_retry_attempts
+    attr_accessor :max_retry_delay
+    attr_accessor :name
+    attr_accessor :max_receive_count
+    attr_accessor :require_signature
+    attr_accessor :retry_delay
+
+    def initialize
+      @allow_retry = false
+      # Default retry back off settings
+      @allow_retry_back_off = false
+      # Default max receive count is 30
+      @max_receive_count = 30
+      # Default max retry attempts is 5
+      @max_retry_attempts = 5
+      # Default require signature to false
+      @require_signature = false
+      # Default retry delay is 30 seconds
+      @retry_delay = 30000
+    end
+  end
+end

data/lib/eventq/eventq_base/queue_message.rb

@@ -0,0 +1,31 @@
+module EventQ
+  class QueueMessage
+    extend ClassKit
+
+    attr_accessor_type :id, type: String
+    attr_accessor_type :retry_attempts, type: Integer
+    attr_accessor_type :type, type: String
+    attr_accessor_type :content
+    attr_accessor_type :content_type, type: String
+    attr_accessor_type :created, type: Float
+    attr_accessor_type :signature, type: String
+    attr_accessor_type :context, type: Hash
+
+    def initialize
+      @retry_attempts = 0
+      @created = Time.now.to_f
+      @id = SecureRandom.uuid
+      @context = {}
+    end
+
+    # Creates a signature for the message
+    #
+    # @param provider [EventQ::SignatureProviders::Sha256SignatureProvider] Signature provider that implements
+    #   a write method
+    def sign(provider)
+      return unless EventQ::Configuration.signature_secret
+
+      self.signature = provider.write(message: self, secret: EventQ::Configuration.signature_secret)
+    end
+  end
+end

data/lib/eventq/eventq_base/queue_worker_contract.rb

@@ -0,0 +1,23 @@
+module EventQ
+  # Contract class for queue workers
+  class QueueWorkerContract
+
+    def start(queue, options = {}, &block)
+
+    end
+
+    def stop
+
+    end
+
+    def on_retry_exceeded(&block)
+
+    end
+
+    def running?
+
+    end
+
+  end
+end
+

data/lib/eventq/eventq_base/serialization_providers/binary_serialization_provider.rb

@@ -0,0 +1,15 @@
+module EventQ
+  module SerializationProviders
+    class BinarySerializationProvider
+
+      def serialize(object)
+        Marshal::dump(object)
+      end
+
+      def deserialize(msg)
+        Marshal::load(msg)
+      end
+
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/array_writer.rb

@@ -0,0 +1,20 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class ArrayWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(Array)
+          end
+          def exec(obj)
+            array = []
+            obj.each do |a|
+              array << AttributeWriter.exec(a)
+            end
+            array
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/attribute_writer.rb

@@ -0,0 +1,24 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class AttributeWriter
+
+          def self.exec(obj)
+            aw = descendants.detect { |a| a.new.valid?(obj) } || ClassWriter
+            aw.new.exec(obj)
+          end
+
+          def self.descendants
+            descendants = []
+            ObjectSpace.each_object(singleton_class) do |k|
+              next if k.singleton_class?
+              descendants.unshift k unless k == self
+            end
+            descendants
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/class_writer.rb

@@ -0,0 +1,20 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class ClassWriter < AttributeWriter
+          def valid?(obj)
+            false
+          end
+          def exec(obj)
+            hash = { '^o': obj.class }
+            obj.instance_variables.each do |key|
+              hash[key[1..-1]] = AttributeWriter.exec(obj.instance_variable_get(key))
+            end
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/date_time_writer.rb

@@ -0,0 +1,33 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class DateTimeWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(DateTime)
+          end
+          def exec(obj)
+            seconds = obj.strftime('%S%N')
+            d = 1_000_000_000
+            if seconds.start_with?('0')
+              seconds[0] = ''
+              d = 100_000_000
+            end
+
+            {
+              '^O': 'DateTime',
+              year: obj.year,
+              month: obj.month,
+              day: obj.day,
+              hour: obj.hour,
+              min: obj.min,
+              sec: RationalWriter.new.exec(Rational(Integer(seconds), d)),
+              offset: RationalWriter.new.exec(obj.offset),
+              start: obj.start
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/date_writer.rb

@@ -0,0 +1,22 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class DateWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(Date) && !obj.is_a?(DateTime)
+          end
+          def exec(obj)
+            {
+              '^O': 'Date',
+              year: obj.year,
+              month: obj.month,
+              day: obj.day,
+              start: obj.start
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/hash_writer.rb

@@ -0,0 +1,18 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class HashWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(Hash)
+          end
+          def exec(obj)
+            obj.each do |key, value|
+              obj[key] = AttributeWriter.exec(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/rational_writer.rb

@@ -0,0 +1,20 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class RationalWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(Rational)
+          end
+          def exec(obj)
+            {
+              '^O': 'Rational',
+              numerator: obj.numerator,
+              denominator: obj.denominator
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/serializer.rb

@@ -0,0 +1,17 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class Serializer
+          def dump(obj)
+            JSON.dump(AttributeWriter.exec(obj))
+          end
+
+          def load(json)
+            raise NotImplementedError.new("[#{self.class}] - #load method has not yet been implemented.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eventq/eventq_base/serialization_providers/jruby/oj/time_writer.rb

@@ -0,0 +1,18 @@
+module EventQ
+  module SerializationProviders
+    module JRuby
+      module Oj
+        class TimeWriter < AttributeWriter
+          def valid?(obj)
+            obj.is_a?(Time)
+          end
+          def exec(obj)
+            {
+              '^t': obj.to_f
+            }
+          end
+        end
+      end
+    end
+  end
+end