Skip to content

Commit 3bd44b6

Browse files
committed
Fix TypeError clearing a DAG run when a queued-at deadline interval is stored as JSON
Since 3.3.0 the deadline_alert.interval column is JSON (migration 0117, apache#64751), holding a serialized timedelta or VariableInterval. _recalculate_dagrun_queued_at_deadlines still passed that raw dict into timedelta(seconds=...), so clearing a DAG run or task instance whose DAG has a DagRunQueuedAtDeadline failed with "TypeError: unsupported type for timedelta seconds component: dict" (HTTP 500). Decode the interval the same way DagRun creation does (decode_deadline_alert), then resolve a VariableInterval to a timedelta before recalculating. The existing test stored the interval as a plain float and never exercised the JSON path; it now stores the serialized envelope and is parametrized over fixed-timedelta and VariableInterval. closes: apache#70368
1 parent 478745a commit 3bd44b6

2 files changed

Lines changed: 82 additions & 16 deletions

File tree

‎airflow-core/src/airflow/models/taskinstance.py‎

Lines changed: 19 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -248,10 +248,26 @@ def _recalculate_dagrun_queued_at_deadlines(
248248
if not results:
249249
return
250250

251+
# Local imports to avoid a circular import between models and serialization.
252+
from airflow.sdk.definitions.deadline import VariableInterval
253+
from airflow.serialization.decoders import decode_deadline_alert
254+
from airflow.serialization.definitions.deadline import DeadlineAlertFields
255+
251256
for deadline, deadline_alert in results:
252-
# We can't use evaluate_with() since the new queued_at is not written to the DB yet.
253-
deadline_interval = timedelta(seconds=deadline_alert.interval)
254-
new_deadline_time = new_queued_at + deadline_interval
257+
# We can't use evaluate_with() since the new queued_at is not written to the DB yet, but
258+
# interval is stored as JSON (a serialized timedelta or VariableInterval), so decode it the
259+
# same way DagRun creation does instead of passing the raw value to timedelta().
260+
deserialized_alert = decode_deadline_alert(
261+
{
262+
DeadlineAlertFields.REFERENCE: deadline_alert.reference,
263+
DeadlineAlertFields.INTERVAL: deadline_alert.interval,
264+
DeadlineAlertFields.CALLBACK: deadline_alert.callback_def,
265+
}
266+
)
267+
interval = deserialized_alert.interval
268+
if isinstance(interval, VariableInterval):
269+
interval = interval.resolve()
270+
new_deadline_time = new_queued_at + interval
255271

256272
log.debug(
257273
"Recalculating deadline %s for DagRun %s.%s: old=%s, new=%s",

‎airflow-core/tests/unit/models/test_taskinstance.py‎

Lines changed: 63 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -4130,8 +4130,28 @@ async def empty_callback_for_deadline():
41304130
pass
41314131

41324132

4133-
def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, session):
4134-
"""Test that clearing tasks recalculates all (and only) DAGRUN_QUEUED_AT deadlines."""
4133+
@pytest.mark.parametrize(
4134+
"use_variable_interval",
4135+
[
4136+
pytest.param(False, id="fixed_timedelta_interval"),
4137+
pytest.param(True, id="variable_interval"),
4138+
],
4139+
)
4140+
def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, session, use_variable_interval):
4141+
"""Test that clearing tasks recalculates all (and only) DAGRUN_QUEUED_AT deadlines.
4142+
4143+
Since Airflow 3.3 the ``deadline_alert.interval`` column is JSON (a serialized ``timedelta``
4144+
or ``VariableInterval``), so the recalculation must decode it instead of passing the raw value
4145+
to ``timedelta()``. Storing the interval via ``serialize`` here mirrors production and covers
4146+
both interval kinds.
4147+
"""
4148+
from airflow.sdk.definitions.deadline import VariableInterval
4149+
from airflow.sdk.definitions.variable import Variable
4150+
from airflow.sdk.serde import serialize
4151+
4152+
variable_key = "deadline_interval_key"
4153+
variable_seconds = 3600
4154+
41354155
with dag_maker(
41364156
dag_id="test_recalculate_deadlines",
41374157
schedule=datetime.timedelta(days=1),
@@ -4151,29 +4171,52 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
41514171
select(SerializedDagModel.id).where(SerializedDagModel.dag_id == dag.dag_id)
41524172
)
41534173

4154-
deadline_configs = [
4155-
(DeadlineReference.DAGRUN_QUEUED_AT, datetime.timedelta(hours=1)),
4156-
(DeadlineReference.DAGRUN_QUEUED_AT, datetime.timedelta(hours=2)),
4157-
(DeadlineReference.FIXED_DATETIME, datetime.timedelta(hours=1)),
4174+
if use_variable_interval:
4175+
queued_interval = VariableInterval(variable_key)
4176+
queued_resolved = datetime.timedelta(seconds=variable_seconds)
4177+
# Both DAGRUN_QUEUED_AT deadlines resolve to the same interval from the Variable.
4178+
queued_configs = [
4179+
(DeadlineReference.DAGRUN_QUEUED_AT, queued_interval, queued_resolved),
4180+
(DeadlineReference.DAGRUN_QUEUED_AT, queued_interval, queued_resolved),
4181+
]
4182+
else:
4183+
queued_configs = [
4184+
(
4185+
DeadlineReference.DAGRUN_QUEUED_AT,
4186+
datetime.timedelta(hours=1),
4187+
datetime.timedelta(hours=1),
4188+
),
4189+
(
4190+
DeadlineReference.DAGRUN_QUEUED_AT,
4191+
datetime.timedelta(hours=2),
4192+
datetime.timedelta(hours=2),
4193+
),
4194+
]
4195+
4196+
# (reference type, interval stored on the alert, timedelta it resolves to)
4197+
deadline_configs = queued_configs + [
4198+
(DeadlineReference.FIXED_DATETIME, datetime.timedelta(hours=1), datetime.timedelta(hours=1)),
41584199
]
41594200

4160-
for deadline_type, interval in deadline_configs:
4201+
expected_resolved_by_alert = {}
4202+
for deadline_type, stored_interval, resolved_interval in deadline_configs:
41614203
if deadline_type == DeadlineReference.DAGRUN_QUEUED_AT:
41624204
reference = DeadlineReference.DAGRUN_QUEUED_AT.serialize_reference()
4163-
deadline_time = dag_run.queued_at + interval
4205+
deadline_time = dag_run.queued_at + resolved_interval
41644206
else: # FIXED_DATETIME
41654207
future_date = timezone.utcnow() + datetime.timedelta(days=7)
41664208
reference = DeadlineReference.FIXED_DATETIME(future_date).serialize_reference()
4167-
deadline_time = future_date + interval
4209+
deadline_time = future_date + resolved_interval
41684210

41694211
deadline_alert = DeadlineAlertModel(
41704212
serialized_dag_id=serialized_dag_id,
41714213
reference=reference,
4172-
interval=interval.total_seconds(),
4214+
interval=serialize(stored_interval),
41734215
callback_def={"path": f"{__name__}.empty_callback_for_deadline", "kwargs": {}},
41744216
)
41754217
session.add(deadline_alert)
41764218
session.flush()
4219+
expected_resolved_by_alert[deadline_alert.id] = resolved_interval
41774220

41784221
deadline = Deadline(
41794222
dagrun_id=dag_run.id,
@@ -4192,7 +4235,15 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
41924235
}
41934236

41944237
tis = session.scalars(select(TI).where(TI.dag_id == dag.dag_id, TI.run_id == dag_run.run_id)).all()
4195-
clear_task_instances(tis, session)
4238+
4239+
# VariableInterval.resolve() reads the Airflow Variable during recalculation.
4240+
variable_ctx = (
4241+
mock.patch.object(Variable, "get", return_value=str(variable_seconds))
4242+
if use_variable_interval
4243+
else contextlib.nullcontext()
4244+
)
4245+
with variable_ctx:
4246+
clear_task_instances(tis, session)
41964247

41974248
dag_run = session.scalar(select(DagRun).where(DagRun.id == dag_run.id))
41984249
assert dag_run.queued_at > original_queued_at
@@ -4205,8 +4256,7 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
42054256
for deadline in deadlines_after:
42064257
if deadline.deadline_time != deadline_times_by_alert[deadline.deadline_alert_id]:
42074258
recalculated_count += 1
4208-
deadline_alert = session.get(DeadlineAlertModel, deadline.deadline_alert_id)
4209-
expected_time = dag_run.queued_at + datetime.timedelta(seconds=deadline_alert.interval)
4259+
expected_time = dag_run.queued_at + expected_resolved_by_alert[deadline.deadline_alert_id]
42104260
assert deadline.deadline_time == expected_time
42114261

42124262
assert recalculated_count == 2

0 commit comments

Comments
 (0)