1 class ArvadosBase < ActiveRecord::Base
2 self.abstract_class = true
3 attr_accessor :attribute_sortkey
4 attr_accessor :create_params
6 def self.arvados_api_client
7 ArvadosApiClient.new_or_current
10 def arvados_api_client
11 ArvadosApiClient.new_or_current
14 def self.uuid_infix_object_kind
15 @@uuid_infix_object_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)
25 # Recognize obsolete types.
27 merge('mxsvm' => 'arvados#pipelineTemplate', # Pipeline
28 'uo14g' => 'arvados#pipelineInstance', # PipelineInvocation
29 'ldvyl' => 'arvados#group') # Project
33 def initialize raw_params={}, create_params={}
34 super self.class.permit_attribute_params(raw_params)
35 @create_params = create_params
36 @attribute_sortkey ||= {
39 'owner_uuid' => '002',
40 'event_type' => '100',
41 'link_class' => '100',
42 'group_class' => '100',
45 'object_uuid' => '102',
47 'description' => '104',
48 'properties' => '150',
50 'created_at' => '200',
51 'modified_at' => '201',
52 'modified_by_user_uuid' => '202',
53 'modified_by_client_uuid' => '203',
56 @loaded_attributes = {}
60 return @columns if @columns.andand.any?
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|
70 if coldef[:type] == coldef[:type].downcase
71 # boolean, integer, etc.
72 @columns << column(k, coldef[:type].to_sym)
75 @columns << column(k, :text)
76 serialize k, coldef[:type].constantize
79 unless new_record? or @loaded_attributes.include? k.to_s
80 Rails.logger.debug "BUG: access non-loaded attribute #{k}"
82 # raise ActiveModel::MissingAttributeError, "missing attribute: #{k}"
86 @attribute_info[k] = coldef
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)
96 def self.attribute_info
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'
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)
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)
117 hash = Rails.cache.fetch cache_key do
118 arvados_api_client.api(self, '/' + uuid)
120 new.private_reload(hash)
123 def self.find?(*args)
124 find(*args) rescue nil
127 def self.order(*args)
128 ArvadosResourceList.new(self).order(*args)
131 def self.filter(*args)
132 ArvadosResourceList.new(self).filter(*args)
135 def self.where(*args)
136 ArvadosResourceList.new(self).where(*args)
139 def self.limit(*args)
140 ArvadosResourceList.new(self).limit(*args)
143 def self.select(*args)
144 ArvadosResourceList.new(self).select(*args)
147 def self.with_count(*args)
148 ArvadosResourceList.new(self).with_count(*args)
151 def self.distinct(*args)
152 ArvadosResourceList.new(self).distinct(*args)
155 def self.include_trash(*args)
156 ArvadosResourceList.new(self).include_trash(*args)
159 def self.recursive(*args)
160 ArvadosResourceList.new(self).recursive(*args)
163 def self.eager(*args)
164 ArvadosResourceList.new(self).eager(*args)
168 ArvadosResourceList.new(self)
171 def self.permit_attribute_params raw_params
172 # strong_parameters does not provide security in Workbench: anyone
173 # who can get this far can just as well do a call directly to our
174 # database (Arvados) with the same credentials we use.
176 # The following permit! is necessary even with
177 # "ActionController::Parameters.permit_all_parameters = true",
178 # because permit_all does not permit nested attributes.
179 ActionController::Parameters.new(raw_params).permit!
182 def self.create raw_params={}, create_params={}
183 x = super(permit_attribute_params(raw_params))
184 x.create_params = create_params
188 def update_attributes raw_params={}
189 super(self.class.permit_attribute_params(raw_params))
194 self.class.columns.each do |col|
195 # Non-nil serialized values must be sent because we can't tell
196 # whether they've changed. Other than that, any given attribute
197 # is either unchanged (in which case there's no need to send its
198 # old value in the update/create command) or has been added to
199 # #changed by ActiveRecord's #attr= method.
200 if changed.include? col.name or
201 (self.class.serialized_attributes.include? col.name and
202 @loaded_attributes[col.name])
203 obdata[col.name.to_sym] = self.send col.name
207 postdata = { self.class.to_s.underscore => obdata }
209 postdata['_method'] = 'PUT'
211 resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
213 postdata.merge!(@create_params) if @create_params
214 resp = arvados_api_client.api(self.class, '', postdata)
216 return false if !resp[:etag] || !resp[:uuid]
218 # set read-only non-database attributes
222 # attributes can be modified during "save" -- we should update our copies
223 resp.keys.each do |attr|
224 if self.respond_to? "#{attr}=".to_sym
225 self.send(attr.to_s + '=', resp[attr.to_sym])
236 self.save or raise Exception.new("Save failed")
241 postdata = { '_method' => 'DELETE' }
242 resp = arvados_api_client.api(self.class, '/' + uuid, postdata)
243 resp[:etag] && resp[:uuid] && resp
251 o.merge!(args.pop) if args[-1].is_a? Hash
252 o[:link_class] ||= args.shift
253 o[:name] ||= args.shift
254 o[:tail_uuid] = self.uuid
256 return all_links.select do |m|
261 if (v.respond_to?(:uuid) ? v.uuid : v.to_s) != (test_v.respond_to?(:uuid) ? test_v.uuid : test_v.to_s)
269 @links = arvados_api_client.api Link, '', { _method: 'GET', where: o, eager: true }
270 @links = arvados_api_client.unpack_api_response(@links)
274 return @all_links if @all_links
275 res = arvados_api_client.api Link, '', {
278 tail_kind: self.kind,
283 @all_links = arvados_api_client.unpack_api_response(res)
287 private_reload(self.uuid)
290 def private_reload(uuid_or_hash)
291 raise "No such object" if !uuid_or_hash
292 if uuid_or_hash.is_a? Hash
295 hash = arvados_api_client.api(self.class, '/' + uuid_or_hash)
298 @loaded_attributes[k.to_s] = true
299 if self.respond_to?(k.to_s + '=')
300 self.send(k.to_s + '=', v)
302 # When ArvadosApiClient#schema starts telling us what to expect
303 # in API responses (not just the server side database
304 # columns), this sort of awfulness can be avoided:
305 self.instance_variable_set('@' + k.to_s, v)
306 if !self.respond_to? k
307 singleton = class << self; self end
308 singleton.send :define_method, k, lambda { instance_variable_get('@' + k.to_s) }
322 def initialize_copy orig
327 def attributes_for_display
328 self.attributes.reject { |k,v|
329 attribute_sortkey.has_key?(k) and !attribute_sortkey[k]
331 attribute_sortkey[k] or k
335 def class_for_display
336 self.class.to_s.underscore.humanize
339 def self.class_for_display
340 self.to_s.underscore.humanize
343 # Array of strings that are names of attributes that should be rendered as textile.
344 def textile_attributes
349 current_user.andand.is_active && api_exists?(:create)
352 def self.goes_in_projects?
356 # can this class of object be copied into a project?
357 # override to false on indivudal model classes for which this should not be true
358 def self.copies_to_projects?
359 self.goes_in_projects?
363 (current_user and current_user.is_active and
364 (current_user.is_admin or
365 current_user.uuid == self.owner_uuid or
367 (respond_to?(:writable_by) ?
368 writable_by.include?(current_user.uuid) :
369 (ArvadosBase.find(owner_uuid).writable_by.include? current_user.uuid rescue false)))) or false
376 def self.api_exists?(method)
377 arvados_api_client.discovery[:resources][self.to_s.underscore.pluralize.to_sym].andand[:methods].andand[method]
380 # Array of strings that are the names of attributes that can be edited
382 def editable_attributes
383 self.class.columns.map(&:name) -
384 %w(created_at modified_at modified_by_user_uuid modified_by_client_uuid updated_at)
387 def attribute_editable?(attr, ever=nil)
388 if not editable_attributes.include?(attr.to_s)
390 elsif not (current_user.andand.is_active)
393 current_user.is_admin
401 def self.resource_class_for_uuid(uuid, opts={})
402 if uuid.is_a? ArvadosBase
405 unless uuid.is_a? String
408 if opts[:class].is_a? Class
411 if uuid.match /^[0-9a-f]{32}(\+[^,]+)*(,[0-9a-f]{32}(\+[^,]+)*)*$/
415 uuid.match /^[0-9a-z]{5}-([0-9a-z]{5})-[0-9a-z]{15}$/ do |re|
416 resource_class ||= arvados_api_client.
417 kind_class(self.uuid_infix_object_kind[re[1]])
419 if opts[:referring_object] and
420 opts[:referring_attr] and
421 opts[:referring_attr].match /_uuid$/
422 resource_class ||= arvados_api_client.
423 kind_class(opts[:referring_object].
424 attributes[opts[:referring_attr].
425 sub(/_uuid$/, '_kind')])
430 def resource_param_name
431 self.class.to_s.underscore
434 def friendly_link_name lookup=nil
435 (name if self.respond_to? :name) || default_name
439 self.class_for_display
446 def self.default_name
447 self.to_s.underscore.humanize
451 (self.class.to_s.pluralize + 'Controller').constantize
455 self.class.to_s.tableize
458 # Placeholder for name when name is missing or empty
460 if self.respond_to? :name
461 "New #{class_for_display.downcase}"
468 ArvadosBase.find(owner_uuid) rescue nil
479 def self.current_user
480 Thread.current[:user] ||= User.current if Thread.current[:arvados_api_token]
481 Thread.current[:user]
484 self.class.current_user