+# Copyright (C) The Arvados Authors. All rights reserved.
+#
+# SPDX-License-Identifier: AGPL-3.0
+
class ProxyWorkUnit < WorkUnit
require 'time'
attr_accessor :my_children
attr_accessor :unreadable_children
- def initialize proxied, label
+ def initialize proxied, label, parent
@lbl = label
@proxied = proxied
+ @parent = parent
end
def label
get(:uuid)
end
+ def parent
+ @parent
+ end
+
def modified_by_user_uuid
get(:modified_by_user_uuid)
end
+ def owner_uuid
+ get(:owner_uuid)
+ end
+
def created_at
t = get(:created_at)
- t = Time.parse(t) if (t.andand.class == String)
+ t = Time.parse(t) if (t.is_a? String)
t
end
def started_at
t = get(:started_at)
- t = Time.parse(t) if (t.andand.class == String)
+ t = Time.parse(t) if (t.is_a? String)
+ t
+ end
+
+ def modified_at
+ t = get(:modified_at)
+ t = Time.parse(t) if (t.is_a? String)
t
end
def finished_at
t = get(:finished_at)
- t = Time.parse(t) if (t.andand.class == String)
+ t = Time.parse(t) if (t.is_a? String)
t
end
state = get(:state)
if ["Running", "RunningOnServer", "RunningOnClient"].include? state
"Running"
+ elsif state == 'New'
+ "Not started"
else
state
end
end
def state_bootstrap_class
- state = get(:state)
+ state = state_label
case state
when 'Complete'
'success'
end
def success?
- state = get(:state)
+ state = state_label
if state == 'Complete'
true
elsif state == 'Failed' or state == 'Cancelled'
end
def progress
- state = get(:state)
+ state = state_label
if state == 'Complete'
return 1.0
elsif state == 'Failed' or state == 'Cancelled'
[]
end
+ def outputs
+ []
+ end
+
def title
"process"
end
@unreadable_children
end
- def readable?
- resource_class = ArvadosBase::resource_class_for_uuid(uuid)
- 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
end
def cputime
- if state_label != "Queued"
+ if children.any?
+ children.map { |c|
+ c.cputime
+ }.reduce(:+) || 0
+ else
if started_at
- (runtime_constraints.andand[:min_nodes] || 1) * ((finished_at || Time.now()) - started_at)
+ (runtime_constraints.andand[:min_nodes] || 1).to_i * ((finished_at || Time.now()) - started_at)
+ else
+ 0
end
end
end
state_label == 'Failed'
end
- def show_runtime
- runningtime = ApplicationController.helpers.determine_wallclock_runtime(if children.any? then children else [self] end)
+ def runtime_contributors
+ contributors = []
+ if children.any?
+ children.each{|c| contributors << c.runtime_contributors}
+ else
+ contributors << self
+ end
+ contributors.flatten
+ end
+ def runningtime
+ ApplicationController.helpers.determine_wallclock_runtime runtime_contributors
+ end
+
+ def show_runtime
walltime = 0
+ running_time = runningtime
if started_at
walltime = if finished_at then (finished_at - started_at) else (Time.now - started_at) end
end
-
resp = '<p>'
if started_at
if state_label == 'Complete'
resp << "completed in "
elsif state_label == 'Failed'
- resp << "failed after "
+ resp << "failed after "
+ elsif state_label == 'Cancelled'
+ resp << "was cancelled 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
+ resp << ApplicationController.helpers.render_time(walltime, false)
if finished_at
resp << " at "
end
if is_failed?
- resp << " Check the Log tab for more detail about why it failed."
+ if runtime_status.andand[:error]
+ resp << " Check the error information below."
+ else
+ resp << " Check the Log tab for more detail about why it failed."
+ end
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 << "It has runtime of "
- resp << ApplicationController.helpers.render_time(runningtime, false)
- if (walltime - runningtime) > 0
+ cpu_time = cputime
+
+ resp << ApplicationController.helpers.render_time(running_time, false)
+ if (walltime - running_time) > 0
resp << "("
- resp << ApplicationController.helpers.render_time(walltime - runningtime, false)
+ resp << ApplicationController.helpers.render_time(walltime - running_time, false)
resp << "queued)"
end
if cpu_time == 0
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 << (cpu_time/running_time).round(1).to_s
resp << "⨯ scaling)."
end
end
resp
end
+ def log_object_uuids
+ [uuid]
+ end
+
+ def live_log_lines(limit)
+ Log.where(object_uuid: log_object_uuids).
+ order("created_at DESC").
+ limit(limit).
+ with_count('none').
+ select { |log| log.properties[:text].is_a? String }.
+ reverse.
+ flat_map { |log| log.properties[:text].split("\n") }
+ end
+
protected
- def get key
- if @proxied.respond_to? key
- @proxied.send(key)
- elsif @proxied.is_a?(Hash)
- @proxied[key]
+ def get key, obj=@proxied
+ if obj.respond_to? key
+ obj.send(key)
+ elsif obj.is_a?(Hash)
+ obj[key] || obj[key.to_s]
end
end
end