X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/8100ee8f50d0c8b0340640db10745e44c0f4571b..6c0bf267d795a3ca49c3258c9490714c9e18d333:/services/api/app/models/container.rb diff --git a/services/api/app/models/container.rb b/services/api/app/models/container.rb index 435f5f4df8..a60ea427b7 100644 --- a/services/api/app/models/container.rb +++ b/services/api/app/models/container.rb @@ -5,6 +5,7 @@ class Container < ArvadosModel include KindAndEtag include CommonApiTemplate include WhitelistUpdate + extend CurrentApiClient serialize :environment, Hash serialize :mounts, Hash @@ -85,48 +86,88 @@ class Container < ArvadosModel where('output_path = ?', attrs[:output_path]). where('container_image = ?', attrs[:container_image]). where('mounts = ?', self.deep_sort_hash(attrs[:mounts]).to_yaml). - where('runtime_constraints = ?', self.deep_sort_hash(attrs[:runtime_constraints]).to_yaml). - where('state in (?)', ['Queued', 'Locked', 'Running', 'Complete']). - reject {|c| c.state == 'Complete' and c.exit_code != 0} - - if candidates.empty? - nil - elsif candidates.count == 1 - candidates.first + where('runtime_constraints = ?', self.deep_sort_hash(attrs[:runtime_constraints]).to_yaml) + + # Check for Completed candidates that had consistent outputs. + completed = candidates.where(state: Complete).where(exit_code: 0) + outputs = completed.select('output').group('output').limit(2) + if outputs.count.count != 1 + Rails.logger.debug("Found #{outputs.count.length} different outputs") + elsif Collection. + readable_by(current_user). + where(portable_data_hash: outputs.first.output). + count < 1 + Rails.logger.info("Found reusable container(s) " + + "but output #{outputs.first} is not readable " + + "by user #{current_user.uuid}") else - # Multiple candidates found, search for the best one: - # The most recent completed container - winner = candidates.select {|c| c.state == 'Complete'}.sort_by {|c| c.finished_at}.last - winner if not winner.nil? - # The running container that's most likely to finish sooner. - winner = candidates.select {|c| c.state == 'Running'}. - sort {|a, b| [b.progress, a.started_at] <=> [a.progress, b.started_at]}.first - winner if not winner.nil? - # The locked container that's most likely to start sooner. - winner = candidates.select {|c| c.state == 'Locked'}. - sort {|a, b| [b.priority, a.created_at] <=> [a.priority, b.created_at]}.first - winner if not winner.nil? - # The queued container that's most likely to start sooner. - winner = candidates.select {|c| c.state == 'Queued'}. - sort {|a, b| [b.priority, a.created_at] <=> [a.priority, b.created_at]}.first - winner if not winner.nil? + # Return the oldest eligible container whose log is still + # present and readable by current_user. + readable_pdh = Collection. + readable_by(current_user). + select('portable_data_hash') + completed = completed. + where("log in (#{readable_pdh.to_sql})"). + order('finished_at asc'). + limit(1) + if completed.first + return completed.first + else + Rails.logger.info("Found reusable container(s) but none with a log " + + "readable by user #{current_user.uuid}") + end end + + # Check for Running candidates and return the most likely to finish sooner. + running = candidates.where(state: Running). + order('progress desc, started_at asc').limit(1).first + return running if not running.nil? + + # Check for Locked or Queued ones and return the most likely to start first. + locked_or_queued = candidates.where("state IN (?)", [Locked, Queued]). + order('state asc, priority desc, created_at asc').limit(1).first + return locked_or_queued if not locked_or_queued.nil? + + # No suitable candidate found. + nil end - protected + def lock + with_lock do + if self.state == Locked + raise AlreadyLockedError + end + self.state = Locked + self.save! + end + end - def self.deep_sort_hash(x) - if x.is_a? Hash - x.sort.collect do |k, v| - [k, deep_sort_hash(v)] - end.to_h - elsif x.is_a? Array - x.collect { |v| deep_sort_hash(v) } - else - x + def unlock + with_lock do + if self.state == Queued + raise InvalidStateTransitionError + end + self.state = Queued + self.save! + end + end + + def self.readable_by(*users_list) + if users_list.select { |u| u.is_admin }.any? + return self end + user_uuids = users_list.map { |u| u.uuid } + uuid_list = user_uuids + users_list.flat_map { |u| u.groups_i_can(:read) } + uuid_list.uniq! + permitted = "(SELECT head_uuid FROM links WHERE link_class='permission' AND tail_uuid IN (:uuids))" + joins(:container_requests). + where("container_requests.uuid IN #{permitted} OR "+ + "container_requests.owner_uuid IN (:uuids)", + uuids: uuid_list) end + protected + def fill_field_defaults self.state ||= Queued self.environment ||= {} @@ -250,9 +291,15 @@ class Container < ArvadosModel end def sort_serialized_attrs - self.environment = self.class.deep_sort_hash(self.environment) - self.mounts = self.class.deep_sort_hash(self.mounts) - self.runtime_constraints = self.class.deep_sort_hash(self.runtime_constraints) + if self.environment_changed? + self.environment = self.class.deep_sort_hash(self.environment) + end + if self.mounts_changed? + self.mounts = self.class.deep_sort_hash(self.mounts) + end + if self.runtime_constraints_changed? + self.runtime_constraints = self.class.deep_sort_hash(self.runtime_constraints) + end end def handle_completed @@ -262,13 +309,13 @@ class Container < ArvadosModel act_as_system_user do # Notify container requests associated with this container ContainerRequest.where(container_uuid: uuid, - :state => ContainerRequest::Committed).each do |cr| + state: ContainerRequest::Committed).each do |cr| cr.container_completed! end # Try to cancel any outstanding container requests made by this container. ContainerRequest.where(requesting_container_uuid: uuid, - :state => ContainerRequest::Committed).each do |cr| + state: ContainerRequest::Committed).each do |cr| cr.priority = 0 cr.save end