eventq 2.0.0.rc1 → 2.0.0.rc2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventq
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - SageOne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-20 00:00:00.000000000 Z
+date: 2018-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
@@ -150,20 +164,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -192,7 +192,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: This is EventQ system
+description: EventQ is a pub/sub system that uses async notifications and message
+  queues
 email:
 - sageone@sage.com
 executables: []
@@ -204,14 +205,12 @@ files:
 - bin/setup
 - lib/eventq.rb
 - lib/eventq/aws.rb
-- lib/eventq/eventq_aws/README.md
 - lib/eventq/eventq_aws/aws_eventq_client.rb
 - lib/eventq/eventq_aws/aws_queue_client.rb
 - lib/eventq/eventq_aws/aws_queue_manager.rb
 - lib/eventq/eventq_aws/aws_queue_worker.rb
 - lib/eventq/eventq_aws/aws_status_checker.rb
 - lib/eventq/eventq_aws/aws_subscription_manager.rb
-- lib/eventq/eventq_aws/jruby/aws_queue_worker.rb
 - lib/eventq/eventq_aws/sns.rb
 - lib/eventq/eventq_aws/sqs.rb
 - lib/eventq/eventq_base/configuration.rb
@@ -230,19 +229,6 @@ files:
 - lib/eventq/eventq_base/queue_worker_contract.rb
 - lib/eventq/eventq_base/serialization_providers.rb
 - lib/eventq/eventq_base/serialization_providers/binary_serialization_provider.rb
-- lib/eventq/eventq_base/serialization_providers/jruby.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/array_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/attribute_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/class_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/date_time_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/date_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/hash_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/rational_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/serializer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/time_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj/value_writer.rb
-- lib/eventq/eventq_base/serialization_providers/jruby/oj_serialization_provider.rb
 - lib/eventq/eventq_base/serialization_providers/json_serialization_provider.rb
 - lib/eventq/eventq_base/serialization_providers/oj_serialization_provider.rb
 - lib/eventq/eventq_base/signature_providers.rb
@@ -250,9 +236,7 @@ files:
 - lib/eventq/eventq_base/subscription_manager_contract.rb
 - lib/eventq/eventq_base/version.rb
 - lib/eventq/eventq_base/worker_id.rb
-- lib/eventq/eventq_rabbitmq/README.md
 - lib/eventq/eventq_rabbitmq/default_queue.rb
-- lib/eventq/eventq_rabbitmq/jruby/rabbitmq_queue_worker.rb
 - lib/eventq/eventq_rabbitmq/rabbitmq_eventq_client.rb
 - lib/eventq/eventq_rabbitmq/rabbitmq_queue_client.rb
 - lib/eventq/eventq_rabbitmq/rabbitmq_queue_manager.rb
@@ -285,5 +269,5 @@ rubyforge_project:
 rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
-summary: This is EventQ system
+summary: EventQ is a pub/sub system that uses async notifications and message queues
 test_files: []

data/lib/eventq/eventq_aws/README.md

@@ -1,53 +0,0 @@
-# EventQ [AWS]
-
-Welcome to EventQ. This gem contains the AWS implementations of the EventQ framework components.
-
-## Installation
-
-Add this line to your application:
-
-```ruby
-require 'eventq/aws'
-```
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-### Preparing the Docker images
-
-Run the setup script of eventq_aws to build the environment. This will create the `eventq/aws` image.
-
-    $ cd script
-    $ ./setup.sh
-
-### Running the tests
-
-By default, the full test suite will run against the mock AWS services defined in the docker-compose.yml file.
-
-If you want to run the tests with AWS directly, you will need an AWS account. Put your credentials into the `.aws.env` file in the parent directory.
-
-    $ cp ../.aws.env.template ../.aws.env
-    $ vi ../.aws.env
-
-Run the whole test suite:
-
-    $ cd script
-    $ ./test.sh
-
-You can run the specs that don't depend on an AWS account with:
-
-    $ cd script
-    $ ./test.sh --tag ~integration
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/sage/eventq. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/eventq/eventq_aws/jruby/aws_queue_worker.rb

@@ -1,370 +0,0 @@
-require 'java'
-java_import java.util.concurrent.Executors
-module EventQ
-  module Amazon
-    class QueueWorker
-      include EventQ::WorkerId
-
-      APPROXIMATE_RECEIVE_COUNT = 'ApproximateReceiveCount'.freeze
-      MESSAGE = 'Message'.freeze
-
-      attr_accessor :is_running
-
-      def initialize
-        @is_running = false
-
-        @on_retry_exceeded_block = nil
-        @on_retry_block = nil
-        @on_error_block = nil
-
-        @hash_helper = HashKit::Helper.new
-        @serialization_provider_manager = EventQ::SerializationProviders::Manager.new
-        @signature_provider_manager = EventQ::SignatureProviders::Manager.new
-
-        @last_gc_flush = Time.now
-        @gc_flush_interval = 10
-
-        @queue_poll_wait = 10
-      end
-
-      def start(queue, options = {}, &block)
-
-        EventQ.logger.info("[#{self.class}] - Preparing to start listening for messages.")
-
-        configure(queue, options)
-
-        if options[:client] == nil
-          raise "[#{self.class}] - :client (QueueClient) must be specified."
-        end
-
-        raise "[#{self.class}] - Worker is already running." if running?
-
-        client = options[:client]
-        EventQ.logger.debug do
-          "[#{self.class} #start] - Listening for messages on queue: #{queue.name}, Queue Url: #{client.sqs_helper.get_queue_url(queue)}, Queue arn: #{client.sqs_helper.get_queue_arn(queue)}"
-        end
-
-        EventQ.logger.info("[#{self.class}] - Listening for messages.")
-
-        start_process(options, queue, block)
-
-        return true
-      end
-
-      def start_process(options, queue, block)
-
-        %w'INT TERM'.each do |sig|
-          Signal.trap(sig) {
-            stop
-            exit
-          }
-        end
-
-        @is_running = true
-
-        @executor = java.util.concurrent.Executors::newFixedThreadPool @thread_count
-
-        #loop through each thread count
-        @thread_count.times do
-
-          @executor.execute do
-
-            client = options[:client]
-            manager = EventQ::Amazon::QueueManager.new({ client: client })
-
-            #begin the queue loop for this thread
-            while true do
-
-              #check if the worker is still allowed to run and break out of thread loop if not
-              unless running?
-                break
-              end
-
-              if @executor.is_shutdown
-                break
-              end
-
-              has_message_received = thread_process_iteration(client, manager, queue, block)
-
-              gc_flush
-
-              if !has_message_received
-                EventQ.logger.debug { "[#{self.class}] - No message received." }
-                if @sleep > 0
-                  EventQ.logger.debug { "[#{self.class}] - Sleeping for #{@sleep} seconds" }
-                  sleep(@sleep)
-                end
-              end
-
-            end
-
-          end
-
-        end
-
-        if options.key?(:wait) && options[:wait] == true
-          while running? do end
-        end
-
-      end
-
-      def gc_flush
-        if Time.now - last_gc_flush > @gc_flush_interval
-          GC.start
-          @last_gc_flush = Time.now
-        end
-      end
-
-      def last_gc_flush
-        @last_gc_flush
-      end
-
-      def thread_process_iteration(client, manager, queue, block)
-        #get the queue
-        q = manager.get_queue(queue)
-
-        received = false
-
-        begin
-
-          #request a message from the queue
-          response = client.sqs.receive_message({
-                                                    queue_url: q,
-                                                    max_number_of_messages: 1,
-                                                    wait_time_seconds: @queue_poll_wait,
-                                                    attribute_names: [APPROXIMATE_RECEIVE_COUNT]
-                                                })
-
-          #check that a message was received
-          if response.messages.length > 0
-            received = true
-            begin
-              tag_processing_thread
-              process_message(response, client, queue, q, block)
-            ensure
-              untag_processing_thread
-            end
-
-          end
-
-        rescue => e
-          EventQ.log(:error, "[#{self.class}] - An unhandled error occurred. Error: #{e} | Backtrace: #{e.backtrace}")
-          call_on_error_block(error: e)
-        end
-
-        return received
-      end
-
-      def call_on_error_block(error:, message: nil)
-        if @on_error_block
-          EventQ.logger.debug { "[#{self.class}] - Executing on_error block." }
-          begin
-            @on_error_block.call(error, message)
-          rescue => e
-            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_error block. Error: #{e}")
-          end
-        else
-          EventQ.logger.debug { "[#{self.class}] - No on_error block specified to execute." }
-        end
-      end
-
-      def call_on_retry_exceeded_block(message)
-        if @on_retry_exceeded_block != nil
-          EventQ.logger.debug { "[#{self.class}] - Executing on_retry_exceeded block." }
-          begin
-            @on_retry_exceeded_block.call(message)
-          rescue => e
-            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry_exceeded block. Error: #{e}")
-          end
-        else
-          EventQ.logger.debug { "[#{self.class}] - No on_retry_exceeded block specified." }
-        end
-      end
-
-      def call_on_retry_block(message)
-        if @on_retry_block
-          EventQ.logger.debug { "[#{self.class}] - Executing on_retry block." }
-          begin
-            @on_retry_block.call(message, abort)
-          rescue => e
-            EventQ.logger.error("[#{self.class}] - An error occurred executing the on_retry block. Error: #{e}")
-          end
-        else
-          EventQ.logger.debug { "[#{self.class}] - No on_retry block specified." }
-        end
-      end
-
-      def stop
-        EventQ.logger.info("[#{self.class}] - Stopping.")
-        @is_running = false
-        @executor.shutdown
-        return true
-      end
-
-      def on_retry_exceeded(&block)
-        @retry_exceeded_block = block
-      end
-
-      def on_retry(&block)
-        @on_retry_block = block
-        return nil
-      end
-
-      def on_error(&block)
-        @on_error_block = block
-        return nil
-      end
-
-      def running?
-        return @is_running
-      end
-
-      def deserialize_message(payload)
-        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
-        return provider.deserialize(payload)
-      end
-
-      def serialize_message(msg)
-        provider = @serialization_provider_manager.get_provider(EventQ::Configuration.serialization_provider)
-        return provider.serialize(msg)
-      end
-
-      private
-
-      def process_message(response, client, queue, q, block)
-        msg = response.messages[0]
-        retry_attempts = msg.attributes[APPROXIMATE_RECEIVE_COUNT].to_i - 1
-
-        #deserialize the message payload
-        payload = JSON.load(msg.body)
-        message = deserialize_message(payload[MESSAGE])
-
-        message_args = EventQ::MessageArgs.new(type: message.type,
-                                               retry_attempts: retry_attempts,
-                                               context: message.context,
-                                               content_type: message.content_type)
-
-        EventQ.logger.info("[#{self.class}] - Message received. Retry Attempts: #{retry_attempts}")
-
-        @signature_provider_manager.validate_signature(message: message, queue: queue)
-
-        if(!EventQ::NonceManager.is_allowed?(message.id))
-          EventQ.logger.info("[#{self.class}] - Duplicate Message received. Dropping message.")
-          client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
-          return false
-        end
-
-        #begin worker block for queue message
-        begin
-
-          block.call(message.content, message_args)
-
-          if message_args.abort == true
-            EventQ.logger.info("[#{self.class}] - Message aborted.")
-          else
-            #accept the message as processed
-            client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
-            EventQ.logger.info("[#{self.class}] - Message acknowledged.")
-          end
-
-        rescue => e
-          EventQ.logger.error("[#{self.class}] - An unhandled error happened while attempting to process a queue message. Error: #{e} | Backtrace: #{e.backtrace}")
-          error = true
-          call_on_error_block(error: e, message: message)
-        end
-
-        if message_args.abort || error
-          EventQ::NonceManager.failed(message.id)
-          reject_message(queue, client, msg, q, retry_attempts, message, message_args.abort)
-        else
-          EventQ::NonceManager.complete(message.id)
-        end
-
-        return true
-      end
-
-      def reject_message(queue, client, msg, q, retry_attempts, message, abort)
-
-        if !queue.allow_retry || retry_attempts >= queue.max_retry_attempts
-
-          EventQ.logger.info("[#{self.class}] - Message rejected removing from queue. Message: #{serialize_message(message)}")
-
-          #remove the message from the queue so that it does not get retried again
-          client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
-
-          if retry_attempts >= queue.max_retry_attempts
-
-            EventQ.logger.info("[#{self.class}] - Message retry attempt limit exceeded.")
-            call_on_retry_exceeded_block(message)
-
-          end
-
-        elsif queue.allow_retry
-
-          retry_attempts += 1
-
-          EventQ.logger.info("[#{self.class}] - Message rejected requesting retry. Attempts: #{retry_attempts}")
-
-          if queue.allow_retry_back_off == true
-            EventQ.logger.debug { "[#{self.class}] - Calculating message back off retry delay. Attempts: #{retry_attempts} * Delay: #{queue.retry_delay}" }
-            visibility_timeout = (queue.retry_delay * retry_attempts) / 1000
-            if visibility_timeout > (queue.max_retry_delay / 1000)
-              EventQ.logger.debug { "[#{self.class}] - Max message back off retry delay reached." }
-              visibility_timeout = queue.max_retry_delay / 1000
-            end
-          else
-            EventQ.logger.debug { "[#{self.class}] - Setting fixed retry delay for message." }
-            visibility_timeout = queue.retry_delay / 1000
-          end
-
-          if visibility_timeout > 43200
-            EventQ.logger.debug { "[#{self.class}] - AWS max visibility timeout of 12 hours has been exceeded. Setting message retry delay to 12 hours." }
-            visibility_timeout = 43200
-          end
-
-          EventQ.logger.debug { "[#{self.class}] - Sending message for retry. Message TTL: #{visibility_timeout}" }
-          client.sqs.change_message_visibility({
-                                               queue_url: q, # required
-                                               receipt_handle: msg.receipt_handle, # required
-                                               visibility_timeout: visibility_timeout.to_s, # required
-                                           })
-
-          call_on_retry_block(message)
-
-        end
-
-      end
-
-      def configure(queue, options = {})
-
-        @queue = queue
-
-        #default thread count
-        @thread_count = 5
-        if options.key?(:thread_count)
-          @thread_count = options[:thread_count]
-        end
-
-        #default sleep time in seconds
-        @sleep = 5
-        if options.key?(:sleep)
-          @sleep = options[:sleep]
-        end
-
-        if options.key?(:gc_flush_interval)
-          @gc_flush_interval = options[:gc_flush_interval]
-        end
-
-        if options.key?(:queue_poll_wait)
-          @queue_poll_wait = options[:queue_poll_wait]
-        end
-
-        EventQ.logger.info("[#{self.class}] - Configuring. Thread Count: #{@thread_count} | Interval Sleep: #{@sleep} | GC Flush Interval: #{@gc_flush_interval} | Queue Poll Wait: #{@queue_poll_wait}.")
-
-        return true
-
-      end
-
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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