Lecture 13: Distributed

Transactions
Notes adapted from Tanenbaum’s
“Distributed Systems Principles
and Paradigms”

OCT Distributed Transaction 1

 Hypothetical Web Service
Transaction
Begin transaction BookTrip
book plane
book hotel
book rental car
End transaction BookTrip

OCT Distributed Transaction 2

 Transactions (ACID)
• Atomic: All or nothing. No intermediate states
are visible.
• Consistent: system invariants preserved, e.g., if
there were n dollars in a bank before a transfer
transaction then there will be n dollars in the
bank after the transfer.
• Isolated: Two transactions do not interfere with
each other. They appear as serial executions.
• Durable: The commit causes a permanent
change.

OCT Distributed Transaction 3

 Client talks to coordinator
Different servers
Any server
BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Recoverable objects needed
openTrans Unique Transaction ID to book a hotel.
TID
BookRentalCar Participant
Recoverable objects needed
BookTrip Client to rent a car.
TID = openTransaction()

OCT Distributed Transaction 4

 Client calls methods
Different servers
Any server
BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Recoverable objects needed
to book a hotel.
Call + TID
BookRentalCar Participant
Recoverable objects needed
BookTrip Client to rent a car.

plane.bookFlight(111,”Seat32A”,TID)

OCT Distributed Transaction 5

 Object informs participant
The participant only
calls join if it has not
Different servers
already done so.
BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
join(TID,ref to participant)
BookHotel Participant
Recoverable objects needed
to book a hotel.
BookRentalCar Participant

BookTrip Client
The participant knows where the
coordinator is because that
information can be included in
the TID (eg. an IP address.)
The coordinator now has a pointer to the
OCT Distributed Transaction 6
participant.
 Suppose all goes well (1)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Recoverable objects needed
to book a hotel.

BookTrip Client BookRentalCar Participant

Recoverable objects needed
to rent a car.

OK returned

OK returned

OK returned OCT Distributed Transaction 7

 Suppose all goes well (2)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane

Coordinator begins BookHotel Participant

Recoverable objects needed
2PC and this results in
to book a hotel.
a GLOBAL COMMIT
sent to each participant. BookRentalCar Participant
Recoverable objects needed
BookTrip Client to rent a car.
OK returned
OK returned
OK returned
OCT Distributed Transaction 8
CloseTransaction(TID) Called
This time no cars available (1)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Recoverable objects needed
to book a hotel.
BookRentalCar Participant
Recoverable objects needed
BookTrip Client to rent a car.
OK returned

OK returned

NO CARS AVAILOCT Distributed Transaction 9

abortTransaction(TID) called
This time no cars available (2)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Coordinator sends a Recoverable objects needed
GLOBAL_ABORT to all to book a hotel.
particpants
BookRentalCar Participant
Recoverable objects needed
BookTrip Client to rent a car.
OK returned

OK returned

NO CARS AVAILOCT Distributed Transaction 10

abortTransaction(TID) called
This time no cars available (3)
Different servers

BookPlane Participant
BookTrip ROLLBACK CHANGES
Coordinator
abortTransaction BookHotel Participant
ROLLBACK CHANGES
Each participant
Gets a GLOBAL_ABORT
BookRentalCar Participant
ROLLBACK CHANGES
BookTrip Client
OK returned

OK returned

NO CARS AVAILOCT Distributed Transaction 11

abortTransaction(TID)
BookPlane Server Crashes after
returning ‘OK’ (1)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane
BookHotel Participant
Recoverable objects needed
to book a hotel.

BookTrip Client BookRentalCar Participant

Recoverable objects needed
to rent a car.

OK returned

OK returned

OK returned OCT Distributed Transaction 12

BookPlane Server Crashes after
returning ‘OK’ (2)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane

Coordinator excutes 2PC: BookHotel Participant

Ask everyone to vote. Recoverable objects needed
No news from the BookPlane to book a hotel.
Participant so multicast a BookRentalCar Participant
GLOBAL ABORT
Recoverable objects needed
BookTrip Client to rent a car.
OK returned
OK returned
OK returned
OCT Distributed Transaction 13
CloseTransaction(TID) Called
BookPlane Server Crashes after
returning ‘OK’ (3)
Different servers

BookPlane Participant
BookTrip Recoverable objects needed
Coordinator to book a plane

GLOBAl ABORT BookHotel Participant

ROLLBACK

BookRentalCar Participant
ROLLBACK
BookTrip Client
OK returned
OK returned
ROLLBACK
OK returned
OCT Distributed Transaction 14
CloseTransaction(TID) Called
 Two-Phase Commit Protocol
BookPlane

Vote_Request
BookTrip Vote_Commit
Coordinator
Vote Request
BookHotel
Vote Commit

Vote Request
Phase 1 BookTrip coordinator BookRentalCar
sends a Vote_Request to each Vote Commit
process. Each process returns
a Vote_Commit or Vote_Abort.

OCT Distributed Transaction 15

 Two-Phase Commit Protocol (Gray

BookPlane

Global Commit
BookTrip ACK
Coordinator BookHotel
Global Commit
ACK
Global Commit

Phase 2 BookTrip coordinator ACK BookRentalCar

checks the votes. If every process
votes to commit then so will the coordinator.
In that case, it will send a Global_Commit to each process.
If any process votes to abort the coordinator sends a GLOBAL_ABORT.
Each process waits for a Global_Commit message
OCT Distributed before committing its part of 16
Transaction the
transaction.
 2PC Finite State Machine from
Tanenbaum
BookTrip Coordinator Participant
State has already been saved to permanent
storage.
Init
Init
Vote-request Vote-request
Commit
----------------- -----------------
----------
Vote-abort Vote-commit
Vote-request
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 17
 2PC Blocks in three places
If waiting too long for a Vote-Request
send a Vote-Abort

Init
Init
Vote-request Vote-request
Commit
----------------- -----------------
----------
Vote-abort Vote-commit
Vote-request
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 18
 2PC Blocks in three places

Init
Init
Vote-request
Commit If waiting too long
-----------------
---------- After Vote-request
Vote-commit
Vote-request Send a Global-Abort
Vote-request Ready
wait -----------------
Vote-abort Vote-commit Vote-abort Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 19
 2PC Blocks in three places
If waiting too long we can’t simply abort! We must wait
until the coordinator recovers. We might also make queries
on other participants.

Init
Init
Vote-request
Commit Vote-request -----------------
---------- ----------------- Vote-commit
Vote-request Vote-abort
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 20
 2PC Blocks in three places
If this process learns that another has committed then this
process is free to commit. The coordinator must have sent out
a Global-commit that did not get to this process.

Init
Init
Vote-request
Commit Vote-request -----------------
---------- ----------------- Vote-commit
Vote-request Vote-abort
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 21
 2PC Blocks in three places
If this process learns that another has aborted then it too
is free to abort.

Init
Init
Vote-request
Commit Vote-request -----------------
---------- ----------------- Vote-commit
Vote-request Vote-abort
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 22
 2PC Blocks in three places
Suppose this process learns that another
process is still in its init state. The coordinator must have
crashed while multicasting the Vote-request. It’s safe for
this process (and the queried process) to abort.
Init
Init
Vote-request
Commit Vote-request -----------------
---------- ----------------- Vote-commit
Vote-request Vote-abort
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 23
 2PC Blocks in three places
Tricky case: If the queried processes are all still in their ready
state what do we know? We have to block and wait until the
Coordinator recovers.

Init
Init
Vote-request
Commit Vote-request -----------------
---------- ----------------- Vote-commit
Vote-request Vote-abort
Ready
wait
Vote-abort Vote-commit Global-commit
-------------- ---------------- -------------------
Global-abort Global-commit ACK
Global-abort
----------------
Abort Commit
ACK
Commit
Abort
OCT Distributed Transaction 24