rocketjob_mission_control 3.0.0.rc1 → 3.0.0

data/app/controllers/rocket_job_mission_control/servers_controller.rb

@@ -1,40 +1,63 @@
 module RocketJobMissionControl
   class ServersController < RocketJobMissionControl::ApplicationController
-    before_filter :find_server, only: [:stop, :pause, :resume, :destroy]
+    before_filter :find_server_or_redirect, only: [:stop, :pause, :resume, :destroy]
     before_filter :show_sidebar
 
     def index
-      @query = RocketJobMissionControl::Query.new(RocketJob::Server.all, name: :asc)
-      respond_to do |format|
-        format.html
-        format.json { render(json: ServersDatatable.new(view_context, @query)) }
-      end
+      @data_table_url = servers_url(format: 'json')
+      @actions        = [:pause_all, :resume_all, :stop_all, :destroy_zombies]
+      render_datatable(RocketJob::Server.all, 'All')
+    end
+
+    def starting
+      @data_table_url = starting_servers_url(format: 'json')
+      @actions        = [:pause_all, :stop_all]
+      render_datatable(RocketJob::Server.starting, 'Starting')
+    end
+
+    def running
+      @data_table_url = running_servers_url(format: 'json')
+      @actions        = [:pause_all, :stop_all, :destroy_zombies]
+      render_datatable(RocketJob::Server.running, 'Running')
     end
 
-    VALID_STATES = {
-      stop_all:        'stopped',
-      pause_all:       'paused',
-      resume_all:      'resumed',
-      destroy_zombies: 'destroyed if zombified',
-    }
+    def paused
+      @data_table_url = paused_servers_url(format: 'json')
+      @actions        = [:resume_all, :destroy_zombies]
+      render_datatable(RocketJob::Server.paused, 'Paused')
+    end
+
+    def stopping
+      @data_table_url = stopping_servers_url(format: 'json')
+      @actions        = [:destroy_zombies]
+      render_datatable(RocketJob::Server.stopping, 'Stopping')
+    end
+
+    def zombie
+      @data_table_url = zombie_servers_url(format: 'json')
+      @actions        = [:destroy_zombies]
+      render_datatable(RocketJob::Server.zombies, 'Zombie')
+    end
+
+    VALID_ACTIONS = [:stop_all, :pause_all, :resume_all, :destroy_zombies]
 
     def update_all
       server_action = params[:server_action].to_sym
-      if VALID_STATES.keys.include?(server_action)
-        RocketJob::Server.send(server_action.to_sym)
-        flash[:notice] = t(:success, scope: [:server, :update_all], server_action: VALID_STATES[server_action])
+      if VALID_ACTIONS.include?(server_action)
+        RocketJob::Server.public_send(server_action.to_sym)
       else
         flash[:alert] = t(:invalid, scope: [:server, :update_all])
       end
 
+      # TODO: Refresh the same page it was on
       respond_to do |format|
         format.html { redirect_to servers_path }
       end
     end
 
     def stop
-      if @server.stop!
-        flash[:notice] = t(:success, scope: [:server, :stop])
+      if @server.may_stop?
+        @server.stop!
       else
         flash[:alert] = t(:failure, scope: [:server, :stop])
       end
@@ -45,11 +68,8 @@ module RocketJobMissionControl
     end
 
     def destroy
-      if @server.nil? || @server.destroy
-        flash[:notice] = t(:success, scope: [:server, :destroy])
-      else
-        flash[:alert] = t(:failure, scope: [:server, :destroy])
-      end
+      @server.destroy
+      flash[:notice] = t(:success, scope: [:server, :destroy])
 
       respond_to do |format|
         format.html { redirect_to servers_path }
@@ -57,8 +77,8 @@ module RocketJobMissionControl
     end
 
     def pause
-      if @server.pause!
-        flash[:notice] = t(:success, scope: [:server, :pause])
+      if @server.may_pause?
+        @server.pause!
       else
         flash[:alert] = t(:failure, scope: [:server, :pause])
       end
@@ -69,8 +89,8 @@ module RocketJobMissionControl
     end
 
     def resume
-      if @server.resume!
-        flash[:notice] = t(:success, scope: [:server, :resume])
+      if @server.may_resume?
+        @server.resume!
       else
         flash[:alert] = t(:failure, scope: [:server, :resume])
       end
@@ -82,8 +102,31 @@ module RocketJobMissionControl
 
     private
 
-    def find_server
-      @server = RocketJob::Server.find(params[:id])
+    def render_datatable(servers, description)
+      respond_to do |format|
+        format.html do
+          @description = description
+          @states      = RocketJob::Server.aasm.states.map { |s| s.name.to_s }
+          @states << 'zombie'
+
+          @server_counts          = RocketJob::Server.counts_by_state
+          # TODO: Move into RocketJob
+          @server_counts[:zombie] = RocketJob::Server.zombies.count
+          render :index
+        end
+        format.json do
+          query = RocketJobMissionControl::Query.new(servers, name: :asc)
+          render(json: ServersDatatable.new(view_context, query))
+        end
+      end
+    end
+
+    def find_server_or_redirect
+      unless @server = RocketJob::Server.where(id: params[:id]).first
+        flash[:alert] = t(:failure, scope: [:server, :find], id: params[:id])
+
+        redirect_to(servers_path)
+      end
     end
 
     def show_sidebar

data/app/datatables/rocket_job_mission_control/abstract_datatable.rb

@@ -16,13 +16,13 @@ module RocketJobMissionControl
         draw:            params[:draw].to_i,
         recordsTotal:    query.unfiltered_count,
         recordsFiltered: query.count,
-        data:            data(query.query)
+        data:            query.query.collect{|record| map(record)}
       }
     end
 
     private
 
-    def data(records)
+    def map(record)
       raise NotImplementedError
     end
 
@@ -51,7 +51,7 @@ module RocketJobMissionControl
       ap order
       sort_by = {}
       order.each_pair do |key, value|
-        name          = query.display_columns[value[:column].to_i]
+        name = query.display_columns[value[:column].to_i]
         raise(ArgumentError, "Invalid column id: #{value[:column]}. Must fit #{query.display_columns.inspect}") unless name.present?
         sort_by[name] = value[:dir]
       end

data/app/datatables/rocket_job_mission_control/active_workers_datatable.rb

@@ -2,26 +2,20 @@ module RocketJobMissionControl
   class ActiveWorkersDatatable < AbstractDatatable
     delegate :job_path, :state_icon, to: :@view
 
-    def initialize(view, query)
-      super(view, query)
-    end
-
     private
 
     def extract_query_params
       @query.order_by = nil
     end
 
-    def data(active_workers)
-      active_workers.collect do |active_worker|
-        {
-          '0'           => worker_name_with_icon(active_worker, active_worker.job),
-          '1'           => job_name_with_link(active_worker.job.class.name, active_worker.job.id),
-          '2'           => h(active_worker.job.description.try!(:truncate, 50)),
-          '3'           => h("#{active_worker.duration} ago"),
-          'DT_RowClass' => 'card callout callout-running'
-        }
-      end
+    def map(active_worker)
+      {
+        '0'           => worker_name_with_icon(active_worker, active_worker.job),
+        '1'           => job_name_with_link(active_worker.job.class.name, active_worker.job.id),
+        '2'           => h(active_worker.job.description.try!(:truncate, 50)),
+        '3'           => h("#{active_worker.duration} ago"),
+        'DT_RowClass' => 'card callout callout-running'
+      }
     end
 
     def worker_name_with_icon(active_worker, job)

data/app/datatables/rocket_job_mission_control/dirmon_entries_datatable.rb

@@ -2,23 +2,15 @@ module RocketJobMissionControl
   class DirmonEntriesDatatable < AbstractDatatable
     delegate :dirmon_entry_path, :state_icon, to: :@view
 
-    def initialize(view, query)
-      query.display_columns   = %w[name _type pattern]
-      query.search_columns = [:job_class_name, :name, :pattern]
-      super(view, query)
-    end
-
     private
 
-    def data(dirmons)
-      dirmons.map do |dirmon|
-        {
-          '0'           => name_with_link(dirmon),
-          '1'           => h(dirmon.job_class_name),
-          '2'           => h(dirmon.pattern.try(:truncate, 80)),
-          'DT_RowClass' => "card callout callout-#{dirmon.state}"
-        }
-      end
+    def map(dirmon)
+      {
+        '0'           => name_with_link(dirmon),
+        '1'           => h(dirmon.job_class_name),
+        '2'           => h(dirmon.pattern.try(:truncate, 80)),
+        'DT_RowClass' => "card callout callout-#{dirmon.state}"
+      }
     end
 
     def name_with_link(dirmon)

data/app/datatables/rocket_job_mission_control/jobs_datatable.rb

@@ -2,28 +2,92 @@ module RocketJobMissionControl
   class JobsDatatable < AbstractDatatable
     delegate :job_path, :job_icon, :edit_job_path,
       :abort_job_path, :job_path, :fail_job_path, :run_now_job_path, :pause_job_path,
-      :resume_job_path, :retry_job_path, :job_failures_path, :job_action_link, :exceptions_job_path, to: :@view
+      :resume_job_path, :retry_job_path, :exception_job_path, :job_action_link, :exceptions_job_path, to: :@view
 
-    def initialize(view, query)
-      query.search_columns = [:_type, :description]
+    COMMON_FIELDS = [:id, :_type, :description, :completed_at, :created_at, :started_at, :state].freeze
+
+    ABORTED_COLUMNS             = [
+      {display: 'Class', value: :class_with_link, field: '_type', width: '30%'},
+      {display: 'Description', value: :description, field: 'description', width: '30%'},
+      {display: 'Aborted', value: :completed_ago, field: 'completed_at'},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+
+    ALL_COLUMNS                 = [
+      {display: 'Class', value: :class_with_link, field: '_type'},
+      {display: 'Description', value: :description, field: 'description'},
+      {display: 'Created', value: :created_at, field: 'created_at'},
+      {display: 'Duration', value: :duration, field: 'duration', orderable: false},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+    ALL_FIELDS                  = COMMON_FIELDS + [:run_at].freeze
+
+    COMPLETED_COLUMNS           = [
+      {display: 'Class', value: :class_with_link, field: '_type', width: '30%'},
+      {display: 'Description', value: :description, field: 'description', width: '30%'},
+      {display: 'Duration', value: :duration, field: 'duration', orderable: false},
+      {display: 'Completed', value: :completed_ago, field: 'completed_at'},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+
+    FAILED_COLUMNS              = ABORTED_COLUMNS.deep_dup
+    FAILED_COLUMNS[2][:display] = 'Failed'
+
+    PAUSED_COLUMNS              = ABORTED_COLUMNS.deep_dup
+    PAUSED_COLUMNS[2][:display] = 'Paused'
+
+    QUEUED_COLUMNS              = [
+      {display: 'Class', value: :class_with_link, field: '_type'},
+      {display: 'Description', value: :description, field: 'description'},
+      {display: 'Priority', value: :priority, field: 'priority'},
+      {display: 'Queued For', value: :duration, field: 'duration', orderable: false},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+    QUEUED_FIELDS               = COMMON_FIELDS + [:run_at, :priority].freeze
+
+    RUNNING_COLUMNS             = [
+      {display: 'Class', value: :class_with_link, field: '_type'},
+      {display: 'Description', value: :description, field: 'description'},
+      {display: 'Progress', value: :progress, field: 'percent_complete', orderable: false},
+      {display: 'Priority', value: :priority, field: 'priority'},
+      {display: 'Started', value: :started, field: 'started_at'},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+    RUNNING_FIELDS              = COMMON_FIELDS + [:record_count, :collect_output, :input_categories, :output_categories, :encrypt, :compress, :slice_size, :priority, :sub_state, :percent_complete].freeze
+
+    SCHEDULED_COLUMNS           = [
+      {display: 'Class', value: :class_with_link, field: '_type'},
+      {display: 'Description', value: :description, field: 'description'},
+      {display: 'Runs in', value: :time_till_run, field: 'run_at'},
+      {display: 'Cron Schedule', value: :cron_schedule, field: 'cron_schedule'},
+      {display: 'Actions', value: :action_buttons, orderable: false}
+    ]
+    SCHEDULED_FIELDS            = COMMON_FIELDS + [:run_at, :cron_schedule].freeze
+
+    def initialize(view, query, columns)
+      @columns = columns
       super(view, query)
     end
 
     private
 
-    def data(jobs)
-      jobs.map do |job|
-        {
-          '0'           => class_with_link(job),
-          '1'           => h(job.description.try(:truncate, 50)),
-          '2'           => h(job.created_at),
-          '3'           => h(job.duration),
-          '4'           => action_buttons(job),
-          'DT_RowClass' => "card callout callout-#{job.state}"
-        }
+    def sort_column(index)
+      @columns[index.to_i][:field]
+    end
+
+    # Map the values for each column
+    def map(job)
+      index = 0
+      h = {}
+      @columns.each do |column|
+        h[index.to_s] = send(column[:value], job)
+        index += 1
       end
+      h['DT_RowClass'] = "card callout callout-#{job.state}"
+      h
     end
 
+    # Job View Helper methods
     def class_with_link(job)
       <<-EOS
         <a class='job-link' href="#{job_path(job.id)}">
@@ -33,6 +97,57 @@ module RocketJobMissionControl
       EOS
     end
 
+    def description(job)
+      h(job.description.try(:truncate, 50))
+    end
+
+    def duration(job)
+      h(job.duration)
+    end
+
+    def created_at(job)
+      h(job.created_at)
+    end
+
+    def priority(job)
+      h(job.priority)
+    end
+
+    def started(job)
+      "#{RocketJob.seconds_as_duration(Time.now - (job.started_at || Time.now))} ago" if job.started_at
+    end
+
+    def completed_ago(job)
+      "#{RocketJob.seconds_as_duration(Time.now - (job.completed_at || Time.now))} ago"
+    end
+
+    def time_till_run(job)
+      h(RocketJob.seconds_as_duration((job.run_at || Time.now) - Time.now))
+    end
+
+    def cron_schedule(job)
+      h(job.cron_schedule) if job.respond_to?(:cron_schedule)
+    end
+
+    def progress(job)
+      if (sub_state = job.attributes['sub_state']) && [:before, :after].include?(sub_state)
+        <<-EOS
+          <div class="job-status">
+            <div class="job-state">
+              <div class="left">Batch</div>
+              <div class="right running">#{sub_state}</div>
+            </div>
+          </div>
+        EOS
+      else
+        <<-EOS
+          <div class='progress'>
+            <div class='progress-bar' style="width: #{job.percent_complete}%;", title="#{job.percent_complete}% complete."></div>
+          </div>
+        EOS
+      end
+    end
+
     def action_buttons(job)
       events  = valid_events(job)
       buttons = "<div class='inline-job-actions'>"

data/app/datatables/rocket_job_mission_control/servers_datatable.rb

@@ -4,23 +4,21 @@ module RocketJobMissionControl
 
     def initialize(view, query)
       query.display_columns = %w[name heartbeat.workers started_at heartbeat.updated_at]
-      query.search_columns = [:name]
+      query.search_columns  = [:name]
       super(view, query)
     end
 
     private
 
-    def data(servers)
-      servers.collect do |server|
-        {
-          '0'           => name_with_icon(server),
-          '1'           => h(threads(server)),
-          '2'           => h(started_ago(server)),
-          '3'           => h(time_since_heartbeat(server)),
-          '4'           => action_links_html(server),
-          'DT_RowClass' => "card callout #{server_card_class(server)}"
-        }
-      end
+    def map(server)
+      {
+        '0'           => name_with_icon(server),
+        '1'           => h(threads(server)),
+        '2'           => h(started_ago(server)),
+        '3'           => h(time_since_heartbeat(server)),
+        '4'           => action_links_html(server),
+        'DT_RowClass' => "card callout #{server_card_class(server)}"
+      }
     end
 
     def name_with_icon(server)
@@ -31,15 +29,15 @@ module RocketJobMissionControl
     end
 
     def threads(server)
-      "#{server.heartbeat.workers.to_i}/#{server.max_workers}"
+      "#{server.try!(:heartbeat).try!(:workers).to_i}/#{server.max_workers}"
     end
 
     def started_ago(server)
-      "#{RocketJob.seconds_as_duration(Time.now - server.started_at)} ago"
+      "#{RocketJob.seconds_as_duration(Time.now - (server.started_at || Time.now))} ago"
     end
 
     def time_since_heartbeat(server)
-      "#{RocketJob.seconds_as_duration(Time.now - server.heartbeat.updated_at)} ago"
+      "#{RocketJob.seconds_as_duration(Time.now - (server.try!(:heartbeat).try!(:updated_at) || Time.now))} ago"
     end
 
     def action_links_html(server)