+# Copyright (C) The Arvados Authors. All rights reserved.
+#
+# SPDX-License-Identifier: AGPL-3.0
+
+require 'log_reuse_info'
require 'whitelist_update'
require 'safe_json'
include CommonApiTemplate
include WhitelistUpdate
extend CurrentApiClient
+ extend DbCurrentTime
+ extend LogReuseInfo
serialize :environment, Hash
serialize :mounts, Hash
serialize :runtime_constraints, Hash
serialize :command, Array
serialize :scheduling_parameters, Hash
+ serialize :secret_mounts, Hash
before_validation :fill_field_defaults, :if => :new_record?
before_validation :set_timestamps
- validates :command, :container_image, :output_path, :cwd, :priority, :presence => true
+ validates :command, :container_image, :output_path, :cwd, :priority, { presence: true }
+ validates :priority, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
validate :validate_state_change
validate :validate_change
validate :validate_lock
validate :validate_output
after_validation :assign_auth
before_save :sort_serialized_attrs
+ before_save :update_secret_mounts_md5
+ before_save :scrub_secret_mounts
after_save :handle_completed
+ after_save :propagate_priority
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
Running => [Complete, Cancelled]
}
+ def self.limit_index_columns_read
+ ["mounts"]
+ end
+
+ def self.full_text_searchable_columns
+ super - ["secret_mounts", "secret_mounts_md5"]
+ end
+
+ def self.searchable_columns *args
+ super - ["secret_mounts_md5"]
+ end
+
+ def logged_attributes
+ super.except('secret_mounts')
+ end
+
def state_transitions
State_transitions
end
+ # Container priority is the highest "computed priority" of any
+ # matching request. The computed priority of a container-submitted
+ # request is the priority of the submitting container. The computed
+ # priority of a user-submitted request is a function of
+ # user-assigned priority and request creation time.
def update_priority!
- if [Queued, Locked, Running].include? self.state
- # Update the priority of this container to the maximum priority of any of
- # its committed container requests and save the record.
- self.priority = ContainerRequest.
- where(container_uuid: uuid,
+ return if ![Queued, Locked, Running].include?(state)
+ p = ContainerRequest.
+ where('container_uuid=? and priority>0', uuid).
+ includes(:requesting_container).
+ lock(true).
+ map do |cr|
+ if cr.requesting_container
+ cr.requesting_container.priority
+ else
+ (cr.priority << 50) - (cr.created_at.to_time.to_f * 1000).to_i
+ end
+ end.max || 0
+ update_attributes!(priority: p)
+ end
+
+ def propagate_priority
+ return true unless priority_changed?
+ act_as_system_user do
+ # 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).
+ ContainerRequest.
+ where(requesting_container_uuid: self.uuid,
state: ContainerRequest::Committed).
- maximum('priority')
- self.save!
+ where('container_uuid is not null').
+ includes(:container).
+ map(&:container).
+ map(&:update_priority!)
end
end
mounts: resolve_mounts(req.mounts),
runtime_constraints: resolve_runtime_constraints(req.runtime_constraints),
scheduling_parameters: req.scheduling_parameters,
+ secret_mounts: req.secret_mounts,
}
act_as_system_user do
if req.use_existing && (reusable = find_reusable(c_attrs))
end
def self.find_reusable(attrs)
- candidates = Container.
- where_serialized(:command, attrs[:command]).
- where('cwd = ?', attrs[:cwd]).
- where_serialized(:environment, attrs[:environment]).
- where('output_path = ?', attrs[:output_path]).
- where('container_image = ?', resolve_container_image(attrs[:container_image])).
- where_serialized(:mounts, resolve_mounts(attrs[:mounts])).
- where_serialized(:runtime_constraints, resolve_runtime_constraints(attrs[:runtime_constraints]))
-
- # Check for Completed candidates whose output and log are both readable.
+ log_reuse_info { "starting with #{Container.all.count} container records in database" }
+ candidates = Container.where_serialized(:command, attrs[:command])
+ 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])
+ log_reuse_info(candidates) { "after filtering on environment #{attrs[:environment].inspect}" }
+
+ candidates = candidates.where('output_path = ?', attrs[:output_path])
+ log_reuse_info(candidates) { "after filtering on output_path #{attrs[:output_path].inspect}" }
+
+ image = resolve_container_image(attrs[:container_image])
+ 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]))
+ 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}" }
+
+ candidates = candidates.where_serialized(:runtime_constraints, resolve_runtime_constraints(attrs[:runtime_constraints]))
+ log_reuse_info(candidates) { "after filtering on runtime_constraints #{attrs[:runtime_constraints].inspect}" }
+
+ log_reuse_info { "checking for state=Complete with readable output and log..." }
+
select_readable_pdh = Collection.
readable_by(current_user).
select(:portable_data_hash).
to_sql
- usable = candidates.
- where(state: Complete).
- where(exit_code: 0).
- where("log IN (#{select_readable_pdh})").
- where("output IN (#{select_readable_pdh})").
- order('finished_at ASC').
- limit(1).
- first
- return usable if usable
+
+ usable = candidates.where(state: Complete, exit_code: 0)
+ log_reuse_info(usable) { "with state=Complete, exit_code=0" }
+
+ usable = usable.where("log IN (#{select_readable_pdh})")
+ log_reuse_info(usable) { "with readable log" }
+
+ usable = usable.where("output IN (#{select_readable_pdh})")
+ log_reuse_info(usable) { "with readable output" }
+
+ usable = usable.order('finished_at ASC').limit(1).first
+ if usable
+ log_reuse_info { "done, reusing container #{usable.uuid} with state=Complete" }
+ return usable
+ end
# Check for Running candidates and return the most likely to finish sooner.
+ log_reuse_info { "checking for state=Running..." }
running = candidates.where(state: Running).
- order('progress desc, started_at asc').limit(1).first
- return running if not running.nil?
+ order('progress desc, started_at asc').
+ limit(1).first
+ if running
+ log_reuse_info { "done, reusing container #{running.uuid} with state=Running" }
+ return running
+ else
+ log_reuse_info { "have no containers in Running state" }
+ end
# 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?
+ locked_or_queued = candidates.
+ where("state IN (?)", [Locked, Queued]).
+ order('state asc, priority desc, created_at asc').
+ limit(1).first
+ if locked_or_queued
+ log_reuse_info { "done, reusing container #{locked_or_queued.uuid} with state=#{locked_or_queued.state}" }
+ return locked_or_queued
+ else
+ log_reuse_info { "have no containers in Locked or Queued state" }
+ end
- # No suitable candidate found.
+ log_reuse_info { "done, no reusable container found" }
nil
end
+ def check_lock_fail
+ if self.state != Queued
+ raise LockFailedError.new("cannot lock when #{self.state}")
+ elsif self.priority <= 0
+ raise LockFailedError.new("cannot lock when priority<=0")
+ end
+ end
+
def lock
- with_lock do
- if self.state == Locked
- raise AlreadyLockedError
+ # Check invalid state transitions once before getting the lock
+ # (because it's cheaper that way) and once after getting the lock
+ # (because state might have changed while acquiring the lock).
+ check_lock_fail
+ transaction do
+ begin
+ reload(lock: 'FOR UPDATE NOWAIT')
+ rescue
+ raise LockFailedError.new("cannot lock: other transaction in progress")
end
- self.state = Locked
- self.save!
+ check_lock_fail
+ update_attributes!(state: Locked)
+ end
+ end
+
+ def check_unlock_fail
+ if self.state != Locked
+ raise InvalidStateTransitionError.new("cannot unlock when #{self.state}")
+ elsif self.locked_by_uuid != current_api_client_authorization.uuid
+ raise InvalidStateTransitionError.new("locked by a different token")
end
end
def unlock
- with_lock do
- if self.state == Queued
- raise InvalidStateTransitionError
- end
- self.state = Queued
- self.save!
+ # Check invalid state transitions twice (see lock)
+ check_unlock_fail
+ transaction do
+ reload(lock: 'FOR UPDATE')
+ check_unlock_fail
+ update_attributes!(state: Queued)
end
end
def self.readable_by(*users_list)
- if users_list.select { |u| u.is_admin }.any?
- return self
+ # Load optional keyword arguments, if they exist.
+ if users_list.last.is_a? Hash
+ kwargs = users_list.pop
+ else
+ kwargs = {}
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)
+ Container.where(ContainerRequest.readable_by(*users_list).where("containers.uuid = container_requests.container_uuid").exists)
end
def final?
self.runtime_constraints ||= {}
self.mounts ||= {}
self.cwd ||= "."
- self.priority ||= 1
+ self.priority ||= 0
self.scheduling_parameters ||= {}
end
if self.new_record?
permitted.push(:owner_uuid, :command, :container_image, :cwd,
:environment, :mounts, :output_path, :priority,
- :runtime_constraints, :scheduling_parameters)
+ :runtime_constraints, :scheduling_parameters,
+ :secret_mounts)
end
case self.state
when Running
permitted.push :finished_at, :output, :log
when Queued, Locked
- permitted.push :finished_at
+ permitted.push :finished_at, :log
end
else
# that a container cannot "claim" a collection that it doesn't otherwise
# have access to just by setting the output field to the collection PDH.
if output_changed?
- c = Collection.unscoped do
- Collection.
- readable_by(current_user).
+ c = Collection.
+ readable_by(current_user, {include_trash: true}).
where(portable_data_hash: self.output).
first
- end
if !c
errors.add :output, "collection must exist and be readable by current user."
end
end
end
+ def update_secret_mounts_md5
+ if self.secret_mounts_changed?
+ self.secret_mounts_md5 = Digest::MD5.hexdigest(
+ SafeJSON.dump(self.class.deep_sort_hash(self.secret_mounts)))
+ end
+ end
+
+ def scrub_secret_mounts
+ # 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 = {}
+ end
+ end
+
def handle_completed
# This container is finished so finalize any associated container requests
# that are associated with this container.
cr.with_lock do
# Use row locking because this increments container_count
cr.container_uuid = c.uuid
- cr.save
+ cr.save!
end
end
end
cr.finalize!
end
- # Try to cancel any outstanding container requests made by this container.
- ContainerRequest.where(requesting_container_uuid: uuid,
- state: ContainerRequest::Committed).each do |cr|
- cr.priority = 0
- cr.save
+ # Cancel outstanding container requests made by this container.
+ ContainerRequest.
+ includes(:container).
+ where(requesting_container_uuid: uuid,
+ state: ContainerRequest::Committed).each do |cr|
+ cr.update_attributes!(priority: 0)
+ cr.container.reload
+ if cr.container.state == Container::Queued || cr.container.state == Container::Locked
+ # If the child container hasn't started yet, finalize the
+ # child CR now instead of leaving it "on hold", i.e.,
+ # Queued with priority 0. (OTOH, if the child is already
+ # running, leave it alone so it can get cancelled the
+ # usual way, get a copy of the log collection, etc.)
+ cr.update_attributes!(state: ContainerRequest::Final)
+ end
end
end
end
projects / arvados.git / blobdiff