X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/87275ec769831e04982a714049ee9d67b6342d68..cec8e2705d260c9df1042858941419a3b9160c0e:/services/api/app/models/user.rb diff --git a/services/api/app/models/user.rb b/services/api/app/models/user.rb index eb181c3856..cc3a22cbf0 100644 --- a/services/api/app/models/user.rb +++ b/services/api/app/models/user.rb @@ -1,4 +1,9 @@ +# Copyright (C) The Arvados Authors. All rights reserved. +# +# SPDX-License-Identifier: AGPL-3.0 + require 'can_be_an_owner' +require 'refresh_permission_view' class User < ArvadosModel include HasUuid @@ -10,7 +15,7 @@ class User < ArvadosModel has_many :api_client_authorizations validates(:username, format: { - with: /^[A-Za-z][A-Za-z0-9]*$/, + with: /\A[A-Za-z][A-Za-z0-9]*\z/, message: "must begin with a letter and contain only alphanumerics", }, uniqueness: true, @@ -20,11 +25,14 @@ class User < ArvadosModel before_update :verify_repositories_empty, :if => Proc.new { |user| user.username.nil? and user.username_changed? } + before_update :setup_on_activate before_create :check_auto_admin before_create :set_initial_username, :if => Proc.new { |user| user.username.nil? and user.email } + after_create :setup_on_activate after_create :add_system_group_permission_link + after_create :invalidate_permissions_cache after_create :auto_setup_new_user, :if => Proc.new { |user| Rails.configuration.auto_setup_new_users and (user.uuid != system_user_uuid) and @@ -41,6 +49,8 @@ class User < ArvadosModel has_many :authorized_keys, :foreign_key => :authorized_user_uuid, :primary_key => :uuid has_many :repositories, foreign_key: :owner_uuid, primary_key: :uuid + default_scope { where('redirect_to_user_uuid is null') } + api_accessible :user, extend: :common do |t| t.add :email t.add :username @@ -136,71 +146,55 @@ class User < ArvadosModel timestamp = DbCurrentTime::db_current_time.to_i if timestamp.nil? connection.execute "NOTIFY invalidate_permissions_cache, '#{timestamp}'" else - Rails.cache.delete_matched(/^groups_for_user_/) + refresh_permission_view end end - # Return a hash of {group_uuid: perm_hash} where perm_hash[:read] - # and perm_hash[:write] are true if this user can read and write - # objects owned by group_uuid. - def calculate_group_permissions - conn = ActiveRecord::Base.connection - self.class.transaction do - # Check whether the temporary view has already been created - # during this connection. If not, create it. - conn.exec_query 'SAVEPOINT check_permission_view' - begin - conn.exec_query('SELECT 1 FROM permission_view LIMIT 0') - rescue - conn.exec_query 'ROLLBACK TO SAVEPOINT check_permission_view' - sql = File.read(Rails.root.join('lib', 'create_permission_view.sql')) - conn.exec_query(sql) - ensure - conn.exec_query 'RELEASE SAVEPOINT check_permission_view' - end - end + def invalidate_permissions_cache(timestamp=nil) + User.invalidate_permissions_cache + end - group_perms = {} - conn.exec_query('SELECT target_owner_uuid, max(perm_level) - FROM permission_view - WHERE user_uuid = $1 - AND target_owner_uuid IS NOT NULL - GROUP BY target_owner_uuid', - "group_permissions for #{uuid}", - [[nil, uuid]]).rows.each do |group_uuid, max_p_val| - group_perms[group_uuid] = PERMS_FOR_VAL[max_p_val.to_i] + # Return a hash of {user_uuid: group_perms} + def self.all_group_permissions + all_perms = {} + ActiveRecord::Base.connection. + exec_query("SELECT user_uuid, target_owner_uuid, perm_level, trashed + FROM #{PERMISSION_VIEW} + WHERE target_owner_uuid IS NOT NULL", + # "name" arg is a query label that appears in logs: + "all_group_permissions", + ).rows.each do |user_uuid, group_uuid, max_p_val, trashed| + all_perms[user_uuid] ||= {} + all_perms[user_uuid][group_uuid] = PERMS_FOR_VAL[max_p_val.to_i] end - Rails.cache.write "groups_for_user_#{self.uuid}", group_perms - group_perms + all_perms end # Return a hash of {group_uuid: perm_hash} where perm_hash[:read] # and perm_hash[:write] are true if this user can read and write # objects owned by group_uuid. def group_permissions - r = Rails.cache.read "groups_for_user_#{self.uuid}" - if r.nil? - if Rails.configuration.async_permissions_update - while r.nil? - sleep(0.1) - r = Rails.cache.read "groups_for_user_#{self.uuid}" - end - else - r = calculate_group_permissions - end + group_perms = {self.uuid => {:read => true, :write => true, :manage => true}} + ActiveRecord::Base.connection. + exec_query("SELECT target_owner_uuid, perm_level, trashed + FROM #{PERMISSION_VIEW} + WHERE user_uuid = $1 + AND target_owner_uuid IS NOT NULL", + # "name" arg is a query label that appears in logs: + "group_permissions for #{uuid}", + # "binds" arg is an array of [col_id, value] for '$1' vars: + [[nil, uuid]], + ).rows.each do |group_uuid, max_p_val, trashed| + group_perms[group_uuid] = PERMS_FOR_VAL[max_p_val.to_i] end - r - end - - def self.setup(user, openid_prefix, repo_name=nil, vm_uuid=nil) - return user.setup_repo_vm_links(repo_name, vm_uuid, openid_prefix) + group_perms end # create links - def setup_repo_vm_links(repo_name, vm_uuid, openid_prefix) + def setup(openid_prefix:, repo_name: nil, vm_uuid: nil) oid_login_perm = create_oid_login_perm openid_prefix repo_perm = create_user_repo_link repo_name - vm_login_perm = create_vm_login_permission_link vm_uuid, username + vm_login_perm = create_vm_login_permission_link(vm_uuid, username) if vm_uuid group_perm = create_user_group_link return [oid_login_perm, repo_perm, vm_login_perm, group_perm, self].compact @@ -263,14 +257,100 @@ class User < ArvadosModel end end + def update_uuid(new_uuid:) + if !current_user.andand.is_admin + raise PermissionDeniedError + end + if uuid == system_user_uuid || uuid == anonymous_user_uuid + raise "update_uuid cannot update system accounts" + end + if self.class != self.class.resource_class_for_uuid(new_uuid) + raise "invalid new_uuid #{new_uuid.inspect}" + end + transaction(requires_new: true) do + reload + old_uuid = self.uuid + self.uuid = new_uuid + save!(validate: false) + change_all_uuid_refs(old_uuid: old_uuid, new_uuid: new_uuid) + end + end + + # Move this user's (i.e., self's) owned items into new_owner_uuid. + # Also redirect future uses of this account to + # redirect_to_user_uuid, i.e., when a caller authenticates to this + # account in the future, the account redirect_to_user_uuid account + # will be used instead. + # + # current_user must have admin privileges, i.e., the caller is + # responsible for checking permission to do this. + def merge(new_owner_uuid:, redirect_to_user_uuid:) + raise PermissionDeniedError if !current_user.andand.is_admin + raise "not implemented" if !redirect_to_user_uuid + transaction(requires_new: true) do + reload + raise "cannot merge an already merged user" if self.redirect_to_user_uuid + + new_user = User.where(uuid: redirect_to_user_uuid).first + raise "user does not exist" if !new_user + raise "cannot merge to an already merged user" if new_user.redirect_to_user_uuid + + # Existing API tokens are updated to authenticate to the new + # user. + ApiClientAuthorization. + where(user_id: id). + update_all(user_id: new_user.id) + + # References to the old user UUID in the context of a user ID + # (rather than a "home project" in the project hierarchy) are + # updated to point to the new user. + [ + [AuthorizedKey, :owner_uuid], + [AuthorizedKey, :authorized_user_uuid], + [Repository, :owner_uuid], + [Link, :owner_uuid], + [Link, :tail_uuid], + [Link, :head_uuid], + ].each do |klass, column| + klass.where(column => uuid).update_all(column => new_user.uuid) + end + + # References to the merged user's "home project" are updated to + # point to new_owner_uuid. + ActiveRecord::Base.descendants.reject(&:abstract_class?).each do |klass| + next if [ApiClientAuthorization, + AuthorizedKey, + Link, + Log, + Repository].include?(klass) + next if !klass.columns.collect(&:name).include?('owner_uuid') + klass.where(owner_uuid: uuid).update_all(owner_uuid: new_owner_uuid) + end + + update_attributes!(redirect_to_user_uuid: new_user.uuid) + invalidate_permissions_cache + end + end + protected + def change_all_uuid_refs(old_uuid:, new_uuid:) + ActiveRecord::Base.descendants.reject(&:abstract_class?).each do |klass| + klass.columns.each do |col| + if col.name.end_with?('_uuid') + column = col.name.to_sym + klass.where(column => old_uuid).update_all(column => new_uuid) + end + end + end + end + def ensure_ownership_path_leads_to_user true end def permission_to_update - if username_changed? + if username_changed? || redirect_to_user_uuid_changed? current_user.andand.is_admin else # users must be able to update themselves (even if they are @@ -281,7 +361,8 @@ class User < ArvadosModel def permission_to_create current_user.andand.is_admin or - (self == current_user and + (self == current_user && + self.redirect_to_user_uuid.nil? && self.is_active == Rails.configuration.new_users_are_active) end @@ -334,7 +415,7 @@ class User < ArvadosModel end if self.is_active_changed? if self.is_active != self.is_active_was - logger.warn "User #{current_user.uuid} tried to change is_active from #{self.is_admin_was} to #{self.is_admin} for #{self.uuid}" + logger.warn "User #{current_user.uuid} tried to change is_active from #{self.is_active_was} to #{self.is_active} for #{self.uuid}" self.is_active = self.is_active_was end end @@ -374,22 +455,22 @@ class User < ArvadosModel merged end - def create_oid_login_perm (openid_prefix) - login_perm_props = { "identity_url_prefix" => openid_prefix} - + def create_oid_login_perm(openid_prefix) # Check oid_login_perm oid_login_perms = Link.where(tail_uuid: self.email, - link_class: 'permission', - name: 'can_login').where("head_uuid = ?", self.uuid) + head_uuid: self.uuid, + link_class: 'permission', + name: 'can_login') if !oid_login_perms.any? # create openid login permission - oid_login_perm = Link.create(link_class: 'permission', + oid_login_perm = Link.create!(link_class: 'permission', name: 'can_login', tail_uuid: self.email, head_uuid: self.uuid, - properties: login_perm_props - ) + properties: { + "identity_url_prefix" => openid_prefix, + }) logger.info { "openid login permission: " + oid_login_perm[:uuid] } else oid_login_perm = oid_login_perms.first @@ -417,15 +498,12 @@ class User < ArvadosModel # create login permission for the given vm_uuid, if it does not already exist def create_vm_login_permission_link(vm_uuid, repo_name) # vm uuid is optional - if vm_uuid - vm = VirtualMachine.where(uuid: vm_uuid).first + return if !vm_uuid - if not vm - logger.warn "Could not find virtual machine for #{vm_uuid.inspect}" - raise "No vm found for #{vm_uuid}" - end - else - return + vm = VirtualMachine.where(uuid: vm_uuid).first + if !vm + logger.warn "Could not find virtual machine for #{vm_uuid.inspect}" + raise "No vm found for #{vm_uuid}" end logger.info { "vm uuid: " + vm[:uuid] } @@ -472,15 +550,23 @@ class User < ArvadosModel # Send admin notifications def send_admin_notifications - AdminNotifier.new_user(self).deliver + AdminNotifier.new_user(self).deliver_now if not self.is_active then - AdminNotifier.new_inactive_user(self).deliver + AdminNotifier.new_inactive_user(self).deliver_now + end + end + + # Automatically setup if is_active flag turns on + def setup_on_activate + return if [system_user_uuid, anonymous_user_uuid].include?(self.uuid) + if is_active && (new_record? || is_active_changed?) + setup(openid_prefix: Rails.configuration.default_openid_prefix) end end # Automatically setup new user during creation def auto_setup_new_user - setup_repo_vm_links(nil, nil, Rails.configuration.default_openid_prefix) + setup(openid_prefix: Rails.configuration.default_openid_prefix) if username create_vm_login_permission_link(Rails.configuration.auto_setup_new_users_with_vm_uuid, username) @@ -499,7 +585,7 @@ class User < ArvadosModel if self.prefs_changed? if self.prefs_was.andand.empty? || !self.prefs_was.andand['profile'] profile_notification_address = Rails.configuration.user_profile_notification_address - ProfileNotifier.profile_created(self, profile_notification_address).deliver if profile_notification_address + ProfileNotifier.profile_created(self, profile_notification_address).deliver_now if profile_notification_address end end end