herdst_worker 0.1.5 → 0.1.8

data/lib/herdst_worker/queue/runner.rb

@@ -1,137 +1,137 @@
-require 'concurrent'
-
-
-module HerdstWorker
-    module Queue
-        class Runner
-            
-            
-            def process_message!(message, raw_message = nil, will_fail_permanently = false)
-                sent_timestamp = raw_message.attributes.include?("SentTimestamp") ? 
-                    raw_message.attributes["SentTimestamp"].to_i : 
-                    nil
-                trigger_timestamp = raw_message.message_attributes.include?("triggerTimestamp") ? 
-                    raw_message.message_attributes["triggerTimestamp"]["string_value"].to_i : 
-                    nil
-                expiry = raw_message.message_attributes.include?("expiry") ? 
-                    raw_message.message_attributes["expiry"]["string_value"].to_i : 
-                    nil
-                
-                if expiry && (expiry > 0) && ((Time.now.utc.to_i * 1000) > expiry)
-                    self.app.logger.queue.info "Job has expired, not running. #{message.inspect}"
-                    
-                    return Concurrent::Promise.new {}
-                end
-                
-                if message["Type"] != nil and message["Type"] == "Notification"
-                    if message["Message"].is_a? String
-                        message["Message"] = JSON.parse(message["Message"])
-                    end
-                    
-                    # Get the type
-                    if (message.include? "Subject") && (message["Subject"].include? "Elastic Transcoder")
-                        type = "Transcoder"
-                    else
-                        type = message["Message"]["notificationType"]
-                    end
-                    
-                    # Update the message with sent and triggered timestamp
-                    message["Message"]["sentTimestamp"] = sent_timestamp
-                    message["Message"]["triggerTimestamp"] = trigger_timestamp || sent_timestamp
-                    
-                    # Update the message with configuration Id
-                    message["Message"]["configurationId"] = "notification#{type}"
-                    
-                    # Since zips take a log time to process we might need to use:
-                    # poller.change_message_visibility_timeout(msg, 60)
-                    # To make sure other workers don't pick up the job
-                    return Concurrent::Promise.new {
-                        if !self.ignored_notifications.include? type
-                            execute_message!(nil, nil, message["Message"])
-                        end
-                    }
-                end
-                
-                if message["Records"].is_a? Array
-                    execution_promise = nil
-                    execution_data = []
-                    
-                    message["Records"].each do |record|
-                        data_source = record["eventSource"].split(":")
-                        data_origin = data_source.first
-                        data_operation = data_source.last
-                        record_data = record[data_operation]                        
-                        company_id = nil
-                        user_id = nil
-                        
-                        # Update the message with sent and triggered timestamp
-                        record_data["sentTimestamp"] = sent_timestamp
-                        record_data["triggerTimestamp"] = trigger_timestamp || sent_timestamp
-                        
-                        execution_data << record_data
-                        
-                        if data_origin === "application" and record.include? "userIdentity"
-                            company_id = record["userIdentity"]["companyId"]
-                            user_id = record["userIdentity"]["principalId"]
-                        end
-                        
-                        if execution_promise == nil
-                            execution_promise = Concurrent::Promise.new {
-                                execute_message!(company_id, user_id, record_data)
-                            }
-                        else
-                            execution_promise = execution_promise.then {
-                                execute_message!(company_id, user_id, record_data)
-                            }
-                        end
-                    end
-                    
-                    return Concurrent::Promise.new {} if execution_promise == nil
-                    return execution_promise.rescue { |ex|
-                        execution_data.each do |data|
-                            fail_action_permanently(data) if will_fail_permanently
-                        end
-                        
-                        raise ex
-                    }
-                end
-                
-                return Concurrent::Promise.new {}
-            end
-            
-            
-            def execute_message!(company_id, user_id, data)
-                action = data["configurationId"]
-                action_name = action.camelize
-                
-                unless self.app.config.actions["enabled"].include?(action_name)
-                    message = "Invalid action. #{action} is not an enabled action. Please add this action to the config file."
-                    
-                    if self.app.config.is_dev?
-                        raise message
-                    else
-                        Raven.capture_message(message)
-                        return
-                    end
-                end
-                
-                action_name.constantize.send(:invoke, company_id, user_id, data)
-            end
-            
-            
-            protected
-                def fail_action_permanently(data)
-                    if data.include? "action_id"
-                        # action = Action.get(data["action_id"])
-                        # 
-                        # if action
-                        #     action.update_data({ :stats => nil, :errors => nil }, :errored)
-                        #     action.cleanup
-                        # end
-                    end
-                end
-                
-            
-        end
-    end
-end
+require 'concurrent'
+
+
+module HerdstWorker
+    module Queue
+        class Runner
+            
+            
+            def process_message!(message, raw_message = nil, will_fail_permanently = false)
+                sent_timestamp = raw_message.attributes.include?("SentTimestamp") ? 
+                    raw_message.attributes["SentTimestamp"].to_i : 
+                    nil
+                trigger_timestamp = raw_message.message_attributes.include?("triggerTimestamp") ? 
+                    raw_message.message_attributes["triggerTimestamp"]["string_value"].to_i : 
+                    nil
+                expiry = raw_message.message_attributes.include?("expiry") ? 
+                    raw_message.message_attributes["expiry"]["string_value"].to_i : 
+                    nil
+                
+                if expiry && (expiry > 0) && ((Time.now.utc.to_i * 1000) > expiry)
+                    self.app.logger.queue.info "Job has expired, not running. #{message.inspect}"
+                    
+                    return Concurrent::Promise.new {}
+                end
+                
+                if message["Type"] != nil and message["Type"] == "Notification"
+                    if message["Message"].is_a? String
+                        message["Message"] = JSON.parse(message["Message"])
+                    end
+                    
+                    # Get the type
+                    if (message.include? "Subject") && (message["Subject"].include? "Elastic Transcoder")
+                        type = "Transcoder"
+                    else
+                        type = message["Message"]["notificationType"]
+                    end
+                    
+                    # Update the message with sent and triggered timestamp
+                    message["Message"]["sentTimestamp"] = sent_timestamp
+                    message["Message"]["triggerTimestamp"] = trigger_timestamp || sent_timestamp
+                    
+                    # Update the message with configuration Id
+                    message["Message"]["configurationId"] = "notification#{type}"
+                    
+                    # Since zips take a log time to process we might need to use:
+                    # poller.change_message_visibility_timeout(msg, 60)
+                    # To make sure other workers don't pick up the job
+                    return Concurrent::Promise.new {
+                        if !self.ignored_notifications.include? type
+                            execute_message!(nil, nil, message["Message"])
+                        end
+                    }
+                end
+                
+                if message["Records"].is_a? Array
+                    execution_promise = nil
+                    execution_data = []
+                    
+                    message["Records"].each do |record|
+                        data_source = record["eventSource"].split(":")
+                        data_origin = data_source.first
+                        data_operation = data_source.last
+                        record_data = record[data_operation]                        
+                        company_id = nil
+                        user_id = nil
+                        
+                        # Update the message with sent and triggered timestamp
+                        record_data["sentTimestamp"] = sent_timestamp
+                        record_data["triggerTimestamp"] = trigger_timestamp || sent_timestamp
+                        
+                        execution_data << record_data
+                        
+                        if data_origin === "application" and record.include? "userIdentity"
+                            company_id = record["userIdentity"]["companyId"]
+                            user_id = record["userIdentity"]["principalId"]
+                        end
+                        
+                        if execution_promise == nil
+                            execution_promise = Concurrent::Promise.new {
+                                execute_message!(company_id, user_id, record_data)
+                            }
+                        else
+                            execution_promise = execution_promise.then {
+                                execute_message!(company_id, user_id, record_data)
+                            }
+                        end
+                    end
+                    
+                    return Concurrent::Promise.new {} if execution_promise == nil
+                    return execution_promise.rescue { |ex|
+                        execution_data.each do |data|
+                            fail_action_permanently(data) if will_fail_permanently
+                        end
+                        
+                        raise ex
+                    }
+                end
+                
+                return Concurrent::Promise.new {}
+            end
+            
+            
+            def execute_message!(company_id, user_id, data)
+                action = data["configurationId"]
+                action_name = action.camelize
+                
+                unless self.app.config.actions["enabled"].include?(action_name)
+                    message = "Invalid action. #{action} is not an enabled action. Please add this action to the config file."
+                    
+                    if self.app.config.is_dev?
+                        raise message
+                    else
+                        Raven.capture_message(message)
+                        return
+                    end
+                end
+                
+                action_name.constantize.send(:invoke, company_id, user_id, data)
+            end
+            
+            
+            protected
+                def fail_action_permanently(data)
+                    if data.include? "action_id"
+                        # action = Action.get(data["action_id"])
+                        # 
+                        # if action
+                        #     action.update_data({ :stats => nil, :errors => nil }, :errored)
+                        #     action.cleanup
+                        # end
+                    end
+                end
+                
+            
+        end
+    end
+end

data/lib/herdst_worker/signals/facade.rb

@@ -1,35 +1,35 @@
-module HerdstWorker
-    module Signals
-        class Facade
-            
-            def self.listen(process_path)
-                write_process_file(process_path)
-                
-                # Start
-                Signal.trap "USR1" do |x|
-                    HerdstWorker::Queue::Facade.start
-                end
-                
-                # Halt
-                Signal.trap "USR2" do |x|
-                    HerdstWorker::Queue::Facade.halt
-                end
-                
-                # Stop (abort)
-                Signal.trap "ABRT" do |x|
-                    HerdstWorker::Queue::Facade.stop
-                end
-            end
-            
-            private
-                def self.write_process_file(process_path)
-                    # Write process id to file so we can signal the current process
-                    process_id = "#{$$}"
-                    process_file = process_path + "/process_id"
-                    
-                    File.open(process_file, "w") { |file| file.write(process_id) }
-                end
-            
-        end
-    end
-end
+module HerdstWorker
+    module Signals
+        class Facade
+            
+            def self.listen(process_path)
+                write_process_file(process_path)
+                
+                # Start
+                Signal.trap "USR1" do |x|
+                    HerdstWorker::Queue::Facade.start
+                end
+                
+                # Halt
+                Signal.trap "USR2" do |x|
+                    HerdstWorker::Queue::Facade.halt
+                end
+                
+                # Stop (abort)
+                Signal.trap "ABRT" do |x|
+                    HerdstWorker::Queue::Facade.stop
+                end
+            end
+            
+            private
+                def self.write_process_file(process_path)
+                    # Write process id to file so we can signal the current process
+                    process_id = "#{$$}"
+                    process_file = process_path + "/process_id"
+                    
+                    File.open(process_file, "w") { |file| file.write(process_id) }
+                end
+            
+        end
+    end
+end

data/lib/herdst_worker/version.rb

@@ -1,3 +1,3 @@
 module HerdstWorker
-  VERSION = '0.1.5'
+  VERSION = '0.1.8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: herdst_worker
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.8
 platform: ruby
 authors:
 - Herd.St
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-05 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -225,11 +225,13 @@ email:
 - devops@herd.st
 executables:
 - herdst_worker
+- herdst_worker_console
 extensions: []
 extra_rdoc_files: []
 files:
 - Rakefile
 - bin/herdst_worker
+- bin/herdst_worker_console
 - lib/herdst_worker.rb
 - lib/herdst_worker/adapters/database.rb
 - lib/herdst_worker/adapters/facade.rb
@@ -250,7 +252,7 @@ licenses:
 - Nonstandard
 metadata:
   allowed_push_host: https://rubygems.org/
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -265,8 +267,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Run background work triggered by aws sqs
 test_files: []