: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(managed-warehouse): push member teams to hogtower (#130337)
James Greenhill577a3d927f87
diff --git a/posthog/settings/base_variables.py b/posthog/settings/base_variables.pyindex 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 valuediff --git a/posthog/tasks/scheduled.py b/posthog/tasks/scheduled.pyindex 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_documentsfrom products.logs.backend.facade.tasks import logs_alert_events_cleanup_task+from products.managed_warehouse.backend.facade.tasks import push_all_warehouse_member_teamsfrom products.mcp_registry.backend.facade.tasks import MCP_REGISTRY_SYNC_CRONTAB, run_mcp_registry_syncfrom products.notebooks.backend.facade.tasks import cleanup_widget_snapshotsfrom 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 instancesender.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.txtindex 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_membepost_delete:posthog.storage.team_access_cache_signal_handlers.personal_api_key_deletedpost_delete:posthog.storage.team_access_cache_signal_handlers.project_secret_api_key_deletedpost_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_changedpost_delete:products.access_control.backend.property_access_control._invalidate_restriction_cache_on_changepost_delete:products.actions.backend.models.action.action_deletedpost_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_changedpost_delete:products.feature_flags.backend.local_evaluation.feature_flag_changedpost_delete:products.feature_flags.backend.local_evaluation.team_deletedpost_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_deletedpost_delete:products.replay_vision.backend.media_expiry.expire_media_assetpost_delete:products.review_hog.backend.ownership._invalidate_owned_repositories_on_deletepost_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_cacpost_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cache_on_project_savepost_save:posthog.storage.team_metadata_signal_handlers.update_team_metadata_cache_on_realtime_cohort_access_savepost_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_changedpost_save:products.access_control.backend.property_access_control._invalidate_restriction_cache_on_changepost_save:products.actions.backend.models.action.action_savedpost_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_confipost_save:products.feature_flags.backend.session_recording_links.relink_teams_on_key_changepost_save:products.knowledge_writer.backend.receivers.open_docs_pull_requestpost_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_savedpost_save:products.metrics.backend.dashboard_import.receivers.schedule_import_finalizationpost_save:products.posthog_ai.backend.receivers.mark_conversation_sandbox_on_first_runpost_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_deletepre_delete:posthog.storage.team_llm_gateway_policy_signal_handlers._clear_cache_on_deletepre_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_deletingpre_delete:products.alerts.backend.activity_logging.cleanup_alert_hog_functionspre_delete:products.alerts.backend.activity_logging.delete_platform_shadow_copypre_delete:products.alerts.backend.activity_logging.handle_alert_subscription_delete@@ -307,6 +319,7 @@ pre_delete:products.customer_analytics.backend.signals.delete_private_account_vipre_delete:products.experiments.backend.activity_logging.handle_experiment_holdout_deletepre_delete:products.experiments.backend.activity_logging.handle_experiment_saved_metric_deletepre_delete:products.managed_migrations.backend.activity_logging.handle_batch_import_delete+pre_delete:products.managed_warehouse.backend.signals.membership_deletingpre_delete:products.replay_vision.backend.observation_notes.delete_scanner_observation_notespre_delete:products.tasks.backend.models.clear_channel_repositories_on_github_integration_deletepre_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_evepre_save:products.feature_flags.backend.flag_version_sync.capture_cohort_definition_before_savepre_save:products.feature_flags.backend.flag_version_sync.capture_flag_definition_before_savepre_save:products.feature_flags.backend.session_recording_links.capture_replay_link_key_before_save+pre_save:products.managed_warehouse.backend.signals.team_savingpre_save:products.signals.backend.receivers.capture_prior_statepre_save:products.surveys.backend.models.pre_save_surveypre_save:products.web_analytics.backend.heatmap_history_expiry.invalidate_historydiff --git a/products/access_control/backend/facade/api.py b/products/access_control/backend/facade/api.pyindex 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 annotationsfrom collections import defaultdict-from collections.abc import Collection, Sequence+from collections.abc import Callable, Collection, Sequencefrom copy import copyfrom typing import castfrom uuid import UUIDfrom django.db import transactionfrom django.db.models import Q-from django.db.models.signals import post_save+from django.db.models.signals import post_delete, post_save, pre_deletefrom django.http import Http404from django.shortcuts import get_object_or_404from 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.pyindex 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 getthem here instead of importing the models."""from uuid import UUIDfrom products.access_control.backend.models.access_control import AccessControl+from products.access_control.backend.models.property_access_control import PropertyAccessControlfrom 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.pyindex 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-leveldiff --git a/products/managed_warehouse/backend/README.md b/products/managed_warehouse/backend/README.mdindex 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, thTrino 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 variablesThe 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.pyindex 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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__.pyindex 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.pyindex 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.pynew file mode 100644index 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 == 2diff --git a/products/managed_warehouse/turbo.json b/products/managed_warehouse/turbo.jsonindex 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