Looping to run an async process (sequilize.authenticate) multiple times until successful

Question

Looping to run an async process (sequilize.authenticate) multiple times until successful

I need my microservice to wait for the database to become available before proceeding. There is a sidecar Cloud SQL proxy involved that requires some time for the database connection.

My current approach involves a for loop that retries connecting after a defined interval, but it doesn't seem to wait properly before reconnecting.

class Database {
  static async connectDatabase() {
    try {
      const maxRetries = 20;

      const retryDelay = async (currentRetry, maxRetries) => {
        return new Promise((resolve) =>
          setTimeout(function () {
            logger.info(`Retry attempt: ${currentRetry}, ${maxRetries} retries left.`);
          }, 1000));
      };

      for (let i = 1; i <= maxRetries; i++) {
        try {
          // Establish database connection
          await SequelizeConnection.authenticate()
            .then(() => {
              logger.info("*** Database connection established successfully.");
            })
            .catch(async (err) => {
              logger.info("Error in connect database function: ", err);
              throw err;
            });
          await SeqzelizeConnectionHealthcheck.authenticate()
            .then(() => {
              logger.info("*** Healthcheck database connection established successfully.");
            })
            .catch(async (err) => {
              logger.error("Error in healthcheck connection function: ", err);
              throw err;
            });
        } catch (error) {
          logger.error("Error in connectDB retry function");
          await retryDelay(i, maxRetries - i);
        }
      }
    } catch (error) {
      logger.error("Error in connect database function: ", error);
    }
  }
}

I've attempted using retry libraries and creating a retry wrapper function, but haven't had success with either method.

javascript typescript loops for-loop asynchronous

Answer 1

Answer №1

After reviewing the comments, it's clear that there are several issues in the code. One major problem is the mixing of await with .then()/.catch(), failing to resolve the promise from the wait, and not properly handling successful connections within the for loop.

To address these issues, I have restructured your method and extracted some functions for better clarity. In the provided example below, I simulate a scenario where the main database connection succeeds after 3 attempts and the health check database connection succeeds after 5 attempts.

I've also adjusted the logic to establish both the main database and health check database connections concurrently while retrying them independently. This prevents unnecessary retries on the main database connection if the health check one fails. For this purpose, I introduced a retryUntilResolved function that will continue retrying the given function until it resolves or reaches the maximum number of retries.

// Mocks exclusively for snippet
const resolveNthTime = nth => {
  let callCount = 0;
  return () => ++callCount >= nth
    ? Promise.resolve()
    : Promise.reject('failed!');
}
const SequelizeConnection = { authenticate: resolveNthTime(3) };
const SequelizeConnectionHealthcheck = { authenticate: resolveNthTime(5) };


// Example
const pause = ms =>
  new Promise(resolve => setTimeout(resolve, ms));

const retryUntilResolved = (waitMs, maxRetries) => async func => {
  let tries = 0;

  while (true) {
    try {
      return await func();
    } catch(err) {
      if (tries++ < maxRetries) await pause(waitMs);
      else return err;
    }
  }
};


const authenticateDatabase = async () => {
  try {
    await SequelizeConnection.authenticate();
    console.info("Database connection established");
  } catch (err) {
    console.warn("Error connecting to database: ", err);
    throw err;
  }
};

const authenticateHealthcheck = async () => {
  try {
    await SequelizeConnectionHealthcheck.authenticate();
    console.info("Database connection for healthcheck established");
  } catch (err) {
    console.warn("Error connecting to healthcheck database: ", err);
    throw err;
  }
};

class Database {
  static async connectDatabase() {
    const maxRetries = 20;
    const msBeforeRetry = 1000;
    const retry = retryUntilResolved(msBeforeRetry, maxRetries);

    try {
      await Promise.all([
        retry(authenticateDatabase),
        retry(authenticateHealthcheck),
      ]);
      console.info('Both connections established');
    } catch (error) {
      console.error('Could not establish both connections');
    }
  }
}

Database.connectDatabase();

Answer 2

After reviewing the comments, it's clear that there are several issues in the code. One major problem is the mixing of await with .then()/.catch(), failing to resolve the promise from the wait, and not properly handling successful connections within the for loop.

To address these issues, I have restructured your method and extracted some functions for better clarity. In the provided example below, I simulate a scenario where the main database connection succeeds after 3 attempts and the health check database connection succeeds after 5 attempts.

I've also adjusted the logic to establish both the main database and health check database connections concurrently while retrying them independently. This prevents unnecessary retries on the main database connection if the health check one fails. For this purpose, I introduced a retryUntilResolved function that will continue retrying the given function until it resolves or reaches the maximum number of retries.

// Mocks exclusively for snippet
const resolveNthTime = nth => {
  let callCount = 0;
  return () => ++callCount >= nth
    ? Promise.resolve()
    : Promise.reject('failed!');
}
const SequelizeConnection = { authenticate: resolveNthTime(3) };
const SequelizeConnectionHealthcheck = { authenticate: resolveNthTime(5) };


// Example
const pause = ms =>
  new Promise(resolve => setTimeout(resolve, ms));

const retryUntilResolved = (waitMs, maxRetries) => async func => {
  let tries = 0;

  while (true) {
    try {
      return await func();
    } catch(err) {
      if (tries++ < maxRetries) await pause(waitMs);
      else return err;
    }
  }
};


const authenticateDatabase = async () => {
  try {
    await SequelizeConnection.authenticate();
    console.info("Database connection established");
  } catch (err) {
    console.warn("Error connecting to database: ", err);
    throw err;
  }
};

const authenticateHealthcheck = async () => {
  try {
    await SequelizeConnectionHealthcheck.authenticate();
    console.info("Database connection for healthcheck established");
  } catch (err) {
    console.warn("Error connecting to healthcheck database: ", err);
    throw err;
  }
};

class Database {
  static async connectDatabase() {
    const maxRetries = 20;
    const msBeforeRetry = 1000;
    const retry = retryUntilResolved(msBeforeRetry, maxRetries);

    try {
      await Promise.all([
        retry(authenticateDatabase),
        retry(authenticateHealthcheck),
      ]);
      console.info('Both connections established');
    } catch (error) {
      console.error('Could not establish both connections');
    }
  }
}

Database.connectDatabase();

Answer 3

Answer №2

It is important to utilize resolve() within the context of a setTimeout() function. Below is an example code snippet that demonstrates this concept, assuming that the authenticate() function always fails.

async function establishConnectionWithDatabase() {
  try {
    const retryAttempts = 20;

    const attemptWithTimeout = async (currentAttempt, retriesLeft) => {
      return new Promise((resolve) =>
        setTimeout(function () {
          console.log(`Attempt: ${currentAttempt}, ${retriesLeft} attempts left.`);
          resolve();
        }, 1000));
    };

    for (let i = 1; i <= retryAttempts; i++) {
      try {
        // Establish the database connection
        await sequelizeAuthenticate()
          .then(() => {
            console.log(
              "*** Database connection has been successfully established."
            );
          })
          .catch(async (err) => {
            console.log("Error in establishing database connection: ", err);
            throw err;
          });
        await seqzelizeHealthcheckAuthenticate()
          .then(() => {
            console.log(
              "*** Database healthcheck connection has been successfully established."
            );
          })
          .catch(async (error) => {
            console.log(
              "Error in establishing database healthcheck connection: ",
              error
            );
            throw error;
          });
      } catch (exception) {
        console.log("Error in retrying database connection establishment");
        await attemptWithTimeout(i, retryAttempts - i);
      }
    }
  } catch (exception) {
    console.log("Error in establishing database connection: ", exception);
  }
}

async function sequelizeAuthenticate() {
  return new Promise((_, reject) => {
    setTimeout(function () {
      reject();
    }, 1000);
  });
}

async function seqzelizeHealthcheckAuthenticate() {
  return new Promise((_, reject) => {
    setTimeout(function () {
      reject();
    }, 1000);
  });
}

establishConnectionWithDatabase();

Answer 4

It is important to utilize resolve() within the context of a setTimeout() function. Below is an example code snippet that demonstrates this concept, assuming that the authenticate() function always fails.

async function establishConnectionWithDatabase() {
  try {
    const retryAttempts = 20;

    const attemptWithTimeout = async (currentAttempt, retriesLeft) => {
      return new Promise((resolve) =>
        setTimeout(function () {
          console.log(`Attempt: ${currentAttempt}, ${retriesLeft} attempts left.`);
          resolve();
        }, 1000));
    };

    for (let i = 1; i <= retryAttempts; i++) {
      try {
        // Establish the database connection
        await sequelizeAuthenticate()
          .then(() => {
            console.log(
              "*** Database connection has been successfully established."
            );
          })
          .catch(async (err) => {
            console.log("Error in establishing database connection: ", err);
            throw err;
          });
        await seqzelizeHealthcheckAuthenticate()
          .then(() => {
            console.log(
              "*** Database healthcheck connection has been successfully established."
            );
          })
          .catch(async (error) => {
            console.log(
              "Error in establishing database healthcheck connection: ",
              error
            );
            throw error;
          });
      } catch (exception) {
        console.log("Error in retrying database connection establishment");
        await attemptWithTimeout(i, retryAttempts - i);
      }
    }
  } catch (exception) {
    console.log("Error in establishing database connection: ", exception);
  }
}

async function sequelizeAuthenticate() {
  return new Promise((_, reject) => {
    setTimeout(function () {
      reject();
    }, 1000);
  });
}

async function seqzelizeHealthcheckAuthenticate() {
  return new Promise((_, reject) => {
    setTimeout(function () {
      reject();
    }, 1000);
  });
}

establishConnectionWithDatabase();

Looping to run an async process (sequilize.authenticate) multiple times until successful

Answer №1

Answer №2

Similar questions

implement a user input field within a div using JavaScript

Displaying a horizontal scroll bar for legends in ECharts can be achieved by limiting the legend to three lines. If the legend items exceed this limit, they will scroll horizontally to accommodate all items

Updating lodash when it depends on jshint: A guide to NPM

Having trouble getting the innerHTML update to be triggered by onchange

Determine whether one class is a parent class of another class

Issue with Ckeditor inside a bootstrap modal

Is there a way to point my Github URL to the index file within a specific folder?

How can I retrieve x-data from an external file using Alpine.js?

Middleware designed for logging in React, akin to Multer in the realm of Express JS

Using React.js - Discover the best way to incorporate a function within a child component to unmount a different child component from the same parent, and then mount a new component in its place

Connect data dynamically to the p-table based on columns

Checking if a module is loaded through dynamic route code splitting

Extract the property value and save it as an array in Vue

Error in Next.js 11: Unable to access property 'canonicalBase' as it is undefined

Incorporate a division based on the selection made from a jQuery dropdown menu

Tips on integrating ActiveX controls in Angular

Using request-promise from npm, send a request with a self-generated certificate in JavaScript

Exploring the differences between DDB.query and Raw Operation Object in CDK within AWS AppSync Resolver

servlet failing to send a response to ajax call

Automatically Populate Text Field with the URL of the Current Page