bito-code-review[bot] commented on code in PR #44406:
URL: https://github.com/apache/superset/pull/44406#discussion_r4045403578
##########
superset/common/query_context_processor.py:
##########
@@ -445,31 +464,144 @@ def query_cache_key(self, query_obj: QueryObject,
**kwargs: Any) -> str | None:
)
return cache_key
- def _annotation_cache_context(self, query_obj: QueryObject) -> dict[str,
Any]:
+ def annotation_cache_key(self, query_obj: QueryObject) -> str | None:
+ """
+ Cache key for this query's annotation-layer payload, or ``None`` when
+ the query has no annotation layers.
+
+ Annotation payloads are fetched under the requesting user's access
+ scope, which is a stricter security requirement than the dataframe
+ itself has. Keying them separately from :meth:`query_cache_key` keeps
+ that scoping from forcing every distinct viewer of an annotated chart
+ onto their own full copy of the (potentially much larger) shared
+ dataframe: users with the same access scope share this key too.
"""
- Cache-key material binding cached annotation data to its security
- context.
+ if not query_obj or not query_obj.annotation_layers:
+ return None
+ return self.query_cache_key(
+ query_obj,
annotation_context=self._annotation_cache_context(query_obj)
+ )
- Annotation payloads are fetched per requesting user and stored on the
- same cache entry as the dataframe, so the key also binds the requesting
- user and, for chart-backed layers, the RLS clauses of the referenced
- chart's datasource.
+ def _annotation_cache_context(self, query_obj: QueryObject) -> dict[str,
Any]:
+ """
+ Cache-key material binding annotation data to its security *scope* so
+ users with the same access share a cache entry and users with a
+ different scope — or no access — never read each other's data.
+
+ * NATIVE layers: the ``can_read`` permission on ``Annotation``, the
+ only user-dependent dimension of these global records.
+ * Chart-backed (``line``/``table``) layers: see
+ :meth:`_annotation_source_scope`.
"""
- source_rls: dict[str, list[str] | None] = {}
+ context: dict[str, Any] = {}
+
+ if any(
+ layer.get("sourceType") == "NATIVE" for layer in
query_obj.annotation_layers
+ ):
+ context["annotation_read"] = security_manager.can_access(
+ "can_read", "Annotation"
+ )
+
+ source_scope: dict[str, Any] = {}
for layer in query_obj.annotation_layers:
if layer.get("sourceType") not in ("line", "table"):
continue
layer_value = layer.get("value")
- chart = (
- ChartDAO.find_by_id(layer_value) if layer_value is not None
else None
+ source_scope[str(layer_value)] =
self._annotation_source_scope(layer_value)
+ if source_scope:
+ context["source_scope"] = source_scope
+
+ return context
+
+ def _annotation_source_scope(self, layer_value: Any) -> dict[str, Any]:
+ """
+ Access and data-identity cache-key material for one chart-backed
+ annotation layer.
+
+ ``access`` keeps a user denied the referenced chart's datasource from
+ reading an authorized user's cached payload. ``data_key`` is the
+ annotation chart's own query cache key(s), which already capture the
+ datasource version, RLS clauses, and any per-user Jinja/virtual-dataset
+ RLS material — reusing it here avoids re-deriving that logic and
+ automatically inherits any future correctness fixes made there.
+ """
+ chart = ChartDAO.find_by_id(layer_value) if layer_value is not None
else None
+ datasource = chart.datasource if chart else None
+ if chart is None or datasource is None:
+ return {"access": None, "data_key": None}
+
+ try:
+ access = security_manager.can_access_datasource(datasource)
+ # Fall back to the RLS-clause identity when the chart has no saved
+ # query context to key on.
+ annotation_query_context = chart.get_query_context()
+ data_key: Any = (
+ [
+ annotation_query_context.query_cache_key(query_object)
+ for query_object in annotation_query_context.queries
+ ]
+ if annotation_query_context is not None
+ else security_manager.get_rls_cache_key(datasource)
+ )
+ except SupersetException:
Review Comment:
<!-- Bito Reply -->
The suggestion to widen the exception to a bare `except` is appropriate
here. It ensures that any unexpected errors during the derivation of the cache
key—such as those from SQLAlchemy or Jinja—are caught, allowing the system to
fall back to the default behavior instead of causing a 500 error for the entire
request.
**superset/common/query_context_processor.py**
```
except Exception:
return {"access": None, "data_key": None}
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
