naf 1.1.0

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

@@ -0,0 +1,22 @@
+module Logical::Naf::ConstructionZone
+  class AdHocWorkOrder < WorkOrder
+    def initialize(*parameters)
+      maybe_hash = parameters.first
+      if maybe_hash.is_a?(Hash)
+        super(maybe_hash[:command],
+              maybe_hash[:application_type] || ::Naf::ApplicationType.rails,
+              maybe_hash[:application_run_group_restriction] || ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+              maybe_hash[:application_run_group_name] || :command,
+              maybe_hash[:application_run_group_limit] || 1,
+              maybe_hash[:priority] || 0,
+              maybe_hash[:affinities] || [],
+              maybe_hash[:prerequisites] || [],
+              maybe_hash[:enqueue_backlogs] || false,
+              maybe_hash[:application] || nil,
+              maybe_hash[:application_schedule] || nil)
+      else
+        super(*parameters)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Logical::Naf::ConstructionZone
+  class ApplicationScheduleWorkOrder < ApplicationWorkOrder
+    def initialize(application_schedule)
+      super(application_schedule.application,
+            application_schedule.application_run_group_restriction,
+            application_schedule.application_run_group_name,
+            application_schedule.application_run_group_limit,
+            application_schedule.priority,
+            application_schedule.affinities,
+            application_schedule.prerequisites,
+            application_schedule.enqueue_backlogs,
+            application_schedule)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Logical::Naf::ConstructionZone
+  class ApplicationWorkOrder < WorkOrder
+    def initialize(application,
+                   application_run_group_restriction = ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+                   application_run_group_name = :command,
+                   application_run_group_limit = 1,
+                   priority = 0,
+                   affinities = [],
+                   prerequisites = [],
+                   enqueue_backlogs = false,
+                   application_schedule = nil)
+      super(application.command,
+            application.application_type,
+            application_run_group_restriction,
+            application_run_group_name,
+            application_run_group_limit,
+            priority,
+            affinities,
+            prerequisites,
+            enqueue_backlogs,
+            application,
+            application_schedule)
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module Logical::Naf::ConstructionZone
+  class Boss
+    include ::Af::Application::Component
+    create_proxy_logger
+
+    def initialize()
+      @foreman = Foreman.new()
+    end
+
+    def enqueue_application(application,
+                            application_run_group_restriction,
+                            application_run_group_name,
+                            application_run_group_limit = 1,
+                            priority = 0,
+                            affinities = [],
+                            prerequisites = [],
+                            enqueue_backlogs = false)
+      work_order = ApplicationWorkOrder.new(application,
+                                            application_run_group_restriction,
+                                            application_run_group_name,
+                                            application_run_group_limit = 1,
+                                            priority = 0,
+                                            affinities = [],
+                                            prerequisites = [],
+                                            enqueue_backlogs = false)
+      @foreman.enqueue(work_order)
+    end
+
+    def enqueue_application_schedule(application_schedule)
+      work_order = ApplicationScheduleWorkOrder.new(application_schedule)
+      @foreman.enqueue(work_order)
+    end
+
+    def enqueue_rails_command(command,
+                              application_run_group_restriction = ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+                              application_run_group_name = :command,
+                              application_run_group_limit = 1,
+                              priority = 0,
+                              affinities = [],
+                              prerequisites = [],
+                              enqueue_backlogs = false)
+      work_order = WorkOrder.new(command,
+                                 ::Naf::ApplicationType.rails,
+                                 application_run_group_restriction,
+                                 application_run_group_name,
+                                 application_run_group_limit,
+                                 priority,
+                                 affinities,
+                                 prerequisites,
+                                 enqueue_backlogs)
+      @foreman.enqueue(work_order)
+    end
+
+    def enqueue_command(command,
+                        application_type = ::Naf::ApplicationType.rails,
+                        application_run_group_restriction = ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+                        application_run_group_name = :command,
+                        application_run_group_limit = 1,
+                        priority = 0,
+                        affinities = [],
+                        prerequisites = [],
+                        enqueue_backlogs = false)
+      work_order = WorkOrder.new(application_type,
+                                 command,
+                                 application_run_group_restriction,
+                                 application_run_group_name,
+                                 application_run_group_limit,
+                                 priority,
+                                 affinities,
+                                 prerequisites,
+                                 enqueue_backlogs)
+      @foreman.enqueue(work_order)
+    end
+
+    def enqueue_ad_hoc_command(parameters)
+      work_order = AdHocWorkOrder.new(parameters)
+      @foreman.enqueue(work_order)
+    end
+
+    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
+        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
+          }.merge(parameters)
+          machine_parameters[:affinities] = 
+            [machine.affinity] + if machine_parameters[:affinities].nil?
+                                   []
+                                 elsif machine_parameters[:affinities].is_a? Array
+                                   machine_parameters[:affinities]
+                                 else
+                                   [machine_parameters[:affinities]]
+                                 end
+           work_order = AdHocWorkOrder.new(machine_parameters)
+          @foreman.enqueue(work_order)
+        end
+      end
+    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
+      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))
+        @foreman.enqueue(work_order)
+      end
+    end
+
+    def reenqueue(job)
+      enqueue_rails_command(job.command,
+                            job.application_run_group_restriction,
+                            job.application_run_group_name,
+                            job.application_run_group_limit,
+                            job.priority,
+                            job.job_affinity_tabs.map{|jat| jat.affinity})
+    end
+
+  end
+end

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

@@ -0,0 +1,53 @@
+module Logical::Naf::ConstructionZone
+  class Foreman
+    include ::Af::Application::Component
+    create_proxy_logger
+
+    def initialize()
+      @proletariat = Proletariat.new
+    end
+
+    def enqueue(work_order)
+      limited = false
+      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)
+          limited = true
+          logger.warn "work order limited by run queue limits #{work_order.inspect}"
+        end
+      end
+      unless limited
+        @proletariat.create_job(work_order.historical_job_parameters,
+                                work_order.historical_job_affinity_tab_parameters,
+                                work_order.historical_job_prerequisite_historical_jobs)
+      end
+    end
+
+    def limited_by_run_group?(application_run_group_restriction, application_run_group_name, application_run_group_limit)
+      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
+
+        #(::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
+        
+        # XXX just returning false
+        false
+      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
+      else
+        logger.warn "not limited by run group restriction but don't know why: #{application_run_group_restriction.inspect}"
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Logical::Naf::ConstructionZone
+  class Proletariat
+    def create_job(parameters, affinities, prerequisites)
+      ::Naf::HistoricalJob.transaction do
+        historical_job = create_historical_job(parameters, affinities, prerequisites)
+        queued_job = create_queued_job(historical_job)
+        return historical_job
+      end
+    end
+
+    def create_historical_job(parameters, affinities, prerequisites)
+      ::Naf::HistoricalJob.transaction do
+        historical_job = ::Naf::HistoricalJob.create!(parameters)
+        affinities.each do |affinity|
+          ::Naf::HistoricalJobAffinityTab.create(affinity.merge(historical_job_id: historical_job.id))
+        end
+        historical_job.verify_prerequisites(prerequisites)
+        prerequisites.each do |prerequisite|
+          ::Naf::HistoricalJobPrerequisite.create({
+                                                    historical_job_id: historical_job.id,
+                                                    prerequisite_historical_job_id: prerequisite.id
+                                                  })
+        end
+        return historical_job
+      end
+    end
+
+    def create_queued_job(historical_job)
+      queued_job = ::Naf::QueuedJob.new(application_id: historical_job.application_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,
+                                        application_run_group_name: historical_job.application_run_group_name,
+                                        application_run_group_limit: historical_job.application_run_group_limit,
+                                        priority: historical_job.priority)
+      queued_job.id = historical_job.id
+      queued_job.save!
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+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
+
+    def initialize(command,
+                   application_type = ::Naf::ApplicationType.rails,
+                   application_run_group_restriction = ::Naf::ApplicationRunGroupRestriction.limited_per_all_machines,
+                   application_run_group_name = :command,
+                   application_run_group_limit = 1,
+                   priority = 0,
+                   affinities = [],
+                   prerequisites = [],
+                   enqueue_backlogs = false,
+                   application = nil,
+                   application_schedule = nil)
+      @command = command
+      @application_type = application_type
+      @application_run_group_restriction = application_run_group_restriction
+      @application_run_group_name = (application_run_group_name == :command ? command : application_run_group_name)
+      @application_run_group_limit = application_run_group_limit
+      @priority = priority
+      @affinities = if affinities.nil?
+                      []
+                    elsif affinities.is_a? Array
+                      affinities
+                    else
+                      [affinities]
+                    end
+      @prerequisites = prerequisites
+      @enqueue_backlogs = enqueue_backlogs
+      @application = application
+      @application_schedule = application_schedule
+    end
+
+    def historical_job_parameters
+      {
+        command: command,
+        application_type_id: application_type.id,
+        application_run_group_restriction_id: application_run_group_restriction.id,
+        application_run_group_name: application_run_group_name,
+        application_run_group_limit: application_run_group_limit,
+        priority: priority,
+        application_id: application.try(:id)
+      }
+    end
+
+    def historical_job_affinity_tab_parameters
+      @affinities.map do |affinity|
+        if affinity.is_a? Symbol
+          # short_name of affinity
+          affinity_object = {
+            :affinity_id => ::Naf::Affinity.find_by_affinity_short_name(affinity).try(:id)
+          }
+          raise "no affinity provided" if affinity_object[:affinity_id].nil?
+          affinity_object
+        elsif affinity.is_a? ::Naf::Affinity
+          {
+            :affinity_id => affinity.id
+          }
+        elsif affinity.is_a? ::Naf::Machine
+          # affinity_for machine
+          {
+            :affinity_id => affinity.affinity.id
+          }
+        elsif affinity.is_a? ::Naf::ApplicationScheduleAffinityTab
+          # affinity_for application_schedule_affinity_tab
+        elsif affinity.is_a? Hash
+          # should have key: :affinity_id or :affinity_short_name or :affinity_name
+          # may have key: :affinity_parameter
+          affinity_object = {
+          }
+          if affinity.has_key?(:affinity_id)
+            affinity_object[:affinity_id] = affinity[:affinity_id]
+          elsif affinity.has_key?(:affinity_name)
+            affinity_object[:affinity_id] = ::Naf::Affinity.find_by_affinity_name(affinity[:affinity_name]).try(:id)
+          elsif affinity.has_key?(:affinity_short_name)
+            affinity_object[:affinity_id] = ::Naf::Affinity.find_by_affinity_short_name(affinity[:affinity_short_name]).try(:id)
+          end
+          raise "no affinity provided" if affinity_object[:affinity_id].nil?
+          affinity_object[:affinity_parameter] = affinity[:affinity_parameter] if affinity.has_key?(:affinity_parameter)
+          affinity_object
+        else
+          raise "unknown affinity kind: #{affinity.inspect}"
+        end
+      end
+    end
+
+    def historical_job_prerequisite_historical_jobs
+      # the idea here is that if it is a historical job its prerequisites have
+      # already been checked, we only need to check if the prerequisites are NOT
+      # the current job we are inserting (which can't happen in the current code path)
+      @prerequisites.each do |prerequisite|
+        raise "found a non Naf::HistoricalJob in prerequisites: #{prerequisite.inspect}" unless prerequisite.is_a? ::Naf::HistoricalJob
+      end
+      return @prerequisites
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Logical
+  module Naf
+    class CreateInfrastructure
+      include ::Af::Application::SafeProxy
+
+      def initialize(model_names)
+        @model_names = model_names
+      end
+
+      def logger
+        return af_logger(self.class.name)
+      end
+
+      def work
+        first_model = nil
+        begin
+          @model_names.each do |target_model_name|
+            logger.info "target model: #{target_model_name}"
+            target_model = target_model_name.constantize rescue nil
+            if target_model.nil?
+              logger.error "couldn't find target_model #{target_model_name}"
+            else
+              unless first_model
+                target_model.connection.begin_db_transaction
+                first_model = target_model
+              end
+              begin
+                logger.info "#{target_model_name}: creating infrastructure"
+                target_model.create_infrastructure
+                logger.info "#{target_model_name}: creating new partitions"
+                target_model.create_new_partitions
+                logger.info "#{target_model_name}: done"
+              rescue StandardError => e
+                logger.error "couldn't create infrastructure for: #{target_model_name}, #{e.message}"
+                logger.error e.backtrace.join("\n")
+              end
+            end
+          end
+        ensure
+          if first_model
+            first_model.connection.commit_db_transaction
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,357 @@
+# A wrapper around Naf::HistoricalJob used for rendering in views
+
+module Logical
+  module Naf
+    class Job
+      include ActionView::Helpers::DateHelper
+      include ActionView::Helpers::TextHelper
+
+      COLUMNS = [:id,
+                 :server,
+                 :pid,
+                 :queued_time,
+                 :title,
+                 :started_at,
+                 :finished_at,
+                 :run_time,
+                 :affinities,
+                 :tags,
+                 :status]
+
+      ATTRIBUTES = [:title,
+                    :id,
+                    :status,
+                    :server,
+                    :pid,
+                    :queued_time,
+                    :command,
+                    :started_at,
+                    :finished_at,
+                    :run_time,
+                    :exit_status,
+                    :script_type_name,
+                    :log_level,
+                    :request_to_terminate,
+                    :machine_started_on_server_address,
+                    :machine_started_on_server_name,
+                    :application_run_group_name,
+                    :application_run_group_limit,
+                    :application_run_group_restriction_name]
+
+      FILTER_FIELDS = [:application_type_id,
+                       :application_run_group_restriction_id,
+                       :priority,
+                       :failed_to_start,
+                       :pid,
+                       :exit_status,
+                       :request_to_terminate,
+                       :started_on_machine_id]
+
+      SEARCH_FIELDS = [:command, :application_run_group_name]
+
+      # Mapping of datatable column positions and job attributes
+      ORDER = { '0' => "id",
+                '2' => "pid",
+                '3' => "created_at",
+                '5' => "started_at",
+                '6' => "finished_at",
+                '10' => "status" }
+
+      def initialize(naf_job)
+        @job = naf_job
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if @job.respond_to?(method_name)
+          @job.send(method_name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      def status
+        if @job.request_to_terminate && @job.finished_at.nil?
+          "Terminating"
+        elsif @job.request_to_terminate && @job.finished_at.present?
+          "Terminated"
+        elsif @job.started_at and (not @job.finished_at)
+          "Running"
+        elsif (not @job.started_at) and (not @job.finished_at) and @job.failed_to_start
+          "Failed to Start"
+        elsif @job.exit_status and @job.exit_status > 0
+          "Error #{@job.exit_status}"
+        elsif @job.started_at and @job.finished_at
+          "Finished"
+        elsif @job.termination_signal
+          "Signaled #{@job.termination_signal}"
+        elsif @job.prerequisites.select { |pre| pre.started_at.nil? }.size > 0
+          "Waiting"
+        else
+          "Queued"
+        end
+      end
+
+      def title
+        if application
+          application.title
+        else
+          command
+        end
+      end
+
+      def application_run_group_name
+        if @job.application_run_group_name.blank?
+          "not set"
+        elsif @job.application_run_group_name == @job.command
+          "command"
+        else
+          @job.application_run_group_name
+        end
+      end
+
+      def server
+        if started_on_machine
+          name = started_on_machine.short_name_if_it_exist
+          if name.blank?
+            started_on_machine.server_address
+          else
+            name
+          end
+        end
+      end
+
+      # Given search, a hash of the search query for jobs on the queue,
+      # build up and return the ActiveRecord scope
+      #
+      # We eventually build up these results over created_at/1.week partitions.
+      def self.search(search)
+        if search[:order] == "status"
+          conditions = ""
+          values = {}
+          values[:limit] = search[:limit].to_i
+          values[:offset]= search[:offset].to_i*search[:limit].to_i
+          FILTER_FIELDS.each do |field|
+            if search[field].present?
+              conditions << " AND "
+              case field
+                when :failed_to_start, :request_to_terminate
+                  values[field.to_sym] = search[field]
+                  conditions << "#{field} = :#{field}"
+                else
+                  values[field.to_sym] = search[field].to_i
+                  conditions << "#{field} = :#{field}"
+              end
+            end
+          end
+          SEARCH_FIELDS.each do |field|
+            if search[field].present?
+              conditions << " AND "
+              conditions << "lower(#{field}) ~ :#{field}"
+              values[field.to_sym] = search[field].downcase
+            end
+          end
+
+          status = search[:status].blank? ? :all : search[:status]
+          sql =
+          case status.to_sym
+            when :queued
+              JobStatuses::Running.all(:queued, conditions) + "union all\n" +
+              JobStatuses::Queued.all(conditions) + "union all\n" +
+              JobStatuses::Waiting.all(conditions) + "union all\n" +
+              JobStatuses::FinishedLessMinute.all(conditions) + "union all\n" +
+              JobStatuses::Terminated.all(conditions)
+            when :running
+              JobStatuses::Running.all(conditions) + "union all\n" +
+              JobStatuses::FinishedLessMinute.all(conditions) + "union all\n" +
+              JobStatuses::Terminated.all(conditions)
+            when :waiting
+              JobStatuses::Waiting.all(conditions)
+            when :finished
+              JobStatuses::Finished.all(conditions)
+            when :errored
+              JobStatuses::Errored.all(conditions)
+            else
+              JobStatuses::Running.all(:queued, conditions) + "union all\n" +
+              JobStatuses::Queued.all(conditions) + "union all\n" +
+              JobStatuses::Waiting.all(conditions) + "union all\n" +
+              JobStatuses::Finished.all(conditions) + "union all\n" +
+              JobStatuses::Terminated.all(conditions)
+          end
+          sql << "LIMIT :limit OFFSET :offset"
+          jobs = ::Naf::HistoricalJob.find_by_sql([sql, values])
+
+          jobs.map{ |physical_job| new(physical_job) }
+        else
+          job_scope = self.get_job_scope(search)
+          order, direction = search[:order], search[:direction]
+          job_scope = job_scope.order("#{order} #{direction}").limit(search[:limit]).offset(search[:offset].to_i*search[:limit].to_i)
+
+          if search[:status] == 'waiting'
+            job_scope = job_scope.select{|job| job.prerequisites.select{ |pre| pre.started_at.nil? }.size > 0 }
+          end
+
+          job_scope.map{|physical_job| new(physical_job) }
+        end
+      end
+
+      def self.total_display_records(search)
+        job_scope = self.get_job_scope(search)
+
+        if search[:status] == 'waiting'
+          job_scope = job_scope.select{ |job| job.prerequisites.select{ |pre| pre.started_at.nil? }.size > 0 }
+        end
+
+        job_scope.count
+      end
+
+      def self.get_job_scope(search)
+        status = search[:status].blank? ? :all : search[:status]
+        case status.to_sym
+          when :queued
+            job_scope = ::Naf::HistoricalJob.queued_status
+          when :running
+            job_scope = ::Naf::HistoricalJob.running_status
+          when :waiting
+            job_scope = ::Naf::HistoricalJob.queued_with_waiting
+          when :finished
+            job_scope = ::Naf::HistoricalJob.finished
+          when :errored
+            job_scope = ::Naf::HistoricalJob.errored
+          else
+            job_scope = ::Naf::HistoricalJob.scoped
+        end
+
+        FILTER_FIELDS.each do |field|
+          job_scope = job_scope.where(field => search[field]) if search[field].present?
+        end
+        SEARCH_FIELDS.each do |field|
+          job_scope = job_scope.where(["lower(#{field}) ~ ?", search[field].downcase]) if search[field].present?
+        end
+
+        job_scope
+      end
+
+      def self.find(id)
+        physical_job = ::Naf::HistoricalJob.find(id)
+        physical_job ? new(physical_job) : nil
+      end
+
+      def application_url
+        if application = @job.application
+          return Rails.application.routes.url_helpers.application_path(application)
+        else
+          return nil
+        end
+      end
+
+      def to_detailed_hash
+        Hash[ ATTRIBUTES.map{ |m|
+          case m
+          when :started_at, :finished_at
+            if value = @job.send(m)
+              [m, value.localtime.strftime("%Y-%m-%d %r")]
+            else
+              [m, '']
+            end
+          else
+            [m, send(m)]
+          end
+        }]
+      end
+
+      # Format the hash of a job record nicely for the table
+      def to_hash
+        Hash[ COLUMNS.map{ |m| [m, send(m)] } ]
+      end
+
+      def started_at
+        if @job.started_at.present?
+          value = Time.zone.now - @job.started_at
+          if value < 60
+            "#{value.to_i} seconds ago, #{@job.started_at.localtime.strftime("%Y-%m-%d %r")}"
+          elsif value < 172_800
+            time_difference(value)
+          elsif value >= 172_800
+            "#{time_ago_in_words(@job.started_at, true)} ago, #{@job.started_at.localtime.strftime("%Y-%m-%d %r")}"
+          else
+            ""
+          end
+        else
+          ""
+        end
+      end
+
+      def time_difference(value, time_format_on=true)
+        seconds = value % 60
+        value = (value - seconds) / 60
+        minutes = value % 60
+        value = (value - minutes) / 60
+        hours = value % 24
+        value = (value - hours) / 24
+        days = value % 7
+        more_hours = hours + days * 24 if days > 0
+
+        if time_format_on
+          "-#{hours.to_i}h#{minutes.to_i}m, #{@job.started_at.localtime.strftime("%Y-%m-%d %r")}"
+        else
+          if days < 2
+            "-#{more_hours.to_i}h#{minutes.to_i}m#{seconds.to_i}s"
+          else
+            "-#{days.to_i}d#{hours.to_i}h#{minutes.to_i}m#{seconds.to_i}s"
+          end
+        end
+      end
+
+      def has_started?
+        @job.started_at.present?
+      end
+
+      def queued_time
+        created_at.localtime.strftime("%Y-%m-%d %r")
+      end
+
+      def run_time
+        if @job.started_at.present?
+          if @job.finished_at.present?
+            time_difference(@job.finished_at - @job.started_at, false)[1..-1]
+          else
+            time_difference(Time.zone.now - @job.started_at, false)[1..-1]
+          end
+        else
+          ""
+        end
+      end
+
+      def finished_at
+        if value = @job.finished_at
+          "#{time_ago_in_words(value, true)} ago, #{value.localtime.strftime("%Y-%m-%d %r")}"
+        else
+          ""
+        end
+      end
+
+      def affinities
+        @job.job_affinities.map do |job_affinity|
+          if job_affinity.present?
+            if job_affinity.affinity_short_name.present?
+              job_affinity.affinity_short_name
+            else
+              job_affinity.affinity_classification_name + '_' + job_affinity.affinity_name
+            end
+          end
+        end.join(", \n")
+      end
+
+      def tags
+        if @job.tags.present?
+          # Only show custom visible tags
+          job_tags = @job.tags.gsub(/[{}]/,'').split(',')
+          (job_tags.select { |elem| !['$', '_'].include?elem[0] }).join(', ')
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end