sidekiq integration

Author: maboukerfa

lib/ontologies_linked_data.rb

@@ -40,7 +40,8 @@
 # Require base model
 require 'ontologies_linked_data/models/base'
 
-
+# Require base job
+require 'ontologies_linked_data/jobs/base'
 
 
 # Require all models and services
@@ -67,6 +68,11 @@
   require m
 end
 
+# We need to require deterministic - that is why we have the sort.
+jobs = Dir.glob("#{project_root}/ontologies_linked_data/jobs/**/*.rb").sort
+jobs.each do |job|
+  require job
+end
 
 
 module LinkedData

lib/ontologies_linked_data/jobs/base.rb

@@ -0,0 +1,22 @@
+require 'sidekiq'
+module LinkedData 
+  module Jobs
+    class Base
+      include Sidekiq::Job
+      sidekiq_options queue: 'default'
+    
+      # Base class for non-retryable errors
+      class HandledException < StandardError; end
+      class NonRetryableError < HandledException; end
+      
+      sidekiq_retry_in do |count, exception|
+        case exception
+        when NonRetryableError
+          :kill
+        else
+          nil
+        end
+      end
+    end
+  end
+end

lib/ontologies_linked_data/jobs/batch_index_job.rb

@@ -0,0 +1,53 @@
+require 'ontologies_linked_data/config/config'
+
+module LinkedData
+  module Jobs
+    class BatchIndexJob < LinkedData::Jobs::Base
+
+      class ModelNotFoundError < NonRetryableError; end
+      class ModelNotIndexableError < NonRetryableError; end
+
+      def perform(model_name)
+        raise InvalidParameterError, 'model_name parameter is required' if model_name.blank?
+
+        model = Goo.model_by_name(model_name.to_sym)
+        raise ModelNotIndexableError, "#{model_name} is not indexable" if model.nil? || !model.index_enabled?
+
+        batch_index(model)
+      end
+
+      private
+      def batch_index(model)
+        all_attrs = get_attributes_to_include([:all], model)
+        collections = model.where.include(all_attrs).all
+
+        indexed = []
+        not_indexed = []
+        collections.each do |m|
+          begin
+            response = m.index.dig('responseHeader', 'status')
+            if response.eql?(0)
+              indexed << m.id
+            else
+              not_indexed << m.id
+              logger.error "Failed to index: #{m.id} - status: #{response}"
+            end
+          rescue StandardError => e
+            not_indexed << m.id
+            logger.error "Error indexing #{m.id}: #{e.message}"
+            raise e
+          end
+          if (indexed.size % 100).zero?
+            logger.info "Successfully indexed #{indexed.size} out of #{collections.size} for the model: #{model}"
+          end
+        end
+      end
+
+      def get_attributes_to_include(includes_param, klass)
+        ld = klass.goo_attrs_to_load(includes_param)
+        ld.delete(:properties)
+        ld
+      end
+    end
+  end
+end

lib/ontologies_linked_data/jobs/email_notification_job.rb

@@ -0,0 +1,56 @@
+module LinkedData
+  module Jobs
+    class EmailNotificationJob < LinkedData::Jobs::Base
+      sidekiq_options queue: 'mailers'
+    
+      def perform(options = {})
+        return unless LinkedData.settings.enable_notifications
+    
+        headers = { 'Content-Type' => 'text/html' }
+        sender = options['sender'] || LinkedData.settings.email_sender
+        recipients = Array(options['recipients']).uniq
+        raise ArgumentError, 'Recipient needs to be provided in options[:recipients]' if !recipients || recipients.empty?
+    
+        # By default we override all recipients to avoid
+        # sending emails from testing environments.
+        # Set `email_disable_override` in production
+        # to send to the actual user.
+        unless LinkedData.settings.email_disable_override
+          headers['Overridden-Sender'] = recipients
+          recipients = LinkedData.settings.email_override
+        end
+      
+        Pony.mail({
+                    to: recipients,
+                    from: sender,
+                    subject: options['subject'],
+                    body: options['body'],
+                    headers: headers,
+                    via: :smtp,
+                    enable_starttls_auto: LinkedData.settings.enable_starttls_auto,
+                    via_options: mail_options
+                  })
+      end
+    
+      private
+    
+      def mail_options
+        options = {
+          address: LinkedData.settings.smtp_host,
+          port: LinkedData.settings.smtp_port,
+          domain: LinkedData.settings.smtp_domain # the HELO domain provided by the client to the server
+        }
+      
+        if LinkedData.settings.smtp_auth_type && LinkedData.settings.smtp_auth_type != :none
+          options.merge!({
+                           user_name: LinkedData.settings.smtp_user,
+                           password: LinkedData.settings.smtp_password,
+                           authentication: LinkedData.settings.smtp_auth_type
+                         })
+        end
+      
+        options
+      end
+    end
+  end
+end

lib/ontologies_linked_data/utils/notifier.rb

@@ -4,30 +4,15 @@ class Notifier
       def self.notify(options = {})
         return unless LinkedData.settings.enable_notifications
 
-        headers = { 'Content-Type' => 'text/html' }
-        sender = options[:sender] || LinkedData.settings.email_sender
-        recipients = Array(options[:recipients]).uniq
-        raise ArgumentError, 'Recipient needs to be provided in options[:recipients]' if !recipients || recipients.empty?
-
-        # By default we override all recipients to avoid
-        # sending emails from testing environments.
-        # Set `email_disable_override` in production
-        # to send to the actual user.
-        unless LinkedData.settings.email_disable_override
-          headers['Overridden-Sender'] = recipients
-          recipients = LinkedData.settings.email_override
-        end
+        email_options = {
+          'sender' => options[:sender],
+          'recipients' => options[:recipients],
+          'subject' => options[:subject],
+          'body' => options[:body]
+        }
 
-        Pony.mail({
-                    to: recipients,
-                    from: sender,
-                    subject: options[:subject],
-                    body: options[:body],
-                    headers: headers,
-                    via: :smtp,
-                    enable_starttls_auto: LinkedData.settings.enable_starttls_auto,
-                    via_options: mail_options
-                  })
+        # Queue the email job
+        LinkedData::Jobs::EmailNotificationJob.perform_async(email_options)
       end
 
       def self.notify_support_grouped(subject, body)