8876: when computing cpu and running times, use the work unit's start and finished...

[arvados.git] / apps / workbench / app / models / proxy_work_unit.rb

diff --git a/apps/workbench/app/models/proxy_work_unit.rb b/apps/workbench/app/models/proxy_work_unit.rb
index 1a24cd5d8721aaf99509e85be30a9eacfe5a8bab..95c88c05155de705d37eaca836a4e6443983e607 100644 (file)
--- a/apps/workbench/app/models/proxy_work_unit.rb
+++ b/apps/workbench/app/models/proxy_work_unit.rb
@@ -7,12 +7,12 @@ class ProxyWorkUnit < WorkUnit
   attr_accessor :unreadable_children
 
   def initialize proxied, label
-    self.lbl = label
-    self.proxied = proxied
+    @lbl = label
+    @proxied = proxied
   end
 
   def label
-    self.lbl
+    @lbl
   end
 
   def uuid
@@ -145,22 +145,6 @@ class ProxyWorkUnit < WorkUnit
     end
   end
 
-  def runtime_constraints
-    get(:runtime_constraints)
-  end
-
-  def priority
-    get(:priority)
-  end
-
-  def log_collection
-    get(:log)
-  end
-
-  def output
-    get(:output)
-  end
-
   def children
     []
   end
@@ -170,7 +154,7 @@ class ProxyWorkUnit < WorkUnit
   end
 
   def has_unreadable_children
-    self.unreadable_children
+    @unreadable_children
   end
 
   def readable?
@@ -178,13 +162,171 @@ class ProxyWorkUnit < WorkUnit
     resource_class.where(uuid: [uuid]).first rescue nil
   end
 
+  def link_to_log
+    if state_label.in? ["Complete", "Failed", "Cancelled"]
+      lc = log_collection
+      if lc
+        logCollection = Collection.find? lc
+        if logCollection
+          ApplicationController.helpers.link_to("Log", "#{uri}#Log")
+        else
+          "Log unavailable"
+        end
+      end
+    elsif state_label == "Running"
+      if readable?
+        ApplicationController.helpers.link_to("Log", "#{uri}#Log")
+      else
+        "Log unavailable"
+      end
+    end
+  end
+
+  def walltime
+    if state_label != "Queued"
+      if started_at
+        ((if finished_at then finished_at else Time.now() end) - started_at)
+      end
+    end
+  end
+
+  def cputime
+    if state_label != "Queued"
+      if started_at
+        (runtime_constraints.andand[:min_nodes] || 1) * ((finished_at || Time.now()) - started_at)
+      end
+    end
+  end
+
+  def queuedtime
+    if state_label == "Queued"
+      Time.now - Time.parse(created_at.to_s)
+    end
+  end
+
+  def show_child_summary
+    if state_label == "Running"
+      if child_summary
+        child_summary_str
+      end
+    end
+  end
+
+  def is_running?
+    state_label == 'Running'
+  end
+
+  def is_paused?
+    state_label == 'Paused'
+  end
+
+  def is_finished?
+    state_label.in? ["Complete", "Failed", "Cancelled"]
+  end
+
+  def is_failed?
+    state_label == 'Failed'
+  end
+
+  def show_runtime
+    runningtime = ApplicationController.helpers.determine_wallclock_runtime(if children.any? then children else [@proxied] end)
+
+    walltime = 0
+    if started_at
+      walltime = if finished_at then (finished_at - started_at) else (Time.now - started_at) end
+    end
+
+    resp = '<p>'
+
+    if started_at
+      resp << "This #{title} started at "
+      resp << ApplicationController.helpers.render_localized_date(started_at)
+      resp << ". It "
+      if state_label == 'Complete'
+        resp << "completed in "
+      elsif state_label == 'Failed'
+         resp << "failed after "
+      else
+        resp << "has been active for "
+      end
+
+      if walltime > runningtime
+        resp << ApplicationController.helpers.render_time(walltime, false)
+      else
+       resp << ApplicationController.helpers.render_time(runningtime, false)
+      end
+
+      if finished_at
+        resp << " at "
+        resp << ApplicationController.helpers.render_localized_date(finished_at)
+      end
+      resp << "."
+    else
+      if state_label
+        resp << "This #{title} is "
+        resp << if state_label == 'Running' then 'active' else state_label.downcase end
+        resp << "."
+      end
+    end
+
+    if is_failed?
+      resp << " Check the Log tab for more detail about why it failed."
+    end
+    resp << "</p>"
+
+    resp << "<p>"
+    if state_label
+      resp << "It "
+      if state_label == 'Running'
+        resp << "has run"
+      else
+        resp << "ran"
+      end
+      resp << " for "
+
+      cpu_time = 0
+      if children.any?
+        cpu_time = children.map { |c|
+          if c.started_at
+             (c.runtime_constraints.andand[:min_nodes] || 1) * ((c.finished_at || Time.now()) - c.started_at)
+          else
+            0
+          end
+        }.reduce(:+) || 0
+      else
+        if started_at
+          cpu_time = (runtime_constraints.andand[:min_nodes] || 1) * ((finished_at || Time.now()) - started_at)
+        end
+      end
+
+      resp << ApplicationController.helpers.render_time(runningtime, false)
+      if (walltime - runningtime) > 0
+        resp << "("
+        resp << ApplicationController.helpers.render_time(walltime - runningtime, false)
+        resp << "queued)"
+      end
+      if cpu_time == 0
+        resp << "."
+      else
+        resp << " and used "
+        resp << ApplicationController.helpers.render_time(cpu_time, false)
+        resp << " of node allocation time ("
+        resp << (cpu_time/runningtime).round(1).to_s
+        resp << "&Cross; scaling)."
+      end
+    end
+    resp << "</p>"
+
+    resp
+  end
+
   protected
 
   def get key
-    if self.proxied.respond_to? key
-      self.proxied.send(key)
-    elsif self.proxied.is_a?(Hash)
-      self.proxied[key]
+    if @proxied.respond_to? key
+      @proxied.send(key)
+    elsif @proxied.is_a?(Hash)
+      @proxied[key]
     end
   end
 end