naf 1.1.0

data/app/models/naf/machine_affinity_slot.rb

@@ -0,0 +1,78 @@
+module Naf
+  class MachineAffinitySlot < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :machine_id,
+                    :affinity_id,
+                    :required,
+                    :affinity_parameter
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :machine,
+      class_name: '::Naf::Machine'
+    belongs_to :affinity,
+      class_name: '::Naf::Affinity'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :machine_id,
+              :affinity_id, presence: true
+    validates_uniqueness_of :affinity_id, scope: :machine_id,
+                                          message: 'has been taken for this machine'
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    delegate :affinity_name,
+             :affinity_classification_name,
+             :affinity_short_name, to: :affinity
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def machine_server_address
+      machine.server_address
+    end
+
+    def machine_server_name
+      machine.server_name
+    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::Machine'
+                      [key, { association_model_name: associations[key], association_value: value }]
+                    else
+                      [key,value]
+                    end
+                  } ]
+    end
+
+  end
+end

data/app/models/naf/machine_runner.rb

@@ -0,0 +1,51 @@
+module Naf
+  class MachineRunner < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :machine_id,
+                    :runner_cwd
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :machine,
+      class_name: '::Naf::Machine'
+    has_many :machine_runner_invocations,
+      class_name: '::Naf::MachineRunnerInvocation'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :machine_id,
+              :runner_cwd, presence: true
+    validates :machine_id, uniqueness: { scope: :runner_cwd }
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.enabled
+      joins(:machine).
+      where("#{::Naf.schema_name}.machines.enabled IS TRUE")
+    end
+
+    def self.running
+      joins(:machine_runner_invocations).
+      where("#{::Naf.schema_name}.machine_runner_invocations.dead_at IS NULL AND
+        #{::Naf.schema_name}.machine_runner_invocations.wind_down_at IS NULL")
+    end
+
+    def self.winding_down
+      joins(:machine_runner_invocations).
+      where("#{::Naf.schema_name}.machine_runner_invocations.dead_at IS NULL AND
+        #{::Naf.schema_name}.machine_runner_invocations.wind_down_at IS NOT NULL")
+    end
+
+    def self.dead
+      (::Naf::MachineRunner.joins(:machine).where("#{::Naf.schema_name}.machines.enabled IS TRUE").pluck(:machine_id) -
+        ::Naf::MachineRunner.running.pluck(:machine_id)).uniq
+    end
+
+  end
+end

data/app/models/naf/machine_runner_invocation.rb

@@ -0,0 +1,71 @@
+module Naf
+  class MachineRunnerInvocation < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :machine_runner_id,
+                    :pid,
+                    :dead_at,
+                    :wind_down_at,
+                    :commit_information,
+                    :branch_name,
+                    :repository_name,
+                    :deployment_tag
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :machine_runner,
+      class_name: '::Naf::MachineRunner'
+    has_many :historical_jobs,
+      class_name: '::Naf::HistoricalJob'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :machine_runner_id,
+              :pid, presence: true
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.choose(filter)
+      if filter.present? && filter == 'top'
+        return joins(
+          "JOIN (
+            SELECT
+              machine_runner_id, max(created_at) as created_at
+            FROM
+              #{::Naf.schema_name}.machine_runner_invocations
+            GROUP BY
+              machine_runner_id
+            ) AS mri2
+          ON #{::Naf.schema_name}.machine_runner_invocations.created_at = mri2.created_at AND
+            #{::Naf.schema_name}.machine_runner_invocations.machine_runner_id = mri2.machine_runner_id"
+        )
+      else
+        return where({})
+      end
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def status
+      if self.dead_at.blank?
+        if self.wind_down_at.present?
+          # Runner is Waiting for jobs to finish running,
+          # and will not start any other jobs
+          'winding-down'
+        else
+          'running' # Runner is UP
+        end
+      else
+        'dead' # Runner is DOWN
+      end
+    end
+
+  end
+end

data/app/models/naf/naf_base.rb

@@ -0,0 +1,9 @@
+module Naf
+  class NafBase < ::Naf.model_class
+    self.abstract_class = true
+
+    def self.full_table_name_prefix
+      return "#{::Naf.schema_name}."
+    end
+  end
+end

data/app/models/naf/queued_job.rb

@@ -0,0 +1,164 @@
+module Naf
+  class QueuedJob < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :application_id,
+                    :application_type_id,
+                    :command,
+                    :application_run_group_restriction_id,
+                    :application_run_group_name,
+                    :application_run_group_limit,
+                    :priority,
+                    :historical_job
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :historical_job,
+      class_name: "::Naf::HistoricalJob",
+      foreign_key: :id
+    belongs_to :application,
+      class_name: "::Naf::Application"
+    belongs_to :application_type,
+      class_name: '::Naf::ApplicationType'
+    belongs_to :application_run_group_restriction,
+      class_name: "::Naf::ApplicationRunGroupRestriction"
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_type_id,
+              :command,
+              :application_run_group_restriction_id,
+              :priority, presence: true
+
+    #-------------------------
+    # *** Class Methods ***
+    #+++++++++++++++++++++++++
+
+    def self.order_by_priority
+      order("priority, created_at")
+    end
+
+    def self.exclude_run_group_names(names)
+      if names.present?
+        where("application_run_group_name NOT IN (?)", names)
+      else
+        where({})
+      end
+    end
+
+    def self.is_not_restricted_by_run_group(machine)
+      sql = <<-SQL
+      (
+        #{Naf.schema_name}.queued_jobs.application_run_group_name is null OR
+        #{Naf.schema_name}.queued_jobs.application_run_group_limit is null OR
+        #{Naf.schema_name}.application_run_group_restrictions.application_run_group_restriction_name = 'no limit' OR
+        (
+          #{Naf.schema_name}.application_run_group_restrictions.application_run_group_restriction_name = 'limited per machine' AND
+          (select
+            count(*) < #{Naf.schema_name}.queued_jobs.application_run_group_limit
+           from
+             #{Naf.schema_name}.running_jobs as rj
+           where
+             rj.application_run_group_name = #{Naf.schema_name}.queued_jobs.application_run_group_name and
+             rj.started_on_machine_id = #{machine.id})
+        ) OR
+        (
+          application_run_group_restrictions.application_run_group_restriction_name = 'limited per all machines' AND
+          (select
+            count(*) < #{Naf.schema_name}.queued_jobs.application_run_group_limit
+           from
+             #{Naf.schema_name}.running_jobs as rj
+           where
+             rj.application_run_group_name = #{Naf.schema_name}.queued_jobs.application_run_group_name)
+        )
+      )
+      SQL
+
+      return joins(:application_run_group_restriction).
+        where(sql)
+    end
+
+    def self.runnable_by_machine(machine)
+      where("NOT EXISTS (
+        SELECT 1
+        FROM #{::Naf.schema_name}.historical_job_affinity_tabs AS t
+        WHERE t.historical_job_id = #{::Naf.schema_name}.queued_jobs.id AND
+          NOT EXISTS (
+            SELECT 1
+            FROM #{::Naf.schema_name}.machine_affinity_slots AS s
+            WHERE s.affinity_id = t.affinity_id AND
+              s.machine_id = #{machine.id}
+          )
+        )"
+      )
+    end
+
+    def self.prerequisites_finished
+      where("NOT EXISTS (
+        SELECT 1
+        FROM #{::Naf.schema_name}.historical_job_prerequisites AS p
+        WHERE p.historical_job_id = #{::Naf.schema_name}.queued_jobs.id AND
+          EXISTS (
+            SELECT 1
+            FROM #{::Naf.schema_name}.historical_jobs AS j
+            WHERE p.prerequisite_historical_job_id = j.id AND
+              j.finished_at IS NULL
+          )
+        )"
+      )
+    end
+
+    def self.weight_available_on_machine(machine)
+      machine_parameter_weights = {}
+      machine.machine_affinity_slots.each do |slot|
+        machine_parameter_weights[slot.affinity_id] = slot.affinity_parameter.to_f
+      end
+
+      running_job_weights = ::Naf::RunningJob.affinity_weights(machine)
+
+      queued_jobs = []
+      machine_parameter_weights.each do |affinity_id, parameter_weight|
+        queued_jobs |= ::Naf::QueuedJob.
+          check_weight_sum(affinity_id, running_job_weights[affinity_id], parameter_weight).
+          map(&:id)
+      end
+
+      if queued_jobs.empty?
+        where({})
+      else
+        where("#{::Naf.schema_name}.queued_jobs.id NOT IN (?)", queued_jobs)
+      end
+    end
+
+    def self.check_weight_sum(affinity_id, running_job_weight_count, machine_weight_count)
+      where("
+        id IN (
+          SELECT
+            historical_job_id
+          FROM
+            #{::Naf.schema_name}.historical_job_affinity_tabs AS t
+          WHERE EXISTS (
+            SELECT
+              1
+            FROM
+              #{::Naf.schema_name}.queued_jobs AS j
+            WHERE
+              t.historical_job_id = j.id
+          ) AND EXISTS (
+            SELECT
+              1
+            FROM
+              #{::Naf.schema_name}.affinities AS a
+            WHERE
+              a.id = '#{affinity_id}' AND
+                t.affinity_id = a.id
+          ) AND COALESCE(affinity_parameter, 0) + #{running_job_weight_count} > #{machine_weight_count}
+        )
+      ")
+    end
+
+  end
+end

data/app/models/naf/running_job.rb

@@ -0,0 +1,80 @@
+module Naf
+  class RunningJob < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :application_id,
+                    :application_type_id,
+                    :command,
+                    :application_run_group_restriction_id,
+                    :application_run_group_name,
+                    :application_run_group_limit,
+                    :started_on_machine_id,
+                    :pid,
+                    :request_to_terminate,
+                    :marked_dead_by_machine_id,
+                    :log_level,
+                    :started_at
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :historical_job,
+      class_name: "::Naf::HistoricalJob",
+      foreign_key: :id
+    belongs_to :application,
+      class_name: "::Naf::Application"
+    belongs_to :application_type,
+      class_name: '::Naf::ApplicationType'
+    belongs_to :application_run_group_restriction,
+      class_name: "::Naf::ApplicationRunGroupRestriction"
+    belongs_to :started_on_machine,
+      class_name: '::Naf::Machine'
+    belongs_to :marked_dead_by_machine,
+      class_name: '::Naf::Machine'
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :application_type_id,
+              :command,
+              :application_run_group_restriction_id, presence: true
+
+    #-------------------------
+    # *** Class Methods ***
+    #+++++++++++++++++++++++++
+
+    def self.started_on(machine)
+      where(started_on_machine_id: machine.id)
+    end
+
+    def self.in_run_group(run_group_name)
+      where(application_run_group_name: run_group_name)
+    end
+
+    def self.assigned_jobs(machine)
+      started_on(machine)
+    end
+
+    def self.affinity_weights(machine)
+      affinity_ids = ::Naf::Affinity.all.map(&:id)
+
+      job_weights = {}
+      affinity_ids.each do |affinity_id|
+        job_weights[affinity_id] = 0
+      end
+
+      ::Naf::RunningJob.where(started_on_machine_id: machine.id).all.each do |running_job|
+        affinity_ids.each do |affinity_id|
+          job_weights[affinity_id] += running_job.
+            historical_job.historical_job_affinity_tabs.
+            where(affinity_id: affinity_id).
+            first.try(:affinity_parameter).to_f
+        end
+      end
+
+      job_weights
+    end
+
+  end
+end