> Or you could possibly have a lock management table/model in your database.
I had that idea.
I could have:
class ModelLock(models.Model):
name = models.CharField(max_length=100)
isLocked = models.BooleanField()
This is an ok solution -- pretty much the only one i have. But there
is a HUGE problem with this.
Here is how the locking might work (assuming for each row i'd like to
lock, there is a ModelLock)
while ModelLock.objects.filter(name=name).filter(isLocked=True):
pass
lock = ModelLock.objects.filter(name=name)[0]
lock.isLocked=True
lock.save()
The huge problem: ModelLock is not a proper mutex. The calls to
isLocked=True & save() are NOT atomic.
I've heard about inter-process mutexes, but that wouldn't even solve
the problem you bring up of requests on different servers.
A memcached lock would probably be better because at least setting the
lock would be faster than setting it in a database table.
Ivan
On Jan 22, 12:27 pm, Rajesh Dhawan <[EMAIL PROTECTED]> wrote:
> Hi,
>
>
>
> > Let's say I have a model with an integer value. I'd like to increment
> > that value.
>
> > Multiple processes would like to increment that value.
>
> > Does the transaction middleware properly protect against this?
>
> > Example:
> > Processes P1, P2, model instance m, with m.val
>
> > - P1 grabs the object : m = MyModel.objects.filter(get the m i want)
> > [0]
> > - P2 grabs the object : m = MyModel.objects.filter(get the m i want)
> > [0]
> > - P1 m.val += 1
> > - P2 m.val += 1
> > - P1 m.save()
> > - P2 m.save()
>
> > What happens normally? What happens with the transaction middleware?
>
> The transaction middleware can't do anything special in these
> situations. The instances of 'm' in processes P1 and P2 are two
> separate Python object instances. If P2's m.save() gets called after
> P1's m.save(), then m.val from P2's instance will get saved in the
> database regardless of the m.val set by P1. The two instances are not
> connected to each other.
>
>
>
> > What happens if the view is more complicated and only conditionally
> > accesses certain models. Will all models actually accessed be properly
> > locked?
>
> No. The model instances are not locked like this at all.
>
> You will need a global shared memory/storage area to simulate an
> interprocess lock of your own. Realize that your processes could even
> be on different web servers. For example, you could use a "slot" in
> memcache to acquire and release a custom lock every time around the
> statements where you increment m.val. Or you could possibly have a
> lock management table/model in your database.
>
> -Rajesh D
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en
-~----------~----~----~----~------~----~------~--~---
