herdst_worker 0.1.0

data/lib/herdst_worker/configuration/paths.rb

@@ -0,0 +1,41 @@
+module HerdstWorker
+    module Configuration
+        class Paths
+            
+            
+            attr_accessor :root_path, :paths
+            
+            
+            def initialize
+                self.root_path = ENV["ROOT_PATH"] || Dir.pwd
+                
+                self.paths = ActiveSupport::HashWithIndifferentAccess.new
+                self.paths[:root] = self.root_path
+                self.paths[:app] = "#{self.root_path}/app"
+                self.paths[:config] = "#{self.root_path}/config"
+                self.paths[:temp] = "#{self.root_path}/tmp"
+            end
+            
+            
+            def []=(name, value)
+                self.paths[name] = "#{self.root_path}/#{value}"
+            end
+            
+            
+            def [](name)
+                self.paths[name]
+            end
+            
+            
+            def method_missing(name)
+                if self.paths.include?(name)
+                    self.paths[name]
+                else
+                    raise NoMethodError
+                end                
+            end
+            
+                
+        end
+    end
+end

data/lib/herdst_worker/log/facade.rb

@@ -0,0 +1,87 @@
+require 'logger'
+
+
+module HerdstWorker
+    module Log
+        
+        
+        DEFAULT_PROGNAME = "application"
+        
+        
+        class Facade
+            
+            
+            attr_accessor :logger, :progname, :single_line, :level
+            
+            
+            def initialize(level = "DEBUG", progname = DEFAULT_PROGNAME, single_line = false)
+                self.progname = progname
+                self.single_line = single_line
+                
+                self.logger = Logger.new(STDOUT)
+                self.logger.progname = self.get_progname(progname)
+                self.set_log_level(level)
+            end
+            
+            
+            def set_log_level(level)
+                self.level = level
+                self.logger.level = Logger.const_get(level)
+            end
+            
+            
+            def debug(*attributes)
+                write_message :debug, attributes
+            end
+            
+            
+            def info(*attributes)
+                write_message :info, attributes
+            end
+            
+            
+            def warn(*attributes)
+                write_message :warn, attributes
+            end
+            
+            
+            def error(*attributes)
+                write_message :error, attributes
+            end
+            
+            
+            def fatal(*attributes)
+                write_message :fatal, attributes
+            end
+            
+            
+            def method_missing(name)
+                full_name = self.progname === DEFAULT_PROGNAME ? 
+                    name : 
+                    "#{self.progname}.#{name}"
+                
+                Facade.new(self.level, full_name, self.single_line)
+            end
+            
+            
+            def write_message(type, message)
+                if self.single_line
+                    full_message = message.map { |i| i.to_s }.join(" ")
+                else
+                    full_message = message.map { |i| i.to_s }.join("\n")
+                end
+                
+                self.logger.send(type, full_message)
+            end
+            
+            
+            protected
+                def get_progname(name)
+                    "[#{name.upcase}]"
+                end
+            
+            
+        end
+        
+    end
+end

data/lib/herdst_worker/queue/facade.rb

@@ -0,0 +1,162 @@
+require 'securerandom'
+require_relative 'processor'
+
+
+module HerdstWorker
+    module Queue
+        class Facade
+            
+            
+            attr_accessor :app, :processor
+            
+            
+            def initialize(app, enabled, url, queue_wait_time)
+                self.app = app
+                self.processor = HerdstWorker::Queue::Processor.new(app, enabled, url, queue_wait_time)
+            end
+            
+            
+            def get_status
+                self.processor.processor_status
+            end
+            
+            
+            def start
+                self.processor.start
+            end
+            
+            
+            def halt
+                self.processor.halt
+            end
+            
+            
+            def stop
+                self.processor.stop
+            end
+            
+            
+            def get_processor
+                self.processor
+            end
+            
+            
+            def send_message(type, company_id, user_id, data = {}, queue = :primary, attributes = nil, delay = nil)
+                client = get_queue_client(queue)
+                message = create_queue_message(type, company_id, user_id, data, attributes, delay)
+                message.delete(:id)
+                
+                client.send_message(message)
+            end
+            
+            
+            def send_messages(messages = [], queue = :primary)
+                client = get_queue_client(queue)
+                
+                messages.each_slice(10) do |messages_group|
+                    client.send_messages({ :entries => messages_group })
+                end
+            end
+            
+            
+            def send_email_message(template, company, data = {}, attributes = nil, delay = nil)
+                client = get_queue_client(:notifications)
+                
+                message = create_email_queue_message(template, company, data, attributes, delay)
+                message.delete(:id)
+                
+                client.send_message(message)
+            end
+            
+            
+            def create_queue_message(type, company_id, user_id, data, attributes = nil, delay = nil)
+                message = Hash.new
+                message[:id] = SecureRandom.hex(32)
+                message[:message_body] = Hash.new
+                message[:message_body][:eventVersion] = 1.0
+                message[:message_body][:eventSource] = "application:Que"
+                message[:message_body][:eventTime] = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ")
+                message[:message_body][:eventName] = type.to_s.camelize(:lower)
+                message[:message_body][:userIdentity] = { :principalId => user_id, :companyId => company_id }
+                message[:message_body][:Que] = data
+                message[:message_body][:Que][:configurationId] = message[:message_body][:eventName]
+            
+                message[:message_body] = { :Records => [message[:message_body]] }.to_json
+                message[:message_attributes] = attributes if attributes
+                message[:delay_seconds] = delay if delay
+                message
+            end
+            
+            
+            def create_email_queue_message(template, company, message_data, attributes = nil, delay = 2)
+                # Convert instances of ApplicationRecord to attributes instead of json representation
+                message_data.each do |key, value|
+                    message_data[key] = value.attributes if value.is_a?(ActiveRecord::Base)
+                end
+                
+                # Build data
+                data = Hash.new
+                data[:app] = self.app.name
+                data[:app_id] = company.id
+                data[:app_name] = company.name
+                data[:app_slug] = company.get_host_name
+                data[:app_brand_id] = company.brand_id
+                data[:app_host] = company.get_url
+                data[:type] = "email"
+                data[:template] = template
+                data[:data] = message_data
+                
+                # Add message structure
+                message = Hash.new
+                message[:id] = SecureRandom.hex(32)
+                message[:message_body] = data.to_json
+                message[:message_attributes] = attributes if attributes
+                message[:delay_seconds] = delay
+                message
+            end
+            
+            
+            def create_notification_message(message_data, attributes = nil, expiry = nil, delay = nil)
+                message = Hash.new
+                message[:id] = SecureRandom.hex(32)
+                message[:message_body] = Hash.new
+                message[:message_body][:Type] = "Notification"
+                message[:message_body][:Message] = message_data.to_json
+                message[:message_body] = message[:message_body].to_json
+                message[:message_attributes] = attributes ? attributes : Hash.new
+                message[:message_attributes]["expiry"] = { :string_value => expiry.to_s, :data_type => "Number" } if expiry
+                message[:delay_seconds] = delay if delay
+                
+                message.delete(:message_attributes) if message[:message_attributes].size == 0
+                
+                message
+            end
+            
+            
+            def get_queue_client(queue_name)
+                queue_url = self.app.queues[queue_name]
+                sqs_client = Aws::SQS::Client.new(
+                    :credentials => self.app.config.metadata.get_aws_credentials
+                )
+                
+                Aws::SQS::Queue.new(
+                    :url => queue_url,
+                    :client => sqs_client
+                )
+            end
+            
+            
+            def self.get_delay(index)
+                messages_per_second = 10
+                send_time_per_message = 0.4
+                
+                offset = (index / messages_per_second)
+                delay = (offset * (messages_per_second * send_time_per_message)).to_i
+                
+                delay > 900 ? 900 : delay
+            end
+
+            
+        end
+    end
+end

data/lib/herdst_worker/queue/processor.rb

@@ -0,0 +1,223 @@
+require 'aws-sdk-sqs'
+
+require_relative 'runner'
+
+
+module HerdstWorker
+    module Queue
+        class Processor < Runner
+            
+            
+            attr_accessor :app, :enabled, :queue_url, :queue_wait_time, :poller
+            attr_accessor :start_time, :restart_time
+            attr_accessor :processor_status, :job_count, :max_jobs
+            attr_accessor :attempt_threshold, :visibility_timeout, :ignored_notifications
+            
+            
+            def initialize(app, enabled, queue_url, queue_wait_time)
+                self.app = app
+                self.enabled = enabled
+                self.queue_url = queue_url
+                self.queue_wait_time = queue_wait_time
+                self.poller = Aws::SQS::QueuePoller.new(queue_url)
+                self.job_count = 0
+                self.max_jobs = 10
+                self.attempt_threshold = 6
+                self.visibility_timeout = 15
+                self.ignored_notifications = [
+                    "AmazonSnsSubscriptionSucceeded"
+                ]
+                
+                # Set the start time 
+                self.reset_time
+                
+                # Start the processor as working
+                self.set_status "starting"
+
+                # Log queue stats
+                self.poller.before_request do |stats|
+                    before_request(stats)
+                end
+            end
+            
+            
+            # Runs the poller
+            def start_poller
+                if self.enabled
+                    self.poller.poll(:wait_time_seconds => self.queue_wait_time, :skip_delete => false) do |msg|
+                        process_message(msg)
+                    end
+                end
+            end
+            
+            
+            # Starts or resets the application to a working status 
+            def start
+                if self.processor_status == "starting"
+                    self.set_status "working"
+                    self.reset_time
+                    self.start_poller
+                else
+                    return if self.processor_status == "working"
+                    
+                    self.set_status "working"
+                    self.reset_time
+                end
+            end
+            
+            
+            # Sets the processor status to finishing. The sqs before action will 
+            # take care of setting the idle state once all jobs have finished.
+            def halt
+                return if self.processor_status === "finishing"
+                set_status "finishing"
+            end
+            
+            
+            # Sets the processor status to stopping. The sqs before action will 
+            # take care of stopping the application once all jobs have finished.
+            def stop
+                return if self.processor_status == "stopping"
+                set_status "stopping"
+            end
+            
+            
+            # Set the processor status. The status is alos logged to file so services 
+            # like capastranio can see the current status
+            def set_status(status)
+                statuses = ["starting", "idle", "working", "finishing", "stopping", "stopped"]
+                
+                if statuses.include? status
+                    # Set status
+                    self.processor_status = status
+                    
+                    # Write the current status to file for capastranio to use
+                    process_file = self.app.config.paths.temp + "/process_status"
+                    File.open(process_file, "w") { |file| file.write(status) }
+                else
+                    raise "Invalid status (#{status})"
+                end
+            end
+            
+            
+            def before_request(stats)
+                if self.app.config.is_dev?
+                    self.app.logger.queue_stats.info "STATS (#{self.processor_status}): #{stats.inspect}"
+                end
+                
+                # After 1 hour of running terminate application. 
+                # The app will automatically restart in production
+                current_time = Time.now.utc.to_i
+                if (self.processor_status == "working") && (current_time >= self.restart_time)
+                    runtime = current_time - self.start_time
+                    self.app.logger.queue.info "Stopping after #{runtime} seconds of work"
+                    set_status "stopping"
+                
+                # On finishing wait for jobs to complete and then set status
+                # to idle
+                elsif self.processor_status == "finishing"
+                    if self.job_count == 0
+                        self.app.logger.queue.info "Setting processor status to idle"
+                        set_status "idle"
+                    end
+                
+                # On stopping wait for jobs to complete and then set status
+                # to stopped. Once stopped the polling will terminate.
+                elsif self.processor_status == "stopping"
+                    if self.job_count == 0
+                        self.app.logger.queue.info "Setting processor status to stopped"
+                        set_status "stopped"
+                    end
+                
+                end
+                
+                if self.processor_status == "stopped"
+                    self.app.logger.queue.info "Exiting program, Service requested to stop"
+                    throw :stop_polling
+                end
+            end
+            
+            
+            def process_message(msg)
+                if self.processor_status == "working"
+                    # If the app is already processing the max number of jobs 
+                    # put the message back in the queue with a short wait time
+                    if self.job_count >= self.max_jobs
+                        self.poller.change_message_visibility_timeout(msg, self.visibility_timeout)
+                        throw :skip_delete
+                    end
+                    
+                    # Find out how many attempts there has been already for 
+                    # the message.
+                    msg_attrs = msg.message_attributes.dup
+                    attempt_number = msg_attrs.include?("attempts") ? msg_attrs["attempts"]["string_value"].to_i + 1 : 1
+                    will_fail_permanently = attempt_number > self.attempt_threshold
+                    
+                    # Run the job and increase the job count
+                    # Once successful the job count is decreased by one
+                    # and the message is deleted.
+                    # If an error occured the job count is decreased by 
+                    # one and the error is logged locally and with sentry
+                    self.job_count += 1
+                    message = JSON.parse(msg.body)
+                    process_message!(message, msg, will_fail_permanently).then {
+                        self.job_count -= 1
+                        
+                    }.rescue { |ex|
+                        if will_fail_permanently
+                            self.app.logger.queue.error "Message failed #{attempt_number} times, Reporting and failing permanently. \n#{ex.to_s} \n#{ex.backtrace.join("\n")}"
+                            Raven.capture_exception(ex, {
+                                :level => "fatal",
+                                :extra => {
+                                    "queue_attempts" => attempt_number,
+                                    "queue_message_body" => msg.body
+                                }
+                            })
+
+                        else
+                            self.app.logger.queue.error "Message failed #{attempt_number} times, Adding back to queue."
+                            
+                            if self.app.config.is_dev?
+                                puts ex.inspect
+                                puts ex.backtrace
+                            end
+                            
+                            replaced_message = {
+                                :queue_url => self.poller.queue_url,
+                                :message_body => msg.body,
+                                :delay_seconds => self.visibility_timeout,
+                                :message_attributes => msg_attrs.merge({
+                                    "attempts" => {
+                                        :string_value => attempt_number.to_s,
+                                        :data_type => "Number"
+                                    }
+                                })
+                            }
+                            
+                            self.poller.client.send_message replaced_message
+                        end
+                        
+                        if self.app.config.is_dev?
+                            self.app.logger.queue.error "Processor Error:"
+                            self.app.logger.queue.error ex.message
+                            self.app.logger.queue.error ex.backtrace
+                        end
+                        
+                        self.job_count -= 1
+                    }.execute
+                else
+                    self.poller.change_message_visibility_timeout(msg, self.visibility_timeout * 2)
+                    throw :skip_delete
+                end
+            end
+            
+            
+            private
+                def reset_time
+                    self.start_time = Time.now.utc.to_i
+                    self.restart_time = self.start_time + (3600)  # One hour
+                end
+            
+        end
+    end
+end