Understanding XA Transactions With Practical Examples in Go | by dongfu ye | May, 2022

A take a look at the precept of XA transaction

Photograph by Towfiqu barbhuiya on Unsplash

XA is a specification for distributed transactions proposed by the X/Open group. The X/Open Distributed Transaction Processing (DTP) mannequin is made up of three software program elements:

  • An software program (AP) defines transaction boundaries and specifies actions that represent a transaction.
  • Useful resource managers (RMs, similar to databases or file entry programs) present entry to shared assets.
  • A separate part known as a transaction supervisor (TM) assigns identifiers to transactions, displays their progress, and takes duty for transaction completion and for failure restoration.

The next determine illustrates the interfaces outlined by the X/Open DTP mannequin.


XA is split into two phases.

  • Part 1 (put together): All taking part RMs put together to execute their transactions and lock the required assets. When every participant is prepared, it experiences to TM.
  • Part 2 (commit/rollback): When the transaction supervisor (TM) receives that every one individuals (RM) are prepared, it sends commit instructions to all individuals. In any other case, it sends rollback instructions to all individuals.

At current, nearly all in style databases help XA transactions, together with Mysql, Oracle, SqlServer, and Postgres.

Let’s see how database Mysql helps XA with the code under:

An interbank switch is a typical distributed transaction state of affairs, the place A must switch cash throughout a financial institution to B. Each the withdraw and the deposit might succeed osr fail, and it’s required that the sum of the steadiness of A and B shouldn’t change after the switch is completed, no matter any errors that happen.

Distributed XA transactions can remedy the above enterprise drawback. This text presents an answer based mostly on dtm-labs/dtm. DTM is a well-liked distributed transaction framework that helps XA, Saga, OutBox, and TCC patterns.

The next determine illustrates a profitable world transaction:

The code to implement it in Go is kind of easy:

The above code first registers a worldwide XA transaction after which calls two sub-transactions: TransOut, TransIn. After executing the sub-transactions efficiently, the worldwide XA transaction is dedicated to DTM. DTM receives the dedication of the XA world transaction, then calls the XA commit of all of the subtransactions, and eventually, change the standing of the worldwide transaction to succeed.

Code samples in different languages might be discovered right here: SDKs

You’ll be able to run the above instance by operating the next instructions.


git clone https://github.com/dtm-labs/dtm && cd dtm
go run most important.go

Run instance

git clone https://github.com/dtm-labs/dtm-examples && cd dtm-examples
go run most important.go http_xa

If any put together operation fails, DTM will name XA rollback of every subtransaction to roll again, and eventually, change the standing of the worldwide transaction to fail.

Let’s cross TransInResult="FAILURE" within the request payload of XaFireRequest to set off a failure.

req := &busi.TransReqAmount: 30, TransInResult: "FAILURE"

The timing diagram for failure is as follows:


  • The command of the second section can also be despatched to the API BusiAPI+"/TransOutXa", and inside this service, dtmcli.XaLocalTransaction will routinely name XA commit | XA rollback. So the physique of the request is nil, and parsing physique operations, such because the earlier reqFrom, should be positioned inside XaLocalTransaction. In any other case, the physique parsing will lead to errors.

The complexity of a two-phase commit comes from all of the failure situations that may come up. Probably the most annoying failure occurs after a participant has acknowledged and ready and earlier than it receives the choice, similar to a failure of the coordinator.

Our answer to this failure is kind of easy and strong. Since many of the cloud distributors present highly-available databases, we will retailer the progress of sub-transactions in these databases and run a number of situations of TMs. Every occasion will ballot the paused transactions and proceed to course of them.

The cloud vendor takes care of the database failure and should use Paxos/Raft to elect a wholesome occasion robustly.

In comparison with different patterns like SAGA and TCC, some great benefits of XA world transactions are:

  • Easy and simple to know
  • Automated rollback of enterprise, no want to write down compensation manually

The disadvantages of XA are:

  • Want the XA transaction from the underlying database
  • Knowledge is locked from knowledge modification till the dedication, for much longer than different patterns. It isn’t appropriate for extremely concurrent enterprise.

This text introduces the essential precept of XA transaction and presents a sensible instance of it. Readers can simply observe the instance to deal with their very own companies.

You’re welcome to go to github.com/dtm-labs/dtm. It’s a devoted challenge to make distributed transactions in microservices simpler. It helps a number of languages and patterns like a two-phase message, Saga, TCC, and XA.

More Posts