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           :error => "#{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       r = Commit.find_commit_range(current_user,
  31                                    resource_attrs[:repository],
  32                                    params[:minimum_script_version],
  33                                    resource_attrs[:script_version],
  34                                    params[:exclude_script_versions])
  35       # Search for jobs whose script_version is in the list of commits
  36       # returned by find_commit_range
  37       @object = nil
  38       incomplete_job = nil
  39       Job.readable_by(current_user).where(script: resource_attrs[:script],
  40                                           script_version: r).
  41         each do |j|
  42         if j.nondeterministic != true and
  43             ((j.success == true and j.output != nil) or j.running == true) and
  44             j.script_parameters == resource_attrs[:script_parameters]
  45           if j.running
  46             # We'll use this if we don't find a job that has completed
  47             incomplete_job ||= j
  48           else
  49             # Record the first job in the list
  50             if !@object
  51               @object = j
  52             end
  53             # Ensure that all candidate jobs actually did produce the same output
  54             if @object.output != j.output
  55               @object = nil
  56               break
  57             end
  58           end
  59         end
  60         @object ||= incomplete_job
  61         if @object
  62           return show
  63         end
  64       end
  65     end
  66
  67     super
  68   end
  69
  70   def cancel
  71     reload_object_before_update
  72     @object.update_attributes! cancelled_at: Time.now
  73     show
  74   end
  75
  76   class LogStreamer
  77     Q_UPDATE_INTERVAL = 12
  78     def initialize(job, opts={})
  79       @job = job
  80       @opts = opts
  81     end
  82     def each
  83       if @job.finished_at
  84         yield "#{@job.uuid} finished at #{@job.finished_at}\n"
  85         return
  86       end
  87       while not @job.started_at
  88         # send a summary (job queue + available nodes) to the client
  89         # every few seconds while waiting for the job to start
  90         last_ack_at ||= Time.now - Q_UPDATE_INTERVAL - 1
  91         if Time.now - last_ack_at >= Q_UPDATE_INTERVAL
  92           nodes_in_state = {idle: 0, alloc: 0}
  93           ActiveRecord::Base.uncached do
  94             Node.where('hostname is not ?', nil).collect do |n|
  95               if n.info[:slurm_state]
  96                 nodes_in_state[n.info[:slurm_state]] ||= 0
  97                 nodes_in_state[n.info[:slurm_state]] += 1
  98               end
  99             end
 100           end
 101           job_queue = Job.queue
 102           n_queued_before_me = 0
 103           job_queue.each do |j|
 104             break if j.uuid == @job.uuid
 105             n_queued_before_me += 1
 106           end
 107           yield "#{Time.now}" \
 108             " job #{@job.uuid}" \
 109             " queue_position #{n_queued_before_me}" \
 110             " queue_size #{job_queue.size}" \
 111             " nodes_idle #{nodes_in_state[:idle]}" \
 112             " nodes_alloc #{nodes_in_state[:alloc]}\n"
 113           last_ack_at = Time.now
 114         end
 115         sleep 3
 116         ActiveRecord::Base.uncached do
 117           @job.reload
 118         end
 119       end
 120       @redis = Redis.new(:timeout => 0)
 121       if @redis.exists @job.uuid
 122         # A log buffer exists. Start by showing the last few KB.
 123         @redis.
 124           getrange(@job.uuid, 0 - [@opts[:buffer_size], 1].max, -1).
 125           sub(/^[^\n]*\n?/, '').
 126           split("\n").
 127           each do |line|
 128           yield "#{line}\n"
 129         end
 130       end
 131       # TODO: avoid missing log entries between getrange() above and
 132       # subscribe() below.
 133       @redis.subscribe(@job.uuid) do |event|
 134         event.message do |channel, msg|
 135           if msg == "end"
 136             @redis.unsubscribe @job.uuid
 137           else
 138             yield "#{msg}\n"
 139           end
 140         end
 141       end
 142     end
 143   end
 144
 145   def self._log_tail_follow_requires_parameters
 146     {
 147       buffer_size: {type: 'integer', required: false, default: 2**13}
 148     }
 149   end
 150   def log_tail_follow
 151     if !@object.andand.uuid
 152       return render_not_found
 153     end
 154     if client_accepts_plain_text_stream
 155       self.response.headers['Last-Modified'] = Time.now.ctime.to_s
 156       self.response_body = LogStreamer.new @object, {
 157         buffer_size: (params[:buffer_size].to_i rescue 2**13)
 158       }
 159     else
 160       render json: {
 161         href: url_for(uuid: @object.uuid),
 162         comment: ('To retrieve the log stream as plain text, ' +
 163                   'use a request header like "Accept: text/plain"')
 164       }
 165     end
 166   end
 167
 168   def queue
 169     params[:order] ||= ['priority desc', 'created_at']
 170     load_limit_offset_order_params
 171     load_where_param
 172     @where.merge!({
 173                     started_at: nil,
 174                     is_locked_by_uuid: nil,
 175                     cancelled_at: nil,
 176                     success: nil
 177                   })
 178     load_filters_param
 179     find_objects_for_index
 180     index
 181   end
 182
 183   def self._queue_requires_parameters
 184     self._index_requires_parameters
 185   end
 186 end