naf 1.1.0

data/app/helpers/naf/application_helper.rb

@@ -0,0 +1,275 @@
+module Naf
+
+  ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+    errors = Array(instance.error_message).join('; ')
+    if html_tag =~ /^<label for=/
+      %(<span class="validation-error">#{html_tag}</span>).html_safe
+    else
+      %(#{html_tag}<span class="validation-error">&nbsp;#{errors}</span>).html_safe
+    end
+  end
+
+  module ApplicationHelper
+    include ActionView::Helpers::TextHelper
+
+    NAF_DESTROY_BLOCKED_RESOURCES = ["historical_jobs",
+                                     "applications",
+                                     "machines",
+                                     "historical_job_affinity_tabs",
+                                     "janitorial_assignments"]
+    NAF_READ_ONLY_RESOURCES = []
+    NAF_CREATE_BLOCKED_RESOURCES = []
+    NAF_ALL_VISIBLE_RESOURCES = {
+                                  "historical_jobs" => "",
+                                  "applications" => "",
+                                  "machines" => "",
+                                  "runners" => ["machine_runners",
+                                                "machine_runner_invocations"],
+                                  "affinities" => "",
+                                  "loggers" => ["logger_styles", "logger_names"],
+                                  "janitorial_assignments" => ["janitorial_archive_assignments",
+                                                               "janitorial_create_assignments",
+                                                               "janitorial_drop_assignments"]
+                                }
+
+    def naf_tabs
+      NAF_ALL_VISIBLE_RESOURCES
+    end
+
+    def naf_last_queued_at_link(app)
+      if historical_job = app.last_queued_job
+        link_to "#{time_ago_in_words(historical_job.created_at, true)} ago, #{historical_job.created_at.localtime.strftime("%Y-%m-%d %r")}",
+          naf.historical_job_path(historical_job)
+      else
+        ""
+      end
+    end
+
+    def naf_highlight_tab?(tab)
+      case tab
+        when "machines"
+          [tab, "machine_affinity_slots"].include?(controller_name)
+        when "runners"
+          ["machine_runners", "machine_runner_invocations"].include?(controller_name)
+        when "historical_jobs"
+          [tab, "historical_job_affinity_tabs"].include?(controller_name)
+        when "applications"
+          [tab, "application_schedule_affinity_tabs"].include?(controller_name)
+        when "loggers"
+          ["logger_styles", "logger_names"].include?(controller_name)
+        when "janitorial_assignments"
+          ["Naf::JanitorialArchiveAssignment",
+           "Naf::JanitorialCreateAssignment",
+           "Naf::JanitorialDropAssignment"].include?(params[:type])
+        when "janitorial_archive_assignments"
+          "Naf::JanitorialArchiveAssignment" == params[:type]
+        when "janitorial_create_assignments"
+          "Naf::JanitorialCreateAssignment" == params[:type]
+        when "janitorial_drop_assignments"
+          "Naf::JanitorialDropAssignment" == params[:type]
+        else
+          tab == controller_name
+      end
+    end
+
+    def naf_parent_resource_link
+      case controller_name
+        when "historical_job_affinity_tabs"
+          link_to "Back to Historical Job",
+            controller: 'historical_jobs',
+            action: 'show',
+            id: params[:historical_job_id]
+        when "application_schedule_affinity_tabs"
+          link_to "Back to Application",
+            controller: 'applications',
+            action: 'show',
+            id: params[:application_id]
+        when "machine_affinity_slots"
+          link_to "Back to Machine",
+            controller: 'machines',
+            action: 'show',
+            id: params[:machine_id]
+        else
+          ""
+      end
+    end
+
+    def naf_nested_resource_index?
+      ["historical_job_affinity_tabs",
+       "application_schedule_affinity_tabs",
+       "machine_affinity_slots"].include?(controller_name) and !params[:id]
+    end
+
+    def naf_table_title
+      if current_page?(naf.janitorial_archive_assignments_path)
+        "Janitorial Archive Assignment"
+      elsif current_page?(naf.janitorial_create_assignments_path)
+        "Janitorial Create Assignment"
+      elsif current_page?(naf.janitorial_drop_assignments_path)
+        "Janitorial Drop Assignment"
+      elsif current_page?(main_app.naf_path)
+        "Jobs"
+      else
+        case controller_name
+          when "application_schedule_affinity_tabs"
+            Application.find(params[:application_id]).title + ", Affinity Tabs"
+          when "machine_affinity_slots"
+            machine = Machine.find(params[:machine_id])
+            name = machine.server_name
+            ((name and name.length > 0) ? name : machine.server_address) + ", Affinity Slots"
+          else
+            naf_make_header(controller_name)
+        end
+      end
+    end
+
+    def naf_generate_child_resources_link
+      case controller_name
+        when "historical_jobs"
+          link_to "Historical Job Affinity Tabs",
+            controller: 'historical_job_affinity_tabs',
+            action: 'index',
+            historical_job_id: params[:id]
+        when "applications"
+          if @record.application_schedule
+            link_to "Application Schedule Affinity Tabs",
+              controller: 'application_schedule_affinity_tabs',
+              action: 'index',
+              application_schedule_id: @record.application_schedule.id,
+              application_id: @record.id
+          else
+            ""
+          end
+        when "machines"
+          link_to "Machine Affinity Slots",
+            controller: 'machine_affinity_slots',
+            action: 'index',
+            machine_id: params[:id]
+        else
+          ""
+      end
+    end
+
+    def naf_generate_index_link(name)
+      case name
+        when "historical_jobs"
+          link_to "Jobs", main_app.naf_path
+        when "loggers"
+          link_to "Loggers", naf.logger_styles_path
+        when "runners"
+          link_to "Runners", naf.machine_runners_path
+        when "janitorial_assignments"
+          link_to "Janitorial Assignments", naf.janitorial_archive_assignments_path
+        when "janitorial_archive_assignments"
+          link_to "Janitorial Archive Assignments", naf.janitorial_archive_assignments_path
+        when "janitorial_create_assignments"
+          link_to "Janitorial Create Assignments", naf.janitorial_create_assignments_path
+        when "janitorial_drop_assignments"
+          link_to "Janitorial Drop Assignments", naf.janitorial_drop_assignments_path
+        else
+          link_to name.split('_').map(&:capitalize).join(' '), { controller: name, action: 'index'}
+      end
+    end
+
+    def naf_generate_create_link
+      return "" if NAF_READ_ONLY_RESOURCES.include?(controller_name) or NAF_CREATE_BLOCKED_RESOURCES.include?(controller_name)
+      return link_to "Add a Job", naf.new_historical_job_path, { class: 'add_job' } if naf_display_job_search_link?
+      link_to "Create new #{naf_model_name}", { controller: controller_name, action: 'new' }
+    end
+
+    def naf_display_job_search_link?
+      current_page?(naf.root_url) or current_page?(controller: 'historical_jobs', action: 'index')
+    end
+
+    def naf_model_name
+      name_pieces = controller_name.split('_')
+      name_pieces[name_pieces.size - 1] = name_pieces.last.singularize
+      name_pieces.map(&:capitalize).join(' ')
+    end
+
+    def naf_make_header(attribute)
+      attribute.to_s.split('_').map(&:capitalize).join(' ')
+    end
+
+    def naf_generate_edit_link
+      return "" if NAF_READ_ONLY_RESOURCES.include?(controller_name)
+      link_to "Edit", { controller: controller_name, action: 'edit', id: params[:id] }, class: 'edit'
+    end
+
+    def naf_generate_back_link
+      link_to "Back to #{naf_make_header(controller_name)}", { controller: controller_name, action: 'index' }, class: 'back'
+    end
+
+    def naf_generate_destroy_link
+      return "" if NAF_READ_ONLY_RESOURCES.include?(controller_name) or NAF_DESTROY_BLOCKED_RESOURCES.include?(controller_name)
+      case controller_name
+        when "application_schedule_affinity_tabs"
+          link_to "Destroy", application_application_schedule_application_schedule_affinity_tab_url(@application, @application_schedule, @record),
+            { confirm: "Are you sure you want to destroy this #{naf_model_name}?",
+              method: :delete,
+              class: 'destroy' }
+        when "machine_affinity_slots"
+          link_to "Destroy", machine_machine_affinity_slot_url(@machine, @record),
+            { confirm: "Are you sure you want to destroy this #{naf_model_name}?",
+              method: :delete,
+              class: 'destroy' }
+        else
+          link_to "Destroy", @record,
+            { confirm: "Are you sure you want to destroy this #{naf_model_name}?",
+              method: :delete,
+              class: 'destroy' }
+      end
+    end
+
+    def include_actions_in_table?
+      current_page?(naf.root_url) or
+      current_page?(controller: 'applications', action: 'index') or
+        current_page?(controller: 'historical_jobs', action: 'index')
+    end
+
+    def naf_papertrail_link(record, runner = false)
+      if group_id = Naf.papertrail_group_id
+        url = "http://www.papertrailapp.com/groups/#{group_id}/events"
+        if record.kind_of?(::Naf::HistoricalJob) || record.kind_of?(::Logical::Naf::Job)
+          if record.pid.present?
+            query = "jid(#{record.id})"
+            url << "?q=#{CGI.escape(query)}"
+          end
+        elsif record.kind_of?(::Naf::Machine) || record.kind_of?(::Logical::Naf::Machine)
+          query = record.server_name
+          unless query.nil?
+            query << " runner" if runner
+            url << "?q=#{CGI.escape(query)}"
+          end
+        end
+      else
+        url = "http://www.papertrailapp.com/dashboard"
+      end
+
+      return url
+    end
+
+    def naf_link_to_remove_fields(name, f)
+      f.hidden_field(:_destroy) + link_to_function(name, "remove_fields(this)")
+    end
+
+    def naf_link_to_add_fields(name, f, association)
+      new_object = f.object.class.reflect_on_association(association).klass.new
+      fields = f.fields_for(association, new_object, child_index: "new_#{association}") do |builder|
+        render(association.to_s, f: builder)
+      end
+      link_to_function(name, "add_fields(this, \"#{association}\", \"#{escape_javascript(fields)}\")", id: 'add_prerequisite')
+    end
+
+    def add_color(status)
+      if status == 'Running'
+        'running'
+      elsif status == 'Queued' || status == 'Waiting'
+        'queued'
+      elsif status =~ /Terminat/ || status == 'Error' || status == 'Failed to Start'
+        'dead'
+      end
+    end
+
+  end
+end

data/app/models/log4r/papertrail_outputter.rb

@@ -0,0 +1,19 @@
+require 'log4r/formatter/patternformatter'
+
+module Log4r
+  class PapertrailOutputter < RemoteSyslogOutputter
+    def initialize(name, options)
+      cloned_options = options.clone
+      unless cloned_options.has_key?('url')
+        if cloned_options.has_key?('port')
+          cloned_options['url'] = "syslog://logs.papertrailapp.com:#{cloned_options['port']}"
+        end
+      end
+      if cloned_options.has_key?('program')
+        program_formatter = Log4r::PatternFormatter.new('pattern' => cloned_options['program'])
+        cloned_options['program'] = program_formatter.format("").chomp
+      end
+      super(name, cloned_options)
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+module Logical
+  module Naf
+    class Application
+
+      attr_reader :app
+
+      include ActionView::Helpers::TextHelper
+
+      COLUMNS = [:id,
+                 :title,
+                 :short_name,
+                 :script_type_name,
+                 :application_run_group_name,
+                 :application_run_group_restriction_name,
+                 :application_run_group_limit,
+                 :enabled,
+                 :enqueue_backlogs,
+                 :run_time,
+                 :affinities,
+                 :prerequisites,
+                 :deleted,
+                 :visible]
+
+      FILTER_FIELDS = [:deleted,
+                       :enabled,
+                       :visible]
+
+      SEARCH_FIELDS = [:title,
+                       :application_run_group_name,
+                       :command,
+                       :short_name]
+
+      def initialize(naf_app)
+        @app = naf_app
+      end
+
+      def self.search(search)
+        application_scope = ::Naf::Application.
+          joins("LEFT JOIN #{::Naf.schema_name}.application_schedules ON #{::Naf.schema_name}.application_schedules.application_id = #{::Naf.schema_name}.applications.id").
+            order("id desc")
+
+        FILTER_FIELDS.each do |field|
+          if search.present? and search[field].present?
+            application_scope =
+            if field == :enabled || field == :visible
+              application_scope.where(application_schedules: { field => search[field] })
+            else
+              application_scope.where(field => search[field])
+            end
+          end
+        end
+
+        SEARCH_FIELDS.each do |field|
+          if search.present? and search[field].present?
+            application_scope =
+            if field == :application_run_group_name
+              application_scope.where(["lower(#{::Naf.schema_name}.application_schedules.application_run_group_name) ~ ?", search[field].downcase])
+            else
+              application_scope.where(["lower(#{field}) ~ ?", search[field].downcase])
+            end
+          end
+        end
+
+        application_scope.map{ |physical_app| new(physical_app) }
+      end
+
+      def to_hash
+        Hash[ COLUMNS.map{ |m| [m, send(m)] } ]
+      end
+
+      def command
+        @app.command
+      end
+
+      def run_start_minute
+        output = ""
+        if schedule = @app.application_schedule and schedule.run_start_minute.present?
+          minutes = schedule.run_start_minute % 60
+          hours =   schedule.run_start_minute / 60
+          output << hours.to_s + ":"
+          output << "%02d" % minutes
+          output = Time.parse(output).strftime("%I:%M %p")
+        end
+
+        return output
+      end
+
+      def run_time
+        run_time = run_start_minute.blank? ? run_interval : run_start_minute
+        run_time = "not scheduled" if run_time.blank?
+
+        run_time
+      end
+
+      def run_interval
+        output = ""
+        if schedule = @app.application_schedule and schedule.run_interval.present?
+          time = schedule.run_interval
+          output =
+          if time == 0
+            "run constantly"
+          elsif time < 60
+            pluralize(time, "minute")
+          elsif time % 60 == 0
+            pluralize(time / 60, "hour")
+          else
+            pluralize(time / 60, "hour") + ', ' + pluralize(time % 60, "minute")
+          end
+        end
+
+        output
+      end
+
+      def prerequisites
+        if schedule = @app.application_schedule and schedule.application_schedule_prerequisites.present?
+          schedule.prerequisites.map do |schedule_prerequisite|
+            schedule_prerequisite.application.short_name_if_it_exist
+          end.join(", \n")
+        end
+      end
+
+      def application_run_group_name
+        if schedule = @app.application_schedule
+          if schedule.application_run_group_name.blank?
+            "not set"
+          else
+            schedule.application_run_group_name
+          end
+        end
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        case method_name
+        when :application_run_group_restriction_name,
+             :application_run_group_name,
+             :run_start_minute,
+             :priority,
+             :application_run_group_limit,
+             :visible,
+             :enabled
+          if schedule = @app.application_schedule
+            schedule.send(method_name, *arguments, &block)
+          else
+            nil
+          end
+        else
+          if @app.respond_to?(method_name)
+            @app.send(method_name, *arguments, &block)
+          else
+            super
+          end
+        end
+      end
+
+      def enqueue_backlogs
+        application_schedule.try(:enqueue_backlogs)
+      end
+
+      def affinities
+        affinity_tab_records = @app.application_schedule.try(:application_schedule_affinity_tabs)
+        return "" if affinity_tab_records.nil?
+
+        affinity_tabs = ""
+        affinity_tab_records.each do |tab|
+          if tab.affinity.affinity_short_name.present?
+            affinity_tabs << tab.affinity.affinity_short_name
+          else
+            affinity_tabs << tab.affinity.affinity_name
+          end
+
+          if tab.affinity_parameter.present? && tab.affinity_parameter > 0
+            affinity_tabs << "(#{tab.affinity_parameter}), "
+          else
+            affinity_tabs << ", "
+          end
+        end
+
+        affinity_tabs[0..-3]
+      end
+
+    end
+  end
+end