X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/d121e087ad1b4e91f869dbd57534c6d6ce51d19d..HEAD:/services/api/app/models/job.rb diff --git a/services/api/app/models/job.rb b/services/api/app/models/job.rb deleted file mode 100644 index 5344d45fbc..0000000000 --- a/services/api/app/models/job.rb +++ /dev/null @@ -1,693 +0,0 @@ -require 'safe_json' - -class Job < ArvadosModel - include HasUuid - include KindAndEtag - include CommonApiTemplate - extend CurrentApiClient - serialize :components, Hash - attr_protected :arvados_sdk_version, :docker_image_locator - serialize :script_parameters, Hash - serialize :runtime_constraints, Hash - serialize :tasks_summary, Hash - before_create :ensure_unique_submit_id - after_commit :trigger_crunch_dispatch_if_cancelled, :on => :update - before_validation :set_priority - before_validation :update_state_from_old_state_attrs - before_validation :update_script_parameters_digest - validate :ensure_script_version_is_commit - validate :find_docker_image_locator - validate :find_arvados_sdk_version - validate :validate_status - validate :validate_state_change - validate :ensure_no_collection_uuids_in_script_params - before_save :tag_version_in_internal_repository - before_save :update_timestamps_when_state_changes - - has_many :commit_ancestors, :foreign_key => :descendant, :primary_key => :script_version - has_many(:nodes, foreign_key: :job_uuid, primary_key: :uuid) - - class SubmitIdReused < StandardError - end - - api_accessible :user, extend: :common do |t| - t.add :submit_id - t.add :priority - t.add :script - t.add :script_parameters - t.add :script_version - t.add :cancelled_at - t.add :cancelled_by_client_uuid - t.add :cancelled_by_user_uuid - t.add :started_at - t.add :finished_at - t.add :output - t.add :success - t.add :running - t.add :state - t.add :is_locked_by_uuid - t.add :log - t.add :runtime_constraints - t.add :tasks_summary - t.add :nondeterministic - t.add :repository - t.add :supplied_script_version - t.add :arvados_sdk_version - t.add :docker_image_locator - t.add :queue_position - t.add :node_uuids - t.add :description - t.add :components - end - - # Supported states for a job - States = [ - (Queued = 'Queued'), - (Running = 'Running'), - (Cancelled = 'Cancelled'), - (Failed = 'Failed'), - (Complete = 'Complete'), - ] - - after_initialize do - @need_crunch_dispatch_trigger = false - end - - def self.limit_index_columns_read - ["components"] - end - - def assert_finished - update_attributes(finished_at: finished_at || db_current_time, - success: success.nil? ? false : success, - running: false) - end - - def node_uuids - nodes.map(&:uuid) - end - - def self.queue - self.where('state = ?', Queued).order('priority desc, created_at') - end - - def queue_position - # We used to report this accurately, but the implementation made queue - # API requests O(n**2) for the size of the queue. See #8800. - # We've soft-disabled it because it's not clear we even want this - # functionality: now that we have Node Manager with support for multiple - # node sizes, "queue position" tells you very little about when a job will - # run. - state == Queued ? 0 : nil - end - - def self.running - self.where('running = ?', true). - order('priority desc, created_at') - end - - def lock locked_by_uuid - with_lock do - unless self.state == Queued and self.is_locked_by_uuid.nil? - raise AlreadyLockedError - end - self.state = Running - self.is_locked_by_uuid = locked_by_uuid - self.save! - end - end - - def update_script_parameters_digest - self.script_parameters_digest = self.class.sorted_hash_digest(script_parameters) - end - - def self.searchable_columns operator - super - ["script_parameters_digest"] - end - - def self.full_text_searchable_columns - super - ["script_parameters_digest"] - end - - def self.load_job_specific_filters attrs, orig_filters, read_users - # Convert Job-specific @filters entries into general SQL filters. - script_info = {"repository" => nil, "script" => nil} - git_filters = Hash.new do |hash, key| - hash[key] = {"max_version" => "HEAD", "exclude_versions" => []} - end - filters = [] - orig_filters.each do |attr, operator, operand| - if (script_info.has_key? attr) and (operator == "=") - if script_info[attr].nil? - script_info[attr] = operand - elsif script_info[attr] != operand - raise ArgumentError.new("incompatible #{attr} filters") - end - end - case operator - when "in git" - git_filters[attr]["min_version"] = operand - when "not in git" - git_filters[attr]["exclude_versions"] += Array.wrap(operand) - when "in docker", "not in docker" - image_hashes = Array.wrap(operand).flat_map do |search_term| - image_search, image_tag = search_term.split(':', 2) - Collection. - find_all_for_docker_image(image_search, image_tag, read_users, filter_compatible_format: false). - map(&:portable_data_hash) - end - filters << [attr, operator.sub(/ docker$/, ""), image_hashes] - else - filters << [attr, operator, operand] - end - end - - # Build a real script_version filter from any "not? in git" filters. - git_filters.each_pair do |attr, filter| - case attr - when "script_version" - script_info.each_pair do |key, value| - if value.nil? - raise ArgumentError.new("script_version filter needs #{key} filter") - end - end - filter["repository"] = script_info["repository"] - if attrs[:script_version] - filter["max_version"] = attrs[:script_version] - else - # Using HEAD, set earlier by the hash default, is fine. - end - when "arvados_sdk_version" - filter["repository"] = "arvados" - else - raise ArgumentError.new("unknown attribute for git filter: #{attr}") - end - revisions = Commit.find_commit_range(filter["repository"], - filter["min_version"], - filter["max_version"], - filter["exclude_versions"]) - if revisions.empty? - raise ArgumentError. - new("error searching #{filter['repository']} from " + - "'#{filter['min_version']}' to '#{filter['max_version']}', " + - "excluding #{filter['exclude_versions']}") - end - filters.append([attr, "in", revisions]) - end - - filters - end - - # 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 - - def self.default_git_filters(attr_name, repo_name, refspec) - # Add a filter to @filters for `attr_name` = the latest commit available - # in `repo_name` at `refspec`. No filter is added if refspec can't be - # resolved. - commits = Commit.find_commit_range(repo_name, nil, refspec, nil) - if commit_hash = commits.first - [[attr_name, "=", commit_hash]] - else - [] - end - end - - def cancel(cascade: false, need_transaction: true) - if need_transaction - ActiveRecord::Base.transaction do - cancel(cascade: cascade, need_transaction: false) - end - return - end - - if self.state.in?([Queued, Running]) - self.state = Cancelled - self.save! - elsif self.state != Cancelled - raise InvalidStateTransitionError - end - - return if !cascade - - # cancel all children; they could be jobs or pipeline instances - children = self.components.andand.collect{|_, u| u}.compact - - return if children.empty? - - # cancel any child jobs - Job.where(uuid: children, state: [Queued, Running]).each do |job| - job.cancel(cascade: cascade, need_transaction: false) - end - - # cancel any child pipelines - PipelineInstance.where(uuid: children, state: [PipelineInstance::RunningOnServer, PipelineInstance::RunningOnClient]).each do |pi| - pi.cancel(cascade: cascade, need_transaction: false) - end - end - - protected - - def self.sorted_hash_digest h - Digest::MD5.hexdigest(Oj.dump(deep_sort_hash(h))) - end - - def foreign_key_attributes - super + %w(output log) - end - - def skip_uuid_read_permission_check - super + %w(cancelled_by_client_uuid) - end - - def skip_uuid_existence_check - super + %w(output log) - end - - def set_priority - if self.priority.nil? - self.priority = 0 - end - true - end - - def ensure_script_version_is_commit - if state == Running - # Apparently client has already decided to go for it. This is - # needed to run a local job using a local working directory - # instead of a commit-ish. - return true - end - if new_record? or repository_changed? or script_version_changed? - sha1 = Commit.find_commit_range(repository, - nil, script_version, nil).first - if not sha1 - errors.add :script_version, "#{script_version} does not resolve to a commit" - return false - end - if supplied_script_version.nil? or supplied_script_version.empty? - self.supplied_script_version = script_version - end - self.script_version = sha1 - end - true - end - - def tag_version_in_internal_repository - if state == Running - # No point now. See ensure_script_version_is_commit. - true - elsif errors.any? - # Won't be saved, and script_version might not even be valid. - true - elsif new_record? or repository_changed? or script_version_changed? - uuid_was = uuid - begin - assign_uuid - Commit.tag_in_internal_repository repository, script_version, uuid - rescue - self.uuid = uuid_was - raise - end - end - end - - def ensure_unique_submit_id - if !submit_id.nil? - if Job.where('submit_id=?',self.submit_id).first - raise SubmitIdReused.new - end - end - true - end - - def resolve_runtime_constraint(key, attr_sym) - if ((runtime_constraints.is_a? Hash) and - (search = runtime_constraints[key])) - ok, result = yield search - else - ok, result = true, nil - end - if ok - send("#{attr_sym}=".to_sym, result) - else - errors.add(attr_sym, result) - end - ok - end - - def find_arvados_sdk_version - resolve_runtime_constraint("arvados_sdk_version", - :arvados_sdk_version) do |git_search| - commits = Commit.find_commit_range("arvados", - nil, git_search, nil) - if commits.empty? - [false, "#{git_search} does not resolve to a commit"] - elsif not runtime_constraints["docker_image"] - [false, "cannot be specified without a Docker image constraint"] - else - [true, commits.first] - end - end - end - - def find_docker_image_locator - if runtime_constraints.is_a? Hash - runtime_constraints['docker_image'] ||= - Rails.configuration.default_docker_image_for_jobs - end - - resolve_runtime_constraint("docker_image", - :docker_image_locator) do |image_search| - image_tag = runtime_constraints['docker_image_tag'] - if coll = Collection.for_latest_docker_image(image_search, image_tag) - [true, coll.portable_data_hash] - else - [false, "not found for #{image_search}"] - end - end - end - - def permission_to_update - if is_locked_by_uuid_was and !(current_user and - (current_user.uuid == is_locked_by_uuid_was or - current_user.uuid == system_user.uuid)) - if script_changed? or - script_parameters_changed? or - script_version_changed? or - (!cancelled_at_was.nil? and - (cancelled_by_client_uuid_changed? or - cancelled_by_user_uuid_changed? or - cancelled_at_changed?)) or - started_at_changed? or - finished_at_changed? or - running_changed? or - success_changed? or - output_changed? or - log_changed? or - tasks_summary_changed? or - (state_changed? && state != Cancelled) or - components_changed? - logger.warn "User #{current_user.uuid if current_user} tried to change protected job attributes on locked #{self.class.to_s} #{uuid_was}" - return false - end - end - if !is_locked_by_uuid_changed? - super - else - if !current_user - logger.warn "Anonymous user tried to change lock on #{self.class.to_s} #{uuid_was}" - false - elsif is_locked_by_uuid_was and is_locked_by_uuid_was != current_user.uuid - logger.warn "User #{current_user.uuid} tried to steal lock on #{self.class.to_s} #{uuid_was} from #{is_locked_by_uuid_was}" - false - elsif !is_locked_by_uuid.nil? and is_locked_by_uuid != current_user.uuid - logger.warn "User #{current_user.uuid} tried to lock #{self.class.to_s} #{uuid_was} with uuid #{is_locked_by_uuid}" - false - else - super - end - end - end - - def update_modified_by_fields - if self.cancelled_at_changed? - # Ensure cancelled_at cannot be set to arbitrary non-now times, - # or changed once it is set. - if self.cancelled_at and not self.cancelled_at_was - self.cancelled_at = db_current_time - self.cancelled_by_user_uuid = current_user.uuid - self.cancelled_by_client_uuid = current_api_client.andand.uuid - @need_crunch_dispatch_trigger = true - else - self.cancelled_at = self.cancelled_at_was - self.cancelled_by_user_uuid = self.cancelled_by_user_uuid_was - self.cancelled_by_client_uuid = self.cancelled_by_client_uuid_was - end - end - super - end - - def trigger_crunch_dispatch_if_cancelled - if @need_crunch_dispatch_trigger - File.open(Rails.configuration.crunch_refresh_trigger, 'wb') do - # That's all, just create/touch a file for crunch-job to see. - end - end - end - - def update_timestamps_when_state_changes - return if not (state_changed? or new_record?) - - case state - when Running - self.started_at ||= db_current_time - when Failed, Complete - self.finished_at ||= db_current_time - when Cancelled - self.cancelled_at ||= db_current_time - end - - # TODO: Remove the following case block when old "success" and - # "running" attrs go away. Until then, this ensures we still - # expose correct success/running flags to older clients, even if - # some new clients are writing only the new state attribute. - case state - when Queued - self.running = false - self.success = nil - when Running - self.running = true - self.success = nil - when Cancelled, Failed - self.running = false - self.success = false - when Complete - self.running = false - self.success = true - end - self.running ||= false # Default to false instead of nil. - - @need_crunch_dispatch_trigger = true - - true - end - - def update_state_from_old_state_attrs - # If a client has touched the legacy state attrs, update the - # "state" attr to agree with the updated values of the legacy - # attrs. - # - # TODO: Remove this method when old "success" and "running" attrs - # go away. - if cancelled_at_changed? or - success_changed? or - running_changed? or - state.nil? - if cancelled_at - self.state = Cancelled - elsif success == false - self.state = Failed - elsif success == true - self.state = Complete - elsif running == true - self.state = Running - else - self.state = Queued - end - end - true - end - - def validate_status - if self.state.in?(States) - true - else - errors.add :state, "#{state.inspect} must be one of: #{States.inspect}" - false - end - end - - def validate_state_change - ok = true - if self.state_changed? - ok = case self.state_was - when nil - # state isn't set yet - true - when Queued - # Permit going from queued to any state - true - when Running - # From running, may only transition to a finished state - [Complete, Failed, Cancelled].include? self.state - when Complete, Failed, Cancelled - # Once in a finished state, don't permit any more state changes - false - else - # Any other state transition is also invalid - false - end - if not ok - errors.add :state, "invalid change from #{self.state_was} to #{self.state}" - end - end - ok - end - - def ensure_no_collection_uuids_in_script_params - # Fail validation if any script_parameters field includes a string containing a - # collection uuid pattern. - if self.script_parameters_changed? - if recursive_hash_search(self.script_parameters, Collection.uuid_regex) - self.errors.add :script_parameters, "must use portable_data_hash instead of collection uuid" - return false - end - end - true - end - - # recursive_hash_search searches recursively through hashes and - # arrays in 'thing' for string fields matching regular expression - # 'pattern'. Returns true if pattern is found, false otherwise. - def recursive_hash_search thing, pattern - if thing.is_a? Hash - thing.each do |k, v| - return true if recursive_hash_search v, pattern - end - elsif thing.is_a? Array - thing.each do |k| - return true if recursive_hash_search k, pattern - end - elsif thing.is_a? String - return true if thing.match pattern - end - false - end -end