naf 2.0.4 → 2.1.0

data/app/models/logical/naf/construction_zone/boss.rb

@@ -80,12 +80,11 @@ module Logical::Naf::ConstructionZone
     def enqueue_n_commands_on_machines(parameters, number_of_jobs = :from_limit, machines = [])
       logger.detail "enqueuing #{parameters[:command]} #{number_of_jobs} time(s) on #{machines.length} machine(s)"
       machines.each do |machine|
-        number_of_jobs = (parameters[:application_run_group_limit] || 1) if number_of_jobs == :from_limit
+        number_of_jobs = (parameters[:application_run_group_quantum] || 1) if number_of_jobs == :from_limit
         logger.info "enqueuing #{parameters[:command]} #{number_of_jobs} time(s) on #{machine}"
         (1..number_of_jobs).each do
           machine_parameters = {
-            :application_run_group_limit => number_of_jobs,
-            :application_run_group_restriction => ::Naf::ApplicationRunGroupRestriction.limited_per_machine
+            application_run_group_restriction: ::Naf::ApplicationRunGroupRestriction.limited_per_machine
           }.merge(parameters)
           machine_parameters[:affinities] =
             [machine.affinity] + if machine_parameters[:affinities].nil?
@@ -102,10 +101,10 @@ module Logical::Naf::ConstructionZone
     end
 
     def enqueue_n_commands(parameters, number_of_jobs = :from_limit)
-      number_of_jobs = (parameters[:application_run_group_limit] || 1) if number_of_jobs == :from_limit
+      number_of_jobs = (parameters[:application_run_group_quantum] || 1) if number_of_jobs == :from_limit
       logger.info "enqueuing #{parameters[:command]} #{number_of_jobs} time(s) on #{machine}"
       (1..number_of_jobs).each do
-        work_order = AdHocWorkOrder.new({:application_run_group_limit => number_of_jobs}.merge(parameters))
+        work_order = AdHocWorkOrder.new(parameters)
         @foreman.enqueue(work_order)
       end
     end

data/app/models/logical/naf/construction_zone/foreman.rb

@@ -11,7 +11,8 @@ module Logical::Naf::ConstructionZone
       unless work_order.enqueue_backlogs
         if limited_by_run_group?(work_order.application_run_group_restriction,
                                  work_order.application_run_group_name,
-                                 work_order.application_run_group_limit)
+                                 work_order.application_run_group_limit,
+                                 work_order.historical_job_affinity_tab_parameters)
           logger.warn "work order limited by run queue limits #{work_order.inspect}"
           return nil
         end
@@ -21,26 +22,46 @@ module Logical::Naf::ConstructionZone
                               work_order.historical_job_prerequisite_historical_jobs)
     end
 
-    def limited_by_run_group?(application_run_group_restriction, application_run_group_name, application_run_group_limit)
+    def limited_by_run_group?(application_run_group_restriction, application_run_group_name, application_run_group_limit, affinities)
       if (application_run_group_restriction.id == ::Naf::ApplicationRunGroupRestriction.no_limit.id ||
           application_run_group_limit.nil? ||
           application_run_group_name.nil?)
         false
       elsif application_run_group_restriction.id == ::Naf::ApplicationRunGroupRestriction.limited_per_machine.id
-        # XXX this is difficult to figure out, so we punt for now
-        # XXX we should check if there is any machine affinity (must pass that in) and
-        # XXX if so check if that machine has this application group running on it.
-        # XXX but this code is only used as a heuristic for queues
+        # Retrieve the affinity associated to the machine
+        machine_affinity = nil
+        affinities.each do |affinity|
+          machine_affinity = ::Naf::Affinity.find_by_id(affinity[:affinity_id])
+          if machine_affinity.affinity_classification_name == 'machine'
+            break
+          end
+        end
 
-        #(::Naf::QueuedJob.where(:application_run_group_name => application_run_group_name).count +
-        #::Naf::RunningJob.where(:application_run_group_name => application_run_group_name,
-        #:started_on_machine_id => @machine.id).count) >= application_run_group_limit
+        # If affinity is present, check if the sum of jobs running on the machine
+        # and queued for the machine is less the application_run_group_limit.
+        # If affinity is not present, send a log warning the user that application schedule
+        # should have affinity associated to the machine in order to behave correctly, and
+        # queue the application.
+        if machine_affinity.present?
+          queued_jobs = ::Naf::QueuedJob.
+            joins(:historical_job).
+            joins("INNER JOIN #{Naf.schema_name}.historical_job_affinity_tabs AS hjat
+              ON hjat.historical_job_id = #{Naf.schema_name}.historical_jobs.id").
+            where("#{Naf.schema_name}.historical_jobs.application_run_group_name = ? AND hjat.affinity_id = ?",
+              application_run_group_name, machine_affinity.id).count
+          running_jobs = ::Naf::RunningJob.where(
+              application_run_group_name: application_run_group_name,
+              started_on_machine_id: machine_affinity.affinity_name
+            ).count
 
-        # XXX just returning false
-        false
+          queued_jobs + running_jobs >= application_run_group_limit
+        else
+          logger.warn "application schedule does not have affinity associated with a machine"
+          false
+        end
       elsif application_run_group_restriction.id == ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines.id
-        (::Naf::QueuedJob.where(:application_run_group_name => application_run_group_name).count +
-         ::Naf::RunningJob.where(:application_run_group_name => application_run_group_name).count) >= application_run_group_limit
+        (::Naf::QueuedJob.where(application_run_group_name: application_run_group_name).count +
+         ::Naf::RunningJob.where(application_run_group_name: application_run_group_name).count) >= application_run_group_limit
       else
         logger.warn "not limited by run group restriction but don't know why: #{application_run_group_restriction.inspect}"
         true

data/app/models/logical/naf/construction_zone/proletariat.rb

@@ -27,6 +27,7 @@ module Logical::Naf::ConstructionZone
 
     def create_queued_job(historical_job)
       queued_job = ::Naf::QueuedJob.new(application_id: historical_job.application_id,
+                                        application_schedule_id: historical_job.application_schedule_id,
                                         application_type_id: historical_job.application_type_id,
                                         command: historical_job.command,
                                         application_run_group_restriction_id: historical_job.application_run_group_restriction_id,

data/app/models/logical/naf/construction_zone/work_order.rb

@@ -1,8 +1,14 @@
 module Logical::Naf::ConstructionZone
   class WorkOrder
-    attr_reader :command, :application_type, :application_run_group_restriction, :application_run_group_name
-    attr_reader :application_run_group_limit, :priority, :enqueue_backlogs
-    attr_reader :application, :application_schedule
+    attr_reader :command,
+                :application_type,
+                :application_run_group_restriction,
+                :application_run_group_name,
+                :application_run_group_limit,
+                :priority,
+                :enqueue_backlogs,
+                :application,
+                :application_schedule
 
     def initialize(command,
                    application_type = ::Naf::ApplicationType.rails,
@@ -42,7 +48,8 @@ module Logical::Naf::ConstructionZone
         application_run_group_name: application_run_group_name,
         application_run_group_limit: application_run_group_limit,
         priority: priority,
-        application_id: application.try(:id)
+        application_id: application.try(:id),
+        application_schedule_id: application_schedule.try(:id)
       }
     end
 

data/app/models/logical/naf/job_fetcher.rb

@@ -117,6 +117,7 @@ module Logical
         if historical_job.present?
           ::Naf::QueuedJob.delete(historical_job.id)
           running_job = ::Naf::RunningJob.new(application_id: historical_job.application_id,
+                                              application_schedule_id: historical_job.application_schedule_id,
                                               application_type_id: historical_job.application_type_id,
                                               command: historical_job.command,
                                               application_run_group_restriction_id: historical_job.application_run_group_restriction_id,

data/app/models/naf/application.rb

@@ -7,8 +7,8 @@ module Naf
                     :log_level,
                     :short_name,
                     :deleted,
-                    :application_schedule,
-                    :application_schedule_attributes
+                    :application_schedules,
+                    :application_schedules_attributes
 
     #---------------------
     # *** Associations ***
@@ -16,7 +16,7 @@ module Naf
 
     belongs_to :application_type,
       class_name: '::Naf::ApplicationType'
-    has_one :application_schedule,
+    has_many :application_schedules,
       class_name: '::Naf::ApplicationSchedule',
       dependent: :destroy
     has_many :historical_jobs,
@@ -35,12 +35,11 @@ module Naf
                            allow_nil: true,
                            format: {
                              with: /^[a-zA-Z_][a-zA-Z0-9_]*$/,
-                             message: "letters should be first"
+                             message: "short name consists of only letters/numbers/underscores, and it needs to start with a letter/underscore"
                            }
 
-    validate :check_references_with_application_schedule_prerequisites
     before_save :check_blank_values
-    accepts_nested_attributes_for :application_schedule, allow_destroy: true
+    accepts_nested_attributes_for :application_schedules, allow_destroy: true
 
     #--------------------
     # *** Delegations ***
@@ -85,16 +84,6 @@ module Naf
       self.log_level = nil if self.log_level.blank?
     end
 
-    def check_references_with_application_schedule_prerequisites
-      if application_schedule.try(:marked_for_destruction?)
-        prerequisites = Naf::ApplicationSchedulePrerequisite.
-          where(prerequisite_application_schedule_id: application_schedule.id).all
-        unless prerequisites.blank?
-          errors.add(:base, "Cannot delete scheduler, because the following applications are referenced to it: " +
-            "#{prerequisites.map{ |pre| pre.application_schedule.title }.join(', ') }")
-        end
-      end
-    end
 
   end
 end

data/app/models/naf/application_schedule.rb

@@ -10,10 +10,14 @@ module Naf
                     :priority,
                     :visible,
                     :enabled,
-                    :run_start_minute,
                     :application_run_group_limit,
+                    :application_run_group_quantum,
                     :application_schedule_prerequisites_attributes,
-                    :enqueue_backlogs
+                    :enqueue_backlogs,
+                    :run_interval_style_id,
+                    :application,
+                    :run_interval_style,
+                    :application_run_group_restriction
 
     SCHEDULES_LOCK_ID = 0
 
@@ -25,6 +29,8 @@ module Naf
       class_name: '::Naf::Application'
     belongs_to :application_run_group_restriction,
       class_name: '::Naf::ApplicationRunGroupRestriction'
+    belongs_to :run_interval_style,
+      class_name: '::Naf::RunIntervalStyle'
     has_many :application_schedule_affinity_tabs,
       class_name: '::Naf::ApplicationScheduleAffinityTab',
       dependent: :destroy
@@ -44,7 +50,10 @@ module Naf
     # *** Validations ***
     #++++++++++++++++++++
 
-    validates :application_run_group_restriction_id, presence: true
+    validates :application_run_group_restriction_id,
+              :run_interval_style_id,
+              :application_id,
+              :priority, presence: true
     validates :priority, numericality: {
                            only_integer: true,
                            greater_than: -2147483648,
@@ -56,12 +65,6 @@ module Naf
                                               less_than: 2147483647,
                                               allow_blank: true
                                             }
-    validates :run_start_minute, numericality: {
-                                   only_integer: true,
-                                   greater_than_or_equal_to: 0,
-                                   less_than: 24*60,
-                                   allow_blank: true
-                                 }
     validates :run_interval, numericality: {
                                only_integer: true,
                                greater_than_or_equal_to: 0,
@@ -71,9 +74,8 @@ module Naf
 
     before_save :check_blank_values
     validate :visible_enabled_check
-    validate :run_interval_at_time_check
-    validate :enabled_application_id_unique
     validate :prerequisite_application_schedule_id_uniqueness
+    validate :run_interval_check
 
     #--------------------
     # *** Delegations ***
@@ -94,17 +96,102 @@ module Naf
       unlock_record(SCHEDULES_LOCK_ID)
     end
 
-    def self.exact_schedules
-      where('run_start_minute is not null')
+    # find the exact based schedules that should be queued
+    # select anything that
+    #  isn't currently running (or queued) AND
+    #  hasn't run since run_interval AND
+    #  should have been run by now
+    def self.exact_schedules(time, not_finished_applications, application_last_runs)
+      custom_current_time = time.to_date + time.strftime('%H').to_i.hours + time.strftime('%M').to_i.minutes
+      schedules = ::Naf::ApplicationSchedule.
+        joins(:run_interval_style).
+        where("#{Naf.schema_name}.run_interval_styles.name IN (?)", ['at beginning of day', 'at beginning of hour']).
+        enabled.select do |schedule|
+
+        interval_time = time.to_date
+        if schedule.run_interval_style.name == 'at beginning of day'
+          interval_time += schedule.run_interval.minutes
+        elsif schedule.run_interval_style.name == 'at beginning of hour'
+          interval_time += time.strftime('%H').to_i.hours + schedule.run_interval.minutes
+        end
+
+        (not_finished_applications[schedule.id].nil? &&
+          (application_last_runs[schedule.id].nil? ||
+            (interval_time >= application_last_runs[schedule.id].finished_at)
+          ) &&
+          (custom_current_time - interval_time) == 0.seconds
+        )
+      end
+
+      schedules
     end
 
-    def self.relative_schedules
-      where('run_interval >= 0')
+    # find the interval based schedules that should be queued
+    # select anything that isn't currently running and completed
+    # running more than run_interval minutes ago
+    def self.relative_schedules(time, not_finished_applications, application_last_runs)
+      schedules = ::Naf::ApplicationSchedule.
+        joins(:run_interval_style).
+        where("#{Naf.schema_name}.run_interval_styles.name = ?", 'after previous run').
+        enabled.select do |schedule|
+
+        (not_finished_applications[schedule.id].nil? &&
+          (application_last_runs[schedule.id].nil? ||
+            (time - application_last_runs[schedule.id].finished_at) > schedule.run_interval.minutes
+          )
+        )
+      end
+
+      schedules
+    end
+
+    def self.constant_schedules
+      ::Naf::ApplicationSchedule.
+        joins(:run_interval_style).
+        where("#{Naf.schema_name}.run_interval_styles.name = ?", 'keep running').
+        enabled
+    end
+
+    def self.enabled
+      where(enabled: true)
+    end
+
+    def self.should_be_queued
+      current_time = Time.zone.now
+      # Applications that are still running
+      not_finished_applications = ::Naf::HistoricalJob.
+        queued_between(current_time - Naf::HistoricalJob::JOB_STALE_TIME, current_time).
+        where("finished_at IS NULL AND request_to_terminate = false").
+        find_all{ |job| job.application_schedule_id.present? }.
+        index_by{ |job| job.application_schedule_id }
+
+      # Last ran job for each application
+      application_last_runs = ::Naf::HistoricalJob.application_last_runs.
+        index_by{ |job| job.application_schedule_id }
+
+      relative_schedules = ::Naf::ApplicationSchedule.
+        relative_schedules(current_time, not_finished_applications, application_last_runs)
+      exact_schedules = ::Naf::ApplicationSchedule.
+        exact_schedules(current_time, not_finished_applications, application_last_runs)
+      constant_schedules = ::Naf::ApplicationSchedule.constant_schedules
+
+      foreman = ::Logical::Naf::ConstructionZone::Foreman.new
+      return (relative_schedules + exact_schedules + constant_schedules).select do |schedule|
+        affinities = []
+        schedule.affinities.each do |affinity|
+          affinities << { affinity_id: affinity.id }
+        end
+
+        schedule.enqueue_backlogs || !foreman.limited_by_run_group?(schedule.application_run_group_restriction,
+                                                                    schedule.application_run_group_name,
+                                                                    schedule.application_run_group_limit,
+                                                                    affinities)
+      end
     end
 
-    def self.pickables
+    def self.pickleables
       # check the application is deleted
-      self.where(:deleted => false)
+      self.where(deleted: false)
     end
 
     #-------------------------
@@ -124,11 +211,7 @@ module Naf
       end
       components << "id: #{id}"
       components << "\"#{application.title}\""
-      if run_start_minute
-        components << "start at: #{"%02d" % (run_start_minute/60)}:#{"%02d" % (run_start_minute%60)}"
-      else
-        components << "start every: #{run_interval} minutes"
-      end
+      components << ::Logical::Naf::ApplicationSchedule.new(self).display
 
       return "::Naf::ApplicationSchedule<#{components.join(', ')}>"
     end
@@ -140,31 +223,22 @@ module Naf
       end
     end
 
-    def enabled_application_id_unique
-      return unless enabled
-
-      if id
-        conditions = ["id <> ? AND application_id = ? AND enabled = ?", id, application_id, true]
+    # When rolling back from Naf v2.1 to v2.0, check whether run_interval
+    # or run_start_minute is nil. Otherwise, just check the presence of
+    # run_interval.
+    def run_interval_check
+      if self.attributes.keys.include?('run_start_minute')
+        if !run_start_minute.present? && !run_interval.present?
+          errors.add(:run_interval, "or run_start_minute must be nil")
+          errors.add(:run_start_minute, "or run_interval must be nil")
+        end
       else
-        conditions = ["application_id = ? AND enabled = ?", application_id, true]
-      end
-
-      num_collisions = self.class.count(conditions: conditions)
-      errors.add(:application_id, "is enabled and has already been taken") if num_collisions > 0
-    end
-
-    def run_interval_at_time_check
-      unless (run_start_minute.blank? || run_interval.blank?)
-        errors.add(:run_interval, "or Run start minute must be nil")
-        errors.add(:run_start_minute, "or Run interval must be nil")
+        if !run_interval.present?
+          errors.add(:run_interval, "must be present")
+        end
       end
     end
 
-    def self.pickleables(pickler)
-      self.joins(:application).
-        where("#{::Naf.schema_name}.applications.deleted IS FALSE")
-    end
-
     private
 
     def prerequisite_application_schedule_id_uniqueness

data/app/models/naf/historical_job.rb

@@ -15,6 +15,7 @@ module Naf
 
     # Protect from mass-assignment issue
     attr_accessible :application_id,
+                    :application_schedule_id,
                     :application_type_id,
                     :command,
                     :application_run_group_restriction_id,
@@ -44,6 +45,8 @@ module Naf
     # *** Associations ***
     #+++++++++++++++++++++
 
+    belongs_to :application_schedule,
+      class_name: '::Naf::ApplicationSchedule'
     belongs_to :application_type,
       class_name: '::Naf::ApplicationType'
     belongs_to :started_on_machine,
@@ -175,9 +178,9 @@ module Naf
     end
 
     def self.application_last_runs
-      where("application_id IS NOT NULL").
-        group("application_id").
-        select("application_id, MAX(finished_at) AS finished_at").
+      where("application_schedule_id IS NOT NULL").
+        group("application_schedule_id").
+        select("application_schedule_id, MAX(finished_at) AS finished_at").
         reject{ |job| job.finished_at.nil? }
     end