Skip to content

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.rb
index 79d3af680c5..3fb6278ba3f 100644
--- a/script/bulk_import/base.rb
+++ b/script/bulk_import/base.rb
@@ -667,6 +667,8 @@ class BulkImport::Base
external_card_background_url
]
+ USER_ASSOCIATED_GROUP_COLUMNS = %i[user_id associated_group_id created_at updated_at]
+
USER_ASSOCIATED_ACCOUNT_COLUMNS = %i[
provider_name
provider_uid
@@ -1137,6 +1139,10 @@ class BulkImport::Base
create_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::Base
account
end
+ 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] ||= false
group_user[:created_at] = NOW
diff --git a/script/bulk_import/generic_bulk.rb b/script/bulk_import/generic_bulk.rb
index 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::Base
import_user_stats
merge_delta_user_aliases if delta_import?
+ import_user_associated_groups
import_permalink_normalizations
import_permalinks
@@ -2011,6 +2012,71 @@ class BulkImport::Generic < BulkImport::Base
rows&.close
end
+ # 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_topics
puts "", "Importing topics..."
diff --git a/spec/script/bulk_import/generic_bulk_spec.rb b/spec/script/bulk_import/generic_bulk_spec.rb
index 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_available
source_db&.close
end
end
+
+ 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
+ end
end
RSpec.describe BulkImport::Base do