eventq_aws 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72dc6e5eedbb1a486df5fb6ae630c9ada26a08b5
-  data.tar.gz: 953364700ea24b683038d3fbd4b2dd5dffbfa7bd
+  metadata.gz: ff66f7c228e5be1bb6fb93fa8fa38162b8d5948b
+  data.tar.gz: 3b40922adb6ef8bdec4721d0102dec780365be0c
 SHA512:
-  metadata.gz: 66b70231f26a2723ff5a37104991d90d562ae6c97e52619472e174aff95e49b53a5f3362bb97718668fc8e2c070746dde9a9426a1086fb784176dfeb87518814
-  data.tar.gz: 0633ab90abfc5d3accfd9803ce68967f10ce5de746ef29fa40b49335e7bd73805c7790c32d1e0f9707872f930e7138a0c512ad7e6b4caf3e9ffbd5633b6b3f0c
+  metadata.gz: 8db3e65bd7cc17343cf39f8dc5670380ff983b5a190e55bc2a369bf05a630934ca2ab5cb9de4728f53b749c2161be8949ab6ab9287261bb7c956efaf36072168
+  data.tar.gz: b6813c2a5a0eef2b01b234ffb670dc9f95e0216381b1bcdcec9a645aaa3a6088e9bf2afacfaff2e0829ad2c4d91de5f02e04ed367c47286bef2af62e51d43535

data/lib/eventq_aws/aws_eventq_client.rb

@@ -1,28 +1,37 @@
-require 'oj'
+module EventQ
+  module Amazon
+    class EventQClient
 
-class AwsEventQClient
-  def initialize
-    @client = AwsQueueClient.new
-  end
+      def initialize(options)
 
-  def raise(event_type, event)
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'
+        end
 
-    topic_arn = @client.get_topic_arn(event_type)
+        @client = options[:client]
 
-    qm = QueueMessage.new
-    qm.content = event
-    qm.type = event_type
+      end
 
-    message = Oj.dump(qm)
+      def raise_event(event_type, event)
 
-    response = @client.sns.publish({
-        topic_arn: topic_arn,
-        message: message,
-        subject: event_type
-                    })
+        topic_arn = @client.get_topic_arn(event_type)
 
-    return response.message_id
+        qm = EventQ::QueueMessage.new
+        qm.content = event
+        qm.type = event_type
 
-  end
+        message = Oj.dump(qm)
+
+        response = @client.sns.publish({
+                                           topic_arn: topic_arn,
+                                           message: message,
+                                           subject: event_type
+                                       })
 
-end
+        return response.message_id
+
+      end
+
+    end
+  end
+end

data/lib/eventq_aws/aws_queue_client.rb

@@ -1,28 +1,38 @@
-class AwsQueueClient
+module EventQ
+  module Amazon
+    class QueueClient
 
-  attr_reader :sns
-  attr_reader :sqs
+      attr_reader :sns
+      attr_reader :sqs
 
-  def initialize
+      def initialize(options = {})
 
-    Aws.config[:credentials] = Aws::Credentials.new(ENV['AWS_KEY'], ENV['AWS_SECRET'])
-    Aws.config[:region] = ENV['AWS_REGION'] || 'us-west-2'
+        if options.has_key?(:aws_key)
+          Aws.config[:credentials] = Aws::Credentials.new(options[:aws_key], options[:aws_secret])
+        end
 
-    @sns = Aws::SNS::Client.new
-    @sqs = Aws::SQS::Client.new
+        if !options.has_key?(:aws_account_number)
+          raise ':aws_account_number option must be specified.'
+        end
 
-    @aws_account = ENV['AWS_ACCOUNT_NUMBER']
-    @aws_region = ENV['AWS_REGION'] || 'us-west-2'
+        @aws_account = options[:aws_account_number]
+        @aws_region = options[:aws_region] || 'eu-west-1'
 
-  end
+        Aws.config[:region] = @aws_region
 
-  def get_topic_arn(event_type)
-    response = @sns.create_topic({ name: event_type })
-    return response.topic_arn
-  end
+        @sns = Aws::SNS::Client.new
+        @sqs = Aws::SQS::Client.new
 
-  def get_queue_arn(queue)
-    return "arn:aws:sqs:#{@aws_region}:#{@aws_account}:#{queue.name}"
-  end
+      end
 
-end
+      def get_topic_arn(event_type)
+        return "arn:aws:sns:#{@aws_region}:#{@aws_account}:#{event_type}"
+      end
+
+      def get_queue_arn(queue)
+        return "arn:aws:sqs:#{@aws_region}:#{@aws_account}:#{queue.name}"
+      end
+
+    end
+  end
+end

data/lib/eventq_aws/aws_queue_manager.rb

@@ -1,35 +1,48 @@
-class AwsQueueManager
+module EventQ
+  module Amazon
+    class QueueManager
 
-  @@dead_letter_queue = 'dead_letter_archive'
+      @@dead_letter_queue = 'dead_letter_archive'
 
-  def initialize
-    @client = AwsQueueClient.new
-  end
+      def initialize(options)
 
-  def get_queue(queue)
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'
+        end
 
-    response = @client.sqs.create_queue({
-        queue_name: queue.name,
-        attributes: {
-            'VisibilityTimeout' => (queue.retry_delay / 1000).to_s
-        }
-                         })
+        @client = options[:client]
+      end
 
-    return response.queue_url
+      def get_queue(queue)
 
-  end
+        response = @client.sqs.create_queue({
+                                                queue_name: queue.name,
+                                                attributes: {
+                                                    'VisibilityTimeout' => (queue.retry_delay / 1000).to_s
+                                                }
+                                            })
 
-  def drop_queue(queue)
+        return response.queue_url
 
-    q = get_queue(queue)
+      end
 
-    @client.sqs.delete_queue({ queue_url: q})
+      def drop_queue(queue)
 
-  end
+        q = get_queue(queue)
 
-  def drop_topic(event_type)
-    topic_arn = @client.get_topic_arn(event_type)
-    @client.sns.delete_topic({ topic_arn: topic_arn})
-  end
+        @client.sqs.delete_queue({ queue_url: q})
+
+        return true
 
-end
+      end
+
+      def drop_topic(event_type)
+        topic_arn = @client.get_topic_arn(event_type)
+        @client.sns.delete_topic({ topic_arn: topic_arn})
+
+        return true
+      end
+
+    end
+  end
+end

data/lib/eventq_aws/aws_queue_worker.rb

@@ -1,145 +1,175 @@
-class AwsQueueWorker
+module EventQ
+  module Amazon
+    class QueueWorker
 
-  attr_accessor :is_running
+      attr_accessor :is_running
 
-  def initialize
-    @threads = []
-    @is_running = false
+      def initialize
+        @threads = []
+        @is_running = false
 
-    @retry_exceeded_block = nil
-  end
+        @retry_exceeded_block = nil
+      end
 
-  def start(queue, options = {}, &block)
-    configure(queue, options)
+      def start(queue, options = {}, &block)
+        configure(queue, options)
 
-    puts '[QUEUE_WORKER] Listening for messages.'
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'
+        end
 
-    raise 'Worker is already running.' if running?
+        raise 'Worker is already running.' if running?
 
-    @is_running = true
-    @threads = []
+        puts '[QUEUE_WORKER] Listening for messages.'
 
-    #loop through each thread count
-    @thread_count.times do
-      thr = Thread.new do
+        @is_running = true
+        @threads = []
 
-        client = AwsQueueClient.new
-        manager = AwsQueueManager.new
+        #loop through each thread count
+        @thread_count.times do
+          thr = Thread.new do
 
-        #begin the queue loop for this thread
-        while true do
+            client = options[:client]
+            manager = EventQ::Amazon::QueueManager.new({ client: client })
 
-          #check if the worker is still allowed to run and break out of thread loop if not
-          if !@is_running
-            break
-          end
+            #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
+              if !@is_running
+                break
+              end
 
-          #get the queue
-          q = manager.get_queue(queue)
+              #get the queue
+              q = manager.get_queue(queue)
 
-          received = false
-          error = false
+              received = false
+              error = false
+              abort = false
 
-          begin
+              begin
 
-            #request a message from the queue
-            response = client.sqs.receive_message({
-                queue_url: q,
-                max_number_of_messages: 1,
-                wait_time_seconds: 1,
-                message_attribute_names: ['ApproximateReceiveCount']
-                                              })
+                #request a message from the queue
+                response = client.sqs.receive_message({
+                                                          queue_url: q,
+                                                          max_number_of_messages: 1,
+                                                          wait_time_seconds: 1,
+                                                          message_attribute_names: ['ApproximateReceiveCount']
+                                                      })
 
-            #check that a message was received
-            if response.messages.length > 0
+                #check that a message was received
+                if response.messages.length > 0
 
-              msg = response.messages[0]
-              retry_attempts = msg.message_attributes['ApproximateReceiveCount'].to_i
+                  msg = response.messages[0]
+                  retry_attempts = msg.message_attributes['ApproximateReceiveCount'].to_i
 
-              #deserialize the message payload
-              message = Oj.load(msg.body)
-              payload = Oj.load(message["Message"])
+                  #deserialize the message payload
+                  message = Oj.load(msg.body)
+                  payload = Oj.load(message["Message"])
 
-              puts "[QUEUE_WORKER] Message received. Retry Attempts: #{retry_attempts}"
+                  message_args = EventQ::MessageArgs.new(payload.type, retry_attempts)
+
+                  puts "[QUEUE_WORKER] Message received. Retry Attempts: #{retry_attempts}"
+
+                  #begin worker block for queue message
+                  begin
+
+                    block.call(payload.content, message_args)
+
+                    if message_args.abort == true
+                      abort = true
+                      puts '[QUEUE_WORKER] Message aborted.'
+                    else
+                      #accept the message as processed
+                      client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
+                      puts '[QUEUE_WORKER] Message acknowledged.'
+                      received = true
+                    end
+
+                  rescue => e
+                    puts '[QUEUE_WORKER] An unhandled error happened attempting to process a queue message.'
+                    puts "Error: #{e}"
+
+                    error = true
+
+                  end
+
+                  if abort || error
+                    puts '[QUEUE_WORKER] Message rejected.'
+                    reject_message(queue, client, msg, q, retry_attempts)
+                  end
 
-              #begin worker block for queue message
-              begin
-                block.call(payload.content, payload.type, retry_attempts)
-
-                #accept the message as processed
-                client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
-                puts '[QUEUE_WORKER] Message acknowledged.'
-                received = true
-              rescue => e
-                puts '[QUEUE_WORKER] An unhandled error happened attempting to process a queue message.'
-                puts "Error: #{e}"
-
-                error = true
-                puts '[QUEUE_WORKER] Message rejected.'
-
-                if !queue.allow_retry
-                  #remove the message from the queue so that it does not get retried
-                  client.sqs.delete_message({ queue_url: q, receipt_handle: msg.receipt_handle })
                 end
 
+              rescue
+                puts 'An error occured attempting to retrieve a message from the queue.'
+              end
+
+              #check if any message was received
+              if !received && !error
+                puts "[QUEUE_WORKER] No message received. Sleeping for #{@sleep} seconds"
+                #no message received so sleep before attempting to pop another message from the queue
+                sleep(@sleep)
               end
 
             end
 
-          rescue
-            puts 'An error occured attempting to retrieve a message from the queue.'
           end
+          @threads.push(thr)
 
-          #check if any message was received
-          if !received && !error
-            puts "[QUEUE_WORKER] No message received. Sleeping for #{@sleep} seconds"
-            #no message received so sleep before attempting to pop another message from the queue
-            sleep(@sleep)
-          end
+        end
 
+        if options.key?(:wait) && options[:wait] == true
+          @threads.each { |thr| thr.join }
         end
 
+        return true
       end
-      @threads.push(thr)
 
-    end
+      def stop
+        @is_running = false
+        @threads.each { |thr| thr.join }
+        return true
+      end
 
-    if options.key?(:wait) && options[:wait] == true
-      @threads.each { |thr| thr.join }
-    end
-  end
+      def on_retry_exceeded(&block)
+        @retry_exceeded_block = block
+      end
 
-  def stop
-    @is_running = false
-    @threads.each { |thr| thr.join }
-  end
+      def running?
+        return @is_running
+      end
 
-  def on_retry_exceeded(&block)
-    @retry_exceeded_block = block
-  end
+      private
 
-  def running?
-    @is_running
-  end
+      def reject_message(queue, client, msg, q, retry_attempts)
+        if !queue.allow_retry || retry_attempts >= queue.max_retry_attempts
+
+          #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 })
+        end
+      end
 
-  private
+      def configure(queue, options = {})
 
-  def configure(queue, options = {})
+        @queue = queue
 
-    @queue = queue
+        #default thread count
+        @thread_count = 5
+        if options.key?(:thread_count)
+          @thread_count = options[:thread_count]
+        end
 
-    #default thread count
-    @thread_count = 5
-    if options.key?(:thread_count)
-      @thread_count = options[:thread_count]
-    end
+        #default sleep time in seconds
+        @sleep = 15
+        if options.key?(:sleep)
+          @sleep = options[:sleep]
+        end
 
-    #default sleep time in seconds
-    @sleep = 15
-    if options.key?(:sleep)
-      @sleep = options[:sleep]
-    end
+        return true
 
-  end
+      end
 
-end
+    end
+  end
+end

data/lib/eventq_aws/aws_subscription_manager.rb

@@ -1,21 +1,33 @@
-class AwsSubscriptionManager
+module EventQ
+  module Amazon
+    class SubscriptionManager
 
-  def initialize
-    @client = AwsQueueClient.new
-    @manager = AwsQueueManager.new
-  end
+      def initialize(options)
+
+        if options[:client] == nil
+          raise ':client (QueueClient) must be specified.'
+        end
+
+        @client = options[:client]
+
+        if options[:queue_manager] == nil
+          raise ':queue_manager (QueueManager) must be specified.'
+        end
+
+        @manager = options[:queue_manager]
+      end
 
-  def subscribe(event_type, queue)
+      def subscribe(event_type, queue)
 
-    topic_arn = @client.get_topic_arn(event_type)
+        topic_arn = @client.get_topic_arn(event_type)
 
-    q = @manager.get_queue(queue)
-    queue_arn = @client.get_queue_arn(queue)
+        q = @manager.get_queue(queue)
+        queue_arn = @client.get_queue_arn(queue)
 
-    @client.sqs.set_queue_attributes({
-        queue_url: q,
-        attributes:{
-            'Policy' => '{
+        @client.sqs.set_queue_attributes({
+                                             queue_url: q,
+                                             attributes:{
+                                                 'Policy' => '{
   "Version": "2012-10-17",
   "Id": "SNStoSQS",
   "Statement": [
@@ -33,21 +45,25 @@ class AwsSubscriptionManager
     }
   ]
 }'
-        }
-                                     })
+                                             }
+                                         })
 
-    @client.sns.subscribe({
-        topic_arn: topic_arn,
-        protocol: 'sqs',
-        endpoint: queue_arn
-                      })
+        @client.sns.subscribe({
+                                  topic_arn: topic_arn,
+                                  protocol: 'sqs',
+                                  endpoint: queue_arn
+                              })
 
-  end
+        return true
 
-  def unsubscribe(queue)
+      end
 
-    raise 'Not implemented. Please unsubscribe the queue from the topic inside the AWS Management Console.'
+      def unsubscribe(queue)
 
-  end
+        raise 'Not implemented. Please unsubscribe the queue from the topic inside the AWS Management Console.'
 
-end
+      end
+
+    end
+  end
+end

data/lib/eventq_aws/version.rb

@@ -1,3 +1,5 @@
-module EventqAws
-  VERSION = "0.1.0"
+module EventQ
+  module Amazon
+    VERSION = "0.2.0"
+  end
 end

data/lib/eventq_aws.rb

@@ -1,6 +1,11 @@
-require "eventq_aws/version"
+require 'aws-sdk-core'
+require 'oj'
+require 'eventq_base'
+
+require 'eventq_aws/version'
 require 'eventq_aws/aws_eventq_client'
 require 'eventq_aws/aws_queue_client'
 require 'eventq_aws/aws_queue_manager'
 require 'eventq_aws/aws_queue_worker'
 require 'eventq_aws/aws_subscription_manager'
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventq_aws
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - vaughanbrittonsage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,16 +70,16 @@ dependencies:
   name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.15.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core
   requirement: !ruby/object:Gem::Requirement