naf 1.1.0

data/app/models/naf/affinity_classification.rb

@@ -0,0 +1,44 @@
+module Naf
+  class AffinityClassification < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :affinity_classification_name
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    has_many :affinities, dependent: :destroy
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :affinity_classification_name, presence: true,
+                                             length: { minimum: 1 }
+
+    #-------------------------
+    # *** Class Methods ***
+    #+++++++++++++++++++++++++
+
+    def self.purpose
+      @@purpose ||= find_by_affinity_classification_name('purpose')
+    end
+
+    def self.location
+      @@location ||= find_by_affinity_classification_name('location')
+    end
+
+    def self.application
+      @@application ||= find_by_affinity_classification_name('application')
+    end
+
+    def self.weight
+      @@weight ||= find_by_affinity_classification_name('weight')
+    end
+
+    def self.machine
+      @@machine ||= find_by_affinity_classification_name('machine')
+    end
+
+  end
+end

data/app/models/naf/application.rb

@@ -0,0 +1,100 @@
+module Naf
+  class Application < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :title,
+                    :command,
+                    :application_type_id,
+                    :log_level,
+                    :short_name,
+                    :deleted,
+                    :application_schedule,
+                    :application_schedule_attributes
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :application_type,
+      class_name: '::Naf::ApplicationType'
+    has_one :application_schedule,
+      class_name: '::Naf::ApplicationSchedule',
+      dependent: :destroy
+    has_many :historical_jobs,
+      class_name: '::Naf::HistoricalJob'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_type_id,
+              :command,
+              :title, presence: true
+    validates :title, uniqueness: true
+    validates :short_name, uniqueness: true,
+                           allow_blank: true,
+                           allow_nil: true,
+                           format: {
+                             with: /^[a-zA-Z_][a-zA-Z0-9_]*$/,
+                             message: "letters should be first"
+                           }
+
+    validate :check_references_with_application_schedule_prerequisites
+    before_save :check_blank_values
+    accepts_nested_attributes_for :application_schedule, allow_destroy: true
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    delegate :script_type_name, to: :application_type
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def to_s
+      components = []
+      components << "DELETED" if deleted
+      components << "id: #{id}"
+      components << title
+
+      return "::Naf::Application<#{components.join(', ')}>"
+    end
+
+    def last_queued_job
+      last_queued_job = ::Naf::HistoricalJob.
+        queued_between(Time.zone.now - Naf::HistoricalJob::JOB_STALE_TIME, Time.zone.now).
+        where(application_id: self.id).
+        group(:application_id).
+        select("application_id, MAX(id) AS id").first
+      last_queued_job ? Naf::HistoricalJob.find(last_queued_job.id) : nil
+    end
+
+    def short_name_if_it_exist
+      short_name || title
+    end
+
+    def self.pickleables(pickler)
+      self.where(deleted: false)
+    end
+
+    private
+
+    def check_blank_values
+      self.short_name = nil if self.short_name.blank?
+      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_run_group_restriction.rb

@@ -0,0 +1,39 @@
+module Naf
+  class ApplicationRunGroupRestriction < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :application_run_group_restriction_name
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    has_many :application_schedules,
+      class_name: '::Naf::ApplicationSchedule'
+    has_many :historical_jobs,
+      class_name: '::Naf::HistoricalJob'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_run_group_restriction_name, presence: true
+
+    #-------------------------
+    # *** Class Methods ***
+    #+++++++++++++++++++++++++
+
+
+    def self.no_limit
+      @no_limit ||= find_by_application_run_group_restriction_name('no limit')
+    end
+
+    def self.limited_per_machine
+      @limited_per_machine ||= find_by_application_run_group_restriction_name('limited per machine')
+    end
+
+    def self.limited_per_all_machines
+      @limited_per_all_machines ||= find_by_application_run_group_restriction_name('limited per all machines')
+    end
+
+  end
+end

data/app/models/naf/application_schedule.rb

@@ -0,0 +1,181 @@
+module Naf
+  class ApplicationSchedule < NafBase
+    include PgAdvisoryLocker
+
+    # Protect from mass-assignment issue
+    attr_accessible :application_id,
+                    :application_run_group_restriction_id,
+                    :application_run_group_name,
+                    :run_interval,
+                    :priority,
+                    :visible,
+                    :enabled,
+                    :run_start_minute,
+                    :application_run_group_limit,
+                    :application_schedule_prerequisites_attributes,
+                    :enqueue_backlogs
+
+    SCHEDULES_LOCK_ID = 0
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :application,
+      class_name: '::Naf::Application'
+    belongs_to :application_run_group_restriction,
+      class_name: '::Naf::ApplicationRunGroupRestriction'
+    has_many :application_schedule_affinity_tabs,
+      class_name: '::Naf::ApplicationScheduleAffinityTab',
+      dependent: :destroy
+    has_many :affinities,
+      through: :application_schedule_affinity_tabs
+    has_many :application_schedule_prerequisites,
+      class_name: "::Naf::ApplicationSchedulePrerequisite",
+      dependent: :destroy
+    has_many :prerequisites,
+      class_name: "::Naf::ApplicationSchedule",
+      through: :application_schedule_prerequisites,
+      source: :prerequisite_application_schedule
+
+    accepts_nested_attributes_for :application_schedule_prerequisites, allow_destroy: true
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_run_group_restriction_id, presence: true
+    validates :priority, numericality: {
+                           only_integer: true,
+                           greater_than: -2147483648,
+                           less_than: 2147483647
+                         }
+    validates :application_run_group_limit, numericality: {
+                                              only_integer: true,
+                                              greater_than_or_equal_to: 1,
+                                              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,
+                               less_than: 2147483647,
+                               allow_blank: true
+                             }
+
+    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
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    delegate :title, to: :application
+    delegate :application_run_group_restriction_name, to: :application_run_group_restriction
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.try_lock_schedules
+      try_lock_record(SCHEDULES_LOCK_ID)
+    end
+
+    def self.unlock_schedules
+      unlock_record(SCHEDULES_LOCK_ID)
+    end
+
+    def self.exact_schedules
+      where('run_start_minute is not null')
+    end
+
+    def self.relative_schedules
+      where('run_interval >= 0')
+    end
+
+    def self.pickables
+      # check the application is deleted
+      self.where(:deleted => false)
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def to_s
+      components = []
+      if enabled
+        components << "ENABLED"
+      else
+        if visible
+          components << "DISABLED"
+        else
+          components << "HIDDEN|DISABLED"
+        end
+      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
+
+      return "::Naf::ApplicationSchedule<#{components.join(', ')}>"
+    end
+
+    def visible_enabled_check
+      unless visible or !enabled
+        errors.add(:visible, "must be true, or set enabled to false")
+        errors.add(:enabled, "must be false, if visible is set to false")
+      end
+    end
+
+    def enabled_application_id_unique
+      return unless enabled
+
+      if id
+        conditions = ["id <> ? AND application_id = ? AND enabled = ?", id, application_id, true]
+      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")
+      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
+      if application_schedule_prerequisites.map{ |asp| asp.prerequisite_application_schedule_id }.uniq!
+        errors.add(:prerequisite_application_schedule_id, "should be an uniqueness")
+      end
+    end
+
+    def check_blank_values
+      self.application_run_group_name = nil if self.application_run_group_name.blank?
+    end
+
+  end
+end

data/app/models/naf/application_schedule_affinity_tab.rb

@@ -0,0 +1,86 @@
+module Naf
+  class ApplicationScheduleAffinityTab < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :application_schedule_id,
+                    :affinity_id,
+                    :affinity_parameter
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :application_schedule,
+      class_name: '::Naf::ApplicationSchedule'
+    belongs_to :affinity,
+      class_name: '::Naf::Affinity'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_schedule_id,
+              :affinity_id, presence: true
+    validates_uniqueness_of :affinity_id, scope: :application_schedule_id,
+                                          message: 'has already been taken for this script'
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    delegate :affinity_name,
+             :affinity_classification_name, to: :affinity
+
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def script_title
+      application_schedule.title
+    end
+
+    def application
+      if schedule = application_schedule
+        application_schedule.application
+      else
+        nil
+      end
+    end
+
+    def self.pickleables(pickler)
+      self.joins([application_schedule: :application]).
+        where('applications.deleted = false')
+    end
+
+    def pickle(pickler, associations = nil, ignored_attributes = [:created_at, :updated_at])
+      instance_attributes = attributes.symbolize_keys
+      ignored_attributes.each do |ignored_attribute|
+        instance_attributes.delete(ignored_attribute.to_sym)
+      end
+
+      unless associations
+        associations = {}
+        instance_attributes.keys.select{|key| key.to_s =~ /_id$/}.each do |key|
+          association_name = key.to_s[0..-4].to_sym
+          association = association(association_name) rescue nil
+          if association
+            associations[key] = association.options[:class_name].constantize.name
+          end
+        end
+      end
+
+      return Hash[instance_attributes.map { |key, value|
+                    if associations[key] == 'Naf::Affinity'
+                      [key, { association_model_name: associations[key],
+                              association_classification_value: affinity.affinity_classification_id,
+                              association_affinity_value: affinity.affinity_name }]
+                    elsif associations[key] == 'Naf::ApplicationSchedule'
+                      [key, { association_model_name: associations[key], association_value: value }]
+                    else
+                      [key,value]
+                    end
+                  } ]
+    end
+
+  end
+end