Google Cloud Function：删除 firestore 文档并插入 SQL 查询的结果导致超时

Question

I have a cloud function that is triggered by a crontab to compute statistics and insert the results in Firestore.

My cloud function delete the previous stats in firestore and then execute a CloudSQL query (MySQL) and batch insert the result in firestore.

The MySQL Query respond nearly instantly.

The execution takes the maximum of 9 minutes to execute which is not possible.

I think I may have an issue with the chaining of promise. The MySQL lib is not supporting promise natively and I'm new to this.

The full code is here : https://github.com/dev-mansonthomas/RedCrossQuestCloudFunctions/blob/master/RCQ/ULQueteurStatsPerYear/index.js

'use strict';
const mysql     = require('mysql');

const {Firestore} = require('@google-cloud/firestore');
const firestore   = new Firestore ({projectId:process.env.TARGET_PROJECT_ID});
const settings    = {timestampsInSnapshots: true};
firestore.settings(settings);

const fsCollectionName = 'ul_queteur_stats_per_year';


const connectionName = process.env.INSTANCE_CONNECTION_NAME || null;
const dbUser         = process.env.SQL_USER                 || null;
const dbPassword     = process.env.SQL_PASSWORD             || null;
const dbName         = process.env.SQL_DB_NAME              || null;

const mysqlConfig = {
  connectionLimit : 1,
  user            : dbUser,
  password        : dbPassword,
  database        : dbName,
};
if (process.env.NODE_ENV === 'production') {
  mysqlConfig.socketPath = `/cloudsql/${connectionName}`;
}

// Connection pools reuse connections between invocations,
// and handle dropped or expired connections automatically.
let mysqlPool;

const queryStr = ['the big SQL query'].join('\n');

exports.ULQueteurStatsPerYear = (event, context) => {

  const pubsubMessage = event.data;
  const parsedObject  = JSON.parse(Buffer.from(pubsubMessage, 'base64').toString());
  const ul_id         = parsedObject.id;
  // Initialize the pool lazily, in case SQL access isnt needed for this
  // GCF instance. Doing so minimizes the number of active SQL connections,
  // which helps keep your GCF instances under SQL connection limits.
  if (!mysqlPool)
  {
    mysqlPool = mysql.createPool(mysqlConfig);
  }

  //delete current stats of the UL
  let deleteCollection = function(path)
  {
    console.log("removing documents on collection '"+path+"' for ul_id="+ul_id);
    // Get a new write batch
    let batch = firestore.batch();

    return firestore.collection(path).listDocuments().then(val => {
      val.map((val) => {
        if(val.ul_id === ul_id)
        {
          batch.delete(val)
        }

      });

      return batch.commit();
    });
  };


  //then inserting new one
  return deleteCollection("ULQueteurStatsPerYear").then(
    ()=>
    {
      return new Promise((resolve, reject) => {
        mysqlPool.query(
          queryStr,
          [ul_id],
          (err, results) => {
            if (err)
            {
              console.error(err);
              reject(err);
            }
            else
            {
              if(results !== undefined && Array.isArray(results) && results.length >= 1)
              {
                const batch       = firestore.batch();
                const collection  = firestore.collection(fsCollectionName);
                let i = 0;
                results.forEach(
                  (row) =>
                  {
                    //console.log("ULQueteurStatsPerYear : inserting row for UL "+ul_id+" "+JSON.stringify(row));
                    const docRef = collection.doc();
                    //otherwise we get this error from firestore : Firestore doesn’t support JavaScript objects with custom prototypes (i.e. objects that were created via the “new” operator)
                    batch.set(docRef, JSON.parse(JSON.stringify(row)));
                  });

                return batch.commit().then(() => {

                  let logMessage = "ULQueteurStatsPerYear for UL='"+parsedObject.name+"'("+ul_id+") : "+i+" rows inserted";

                  console.log(logMessage);
                  resolve(logMessage);
                });
              }
            }
          });
      });

    });
};

Answer 1

The issue in my code was

if(results !== undefined && Array.isArray(results) && results.length >= 1)

on the 'else' part of this condition, I wasn't calling either 'resolve' or 'reject' functions from the promise.

Which explains why it ended in timeout.

(and the fact the query returned no row, was because I used a named parameter while mysql only support '?').

I'm not sure if it helped, but I've also change the way I return a promise.

I've switch to :

 return new Promise((resolve, reject) => {

    deleteCollection(fsCollectionName).then(
      ()=>
      {
        console.log("running query for UL : "+ul_id);
        mysqlPool.query(
          queryStr,