- # log_reuse_info logs whatever the given block returns, if
- # log_reuse_decisions is enabled. It accepts a block instead of a
- # string because in some cases constructing the strings involves
- # doing database queries, and we want to skip those queries when
- # logging is disabled.
- def self.log_reuse_info
- if Rails.configuration.log_reuse_decisions
- Rails.logger.info("find_reusable: " + yield)
- end
- end
-
- def self.find_reusable attrs, params, filters, read_users
- if filters.empty? # Translate older creation parameters into filters.
- filters =
- [["repository", "=", attrs[:repository]],
- ["script", "=", attrs[:script]],
- ["script_version", "not in git", params[:exclude_script_versions]],
- ].reject { |filter| filter.last.nil? or filter.last.empty? }
- if !params[:minimum_script_version].blank?
- filters << ["script_version", "in git",
- params[:minimum_script_version]]
- else
- filters += default_git_filters("script_version", attrs[:repository],
- attrs[:script_version])
- end
- if image_search = attrs[:runtime_constraints].andand["docker_image"]
- if image_tag = attrs[:runtime_constraints]["docker_image_tag"]
- image_search += ":#{image_tag}"
- end
- image_locator = Collection.
- for_latest_docker_image(image_search).andand.portable_data_hash
- else
- image_locator = nil
- end
- filters << ["docker_image_locator", "=", image_locator]
- if sdk_version = attrs[:runtime_constraints].andand["arvados_sdk_version"]
- filters += default_git_filters("arvados_sdk_version", "arvados", sdk_version)
- end
- filters = load_job_specific_filters(attrs, filters, read_users)
- end
-
- # Check specified filters for some reasonableness.
- filter_names = filters.map { |f| f.first }.uniq
- ["repository", "script"].each do |req_filter|
- if not filter_names.include?(req_filter)
- return send_error("#{req_filter} filter required")
- end
- end
-
- # Search for a reusable Job, and return it if found.
- candidates = Job.readable_by(current_user)
- log_reuse_info { "starting with #{candidates.count} jobs readable by current user #{current_user.uuid}" }
-
- candidates = candidates.where(
- 'state = ? or (owner_uuid = ? and state in (?))',
- Job::Complete, current_user.uuid, [Job::Queued, Job::Running])
- log_reuse_info { "have #{candidates.count} candidates after filtering on job state ((state=Complete) or (state=Queued/Running and (submitted by current user)))" }
-
- digest = Job.sorted_hash_digest(attrs[:script_parameters])
- candidates = candidates.where('script_parameters_digest = ?', digest)
- log_reuse_info { "have #{candidates.count} candidates after filtering on script_parameters_digest #{digest}" }
-
- candidates = candidates.where('nondeterministic is distinct from ?', true)
- log_reuse_info { "have #{candidates.count} candidates after filtering on !nondeterministic" }
-
- # prefer Running jobs over Queued
- candidates = candidates.order('state desc, created_at')
-
- candidates = apply_filters candidates, filters
- log_reuse_info { "have #{candidates.count} candidates after filtering on repo, script, and custom filters #{filters.inspect}" }
-
- chosen = nil
- incomplete_job = nil
- candidates.each do |j|
- if j.state != Job::Complete
- if !incomplete_job
- # We'll use this if we don't find a job that has completed
- log_reuse_info { "job #{j.uuid} is reusable, but unfinished; continuing search for completed jobs" }
- incomplete_job = j
- else
- log_reuse_info { "job #{j.uuid} is unfinished and we already have #{incomplete_job.uuid}; ignoring" }
- end
- elsif chosen == false
- # Ignore: we have already decided not to reuse any completed
- # job.
- log_reuse_info { "job #{j.uuid} with output #{j.output} ignored, see above" }
- elsif Rails.configuration.reuse_job_if_outputs_differ
- if Collection.readable_by(current_user).find_by_portable_data_hash(j.output)
- log_reuse_info { "job #{j.uuid} with output #{j.output} is reusable; decision is final." }
- return j
- else
- # Ignore: keep locking for an incomplete job or one whose
- # output is readable.
- log_reuse_info { "job #{j.uuid} output #{j.output} unavailable to user; continuing search" }
- end
- elsif chosen
- if chosen.output != j.output
- # If two matching jobs produced different outputs, run a new
- # job (or use one that's already running/queued) instead of
- # choosing one arbitrarily.
- log_reuse_info { "job #{j.uuid} output #{j.output} disagrees; forgetting about #{chosen.uuid} and ignoring any other finished jobs (see reuse_job_if_outputs_differ in application.default.yml)" }
- chosen = false
- else
- log_reuse_info { "job #{j.uuid} output #{j.output} agrees with chosen #{chosen.uuid}; continuing search in case other candidates have different outputs" }
- end
- # ...and that's the only thing we need to do once we've chosen
- # a job to reuse.
- elsif !Collection.readable_by(current_user).find_by_portable_data_hash(j.output)
- # This user cannot read the output of this job. Any other
- # completed job will have either the same output (making it
- # unusable) or a different output (making it unusable because
- # reuse_job_if_outputs_different is turned off). Therefore,
- # any further investigation of reusable jobs is futile.
- log_reuse_info { "job #{j.uuid} output #{j.output} is unavailable to user; this means no finished job can be reused (see reuse_job_if_outputs_differ in application.default.yml)" }
- chosen = false
- else
- log_reuse_info { "job #{j.uuid} with output #{j.output} can be reused; continuing search in case other candidates have different outputs" }
- chosen = j
- end
- end
- j = chosen || incomplete_job
- if j
- log_reuse_info { "done, #{j.uuid} was selected" }
- else
- log_reuse_info { "done, nothing suitable" }
- end
- return j
- end
-