A platform for community discussion. Free, open, simple.
MT: Seed identity provider group claims for imported users (#43903)
Ruben Oussorenfc33a84d58aa
diff --git a/script/bulk_import/base.rb b/script/bulk_import/base.rbindex 79d3af680c5..3fb6278ba3f 100644--- a/script/bulk_import/base.rb+++ b/script/bulk_import/base.rb@@ -667,6 +667,8 @@ class BulkImport::Baseexternal_card_background_url]+ USER_ASSOCIATED_GROUP_COLUMNS = %i[user_id associated_group_id created_at updated_at]+USER_ASSOCIATED_ACCOUNT_COLUMNS = %i[provider_nameprovider_uid@@ -1137,6 +1139,10 @@ class BulkImport::Basecreate_records(rows, "user_associated_account", USER_ASSOCIATED_ACCOUNT_COLUMNS, &block)end+ def create_user_associated_groups(rows, &block)+ create_records(rows, "user_associated_group", USER_ASSOCIATED_GROUP_COLUMNS, &block)+ end+def create_user_custom_fields(rows, &block)create_records(rows, "user_custom_field", USER_CUSTOM_FIELD_COLUMNS, &block)end@@ -1604,6 +1610,12 @@ class BulkImport::Baseaccountend+ def process_user_associated_group(user_associated_group)+ user_associated_group[:created_at] = NOW+ user_associated_group[:updated_at] = NOW+ user_associated_group+ end+def process_group_user(group_user)group_user[:owner] ||= falsegroup_user[:created_at] = NOWdiff --git a/script/bulk_import/generic_bulk.rb b/script/bulk_import/generic_bulk.rbindex 087630bdaf7..0a969968295 100644--- a/script/bulk_import/generic_bulk.rb+++ b/script/bulk_import/generic_bulk.rb@@ -695,6 +695,7 @@ class BulkImport::Generic < BulkImport::Baseimport_user_statsmerge_delta_user_aliases if delta_import?+ import_user_associated_groupsimport_permalink_normalizationsimport_permalinks@@ -2011,6 +2012,71 @@ class BulkImport::Generic < BulkImport::Baserows&.closeend+ # An authenticator that provides group claims rewrites each user's+ # associated groups on every login, and only a destroyed claim row removes+ # the user from the Discourse groups that claim granted. Imported members+ # hold group_users rows alone, so seed the claim rows a login would have+ # created for the linked groups they already belong to; their next login+ # then reconciles against the provider like any other user's. A group+ # granted by several claims seeds all of them, and the login keeps only the+ # ones the provider still returns.+ def import_user_associated_groups+ puts "", "Importing user associated groups..."++ provider_names = Discourse.enabled_authenticators.select(&:provides_groups?).map(&:name)+ if provider_names.empty?+ puts " Skipped: no enabled authenticator provides group claims"+ return+ end++ links =+ GroupAssociatedGroup+ .joins(:associated_group)+ .where(associated_groups: { provider_name: provider_names })+ .pluck(:group_id, :associated_group_id)+ if links.empty?+ puts " Skipped: no Discourse group is linked to a #{provider_names.join(", ")} group"+ return+ end++ associated_group_ids_by_group_id =+ links.group_by(&:first).transform_values { |pairs| pairs.map(&:last).uniq }+ imported_user_ids = @users.values.to_set+ existing_claims =+ UserAssociatedGroup+ .where(associated_group_id: links.map(&:last).uniq)+ .pluck(:user_id, :associated_group_id)+ .to_set++ memberships =+ GroupUser+ .where(group_id: associated_group_ids_by_group_id.keys)+ .order(:user_id, :group_id)+ .pluck(:user_id, :group_id)++ seeded_associated_group_ids = Set.new+ seeded_user_ids = Set.new+ claims =+ memberships.flat_map do |user_id, group_id|+ next [] if imported_user_ids.exclude?(user_id)++ associated_group_ids_by_group_id[group_id].filter_map do |associated_group_id|+ next unless existing_claims.add?([user_id, associated_group_id])++ seeded_associated_group_ids << associated_group_id+ seeded_user_ids << user_id+ { user_id: user_id, associated_group_id: associated_group_id }+ end+ end++ create_user_associated_groups(claims) { |claim| claim }++ # The daily cleanup drops associated groups unused for a week; the seeded+ # claims count as use.+ AssociatedGroup.where(id: seeded_associated_group_ids.to_a).update_all(last_used: Time.zone.now)+ puts " Seeded #{claims.size} group claim(s) for #{seeded_user_ids.size} imported user(s)"+ end+def import_topicsputs "", "Importing topics..."diff --git a/spec/script/bulk_import/generic_bulk_spec.rb b/spec/script/bulk_import/generic_bulk_spec.rbindex 896b95eb8e2..f84383a2f11 100644--- a/spec/script/bulk_import/generic_bulk_spec.rb+++ b/spec/script/bulk_import/generic_bulk_spec.rb@@ -1586,6 +1586,155 @@ if generic_import_dependencies_availablesource_db&.closeendend++ describe "#import_user_associated_groups" do+ fab!(:employee, :user)+ fab!(:customer, :user)+ fab!(:claimed_customer, :user)+ fab!(:manual_customer, :user)+ fab!(:employee_group, :group)+ fab!(:customer_group, :group)+ fab!(:unlinked_group, :group)++ fab!(:internal_claim) do+ AssociatedGroup.create!(+ name: "SailPoint Internal",+ provider_name: "oidc",+ provider_id: "SailPoint Internal",+ last_used: 2.weeks.ago,+ )+ end+ fab!(:employee_claim) do+ AssociatedGroup.create!(+ name: "SailPoint Employee",+ provider_name: "oidc",+ provider_id: "SailPoint Employee",+ last_used: 2.weeks.ago,+ )+ end+ fab!(:customer_claim) do+ AssociatedGroup.create!(+ name: "Customer",+ provider_name: "oidc",+ provider_id: "Customer",+ last_used: 2.weeks.ago,+ )+ end+ fab!(:saml_claim) do+ AssociatedGroup.create!(+ name: "Customer",+ provider_name: "saml",+ provider_id: "Customer",+ last_used: 2.weeks.ago,+ )+ end++ let(:importer) do+ described_class.allocate.tap do |instance|+ instance.instance_variable_set(+ :@users,+ { 10 => employee.id, 20 => customer.id, 30 => claimed_customer.id },+ )+ instance.instance_variable_set(+ :@raw_connection,+ ActiveRecord::Base.connection.raw_connection,+ )+ instance.instance_variable_set(:@encoder, PG::TextEncoder::CopyRow.new)+ end+ end++ def claims_for(user)+ user.associated_groups.reload.order(:provider_id).pluck(:provider_name, :provider_id)+ end++ before do+ GroupAssociatedGroup.create!(group: employee_group, associated_group: internal_claim)+ GroupAssociatedGroup.create!(group: employee_group, associated_group: employee_claim)+ GroupAssociatedGroup.create!(group: customer_group, associated_group: customer_claim)+ GroupAssociatedGroup.create!(group: customer_group, associated_group: saml_claim)++ [employee_group, customer_group, unlinked_group].each do |group|+ group.group_users.delete_all+ end+ GroupUser.create!(group: employee_group, user: employee)+ GroupUser.create!(group: customer_group, user: customer)+ GroupUser.create!(group: unlinked_group, user: customer)+ GroupUser.create!(group: customer_group, user: claimed_customer)+ GroupUser.create!(group: customer_group, user: manual_customer)+ UserAssociatedGroup.create!(user: claimed_customer, associated_group: customer_claim)++ allow(Discourse).to receive(:enabled_authenticators).and_return(+ [instance_double(Auth::Authenticator, name: "oidc", provides_groups?: true)],+ )+ end++ it "seeds every claim linked to an imported member's groups, once" do+ expect { importer.import_user_associated_groups }.to change {+ UserAssociatedGroup.count+ }.by(3)++ expect(claims_for(employee)).to eq(+ [%w[oidc SailPoint\ Employee], %w[oidc SailPoint\ Internal]],+ )+ expect(claims_for(customer)).to eq([%w[oidc Customer]])+ expect(claims_for(claimed_customer)).to eq([%w[oidc Customer]])+ expect(claims_for(manual_customer)).to be_empty+ expect(saml_claim.reload.users).to be_empty++ expect { importer.import_user_associated_groups }.not_to change {+ UserAssociatedGroup.count+ }+ end++ it "marks the seeded associated groups as used and leaves the others alone" do+ importer.import_user_associated_groups++ expect(internal_claim.reload.last_used).to be_within(1.minute).of(Time.zone.now)+ expect(employee_claim.reload.last_used).to be_within(1.minute).of(Time.zone.now)+ expect(customer_claim.reload.last_used).to be_within(1.minute).of(Time.zone.now)+ expect(saml_claim.reload.last_used).to be_within(1.minute).of(2.weeks.ago)+ end++ it "reconciles seeded memberships with the claims returned by subsequent logins" do+ GroupUser.create!(group: unlinked_group, user: employee)+ importer.import_user_associated_groups++ result = Auth::Result.new+ result.user = employee+ result.authenticator_name = "oidc"+ result.extra_data = { provider: "oidc" }+ result.associated_groups = [{ id: employee_claim.provider_id, name: employee_claim.name }]+ result.apply_associated_attributes!++ expect(employee.associated_groups.reload).to contain_exactly(employee_claim)+ expect(employee.groups.reload).to include(employee_group, unlinked_group)++ result.associated_groups = []+ result.apply_associated_attributes!++ expect(employee.associated_groups.reload).to be_empty+ expect(employee.groups.reload).not_to include(employee_group)+ expect(employee.groups).to include(unlinked_group)+ end++ it "does nothing when no enabled authenticator provides group claims" do+ allow(Discourse).to receive(:enabled_authenticators).and_return(+ [instance_double(Auth::Authenticator, name: "oidc", provides_groups?: false)],+ )++ expect { importer.import_user_associated_groups }.not_to change {+ UserAssociatedGroup.count+ }+ end++ it "does nothing when the provider's associated groups grant no Discourse group" do+ GroupAssociatedGroup.where.not(associated_group: saml_claim).delete_all++ expect { importer.import_user_associated_groups }.not_to change {+ UserAssociatedGroup.count+ }+ end+ endendRSpec.describe BulkImport::Base do