Teach you step by step how to use PHP to complete a distributed transaction TCC

                                                                                                               

What is TCC? TCC is the abbreviation of Try, Confirm, and Cancel. It was first proposed by Pat Helland in a paper titled "Life beyond Distributed Transactions: an Apostate's Opinion" published in 2007. .

TCC composition

TCC is divided into 3 phases

• Try phase: try to execute, complete all business checks (consistency), Reserve necessary business resources (quasi-isolation)
• Confirm stage: If the Try of all branches is successful, go to the Confirm stage. Confirm actually executes the business, does not perform any business checks, and only uses the business resources reserved in the Try stage.
• Cancel stage: If one of the Trys of all branches fails, it goes to the Cancel stage. Cancel releases the business resources reserved in the Try phase.

In TCC distributed transactions, there are three roles, which are the same as classic XA distributed transactions:

• AP/application, initiates global transactions and defines global transactions Which transaction branches are included?
• RM/Resource Manager is responsible for the management of various resources of branch transactions.
• TM/Transaction Manager is responsible for coordinating the correct execution of global transactions, including the execution of Confirm and Cancel. , and handle network exceptions

If we want to conduct a business similar to inter-bank transfers, the transfer out (TransOut) and the transfer in (TransIn) are in different microservices, and a successfully completed The typical sequence diagram of a TCC transaction is as follows:

##TCC Practice

Now we will carry out the specific development of a TCC transaction

The open source framework currently available for TCC is mainly Java language, represented by seata. Our example uses nodejs, and the distributed transaction framework used is dtm, which supports distributed transactions very elegantly. Let’s explain the composition of TCC in detail

Let’s write specific Try/Confirm/Cancel processing functions

$vega->handleFunc('/api/TransOutTry', function (Mix\Vega\Context $ctx) {
    var_dump('TransOutTry', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');$vega->handleFunc('/api/TransOutConfirm', function (Mix\Vega\Context $ctx) {
    var_dump('TransOutConfirm', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');$vega->handleFunc('/api/TransOutCancel', function (Mix\Vega\Context $ctx) {
    var_dump('TransOutCancel', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');$vega->handleFunc('/api/TransInTry', function (Mix\Vega\Context $ctx) {
    var_dump('TransInTry', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');$vega->handleFunc('/api/TransInConfirm', function (Mix\Vega\Context $ctx) {
    var_dump('TransInConfirm', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');$vega->handleFunc('/api/TransInCancel', function (Mix\Vega\Context $ctx) {
    var_dump('TransInCancel', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'SUCCESS']);})->methods('POST');

At this point, the processing functions of each sub-transaction are OK, and then open TCC Transaction, make branch call

    Dtmcli\tccGlobalTransaction($dtm, function ($tcc) use ($svc) {
        /** @var Dtmcli\Tcc $tcc */
        $req = ['amount' => 30];
        $tcc->callBranch($req, $svc . '/TransOutTry', $svc . '/TransOutConfirm', $svc . '/TransOutCancel');
        $tcc->callBranch($req, $svc . '/TransInTry', $svc . '/TransInConfirm', $svc . '/TransInCancel');
    });

At this point, a complete TCC distributed transaction is completed.

If you want to completely run a successful example, then refer to this example yedf/dtmcli-php-sample, it is very simple to run it

# 部署启动dtm# 需要docker版本18以上git clone https://github.com/yedf/dtmcd dtm
docker-compose up# 另起一个命令行https://github.com/yedf/dtmcli-php-sample.gitcd dtmcli-php-sample
composer installphp demo.php start

TCC's Rollback

What happens if the bank finds that user 2’s account is abnormal and the return fails when the amount is being transferred to user 2? We can simulate this situation by letting TransIn return failure

$vega->handleFunc('/api/TransInTry', function (Mix\Vega\Context $ctx) {
    var_dump('TransInTry', $ctx->request->getQueryParams(), $ctx->request->getParsedBody());
    $ctx->JSON(200, ['result' => 'FAILURE']);})->methods('POST');

We give the sequence diagram of transaction failure interaction

The difference between this and successful TCC is that , when a sub-transaction returns failure, the global transaction will be rolled back later, and the Cancel operation of each sub-transaction will be called to ensure that all global transactions are rolled back.

Regarding the TCC transaction model, many readers will ask, what will happen if Confirm/Cancel fails? This is a good question because it means you are thinking deeply about the TCC transaction model. The first case is a temporary failure, such as network failure, application or database downtime. Such errors will be retried and success will be returned in the end; the other case is business failure. According to the TCC agreement, resources are locked in the first stage to ensure Sufficient resources can allow Confirm/Cancel to be executed. In other words, in terms of program logic, Confirm/Cancel is not allowed to return business failure. If a business failure occurs, it is a bug and developers need to manually fix the bug.

Summary

In this article, we introduced the theoretical knowledge of TCC, and also gave a complete process of writing a TCC transaction through an example, covering Normal and successful completion, as well as successful rollback. I believe that readers have a deep understanding of TCC through this article.

For more comprehensive knowledge about distributed transactions, please refer to "

The Seven Most Classic Solutions for Distributed Transactions"

The examples used in this article are excerpted from yedf /dtm (https://github.com/yedf/dtm), which supports multiple transaction modes: TCC, SAGA, XA, cross-language support for transaction messages, and has supported customers in golang, python, Java, Teach you step by step how to use Teach you step by step how to use PHP to complete a distributed transaction TCC to complete a distributed transaction TCC, nodejs and other languages. terminal, refer to each language SDK (https://dtm.pub/summary/code.html#go). Provides sub-transaction barrier function to elegantly solve problems such as idempotence, suspension, and null compensation.

After reading this article, you are welcome to visit the github.com/yedf/dtm project and give a star to support it!

The above is the detailed content of Teach you step by step how to use PHP to complete a distributed transaction TCC. For more information, please follow other related articles on the PHP Chinese website!