Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(managed-warehouse): push member teams to hogtower (#130337)

James Greenhill577a3d927f87
diff --git a/posthog/settings/base_variables.py b/posthog/settings/base_variables.py
index d38572bb7a50..8a0dc08baa84 100644
--- a/posthog/settings/base_variables.py
+++ b/posthog/settings/base_variables.py
@@ -88,6 +88,11 @@ DUCKGRES_PG_PORT: int = get_from_env("DUCKGRES_PG_PORT", 5432, type_cast=int)
# HOGTOWER_API_URL is set, control-plane calls go to hogtower's /api/v2 instead of duckgres.
HOGTOWER_API_URL: str | None = get_from_env("HOGTOWER_API_URL", optional=True)
HOGTOWER_INTERNAL_SECRET: str | None = get_from_env("HOGTOWER_INTERNAL_SECRET", optional=True)
+# Push each member's visible projects, with their warehouse access level, to hogtower, which
+# mints team-scoped hoglake tokens from its copy. Needs HOGTOWER_API_URL.
+HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED: bool = get_from_env(
+ "HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED", False, type_cast=str_to_bool
+)
# MANAGED_WAREHOUSE_INGRESS_IPS is the comma-separated address set the shared managed-warehouse
# `dw` load balancer answers on. The warehouse-source host guard exempts a managed warehouse host
# from the private-address check only when every resolved address is in this set, so an empty value
diff --git a/posthog/tasks/scheduled.py b/posthog/tasks/scheduled.py
index fee31fa3ebf4..531ef0a2c259 100644
--- a/posthog/tasks/scheduled.py
+++ b/posthog/tasks/scheduled.py
@@ -115,6 +115,7 @@ from products.feature_flags.backend.tasks import (
)
from products.legal_documents.backend.facade.tasks import reconcile_pending_legal_documents
from products.logs.backend.facade.tasks import logs_alert_events_cleanup_task
+from products.managed_warehouse.backend.facade.tasks import push_all_warehouse_member_teams
from products.mcp_registry.backend.facade.tasks import MCP_REGISTRY_SYNC_CRONTAB, run_mcp_registry_sync
from products.notebooks.backend.facade.tasks import cleanup_widget_snapshots
from products.pulse.backend.tasks import mark_stale_pulse_briefs_failed
@@ -839,6 +840,15 @@ def setup_periodic_tasks(sender: Celery, **kwargs: Any) -> None:
expires=1800,
)
+ # The full push of member teams to hogtower: the net under the change signals, for team-scoped
+ # hoglake tokens. A no-op unless HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED.
+ sender.add_periodic_task(
+ crontab(minute="23"),
+ push_all_warehouse_member_teams.s(),
+ name="push managed warehouse member teams to hogtower",
+ expires=3000,
+ )
+
# Every 30 minutes, send decide request counts to the main posthog instance
sender.add_periodic_task(
crontab(minute="*/30"),
diff --git a/posthog/test/repo_invariants/setup_receivers_baseline.txt b/posthog/test/repo_invariants/setup_receivers_baseline.txt
index 28f3c423b1ef..50b8f71a2f09 100644
--- a/posthog/test/repo_invariants/setup_receivers_baseline.txt
+++ b/posthog/test/repo_invariants/setup_receivers_baseline.txt
@@ -92,6 +92,9 @@ post_delete:posthog.storage.team_access_cache_signal_handlers.organization_membe
post_delete:posthog.storage.team_access_cache_signal_handlers.personal_api_key_deleted
post_delete:posthog.storage.team_access_cache_signal_handlers.project_secret_api_key_deleted
post_delete:posthog.storage.team_access_cache_signal_handlers.team_deleted_auth_cache
+post_delete:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.property_rule_changed
+post_delete:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.role_membership_deleted
+post_delete:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.rule_changed
post_delete:products.access_control.backend.property_access_control._invalidate_restriction_cache_on_change
post_delete:products.actions.backend.models.action.action_deleted
post_delete:products.ai_observability.backend.models.llm_prompt.invalidate_llm_prompt_cache
@@ -121,6 +124,8 @@ post_delete:products.feature_flags.backend.local_evaluation.experiment_changed
post_delete:products.feature_flags.backend.local_evaluation.feature_flag_changed
post_delete:products.feature_flags.backend.local_evaluation.team_deleted
post_delete:products.managed_warehouse.backend.models._observe_duckgres_server_delete
+post_delete:products.managed_warehouse.backend.signals.membership_deleted
+post_delete:products.managed_warehouse.backend.signals.team_deleted
post_delete:products.replay_vision.backend.media_expiry.expire_media_asset
post_delete:products.review_hog.backend.ownership._invalidate_owned_repositories_on_delete
post_delete:products.signals.backend.implementation_pr_cache._refresh_for_artefact
@@ -190,6 +195,9 @@ post_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cac
post_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cache_on_project_save
post_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cache_on_realtime_cohort_access_save
post_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cache_on_save
+post_save:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.property_rule_changed
+post_save:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.role_membership_changed
+post_save:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.rule_changed
post_save:products.access_control.backend.property_access_control._invalidate_restriction_cache_on_change
post_save:products.actions.backend.models.action.action_saved
post_save:products.ai_observability.backend.models.clustering_job.create_default_clustering_jobs_for_new_team
@@ -248,6 +256,9 @@ post_save:products.feature_flags.backend.models.organization_feature_flags_confi
post_save:products.feature_flags.backend.session_recording_links.relink_teams_on_key_change
post_save:products.knowledge_writer.backend.receivers.open_docs_pull_request
post_save:products.managed_warehouse.backend.models._observe_duckgres_server_save
+post_save:products.managed_warehouse.backend.signals.membership_saved
+post_save:products.managed_warehouse.backend.signals.team_saved
+post_save:products.managed_warehouse.backend.signals.user_saved
post_save:products.metrics.backend.dashboard_import.receivers.schedule_import_finalization
post_save:products.posthog_ai.backend.receivers.mark_conversation_sandbox_on_first_run
post_save:products.review_hog.backend.ownership._invalidate_owned_repositories_on_save
@@ -299,6 +310,7 @@ pre_delete:posthog.storage.gateway_credential_signal_handlers._clear_secret_key_
pre_delete:posthog.storage.team_access_cache_signal_handlers.clear_project_secret_api_key_cache_on_delete
pre_delete:posthog.storage.team_llm_gateway_policy_signal_handlers._clear_cache_on_delete
pre_delete:posthog.storage.team_metadata_signal_handlers.clear_team_metadata_cache_on_delete
+pre_delete:products.access_control.backend.facade.api.connect_access_change_receivers.<locals>.role_membership_deleting
pre_delete:products.alerts.backend.activity_logging.cleanup_alert_hog_functions
pre_delete:products.alerts.backend.activity_logging.delete_platform_shadow_copy
pre_delete:products.alerts.backend.activity_logging.handle_alert_subscription_delete
@@ -307,6 +319,7 @@ pre_delete:products.customer_analytics.backend.signals.delete_private_account_vi
pre_delete:products.experiments.backend.activity_logging.handle_experiment_holdout_delete
pre_delete:products.experiments.backend.activity_logging.handle_experiment_saved_metric_delete
pre_delete:products.managed_migrations.backend.activity_logging.handle_batch_import_delete
+pre_delete:products.managed_warehouse.backend.signals.membership_deleting
pre_delete:products.replay_vision.backend.observation_notes.delete_scanner_observation_notes
pre_delete:products.tasks.backend.models.clear_channel_repositories_on_github_integration_delete
pre_delete:products.tasks.backend.team_deletion.cancel_task_workflows_on_team_delete
@@ -331,6 +344,7 @@ pre_save:products.event_definitions.backend.models.event_definition._capture_eve
pre_save:products.feature_flags.backend.flag_version_sync.capture_cohort_definition_before_save
pre_save:products.feature_flags.backend.flag_version_sync.capture_flag_definition_before_save
pre_save:products.feature_flags.backend.session_recording_links.capture_replay_link_key_before_save
+pre_save:products.managed_warehouse.backend.signals.team_saving
pre_save:products.signals.backend.receivers.capture_prior_state
pre_save:products.surveys.backend.models.pre_save_survey
pre_save:products.web_analytics.backend.heatmap_history_expiry.invalidate_history
diff --git a/products/access_control/backend/facade/api.py b/products/access_control/backend/facade/api.py
index f9d5b56697f1..5395d1005939 100644
--- a/products/access_control/backend/facade/api.py
+++ b/products/access_control/backend/facade/api.py
@@ -19,14 +19,14 @@ Do NOT:
from __future__ import annotations
from collections import defaultdict
-from collections.abc import Collection, Sequence
+from collections.abc import Callable, Collection, Sequence
from copy import copy
from typing import cast
from uuid import UUID
from django.db import transaction
from django.db.models import Q
-from django.db.models.signals import post_save
+from django.db.models.signals import post_delete, post_save, pre_delete
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.utils import timezone
@@ -871,7 +871,124 @@ def available_access_levels() -> list[PropertyAccessLevel]:
return list(PropertyAccessLevel)
+_PROPERTY_LEVEL_ORDER = (PropertyAccessLevel.NONE, PropertyAccessLevel.READ, PropertyAccessLevel.READ_WRITE)
+
+
+def stored_property_rule_floor(*, user: User, team_id: int) -> PropertyAccessLevel | None:
+ """The lowest level the stored property rules can give ``user`` on one property of the team.
+
+ The property-rule counterpart of ``UserAccessControl.stored_rule_floor``, with the same
+ candidates per property: the user's member rows, else their role rows and the default rows.
+ Rows match as ``_resolve_access_level`` matches them: a row naming the user's membership is
+ a member row whatever its role, and a row naming one of the user's roles is a role row.
+ It holds whether or not the organization is entitled to property access control or roles.
+ ``None`` means no stored rule applies. This includes org admins, who bypass property rules.
+ """
+ organization_id = Team.objects.filter(id=team_id).values_list("organization_id", flat=True).first()
+ if organization_id is None:
+ return None
+ membership = OrganizationMembership.objects.filter(user=user, organization_id=organization_id).first()
+ if membership is None or membership.level >= OrganizationMembership.Level.ADMIN:
+ return None
+ role_ids = list(
+ RoleMembership.objects.filter(user=user, role__organization_id=organization_id)
+ .valid_for_authorization()
+ .values_list("role_id", flat=True)
+ )
+ rows = PropertyAccessControl.objects.filter(team_id=team_id, property_definition__isnull=False).filter(
+ Q(organization_member=None, role=None) | Q(organization_member_id=membership.id) | Q(role_id__in=role_ids)
+ )
+ rows_by_property: dict[UUID | None, list[PropertyAccessControl]] = {}
+ for row in rows:
+ rows_by_property.setdefault(row.property_definition_id, []).append(row)
+ lowest: PropertyAccessLevel | None = None
+ for property_rows in rows_by_property.values():
+ member_rows = [row for row in property_rows if row.organization_member_id == membership.id]
+ for row in member_rows or property_rows:
+ # A level outside the order is unknown: count it as no access.
+ level = next((known for known in _PROPERTY_LEVEL_ORDER if known.value == row.access_level), None)
+ level = level or PropertyAccessLevel.NONE
+ if lowest is None or _PROPERTY_LEVEL_ORDER.index(level) < _PROPERTY_LEVEL_ORDER.index(lowest):
+ lowest = level
+ return lowest
+
+
+def connect_access_change_receivers(
+ *,
+ on_rule_change: Callable[[int, str], None],
+ on_role_membership_change: Callable[[int, UUID], None],
+ is_active: Callable[[], bool],
+ dispatch_uid: str,
+) -> None:
+ """Call back when an access rule or a role membership is saved or deleted.
+
+ ``on_rule_change(team_id, resource)`` runs after a rule is saved or deleted. A property rule
+ comes in as the ``property_definition`` resource.
+ ``on_role_membership_change(user_id, organization_id)`` runs after a role membership is
+ saved or deleted. ``organization_id`` is the role's organization, read before a delete while
+ the role is still there: most role memberships carry no organization membership.
+
+ Neither runs while ``is_active()`` is false, so a disabled caller costs no role query.
+
+ Both run inside the change's transaction: defer real work with ``transaction.on_commit``.
+ Only ids cross this boundary, never the models.
+ """
+
+ def rule_changed(sender: object, instance: AccessControl, **kwargs: object) -> None:
+ if is_active():
+ on_rule_change(instance.team_id, instance.resource)
+
+ def role_membership_changed(sender: object, instance: RoleMembership, **kwargs: object) -> None:
+ if is_active():
+ on_role_membership_change(instance.user_id, instance.role.organization_id)
+
+ # Outside a transaction a callback's on_commit runs at once, so it must not run before the
+ # delete: read the organization before it, and call back after it.
+ pending_attr = f"_{dispatch_uid}_role_organization_id"
+
+ def role_membership_deleting(sender: object, instance: RoleMembership, **kwargs: object) -> None:
+ if is_active():
+ setattr(instance, pending_attr, instance.role.organization_id)
+
+ def role_membership_deleted(sender: object, instance: RoleMembership, **kwargs: object) -> None:
+ organization_id = getattr(instance, pending_attr, None)
+ if organization_id is not None:
+ on_role_membership_change(instance.user_id, organization_id)
+
+ # weak=False: the receivers are closures, and nothing else holds them.
+ post_save.connect(rule_changed, sender=AccessControl, weak=False, dispatch_uid=f"{dispatch_uid}_rule_saved")
+ post_delete.connect(rule_changed, sender=AccessControl, weak=False, dispatch_uid=f"{dispatch_uid}_rule_deleted")
+
+ def property_rule_changed(sender: object, instance: PropertyAccessControl, **kwargs: object) -> None:
+ if is_active():
+ on_rule_change(instance.team_id, "property_definition")
+
+ post_save.connect(
+ property_rule_changed,
+ sender=PropertyAccessControl,
+ weak=False,
+ dispatch_uid=f"{dispatch_uid}_property_rule_saved",
+ )
+ post_delete.connect(
+ property_rule_changed,
+ sender=PropertyAccessControl,
+ weak=False,
+ dispatch_uid=f"{dispatch_uid}_property_rule_deleted",
+ )
+ post_save.connect(
+ role_membership_changed, sender=RoleMembership, weak=False, dispatch_uid=f"{dispatch_uid}_role_saved"
+ )
+ pre_delete.connect(
+ role_membership_deleting, sender=RoleMembership, weak=False, dispatch_uid=f"{dispatch_uid}_role_deleting"
+ )
+ post_delete.connect(
+ role_membership_deleted, sender=RoleMembership, weak=False, dispatch_uid=f"{dispatch_uid}_role_deleted"
+ )
+
+
__all__ = [
+ "connect_access_change_receivers",
+ "stored_property_rule_floor",
"InvalidPropertyAccessControlTargetError",
"PropertyAccessControlRuleNotFoundError",
"PropertyAccessLevel",
diff --git a/products/access_control/backend/facade/testing.py b/products/access_control/backend/facade/testing.py
index 8a0d34773e1c..6098464042a6 100644
--- a/products/access_control/backend/facade/testing.py
+++ b/products/access_control/backend/facade/testing.py
@@ -1,12 +1,14 @@
"""Test-support facade for access_control.
-Test suites outside the product plant roles, role members and access control rows. They get
+Test suites outside the product plant roles, role members, access control rows and property
+access control rows. They get
them here instead of importing the models.
"""
from uuid import UUID
from products.access_control.backend.models.access_control import AccessControl
+from products.access_control.backend.models.property_access_control import PropertyAccessControl
from products.access_control.backend.models.role import Role, RoleMembership
@@ -46,3 +48,33 @@ def create_access_control(
organization_member_id=organization_member_id,
role_id=role_id,
).id
+
+
+def delete_access_control(*, team_id: int, access_control_id: UUID) -> None:
+ """Delete one access control row, signals and all, as the production delete does."""
+ AccessControl.objects.get(id=access_control_id, team_id=team_id).delete()
+
+
+def remove_role_member(*, organization_id: UUID, role_membership_id: UUID) -> None:
+ RoleMembership.objects.get(id=role_membership_id, role__organization_id=organization_id).delete()
+
+
+def create_property_access_control(
+ *,
+ team_id: int,
+ property_definition_id: UUID,
+ access_level: str,
+ organization_member_id: UUID | None = None,
+ role_id: UUID | None = None,
+) -> UUID:
+ return PropertyAccessControl.objects.create(
+ team_id=team_id,
+ property_definition_id=property_definition_id,
+ access_level=access_level,
+ organization_member_id=organization_member_id,
+ role_id=role_id,
+ ).id
+
+
+def delete_property_access_control_rule(*, team_id: int, property_access_control_id: UUID) -> None:
+ PropertyAccessControl.objects.get(id=property_access_control_id, team_id=team_id).delete()
diff --git a/products/access_control/backend/facade/user_access_control.py b/products/access_control/backend/facade/user_access_control.py
index 5102fb46645d..b3705c848e78 100644
--- a/products/access_control/backend/facade/user_access_control.py
+++ b/products/access_control/backend/facade/user_access_control.py
@@ -1312,6 +1312,56 @@ class UserAccessControl:
return False
+ def stored_rule_floor(self, resources: Iterable[APIScopeObject]) -> Optional[AccessControlLevel]:
+ """The lowest level the stored rules on ``resources`` can give this user in this team.
+
+ For a caller that copies access to a place that cannot follow PostHog's resolution, such as
+ a grant over a whole warehouse namespace. The floor holds under either resolution mode and
+ whether or not the organization is entitled to access control or roles. So a later change
+ to either can only raise what PostHog enforces above it, never drop it below.
+
+ Each scope (the resource, or one object) contributes its lowest candidate row. The
+ candidates are the user's member rows, if the scope has any. Otherwise they are the rows of
+ the user's roles and the default rows, because a role rule may not apply. Every resolution
+ picks one of the candidates or a level from a broader scope, which contributes on its own.
+ A ``project`` rule on this team contributes only when it denies the project.
+
+ ``None`` means no stored rule applies. This includes org admins, who bypass every rule.
+ """
+ membership = self._organization_membership
+ if not EE_AVAILABLE or not self._team or not membership or self.is_organization_admin:
+ return None
+ role_ids = list(
+ cast(Any, self._user)
+ .role_memberships.filter(role__organization_id=self._organization_id)
+ .valid_for_authorization()
+ .values_list("role_id", flat=True)
+ )
+ rows = AccessControl.objects.filter(team_id=self._team.id, resource__in=list(resources)).filter(
+ Q(organization_member=None, role=None)
+ | Q(organization_member_id=membership.id, role=None)
+ | Q(organization_member=None, role_id__in=role_ids)
+ )
+ rows_by_scope: dict[tuple[str, Optional[str]], list[AccessControl]] = defaultdict(list)
+ for row in rows:
+ rows_by_scope[(row.resource, row.resource_id)].append(row)
+
+ lowest: Optional[AccessControlLevel] = None
+ for (resource, resource_id), scope_rows in rows_by_scope.items():
+ member_rows = [row for row in scope_rows if row.organization_member_id is not None]
+ candidates = member_rows or scope_rows
+ if resource == "project":
+ if resource_id == str(self._team.id) and any(r.access_level == NO_ACCESS_LEVEL for r in candidates):
+ return cast(AccessControlLevel, NO_ACCESS_LEVEL)
+ continue
+ order = ordered_access_levels(cast(APIScopeObject, resource))
+ for row in candidates:
+ # A level outside the order is unknown: count it as no access.
+ level = cast(AccessControlLevel, row.access_level if row.access_level in order else NO_ACCESS_LEVEL)
+ if lowest is None or order.index(level) < order.index(lowest):
+ lowest = level
+ return lowest
+
def effective_access_level_for_resource(self, resource: APIScopeObject) -> Optional[AccessControlLevel]:
"""
Get the effective access level for a resource, considering both resource-level
diff --git a/products/managed_warehouse/backend/README.md b/products/managed_warehouse/backend/README.md
index fbd04530474b..920a7764c8bd 100644
--- a/products/managed_warehouse/backend/README.md
+++ b/products/managed_warehouse/backend/README.md
@@ -75,6 +75,18 @@ Data modeling shadow materialization starts when its feature flag is enabled, th
Trino shadow materialization has a six-hour execution deadline. Its Temporal activity allows six hours and five minutes so cancellation and cleanup can finish before the activity times out, and requires a heartbeat every two minutes. Deadline failures retain an explicit timeout message on the modeling job. Alias reconciliation keeps its separate five-minute execution deadline.
+## Member teams pushed to hogtower
+
+hogtower mints team-scoped hoglake tokens from its own copy of which projects each organization member can see. With `HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED` and `HOGTOWER_API_URL` set, `member_teams.py` keeps that copy current:
+
+- Each visible project goes in at the member's level on warehouse objects. `viewer` becomes `read`, and `editor` or above becomes `write`. A project where the level is `none` is left out.
+- A team grant covers the whole namespace, so it cannot honor a rule on a single table, view, source or property, and it cannot follow PostHog's resolution of rules either. The level is therefore capped by the floor of the member's stored rules: the lowest level any of them can give, under either resolution mode and with or without the access-control entitlements (`UserAccessControl.stored_rule_floor` and `stored_property_rule_floor`). A member denied one table or property, or a private project, gets no grant. `viewer` on one object, or a read-only property, caps the grant at `read`. The cap can be stricter than PostHog, never looser. For example, a role that shares a hidden table does not lift the floor, because the role rule may not apply. So a switch of resolution mode or entitlement needs no push.
+- A member who leaves the organization, or whose user is deactivated, is removed. hogtower then revokes every team credential they own.
+- `signals.py` enqueues a push after a change to a membership, a role membership, or a project (created, deleted, or moved to another organization), or to an access rule on the project, on warehouse data, or on a property. Receivers that read state before a write only record it; the enqueue runs after the write, so a push never reads the old state. The push runs as a Celery task that retries for about ten hours.
+- `push managed warehouse member teams to hogtower` runs every hour and pushes every member of every Trino warehouse that hogtower lists. It catches changes that no signal reports, such as a user's reactivation. It also removes the members that hogtower still holds who have left, so a removal whose own push gave up is still reconciled.
+
+Each push sends the member's whole team set, versioned by the database clock. hogtower keeps the highest version, so pushes may finish in any order.
+
## Environment variables
The workflow obtains its DuckLake configuration from the following environment variables:
diff --git a/products/managed_warehouse/backend/apps.py b/products/managed_warehouse/backend/apps.py
index 1b7e66fbb6c7..60efd3de24b5 100644
--- a/products/managed_warehouse/backend/apps.py
+++ b/products/managed_warehouse/backend/apps.py
@@ -6,3 +6,9 @@ class ManagedWarehouseConfig(AppConfig):
name = "products.managed_warehouse.backend"
label = "managed_warehouse"
verbose_name = "Managed warehouse"
+
+ def ready(self) -> None:
+ # Membership and access changes happen outside web requests too, so every process connects.
+ from products.managed_warehouse.backend import signals # noqa: PLC0415
+
+ signals.connect()
diff --git a/products/managed_warehouse/backend/facade/tasks.py b/products/managed_warehouse/backend/facade/tasks.py
index 230a4e16d216..5c89d5c84515 100644
--- a/products/managed_warehouse/backend/facade/tasks.py
+++ b/products/managed_warehouse/backend/facade/tasks.py
@@ -1,3 +1,3 @@
-from products.managed_warehouse.backend.tasks import load_internal_warehouse
+from products.managed_warehouse.backend.tasks import load_internal_warehouse, push_all_warehouse_member_teams
-__all__ = ["load_internal_warehouse"]
+__all__ = ["load_internal_warehouse", "push_all_warehouse_member_teams"]
diff --git a/products/managed_warehouse/backend/member_teams.py b/products/managed_warehouse/backend/member_teams.py
new file mode 100644
index 000000000000..cf31d7d01cae
--- /dev/null
+++ b/products/managed_warehouse/backend/member_teams.py
@@ -0,0 +1,301 @@
+"""Push each organization member's projects to hogtower, for team-scoped hoglake tokens.
+
+hogtower mints a team credential's token from its own copy of which teams the credential's
+owner can see. PostHog is not a live dependency of that mint, so PostHog pushes the copy:
+
+- Every team the member can see, by both access-control systems (``visible_teams_for_user``),
+ goes in at the member's level on warehouse objects: ``viewer`` is ``read``, ``editor`` and
+ above are ``write``. A team where that level is ``none`` is left out.
+- A team grant covers the whole namespace, so it cannot honor a rule on one table, view,
+ source or property, and it cannot follow PostHog's resolution of rules either. So the level
+ is capped by the floor of the stored rules that apply to the member (see
+ ``UserAccessControl.stored_rule_floor``): the lowest level any of them can give, under either
+ resolution mode, with or without the access-control entitlements. A member denied one table
+ or one property gets no grant on the team; ``viewer`` on one object, or a read-only property,
+ caps the grant at ``read``. The cap can be stricter than PostHog, never looser, so a switch of
+ resolution mode or of entitlement needs no push.
+- A member who has left the organization, or whose user is deactivated, is removed. hogtower
+ then revokes every team credential the member owns.
+
+Each push carries the member's whole team set and a version: the database clock, read before
+the state is. hogtower keeps the highest version and answers 409 for an older one, which here
+means a newer push already landed. Every change enqueues a push after it commits, so the last
+push to run reads the change, and hogtower settles on it whatever order the pushes finish in.
+A full push runs on a schedule as well, for anything a signal missed. It also removes the
+members hogtower still holds who have left, for a removal whose own push gave up.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Callable
+from typing import Literal
+
+from django.conf import settings
+from django.core.cache import cache
+from django.db import connection
+
+import structlog
+
+from posthog.models import Organization, OrganizationMembership, User
+from posthog.scopes import APIScopeObject
+from posthog.user_permissions import UserPermissions
+
+from products.access_control.backend.facade.api import stored_property_rule_floor
+from products.access_control.backend.facade.contracts import PropertyAccessLevel
+from products.access_control.backend.facade.user_access_control import UserAccessControl, visible_teams_for_user
+from products.managed_warehouse.backend.metrics import record_counter
+from products.managed_warehouse.backend.presentation import hogtower
+
+logger = structlog.get_logger(__name__)
+
+READ = "read"
+WRITE = "write"
+# The access-control resource whose level decides read or write on a team's namespace.
+WAREHOUSE_RESOURCE: APIScopeObject = "warehouse_objects"
+# Every resource whose rules can lower a member's access to the team or to data in its namespace.
+RESTRICTING_RESOURCES: tuple[APIScopeObject, ...] = (
+ "project",
+ WAREHOUSE_RESOURCE,
+ "external_data_source",
+ "warehouse_table",
+ "warehouse_view",
+)
+_LEVEL_ORDER = ("none", "viewer", "editor", "manager")
+# A property rule caps the namespace: a hidden property leaves the team out, a read-only one
+# allows reads only.
+_PROPERTY_CAPS = {PropertyAccessLevel.NONE: "none", PropertyAccessLevel.READ: "viewer"}
+_READ_LEVELS = frozenset({"viewer"})
+_WRITE_LEVELS = frozenset({"editor", "manager"})
+
+# A push waiting in the queue covers every change made before it runs, so a second one is
+# not enqueued. The key is cleared when the push starts, so a change made while it runs
+# enqueues another. The timeout only bounds a key whose push never ran.
+_PENDING_TIMEOUT_SECONDS = 600
+# A short delay lets the changes of one request share one push.
+_ENQUEUE_COUNTDOWN_SECONDS = 5
+
+Outcome = Literal["pushed", "removed", "superseded", "no_warehouse", "rejected"]
+
+
+class MemberTeamsPushError(Exception):
+ """A push hogtower did not accept and may accept on retry (transport error, 5xx)."""
+
+
+def is_enabled() -> bool:
+ return bool(getattr(settings, "HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED", False)) and hogtower.is_configured()
+
+
+def member_teams(organization: Organization, user: User) -> dict[int, str]:
+ """The teams ``user`` can see in ``organization``, each with ``read`` or ``write``."""
+ access = UserAccessControl(user, organization_id=str(organization.id))
+ visible = visible_teams_for_user(organization, access, UserPermissions(user)).values_list("id", flat=True)
+ teams: dict[int, str] = {}
+ for team_id, team_access in access.for_team_ids(list(visible)).items():
+ level = _namespace_level(team_access, user, team_id)
+ if level in _WRITE_LEVELS:
+ teams[team_id] = WRITE
+ elif level in _READ_LEVELS:
+ teams[team_id] = READ
+ return teams
+
+
+def _namespace_level(team_access: UserAccessControl, user: User, team_id: int) -> str | None:
+ """The member's level on warehouse objects, capped by the floor of their stored rules."""
+ resolved = team_access.access_level_for_resource(WAREHOUSE_RESOURCE)
+ if resolved is None:
+ return None
+ levels: list[str | None] = [resolved.access_level, team_access.stored_rule_floor(RESTRICTING_RESOURCES)]
+ property_floor = stored_property_rule_floor(user=user, team_id=team_id)
+ if property_floor is not None:
+ levels.append(_PROPERTY_CAPS.get(property_floor))
+ known = [level for level in levels if level is not None]
+ # A level outside the order is unknown: treat it as no access.
+ return min(known, key=lambda level: _LEVEL_ORDER.index(level) if level in _LEVEL_ORDER else -1)
+
+
+def _version() -> int:
+ """Microseconds on the database clock: one clock for every web and worker host."""
+ with connection.cursor() as cursor:
+ cursor.execute("SELECT (EXTRACT(EPOCH FROM clock_timestamp()) * 1000000)::bigint")
+ row = cursor.fetchone()
+ return int(row[0])
+
+
+def _record(outcome: str) -> None:
+ record_counter("managed_warehouse.member_teams.push", 1, {"outcome": outcome})
+
+
+def push_member(organization_id: str, user_uuid: str) -> Outcome:
+ """Push one member's teams to hogtower, or their removal when they are no longer a member.
+
+ Raises :class:`MemberTeamsPushError` when a retry may succeed.
+ """
+ _clear_pending(_member_key(organization_id, user_uuid))
+ version = _version()
+ membership = (
+ OrganizationMembership.objects.select_related("organization", "user")
+ .filter(organization_id=organization_id, user__uuid=user_uuid, user__is_active=True)
+ .first()
+ )
+ try:
+ if membership is None:
+ response = hogtower.remove_member(organization_id, user_uuid, version)
+ done: Outcome = "removed"
+ else:
+ teams = member_teams(membership.organization, membership.user)
+ response = hogtower.put_member_teams(organization_id, user_uuid, teams, version)
+ done = "pushed"
+ except Exception as e:
+ _record("error")
+ raise MemberTeamsPushError(f"hogtower unreachable: {type(e).__name__}") from e
+
+ status = response.status_code
+ if 200 <= status < 300:
+ outcome: Outcome = done
+ elif status == 409:
+ outcome = "superseded"
+ elif status == 404:
+ # hogtower has no warehouse for this organization (yet, or any more).
+ outcome = "no_warehouse"
+ elif status == 400:
+ # Malformed on our side: a retry sends the same thing, so log it and stop.
+ logger.error(
+ "managed_warehouse_member_teams_rejected",
+ organization_id=organization_id,
+ user_uuid=user_uuid,
+ error=str(response.json())[:500],
+ )
+ outcome = "rejected"
+ else:
+ _record("error")
+ raise MemberTeamsPushError(f"hogtower answered {status}")
+ _record(outcome)
+ logger.info(
+ "managed_warehouse_member_teams_push",
+ organization_id=organization_id,
+ user_uuid=user_uuid,
+ outcome=outcome,
+ version=version,
+ )
+ return outcome
+
+
+def organization_member_uuids(organization_id: str) -> list[str]:
+ return [
+ str(user_uuid)
+ for user_uuid in OrganizationMembership.objects.filter(
+ organization_id=organization_id, user__is_active=True
+ ).values_list("user__uuid", flat=True)
+ ]
+
+
+def hogtower_member_uuids(organization_id: str) -> set[str]:
+ """The members hogtower holds who are not removed, or an empty set when it cannot say."""
+ try:
+ response = hogtower.list_members(organization_id)
+ except Exception:
+ logger.warning("managed_warehouse_member_teams_list_failed", organization_id=organization_id, exc_info=True)
+ return set()
+ if not 200 <= response.status_code < 300:
+ # 404 also comes from a hogtower without the list route: skip the reconcile.
+ return set()
+ body = response.json()
+ members = body.get("members") if isinstance(body, dict) else None
+ return {
+ str(member["user_uuid"])
+ for member in members or []
+ if isinstance(member, dict) and isinstance(member.get("user_uuid"), str)
+ }
+
+
+def push_organization(organization_id: str) -> int:
+ """Enqueue a push for every member of ``organization_id``, and for every member hogtower
+ still holds who has left; returns how many.
+
+ A leaver's push finds no membership and removes them, so a removal whose own push gave up
+ is still reconciled here.
+ """
+ _clear_pending(_organization_key(organization_id))
+ user_uuids = set(organization_member_uuids(organization_id)) | hogtower_member_uuids(organization_id)
+ for user_uuid in sorted(user_uuids):
+ enqueue_member_push(organization_id, user_uuid, countdown=0)
+ return len(user_uuids)
+
+
+def push_all() -> int:
+ """Enqueue an organization push for every Trino warehouse hogtower manages; returns how many."""
+ response = hogtower.list_warehouses()
+ if not 200 <= response.status_code < 300:
+ raise MemberTeamsPushError(f"hogtower answered {response.status_code} listing warehouses")
+ body = response.json()
+ warehouses = body.get("warehouses") if isinstance(body, dict) else None
+ org_ids: set[uuid.UUID] = set()
+ for warehouse in warehouses or []:
+ # Only a Trino warehouse has a hoglake catalog, so only its members can hold team tokens.
+ if not isinstance(warehouse, dict) or not warehouse.get("trino"):
+ continue
+ try:
+ org_ids.add(uuid.UUID(str(warehouse.get("org_id"))))
+ except ValueError:
+ continue # a warehouse whose id is not a PostHog organization
+ existing = [str(org_id) for org_id in Organization.objects.filter(id__in=org_ids).values_list("id", flat=True)]
+ for organization_id in existing:
+ enqueue_organization_push(organization_id, countdown=0)
+ return len(existing)
+
+
+# --- enqueueing ---------------------------------------------------------------------------
+
+
+def _member_key(organization_id: str, user_uuid: str) -> str:
+ return f"managed_warehouse:member_teams:pending:{organization_id}:{user_uuid}"
+
+
+def _organization_key(organization_id: str) -> str:
+ return f"managed_warehouse:member_teams:pending:{organization_id}"
+
+
+def _claim_pending(key: str) -> bool:
+ """Whether to enqueue: False only when a push is already waiting. A cache failure enqueues."""
+ try:
+ return bool(cache.add(key, 1, timeout=_PENDING_TIMEOUT_SECONDS))
+ except Exception:
+ logger.warning("managed_warehouse_member_teams_cache_failure", exc_info=True)
+ return True
+
+
+def _clear_pending(key: str) -> None:
+ try:
+ cache.delete(key)
+ except Exception:
+ logger.warning("managed_warehouse_member_teams_cache_failure", exc_info=True)
+
+
+def _publish(key: str, send: Callable[[], object]) -> None:
+ """Send a claimed push. When the send fails, release the claim, or the next enqueue skips the push."""
+ try:
+ send()
+ except Exception:
+ _clear_pending(key)
+ raise
+
+
+def enqueue_member_push(organization_id: str, user_uuid: str, *, countdown: int = _ENQUEUE_COUNTDOWN_SECONDS) -> None:
+ from products.managed_warehouse.backend.tasks.tasks import push_warehouse_member_teams # noqa: PLC0415
+
+ key = _member_key(organization_id, user_uuid)
+ if _claim_pending(key):
+ _publish(
+ key, lambda: push_warehouse_member_teams.apply_async((organization_id, user_uuid), countdown=countdown)
+ )
+
+
+def enqueue_organization_push(organization_id: str, *, countdown: int = _ENQUEUE_COUNTDOWN_SECONDS) -> None:
+ from products.managed_warehouse.backend.tasks.tasks import push_warehouse_organization_member_teams # noqa: PLC0415
+
+ key = _organization_key(organization_id)
+ if _claim_pending(key):
+ _publish(
+ key, lambda: push_warehouse_organization_member_teams.apply_async((organization_id,), countdown=countdown)
+ )
diff --git a/products/managed_warehouse/backend/presentation/hogtower.py b/products/managed_warehouse/backend/presentation/hogtower.py
index d3c0993792e9..65270dbc2af6 100644
--- a/products/managed_warehouse/backend/presentation/hogtower.py
+++ b/products/managed_warehouse/backend/presentation/hogtower.py
@@ -472,3 +472,54 @@ def request(
if handler is None:
return _not_supported(method, path)
return handler(call)
+
+
+# --- hogtower-only routes -----------------------------------------------------------------
+# No duckgres v1 counterpart, so no translation: callers check is_configured() first.
+
+MEMBER_TEAMS_TIMEOUT_SECONDS = 10
+
+
+def _member_path(organization_id: object, user_uuid: object) -> str:
+ return f"/warehouses/{quote(str(organization_id), safe='')}/members/{quote(str(user_uuid), safe='')}"
+
+
+def list_warehouses(*, timeout: int | float = 30) -> TranslatedResponse:
+ """v2 GET /warehouses: every warehouse hogtower manages, as ``{"warehouses": [...]}``."""
+ return _send("GET", "/warehouses", timeout=timeout)
+
+
+def list_members(organization_id: object, *, timeout: int | float = MEMBER_TEAMS_TIMEOUT_SECONDS) -> TranslatedResponse:
+ """v2 GET /warehouses/:id/members: the members hogtower holds who are not removed."""
+ return _send("GET", f"/warehouses/{quote(str(organization_id), safe='')}/members", timeout=timeout)
+
+
+def put_member_teams(
+ organization_id: object,
+ user_uuid: object,
+ teams: dict[int, str],
+ version: int,
+ *,
+ timeout: int | float = MEMBER_TEAMS_TIMEOUT_SECONDS,
+) -> TranslatedResponse:
+ """v2 PUT /warehouses/:id/members/:user_uuid/teams: the member's whole team set.
+
+ ``teams`` maps a team id to ``"read"`` or ``"write"``. hogtower keeps the push with
+ the highest ``version`` and answers 409 for an older one.
+ """
+ body = {"teams": {str(team_id): perm for team_id, perm in teams.items()}, "version": version}
+ return _send("PUT", f"{_member_path(organization_id, user_uuid)}/teams", json_body=body, timeout=timeout)
+
+
+def remove_member(
+ organization_id: object,
+ user_uuid: object,
+ version: int,
+ *,
+ timeout: int | float = MEMBER_TEAMS_TIMEOUT_SECONDS,
+) -> TranslatedResponse:
+ """v2 DELETE /warehouses/:id/members/:user_uuid: tombstone the member at ``version``.
+
+ hogtower revokes every team credential the member owns in the same transaction.
+ """
+ return _send("DELETE", _member_path(organization_id, user_uuid), json_body={"version": version}, timeout=timeout)
diff --git a/products/managed_warehouse/backend/signals.py b/products/managed_warehouse/backend/signals.py
new file mode 100644
index 000000000000..e88ed4e1c802
--- /dev/null
+++ b/products/managed_warehouse/backend/signals.py
@@ -0,0 +1,155 @@
+"""Enqueue a member-teams push to hogtower when what a member can see may have changed.
+
+Each receiver only enqueues, after the transaction commits, and only for an organization with
+a managed warehouse. ``member_teams`` reads the committed state when the push runs.
+
+- An organization membership is created, changed (its level) or deleted: that member.
+- A user is deactivated: that user, in each of their organizations.
+- A role membership is created or deleted: that member.
+- A project is created, deleted or moved to another organization, or an access rule on the
+ project, on warehouse data or on a property changes: every member of the organization (both,
+ for a move). A switch of resolution mode or of entitlement needs no push, because the pushed
+ level is capped by a floor that holds under both (``member_teams``).
+
+Access rules and role memberships arrive through the access_control facade, as ids.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from django.db import transaction
+from django.db.models.signals import post_delete, post_save, pre_delete, pre_save
+
+from posthog.models import OrganizationMembership, Team, User
+
+from products.managed_warehouse.backend import member_teams
+
+# Access rules on these resources change which teams a member sees, or the level on them.
+_ACCESS_RESOURCES = frozenset({"project", "property_definition", *member_teams.RESTRICTING_RESOURCES})
+
+
+def _has_warehouse(organization_id: str) -> bool:
+ from products.managed_warehouse.backend.facade.api import has_provisioned_warehouse # noqa: PLC0415
+
+ return has_provisioned_warehouse(organization_id)
+
+
+def _on_commit_member(organization_id: object, user_uuid: object) -> None:
+ if not member_teams.is_enabled() or organization_id is None or user_uuid is None:
+ return
+ org, user = str(organization_id), str(user_uuid)
+
+ def enqueue() -> None:
+ if _has_warehouse(org):
+ member_teams.enqueue_member_push(org, user)
+
+ transaction.on_commit(enqueue)
+
+
+def _on_commit_organization(organization_id: object) -> None:
+ if not member_teams.is_enabled() or organization_id is None:
+ return
+ org = str(organization_id)
+
+ def enqueue() -> None:
+ if _has_warehouse(org):
+ member_teams.enqueue_organization_push(org)
+
+ transaction.on_commit(enqueue)
+
+
+def _user_uuid(user_id: object) -> object:
+ return User.objects.filter(pk=user_id).values_list("uuid", flat=True).first()
+
+
+def _team_organization_id(team_id: object) -> object:
+ return Team.objects.filter(pk=team_id).values_list("organization_id", flat=True).first()
+
+
+def membership_saved(sender: Any, instance: OrganizationMembership, **kwargs: Any) -> None:
+ if member_teams.is_enabled():
+ _on_commit_member(instance.organization_id, _user_uuid(instance.user_id))
+
+
+# A receiver that must read state before a write records it on the instance under this name,
+# and the receiver after the write enqueues. Outside a transaction on_commit runs at once, so an
+# enqueue from before the write could run its push before the write lands.
+_PENDING_ATTR = "_managed_warehouse_member_teams_pending"
+
+
+def membership_deleting(sender: Any, instance: OrganizationMembership, **kwargs: Any) -> None:
+ # The user row is still there to read the uuid from, even when the user's own deletion is
+ # what removes the membership.
+ if member_teams.is_enabled():
+ setattr(instance, _PENDING_ATTR, _user_uuid(instance.user_id))
+
+
+def membership_deleted(sender: Any, instance: OrganizationMembership, **kwargs: Any) -> None:
+ user_uuid = getattr(instance, _PENDING_ATTR, None)
+ if user_uuid is not None:
+ _on_commit_member(instance.organization_id, user_uuid)
+
+
+def user_saved(sender: Any, instance: User, created: bool = False, **kwargs: Any) -> None:
+ # Reactivation needs no push here: the scheduled full push brings the member back.
+ if created or instance.is_active or not member_teams.is_enabled():
+ return
+ for organization_id in OrganizationMembership.objects.filter(user_id=instance.pk).values_list(
+ "organization_id", flat=True
+ ):
+ _on_commit_member(organization_id, instance.uuid)
+
+
+def team_saving(sender: Any, instance: Team, update_fields: Any = None, **kwargs: Any) -> None:
+ # A project moved to another organization: record the old one, whose members lose the team.
+ if instance._state.adding or not member_teams.is_enabled():
+ return
+ if update_fields is not None and not {"organization", "organization_id"} & set(update_fields):
+ return
+ previous = _team_organization_id(instance.pk)
+ if previous is not None and previous != instance.organization_id:
+ setattr(instance, _PENDING_ATTR, previous)
+
+
+def team_saved(sender: Any, instance: Team, created: bool = False, **kwargs: Any) -> None:
+ previous = instance.__dict__.pop(_PENDING_ATTR, None)
+ if created or previous is not None:
+ _on_commit_organization(instance.organization_id)
+ if previous is not None:
+ _on_commit_organization(previous)
+
+
+def team_deleted(sender: Any, instance: Team, **kwargs: Any) -> None:
+ _on_commit_organization(instance.organization_id)
+
+
+def access_rule_changed(team_id: int, resource: str) -> None:
+ if resource not in _ACCESS_RESOURCES or not member_teams.is_enabled():
+ return
+ # A rule deleted with its project has no team left to read; team_deleted covers that.
+ _on_commit_organization(_team_organization_id(team_id))
+
+
+def role_membership_changed(user_id: int, organization_id: UUID) -> None:
+ _on_commit_member(organization_id, _user_uuid(user_id))
+
+
+def connect() -> None:
+ from products.access_control.backend.facade.api import connect_access_change_receivers # noqa: PLC0415
+
+ uid = "managed_warehouse_member_teams"
+ post_save.connect(membership_saved, sender=OrganizationMembership, dispatch_uid=f"{uid}_membership_saved")
+ pre_delete.connect(membership_deleting, sender=OrganizationMembership, dispatch_uid=f"{uid}_membership_deleting")
+ post_delete.connect(membership_deleted, sender=OrganizationMembership, dispatch_uid=f"{uid}_membership_deleted")
+ post_save.connect(user_saved, sender=User, dispatch_uid=f"{uid}_user_saved")
+ pre_save.connect(team_saving, sender=Team, dispatch_uid=f"{uid}_team_saving")
+ post_save.connect(team_saved, sender=Team, dispatch_uid=f"{uid}_team_saved")
+ post_delete.connect(team_deleted, sender=Team, dispatch_uid=f"{uid}_team_deleted")
+ connect_access_change_receivers(
+ on_rule_change=access_rule_changed,
+ on_role_membership_change=role_membership_changed,
+ is_active=member_teams.is_enabled,
+ dispatch_uid=uid,
+ )
diff --git a/products/managed_warehouse/backend/tasks/__init__.py b/products/managed_warehouse/backend/tasks/__init__.py
index 51bc13a8f712..9f5dd0369b2f 100644
--- a/products/managed_warehouse/backend/tasks/__init__.py
+++ b/products/managed_warehouse/backend/tasks/__init__.py
@@ -1,3 +1,13 @@
-from products.managed_warehouse.backend.tasks.tasks import load_internal_warehouse
+from products.managed_warehouse.backend.tasks.tasks import (
+ load_internal_warehouse,
+ push_all_warehouse_member_teams,
+ push_warehouse_member_teams,
+ push_warehouse_organization_member_teams,
+)
-__all__ = ["load_internal_warehouse"]
+__all__ = [
+ "load_internal_warehouse",
+ "push_all_warehouse_member_teams",
+ "push_warehouse_member_teams",
+ "push_warehouse_organization_member_teams",
+]
diff --git a/products/managed_warehouse/backend/tasks/tasks.py b/products/managed_warehouse/backend/tasks/tasks.py
index d143a4201d20..cf161b298878 100644
--- a/products/managed_warehouse/backend/tasks/tasks.py
+++ b/products/managed_warehouse/backend/tasks/tasks.py
@@ -15,3 +15,37 @@ from products.managed_warehouse.backend.internal_loading import load_internal_te
)
def load_internal_warehouse(organization_id: str, team_id: int, generation: int) -> None:
load_internal_team(organization_id, team_id, generation)
+
+
+# Member-team pushes retry for about ten hours: a removal must reach hogtower, because hogtower
+# revokes the member's team credentials only when it does.
+_MEMBER_TEAMS_RETRY = {
+ "autoretry_for": (Exception,),
+ "retry_backoff": 30,
+ "retry_backoff_max": 600,
+ "max_retries": 60,
+}
+
+
+@shared_task(ignore_result=True, queue=CeleryQueue.DEFAULT.value, **_MEMBER_TEAMS_RETRY)
+def push_warehouse_member_teams(organization_id: str, user_uuid: str) -> None:
+ from products.managed_warehouse.backend import member_teams # noqa: PLC0415
+
+ if member_teams.is_enabled():
+ member_teams.push_member(organization_id, user_uuid)
+
+
+@shared_task(ignore_result=True, queue=CeleryQueue.DEFAULT.value, **_MEMBER_TEAMS_RETRY)
+def push_warehouse_organization_member_teams(organization_id: str) -> None:
+ from products.managed_warehouse.backend import member_teams # noqa: PLC0415
+
+ if member_teams.is_enabled():
+ member_teams.push_organization(organization_id)
+
+
+@shared_task(ignore_result=True, queue=CeleryQueue.DEFAULT.value)
+def push_all_warehouse_member_teams() -> None:
+ from products.managed_warehouse.backend import member_teams # noqa: PLC0415
+
+ if member_teams.is_enabled():
+ member_teams.push_all()
diff --git a/products/managed_warehouse/backend/tests/test_member_teams.py b/products/managed_warehouse/backend/tests/test_member_teams.py
new file mode 100644
index 000000000000..e664ba8da165
--- /dev/null
+++ b/products/managed_warehouse/backend/tests/test_member_teams.py
@@ -0,0 +1,538 @@
+from uuid import UUID, uuid4
+
+import pytest
+from posthog.test.base import BaseTest
+from unittest.mock import MagicMock, patch
+
+from django.core.cache import cache
+from django.test import override_settings
+
+import requests
+
+from posthog.constants import AvailableFeature
+from posthog.models import Organization, OrganizationMembership, PropertyDefinition, Team, User
+
+from products.access_control.backend.facade import testing as access_testing
+from products.managed_warehouse.backend import member_teams, signals
+from products.managed_warehouse.backend.models import DuckgresServer
+
+BASE = "http://hogtower.invalid"
+REQUEST = "products.managed_warehouse.backend.presentation.hogtower.internal_requests.request"
+ENABLED = override_settings(
+ HOGTOWER_API_URL=f"{BASE}/",
+ HOGTOWER_INTERNAL_SECRET="ht-secret",
+ HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED=True,
+)
+
+
+def _http(status_code: int, body: object) -> MagicMock:
+ resp = MagicMock(status_code=status_code, text=str(body))
+ resp.json.return_value = body
+ return resp
+
+
+class _MemberTeamsTest(BaseTest):
+ def setUp(self) -> None:
+ super().setUp()
+ cache.clear()
+ self.organization.available_product_features = [
+ {"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL},
+ {"key": AvailableFeature.ROLE_BASED_ACCESS, "name": AvailableFeature.ROLE_BASED_ACCESS},
+ {"key": AvailableFeature.PROPERTY_ACCESS_CONTROL, "name": AvailableFeature.PROPERTY_ACCESS_CONTROL},
+ ]
+ self.organization.save()
+ self.member = User.objects.create_and_join(self.organization, "[email protected]", "testtest")
+ self.membership = OrganizationMembership.objects.get(organization=self.organization, user=self.member)
+
+ def _rule(self, team: Team, resource: str, level: str, **kwargs) -> UUID:
+ return access_testing.create_access_control(team_id=team.id, resource=resource, access_level=level, **kwargs)
+
+ def _property_rule(self, team: Team, level: str, **kwargs) -> UUID:
+ definition = PropertyDefinition.objects.create(team=team, name=f"secret_{uuid4().hex[:8]}", type=1)
+ return access_testing.create_property_access_control(
+ team_id=team.id, property_definition_id=definition.id, access_level=level, **kwargs
+ )
+
+
+class TestMemberTeams(_MemberTeamsTest):
+ def test_default_access_is_write_on_every_visible_team(self) -> None:
+ other = Team.objects.create(organization=self.organization, name="other")
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write", other.id: "write"}
+
+ def test_a_warehouse_viewer_reads_and_none_leaves_the_team_out(self) -> None:
+ read_only = Team.objects.create(organization=self.organization, name="read only")
+ hidden = Team.objects.create(organization=self.organization, name="hidden")
+ self._rule(read_only, "warehouse_objects", "viewer")
+ self._rule(hidden, "warehouse_objects", "none")
+ assert member_teams.member_teams(self.organization, self.member) == {
+ self.team.id: "write",
+ read_only.id: "read",
+ }
+
+ def test_a_private_project_is_left_out(self) -> None:
+ private = Team.objects.create(organization=self.organization, name="private")
+ self._rule(private, "project", "none", resource_id=str(private.id))
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_an_explicit_member_rule_beats_the_default(self) -> None:
+ self._rule(self.team, "warehouse_objects", "viewer")
+ self._rule(self.team, "warehouse_objects", "editor", organization_member_id=self.membership.id)
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_an_organization_admin_writes_whatever_the_rules_say(self) -> None:
+ self._rule(self.team, "warehouse_objects", "viewer")
+ self.membership.level = OrganizationMembership.Level.ADMIN
+ self.membership.save()
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_a_hidden_table_view_or_source_withholds_the_team(self) -> None:
+ # A team grant covers every table, so it cannot keep one hidden: the team is left out.
+ for resource in ("warehouse_table", "warehouse_view", "external_data_source"):
+ team = Team.objects.create(organization=self.organization, name=resource)
+ self._rule(team, resource, "none", resource_id=str(uuid4()))
+ assert team.id not in member_teams.member_teams(self.organization, self.member), resource
+
+ def test_a_member_denied_one_table_loses_the_team(self) -> None:
+ self._rule(
+ self.team, "warehouse_table", "none", resource_id=str(uuid4()), organization_member_id=self.membership.id
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_an_object_viewer_rule_lowers_write_to_read(self) -> None:
+ self._rule(
+ self.team, "warehouse_view", "viewer", resource_id=str(uuid4()), organization_member_id=self.membership.id
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "read"}
+
+ def test_a_higher_object_rule_does_not_raise_the_team_level(self) -> None:
+ self._rule(self.team, "warehouse_objects", "viewer")
+ self._rule(self.team, "warehouse_table", "editor", resource_id=str(uuid4()))
+ self._rule(
+ self.team, "warehouse_table", "manager", resource_id=str(uuid4()), organization_member_id=self.membership.id
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "read"}
+
+ def test_a_hidden_object_for_someone_else_does_not_restrict(self) -> None:
+ other = User.objects.create_and_join(self.organization, "[email protected]", "testtest")
+ other_membership = OrganizationMembership.objects.get(organization=self.organization, user=other)
+ self._rule(
+ self.team, "warehouse_table", "none", resource_id=str(uuid4()), organization_member_id=other_membership.id
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_no_access_to_all_sources_withholds_the_team(self) -> None:
+ # A table with a source falls back to the all-sources rule.
+ self._rule(self.team, "external_data_source", "none")
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def _role_editor_and_member_denied_on_one_table(self) -> None:
+ table = str(uuid4())
+ role_id = access_testing.create_role(organization_id=self.organization.id, name="Analysts")
+ access_testing.add_role_member(role_id=role_id, user_id=self.member.id)
+ self._rule(self.team, "warehouse_table", "editor", resource_id=table, role_id=role_id)
+ self._rule(self.team, "warehouse_table", "none", resource_id=table, organization_member_id=self.membership.id)
+
+ def test_a_member_denial_withholds_the_team_under_either_resolution(self) -> None:
+ # Most-specific resolution hides the table from the member, so the floor holds for both
+ # modes and a switch between them needs no push.
+ self._role_editor_and_member_denied_on_one_table()
+ for most_specific in (True, False):
+ self.organization.uses_most_specific_access_resolution = most_specific
+ self.organization.save()
+ assert member_teams.member_teams(self.organization, self.member) == {}, most_specific
+
+ def test_a_member_grant_lifts_a_default_denial(self) -> None:
+ # Every resolution lets the member's own row decide, so the member reads the table.
+ table = str(uuid4())
+ self._rule(self.team, "warehouse_table", "none", resource_id=table)
+ self._rule(self.team, "warehouse_table", "viewer", resource_id=table, organization_member_id=self.membership.id)
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "read"}
+
+ def test_a_role_grant_does_not_lift_a_default_denial(self) -> None:
+ # Without the roles entitlement the role row does not apply, so the floor keeps the denial.
+ table = str(uuid4())
+ role_id = access_testing.create_role(organization_id=self.organization.id, name="Analysts")
+ access_testing.add_role_member(role_id=role_id, user_id=self.member.id)
+ self._rule(self.team, "warehouse_table", "none", resource_id=table)
+ self._rule(self.team, "warehouse_table", "viewer", resource_id=table, role_id=role_id)
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_stored_rules_cap_without_the_entitlement(self) -> None:
+ # Restoring the entitlement makes the stored rules effective again with no push, so they
+ # cap the grant already.
+ self._rule(self.team, "warehouse_table", "none", resource_id=str(uuid4()))
+ self.organization.available_product_features = []
+ self.organization.save()
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_a_private_project_floor_withholds_the_team(self) -> None:
+ self._rule(self.team, "project", "none", resource_id=str(self.team.id))
+ self.organization.available_product_features = []
+ self.organization.save()
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_an_object_default_viewer_lowers_write_to_read_in_both_modes(self) -> None:
+ # Both resolutions give the member viewer on that view when no resource rule outranks it.
+ for most_specific in (True, False):
+ self.organization.uses_most_specific_access_resolution = most_specific
+ self.organization.save()
+ team = Team.objects.create(organization=self.organization, name=f"most specific {most_specific}")
+ self._rule(team, "warehouse_view", "viewer", resource_id=str(uuid4()))
+ assert member_teams.member_teams(self.organization, self.member)[team.id] == "read", most_specific
+
+ def test_a_hidden_property_withholds_the_team(self) -> None:
+ # The namespace holds raw property values, so a member who may not see one gets nothing.
+ self._property_rule(self.team, "none", organization_member_id=self.membership.id)
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_a_read_only_property_caps_the_team_at_read(self) -> None:
+ # A team grant could rewrite the raw values, which the property rule forbids.
+ self._property_rule(self.team, "read")
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "read"}
+
+ def test_a_member_property_grant_lifts_a_default_hidden_property(self) -> None:
+ definition = PropertyDefinition.objects.create(team=self.team, name="email", type=2)
+ for level, member in (("none", None), ("read_write", self.membership.id)):
+ access_testing.create_property_access_control(
+ team_id=self.team.id,
+ property_definition_id=definition.id,
+ access_level=level,
+ organization_member_id=member,
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_property_rows_naming_both_a_member_and_a_role_count(self) -> None:
+ # The property resolver applies a row naming the member whatever its role, and a row
+ # naming one of the member's roles whatever its member.
+ role_id = access_testing.create_role(organization_id=self.organization.id, name="Analysts")
+ access_testing.add_role_member(role_id=role_id, user_id=self.member.id)
+ other = User.objects.create_and_join(self.organization, "[email protected]", "testtest")
+ other_membership = OrganizationMembership.objects.get(organization=self.organization, user=other)
+ for team, member_id in (
+ (self.team, self.membership.id),
+ (Team.objects.create(organization=self.organization, name="t2"), other_membership.id),
+ ):
+ definition = PropertyDefinition.objects.create(team=team, name="email", type=2)
+ access_testing.create_property_access_control(
+ team_id=team.id,
+ property_definition_id=definition.id,
+ access_level="none",
+ organization_member_id=member_id,
+ role_id=role_id,
+ )
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_a_stored_hidden_property_caps_without_the_feature(self) -> None:
+ self._property_rule(self.team, "none")
+ self.organization.available_product_features = []
+ self.organization.save()
+ assert member_teams.member_teams(self.organization, self.member) == {}
+
+ def test_an_organization_admin_is_not_restricted_by_property_rules(self) -> None:
+ self._property_rule(self.team, "none")
+ self.membership.level = OrganizationMembership.Level.ADMIN
+ self.membership.save()
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_an_organization_admin_is_not_restricted_by_object_rules(self) -> None:
+ self._rule(self.team, "warehouse_table", "none", resource_id=str(uuid4()))
+ self.membership.level = OrganizationMembership.Level.ADMIN
+ self.membership.save()
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+ def test_another_organizations_teams_never_appear(self) -> None:
+ elsewhere = Organization.objects.create(name="elsewhere")
+ Team.objects.create(organization=elsewhere, name="theirs")
+ OrganizationMembership.objects.create(organization=elsewhere, user=self.member)
+ assert member_teams.member_teams(self.organization, self.member) == {self.team.id: "write"}
+
+
+@ENABLED
+class TestPushMember(_MemberTeamsTest):
+ def _push(self, response: MagicMock | Exception, user_uuid: str | None = None) -> tuple[str, MagicMock]:
+ mock = MagicMock(side_effect=response) if isinstance(response, Exception) else MagicMock(return_value=response)
+ with patch(REQUEST, mock):
+ outcome = member_teams.push_member(str(self.organization.id), user_uuid or str(self.member.uuid))
+ return outcome, mock
+
+ def test_puts_the_whole_team_set_with_a_version(self) -> None:
+ outcome, mock = self._push(_http(200, {"changed": True}))
+ assert outcome == "pushed"
+ method, url = mock.call_args.args
+ assert method == "PUT"
+ assert url == f"{BASE}/api/v2/warehouses/{self.organization.id}/members/{self.member.uuid}/teams"
+ body = mock.call_args.kwargs["json"]
+ assert body["teams"] == {str(self.team.id): "write"}
+ assert isinstance(body["version"], int) and body["version"] > 0
+ assert mock.call_args.kwargs["headers"] == {"X-Hogtower-Internal-Secret": "ht-secret"}
+
+ def test_versions_increase(self) -> None:
+ _, first = self._push(_http(200, {}))
+ _, second = self._push(_http(200, {}))
+ assert second.call_args.kwargs["json"]["version"] > first.call_args.kwargs["json"]["version"]
+
+ def test_a_member_who_left_is_removed(self) -> None:
+ self.membership.delete()
+ outcome, mock = self._push(_http(200, {"removed": True}))
+ assert outcome == "removed"
+ method, url = mock.call_args.args
+ assert method == "DELETE"
+ assert url == f"{BASE}/api/v2/warehouses/{self.organization.id}/members/{self.member.uuid}"
+ assert set(mock.call_args.kwargs["json"]) == {"version"}
+
+ def test_a_deactivated_user_is_removed(self) -> None:
+ self.member.is_active = False
+ self.member.save()
+ outcome, mock = self._push(_http(200, {}))
+ assert outcome == "removed"
+ assert mock.call_args.args[0] == "DELETE"
+
+ def test_an_unknown_user_is_removed(self) -> None:
+ outcome, mock = self._push(_http(200, {}), user_uuid=str(uuid4()))
+ assert outcome == "removed"
+
+ def test_409_means_a_newer_push_landed(self) -> None:
+ assert self._push(_http(409, {"error": "newer version stored"}))[0] == "superseded"
+
+ def test_404_means_hogtower_has_no_warehouse(self) -> None:
+ assert self._push(_http(404, {"error": "warehouse not found"}))[0] == "no_warehouse"
+
+ def test_400_is_logged_and_not_retried(self) -> None:
+ assert self._push(_http(400, {"error": "invalid member teams"}))[0] == "rejected"
+
+ def test_a_5xx_raises_for_a_retry(self) -> None:
+ with pytest.raises(member_teams.MemberTeamsPushError):
+ self._push(_http(503, {"error": "unavailable"}))
+
+ def test_a_transport_error_raises_for_a_retry(self) -> None:
+ with pytest.raises(member_teams.MemberTeamsPushError):
+ self._push(requests.ConnectionError("refused"))
+
+
+@ENABLED
+class TestReceivers(_MemberTeamsTest):
+ def setUp(self) -> None:
+ super().setUp()
+ DuckgresServer.objects.create(organization=self.organization, host="h", username="u", password="p")
+ self.member_push = patch.object(member_teams, "enqueue_member_push").start()
+ self.org_push = patch.object(member_teams, "enqueue_organization_push").start()
+ self.addCleanup(patch.stopall)
+
+ def test_a_new_member_is_pushed_after_commit(self) -> None:
+ with self.captureOnCommitCallbacks(execute=False) as callbacks:
+ joiner = User.objects.create_and_join(self.organization, "[email protected]", "testtest")
+ self.member_push.assert_not_called()
+ for callback in callbacks:
+ callback()
+ self.member_push.assert_any_call(str(self.organization.id), str(joiner.uuid))
+
+ def test_a_level_change_is_pushed(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ self.membership.level = OrganizationMembership.Level.ADMIN
+ self.membership.save()
+ self.member_push.assert_called_once_with(str(self.organization.id), str(self.member.uuid))
+
+ def test_a_removed_member_is_pushed_with_their_uuid(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ self.membership.delete()
+ self.member_push.assert_called_once_with(str(self.organization.id), str(self.member.uuid))
+
+ def test_a_deleted_user_is_pushed_with_their_uuid(self) -> None:
+ member_uuid = str(self.member.uuid)
+ with self.captureOnCommitCallbacks(execute=True):
+ self.member.delete()
+ self.member_push.assert_any_call(str(self.organization.id), member_uuid)
+
+ def test_a_deactivated_user_is_pushed(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ self.member.is_active = False
+ self.member.save()
+ self.member_push.assert_called_once_with(str(self.organization.id), str(self.member.uuid))
+
+ def test_a_role_membership_added_or_removed_is_pushed(self) -> None:
+ # The usual shape: a role membership with no organization membership on it.
+ role_id = access_testing.create_role(organization_id=self.organization.id, name="Analysts")
+ with self.captureOnCommitCallbacks(execute=True):
+ role_membership_id = access_testing.add_role_member(role_id=role_id, user_id=self.member.id)
+ self.member_push.assert_called_once_with(str(self.organization.id), str(self.member.uuid))
+ self.member_push.reset_mock()
+ with self.captureOnCommitCallbacks(execute=True):
+ access_testing.remove_role_member(
+ organization_id=self.organization.id, role_membership_id=role_membership_id
+ )
+ self.member_push.assert_called_once_with(str(self.organization.id), str(self.member.uuid))
+
+ def test_project_and_warehouse_rules_push_the_organization(self) -> None:
+ for resource in ("project", *member_teams.RESTRICTING_RESOURCES):
+ self.org_push.reset_mock()
+ resource_id = None if resource in ("project", "warehouse_objects") else str(uuid4())
+ with self.captureOnCommitCallbacks(execute=True):
+ rule_id = self._rule(self.team, resource, "viewer", resource_id=resource_id)
+ self.org_push.assert_called_once_with(str(self.organization.id))
+ self.org_push.reset_mock()
+ with self.captureOnCommitCallbacks(execute=True):
+ access_testing.delete_access_control(team_id=self.team.id, access_control_id=rule_id)
+ self.org_push.assert_called_once_with(str(self.organization.id))
+
+ def test_a_property_rule_pushes_the_organization(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ rule_id = self._property_rule(self.team, "none")
+ self.org_push.assert_called_once_with(str(self.organization.id))
+ self.org_push.reset_mock()
+ with self.captureOnCommitCallbacks(execute=True):
+ access_testing.delete_property_access_control_rule(team_id=self.team.id, property_access_control_id=rule_id)
+ self.org_push.assert_called_once_with(str(self.organization.id))
+
+ def test_other_rules_push_nothing(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ self._rule(self.team, "dashboard", "viewer")
+ self.org_push.assert_not_called()
+
+ def test_a_project_created_or_deleted_pushes_the_organization(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ team = Team.objects.create(organization=self.organization, name="new")
+ self.org_push.assert_called_once_with(str(self.organization.id))
+ self.org_push.reset_mock()
+ # Team.delete() needs object storage, which unit tests don't run, so drive the receiver.
+ with self.captureOnCommitCallbacks(execute=True):
+ signals.team_deleted(Team, team)
+ self.org_push.assert_called_once_with(str(self.organization.id))
+
+ def test_a_project_moved_to_another_organization_pushes_both(self) -> None:
+ target = Organization.objects.create(name="target")
+ DuckgresServer.objects.create(organization=target, host="h2", username="u", password="p")
+ with self.captureOnCommitCallbacks(execute=True):
+ self.team.organization_id = target.id
+ self.team.save()
+ assert {call.args[0] for call in self.org_push.call_args_list} == {str(self.organization.id), str(target.id)}
+
+ def test_a_team_save_that_keeps_the_organization_pushes_nothing(self) -> None:
+ with self.captureOnCommitCallbacks(execute=True):
+ self.team.name = "renamed"
+ self.team.save()
+ self.team.save(update_fields=["name"])
+ self.org_push.assert_not_called()
+
+ def test_receivers_before_a_write_only_record(self) -> None:
+ # Outside a transaction on_commit runs at once, so an enqueue from before the write could
+ # push the old state. The receivers before the write record, and the ones after enqueue.
+ target = Organization.objects.create(name="target")
+ self.team.organization_id = target.id
+ with self.captureOnCommitCallbacks(execute=False) as callbacks:
+ signals.membership_deleting(OrganizationMembership, self.membership)
+ signals.team_saving(Team, self.team)
+ assert callbacks == []
+ with self.captureOnCommitCallbacks(execute=False) as callbacks:
+ signals.membership_deleted(OrganizationMembership, self.membership)
+ signals.team_saved(Team, self.team)
+ assert len(callbacks) == 3
+
+ def test_no_push_without_a_warehouse(self) -> None:
+ DuckgresServer.objects.filter(organization=self.organization).delete()
+ with self.captureOnCommitCallbacks(execute=True):
+ self.membership.delete()
+ self.member_push.assert_not_called()
+
+ def test_no_push_when_disabled(self) -> None:
+ role_id = access_testing.create_role(organization_id=self.organization.id, name="Analysts")
+ with override_settings(HOGTOWER_MEMBER_TEAMS_PUSH_ENABLED=False):
+ with self.captureOnCommitCallbacks(execute=True):
+ self.membership.delete()
+ self._rule(self.team, "project", "none")
+ # A role change does not reach the receiver, so it reads no role, when the push is off.
+ with patch.object(signals, "_user_uuid") as receiver_ran:
+ access_testing.add_role_member(role_id=role_id, user_id=self.user.id)
+ receiver_ran.assert_not_called()
+ self.member_push.assert_not_called()
+ self.org_push.assert_not_called()
+
+ def test_no_push_without_hogtower(self) -> None:
+ with override_settings(HOGTOWER_API_URL=None):
+ with self.captureOnCommitCallbacks(execute=True):
+ self.membership.delete()
+ self.member_push.assert_not_called()
+
+
+@ENABLED
+class TestPushAllAndEnqueue(_MemberTeamsTest):
+ def test_push_all_covers_trino_warehouses_of_existing_organizations(self) -> None:
+ duckgres_only = Organization.objects.create(name="duckgres only")
+ warehouses = [
+ {"org_id": str(self.organization.id), "trino": {"catalog": "x"}},
+ {"org_id": str(duckgres_only.id)},
+ {"org_id": str(uuid4()), "trino": {"catalog": "gone"}},
+ {"org_id": "hte2e-1", "trino": {"catalog": "test"}},
+ ]
+ with (
+ patch(REQUEST, return_value=_http(200, {"warehouses": warehouses})),
+ patch.object(member_teams, "enqueue_organization_push") as org_push,
+ ):
+ assert member_teams.push_all() == 1
+ org_push.assert_called_once_with(str(self.organization.id), countdown=0)
+
+ def test_push_all_raises_when_hogtower_fails(self) -> None:
+ with patch(REQUEST, return_value=_http(503, {})), pytest.raises(member_teams.MemberTeamsPushError):
+ member_teams.push_all()
+
+ def test_push_organization_enqueues_every_active_member(self) -> None:
+ inactive = User.objects.create_and_join(self.organization, "[email protected]", "testtest")
+ inactive.is_active = False
+ inactive.save()
+ with (
+ patch(REQUEST, return_value=_http(404, {"error": "not found"})),
+ patch.object(member_teams, "enqueue_member_push") as member_push,
+ ):
+ count = member_teams.push_organization(str(self.organization.id))
+ pushed = {call.args[1] for call in member_push.call_args_list}
+ assert count == 2
+ assert pushed == {str(self.user.uuid), str(self.member.uuid)}
+
+ def test_push_organization_also_pushes_members_hogtower_holds_who_left(self) -> None:
+ leaver = str(uuid4())
+ listed = {"members": [{"user_uuid": str(self.member.uuid)}, {"user_uuid": leaver}]}
+ with (
+ patch(REQUEST, return_value=_http(200, listed)) as request,
+ patch.object(member_teams, "enqueue_member_push") as member_push,
+ ):
+ count = member_teams.push_organization(str(self.organization.id))
+ assert request.call_args.args == ("GET", f"{BASE}/api/v2/warehouses/{self.organization.id}/members")
+ assert count == 3
+ assert {call.args[1] for call in member_push.call_args_list} == {
+ str(self.user.uuid),
+ str(self.member.uuid),
+ leaver,
+ }
+
+ def test_push_organization_still_runs_when_hogtower_cannot_list(self) -> None:
+ with (
+ patch(REQUEST, side_effect=requests.ConnectionError("refused")),
+ patch.object(member_teams, "enqueue_member_push") as member_push,
+ ):
+ assert member_teams.push_organization(str(self.organization.id)) == 2
+ assert member_push.call_count == 2
+
+ def test_a_failed_publish_releases_the_claim(self) -> None:
+ from products.managed_warehouse.backend.tasks import tasks # noqa: PLC0415
+
+ org, user = str(self.organization.id), str(self.member.uuid)
+ with patch.object(
+ tasks.push_warehouse_member_teams, "apply_async", side_effect=[OSError("broker"), None]
+ ) as send:
+ with pytest.raises(OSError):
+ member_teams.enqueue_member_push(org, user)
+ member_teams.enqueue_member_push(org, user)
+ assert send.call_count == 2
+
+ def test_a_waiting_push_is_not_enqueued_twice(self) -> None:
+ from products.managed_warehouse.backend.tasks import tasks # noqa: PLC0415
+
+ org, user = str(self.organization.id), str(self.member.uuid)
+ with patch.object(tasks.push_warehouse_member_teams, "apply_async") as apply_async:
+ member_teams.enqueue_member_push(org, user)
+ member_teams.enqueue_member_push(org, user)
+ assert apply_async.call_count == 1
+ # The push clears the mark when it starts, so a change made during it enqueues again.
+ with patch(REQUEST, return_value=_http(200, {})):
+ member_teams.push_member(org, user)
+ member_teams.enqueue_member_push(org, user)
+ assert apply_async.call_count == 2
diff --git a/products/managed_warehouse/turbo.json b/products/managed_warehouse/turbo.json
index 8322996c63c2..558938f600d4 100644
--- a/products/managed_warehouse/turbo.json
+++ b/products/managed_warehouse/turbo.json
@@ -20,7 +20,8 @@
"backend/logic/sql_editor_trino.py",
"backend/managed_ingress.py",
"backend/models.py",
- "backend/migrations/**"
+ "backend/migrations/**",
+ "backend/signals.py"
],
"outputs": [],
"cache": true