Rollback in seat booking - grails

Question

I am working on a seat booking module where the user checks whether the seats are available in exam and if yes he can proceed to payment page an then enter card details and pay. Now what I want is that when the payment page is opened seats available value should be reduced by 1 for some time(till session expires or user navigates to some other page).
If I do it using database transaction for the create action(MVC) it won't be possible as when the controller's action(In grails) will be triggered and database changes would be saved without any possibility of rollback.
Is it feasible to acquire seat lock using db or should I use some cron job to check it. Please suggest.

Answer 1

I'm assuming that an exam should never be over-booked. In other words, that exactness is more important than concurrency. In such a case, pessimistic locking strategy is the best bet. Note: by default, Grails uses optimistic locking.
You can use database pessimistic locking to assist with allocating seats, but on it's own, database locking is ill-suited for business transaction locking. As you implied, the lock is released when the transaction commits. So what you can do is implement your business transaction locking on top of database pessimistic locking.
Allocating/locking seats
I recommend using a service to allocate/deallocate seats so that all of the locking code is done in one place.
import groovy.time.TimeDuration
class ExamService {
TimeDuration allocationExpiration = new TimeDuration(0, 30, 0, 0) // 30 minutes
SeatsAllocation allocateSeats(long examId, long userId, int numberOfSeats) {
def exam = Exam.lock(examId)
if(exam.seatsAvailable >= numberOfSeats) {
exam.seatsAvailable = exam.seatsAvailable - numberOfSeats
exam.save()
return new SeatsAllocation(
exam: exam,
user: User.get(userId),
numberOfSeats: numberOfSeats,
purchased: false,
expiration: new Date() + allocationExpiration).save()
} else {
return null
}
}
}
In this example, allocateSeats() is called when the user decides to purchase a certain number of seats, but has not actually made the purchase yet. In this stage of the transaction, a SeatsAllocation represents a user's intent to purchase. The allocation has an expiration date which must be checked at the exact moment the purchase is made. If the allocation has expired, the purchase should be disallowed. The purchasing code is not shown, but basically make sure to set SeatsAllocation.purchased to true.
Deallocating/unlocking seats
This is a good place for the cron/Quartz job you mentioned. The job would retrieve the expired SeatsAllocations, make the seats available, and finally delete the allocations. In the following example, I have the code as part of the service, which the Quartz job can call.
import groovy.time.TimeDuration
class ExamService {
...
def deallocateExpiredSeats() {
SeatsAllocation.where {
purchased == false
expiration < new Date()
}.list([lock: true])
.each {
it.exam.seatsAvailable = it.exam.seatsAvailable + it.numberOfSeats
it.exam.save()
it.delete()
}
}
}
Note that using a scheduled job presents the problem of a delay between the SeatsAllocations expiring and those seats being made available. If the job runs too frequently it will conflict with the pessimistic locking used in allocateSeats(), reducing concurrency even further. On the other hand, if the job runs too infrequently, seats which technically are available cannot be allocated to potential customers because they'll be held hostage by the SeatsAllocations. You can choose the frequency based on the app's load.