diff --git a/apps/feeds/migrations/0003_feed_claimed_at.py b/apps/feeds/migrations/0003_feed_claimed_at.py new file mode 100644 index 0000000..dd65e2f --- /dev/null +++ b/apps/feeds/migrations/0003_feed_claimed_at.py @@ -0,0 +1,18 @@ +# Generated by Django 5.2.18 on 2026-10-31 18:00 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ("feeds", "0002_remove_folder"), + ] + + operations = [ + migrations.AddField( + model_name="feed", + name="claimed_at", + field=models.DateTimeField(blank=True, null=True), + ), + ] diff --git a/apps/feeds/models.py b/apps/feeds/models.py index 98418b2..ef89b27 100644 --- a/apps/feeds/models.py +++ b/apps/feeds/models.py @@ -40,6 +40,15 @@ class Feed(models.Model): fetch_error_count = models.PositiveIntegerField(default=0) is_active = models.BooleanField(default=True) + # Set by poll_due_feeds' atomic claim (an UPDATE ... WHERE clause, not + # select_for_update — Celery Beat and fetch_feed run in separate + # transactions) and cleared once fetch_feed finishes, so overlapping + # beat ticks or a fetch that runs long can't both dispatch the same + # feed. A claim older than CLAIM_STALE_MINUTES (tasks.py) is treated as + # abandoned and can be reclaimed, so a worker dying mid-fetch doesn't + # wedge the feed forever. + claimed_at = models.DateTimeField(null=True, blank=True) + created_at = models.DateTimeField(auto_now_add=True) def __str__(self): diff --git a/apps/feeds/tasks.py b/apps/feeds/tasks.py index bf74571..58f5666 100644 --- a/apps/feeds/tasks.py +++ b/apps/feeds/tasks.py @@ -4,6 +4,7 @@ from io import BytesIO from celery import shared_task from django.contrib.auth import get_user_model +from django.db.models import Q from django.utils import timezone from apps.articles.tasks import apply_filter_rules_for_feed @@ -14,13 +15,23 @@ from .services.fetcher import effective_interval_minutes, fetch_and_ingest logger = logging.getLogger(__name__) +# How long a claimed-but-unfinished fetch blocks the same feed from being +# claimed again — must comfortably exceed FETCH_TIMEOUT_SECONDS plus parse/ +# ingest time, so a slow-but-healthy fetch is never raced by the next tick, +# while a worker that died mid-fetch doesn't wedge the feed forever. +CLAIM_STALE_MINUTES = 10 + @shared_task def poll_due_feeds(): - """Find every active Feed whose polling interval has elapsed and - dispatch a fetch_feed task for each — fan-out happens here, not via one - Celery Beat entry per feed. + """Find every active Feed whose polling interval has elapsed, atomically + claim it (so overlapping beat ticks or a slow-running previous fetch + can't dispatch the same feed twice), and dispatch a fetch_feed task for + each claimed feed — fan-out happens here, not via one Celery Beat entry + per feed. """ + now = timezone.now() + claim_stale_before = now - timedelta(minutes=CLAIM_STALE_MINUTES) due_feed_ids = [ feed.id for feed in Feed.objects.filter(is_active=True).only( @@ -28,9 +39,22 @@ def poll_due_feeds(): ) if _is_due(feed) ] + claimed_ids = [] for feed_id in due_feed_ids: + # The UPDATE's WHERE clause re-checks staleness at the database + # level: it only claims rows nobody else has already claimed more + # recently than CLAIM_STALE_MINUTES ago, so two workers racing this + # same loop can't both get rowcount=1 for the same feed. + claimed = ( + Feed.objects.filter(id=feed_id, is_active=True) + .filter(Q(claimed_at__isnull=True) | Q(claimed_at__lt=claim_stale_before)) + .update(claimed_at=now) + ) + if claimed: + claimed_ids.append(feed_id) + for feed_id in claimed_ids: fetch_feed.delay(feed_id) - return len(due_feed_ids) + return len(claimed_ids) def _is_due(feed: Feed) -> bool: @@ -48,6 +72,7 @@ def fetch_feed(feed_id: int): return None result = fetch_and_ingest(feed) + feed.claimed_at = None feed.save() changed_article_ids = result.new_article_ids + result.updated_article_ids diff --git a/apps/feeds/test_tasks.py b/apps/feeds/test_tasks.py index b4f678d..38fe8f1 100644 --- a/apps/feeds/test_tasks.py +++ b/apps/feeds/test_tasks.py @@ -40,6 +40,58 @@ def test_poll_due_feeds_dispatches_only_due_feeds(): assert inactive_but_overdue.id not in dispatched_ids +@pytest.mark.django_db +def test_poll_due_feeds_does_not_reclaim_a_feed_it_just_claimed(): + # Models a second beat tick (or an overlapping worker) running + # poll_due_feeds before the first claimed fetch_feed has finished — + # the feed must only be dispatched once. + overdue = Feed.objects.create( + feed_url="https://c.example.com/feed.xml", + last_fetched_at=timezone.now() - timedelta(hours=2), + fetch_interval_minutes=60, + ) + + with patch("apps.feeds.tasks.fetch_feed.delay") as mock_delay: + first_count = poll_due_feeds() + second_count = poll_due_feeds() + + assert first_count == 1 + assert second_count == 0 + assert mock_delay.call_count == 1 + overdue.refresh_from_db() + assert overdue.claimed_at is not None + + +@pytest.mark.django_db +def test_poll_due_feeds_reclaims_a_stale_claim(): + from apps.feeds.tasks import CLAIM_STALE_MINUTES + + overdue = Feed.objects.create( + feed_url="https://c.example.com/feed.xml", + last_fetched_at=timezone.now() - timedelta(hours=2), + fetch_interval_minutes=60, + claimed_at=timezone.now() - timedelta(minutes=CLAIM_STALE_MINUTES + 1), + ) + + with patch("apps.feeds.tasks.fetch_feed.delay") as mock_delay: + dispatched_count = poll_due_feeds() + + assert dispatched_count == 1 + assert mock_delay.call_args.args[0] == overdue.id + + +@pytest.mark.django_db +@responses.activate +def test_fetch_feed_task_clears_its_claim(): + feed = Feed.objects.create(feed_url="https://example.com/feed.xml", claimed_at=timezone.now()) + responses.add(responses.GET, feed.feed_url, body=GOOD_FEED_XML, status=200) + + fetch_feed(feed.id) + + feed.refresh_from_db() + assert feed.claimed_at is None + + GOOD_FEED_XML = """ Example Blog