1 class Job < ArvadosModel
4 include CommonApiTemplate
5 extend CurrentApiClient
6 serialize :components, Hash
7 attr_protected :arvados_sdk_version, :docker_image_locator
8 serialize :script_parameters, Hash
9 serialize :runtime_constraints, Hash
10 serialize :tasks_summary, Hash
11 before_create :ensure_unique_submit_id
12 after_commit :trigger_crunch_dispatch_if_cancelled, :on => :update
13 before_validation :set_priority
14 before_validation :update_state_from_old_state_attrs
15 before_validation :update_script_parameters_digest
16 validate :ensure_script_version_is_commit
17 validate :find_docker_image_locator
18 validate :find_arvados_sdk_version
19 validate :validate_status
20 validate :validate_state_change
21 validate :ensure_no_collection_uuids_in_script_params
22 before_save :tag_version_in_internal_repository
23 before_save :update_timestamps_when_state_changes
25 has_many :commit_ancestors, :foreign_key => :descendant, :primary_key => :script_version
26 has_many(:nodes, foreign_key: :job_uuid, primary_key: :uuid)
28 class SubmitIdReused < StandardError
31 api_accessible :user, extend: :common do |t|
35 t.add :script_parameters
38 t.add :cancelled_by_client_uuid
39 t.add :cancelled_by_user_uuid
46 t.add :is_locked_by_uuid
48 t.add :runtime_constraints
50 t.add :nondeterministic
52 t.add :supplied_script_version
53 t.add :arvados_sdk_version
54 t.add :docker_image_locator
61 # Supported states for a job
64 (Running = 'Running'),
65 (Cancelled = 'Cancelled'),
67 (Complete = 'Complete'),
71 @need_crunch_dispatch_trigger = false
75 update_attributes(finished_at: finished_at || db_current_time,
76 success: success.nil? ? false : success,
85 self.where('state = ?', Queued).order('priority desc, created_at')
89 # We used to report this accurately, but the implementation made queue
90 # API requests O(n**2) for the size of the queue. See #8800.
91 # We've soft-disabled it because it's not clear we even want this
92 # functionality: now that we have Node Manager with support for multiple
93 # node sizes, "queue position" tells you very little about when a job will
95 state == Queued ? 0 : nil
99 self.where('running = ?', true).
100 order('priority desc, created_at')
103 def lock locked_by_uuid
105 unless self.state == Queued and self.is_locked_by_uuid.nil?
106 raise AlreadyLockedError
109 self.is_locked_by_uuid = locked_by_uuid
114 def update_script_parameters_digest
115 self.script_parameters_digest = self.class.sorted_hash_digest(script_parameters)
118 def self.searchable_columns operator
119 super - ["script_parameters_digest"]
122 def self.full_text_searchable_columns
123 super - ["script_parameters_digest"]
126 def self.load_job_specific_filters attrs, orig_filters, read_users
127 # Convert Job-specific @filters entries into general SQL filters.
128 script_info = {"repository" => nil, "script" => nil}
129 git_filters = Hash.new do |hash, key|
130 hash[key] = {"max_version" => "HEAD", "exclude_versions" => []}
133 orig_filters.each do |attr, operator, operand|
134 if (script_info.has_key? attr) and (operator == "=")
135 if script_info[attr].nil?
136 script_info[attr] = operand
137 elsif script_info[attr] != operand
138 raise ArgumentError.new("incompatible #{attr} filters")
143 git_filters[attr]["min_version"] = operand
145 git_filters[attr]["exclude_versions"] += Array.wrap(operand)
146 when "in docker", "not in docker"
147 image_hashes = Array.wrap(operand).flat_map do |search_term|
148 image_search, image_tag = search_term.split(':', 2)
150 find_all_for_docker_image(image_search, image_tag, read_users).
151 map(&:portable_data_hash)
153 filters << [attr, operator.sub(/ docker$/, ""), image_hashes]
155 filters << [attr, operator, operand]
159 # Build a real script_version filter from any "not? in git" filters.
160 git_filters.each_pair do |attr, filter|
162 when "script_version"
163 script_info.each_pair do |key, value|
165 raise ArgumentError.new("script_version filter needs #{key} filter")
168 filter["repository"] = script_info["repository"]
169 if attrs[:script_version]
170 filter["max_version"] = attrs[:script_version]
172 # Using HEAD, set earlier by the hash default, is fine.
174 when "arvados_sdk_version"
175 filter["repository"] = "arvados"
177 raise ArgumentError.new("unknown attribute for git filter: #{attr}")
179 revisions = Commit.find_commit_range(filter["repository"],
180 filter["min_version"],
181 filter["max_version"],
182 filter["exclude_versions"])
185 new("error searching #{filter['repository']} from " +
186 "'#{filter['min_version']}' to '#{filter['max_version']}', " +
187 "excluding #{filter['exclude_versions']}")
189 filters.append([attr, "in", revisions])
195 def self.find_reusable attrs, params, filters, read_users
196 if filters.empty? # Translate older creation parameters into filters.
198 [["repository", "=", attrs[:repository]],
199 ["script", "=", attrs[:script]],
200 ["script_version", "not in git", params[:exclude_script_versions]],
201 ].reject { |filter| filter.last.nil? or filter.last.empty? }
202 if !params[:minimum_script_version].blank?
203 filters << ["script_version", "in git",
204 params[:minimum_script_version]]
206 filters += default_git_filters("script_version", attrs[:repository],
207 attrs[:script_version])
209 if image_search = attrs[:runtime_constraints].andand["docker_image"]
210 if image_tag = attrs[:runtime_constraints]["docker_image_tag"]
211 image_search += ":#{image_tag}"
213 image_locator = Collection.
214 for_latest_docker_image(image_search).andand.portable_data_hash
218 filters << ["docker_image_locator", "=", image_locator]
219 if sdk_version = attrs[:runtime_constraints].andand["arvados_sdk_version"]
220 filters += default_git_filters("arvados_sdk_version", "arvados", sdk_version)
222 filters = load_job_specific_filters(attrs, filters, read_users)
225 # Check specified filters for some reasonableness.
226 filter_names = filters.map { |f| f.first }.uniq
227 ["repository", "script"].each do |req_filter|
228 if not filter_names.include?(req_filter)
229 return send_error("#{req_filter} filter required")
233 # Search for a reusable Job, and return it if found.
235 readable_by(current_user).
236 where('state = ? or (owner_uuid = ? and state in (?))',
237 Job::Complete, current_user.uuid, [Job::Queued, Job::Running]).
238 where('script_parameters_digest = ?', Job.sorted_hash_digest(attrs[:script_parameters])).
239 where('nondeterministic is distinct from ?', true).
240 order('state desc, created_at') # prefer Running jobs over Queued
241 candidates = apply_filters candidates, filters
244 candidates.each do |j|
245 if j.state != Job::Complete
246 # We'll use this if we don't find a job that has completed
252 # We have already decided not to reuse any completed job
255 if chosen.output != j.output
256 # If two matching jobs produced different outputs, run a new
257 # job (or use one that's already running/queued) instead of
258 # choosing one arbitrarily.
261 # ...and that's the only thing we need to do once we've chosen
263 elsif !Collection.readable_by(current_user).find_by_portable_data_hash(j.output)
264 # As soon as the output we will end up returning (if any) is
265 # decided, check whether it will be visible to the user; if
266 # not, any further investigation of reusable jobs is futile.
272 chosen || incomplete_job
275 def self.default_git_filters(attr_name, repo_name, refspec)
276 # Add a filter to @filters for `attr_name` = the latest commit available
277 # in `repo_name` at `refspec`. No filter is added if refspec can't be
279 commits = Commit.find_commit_range(repo_name, nil, refspec, nil)
280 if commit_hash = commits.first
281 [[attr_name, "=", commit_hash]]
287 def cancel(cascade: false, need_transaction: true)
289 ActiveRecord::Base.transaction do
290 cancel(cascade: cascade, need_transaction: false)
295 if self.state.in?([Queued, Running])
296 self.state = Cancelled
298 elsif self.state != Cancelled
299 raise InvalidStateTransitionError
304 # cancel all children; they could be jobs or pipeline instances
305 children = self.components.andand.collect{|_, u| u}.compact
307 return if children.empty?
309 # cancel any child jobs
310 Job.where(uuid: children, state: [Queued, Running]).each do |job|
311 job.cancel(cascade: cascade, need_transaction: false)
314 # cancel any child pipelines
315 PipelineInstance.where(uuid: children, state: [PipelineInstance::RunningOnServer, PipelineInstance::RunningOnClient]).each do |pi|
316 pi.cancel(cascade: cascade, need_transaction: false)
322 def self.sorted_hash_digest h
323 Digest::MD5.hexdigest(Oj.dump(deep_sort_hash(h)))
326 def foreign_key_attributes
327 super + %w(output log)
330 def skip_uuid_read_permission_check
331 super + %w(cancelled_by_client_uuid)
334 def skip_uuid_existence_check
335 super + %w(output log)
339 if self.priority.nil?
345 def ensure_script_version_is_commit
347 # Apparently client has already decided to go for it. This is
348 # needed to run a local job using a local working directory
349 # instead of a commit-ish.
352 if new_record? or repository_changed? or script_version_changed?
353 sha1 = Commit.find_commit_range(repository,
354 nil, script_version, nil).first
356 errors.add :script_version, "#{script_version} does not resolve to a commit"
359 if supplied_script_version.nil? or supplied_script_version.empty?
360 self.supplied_script_version = script_version
362 self.script_version = sha1
367 def tag_version_in_internal_repository
369 # No point now. See ensure_script_version_is_commit.
372 # Won't be saved, and script_version might not even be valid.
374 elsif new_record? or repository_changed? or script_version_changed?
378 Commit.tag_in_internal_repository repository, script_version, uuid
386 def ensure_unique_submit_id
388 if Job.where('submit_id=?',self.submit_id).first
389 raise SubmitIdReused.new
395 def resolve_runtime_constraint(key, attr_sym)
396 if ((runtime_constraints.is_a? Hash) and
397 (search = runtime_constraints[key]))
398 ok, result = yield search
400 ok, result = true, nil
403 send("#{attr_sym}=".to_sym, result)
405 errors.add(attr_sym, result)
410 def find_arvados_sdk_version
411 resolve_runtime_constraint("arvados_sdk_version",
412 :arvados_sdk_version) do |git_search|
413 commits = Commit.find_commit_range("arvados",
414 nil, git_search, nil)
416 [false, "#{git_search} does not resolve to a commit"]
417 elsif not runtime_constraints["docker_image"]
418 [false, "cannot be specified without a Docker image constraint"]
420 [true, commits.first]
425 def find_docker_image_locator
426 runtime_constraints['docker_image'] =
427 Rails.configuration.default_docker_image_for_jobs if ((runtime_constraints.is_a? Hash) and
428 (runtime_constraints['docker_image']).nil? and
429 Rails.configuration.default_docker_image_for_jobs)
430 resolve_runtime_constraint("docker_image",
431 :docker_image_locator) do |image_search|
432 image_tag = runtime_constraints['docker_image_tag']
433 if coll = Collection.for_latest_docker_image(image_search, image_tag)
434 [true, coll.portable_data_hash]
436 [false, "not found for #{image_search}"]
441 def permission_to_update
442 if is_locked_by_uuid_was and !(current_user and
443 (current_user.uuid == is_locked_by_uuid_was or
444 current_user.uuid == system_user.uuid))
445 if script_changed? or
446 script_parameters_changed? or
447 script_version_changed? or
448 (!cancelled_at_was.nil? and
449 (cancelled_by_client_uuid_changed? or
450 cancelled_by_user_uuid_changed? or
451 cancelled_at_changed?)) or
452 started_at_changed? or
453 finished_at_changed? or
458 tasks_summary_changed? or
459 (state_changed? && state != Cancelled) or
461 logger.warn "User #{current_user.uuid if current_user} tried to change protected job attributes on locked #{self.class.to_s} #{uuid_was}"
465 if !is_locked_by_uuid_changed?
469 logger.warn "Anonymous user tried to change lock on #{self.class.to_s} #{uuid_was}"
471 elsif is_locked_by_uuid_was and is_locked_by_uuid_was != current_user.uuid
472 logger.warn "User #{current_user.uuid} tried to steal lock on #{self.class.to_s} #{uuid_was} from #{is_locked_by_uuid_was}"
474 elsif !is_locked_by_uuid.nil? and is_locked_by_uuid != current_user.uuid
475 logger.warn "User #{current_user.uuid} tried to lock #{self.class.to_s} #{uuid_was} with uuid #{is_locked_by_uuid}"
483 def update_modified_by_fields
484 if self.cancelled_at_changed?
485 # Ensure cancelled_at cannot be set to arbitrary non-now times,
486 # or changed once it is set.
487 if self.cancelled_at and not self.cancelled_at_was
488 self.cancelled_at = db_current_time
489 self.cancelled_by_user_uuid = current_user.uuid
490 self.cancelled_by_client_uuid = current_api_client.andand.uuid
491 @need_crunch_dispatch_trigger = true
493 self.cancelled_at = self.cancelled_at_was
494 self.cancelled_by_user_uuid = self.cancelled_by_user_uuid_was
495 self.cancelled_by_client_uuid = self.cancelled_by_client_uuid_was
501 def trigger_crunch_dispatch_if_cancelled
502 if @need_crunch_dispatch_trigger
503 File.open(Rails.configuration.crunch_refresh_trigger, 'wb') do
504 # That's all, just create/touch a file for crunch-job to see.
509 def update_timestamps_when_state_changes
510 return if not (state_changed? or new_record?)
514 self.started_at ||= db_current_time
515 when Failed, Complete
516 self.finished_at ||= db_current_time
518 self.cancelled_at ||= db_current_time
521 # TODO: Remove the following case block when old "success" and
522 # "running" attrs go away. Until then, this ensures we still
523 # expose correct success/running flags to older clients, even if
524 # some new clients are writing only the new state attribute.
532 when Cancelled, Failed
539 self.running ||= false # Default to false instead of nil.
541 @need_crunch_dispatch_trigger = true
546 def update_state_from_old_state_attrs
547 # If a client has touched the legacy state attrs, update the
548 # "state" attr to agree with the updated values of the legacy
551 # TODO: Remove this method when old "success" and "running" attrs
553 if cancelled_at_changed? or
558 self.state = Cancelled
559 elsif success == false
561 elsif success == true
562 self.state = Complete
563 elsif running == true
573 if self.state.in?(States)
576 errors.add :state, "#{state.inspect} must be one of: #{States.inspect}"
581 def validate_state_change
583 if self.state_changed?
584 ok = case self.state_was
586 # state isn't set yet
589 # Permit going from queued to any state
592 # From running, may only transition to a finished state
593 [Complete, Failed, Cancelled].include? self.state
594 when Complete, Failed, Cancelled
595 # Once in a finished state, don't permit any more state changes
598 # Any other state transition is also invalid
602 errors.add :state, "invalid change from #{self.state_was} to #{self.state}"
608 def ensure_no_collection_uuids_in_script_params
609 # Fail validation if any script_parameters field includes a string containing a
610 # collection uuid pattern.
611 if self.script_parameters_changed?
612 if recursive_hash_search(self.script_parameters, Collection.uuid_regex)
613 self.errors.add :script_parameters, "must use portable_data_hash instead of collection uuid"
620 # recursive_hash_search searches recursively through hashes and
621 # arrays in 'thing' for string fields matching regular expression
622 # 'pattern'. Returns true if pattern is found, false otherwise.
623 def recursive_hash_search thing, pattern
626 return true if recursive_hash_search v, pattern
628 elsif thing.is_a? Array
630 return true if recursive_hash_search k, pattern
632 elsif thing.is_a? String
633 return true if thing.match pattern