services/api/app/controllers/arvados/v1/jobs_controller.rb

   1 class Arvados::V1::JobsController < ApplicationController
   2   accept_attribute_as_json :script_parameters, Hash
   3   accept_attribute_as_json :runtime_constraints, Hash
   4   accept_attribute_as_json :tasks_summary, Hash
   5   skip_before_filter :find_object_by_uuid, :only => [:queue, :queue_size]
   6   skip_before_filter :render_404_if_no_object, :only => [:queue, :queue_size]
   7
   8   def create
   9     [:repository, :script, :script_version, :script_parameters].each do |r|
  10       if !resource_attrs[r]
  11         return send_error("#{r} attribute must be specified",
  12                           status: :unprocessable_entity)
  13       end
  14     end
  15
  16     # We used to ask for the minimum_, exclude_, and no_reuse params
  17     # in the job resource. Now we advertise them as flags that alter
  18     # the behavior of the create action.
  19     [:minimum_script_version, :exclude_script_versions].each do |attr|
  20       if resource_attrs.has_key? attr
  21         params[attr] = resource_attrs.delete attr
  22       end
  23     end
  24     if resource_attrs.has_key? :no_reuse
  25       params[:find_or_create] = !resource_attrs.delete(:no_reuse)
  26     end
  27
  28     if params[:find_or_create]
  29       return if false.equal?(load_filters_param)
  30       if @filters.empty?  # Translate older creation parameters into filters.
  31         @filters =
  32           [["repository", "=", resource_attrs[:repository]],
  33            ["script", "=", resource_attrs[:script]],
  34            ["script_version", "in git",
  35             params[:minimum_script_version] || resource_attrs[:script_version]],
  36            ["script_version", "not in git", params[:exclude_script_versions]],
  37           ].reject { |filter| filter.last.nil? or filter.last.empty? }
  38         if image_search = resource_attrs[:runtime_constraints].andand["docker_image"]
  39           if image_tag = resource_attrs[:runtime_constraints]["docker_image_tag"]
  40             image_search += ":#{image_tag}"
  41           end
  42           @filters.append(["docker_image_locator", "in docker", image_search])
  43         else
  44           @filters.append(["docker_image_locator", "=", nil])
  45         end
  46         if sdk_version = resource_attrs[:runtime_constraints].andand["arvados_sdk_version"]
  47           @filters.append(["arvados_sdk_version", "in git", sdk_version])
  48         end
  49         begin
  50           load_job_specific_filters
  51         rescue ArgumentError => error
  52           return send_error(error.message)
  53         end
  54       end
  55
  56       # Check specified filters for some reasonableness.
  57       filter_names = @filters.map { |f| f.first }.uniq
  58       ["repository", "script"].each do |req_filter|
  59         if not filter_names.include?(req_filter)
  60           return send_error("#{req_filter} filter required")
  61         end
  62       end
  63
  64       # Search for a reusable Job, and return it if found.
  65       @objects = Job.readable_by(current_user)
  66       apply_filters
  67       @object = nil
  68       incomplete_job = nil
  69       @objects.each do |j|
  70         if j.nondeterministic != true and
  71             ["Queued", "Running", "Complete"].include?(j.state) and
  72             j.script_parameters == resource_attrs[:script_parameters]
  73           if j.state != "Complete" && j.owner_uuid == current_user.uuid
  74             # We'll use this if we don't find a job that has completed
  75             incomplete_job ||= j
  76           else
  77             if Collection.readable_by(current_user).find_by_portable_data_hash(j.output)
  78               # Record the first job in the list
  79               if !@object
  80                 @object = j
  81               end
  82               # Ensure that all candidate jobs actually did produce the same output
  83               if @object.output != j.output
  84                 @object = nil
  85                 break
  86               end
  87             end
  88           end
  89         end
  90         @object ||= incomplete_job
  91         if @object
  92           return show
  93         end
  94       end
  95     end
  96
  97     super
  98   end
  99
 100   def cancel
 101     reload_object_before_update
 102     @object.update_attributes! state: Job::Cancelled
 103     show
 104   end
 105
 106   def lock
 107     @object.lock current_user.uuid
 108     show
 109   end
 110
 111   class LogStreamer
 112     Q_UPDATE_INTERVAL = 12
 113     def initialize(job, opts={})
 114       @job = job
 115       @opts = opts
 116     end
 117     def each
 118       if @job.finished_at
 119         yield "#{@job.uuid} finished at #{@job.finished_at}\n"
 120         return
 121       end
 122       while not @job.started_at
 123         # send a summary (job queue + available nodes) to the client
 124         # every few seconds while waiting for the job to start
 125         current_time = db_current_time
 126         last_ack_at ||= current_time - Q_UPDATE_INTERVAL - 1
 127         if current_time - last_ack_at >= Q_UPDATE_INTERVAL
 128           nodes_in_state = {idle: 0, alloc: 0}
 129           ActiveRecord::Base.uncached do
 130             Node.where('hostname is not ?', nil).collect do |n|
 131               if n.info[:slurm_state]
 132                 nodes_in_state[n.info[:slurm_state]] ||= 0
 133                 nodes_in_state[n.info[:slurm_state]] += 1
 134               end
 135             end
 136           end
 137           job_queue = Job.queue
 138           n_queued_before_me = 0
 139           job_queue.each do |j|
 140             break if j.uuid == @job.uuid
 141             n_queued_before_me += 1
 142           end
 143           yield "#{db_current_time}" \
 144             " job #{@job.uuid}" \
 145             " queue_position #{n_queued_before_me}" \
 146             " queue_size #{job_queue.size}" \
 147             " nodes_idle #{nodes_in_state[:idle]}" \
 148             " nodes_alloc #{nodes_in_state[:alloc]}\n"
 149           last_ack_at = db_current_time
 150         end
 151         sleep 3
 152         ActiveRecord::Base.uncached do
 153           @job.reload
 154         end
 155       end
 156     end
 157   end
 158
 159   def queue
 160     params[:order] ||= ['priority desc', 'created_at']
 161     load_limit_offset_order_params
 162     load_where_param
 163     @where.merge!({state: Job::Queued})
 164     return if false.equal?(load_filters_param)
 165     find_objects_for_index
 166     index
 167   end
 168
 169   def queue_size
 170     # Users may not be allowed to see all the jobs in the queue, so provide a
 171     # method to get just the queue size in order to get a gist of how busy the
 172     # cluster is.
 173     render :json => {:queue_size => Job.queue.size}
 174   end
 175
 176   def self._create_requires_parameters
 177     (super rescue {}).
 178       merge({
 179               find_or_create: {
 180                 type: 'boolean', required: false, default: false
 181               },
 182               filters: {
 183                 type: 'array', required: false
 184               },
 185               minimum_script_version: {
 186                 type: 'string', required: false
 187               },
 188               exclude_script_versions: {
 189                 type: 'array', required: false
 190               },
 191             })
 192   end
 193
 194   def self._queue_requires_parameters
 195     self._index_requires_parameters
 196   end
 197
 198   protected
 199
 200   def load_job_specific_filters
 201     # Convert Job-specific @filters entries into general SQL filters.
 202     script_info = {"repository" => nil, "script" => nil}
 203     git_filters = Hash.new do |hash, key|
 204       hash[key] = {"max_version" => "HEAD", "exclude_versions" => []}
 205     end
 206     @filters.select! do |(attr, operator, operand)|
 207       if (script_info.has_key? attr) and (operator == "=")
 208         if script_info[attr].nil?
 209           script_info[attr] = operand
 210         elsif script_info[attr] != operand
 211           raise ArgumentError.new("incompatible #{attr} filters")
 212         end
 213       end
 214       case operator
 215       when "in git"
 216         git_filters[attr]["min_version"] = operand
 217         false
 218       when "not in git"
 219         git_filters[attr]["exclude_versions"] += Array.wrap(operand)
 220         false
 221       when "in docker", "not in docker"
 222         image_hashes = Array.wrap(operand).flat_map do |search_term|
 223           image_search, image_tag = search_term.split(':', 2)
 224           Collection.
 225             find_all_for_docker_image(image_search, image_tag, @read_users).
 226             map(&:portable_data_hash)
 227         end
 228         @filters << [attr, operator.sub(/ docker$/, ""), image_hashes]
 229         false
 230       else
 231         true
 232       end
 233     end
 234
 235     # Build a real script_version filter from any "not? in git" filters.
 236     git_filters.each_pair do |attr, filter|
 237       case attr
 238       when "script_version"
 239         script_info.each_pair do |key, value|
 240           if value.nil?
 241             raise ArgumentError.new("script_version filter needs #{key} filter")
 242           end
 243         end
 244         filter["repository"] = script_info["repository"]
 245         begin
 246           filter["max_version"] = resource_attrs[:script_version]
 247         rescue
 248           # Using HEAD, set earlier by the hash default, is fine.
 249         end
 250       when "arvados_sdk_version"
 251         filter["repository"] = "arvados"
 252       else
 253         raise ArgumentError.new("unknown attribute for git filter: #{attr}")
 254       end
 255       version_range = Commit.find_commit_range(current_user,
 256                                                filter["repository"],
 257                                                filter["min_version"],
 258                                                filter["max_version"],
 259                                                filter["exclude_versions"])
 260       if version_range.nil?
 261         raise ArgumentError.
 262           new("error searching #{filter['repository']} from " +
 263               "'#{filter['min_version']}' to '#{filter['max_version']}', " +
 264               "excluding #{filter['exclude_versions']}")
 265       end
 266       @filters.append([attr, "in", version_range])
 267     end
 268   end
 269
 270   def load_filters_param
 271     begin
 272       super
 273       load_job_specific_filters
 274     rescue ArgumentError => error
 275       send_error(error.message)
 276       false
 277     end
 278   end
 279 end