Merge pull request #208153 from saimicrosoft/retry_logic

v-dirichards · web-flow · commit 201924e90148 · 2022-08-24T14:48:29.000-05:00
Add retry logic code for app stacks, Citus
diff --git a/articles/postgresql/hyperscale/includes/app-stack-retry-intro.md b/articles/postgresql/hyperscale/includes/app-stack-retry-intro.md
@@ -0,0 +1,23 @@
+---
+author: jonels-msft
+ms.author: jonels
+ms.service: postgresql
+ms.subservice: hyperscale-citus
+ms.topic: include
+ms.date: 08/24/2022
+---
+
+It's sometimes possible that database requests from your application fail.
+Such issues can happen under different scenarios, such as network failure
+between app and database, incorrect password, etc. Some issues may be
+transient, and resolve themselves in a few seconds to minutes. You can
+configure retry logic in your app to overcome the transient errors.
+
+Configuring retry logic in your app helps improve the end user experience.
+Under failure scenarios, users will merely wait a bit longer for the
+application to serve requests, rather than experience errors.
+
+The example below shows how to implement retry logic in your app. The sample
+code snippet tries a database request every 60 seconds (up to five times) until
+it succeeds. The number and frequency of retries can be configured based on
+your application's needs.
diff --git a/articles/postgresql/hyperscale/quickstart-app-stacks-csharp.md b/articles/postgresql/hyperscale/quickstart-app-stacks-csharp.md
@@ -7,7 +7,7 @@ ms.service: postgresql
 ms.subservice: hyperscale-citus
 ms.topic: quickstart
 recommendations: false
-ms.date: 08/11/2022
+ms.date: 08/24/2022
 ---
 
 # C# app to connect and query Hyperscale (Citus)
@@ -351,6 +351,76 @@ namespace Driver
     }
 }
 ```
+## App retry during database request failures
+
+[!INCLUDE[app-stack-next-steps](includes/app-stack-retry-intro.md)]
+
+```csharp
+using System;
+using System.Data;
+using System.Runtime.InteropServices;
+using System.Text;
+using Npgsql;
+
+namespace Driver
+{
+    public class Reconnect
+    {
+        static string connStr = new NpgsqlConnectionStringBuilder("Server = <host name>; Database = citus; Port = 5432; User Id = citus; Password = {Your Password}; Ssl Mode = Require; Pooling = true; Minimum Pool Size=0; Maximum Pool Size =50;TrustServerCertificate = true").ToString();
+        static string executeRetry(string sql, int retryCount)
+        {
+            for (int i = 0; i < retryCount; i++)
+            {
+                try
+                {
+                    using (var conn = new NpgsqlConnection(connStr))
+                    {
+                        conn.Open();
+                        DataTable dt = new DataTable();
+                        using (var _cmd = new NpgsqlCommand(sql, conn))
+                        {
+                            NpgsqlDataAdapter _dap = new NpgsqlDataAdapter(_cmd);
+                            _dap.Fill(dt);
+                            conn.Close();
+                            if (dt != null)
+                            {
+                                if (dt.Rows.Count > 0)
+                                {
+                                    int J = dt.Rows.Count;
+                                    StringBuilder sb = new StringBuilder();
+
+                                    for (int k = 0; k < dt.Rows.Count; k++)
+                                    {
+                                        for (int j = 0; j < dt.Columns.Count; j++)
+                                        {
+                                            sb.Append(dt.Rows[k][j] + ",");
+                                        }
+                                        sb.Remove(sb.Length - 1, 1);
+                                        sb.Append("\n");
+                                    }
+                                    return sb.ToString();
+                                }
+                            }
+                        }
+                    }
+                    return null;
+                }
+                catch (Exception e)
+                {
+                    Thread.Sleep(60000);
+                    Console.WriteLine(e.Message);
+                }
+            }
+            return null;
+        }
+        static void Main(string[] args)
+        {
+            string result = executeRetry("select 1",5);
+            Console.WriteLine(result);
+        }
+    }
+}
+```
 
 ## Next steps
 
diff --git a/articles/postgresql/hyperscale/quickstart-app-stacks-java.md b/articles/postgresql/hyperscale/quickstart-app-stacks-java.md
@@ -7,7 +7,7 @@ ms.service: postgresql
 ms.subservice: hyperscale-citus
 ms.topic: quickstart
 recommendations: false
-ms.date: 08/11/2022
+ms.date: 08/24/2022
 ---
 
 # Java app to connect and query Hyperscale (Citus)
@@ -109,9 +109,9 @@ Create a `src/main/resources/application.properties` file, and add:
 
 ``` properties
 driver.class.name=org.postgresql.Driver
-url=jdbc:postgresql://<host>:5432/citus?ssl=true&sslmode=require
-user=citus
-password=<password>
+db.url=jdbc:postgresql://<host>:5432/citus?ssl=true&sslmode=require
+db.username=citus
+db.password=<password>
 ```
 
 Replace the  \<host\> using the Connection string that you gathered previously. Replace \<password\> with the password that you set for the database.
@@ -193,7 +193,7 @@ public class DButil {
             datasource.setPassword(properties.getProperty(DB_PASSWORD));
             datasource.setMinimumIdle(100);
             datasource.setMaximumPoolSize(1000000000);
-            datasource.setAutoCommit(false);
+            datasource.setAutoCommit(true);
             datasource.setLoginTimeout(3);
         } catch (IOException | SQLException  e) {
             e.printStackTrace();
@@ -593,23 +593,23 @@ Executing the `main` class should now produce the following output:
 The following code is an example for copying in-memory data to table.
 
 ```java
-private static void inMemory(Connection connection) throws SQLException,IOException {
-    log.info("Copying in-memory data into table");
-    String[] input = {"0,Target,Sunnyvale,California,94001"};
-
-    Connection unwrap = connection.unwrap(Connection.class);
-    BaseConnection  connSec = (BaseConnection) unwrap;
-
-    CopyManager copyManager = new CopyManager((BaseConnection) connSec);
-    String copyCommand = "COPY pharmacy FROM STDIN with csv";
-
-    for (String var : input)
+private static void inMemory(Connection connection) throws SQLException,IOException
     {
-        Reader reader = new StringReader(var);
+    log.info("Copying inmemory data into table");
+            
+    final List<String> rows = new ArrayList<>();
+    rows.add("0,Target,Sunnyvale,California,94001");
+    rows.add("1,Apollo,Guntur,Andhra,94003");
+        
+    final BaseConnection baseConnection = (BaseConnection) connection.unwrap(Connection.class);
+    final CopyManager copyManager = new CopyManager(baseConnection);
+
+    // COPY command can change based on the format of rows. This COPY command is for above rows.
+    final String copyCommand = "COPY pharmacy FROM STDIN with csv";        
+       
+    try (final Reader reader = new StringReader(String.join("\n", rows))) {
         copyManager.copyIn(copyCommand, reader);
     }
-
-    copyManager.copyIn(copyCommand);
 }
 ```
 
@@ -642,6 +642,90 @@ Executing the main class should now produce the following output:
 [INFO   ] Closing database connection
 ```
 
+## App retry during database request failures
+
+[!INCLUDE[app-stack-next-steps](includes/app-stack-retry-intro.md)]
+
+```java
+package test.crud;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.util.logging.Logger;
+import com.zaxxer.hikari.HikariDataSource;
+
+public class DemoApplication
+{
+    private static final Logger log;
+
+    static
+    {
+        System.setProperty("java.util.logging.SimpleFormatter.format", "[%4$-7s] %5$s %n");
+        log = Logger.getLogger(DemoApplication.class.getName());
+    }
+    private static final String DB_USERNAME = "citus";
+    private static final String DB_PASSWORD = "<Your Password>";
+    private static final String DB_URL = "jdbc:postgresql://<Server Name>:5432/citus?sslmode=require";
+    private static final String DB_DRIVER_CLASS = "org.postgresql.Driver";
+    private static HikariDataSource datasource;
+
+    private static String executeRetry(String sql, int retryCount) throws InterruptedException
+    {
+        Connection con = null;
+        PreparedStatement pst = null;
+        ResultSet rs = null;
+        for (int i = 1; i <= retryCount; i++)
+        {
+            try
+            {
+                datasource = new HikariDataSource();
+                datasource.setDriverClassName(DB_DRIVER_CLASS);
+                datasource.setJdbcUrl(DB_URL);
+                datasource.setUsername(DB_USERNAME);
+                datasource.setPassword(DB_PASSWORD);
+                datasource.setMinimumIdle(10);
+                datasource.setMaximumPoolSize(1000);
+                datasource.setAutoCommit(true);
+                datasource.setLoginTimeout(3);
+                log.info("Connecting to the database");
+                con = datasource.getConnection();
+                log.info("Connection established");
+                log.info("Read data");
+                pst = con.prepareStatement(sql);
+                rs = pst.executeQuery();
+                StringBuilder builder = new StringBuilder();
+                int columnCount = rs.getMetaData().getColumnCount();
+                while (rs.next())
+                {
+                    for (int j = 0; j < columnCount;)
+                    {
+                        builder.append(rs.getString(j + 1));
+                        if (++j < columnCount)
+                            builder.append(",");
+                    }
+                    builder.append("\r\n");
+                }
+                return builder.toString();
+            }
+            catch (Exception e)
+            {
+                Thread.sleep(60000);
+                System.out.println(e.getMessage());
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) throws Exception
+    {
+        String result = executeRetry("select 1", 5);
+        System.out.print(result);
+    }
+}
+```
+
 ## Next steps
 
 [!INCLUDE[app-stack-next-steps](includes/app-stack-next-steps.md)]
diff --git a/articles/postgresql/hyperscale/quickstart-app-stacks-nodejs.md b/articles/postgresql/hyperscale/quickstart-app-stacks-nodejs.md
@@ -7,7 +7,7 @@ ms.service: postgresql
 ms.subservice: hyperscale-citus
 ms.topic: quickstart
 recommendations: false
-ms.date: 08/18/2022
+ms.date: 08/24/2022
 ---
 
 # Node.js app to connect and query Hyperscale (Citus)
@@ -73,10 +73,10 @@ const pool = new Pool({
   max: 300,
   connectionTimeoutMillis: 5000,
 
-  host: 'c.citustest.postgres.database.azure.com',
+  host: '<host>',
   port: 5432,
   user: 'citus',
-  password: 'Password123$',
+  password: '<your password>',
   database: 'citus',
   ssl: true,
 });
@@ -387,6 +387,50 @@ async function importInMemoryDatabase() {
 })();
 ```
 
+## App retry during database request failures
+
+[!INCLUDE[app-stack-next-steps](includes/app-stack-retry-intro.md)]
+
+```javascript
+const { Pool } = require('pg');
+const { sleep } = require('sleep');
+
+const pool = new Pool({
+  host: '<host>',
+  port: 5432,
+  user: 'citus',
+  password: '<your password>',
+  database: 'citus',
+  ssl: true,
+  connectionTimeoutMillis: 0,
+  idleTimeoutMillis: 0,
+  min: 10,
+  max: 20,
+});
+
+(async function() {
+  res = await executeRetry('select nonexistent_thing;',5);
+  console.log(res);
+  process.exit(res ? 0 : 1);
+})();
+
+async function executeRetry(sql,retryCount)
+{
+  for (let i = 0; i < retryCount; i++) {
+    try {
+      result = await pool.query(sql)
+      return result;
+    } catch (err) {
+      console.log(err.message);
+      sleep(60);
+    }
+  }
+
+  // didn't succeed after all the tries
+  return null;
+}
+```
+
 ## Next steps
 
 [!INCLUDE[app-stack-next-steps](includes/app-stack-next-steps.md)]
diff --git a/articles/postgresql/hyperscale/quickstart-app-stacks-python.md b/articles/postgresql/hyperscale/quickstart-app-stacks-python.md
@@ -7,7 +7,7 @@ ms.service: postgresql
 ms.subservice: hyperscale-citus
 ms.topic: quickstart
 recommendations: false
-ms.date: 08/11/2022
+ms.date: 08/24/2022
 ---
 
 # Python app to connect and query Hyperscale (Citus)
@@ -195,6 +195,43 @@ with conn.cursor() as cur:
 conn.commit()
 conn.close()
 ```
+## App retry during database request failures
+
+[!INCLUDE[app-stack-next-steps](includes/app-stack-retry-intro.md)]
+
+```python
+import psycopg2
+import time
+from psycopg2 import pool
+
+host = "<host>"
+dbname = "citus"
+user = "citus"
+password = "{your password}"
+sslmode = "require"
+
+conn_string = "host={0} user={1} dbname={2} password={3} sslmode={4}".format(
+        host, user, dbname, password, sslmode)
+postgreSQL_pool = psycopg2.pool.SimpleConnectionPool(1, 20, conn_string)
+
+def executeRetry(query, retryCount):
+    for x in range(retryCount):
+        try:
+            if (postgreSQL_pool):
+                # Use getconn() to Get Connection from connection pool
+                conn = postgreSQL_pool.getconn()
+                cursor = conn.cursor()
+                cursor.execute(query)
+                return cursor.fetchall()
+            break
+        except Exception as err:
+            print(err)
+            postgreSQL_pool.putconn(conn)
+            time.sleep(60)
+    return None
+
+print(executeRetry("select 1", 5))
+```
 
 ## Next steps
 
diff --git a/articles/postgresql/hyperscale/quickstart-app-stacks-ruby.md b/articles/postgresql/hyperscale/quickstart-app-stacks-ruby.md
