X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/3f92c7068e94ee3a8f6bbe1907f2dd369c62cd7c..f89de11af2c33d4f56517e818543f72866396e50:/services/api/app/models/container.rb diff --git a/services/api/app/models/container.rb b/services/api/app/models/container.rb index 1dbdb57105..527881ba6e 100644 --- a/services/api/app/models/container.rb +++ b/services/api/app/models/container.rb @@ -5,6 +5,7 @@ require 'log_reuse_info' require 'whitelist_update' require 'safe_json' +require 'update_priority' class Container < ArvadosModel include ArvadosModelUpdates @@ -22,11 +23,13 @@ class Container < ArvadosModel serialize :command, Array serialize :scheduling_parameters, Hash serialize :secret_mounts, Hash + serialize :runtime_status, Hash before_validation :fill_field_defaults, :if => :new_record? before_validation :set_timestamps validates :command, :container_image, :output_path, :cwd, :priority, { presence: true } validates :priority, numericality: { only_integer: true, greater_than_or_equal_to: 0 } + validate :validate_runtime_status validate :validate_state_change validate :validate_change validate :validate_lock @@ -34,9 +37,12 @@ class Container < ArvadosModel after_validation :assign_auth before_save :sort_serialized_attrs before_save :update_secret_mounts_md5 - before_save :scrub_secret_mounts + before_save :scrub_secrets + before_save :clear_runtime_status_when_queued + after_save :update_cr_logs after_save :handle_completed after_save :propagate_priority + after_commit { UpdatePriority.run_update_thread } has_many :container_requests, :foreign_key => :container_uuid, :class_name => 'ContainerRequest', :primary_key => :uuid belongs_to :auth, :class_name => 'ApiClientAuthorization', :foreign_key => :auth_uuid, :primary_key => :uuid @@ -56,10 +62,13 @@ class Container < ArvadosModel t.add :priority t.add :progress t.add :runtime_constraints + t.add :runtime_status t.add :started_at t.add :state t.add :auth_uuid t.add :scheduling_parameters + t.add :runtime_user_uuid + t.add :runtime_auth_scopes end # Supported states for a container @@ -84,15 +93,15 @@ class Container < ArvadosModel end def self.full_text_searchable_columns - super - ["secret_mounts", "secret_mounts_md5"] + super - ["secret_mounts", "secret_mounts_md5", "runtime_token"] end def self.searchable_columns *args - super - ["secret_mounts_md5"] + super - ["secret_mounts_md5", "runtime_token"] end def logged_attributes - super.except('secret_mounts') + super.except('secret_mounts', 'runtime_token') end def state_transitions @@ -126,7 +135,6 @@ class Container < ArvadosModel # Update the priority of child container requests to match new # priority of the parent container (ignoring requests with no # container assigned, because their priority doesn't matter). - ActiveRecord::Base.connection.execute('LOCK container_requests, containers IN EXCLUSIVE MODE') ContainerRequest. where(requesting_container_uuid: self.uuid, state: ContainerRequest::Committed). @@ -140,17 +148,37 @@ class Container < ArvadosModel # Create a new container (or find an existing one) to satisfy the # given container request. def self.resolve(req) - c_attrs = { - command: req.command, - cwd: req.cwd, - environment: req.environment, - output_path: req.output_path, - container_image: resolve_container_image(req.container_image), - mounts: resolve_mounts(req.mounts), - runtime_constraints: resolve_runtime_constraints(req.runtime_constraints), - scheduling_parameters: req.scheduling_parameters, - secret_mounts: req.secret_mounts, - } + if req.runtime_token.nil? + runtime_user = if req.modified_by_user_uuid.nil? + current_user + else + User.find_by_uuid(req.modified_by_user_uuid) + end + runtime_auth_scopes = ["all"] + else + auth = ApiClientAuthorization.validate(token: req.runtime_token) + if auth.nil? + raise ArgumentError.new "Invalid runtime token" + end + runtime_user = User.find_by_id(auth.user_id) + runtime_auth_scopes = auth.scopes + end + c_attrs = act_as_user runtime_user do + { + command: req.command, + cwd: req.cwd, + environment: req.environment, + output_path: req.output_path, + container_image: resolve_container_image(req.container_image), + mounts: resolve_mounts(req.mounts), + runtime_constraints: resolve_runtime_constraints(req.runtime_constraints), + scheduling_parameters: req.scheduling_parameters, + secret_mounts: req.secret_mounts, + runtime_token: req.runtime_token, + runtime_user_uuid: runtime_user.uuid, + runtime_auth_scopes: runtime_auth_scopes + } + end act_as_system_user do if req.use_existing && (reusable = find_reusable(c_attrs)) reusable @@ -227,13 +255,13 @@ class Container < ArvadosModel def self.find_reusable(attrs) log_reuse_info { "starting with #{Container.all.count} container records in database" } - candidates = Container.where_serialized(:command, attrs[:command]) + candidates = Container.where_serialized(:command, attrs[:command], md5: true) log_reuse_info(candidates) { "after filtering on command #{attrs[:command].inspect}" } candidates = candidates.where('cwd = ?', attrs[:cwd]) log_reuse_info(candidates) { "after filtering on cwd #{attrs[:cwd].inspect}" } - candidates = candidates.where_serialized(:environment, attrs[:environment]) + candidates = candidates.where_serialized(:environment, attrs[:environment], md5: true) log_reuse_info(candidates) { "after filtering on environment #{attrs[:environment].inspect}" } candidates = candidates.where('output_path = ?', attrs[:output_path]) @@ -243,15 +271,24 @@ class Container < ArvadosModel candidates = candidates.where('container_image = ?', image) log_reuse_info(candidates) { "after filtering on container_image #{image.inspect} (resolved from #{attrs[:container_image].inspect})" } - candidates = candidates.where_serialized(:mounts, resolve_mounts(attrs[:mounts])) + candidates = candidates.where_serialized(:mounts, resolve_mounts(attrs[:mounts]), md5: true) log_reuse_info(candidates) { "after filtering on mounts #{attrs[:mounts].inspect}" } - candidates = candidates.where('secret_mounts_md5 = ?', Digest::MD5.hexdigest(SafeJSON.dump(self.deep_sort_hash(attrs[:secret_mounts])))) - log_reuse_info(candidates) { "after filtering on mounts #{attrs[:mounts].inspect}" } + secret_mounts_md5 = Digest::MD5.hexdigest(SafeJSON.dump(self.deep_sort_hash(attrs[:secret_mounts]))) + candidates = candidates.where('secret_mounts_md5 = ?', secret_mounts_md5) + log_reuse_info(candidates) { "after filtering on secret_mounts_md5 #{secret_mounts_md5.inspect}" } - candidates = candidates.where_serialized(:runtime_constraints, resolve_runtime_constraints(attrs[:runtime_constraints])) + candidates = candidates.where_serialized(:runtime_constraints, resolve_runtime_constraints(attrs[:runtime_constraints]), md5: true) log_reuse_info(candidates) { "after filtering on runtime_constraints #{attrs[:runtime_constraints].inspect}" } + candidates = candidates.where('runtime_user_uuid = ? or (runtime_user_uuid is NULL and runtime_auth_scopes is NULL)', + attrs[:runtime_user_uuid]) + log_reuse_info(candidates) { "after filtering on runtime_user_uuid #{attrs[:runtime_user_uuid].inspect}" } + + candidates = candidates.where('runtime_auth_scopes = ? or (runtime_user_uuid is NULL and runtime_auth_scopes is NULL)', + SafeJSON.dump(attrs[:runtime_auth_scopes])) + log_reuse_info(candidates) { "after filtering on runtime_auth_scopes #{attrs[:runtime_auth_scopes].inspect}" } + log_reuse_info { "checking for state=Complete with readable output and log..." } select_readable_pdh = Collection. @@ -274,9 +311,10 @@ class Container < ArvadosModel return usable end - # Check for Running candidates and return the most likely to finish sooner. + # Check for non-failing Running candidates and return the most likely to finish sooner. log_reuse_info { "checking for state=Running..." } running = candidates.where(state: Running). + where("(runtime_status->'error') is null"). order('progress desc, started_at asc'). limit(1).first if running @@ -316,10 +354,6 @@ class Container < ArvadosModel # (because state might have changed while acquiring the lock). check_lock_fail transaction do - # Locking involves assigning auth_uuid, which involves looking - # up container requests, so we must lock both tables in the - # proper order to avoid deadlock. - ActiveRecord::Base.connection.execute('LOCK container_requests, containers IN EXCLUSIVE MODE') reload check_lock_fail update_attributes!(state: Locked) @@ -358,6 +392,18 @@ class Container < ArvadosModel [Complete, Cancelled].include?(self.state) end + def self.for_current_token + _, _, _, container_uuid = Thread.current[:token].split('/') + if container_uuid.nil? + Container.where(auth_uuid: current_api_client_authorization.uuid) + else + Container.where('auth_uuid=? or (uuid=? and runtime_token=?)', + current_api_client_authorization.uuid, + container_uuid, + current_api_client_authorization.token) + end + end + protected def fill_field_defaults @@ -374,24 +420,11 @@ class Container < ArvadosModel current_user.andand.is_admin end - def permission_to_update - # Override base permission check to allow auth_uuid to set progress and - # output (only). Whether it is legal to set progress and output in the current - # state has already been checked in validate_change. - current_user.andand.is_admin || - (!current_api_client_authorization.nil? and - [self.auth_uuid, self.locked_by_uuid].include? current_api_client_authorization.uuid) - end - def ensure_owner_uuid_is_permitted - # Override base permission check to allow auth_uuid to set progress and - # output (only). Whether it is legal to set progress and output in the current - # state has already been checked in validate_change. - if !current_api_client_authorization.nil? and self.auth_uuid == current_api_client_authorization.uuid - check_update_whitelist [:progress, :output] - else - super - end + # validate_change ensures owner_uuid can't be changed at all -- + # except during create, which requires admin privileges. Checking + # permission here would be superfluous. + true end def set_timestamps @@ -404,35 +437,52 @@ class Container < ArvadosModel end end + # Check that well-known runtime status keys have desired data types + def validate_runtime_status + [ + 'error', 'errorDetail', 'warning', 'warningDetail', 'activity' + ].each do |k| + if self.runtime_status.andand.include?(k) && !self.runtime_status[k].is_a?(String) + errors.add(:runtime_status, "'#{k}' value must be a string") + end + end + end + def validate_change permitted = [:state] + progress_attrs = [:progress, :runtime_status, :log, :output] + final_attrs = [:exit_code, :finished_at] if self.new_record? permitted.push(:owner_uuid, :command, :container_image, :cwd, :environment, :mounts, :output_path, :priority, :runtime_constraints, :scheduling_parameters, - :secret_mounts) + :secret_mounts, :runtime_token, + :runtime_user_uuid, :runtime_auth_scopes) end case self.state - when Queued, Locked + when Locked + permitted.push :priority, :runtime_status, :log + + when Queued permitted.push :priority when Running - permitted.push :priority, :progress, :output + permitted.push :priority, *progress_attrs if self.state_changed? permitted.push :started_at end when Complete if self.state_was == Running - permitted.push :finished_at, :output, :log, :exit_code + permitted.push *final_attrs, *progress_attrs end when Cancelled case self.state_was when Running - permitted.push :finished_at, :output, :log + permitted.push :finished_at, *progress_attrs when Queued, Locked permitted.push :finished_at, :log end @@ -442,6 +492,15 @@ class Container < ArvadosModel return false end + if current_api_client_authorization.andand.uuid.andand == self.auth_uuid + # The contained process itself can update progress indicators, + # but can't change priority etc. + permitted = permitted & (progress_attrs + final_attrs + [:state] - [:log]) + elsif self.locked_by_uuid && self.locked_by_uuid != current_api_client_authorization.andand.uuid + # When locked, progress fields cannot be updated by the wrong + # dispatcher, even though it has admin privileges. + permitted = permitted - progress_attrs + end check_update_whitelist permitted end @@ -480,9 +539,22 @@ class Container < ArvadosModel end end + def update_cr_logs + # If self.final?, this update is superfluous: the final log/output + # update will be done when handle_completed calls finalize! on + # each requesting CR. + return if self.final? || !self.log_changed? + leave_modified_by_user_alone do + ContainerRequest.where(container_uuid: self.uuid).each do |cr| + cr.update_collections(container: self, collections: ['log']) + cr.save! + end + end + end + def assign_auth if self.auth_uuid_changed? - return errors.add :auth_uuid, 'is readonly' + return errors.add :auth_uuid, 'is readonly' end if not [Locked, Running].include? self.state # don't need one @@ -493,16 +565,29 @@ class Container < ArvadosModel # already have one return end - cr = ContainerRequest. - where('container_uuid=? and priority>0', self.uuid). - order('priority desc'). - first - if !cr - return errors.add :auth_uuid, "cannot be assigned because priority <= 0" + if self.runtime_token.nil? + if self.runtime_user_uuid.nil? + # legacy behavior, we don't have a runtime_user_uuid so get + # the user from the highest priority container request, needed + # when performing an upgrade and there are queued containers, + # and some tests. + cr = ContainerRequest. + where('container_uuid=? and priority>0', self.uuid). + order('priority desc'). + first + if !cr + return errors.add :auth_uuid, "cannot be assigned because priority <= 0" + end + self.runtime_user_uuid = cr.modified_by_user_uuid + self.runtime_auth_scopes = ["all"] + end + + # generate a new token + self.auth = ApiClientAuthorization. + create!(user_id: User.find_by_uuid(self.runtime_user_uuid).id, + api_client_id: 0, + scopes: self.runtime_auth_scopes) end - self.auth = ApiClientAuthorization. - create!(user_id: User.find_by_uuid(cr.modified_by_user_uuid).id, - api_client_id: 0) end def sort_serialized_attrs @@ -527,12 +612,20 @@ class Container < ArvadosModel end end - def scrub_secret_mounts + def scrub_secrets # this runs after update_secret_mounts_md5, so the # secret_mounts_md5 will still reflect the secrets that are being # scrubbed here. if self.state_changed? && self.final? self.secret_mounts = {} + self.runtime_token = nil + end + end + + def clear_runtime_status_when_queued + # Avoid leaking status messages between different dispatch attempts + if self.state_was == Locked && self.state == Queued + self.runtime_status = {} end end @@ -542,7 +635,6 @@ class Container < ArvadosModel if self.state_changed? and self.final? act_as_system_user do - ActiveRecord::Base.connection.execute('LOCK container_requests, containers IN EXCLUSIVE MODE') if self.state == Cancelled retryable_requests = ContainerRequest.where("container_uuid = ? and priority > 0 and state = 'Committed' and container_count < container_count_max", uuid) else @@ -558,7 +650,11 @@ class Container < ArvadosModel container_image: self.container_image, mounts: self.mounts, runtime_constraints: self.runtime_constraints, - scheduling_parameters: self.scheduling_parameters + scheduling_parameters: self.scheduling_parameters, + secret_mounts: self.secret_mounts_was, + runtime_token: self.runtime_token_was, + runtime_user_uuid: self.runtime_user_uuid, + runtime_auth_scopes: self.runtime_auth_scopes } c = Container.create! c_attrs retryable_requests.each do |cr|