rocketjob_mission_control 4.3.0 → 6.0.0.beta

data/app/helpers/rocket_job_mission_control/application_helper.rb

@@ -1,42 +1,43 @@
 module RocketJobMissionControl
   module ApplicationHelper
     STATE_ICON_MAP = {
-      aborted:   'fas fa-stop',
-      completed: 'fas fa-check',
-      disabled:  'fas fa-stop',
-      enabled:   'fas fa-check',
-      failed:    'fas fa-exclamation-triangle',
-      paused:    'fas fa-pause',
-      pending:   'fas fa-inbox',
-      queued:    'fas fa-inbox',
-      running:   'fas fa-play',
-      sleeping:  'fas fa-hourglass',
-      scheduled: 'fas fa-clock',
-      starting:  'fas fa-cogs',
-      stopping:  'fas fa-stop',
-      zombie:    'fas fa-hourglass'
-    }
+      aborted:   "fas fa-stop",
+      completed: "fas fa-check",
+      disabled:  "fas fa-stop",
+      enabled:   "fas fa-check",
+      failed:    "fas fa-exclamation-triangle",
+      paused:    "fas fa-pause",
+      pending:   "fas fa-inbox",
+      queued:    "fas fa-inbox",
+      running:   "fas fa-play",
+      sleeping:  "fas fa-hourglass",
+      scheduled: "fas fa-clock",
+      starting:  "fas fa-cogs",
+      stopping:  "fas fa-stop",
+      zombie:    "fas fa-hourglass"
+    }.freeze
 
     def state_icon(state)
-      STATE_ICON_MAP[state.to_sym] + ' ' + state.to_s
+      STATE_ICON_MAP[state.to_sym] + " " + state.to_s
     end
 
     def site_title
-      'Rocket Job Mission Control'
+      "Rocket Job Mission Control"
     end
 
     def title
       @page_title ||= params[:controller].to_s.titleize
-      h(@full_title || [@page_title, site_title].compact.join(' | '))
+      h(@full_title || [@page_title, site_title].compact.join(" | "))
     end
 
     def active_page(path)
-      'active' if current_page?(path)
+      "active" if current_page?(path)
     end
 
     def pretty_print_array_or_hash(arguments)
-      return arguments unless arguments.kind_of?(Array) || arguments.kind_of?(Hash)
-      json_string_options = {space: ' ', indent: '  ', array_nl: '<br />', object_nl: '<br />'}
+      return arguments unless arguments.is_a?(Array) || arguments.is_a?(Hash)
+
+      json_string_options = {space: " ", indent: "  ", array_nl: "<br />", object_nl: "<br />"}
       JSON.generate(arguments, json_string_options).html_safe
     end
 
@@ -56,54 +57,71 @@ module RocketJobMissionControl
     end
 
     # Returns the editable field as html for use in editing dynamic fields from a Job class.
-    def editable_field_html(klass, field_name, value, f, include_nil_selectors = false)
+    def editable_field_html(klass, field_name, value, f)
       # When editing a job the values are of the correct type.
       # When editing a dirmon entry values are strings.
       field = klass.fields[field_name.to_s]
-      return unless field && field.type
+      return unless field&.type
 
       placeholder = field.default_val
       placeholder = nil if placeholder.is_a?(Proc)
 
       case field.type.name
-      when 'Symbol', 'String', 'Integer'
+      when "Integer"
+        options = extract_inclusion_values(klass, field_name)
+        f.number_field(field_name, in: options, include_blank: false, value: value, class: "form-control", placeholder: placeholder)
+      when "String", "Symbol", "Mongoid::StringifiedSymbol"
         options = extract_inclusion_values(klass, field_name)
-        str     = "[#{field.type.name}]\n".html_safe
         if options
-          str + f.select(field_name, options, { include_blank: options.include?(nil) || include_nil_selectors, selected: value }, { class: 'selectize form-control' })
+          f.select(field_name, options, {include_blank: options.include?(nil), selected: value}, {class: "selectize form-control"})
         else
-          if field.type.name == 'Integer'
-            str + f.number_field(field_name, value: value, class: 'form-control', placeholder: placeholder)
-          else
-            str + f.text_field(field_name, value: value, class: 'form-control', placeholder: placeholder)
-          end
+          f.text_field(field_name, value: value, class: "form-control", placeholder: placeholder)
         end
-      when 'Hash'
+      when "Boolean", "Mongoid::Boolean"
+        options = extract_inclusion_values(klass, field_name) || [nil, "true", "false"]
+        f.select(field_name, options, {include_blank: options.include?(nil), selected: value}, {class: "selectize form-control"})
+      when "Hash"
         "[JSON Hash]\n".html_safe +
-          f.text_field(field_name, value: value ? value.to_json : '', class: 'form-control', placeholder: '{"key1":"value1", "key2":"value2", "key3":"value3"}')
-      when 'Array'
+          f.text_field(field_name, value: value ? value.to_json : "", class: "form-control", placeholder: '{"key1":"value1", "key2":"value2", "key3":"value3"}')
+      when "Array"
         options = Array(value)
-        "[Array]\n".html_safe +
-          f.select(field_name, options_for_select(options, options), { include_hidden: false }, { class: 'selectize form-control', multiple: true })
-      when 'Mongoid::Boolean'
-        name = "#{field_name}_true".to_sym
-        value = value.to_s
-        str  = '<div class="radio-buttons">'.html_safe
-        str << f.radio_button(field_name, 'true', checked: value == 'true')
-        str << ' '.html_safe + f.label(name, 'true')
-        str << ' '.html_safe + f.radio_button(field_name, 'false', checked: value == 'false')
-        str << ' '.html_safe + f.label(name, 'false')
-        # Allow this field to be unset (nil).
-        if include_nil_selectors
-          str << ' '.html_safe + f.radio_button(field_name, '', checked: value == '')
-          str << ' '.html_safe + f.label(name, 'nil')
-        end
-
-        str << '</div>'.html_safe
+        f.select(field_name, options_for_select(options, options), {include_hidden: false}, {class: "selectize form-control", multiple: true})
       else
         "[#{field.type.name}]".html_safe +
-          f.text_field(field_name, value: value, class: 'form-control', placeholder: placeholder)
+          f.text_field(field_name, value: value, class: "form-control", placeholder: placeholder)
+      end
+    end
+
+    # This method creates a link with `data-id` `data-fields` attributes. These attributes are used to create new instances of the nested fields through Javascript.
+    def link_to_add_fields(name, f, association, option)
+      # Takes an object (@job) and creates a new instance of its associated model (:properties)
+      new_object = f.object.send(association).klass.new
+
+      # Saves the unique ID of the object into a variable.
+      # This is needed to ensure the key of the associated array is unique. This is makes parsing the content in the `data-fields` attribute easier through Javascript.
+      # We could use another method to achive this.
+      id = new_object.object_id
+
+      # https://api.rubyonrails.org/ fields_for(record_name, record_object = nil, fields_options = {}, &block)
+      # record_name = :addresses
+      # record_object = new_object
+      # fields_options = { child_index: id }
+      # child_index` is used to ensure the key of the associated array is unique, and that it matched the value in the `data-id` attribute.
+      # `person[addresses_attributes][child_index_value][_destroy]`
+      fields = f.fields_for(association, new_object, child_index: id) do |builder|
+        # `association.to_s.singularize + "_fields"` ends up evaluating to `address_fields`
+        # The render function will then look for `views/people/_address_fields.html.erb`
+        # The render function also needs to be passed the value of 'builder', because `views/dirmon_entries/_input_categories.html.erb` needs this to render the form tags.
+        render(association.to_s.singularize + "_fields", f: builder)
       end
+
+      # This renders a simple link, but passes information into `data` attributes.
+      # This info can be named anything we want, but in this case we chose `data-id:` and `data-fields:`.
+      # The `id:` is from `new_object.object_id`.
+      # The `fields:` are rendered from the `fields` blocks.
+      # We use `gsub("\n", "")` to remove anywhite space from the rendered partial.
+      # The `id:` value needs to match the value used in `child_index: id`.
+      link_to(name, '#', class: "add_fields btn btn-#{option}", data: { id: id, fields: fields.gsub("\n", "") })
     end
   end
 end

data/app/helpers/rocket_job_mission_control/dirmon_entries_helper.rb

@@ -3,5 +3,13 @@ module RocketJobMissionControl
     def dirmon_counts_by_state(state)
       RocketJob::DirmonEntry.counts_by_state.fetch(state.downcase.to_sym, 0)
     end
+
+
+    def dirmon_entry_find_category(categories, category_name = :main)
+      return unless categories
+
+      categories.each { |category| return category if category_name == (category["name"] || :main).to_sym }
+      nil
+    end
   end
 end

data/app/helpers/rocket_job_mission_control/jobs_helper.rb

@@ -1,5 +1,23 @@
 module RocketJobMissionControl
   module JobsHelper
+    # The fields that RJMC already displays, all other will be rendered under the custom section.
+    DISPLAYED_FIELDS = %w[
+      _id _type
+      completed_at created_at cron_schedule
+      description destroy_on_complete download_encryption
+      exception expires_at
+      failed_at_list failure_count
+      input_categories
+      log_level
+      output_categories output_path
+      percent_complete priority
+      record_count retry_limit run_at
+      started_at state statistics sub_state
+      throttle_group throttle_running_workers
+      upload_file_name
+      worker_name
+    ]
+
     def job_icon(job)
       state = job_state(job)
       state_icon(state)
@@ -15,52 +33,101 @@ module RocketJobMissionControl
       end
     end
 
+    def job_state_name(job)
+      job_state(@job).to_s.camelcase
+    end
+
+    def job_time(time)
+      return "" unless time
+      time.in_time_zone(Time.zone)
+    end
+
+    def job_state_time(job)
+      return job_time(job.run_at) if job.scheduled?
+
+      job_time(job.completed_at || job.started_at || job.created_at )
+      # job_time(job.running? ? job.started_at : job.completed_at)
+    end
+
+    def job_estimated_time_left(job)
+      if job.record_count && job.running? && job.record_count.positive?
+        percent = job.percent_complete
+        if percent >= 5
+          secs = job.seconds.to_f
+          RocketJob.seconds_as_duration((((secs / percent) * 100) - secs))
+        end
+      end
+    end
+
+    def job_records_per_hour(job)
+      return unless job.completed?
+
+      secs = job.seconds.to_f
+      ((job.record_count.to_f / secs) * 60 * 60).round if job.record_count&.positive? && (secs > 0.0)
+    end
+
+    def job_custom_fields(job)
+      attrs = job.attributes.dup
+      DISPLAYED_FIELDS.each { |key| attrs.delete(key) }
+      # Convert time zones for any custom time fields
+      attrs.keys { |key| attrs[key] = attrs[key].in_time_zone(Time.zone) if attrs[key].is_a?(Time) }
+      attrs
+    end
+
     def job_states
       @job_states ||= RocketJob::Job.aasm.states.map { |state| state.name.to_s }
     end
 
     def job_states_with_scheduled
-      @job_states_with_scheduled ||= ['scheduled'] + job_states
+      @job_states_with_scheduled ||= ["scheduled"] + job_states
     end
 
     def job_counts_by_state(state)
       @job_counts ||= begin
-        counts          = RocketJob::Job.counts_by_state
-        counts[:queued] = counts[:queued_now] || 0
-        counts
-      end
+                        counts          = RocketJob::Job.counts_by_state
+                        counts[:queued] = counts[:queued_now] || 0
+                        counts
+                      end
       @job_counts.fetch(state.downcase.to_sym, 0)
     end
 
-    def job_action_link(action, path, http_method=:get)
+    def job_action_link(action, path, http_method = :get)
       link_to(
         action,
         path,
         method: http_method,
         title:  "#{action} job",
-        class:  'btn btn-default',
-        data:   {confirm: t(:confirm, scope: [:job, :action], action: action)}
+        class:  "btn btn-default btn-group",
+        role:   "group",
+        data:   { confirm: t(:confirm, scope: %i[job action], action: action) }
       )
     end
 
-    def job_action_links_for_show(action, path, http_method=:get)
+    def job_action_links_for_show(action, path, http_method = :get)
       link_to(
         action,
         path,
         method: http_method,
         title:  "#{action} job",
-        class:  'btn btn-primary',
-        data:   {confirm: t(:confirm, scope: [:job, :action], action: action)}
+        class:  "btn btn-default btn-group",
+        role:   "group",
+        data:   { confirm: t(:confirm, scope: %i[job action], action: action) }
       )
     end
 
     def job_selected_class(job, selected_job)
       if selected_job.present? && job.id == selected_job.id
-        'selected'
+        "selected"
       else
-        ''
+        ""
       end
     end
 
+    def job_find_category(categories, category_name = :main)
+      return unless categories
+
+      categories.each { |category| return category if category_name == (category["name"] || :main).to_sym }
+      nil
+    end
   end
 end

data/app/helpers/rocket_job_mission_control/pagination_helper.rb

@@ -1,7 +1,7 @@
 module RocketJobMissionControl
   module PaginationHelper
     def page_nav_disabled_class(current_position, boundary)
-      current_position.to_i == boundary.to_i ? 'disabled' : ''
+      current_position.to_i == boundary.to_i ? "disabled" : ""
     end
   end
 end

data/app/helpers/rocket_job_mission_control/servers_helper.rb

@@ -7,7 +7,7 @@ module RocketJobMissionControl
     def server_icon(server)
       state =
         if server.zombie?
-          'zombie'
+          "zombie"
         else
           server.state
         end
@@ -16,14 +16,14 @@ module RocketJobMissionControl
 
     def server_card_class(server)
       if server.zombie?
-        'callout-zombie'
+        "callout-zombie"
       else
         map = {
-          running:  'callout-success',
-          paused:   'callout-warning',
-          stopping: 'callout-alert',
+          running:  "callout-success",
+          paused:   "callout-warning",
+          stopping: "callout-alert"
         }
-        map[server.state] || 'callout-info'
+        map[server.state] || "callout-info"
       end
     end
   end

data/app/helpers/rocket_job_mission_control/slices_helper.rb

@@ -1,9 +1,7 @@
 module RocketJobMissionControl
   module SlicesHelper
-
-    def display_slice_info(slice, encrypted=false)
-      encrypted ? 'encrypted' : pretty_print_array_or_hash(slice.to_a)
+    def display_slice_info(slice, encrypted = false)
+      encrypted ? "encrypted" : pretty_print_array_or_hash(slice.to_a)
     end
-
   end
 end

data/app/models/rocket_job_mission_control/access_policy.rb

@@ -17,7 +17,7 @@ module RocketJobMissionControl
 
       # Stop, Pause, Resume, Destroy (force stop) Rocket Job Servers
       role :operator, {operator: true} do
-        can %i[stop kill pause resume destroy update_all], RocketJob::Server
+        can %i[stop kill pause resume destroy destroy_zombies thread_dump], RocketJob::Server
       end
 
       # Pause, Resume, Retry, Abort, Edit Jobs
@@ -25,9 +25,9 @@ module RocketJobMissionControl
         can %i[edit pause resume retry abort fail update run_now], RocketJob::Job
       end
 
-      # Create, Destroy, Enable, Disable, Edit Dirmon Entries
+      # Create, Destroy, Enable, Disable, Edit, Copy, Replicate Dirmon Entries
       role :dirmon, {dirmon: true} do
-        can %i[create enable disable update edit], RocketJob::DirmonEntry
+        can %i[create enable disable update edit copy replicate], RocketJob::DirmonEntry
       end
 
       # A User can only edit their own jobs
@@ -47,4 +47,3 @@ module RocketJobMissionControl
     end
   end
 end
-

data/app/models/rocket_job_mission_control/authorization.rb

@@ -1,12 +1,13 @@
 module RocketJobMissionControl
   class Authorization
-    ROLES = %i[admin editor operator manager dirmon user view]
+    ROLES = %i[admin editor operator manager dirmon user view].freeze
     attr_accessor *ROLES
     attr_accessor :login
 
     def initialize(roles: [], login: nil)
       @login = login
       return if roles.blank?
+
       invalid_roles = roles - ROLES
       raise(ArgumentError, "Invalid Roles Supplied: #{invalid_roles.inspect}") unless invalid_roles.empty?
 
@@ -19,4 +20,4 @@ module RocketJobMissionControl
       roles.each { |role| public_send("#{role}=", true) }
     end
   end
-end
+end

data/app/models/rocket_job_mission_control/dirmon_sanitizer.rb

@@ -0,0 +1,68 @@
+module RocketJobMissionControl
+  module DirmonSanitizer
+    DIRMON_FIELDS = %i(archive_directory job_class_name name pattern).freeze
+
+    def self.sanitize(params, job_class, target)
+      permissible_params = {}
+
+      DIRMON_FIELDS.each do |field_name|
+        value = params[field_name]
+        next if value.blank?
+
+        permissible_params[field_name] = value
+      end
+
+      if params.key?(:properties)
+        properties                      = JobSanitizer.sanitize(params[:properties], job_class, target, false)
+        permissible_params[:properties] = properties unless properties.blank?
+      end
+
+      permissible_params
+    end
+
+    # Returns [Hash] the difference between the supplied params and those already set in the job itself
+    def self.diff_properties(sanitized_properties, dirmon_entry)
+      default_job = dirmon_entry.job_class.new
+      updated_job = dirmon_entry.job_class.from_properties(sanitized_properties)
+      properties  = {}
+      sanitized_properties&.each_pair do |name, value|
+        if name == :input_categories
+          categories = []
+          value.each do |category_properties|
+            category_name = category_properties[:name].to_sym
+            props         = diff_category(category_properties, updated_job.input_category(category_name), default_job.input_category(category_name))
+            categories << props unless props.empty?
+          end
+          properties[:input_categories] = categories unless categories.empty?
+        elsif name == :output_categories
+          categories = []
+          value.each do |category_properties|
+            category_name = category_properties[:name].to_sym
+            props         = diff_category(category_properties, updated_job.output_category(category_name), default_job.output_category(category_name))
+            categories << props unless props.empty?
+          end
+          properties[:output_categories] = categories unless categories.empty?
+        else
+          properties[name] = value unless default_job.public_send(name) == updated_job.public_send(name)
+        end
+      end
+      properties
+    end
+
+    def self.diff_category(properties, updated_category, default_category)
+      diff = {}
+      name = nil
+      properties&.each_pair do |key, value|
+        if key == :name
+          name = value
+          next
+        end
+        next if updated_category.public_send(key) == default_category.public_send(key)
+
+        diff[key] = value
+      end
+      diff[:name] = name unless diff.empty?
+      diff
+    end
+  end
+end