naf 1.1.0

data/app/models/logical/naf/job_statuses/terminated.rb

@@ -0,0 +1,25 @@
+module Logical
+  module Naf
+    module JobStatuses
+      class Terminated
+
+        def self.all(conditions)
+          <<-SQL
+          (
+            SELECT
+              hj.*, NULL AS "historical_job_id"
+            FROM
+              "#{::Naf.schema_name}"."historical_jobs" AS hj
+            WHERE
+              hj.request_to_terminate IS TRUE AND hj.finished_at IS NULL
+              #{conditions}
+            ORDER BY
+              finished_at DESC NULLS LAST
+          )
+          SQL
+        end
+
+      end
+    end
+  end
+end

data/app/models/logical/naf/job_statuses/waiting.rb

@@ -0,0 +1,43 @@
+module Logical
+  module Naf
+    module JobStatuses
+      class Waiting
+
+        def self.all(conditions)
+          <<-SQL
+            (
+              SELECT DISTINCT
+                j.*, jp."historical_job_id"
+              FROM
+                "#{::Naf.schema_name}"."historical_jobs" AS j
+              LEFT JOIN
+                "#{::Naf.schema_name}"."historical_job_prerequisites" AS jp
+                ON j."id" = jp."historical_job_id"
+              WHERE
+                j.finished_at is NULL AND
+                j.request_to_terminate = false AND
+                jp.historical_job_id IS NOT NULL
+                AND j.started_at is NULL AND
+                EXISTS (
+                  SELECT
+                    1
+                  FROM
+                    "#{::Naf.schema_name}"."historical_jobs"
+                  JOIN
+                    "#{::Naf.schema_name}"."historical_job_prerequisites" ON
+                    "#{::Naf.schema_name}"."historical_jobs"."id" = "#{::Naf.schema_name}"."historical_job_prerequisites"."prerequisite_historical_job_id"
+                  WHERE
+                    "#{::Naf.schema_name}"."historical_job_prerequisites"."historical_job_id" = jp."historical_job_id" AND
+                    "#{::Naf.schema_name}"."historical_jobs"."finished_at" is NULL
+                )
+                #{conditions}
+                ORDER BY
+                  created_at DESC
+              )
+          SQL
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# A wrapper around Naf::Machine used for rendering in views
+
+module Logical
+  module Naf
+    class Machine
+
+      include ActionView::Helpers::DateHelper
+
+      COLUMNS = [:id,
+                 :server_name,
+                 :server_address,
+                 :server_note,
+                 :enabled,
+                 :process_pool_size,
+                 :last_checked_schedules_at,
+                 :last_seen_alive_at,
+                 :log_level,
+                 :affinities,
+                 :marked_down]
+
+      def initialize(naf_machine)
+        @machine = naf_machine
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if @machine.respond_to?(method_name)
+          @machine.send(method_name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      def self.all(filter = false)
+        ::Naf::Machine.include_deleted(filter).all.map{ |machine| new(machine) }
+      end
+
+      def process_pool_size
+        thread_pool_size
+      end
+
+      def last_checked_schedules_at
+        if value = @machine.last_checked_schedules_at
+          "#{time_ago_in_words(value, true)} ago, #{value.localtime.strftime("%Y-%m-%d %r")}"
+        else
+          ""
+        end
+      end
+
+      def last_seen_alive_at
+        if value = @machine.last_seen_alive_at
+          "#{time_ago_in_words(value, true)} ago, #{value.localtime.strftime("%Y-%m-%d %r")}"
+        else
+          ""
+        end
+      end
+
+      def to_hash
+        Hash[COLUMNS.map{ |m| [m, send(m)] }]
+      end
+
+      def affinities
+        @machine.machine_affinity_slots.map do |slot|
+          if slot.affinity_short_name
+            slot.affinity_short_name
+          else
+            name = slot.affinity_classification_name + '_' + slot.affinity_name
+            name = name + '_required' if slot.required
+            name
+          end
+        end.join(", \n")
+      end
+
+      def name
+        if @machine.short_name
+          @machine.short_name
+        elsif @machine.server_name
+          @machine.server_name
+        else
+          @machine.server_address
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# A wrapper around Naf::MachineRunner used for rendering in views
+
+module Logical
+  module Naf
+    class MachineRunner
+
+      COLUMNS = [
+        'id',
+        'created_at',
+        'server_name',
+        'runner_cwd'
+      ]
+
+      def self.to_array(column, order)
+        machine_runners = []
+        order_by = COLUMNS[column].to_s + ' ' + order
+        ::Naf::MachineRunner.enabled.order(order_by).all.each do |runner|
+          values = []
+          runner.attributes.each do |key, value|
+            if key == 'created_at'
+              values << value.to_s
+            else
+              values << value
+            end
+          end
+
+          invocation = runner.machine_runner_invocations.last
+          values << invocation.id
+          values << invocation.pid
+          values << invocation.status.gsub('-', ' ').split.map(&:capitalize).join(' ')
+
+          values << ::Naf::HistoricalJob.
+            joins("inner join #{::Naf.schema_name}.running_jobs nj on nj.id = #{::Naf.schema_name}.historical_jobs.id").
+            joins(:machine_runner_invocation).
+            where("#{::Naf.schema_name}.machine_runner_invocations.machine_runner_id = ?", runner.id).count
+          values << ''
+
+          machine_runners << values
+        end
+
+        machine_runners
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# A wrapper around Naf::MachineRunnerInvocation used for rendering in views
+
+module Logical
+  module Naf
+    class MachineRunnerInvocation
+
+      COLUMNS = [
+        'id',
+        'created_at',
+        'machine_runner_id',
+        'server_name',
+        'pid',
+        'status',
+        'commit_information',
+        'deployment_tag',
+        'repository_name'
+      ]
+
+      def self.to_array(column, order, filter)
+        machine_runner_invocations = []
+        order_by = COLUMNS[column].to_s + ' ' + order
+
+        if order_by =~ /status/
+          order_by = "dead_at #{order}, wind_down_at #{order}"
+        end
+
+        ::Naf::MachineRunnerInvocation.joins(machine_runner: :machine).choose(filter).order(order_by).all.each do |invocation|
+          values = []
+          invocation_hash = invocation.attributes
+          COLUMNS.each do |key|
+            if key == 'created_at'
+              values << invocation_hash[key].to_s
+            elsif key == 'server_name'
+              machine_runner = ::Naf::MachineRunner.find_by_id(invocation_hash['machine_runner_id'])
+              values << [machine_runner.machine.id, ::Logical::Naf::Machine.new(machine_runner.machine).name.to_s]
+            elsif key == 'status'
+              values << invocation.status.gsub('-', ' ').split.map(&:capitalize).join(' ')
+            else
+              values << invocation_hash[key]
+            end
+          end
+          machine_runner_invocations << values
+        end
+
+        machine_runner_invocations
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module ::Logical::Naf
+  class Pickler
+    include ::Af::Application::Component
+
+    create_proxy_logger
+    attr_reader :preserves,
+                :preservables,
+                :naf_version,
+                :context
+
+    def initialize(naf_version, preservables)
+      @preservables = preservables
+      @naf_version = naf_version
+      @preserves = {}
+      @context = {}
+    end
+
+    def generic_pickle(instance, associations = nil, ignored_attributes = [:created_at, :updated_at])
+      instance_attributes = instance.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 = instance.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]
+                      [key, { association_model_name: associations[key], association_value: value }]
+                    else
+                      [key,value]
+                    end
+                  } ]
+    end
+
+    def preserve
+      @preservables.each do |model|
+        preserve_model(model)
+      end
+    end
+
+    def preserve_model(model)
+      if model.respond_to?(:pickleables)
+        pickables = model.pickleables(self)
+      else
+        pickables = model.all
+      end
+
+      @preserves[model.name] = pickables.map do |instance|
+        if instance.respond_to?(:pickle)
+          instance.pickle(self)
+        else
+          generic_pickle(instance)
+        end
+      end
+    end
+
+    def pickle_jar
+      {
+        version: @naf_version,
+        preserved_at: Time.now,
+        preserves: @preserves
+      }
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module ::Logical::Naf
+  class Unpickler
+    include ::Af::Application::Component
+
+    create_proxy_logger
+    attr_reader :preserves,
+                :preservables,
+                :input_version,
+                :references,
+                :context
+
+    def initialize(preserves, preservables, input_version)
+      @preserves = preserves
+      @preservables = preservables
+      @input_version = input_version
+      @references = {}
+      @context = {}
+    end
+
+    def cache_all_models(model)
+      references.merge!(Hash[model.all.map do |m|
+                               logger.detail "caching: #{m.inspect}"
+                               [{ association_model_name: model.name, association_value: m.id }, m]
+                             end
+                            ])
+    end
+
+    def retrieve_reference(reference)
+      references[reference.symbolize_keys]
+    end
+
+    def generic_unpickle(model, preserve, id_method_name = :id)
+      if references[{ association_model_name: model.name, association_value: preserve[id_method_name.to_s] }]
+        return {}
+      end
+
+      attributes = {}
+
+      reference_methods = []
+      preserve.each do |method_name, value|
+        id_method = method_name.to_sym
+        unless id_method_name == id_method
+          if value.is_a?(Hash)
+            # this is a reference
+            reference_instance = retrieve_reference(value)
+            if reference_instance.nil?
+              logger.error value.inspect
+              logger.error { references.map{|r| r.inspect}.join("\n") }
+              logger.error { references.map{ |r| r.inspect }.join("\n") }
+              raise "couldn't find reference for #{value.inspect} in #{preserve.inspect}"
+            end
+            attributes[method_name.to_sym] = reference_instance.id
+          else
+            attributes[method_name.to_sym] = value
+          end
+        end
+      end
+
+      instance = model.new
+      attributes.each do |method, value|
+        instance.send("#{method}=".to_sym, value)
+      end
+      instance.save!
+      logger.info "created #{instance.inspect}"
+
+      return { { association_model_name: model.name,
+                 association_value: preserve[id_method_name.to_s] } => instance }
+    end
+
+    def reconstitute
+      preservables.each do |model|
+        if model.respond_to?(:pre_unpickle)
+          model.pre_unpickle(self)
+        else
+          cache_all_models(model)
+        end
+      end
+
+      preservables.each do |model|
+        model_preserves = preserves[model.name]
+        if model_preserves
+          model_preserves.each do |model_preserve|
+            if model.respond_to?(:unpickle)
+              additional_references = model.unpickle(model_preserve, self)
+            else
+              additional_references = generic_unpickle(model, model_preserve)
+            end
+            references.merge!(additional_references)
+          end
+        end
+      end
+
+      preservables.each do |model|
+        model.post_unpickle(self) if model.respond_to?(:post_unpickle)
+      end
+    end
+  end
+end

data/app/models/naf/affinity.rb

@@ -0,0 +1,145 @@
+module Naf
+  class Affinity < NafBase
+    # Protect from mass-assignment issue
+    attr_accessible :affinity_classification_id,
+                    :affinity_name,
+                    :selectable,
+                    :affinity_short_name,
+                    :affinity_note
+
+    #---------------------
+    # *** Associations ***
+    #+++++++++++++++++++++
+
+    belongs_to :affinity_classification,
+      class_name: '::Naf::AffinityClassification'
+    has_many :application_schedule_affinity_tabs,
+      class_name: '::Naf::ApplicationScheduleAffinityTab',
+      dependent: :destroy
+    has_many :machine_affinity_slots,
+      class_name: '::Naf::MachineAffinitySlot',
+      dependent: :destroy
+
+    #--------------------
+    # *** Validations ***
+    #++++++++++++++++++++
+
+    validates :affinity_classification_id,
+              :affinity_name, presence: true
+    validates :affinity_name, length: { minimum: 1 }
+    validates :affinity_short_name, uniqueness: true,
+                                    allow_blank: true,
+                                    allow_nil: true,
+                                    format: {
+                                      with: /^[a-zA-Z_][a-zA-Z0-9_]*$/,
+                                      message: 'letters should be first'
+                                    }
+
+    before_save :check_blank_values
+
+    #--------------------
+    # *** Delegations ***
+    #++++++++++++++++++++
+
+    delegate :affinity_classification_name, to: :affinity_classification
+
+    #----------------------
+    # *** Class Methods ***
+    #++++++++++++++++++++++
+
+    def self.selectable
+      where(selectable: true)
+    end
+
+    def self.pre_unpickle(unpickler)
+      unpickler.references.merge!(Hash[::Naf::Affinity.all.map do |m|
+                                    [{ association_model_name: ::Naf::Affinity.name,
+                                       association_classification_value: m.affinity_classification_id,
+                                       association_affinity_value: m.affinity_name }, m]
+                                  end
+                                 ])
+    end
+
+    def self.unpickle(preserve, unpickler)
+      reference = unpickler.references[{ association_model_name: self.name,
+                                         association_classification_value: preserve['affinity_classification_id']['association_value'],
+                                         association_affinity_value: preserve['affinity_name'] }]
+      if reference.present?
+        return {}
+      end
+
+      attributes = {}
+      reference_methods = []
+      preserve.each do |method_name, value|
+        unless method_name == 'id'
+          if value.is_a?(Hash)
+            # this is a reference
+            reference_instance = unpickler.retrieve_reference(value)
+            if reference_instance.nil?
+              logger.error value.inspect
+              logger.error { unpickler.references.map{ |r| r.inspect }.join("\n") }
+              raise "couldn't find reference for #{value.inspect} in #{preserve.inspect}"
+            end
+            attributes[method_name.to_sym] = reference_instance.id
+          else
+            attributes[method_name.to_sym] = value
+          end
+        end
+      end
+
+      instance = self.new
+      attributes.each do |method, value|
+        instance.send("#{method}=".to_sym, value)
+      end
+      instance.save!
+      logger.info "created #{instance.inspect}"
+
+      return { { association_model_name: self.name,
+                 association_classification_value: preserve['affinity_classification_id']['association_value'],
+                 association_affinity_value: preserve['affinity_name'] } => instance }
+    end
+
+    #-------------------------
+    # *** Instance Methods ***
+    #+++++++++++++++++++++++++
+
+    def to_s
+      components = []
+      components << "UNSELECTABLE" unless selectable
+      components << "classification: \"#{affinity_classification_name}\""
+      components << "name: \"#{affinity_name}\""
+
+      return "::Naf::Affinity<#{components.join(', ')}>"
+    end
+
+    def validate_affinity_name
+      if affinity_classification.present? &&
+        affinity_classification.affinity_classification_name == 'machine'
+
+        machine = ::Naf::Machine.find_by_id(affinity_name)
+        if machine.blank?
+          return "There isn't a machine with that id!"
+        end
+
+        count = ::Naf::Affinity.
+          where(affinity_classification_id: ::Naf::AffinityClassification.
+                  find_by_affinity_classification_name('machine').id,
+                affinity_name: machine.id.to_s).count
+
+        if count > 0
+          return 'An affinity with the pair value (affinity_classification_id, affinity_name) already exists!'
+        end
+      end
+
+      nil
+    end
+
+    private
+
+    def check_blank_values
+      self.affinity_short_name = nil if self.affinity_short_name.blank?
+      self.affinity_note = nil if self.affinity_note.blank?
+    end
+
+  end
+end