Retry

  /// <summary> 
 /// Retry the action when a Grpc.Core.RpcException is thrown. 
 /// </summary> 
 private 
  
 T 
  
 RetryRpc<T> 
 ( 
 Func<T> 
  
 action 
 ) 
 { 
  
 List<Grpc 
 . 
 Core 
 . 
 RpcException 
>  
 exceptions 
  
 = 
  
 null 
 ; 
  
 var 
  
 delayMs 
  
 = 
  
 _retryDelayMs 
 ; 
  
 for 
  
 ( 
 int 
  
 tryCount 
  
 = 
  
 0 
 ; 
  
 tryCount 
 < 
 _retryCount 
 ; 
  
 ++ 
 tryCount 
 ) 
  
 { 
  
 try 
  
 { 
  
 return 
  
 action 
 (); 
  
 } 
  
 catch 
  
 ( 
 Grpc 
 . 
 Core 
 . 
 RpcException 
  
 e 
 ) 
  
 { 
  
 if 
  
 ( 
 exceptions 
  
 == 
  
 null 
 ) 
  
 exceptions 
  
 = 
  
 new 
  
 List<Grpc 
 . 
 Core 
 . 
 RpcException 
> (); 
  
 exceptions 
 . 
 Add 
 ( 
 e 
 ); 
  
 } 
  
 System 
 . 
 Threading 
 . 
 Thread 
 . 
 Sleep 
 ( 
 delayMs 
 ); 
  
 delayMs 
  
 *= 
  
 2 
 ; 
  
 // Exponential back-off. 
  
 } 
  
 throw 
  
 new 
  
 AggregateException 
 ( 
 exceptions 
 ); 
 } 
 private 
  
 void 
  
 RetryRpc 
 ( 
 Action 
  
 action 
 ) 
 { 
  
 RetryRpc 
 (() 
  
 = 
>  
 { 
  
 action 
 (); 
  
 return 
  
 0 
 ; 
  
 }); 
 } 
 [Fact] 
 public 
  
 void 
  
 TestTransactionalRetry 
 () 
 { 
  
 int 
  
 tryCount 
  
 = 
  
 0 
 ; 
  
 var 
  
 keys 
  
 = 
  
 UpsertBalances 
 (); 
  
 RetryRpc 
 (() 
  
 = 
>  
 { 
  
 using 
  
 ( 
 var 
  
 transaction 
  
 = 
  
 _db 
 . 
 BeginTransaction 
 ()) 
  
 { 
  
 TransferFunds 
 ( 
 keys 
 [ 
 0 
 ], 
  
 keys 
 [ 
 1 
 ], 
  
 10 
 , 
  
 transaction 
 ); 
  
 // Insert a conflicting transaction on the first try. 
  
 if 
  
 ( 
 tryCount 
 ++ 
  
 == 
  
 0 
 ) 
  
 TransferFunds 
 ( 
 keys 
 [ 
 1 
 ], 
  
 keys 
 [ 
 0 
 ], 
  
 5 
 ); 
  
 transaction 
 . 
 Commit 
 (); 
  
 } 
  
 }); 
  
 Assert 
 . 
 Equal 
 ( 
 2 
 , 
  
 tryCount 
 ); 
 } 
 

  type 
  
 BankAccount 
  
 struct 
  
 { 
  
 Balance 
  
 int 
 } 
 const 
  
 amount 
  
 = 
  
 50 
 _ 
 , 
  
 err 
  
 := 
  
 client 
 . 
 RunInTransaction 
 ( 
 ctx 
 , 
  
 func 
 ( 
 tx 
  
 * 
 datastore 
 . 
 Transaction 
 ) 
  
 error 
  
 { 
  
 keys 
  
 := 
  
 [] 
 * 
 datastore 
 . 
 Key 
 { 
 to 
 , 
  
 from 
 } 
  
 accs 
  
 := 
  
 make 
 ([] 
 BankAccount 
 , 
  
 2 
 ) 
  
 if 
  
 err 
  
 := 
  
 tx 
 . 
 GetMulti 
 ( 
 keys 
 , 
  
 accs 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 accs 
 [ 
 0 
 ]. 
 Balance 
  
 += 
  
 amount 
  
 accs 
 [ 
 1 
 ]. 
 Balance 
  
 -= 
  
 amount 
  
 _ 
 , 
  
 err 
  
 := 
  
 tx 
 . 
 PutMulti 
 ( 
 keys 
 , 
  
 accs 
 ) 
  
 return 
  
 err 
 }) 
 

  int 
  
 retries 
  
 = 
  
 5 
 ; 
 while 
  
 ( 
 true 
 ) 
  
 { 
  
 try 
  
 { 
  
 transferFunds 
 ( 
 fromKey 
 , 
  
 toKey 
 , 
  
 10 
 ); 
  
 break 
 ; 
  
 } 
  
 catch 
  
 ( 
 DatastoreException 
  
 e 
 ) 
  
 { 
  
 if 
  
 ( 
 retries 
  
 == 
  
 0 
 ) 
  
 { 
  
 throw 
  
 e 
 ; 
  
 } 
  
 -- 
 retries 
 ; 
  
 } 
 } 
 // Retry handling can also be configured and automatically applied using google-cloud-java. 
 

  async 
  
 function 
  
 transferFundsWithRetry 
 () 
  
 { 
  
 const 
  
 maxTries 
  
 = 
  
 5 
 ; 
  
 async 
  
 function 
  
 tryRequest 
 ( 
 currentAttempt 
 , 
  
 delay 
 ) 
  
 { 
  
 try 
  
 { 
  
 await 
  
 transferFunds 
 ( 
 fromKey 
 , 
  
 toKey 
 , 
  
 10 
 ); 
  
 } 
  
 catch 
  
 ( 
 err 
 ) 
  
 { 
  
 if 
  
 ( 
 currentAttempt 
  
< = 
  
 maxTries 
 ) 
  
 { 
  
 // Use exponential backoff 
  
 setTimeout 
 ( 
 async 
  
 () 
  
 = 
>  
 { 
  
 await 
  
 tryRequest 
 ( 
 currentAttempt 
  
 + 
  
 1 
 , 
  
 delay 
  
 * 
  
 2 
 ); 
  
 }, 
  
 delay 
 ); 
  
 } 
  
 throw 
  
 err 
 ; 
  
 } 
  
 } 
  
 await 
  
 tryRequest 
 ( 
 1 
 , 
  
 100 
 ); 
 } 
 

  $retries = 5; 
 for ($i = 0; $i < $retries; $i++) { 
 try { 
 require_once __DIR__ . '/transfer_funds.php'; 
 transfer_funds($fromKeyId, $toKeyId, 10, $namespaceId); 
 } catch (\Google\Cloud\Core\Exception\ConflictException $e) { 
 // if $i >= $retries, the failure is final 
 continue; 
 } 
 // Succeeded! 
 break; 
 } 
 

  from 
  
 google.cloud 
  
 import 
  datastore 
 
 # For help authenticating your client, visit 
 # https://cloud.google.com/docs/authentication/getting-started 
 client 
 = 
  datastore 
 
 . 
  Client 
 
 () 
 import 
  
 google.cloud.exceptions 
 for 
 _ 
 in 
 range 
 ( 
 5 
 ): 
 try 
 : 
 transfer_funds 
 ( 
 client 
 , 
 account1 
 . 
 key 
 , 
 account2 
 . 
 key 
 , 
 50 
 ) 
 break 
 except 
 google 
 . 
 cloud 
 . 
 exceptions 
 . 
 Conflict 
 : 
 continue 
 else 
 : 
 print 
 ( 
 "Transaction failed." 
 ) 
 

  ( 
 1 
 .. 
 5 
 ) 
 . 
 each 
  
 do 
  
 | 
 i 
 | 
  
 begin 
  
 return 
  
 transfer_funds 
  
 from_key 
 , 
  
 to_key 
 , 
  
 amount 
  
 rescue 
  
 Google 
 :: 
 Cloud 
 :: 
 Error 
  
 = 
>  
 e 
  
 raise 
  
 e 
  
 if 
  
 i 
  
 == 
  
 5 
  
 end 
 end