apps/workbench/app/models/arvados_base.rb

   1 class ArvadosBase < ActiveRecord::Base
   2   self.abstract_class = true
   3   attr_accessor :attribute_sortkey
   4   attr_accessor :create_params
   5
   6   def self.arvados_api_client
   7     ArvadosApiClient.new_or_current
   8   end
   9
  10   def arvados_api_client
  11     ArvadosApiClient.new_or_current
  12   end
  13
  14   def self.uuid_infix_object_kind
  15     @@uuid_infix_object_kind ||=
  16       begin
  17         infix_kind = {}
  18         arvados_api_client.discovery[:schemas].each do |name, schema|
  19           if schema[:uuidPrefix]
  20             infix_kind[schema[:uuidPrefix]] =
  21               'arvados#' + name.to_s.camelcase(:lower)
  22           end
  23         end
  24
  25         # Recognize obsolete types.
  26         infix_kind.
  27           merge('mxsvm' => 'arvados#pipelineTemplate', # Pipeline
  28                 'uo14g' => 'arvados#pipelineInstance', # PipelineInvocation
  29                 'ldvyl' => 'arvados#group') # Project
  30       end
  31   end
  32
  33   def initialize raw_params={}, create_params={}
  34     super self.class.permit_attribute_params(raw_params)
  35     @create_params = create_params
  36     @attribute_sortkey ||= {
  37       'id' => nil,
  38       'name' => '000',
  39       'owner_uuid' => '002',
  40       'event_type' => '100',
  41       'link_class' => '100',
  42       'group_class' => '100',
  43       'tail_uuid' => '101',
  44       'head_uuid' => '102',
  45       'object_uuid' => '102',
  46       'summary' => '104',
  47       'description' => '104',
  48       'properties' => '150',
  49       'info' => '150',
  50       'created_at' => '200',
  51       'modified_at' => '201',
  52       'modified_by_user_uuid' => '202',
  53       'modified_by_client_uuid' => '203',
  54       'uuid' => '999',
  55     }
  56     @loaded_attributes = {}
  57   end
  58
  59   def self.columns
  60     return @columns if @columns.andand.any?
  61     @columns = []
  62     @attribute_info ||= {}
  63     schema = arvados_api_client.discovery[:schemas][self.to_s.to_sym]
  64     return @columns if schema.nil?
  65     schema[:properties].each do |k, coldef|
  66       case k
  67       when :etag, :kind
  68         attr_reader k
  69       else
  70         if coldef[:type] == coldef[:type].downcase
  71           # boolean, integer, etc.
  72           @columns << column(k, coldef[:type].to_sym)
  73         else
  74           # Hash, Array
  75           @columns << column(k, :text)
  76           serialize k, coldef[:type].constantize
  77         end
  78         define_method k do
  79           unless new_record? or @loaded_attributes.include? k.to_s
  80             Rails.logger.debug "BUG: access non-loaded attribute #{k}"
  81             # We should...
  82             # raise ActiveModel::MissingAttributeError, "missing attribute: #{k}"
  83           end
  84           super()
  85         end
  86         @attribute_info[k] = coldef
  87       end
  88     end
  89     @columns
  90   end
  91
  92   def self.column(name, sql_type = nil, default = nil, null = true)
  93     ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
  94   end
  95
  96   def self.attribute_info
  97     self.columns
  98     @attribute_info
  99   end
 100
 101   def self.find(uuid, opts={})
 102     if uuid.class != String or uuid.length < 27 then
 103       raise 'argument to find() must be a uuid string. Acceptable formats: warehouse locator or string with format xxxxx-xxxxx-xxxxxxxxxxxxxxx'
 104     end
 105
 106     if self == ArvadosBase
 107       # Determine type from uuid and defer to the appropriate subclass.
 108       return resource_class_for_uuid(uuid).find(uuid, opts)
 109     end
 110
 111     # Only do one lookup on the API side per {class, uuid, workbench
 112     # request} unless {cache: false} is given via opts.
 113     cache_key = "request_#{Thread.current.object_id}_#{self.to_s}_#{uuid}"
 114     if opts[:cache] == false
 115       Rails.cache.write cache_key, arvados_api_client.api(self, '/' + uuid)
 116     end
 117     hash = Rails.cache.fetch cache_key do
 118       arvados_api_client.api(self, '/' + uuid)
 119     end
 120     new.private_reload(hash)
 121   end
 122
 123   def self.find?(*args)
 124     find(*args) rescue nil
 125   end
 126
 127   def self.order(*args)
 128     ArvadosResourceList.new(self).order(*args)
 129   end
 130
 131   def self.filter(*args)
 132     ArvadosResourceList.new(self).filter(*args)
 133   end
 134
 135   def self.where(*args)
 136     ArvadosResourceList.new(self).where(*args)
 137   end
 138
 139   def self.limit(*args)
 140     ArvadosResourceList.new(self).limit(*args)
 141   end
 142
 143   def self.select(*args)
 144     ArvadosResourceList.new(self).select(*args)
 145   end
 146
 147   def self.with_count(*args)
 148     ArvadosResourceList.new(self).with_count(*args)
 149   end
 150
 151   def self.distinct(*args)
 152     ArvadosResourceList.new(self).distinct(*args)
 153   end
 154
 155   def self.eager(*args)
 156     ArvadosResourceList.new(self).eager(*args)
 157   end
 158
 159   def self.all
 160     ArvadosResourceList.new(self)
 161   end
 162
 163   def self.permit_attribute_params raw_params
 164     # strong_parameters does not provide security in Workbench: anyone
 165     # who can get this far can just as well do a call directly to our
 166     # database (Arvados) with the same credentials we use.
 167     #
 168     # The following permit! is necessary even with
 169     # "ActionController::Parameters.permit_all_parameters = true",
 170     # because permit_all does not permit nested attributes.
 171     ActionController::Parameters.new(raw_params).permit!
 172   end
 173
 174   def self.create raw_params={}, create_params={}
 175     x = super(permit_attribute_params(raw_params))
 176     x.create_params = create_params
 177     x
 178   end
 179
 180   def update_attributes raw_params={}
 181     super(self.class.permit_attribute_params(raw_params))
 182   end
 183
 184   def save
 185     obdata = {}
 186     self.class.columns.each do |col|
 187       # Non-nil serialized values must be sent because we can't tell
 188       # whether they've changed. Other than that, any given attribute
 189       # is either unchanged (in which case there's no need to send its
 190       # old value in the update/create command) or has been added to
 191       # #changed by ActiveRecord's #attr= method.
 192       if changed.include? col.name or
 193           (self.class.serialized_attributes.include? col.name and
 194            @loaded_attributes[col.name])
 195         obdata[col.name.to_sym] = self.send col.name
 196       end
 197     end
 198     obdata.delete :id
 199     postdata = { self.class.to_s.underscore => obdata }
 200     if etag
 201       postdata['_method'] = 'PUT'
 202       obdata.delete :uuid
 203       resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
 204     else
 205       postdata.merge!(@create_params) if @create_params
 206       resp = arvados_api_client.api(self.class, '', postdata)
 207     end
 208     return false if !resp[:etag] || !resp[:uuid]
 209
 210     # set read-only non-database attributes
 211     @etag = resp[:etag]
 212     @kind = resp[:kind]
 213
 214     # attributes can be modified during "save" -- we should update our copies
 215     resp.keys.each do |attr|
 216       if self.respond_to? "#{attr}=".to_sym
 217         self.send(attr.to_s + '=', resp[attr.to_sym])
 218       end
 219     end
 220
 221     changes_applied
 222     @new_record = false
 223
 224     self
 225   end
 226
 227   def save!
 228     self.save or raise Exception.new("Save failed")
 229   end
 230
 231   def destroy
 232     if etag || uuid
 233       postdata = { '_method' => 'DELETE' }
 234       resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
 235       resp[:etag] && resp[:uuid] && resp
 236     else
 237       true
 238     end
 239   end
 240
 241   def links(*args)
 242     o = {}
 243     o.merge!(args.pop) if args[-1].is_a? Hash
 244     o[:link_class] ||= args.shift
 245     o[:name] ||= args.shift
 246     o[:tail_uuid] = self.uuid
 247     if all_links
 248       return all_links.select do |m|
 249         ok = true
 250         o.each do |k,v|
 251           if !v.nil?
 252             test_v = m.send(k)
 253             if (v.respond_to?(:uuid) ? v.uuid : v.to_s) != (test_v.respond_to?(:uuid) ? test_v.uuid : test_v.to_s)
 254               ok = false
 255             end
 256           end
 257         end
 258         ok
 259       end
 260     end
 261     @links = arvados_api_client.api Link, '', { _method: 'GET', where: o, eager: true }
 262     @links = arvados_api_client.unpack_api_response(@links)
 263   end
 264
 265   def all_links
 266     return @all_links if @all_links
 267     res = arvados_api_client.api Link, '', {
 268       _method: 'GET',
 269       where: {
 270         tail_kind: self.kind,
 271         tail_uuid: self.uuid
 272       },
 273       eager: true
 274     }
 275     @all_links = arvados_api_client.unpack_api_response(res)
 276   end
 277
 278   def reload
 279     private_reload(self.uuid)
 280   end
 281
 282   def private_reload(uuid_or_hash)
 283     raise "No such object" if !uuid_or_hash
 284     if uuid_or_hash.is_a? Hash
 285       hash = uuid_or_hash
 286     else
 287       hash = arvados_api_client.api(self.class, '/' + uuid_or_hash)
 288     end
 289     hash.each do |k,v|
 290       @loaded_attributes[k.to_s] = true
 291       if self.respond_to?(k.to_s + '=')
 292         self.send(k.to_s + '=', v)
 293       else
 294         # When ArvadosApiClient#schema starts telling us what to expect
 295         # in API responses (not just the server side database
 296         # columns), this sort of awfulness can be avoided:
 297         self.instance_variable_set('@' + k.to_s, v)
 298         if !self.respond_to? k
 299           singleton = class << self; self end
 300           singleton.send :define_method, k, lambda { instance_variable_get('@' + k.to_s) }
 301         end
 302       end
 303     end
 304     @all_links = nil
 305     changes_applied
 306     @new_record = false
 307     self
 308   end
 309
 310   def to_param
 311     uuid
 312   end
 313
 314   def initialize_copy orig
 315     super
 316     forget_uuid!
 317   end
 318
 319   def attributes_for_display
 320     self.attributes.reject { |k,v|
 321       attribute_sortkey.has_key?(k) and !attribute_sortkey[k]
 322     }.sort_by { |k,v|
 323       attribute_sortkey[k] or k
 324     }
 325   end
 326
 327   def class_for_display
 328     self.class.to_s.underscore.humanize
 329   end
 330
 331   def self.class_for_display
 332     self.to_s.underscore.humanize
 333   end
 334
 335   # Array of strings that are names of attributes that should be rendered as textile.
 336   def textile_attributes
 337     []
 338   end
 339
 340   def self.creatable?
 341     current_user.andand.is_active && api_exists?(:create)
 342   end
 343
 344   def self.goes_in_projects?
 345     false
 346   end
 347
 348   # can this class of object be copied into a project?
 349   # override to false on indivudal model classes for which this should not be true
 350   def self.copies_to_projects?
 351     self.goes_in_projects?
 352   end
 353
 354   def editable?
 355     (current_user and current_user.is_active and
 356      (current_user.is_admin or
 357       current_user.uuid == self.owner_uuid or
 358       new_record? or
 359       (respond_to?(:writable_by) ?
 360        writable_by.include?(current_user.uuid) :
 361        (ArvadosBase.find(owner_uuid).writable_by.include? current_user.uuid rescue false)))) or false
 362   end
 363
 364   def deletable?
 365     editable?
 366   end
 367
 368   def self.api_exists?(method)
 369     arvados_api_client.discovery[:resources][self.to_s.underscore.pluralize.to_sym].andand[:methods].andand[method]
 370   end
 371
 372   # Array of strings that are the names of attributes that can be edited
 373   # with X-Editable.
 374   def editable_attributes
 375     self.class.columns.map(&:name) -
 376       %w(created_at modified_at modified_by_user_uuid modified_by_client_uuid updated_at)
 377   end
 378
 379   def attribute_editable?(attr, ever=nil)
 380     if not editable_attributes.include?(attr.to_s)
 381       false
 382     elsif not (current_user.andand.is_active)
 383       false
 384     elsif attr == 'uuid'
 385       current_user.is_admin
 386     elsif ever
 387       true
 388     else
 389       editable?
 390     end
 391   end
 392
 393   def self.resource_class_for_uuid(uuid, opts={})
 394     if uuid.is_a? ArvadosBase
 395       return uuid.class
 396     end
 397     unless uuid.is_a? String
 398       return nil
 399     end
 400     if opts[:class].is_a? Class
 401       return opts[:class]
 402     end
 403     if uuid.match /^[0-9a-f]{32}(\+[^,]+)*(,[0-9a-f]{32}(\+[^,]+)*)*$/
 404       return Collection
 405     end
 406     resource_class = nil
 407     uuid.match /^[0-9a-z]{5}-([0-9a-z]{5})-[0-9a-z]{15}$/ do |re|
 408       resource_class ||= arvados_api_client.
 409         kind_class(self.uuid_infix_object_kind[re[1]])
 410     end
 411     if opts[:referring_object] and
 412         opts[:referring_attr] and
 413         opts[:referring_attr].match /_uuid$/
 414       resource_class ||= arvados_api_client.
 415         kind_class(opts[:referring_object].
 416                    attributes[opts[:referring_attr].
 417                               sub(/_uuid$/, '_kind')])
 418     end
 419     resource_class
 420   end
 421
 422   def resource_param_name
 423     self.class.to_s.underscore
 424   end
 425
 426   def friendly_link_name lookup=nil
 427     (name if self.respond_to? :name) || default_name
 428   end
 429
 430   def content_summary
 431     self.class_for_display
 432   end
 433
 434   def selection_label
 435     friendly_link_name
 436   end
 437
 438   def self.default_name
 439     self.to_s.underscore.humanize
 440   end
 441
 442   def controller
 443     (self.class.to_s.pluralize + 'Controller').constantize
 444   end
 445
 446   def controller_name
 447     self.class.to_s.tableize
 448   end
 449
 450   # Placeholder for name when name is missing or empty
 451   def default_name
 452     if self.respond_to? :name
 453       "New #{class_for_display.downcase}"
 454     else
 455       uuid
 456     end
 457   end
 458
 459   def owner
 460     ArvadosBase.find(owner_uuid) rescue nil
 461   end
 462
 463   protected
 464
 465   def forget_uuid!
 466     self.uuid = nil
 467     @etag = nil
 468     self
 469   end
 470
 471   def self.current_user
 472     Thread.current[:user] ||= User.current if Thread.current[:arvados_api_token]
 473     Thread.current[:user]
 474   end
 475   def current_user
 476     self.class.current_user
 477   end
 478 end