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
   6   skip_before_filter :render_404_if_no_object, :only => :queue
   7
   8   def create
   9     [:repository, :script, :script_version, :script_parameters].each do |r|
  10       if !resource_attrs[r]
  11         return render json: {
  12           :errors => ["#{r} attribute must be specified"]
  13         }, status: :unprocessable_entity
  14       end
  15     end
  16
  17     # We used to ask for the minimum_, exclude_, and no_reuse params
  18     # in the job resource. Now we advertise them as flags that alter
  19     # the behavior of the create action.
  20     [:minimum_script_version, :exclude_script_versions].each do |attr|
  21       if resource_attrs.has_key? attr
  22         params[attr] = resource_attrs.delete attr
  23       end
  24     end
  25     if resource_attrs.has_key? :no_reuse
  26       params[:find_or_create] = !resource_attrs.delete(:no_reuse)
  27     end
  28
  29     if params[:find_or_create]
  30       load_filters_param
  31       if @filters.empty?  # Translate older creation parameters into filters.
  32         @filters = [:repository, :script].map do |attrsym|
  33           [attrsym.to_s, "=", resource_attrs[attrsym]]
  34         end
  35         @filters.append(["script_version", "in",
  36                          Commit.find_commit_range(current_user,
  37                                                   resource_attrs[:repository],
  38                                                   params[:minimum_script_version],
  39                                                   resource_attrs[:script_version],
  40                                                   params[:exclude_script_versions])])
  41         if image_search = resource_attrs[:runtime_constraints].andand["docker_image"]
  42           image_tag = resource_attrs[:runtime_constraints]["docker_image_tag"]
  43           image_locator = Collection.
  44             uuids_for_docker_image(image_search, image_tag, @read_users).first
  45           return super if image_locator.nil?  # We won't find anything to reuse.
  46           @filters.append(["docker_image_locator", "=", image_locator])
  47         else
  48           @filters.append(["docker_image_locator", "=", nil])
  49         end
  50       else  # Check specified filters for some reasonableness.
  51         filter_names = @filters.map { |f| f.first }.uniq
  52         ["repository", "script"].each do |req_filter|
  53           if not filter_names.include?(req_filter)
  54             raise ArgumentError.new("#{req_filter} filter required")
  55           end
  56         end
  57       end
  58
  59       # Search for a reusable Job, and return it if found.
  60       @objects = Job.readable_by(current_user)
  61       apply_filters
  62       @object = nil
  63       incomplete_job = nil
  64       @objects.each do |j|
  65         if j.nondeterministic != true and
  66             ((j.success == true and j.output != nil) or j.running == true) and
  67             j.script_parameters == resource_attrs[:script_parameters]
  68           if j.running
  69             # We'll use this if we don't find a job that has completed
  70             incomplete_job ||= j
  71           else
  72             # Record the first job in the list
  73             if !@object
  74               @object = j
  75             end
  76             # Ensure that all candidate jobs actually did produce the same output
  77             if @object.output != j.output
  78               @object = nil
  79               break
  80             end
  81           end
  82         end
  83         @object ||= incomplete_job
  84         if @object
  85           return show
  86         end
  87       end
  88     end
  89
  90     super
  91   end
  92
  93   def cancel
  94     reload_object_before_update
  95     @object.update_attributes! cancelled_at: Time.now
  96     show
  97   end
  98
  99   class LogStreamer
 100     Q_UPDATE_INTERVAL = 12
 101     def initialize(job, opts={})
 102       @job = job
 103       @opts = opts
 104     end
 105     def each
 106       if @job.finished_at
 107         yield "#{@job.uuid} finished at #{@job.finished_at}\n"
 108         return
 109       end
 110       while not @job.started_at
 111         # send a summary (job queue + available nodes) to the client
 112         # every few seconds while waiting for the job to start
 113         last_ack_at ||= Time.now - Q_UPDATE_INTERVAL - 1
 114         if Time.now - last_ack_at >= Q_UPDATE_INTERVAL
 115           nodes_in_state = {idle: 0, alloc: 0}
 116           ActiveRecord::Base.uncached do
 117             Node.where('hostname is not ?', nil).collect do |n|
 118               if n.info[:slurm_state]
 119                 nodes_in_state[n.info[:slurm_state]] ||= 0
 120                 nodes_in_state[n.info[:slurm_state]] += 1
 121               end
 122             end
 123           end
 124           job_queue = Job.queue
 125           n_queued_before_me = 0
 126           job_queue.each do |j|
 127             break if j.uuid == @job.uuid
 128             n_queued_before_me += 1
 129           end
 130           yield "#{Time.now}" \
 131             " job #{@job.uuid}" \
 132             " queue_position #{n_queued_before_me}" \
 133             " queue_size #{job_queue.size}" \
 134             " nodes_idle #{nodes_in_state[:idle]}" \
 135             " nodes_alloc #{nodes_in_state[:alloc]}\n"
 136           last_ack_at = Time.now
 137         end
 138         sleep 3
 139         ActiveRecord::Base.uncached do
 140           @job.reload
 141         end
 142       end
 143     end
 144   end
 145
 146   def queue
 147     params[:order] ||= ['priority desc', 'created_at']
 148     load_limit_offset_order_params
 149     load_where_param
 150     @where.merge!({
 151                     started_at: nil,
 152                     is_locked_by_uuid: nil,
 153                     cancelled_at: nil,
 154                     success: nil
 155                   })
 156     load_filters_param
 157     find_objects_for_index
 158     index
 159   end
 160
 161   def self._queue_requires_parameters
 162     self._index_requires_parameters
 163   end
 164
 165   protected
 166
 167   def load_filters_param
 168     # Convert Job-specific git and Docker filters into normal SQL filters.
 169     super
 170     script_info = {"repository" => nil, "script" => nil}
 171     script_range = {"exclude_versions" => []}
 172     @filters.select! do |filter|
 173       if (script_info.has_key? filter[0]) and (filter[1] == "=")
 174         if script_info[filter[0]].nil?
 175           script_info[filter[0]] = filter[2]
 176         elsif script_info[filter[0]] != filter[2]
 177           raise ArgumentError.new("incompatible #{filter[0]} filters")
 178         end
 179       end
 180       case filter[0..1]
 181       when ["script_version", "in git"]
 182         script_range["min_version"] = filter.last
 183         false
 184       when ["script_version", "not in git"]
 185         begin
 186           script_range["exclude_versions"] += filter.last
 187         rescue TypeError
 188           script_range["exclude_versions"] << filter.last
 189         end
 190         false
 191       when ["docker_image_locator", "in docker"], ["docker_image_locator", "not in docker"]
 192         filter[1].sub!(/ docker$/, '')
 193         search_list = filter[2].is_a?(Enumerable) ? filter[2] : [filter[2]]
 194         filter[2] = search_list.flat_map do |search_term|
 195           image_search, image_tag = search_term.split(':', 2)
 196           Collection.uuids_for_docker_image(image_search, image_tag, @read_users)
 197         end
 198         true
 199       else
 200         true
 201       end
 202     end
 203
 204     # Build a real script_version filter from any "not? in git" filters.
 205     if (script_range.size > 1) or script_range["exclude_versions"].any?
 206       script_info.each_pair do |key, value|
 207         if value.nil?
 208           raise ArgumentError.new("script_version filter needs #{key} filter")
 209         end
 210       end
 211       last_version = begin resource_attrs[:script_version] rescue "HEAD" end
 212       @filters.append(["script_version", "in",
 213                        Commit.find_commit_range(current_user,
 214                                                 script_info["repository"],
 215                                                 script_range["min_version"],
 216                                                 last_version,
 217                                                 script_range["exclude_versions"])])
 218     end
 219   end
 220 end