X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/c1e7255a85dfc2807ba78e1cf9d109d896c80b42..68aa07e5c152fd573e254614b34b71957b50ad8c:/services/api/app/models/arvados_model.rb?ds=sidebyside diff --git a/services/api/app/models/arvados_model.rb b/services/api/app/models/arvados_model.rb index a6c9d31d41..5cd0c77c49 100644 --- a/services/api/app/models/arvados_model.rb +++ b/services/api/app/models/arvados_model.rb @@ -20,6 +20,7 @@ class ArvadosModel < ActiveRecord::Base after_create :log_create after_update :log_update after_destroy :log_destroy + after_find :convert_serialized_symbols_to_strings validate :ensure_serialized_attribute_type validate :normalize_collection_uuids validate :ensure_valid_uuids @@ -51,13 +52,16 @@ class ArvadosModel < ActiveRecord::Base def self.searchable_columns operator textonly_operator = !operator.match(/[<=>]/) - self.columns.collect do |col| - if [:string, :text].index(col.type) - col.name - elsif !textonly_operator and [:datetime, :integer].index(col.type) - col.name + self.columns.select do |col| + case col.type + when :string, :text + true + when :datetime, :integer, :boolean + !textonly_operator + else + false end - end.compact + end.map(&:name) end def self.attribute_column attr @@ -90,6 +94,13 @@ class ArvadosModel < ActiveRecord::Base # Get rid of troublesome nils users_list.compact! + # Load optional keyword arguments, if they exist. + if users_list.last.is_a? Hash + kwargs = users_list.pop + else + kwargs = {} + end + # Check if any of the users are admin. If so, we're done. if users_list.select { |u| u.is_admin }.empty? @@ -100,6 +111,7 @@ class ArvadosModel < ActiveRecord::Base collect { |uuid| sanitize(uuid) }.join(', ') sql_conds = [] sql_params = [] + sql_table = kwargs.fetch(:table_name, table_name) or_object_uuid = '' # This row is owned by a member of users_list, or owned by a group @@ -112,25 +124,25 @@ class ArvadosModel < ActiveRecord::Base # to this row, or to the owner of this row (see join() below). permitted_uuids = "(SELECT head_uuid FROM links WHERE link_class='permission' AND tail_uuid IN (#{sanitized_uuid_list}))" - sql_conds += ["#{table_name}.owner_uuid in (?)", - "#{table_name}.uuid in (?)", - "#{table_name}.uuid IN #{permitted_uuids}"] + sql_conds += ["#{sql_table}.owner_uuid in (?)", + "#{sql_table}.uuid in (?)", + "#{sql_table}.uuid IN #{permitted_uuids}"] sql_params += [uuid_list, user_uuids] - if self == Link and users_list.any? + if sql_table == "links" and users_list.any? # This row is a 'permission' or 'resources' link class # The uuid for a member of users_list is referenced in either the head # or tail of the link - sql_conds += ["(#{table_name}.link_class in (#{sanitize 'permission'}, #{sanitize 'resources'}) AND (#{table_name}.head_uuid IN (?) OR #{table_name}.tail_uuid IN (?)))"] + sql_conds += ["(#{sql_table}.link_class in (#{sanitize 'permission'}, #{sanitize 'resources'}) AND (#{sql_table}.head_uuid IN (?) OR #{sql_table}.tail_uuid IN (?)))"] sql_params += [user_uuids, user_uuids] end - if self == Log and users_list.any? + if sql_table == "logs" and users_list.any? # Link head points to the object described by this row - sql_conds += ["#{table_name}.object_uuid IN #{permitted_uuids}"] + sql_conds += ["#{sql_table}.object_uuid IN #{permitted_uuids}"] # This object described by this row is owned by this user, or owned by a group readable by this user - sql_conds += ["#{table_name}.object_owner_uuid in (?)"] + sql_conds += ["#{sql_table}.object_owner_uuid in (?)"] sql_params += [uuid_list] end @@ -151,6 +163,13 @@ class ArvadosModel < ActiveRecord::Base attributes end + def has_permission? perm_type, target_uuid + Link.where(link_class: "permission", + name: perm_type, + tail_uuid: uuid, + head_uuid: target_uuid).any? + end + protected def ensure_ownership_path_leads_to_user @@ -187,29 +206,25 @@ class ArvadosModel < ActiveRecord::Base def ensure_owner_uuid_is_permitted raise PermissionDeniedError if !current_user - if respond_to? :owner_uuid= + if new_record? and respond_to? :owner_uuid= self.owner_uuid ||= current_user.uuid end - if self.owner_uuid_changed? - if new_record? - return true - elsif current_user.uuid == self.owner_uuid or - current_user.can? write: self.owner_uuid - # current_user is, or has :write permission on, the new owner - else - logger.warn "User #{current_user.uuid} tried to change owner_uuid of #{self.class.to_s} #{self.uuid} to #{self.owner_uuid} but does not have permission to write to #{self.owner_uuid}" - raise PermissionDeniedError - end - end - if new_record? - return true - elsif current_user.uuid == self.owner_uuid_was or + # Verify permission to write to old owner (unless owner_uuid was + # nil -- or hasn't changed, in which case the following + # "permission to write to new owner" block will take care of us) + unless !owner_uuid_changed? or + owner_uuid_was.nil? or + current_user.uuid == self.owner_uuid_was or current_user.uuid == self.uuid or current_user.can? write: self.owner_uuid_was - # current user is, or has :write permission on, the previous owner - return true - else - logger.warn "User #{current_user.uuid} tried to modify #{self.class.to_s} #{self.uuid} but does not have permission to write #{self.owner_uuid_was}" + logger.warn "User #{current_user.uuid} tried to modify #{self.class.to_s} #{uuid} but does not have permission to write old owner_uuid #{owner_uuid_was}" + errors.add :owner_uuid, "cannot be changed without write permission on old owner" + raise PermissionDeniedError + end + # Verify permission to write to new owner + unless current_user == self or current_user.can? write: owner_uuid + logger.warn "User #{current_user.uuid} tried to modify #{self.class.to_s} #{uuid} but does not have permission to write new owner_uuid #{owner_uuid}" + errors.add :owner_uuid, "cannot be changed without write permission on new owner" raise PermissionDeniedError end end @@ -263,6 +278,38 @@ class ArvadosModel < ActiveRecord::Base true end + def self.has_symbols? x + if x.is_a? Hash + x.each do |k,v| + return true if has_symbols?(k) or has_symbols?(v) + end + false + elsif x.is_a? Array + x.each do |k| + return true if has_symbols?(k) + end + false + else + (x.class == Symbol) + end + end + + def self.recursive_stringify x + if x.is_a? Hash + Hash[x.collect do |k,v| + [recursive_stringify(k), recursive_stringify(v)] + end] + elsif x.is_a? Array + x.collect do |k| + recursive_stringify k + end + elsif x.is_a? Symbol + x.to_s + else + x + end + end + def ensure_serialized_attribute_type # Specifying a type in the "serialize" declaration causes rails to # raise an exception if a different data type is retrieved from @@ -272,13 +319,31 @@ class ArvadosModel < ActiveRecord::Base # developer. self.class.serialized_attributes.each do |colname, attr| if attr.object_class - unless self.attributes[colname].is_a? attr.object_class - self.errors.add colname.to_sym, "must be a #{attr.object_class.to_s}" + if self.attributes[colname].class != attr.object_class + self.errors.add colname.to_sym, "must be a #{attr.object_class.to_s}, not a #{self.attributes[colname].class.to_s}" + elsif self.class.has_symbols? attributes[colname] + self.errors.add colname.to_sym, "must not contain symbols: #{attributes[colname].inspect}" end end end end + def convert_serialized_symbols_to_strings + # ensure_serialized_attribute_type should prevent symbols from + # getting into the database in the first place. If someone managed + # to get them into the database (perhaps using an older version) + # we'll convert symbols to strings when loading from the + # database. (Otherwise, loading and saving an object with existing + # symbols in a serialized field will crash.) + self.class.serialized_attributes.each do |colname, attr| + if self.class.has_symbols? attributes[colname] + attributes[colname] = self.class.recursive_stringify attributes[colname] + self.send(colname + '=', + self.class.recursive_stringify(attributes[colname])) + end + end + end + def foreign_key_attributes attributes.keys.select { |a| a.match /_uuid$/ } end @@ -388,6 +453,18 @@ class ArvadosModel < ActiveRecord::Base nil end + # ArvadosModel.find_by_uuid needs extra magic to allow it to return + # an object in any class. + def self.find_by_uuid uuid + if self == ArvadosModel + # If called directly as ArvadosModel.find_by_uuid rather than via subclass, + # delegate to the appropriate subclass based on the given uuid. + self.resource_class_for_uuid(uuid).find_by_uuid(uuid) + else + super + end + end + def log_start_state @old_etag = etag @old_attributes = logged_attributes