fix(hc): Introduce OrganizationService.get_default_organization (#52372)

Fix a silo access error when running a typical dev environment in the
single-org and split silo modes. Introduce a special region resolution
strategy that requires there to be only one region, which is a safe
assumption when there is only one organization.

Author: RyanSkonnord

Diff for: src/sentry/services/hybrid_cloud/organization/impl.py

@@ -110,6 +110,9 @@ def get_org_by_slug(
         except Organization.DoesNotExist:
             return None
 
+    def get_default_organization(self) -> RpcOrganization:
+        return serialize_rpc_organization(Organization.get_default())
+
     def check_membership_by_email(
         self, organization_id: int, email: str
     ) -> Optional[RpcOrganizationMember]:

Diff for: src/sentry/services/hybrid_cloud/organization/service.py

@@ -25,6 +25,7 @@
     ByOrganizationIdAttribute,
     ByOrganizationSlug,
     ByRegionName,
+    RequireSingleOrganization,
     UnimplementedRegionResolution,
 )
 from sentry.services.hybrid_cloud.rpc import RpcService, regional_rpc_method
@@ -189,6 +190,11 @@ def get_organization_by_slug(
             return None
         return org_context
 
+    @regional_rpc_method(resolve=RequireSingleOrganization())
+    @abstractmethod
+    def get_default_organization(self) -> RpcOrganization:
+        pass
+
     @regional_rpc_method(resolve=ByOrganizationId())
     @abstractmethod
     def add_organization_member(

Diff for: src/sentry/services/hybrid_cloud/region.py

@@ -4,9 +4,11 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from django.conf import settings
+
 from sentry.services.hybrid_cloud import ArgumentDict
 from sentry.services.hybrid_cloud.rpc import RpcServiceUnimplementedException
-from sentry.types.region import Region, get_region_by_name
+from sentry.types.region import Region, RegionResolutionError, get_region_by_name
 
 if TYPE_CHECKING:
     from sentry.db.models import BaseManager
@@ -94,6 +96,32 @@ def resolve(self, arguments: ArgumentDict) -> Region:
         return self._resolve_from_mapping(mapping)
 
 
+class RequireSingleOrganization(RegionResolution):
+    """Resolve to the only region in a single-organization environment.
+
+    Calling a service method with this resolution strategy will cause an error if the
+    environment is not configured with the "single organization" or has more than one
+    region.
+    """
+
+    def resolve(self, arguments: ArgumentDict) -> Region:
+        if not settings.SENTRY_SINGLE_ORGANIZATION:
+            raise RegionResolutionError("Method is available only in single-org environment")
+
+        all_region_names = list(
+            self.organization_mapping_manager.all()
+            .values_list("region_name", flat=True)
+            .distinct()[:2]
+        )
+        if len(all_region_names) == 0:
+            return get_region_by_name(settings.SENTRY_MONOLITH_REGION)
+        if len(all_region_names) != 1:
+            raise RegionResolutionError("Expected single-org environment to have only one region")
+
+        (single_region_name,) = all_region_names
+        return get_region_by_name(single_region_name)
+
+
 class UnimplementedRegionResolution(RegionResolution):
     """Indicate that a method's region resolution logic has not been implemented yet.
 

Diff for: src/sentry/web/frontend/auth_login.py

@@ -319,7 +319,7 @@ def get(self, request: Request, **kwargs) -> Response:
 
         # Single org mode -- send them to the org-specific handler
         if settings.SENTRY_SINGLE_ORGANIZATION:
-            org = Organization.get_default()
+            org = organization_service.get_default_organization()
             next_uri = reverse("sentry-auth-organization", args=[org.slug])
             return HttpResponseRedirect(next_uri)
 

Diff for: tests/sentry/hybrid_cloud/test_region.py

@@ -1,4 +1,5 @@
 import pytest
+from django.test import override_settings
 
 from sentry.db.postgres.roles import in_test_psql_role_override
 from sentry.models.organizationmapping import OrganizationMapping
@@ -8,14 +9,15 @@
     ByOrganizationIdAttribute,
     ByOrganizationObject,
     ByOrganizationSlug,
+    RequireSingleOrganization,
     UnimplementedRegionResolution,
 )
 from sentry.services.hybrid_cloud.rpc import RpcServiceUnimplementedException
 from sentry.silo import SiloMode
 from sentry.testutils import TestCase
 from sentry.testutils.region import override_regions
 from sentry.testutils.silo import assume_test_silo_mode, control_silo_test
-from sentry.types.region import Region, RegionCategory
+from sentry.types.region import Region, RegionCategory, RegionResolutionError
 
 
 @control_silo_test(stable=True)
@@ -26,11 +28,16 @@ def setUp(self):
             Region("europe", 2, "eu.sentry.io", RegionCategory.MULTI_TENANT),
         ]
         self.target_region = self.regions[0]
-        self.organization = self.create_organization()
-        org_mapping = OrganizationMapping.objects.get(organization_id=self.organization.id)
+        self.organization = self._create_org_in_region(self.target_region)
+
+    def _create_org_in_region(self, target_region):
+        with override_settings(SENTRY_REGION=target_region.name):
+            organization = self.create_organization()
+        org_mapping = OrganizationMapping.objects.get(organization_id=organization.id)
         with in_test_psql_role_override("postgres"):
-            org_mapping.region_name = self.target_region.name
+            org_mapping.region_name = target_region.name
             org_mapping.save()
+        return organization
 
     def test_by_organization_object(self):
         with override_regions(self.regions):
@@ -65,6 +72,26 @@ def test_by_organization_id_attribute(self):
             actual_region = region_resolution.resolve(arguments)
             assert actual_region == self.target_region
 
+    def test_require_single_organization(self):
+        region_resolution = RequireSingleOrganization()
+
+        with override_regions([self.target_region]), override_settings(
+            SENTRY_SINGLE_ORGANIZATION=True
+        ):
+            actual_region = region_resolution.resolve({})
+            assert actual_region == self.target_region
+
+        with override_regions([self.target_region]), override_settings(
+            SENTRY_SINGLE_ORGANIZATION=False
+        ):
+            with pytest.raises(RegionResolutionError):
+                region_resolution.resolve({})
+
+        with override_regions(self.regions), override_settings(SENTRY_SINGLE_ORGANIZATION=True):
+            self._create_org_in_region(self.regions[1])
+            with pytest.raises(RegionResolutionError):
+                region_resolution.resolve({})
+
     def test_unimplemented_region_resolution(self):
         with override_regions(self.regions):
             region_resolution = UnimplementedRegionResolution()