Is there a race condition when allocating stock?

there are several methods in the partner.StockRecord model that look a bit like this:

def allocate(self, amount, reference='', status=''):
        """
        Convenience method for ring-fencing money against this source
        """
        self.amount_allocated += amount
        self.save()

I didn’t dig too deep but I didn’t find any use of select_for_update in the source so I think even knowing that everything’s wrapped in a per-request transaction there’s a possible race condition here?

Should the methods do something like this to be safer?

def allocate(self, amount, reference='', status=''):
        """
        Convenience method for ring-fencing money against this source
        """
        self.__class__.objects.select_for_update().filter(pk=self.pk).update(
            amount_allocated=F('amount_allocated') + amount)

[anentropic]

coming back on my earlier comments, I think select_for_update is not necessary when doing an atomic update, you would only use it where you are first selecting, then modifying the instance, then saving

you could manually send those signals for the affected rows, e.g.

from django.db import router
from django.db.models import signals

def allocate(self, quantity):
    """
    Record a stock allocation.

    This normally happens when a product is bought at checkout.  When the
    product is actually shipped, then we 'consume' the allocation.
    """

    self.__class__.objects.filter(pk=self.pk).update(
        num_allocated=Case(
            When(num_allocated__isnull=True,
                 then=(0 + quantity)),
            default=F('num_allocated') + quantity
        ),
    )
    signals.post_save.send(
        sender=self.__class__,
        instance=self,
        created=False,
        raw=False,
        using=router.db_for_write(self.__class__, instance=self)
    )
allocate.alters_data = True

[sasha0]

Fixed in #2281.