Recipe 3.13. Protecting Against Race Conditions with Transactions

Problem

You've got a shopping application that adds items to a cart and then removes those items from inventory. These two steps are part of a single operation. Both the number of items in the cart and the amount remaining in inventory are stored in separate tables in a database. You recognize that it's possible that when a specific number of items are added to the cart that there could be insufficient inventory to fill the order.

You could try to get around this by checking for available inventory prior to adding items to the cart, but it's still possible for another user to deplete the inventory in between your check for availability and the cart quantity update.

You want to ensure that if there isn't enough of an item in inventory, the amount added to the cart is rolled back to its original state. In other words, you want both operations to complete successfully, or neither to make any changes.

Solution

Use Active Record transactions.

First, create a very simple database to store items in the cart and those remaining in inventory. Populate the inventory table with 50 laptops. Use the following migration to set this up:

db/migrate/001_build_db.rb :

class BuildDb < ActiveRecord::Migration
  def self.up

    create_table :cart_items do t
      t.column :user_id, :integer
      t.column :name, :string
      t.column :quantity, :integer, { :default => 0 }
    end

    create_table :inventory_items do t
      t.column :name, :string
      t.column :on_hand, :integer
    end

    InventoryItem.create :name => "Laptop",
                         :on_hand => 50
  end

  def self.down
    drop_table :cart_items
    drop_table :inventory_items
  end
end

Create a model for inventory that subtracts items from the quantity on hand. Add a validation method that ensures that the amount of an item in inventory cannot be negative.

app/models/inventory_item.rb :

class InventoryItem < ActiveRecord::Base

  def subtract_from_inventory(total)
    self.on_hand -= total
    self.save!
    return self.on_hand
  end

  protected
    def validate
      errors.add("on_hand", "can't be negative") unless on_hand >= 0
    end     
end

Next, create a cart model with an accessor method for adding items:

app/models/cart_item.rb :

class CartItem < ActiveRecord::Base

  def add_to_cart(qty)
    self.quantity += qty
    self.save!
    return self.quantity
  end
end

In the Cart Controller , create a method that adds five laptops to a shopping cart. Pass a block containing the related operations into an Active Record transaction method. Further surround this transaction with exception handling.

app/controllers/cart_controller.rb :

class CartController < ApplicationController

  def add_items 
    item = params[:item]  "Laptop" 
    quantity = params[:quantity].to_i  5
    @new_item = CartItem.find_or_create_by_name(item)
    @inv_item = InventoryItem.find_by_name(@new_item.name)

    begin   
      CartItem.transaction(@new_item, @inv_item) do
        @new_item.add_to_cart(quantity)  
        @inv_item.subtract_from_inventory(quantity)
      end     
    rescue  
      flash[:error] = "Sorry, we don't have #{quantity} of that item left!" 
      render :action => "add_items" 
      return  
    end
  end
end

Finally, create a view that displays the number of items in the cart with the number left in inventory, as well as a form for adding more items:

app/views/cart/add_items. rhtml :

<h1>Simple Cart</h1>

<% if flash[:error] %>
  <p style="color: red; font-weight: bold;"><%= flash[:error] %></p>
<% end %>

<p>Items in cart: <b><%= @new_item.quantity %></b>  
<%= @new_item.name.pluralize %><p>

<p>Items remaining in inventory: <b><%= @inv_item.on_hand %></b>  
<%= @inv_item.name.pluralize %><p>

<form action="add_items" method="post">
  <input type="text" name="quantity" value="1" size="2">
  <select name="item">
    <option value="Laptop">Laptop</option>
  </select>
  <input type="submit" value="Add to cart">
</form>

Discussion

The solution uses Active Record's transaction facility to guarantee that all operations within the transaction block are performed successfully or that none of them are.

In the solution, the model definitions take care of incrementing and decrementing the quantities involved. The save! method that Active Record provides will commit the changed object to the database. save! differs from save because it raises a RecordInvalid exception if the save fails, instead of returning false . The rescue block in the Cart Controller catches the error, should one occur; this block defines the error message to be sent to the user.

Passing a block of code to the transaction method takes care of rolling back partial database changes made by that code, upon error. To return the objects involved in the transaction to their original state, you have to pass them as arguments to the transaction call as well as the code block.

Figure 3-6 shows the cart from the solution after a successful "add to cart" attempt.

Figure 3-6. A laptop successfully added to the cart and removed from inventory

At the mysql prompt, you can confirm that the quantities change as expected. More importantly, you can confirm that the transaction actually rolls back any database changes upon error.

mysql>

select quantity, on_hand from cart_items ci, inventory_items ii where
ci.name = ii.name;

+----------+---------+
 quantity  on_hand 
+----------+---------+
       32       18 
+----------+---------+
1 row in set (0.01 sec)

Figure 3-7 shows the results of trying to add more than what's left in inventory.

Figure 3-7. The results of a failed transaction

Sure enough, the update of quantity was rolled back because the decrement of on_hand failed its validation check:

mysql>

select quantity, on_hand from cart_items ci, inventory_items ii where
ci.name = ii.name;

+----------+---------+
 quantity  on_hand 
+----------+---------+
       50        0 
+----------+---------+
1 row in set (0.01 sec)

For Active Record transactions to work, your database needs to have transaction support. The default database engine for MySQL is MyISAM, which does not support transactions. The solution specifies that MySQL use the InnoDB storage engine in the table creation statements. InnoDB has transaction support. If you're using PostgreSQL, you have transaction support by default.

Flylib.com

Category list

Similar pages

Recipe 3.13. Protecting Against Race Conditions with Transactions