Question

I’m currently writing a Node app and I’m thinking ahead in scaling. As I understand, horizontal scaling is one of the easier ways to scale up an application to handle more concurrent requests. My working copy currently uses MongoDb on the backend.

My question is thus this: I have a data structure that resembles a linked list that requires the order to be strictly maintained. My (imaginary) concern is that when there is a race condition to the database via multiple node instances, it is possible that the resolution of the linked list will be incorrect.

To give an example: Imagine the server having this list a->b. Instance 1 comes in with object c and instance 2 comes in with object d. It is possible that there is a race condition in which both instances read a->b and decides to append their own objects to the list. Instance 1 will then imagine it’s insertion to be a->b->c while instance 2 think it’s a->b->d when the database actually holds a->b->c->d.

In general, this sounds like a job for optimistic locking, however, as I understand, neither MongoDB or Redis (the other database that I am considering) does transactions in the SQL manner.

I therefore imagine the solution to be one of the below:

1. Implement my own transaction in MongoDB using flags. The client does a findAndModify on the lock variable and if successful, performs the operations. If unsuccessful, the client retries after a certain timeout.

2. Use Redis transactions and pubsub to achieve the same effect. I’m not exactly sure how to do this yet, but it sounds like it might be plausible.

3. Implement some sort of smart load balancing. If multiple clients is operating on the same item, route them to the same instance. Since JS is single threaded, the problem would be solved. Unfortunately, I didn’t find a straightforward solution to that.

I sure there exists a better, more elegant way to achieve the above, and I would love to hear any solutions or suggestions. Thank you!

Answer 1

If I understood correctly, and the list is being stored as one single document, you might be looking at row versioning. So add a property to the document that will handle the version, when you update, you increase (or change) the version and you make that a conditional update:

//update(condition, value)

update({version: whateverYouReceivedWhenYouDidFind}, newValue)

Hope it helps.
Gus