apps/workbench/app/models/arvados_resource_list.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 class ArvadosResourceList
   6   include ArvadosApiClientHelper
   7   include Enumerable
   8
   9   attr_reader :resource_class
  10
  11   def initialize resource_class=nil
  12     @resource_class = resource_class
  13     @fetch_multiple_pages = true
  14     @arvados_api_token = Thread.current[:arvados_api_token]
  15     @reader_tokens = Thread.current[:reader_tokens]
  16     @results = nil
  17     @count = nil
  18     @offset = 0
  19     @cond = nil
  20     @eager = nil
  21     @select = nil
  22     @orderby_spec = nil
  23     @filters = nil
  24     @distinct = nil
  25     @include_trash = nil
  26     @limit = nil
  27   end
  28
  29   def eager(bool=true)
  30     @eager = bool
  31     self
  32   end
  33
  34   def distinct(bool=true)
  35     @distinct = bool
  36     self
  37   end
  38
  39   def include_trash(option=nil)
  40     @include_trash = option
  41     self
  42   end
  43
  44   def recursive(option=nil)
  45     @recursive = option
  46     self
  47   end
  48
  49   def limit(max_results)
  50     if not max_results.nil? and not max_results.is_a? Integer
  51       raise ArgumentError("argument to limit() must be an Integer or nil")
  52     end
  53     @limit = max_results
  54     self
  55   end
  56
  57   def offset(skip)
  58     @offset = skip
  59     self
  60   end
  61
  62   def order(orderby_spec)
  63     @orderby_spec = orderby_spec
  64     self
  65   end
  66
  67   def select(columns=nil)
  68     # If no column arguments were given, invoke Enumerable#select.
  69     if columns.nil?
  70       super()
  71     else
  72       @select ||= []
  73       @select += columns
  74       self
  75     end
  76   end
  77
  78   def filter _filters
  79     @filters ||= []
  80     @filters += _filters
  81     self
  82   end
  83
  84   def where(cond)
  85     @cond = cond.dup
  86     @cond.keys.each do |uuid_key|
  87       if @cond[uuid_key] and (@cond[uuid_key].is_a? Array or
  88                              @cond[uuid_key].is_a? ArvadosBase)
  89         # Coerce cond[uuid_key] to an array of uuid strings.  This
  90         # allows caller the convenience of passing an array of real
  91         # objects and uuids in cond[uuid_key].
  92         if !@cond[uuid_key].is_a? Array
  93           @cond[uuid_key] = [@cond[uuid_key]]
  94         end
  95         @cond[uuid_key] = @cond[uuid_key].collect do |item|
  96           if item.is_a? ArvadosBase
  97             item.uuid
  98           else
  99             item
 100           end
 101         end
 102       end
 103     end
 104     @cond.keys.select { |x| x.match(/_kind$/) }.each do |kind_key|
 105       if @cond[kind_key].is_a? Class
 106         @cond = @cond.merge({ kind_key => 'arvados#' + arvados_api_client.class_kind(@cond[kind_key]) })
 107       end
 108     end
 109     self
 110   end
 111
 112   # with_count sets the 'count' parameter to 'exact' or 'none' -- see
 113   # https://doc.arvados.org/api/methods.html#index
 114   def with_count(count_param='exact')
 115     @count = count_param
 116     self
 117   end
 118
 119   def fetch_multiple_pages(f)
 120     @fetch_multiple_pages = f
 121     self
 122   end
 123
 124   def results
 125     if !@results
 126       @results = []
 127       self.each_page do |r|
 128         @results.concat r
 129       end
 130     end
 131     @results
 132   end
 133
 134   def results=(r)
 135     @results = r
 136     @items_available = r.items_available if r.respond_to? :items_available
 137     @result_limit = r.limit if r.respond_to? :limit
 138     @result_offset = r.offset if r.respond_to? :offset
 139     @results
 140   end
 141
 142   def to_ary
 143     results
 144   end
 145
 146   def each(&block)
 147     if not @results.nil?
 148       @results.each(&block)
 149     else
 150       self.each_page do |items|
 151         items.each do |i|
 152           block.call i
 153         end
 154       end
 155     end
 156     self
 157   end
 158
 159   def first
 160     results.first
 161   end
 162
 163   def last
 164     results.last
 165   end
 166
 167   def [](*x)
 168     results.send('[]', *x)
 169   end
 170
 171   def |(x)
 172     if x.is_a? Hash
 173       self.to_hash | x
 174     else
 175       results | x.to_ary
 176     end
 177   end
 178
 179   def to_hash
 180     Hash[self.collect { |x| [x.uuid, x] }]
 181   end
 182
 183   def empty?
 184     self.first.nil?
 185   end
 186
 187   def items_available
 188     results
 189     @items_available
 190   end
 191
 192   def result_limit
 193     results
 194     @result_limit
 195   end
 196
 197   def result_offset
 198     results
 199     @result_offset
 200   end
 201
 202   # Obsolete method retained during api transition.
 203   def links_for item_or_uuid, link_class=false
 204     []
 205   end
 206
 207   protected
 208
 209   def each_page
 210     api_params = {
 211       _method: 'GET'
 212     }
 213     api_params[:count] = @count if @count
 214     api_params[:where] = @cond if @cond
 215     api_params[:eager] = '1' if @eager
 216     api_params[:select] = @select if @select
 217     api_params[:order] = @orderby_spec if @orderby_spec
 218     api_params[:filters] = @filters if @filters
 219     api_params[:distinct] = @distinct if @distinct
 220     api_params[:include_trash] = @include_trash if @include_trash
 221     if @fetch_multiple_pages
 222       # Default limit to (effectively) api server's MAX_LIMIT
 223       api_params[:limit] = 2**(0.size*8 - 1) - 1
 224     end
 225
 226     item_count = 0
 227     offset = @offset || 0
 228     @result_limit = nil
 229     @result_offset = nil
 230
 231     begin
 232       api_params[:offset] = offset
 233       api_params[:limit] = (@limit - item_count) if @limit
 234
 235       res = arvados_api_client.api(@resource_class, '', api_params,
 236                                    arvados_api_token: @arvados_api_token,
 237                                    reader_tokens: @reader_tokens)
 238       items = arvados_api_client.unpack_api_response res
 239
 240       @items_available = items.items_available if items.respond_to?(:items_available)
 241       @result_limit = items.limit if (@fetch_multiple_pages == false) and items.respond_to?(:limit)
 242       @result_offset = items.offset if (@fetch_multiple_pages == false) and items.respond_to?(:offset)
 243
 244       break if items.nil? or not items.any?
 245
 246       item_count += items.size
 247       if items.respond_to?(:offset)
 248         offset = items.offset + items.size
 249       else
 250         offset = item_count
 251       end
 252
 253       yield items
 254
 255       break if @limit and item_count >= @limit
 256       break if items.respond_to? :items_available and offset >= items.items_available
 257     end while @fetch_multiple_pages
 258     self
 259   end
 260
 261 end