services/api/app/models/user.rb

   1 class User < ArvadosModel
   2   include AssignUuid
   3   include KindAndEtag
   4   include CommonApiTemplate
   5   serialize :prefs, Hash
   6   has_many :api_client_authorizations
   7   before_update :prevent_privilege_escalation
   8   before_update :prevent_inactive_admin
   9   before_create :check_auto_admin
  10   after_create AdminNotifier
  11
  12   has_many :authorized_keys, :foreign_key => :authorized_user_uuid, :primary_key => :uuid
  13
  14   api_accessible :user, extend: :common do |t|
  15     t.add :email
  16     t.add :full_name
  17     t.add :first_name
  18     t.add :last_name
  19     t.add :identity_url
  20     t.add :is_active
  21     t.add :is_admin
  22     t.add :prefs
  23   end
  24
  25   ALL_PERMISSIONS = {read: true, write: true, manage: true}
  26
  27   def full_name
  28     "#{first_name} #{last_name}"
  29   end
  30
  31   def groups_i_can(verb)
  32     self.group_permissions.select { |uuid, mask| mask[verb] }.keys
  33   end
  34
  35   def can?(actions)
  36     actions.each do |action, target|
  37       target_uuid = target
  38       if target.respond_to? :uuid
  39         target_uuid = target.uuid
  40       end
  41       next if target_uuid == self.uuid
  42       next if (group_permissions[target_uuid] and
  43                group_permissions[target_uuid][action])
  44       if target.respond_to? :owner_uuid
  45         next if target.owner_uuid == self.uuid
  46         next if (group_permissions[target.owner_uuid] and
  47                  group_permissions[target.owner_uuid][action])
  48       end
  49       return false
  50     end
  51     true
  52   end
  53
  54   def self.invalidate_permissions_cache
  55     Rails.cache.delete_matched(/^groups_for_user_/)
  56   end
  57
  58   protected
  59
  60   def permission_to_update
  61     # users must be able to update themselves (even if they are
  62     # inactive) in order to create sessions
  63     self == current_user or super
  64   end
  65
  66   def permission_to_create
  67     current_user.andand.is_admin or
  68       (self == current_user and
  69        self.is_active == Rails.configuration.new_users_are_active)
  70   end
  71
  72   def check_auto_admin
  73     if User.where("uuid not like '%-000000000000000'").where(:is_admin => true).count == 0 and not Rails.configuration.auto_admin_user.nil?
  74       if current_user.email == Rails.configuration.auto_admin_user
  75         self.is_admin = true
  76         self.is_active = true
  77       end
  78     end
  79   end
  80
  81   def prevent_privilege_escalation
  82     if current_user.andand.is_admin
  83       return true
  84     end
  85     if self.is_active_changed?
  86       if self.is_active != self.is_active_was
  87         logger.warn "User #{current_user.uuid} tried to change is_active from #{self.is_admin_was} to #{self.is_admin} for #{self.uuid}"
  88         self.is_active = self.is_active_was
  89       end
  90     end
  91     if self.is_admin_changed?
  92       if self.is_admin != self.is_admin_was
  93         logger.warn "User #{current_user.uuid} tried to change is_admin from #{self.is_admin_was} to #{self.is_admin} for #{self.uuid}"
  94         self.is_admin = self.is_admin_was
  95       end
  96     end
  97     true
  98   end
  99
 100   def prevent_inactive_admin
 101     if self.is_admin and not self.is_active
 102       # There is no known use case for the strange set of permissions
 103       # that would result from this change. It's safest to assume it's
 104       # a mistake and disallow it outright.
 105       raise "Admin users cannot be inactive"
 106     end
 107     true
 108   end
 109
 110   def group_permissions
 111     Rails.cache.fetch "groups_for_user_#{self.uuid}" do
 112       permissions_from = {}
 113       todo = {self.uuid => true}
 114       done = {}
 115       while !todo.empty?
 116         lookup_uuids = todo.keys
 117         lookup_uuids.each do |uuid| done[uuid] = true end
 118         todo = {}
 119         Link.where('tail_uuid in (?) and link_class = ? and head_kind = ?',
 120                    lookup_uuids,
 121                    'permission',
 122                    'arvados#group').each do |link|
 123           unless done.has_key? link.head_uuid
 124             todo[link.head_uuid] = true
 125           end
 126           link_permissions = {}
 127           case link.name
 128           when 'can_read'
 129             link_permissions = {read:true}
 130           when 'can_write'
 131             link_permissions = {read:true,write:true}
 132           when 'can_manage'
 133             link_permissions = ALL_PERMISSIONS
 134           end
 135           permissions_from[link.tail_uuid] ||= {}
 136           permissions_from[link.tail_uuid][link.head_uuid] ||= {}
 137           link_permissions.each do |k,v|
 138             permissions_from[link.tail_uuid][link.head_uuid][k] ||= v
 139           end
 140         end
 141       end
 142       search_permissions(self.uuid, permissions_from)
 143     end
 144   end
 145
 146   def search_permissions(start, graph, merged={}, upstream_mask=nil, upstream_path={})
 147     nextpaths = graph[start]
 148     return merged if !nextpaths
 149     return merged if upstream_path.has_key? start
 150     upstream_path[start] = true
 151     upstream_mask ||= ALL_PERMISSIONS
 152     nextpaths.each do |head, mask|
 153       merged[head] ||= {}
 154       mask.each do |k,v|
 155         merged[head][k] ||= v if upstream_mask[k]
 156       end
 157       search_permissions(head, graph, merged, upstream_mask.select { |k,v| v && merged[head][k] }, upstream_path)
 158     end
 159     upstream_path.delete start
 160     merged
 161   end
 162 end