services/api/app/models/container_request.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'whitelist_update'
   6
   7 class ContainerRequest < ArvadosModel
   8   include HasUuid
   9   include KindAndEtag
  10   include CommonApiTemplate
  11   include WhitelistUpdate
  12
  13   belongs_to :container, foreign_key: :container_uuid, primary_key: :uuid
  14
  15   serialize :properties, Hash
  16   serialize :environment, Hash
  17   serialize :mounts, Hash
  18   serialize :runtime_constraints, Hash
  19   serialize :command, Array
  20   serialize :scheduling_parameters, Hash
  21   serialize :secret_mounts, Hash
  22
  23   before_validation :fill_field_defaults, :if => :new_record?
  24   before_validation :validate_runtime_constraints
  25   before_validation :validate_scheduling_parameters
  26   before_validation :set_container
  27   validates :command, :container_image, :output_path, :cwd, :presence => true
  28   validates :output_ttl, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
  29   validates :priority, numericality: { only_integer: true, greater_than_or_equal_to: 0, less_than_or_equal_to: 1000 }
  30   validate :validate_state_change
  31   validate :check_update_whitelist
  32   validate :secret_mounts_key_conflict
  33   before_save :scrub_secret_mounts
  34   after_save :update_priority
  35   after_save :finalize_if_needed
  36   before_create :set_requesting_container_uuid
  37   before_destroy :set_priority_zero
  38
  39   api_accessible :user, extend: :common do |t|
  40     t.add :command
  41     t.add :container_count
  42     t.add :container_count_max
  43     t.add :container_image
  44     t.add :container_uuid
  45     t.add :cwd
  46     t.add :description
  47     t.add :environment
  48     t.add :expires_at
  49     t.add :filters
  50     t.add :log_uuid
  51     t.add :mounts
  52     t.add :name
  53     t.add :output_name
  54     t.add :output_path
  55     t.add :output_uuid
  56     t.add :output_ttl
  57     t.add :priority
  58     t.add :properties
  59     t.add :requesting_container_uuid
  60     t.add :runtime_constraints
  61     t.add :scheduling_parameters
  62     t.add :state
  63     t.add :use_existing
  64   end
  65
  66   # Supported states for a container request
  67   States =
  68     [
  69      (Uncommitted = 'Uncommitted'),
  70      (Committed = 'Committed'),
  71      (Final = 'Final'),
  72     ]
  73
  74   State_transitions = {
  75     nil => [Uncommitted, Committed],
  76     Uncommitted => [Committed],
  77     Committed => [Final]
  78   }
  79
  80   AttrsPermittedAlways = [:owner_uuid, :state, :name, :description]
  81   AttrsPermittedBeforeCommit = [:command, :container_count_max,
  82   :container_image, :cwd, :environment, :filters, :mounts,
  83   :output_path, :priority, :properties, :requesting_container_uuid,
  84   :runtime_constraints, :state, :container_uuid, :use_existing,
  85   :scheduling_parameters, :secret_mounts, :output_name, :output_ttl]
  86
  87   def self.limit_index_columns_read
  88     ["mounts"]
  89   end
  90
  91   def logged_attributes
  92     super.except('secret_mounts')
  93   end
  94
  95   def state_transitions
  96     State_transitions
  97   end
  98
  99   def skip_uuid_read_permission_check
 100     # XXX temporary until permissions are sorted out.
 101     %w(modified_by_client_uuid container_uuid requesting_container_uuid)
 102   end
 103
 104   def finalize_if_needed
 105     if state == Committed && Container.find_by_uuid(container_uuid).final?
 106       reload
 107       act_as_system_user do
 108         finalize!
 109       end
 110     end
 111   end
 112
 113   # Finalize the container request after the container has
 114   # finished/cancelled.
 115   def finalize!
 116     out_coll = nil
 117     log_coll = nil
 118     c = Container.find_by_uuid(container_uuid)
 119     ['output', 'log'].each do |out_type|
 120       pdh = c.send(out_type)
 121       next if pdh.nil?
 122       coll_name = "Container #{out_type} for request #{uuid}"
 123       trash_at = nil
 124       if out_type == 'output'
 125         if self.output_name
 126           coll_name = self.output_name
 127         end
 128         if self.output_ttl > 0
 129           trash_at = db_current_time + self.output_ttl
 130         end
 131       end
 132       manifest = Collection.where(portable_data_hash: pdh).first.manifest_text
 133
 134       coll = Collection.new(owner_uuid: owner_uuid,
 135                             manifest_text: manifest,
 136                             portable_data_hash: pdh,
 137                             name: coll_name,
 138                             trash_at: trash_at,
 139                             delete_at: trash_at,
 140                             properties: {
 141                               'type' => out_type,
 142                               'container_request' => uuid,
 143                             })
 144       coll.save_with_unique_name!
 145       if out_type == 'output'
 146         out_coll = coll.uuid
 147       else
 148         log_coll = coll.uuid
 149       end
 150     end
 151     update_attributes!(state: Final, output_uuid: out_coll, log_uuid: log_coll)
 152   end
 153
 154   def self.full_text_searchable_columns
 155     super - ["mounts", "secret_mounts", "secret_mounts_md5"]
 156   end
 157
 158   protected
 159
 160   def fill_field_defaults
 161     self.state ||= Uncommitted
 162     self.environment ||= {}
 163     self.runtime_constraints ||= {}
 164     self.mounts ||= {}
 165     self.cwd ||= "."
 166     self.container_count_max ||= Rails.configuration.container_count_max
 167     self.scheduling_parameters ||= {}
 168     self.output_ttl ||= 0
 169     self.priority ||= 0
 170   end
 171
 172   def set_container
 173     if (container_uuid_changed? and
 174         not current_user.andand.is_admin and
 175         not container_uuid.nil?)
 176       errors.add :container_uuid, "can only be updated to nil."
 177       return false
 178     end
 179     if state_changed? and state == Committed and container_uuid.nil?
 180       self.container_uuid = Container.resolve(self).uuid
 181     end
 182     if self.container_uuid != self.container_uuid_was
 183       if self.container_count_changed?
 184         errors.add :container_count, "cannot be updated directly."
 185         return false
 186       else
 187         self.container_count += 1
 188       end
 189     end
 190   end
 191
 192   def validate_runtime_constraints
 193     case self.state
 194     when Committed
 195       [['vcpus', true],
 196        ['ram', true],
 197        ['keep_cache_ram', false]].each do |k, required|
 198         if !required && !runtime_constraints.include?(k)
 199           next
 200         end
 201         v = runtime_constraints[k]
 202         unless (v.is_a?(Integer) && v > 0)
 203           errors.add(:runtime_constraints,
 204                      "[#{k}]=#{v.inspect} must be a positive integer")
 205         end
 206       end
 207     end
 208   end
 209
 210   def validate_scheduling_parameters
 211     if self.state == Committed
 212       if scheduling_parameters.include? 'partitions' and
 213          (!scheduling_parameters['partitions'].is_a?(Array) ||
 214           scheduling_parameters['partitions'].reject{|x| !x.is_a?(String)}.size !=
 215             scheduling_parameters['partitions'].size)
 216             errors.add :scheduling_parameters, "partitions must be an array of strings"
 217       end
 218     end
 219   end
 220
 221   def check_update_whitelist
 222     permitted = AttrsPermittedAlways.dup
 223
 224     if self.new_record? || self.state_was == Uncommitted
 225       # Allow create-and-commit in a single operation.
 226       permitted.push(*AttrsPermittedBeforeCommit)
 227     end
 228
 229     case self.state
 230     when Committed
 231       permitted.push :priority, :container_count_max, :container_uuid
 232
 233       if self.container_uuid.nil?
 234         self.errors.add :container_uuid, "has not been resolved to a container."
 235       end
 236
 237       if self.priority.nil?
 238         self.errors.add :priority, "cannot be nil"
 239       end
 240
 241       # Allow container count to increment by 1
 242       if (self.container_uuid &&
 243           self.container_uuid != self.container_uuid_was &&
 244           self.container_count == 1 + (self.container_count_was || 0))
 245         permitted.push :container_count
 246       end
 247
 248     when Final
 249       if self.state_was == Committed
 250         # "Cancel" means setting priority=0, state=Committed
 251         permitted.push :priority
 252
 253         if current_user.andand.is_admin
 254           permitted.push :output_uuid, :log_uuid
 255         end
 256       end
 257
 258     end
 259
 260     super(permitted)
 261   end
 262
 263   def secret_mounts_key_conflict
 264     secret_mounts.each do |k, v|
 265       if mounts.has_key?(k)
 266         errors.add(:secret_mounts, 'conflict with non-secret mounts')
 267         return false
 268       end
 269     end
 270   end
 271
 272   def scrub_secret_mounts
 273     if self.state == Final
 274       self.secret_mounts = {}
 275     end
 276   end
 277
 278   def update_priority
 279     if self.state_changed? or
 280         self.priority_changed? or
 281         self.container_uuid_changed?
 282       act_as_system_user do
 283         Container.
 284           where('uuid in (?)',
 285                 [self.container_uuid_was, self.container_uuid].compact).
 286           map(&:update_priority!)
 287       end
 288     end
 289   end
 290
 291   def set_priority_zero
 292     self.update_attributes!(priority: 0) if self.state != Final
 293   end
 294
 295   def set_requesting_container_uuid
 296     return !new_record? if self.requesting_container_uuid   # already set
 297
 298     token_uuid = current_api_client_authorization.andand.uuid
 299     container = Container.where('auth_uuid=?', token_uuid).order('created_at desc').first
 300     if container
 301       self.requesting_container_uuid = container.uuid
 302       self.priority = container.priority
 303     end
 304     true
 305   end
 306 end