What do you think is the best way to manage concurrency in this (made
up) scenario?

1) You are selling Orders for items of various ProductVariants,
belonging to one Product
2) There may be an upper limit to how many Orders you can take for any
given Product
3) For our example today, you can only accept three more orders for
any combination of ProductVariants of a Product
4) Two users put in three Orders, at the same time

It's in the realm of millisecond possibility, then, for this to
happen:

Person 1: Validate that 3 Orders can be made for Product 123 => true
Person 2: Validate that 3 Orders can be made for Product 123 => true
Person 1: Orders.create(:product_variant => 9); Orders.create
(:product_variant => 8); Orders.create(:product_variant => 7)
Person 2: Orders.create(:product_variant => 6); Orders.create
(:product_variant => 5); Orders.create(:product_variant => 4)

Oops! 6 Orders placed!

What do you think is the best way to prevent overselling in this case?
I've considered:

* Table locking (sucks)
* Setting a lock file per-Product (filesystem-y and not elegantly
scalable past one machine)
* Setting a lock variable per-Product in a memcached store
* A single-worker queue that validates and processes orders in
sequence
* A per Product single-worker queue that validates and processes
orders in sequence
* Something I haven't considered?

What do you think?
Steve!

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Ruby 
on Rails: Talk" group.
To post to this group, send email to rubyonrails-talk@googlegroups.com
To unsubscribe from this group, send email to 
rubyonrails-talk+unsubscr...@googlegroups.com
For more options, visit this group at 
http://groups.google.com/group/rubyonrails-talk?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to