如何通过 API 调用停止递归 setTimeout？

Question

I have a NextJS application that runs a recursive setTimeout when the server is started. I need to create an API endpoint that can start and stop this loop (to have more control over it in production). This loop is used to process items in a database that are added from another API endpoint.

  import { clearTimeout } from "timers";

  var loopFlag = true;

  export function loopFlagSwitch(flag: boolean) {
    loopFlag = flag;
  }

  export async function loop() {
    
    try {
      // Retrieve all unprocessed transactions
      const unprocessedTransactions = await prisma.transaction.findMany({
        take: 100,
        where: { status: "UNPROCESSED" },
      });

      // Loop through transactions and do stuff
      for (const transaction of unprocessedTransactions) {
        //stuff
      }
    } catch (e) {
      // handle error
    }

    if (loopFlag === true) { 
      setTimeout(loop, 1000);  //if flag changes, this will stop running
    }
  }

  if (require.main === module) {
    loop(); // This is called when server starts, but not when file is imported
  }

The reason I use setTimeout and not setInterval is because many errors can occur when processing items retrieved from DB. These errors, however, are solved by waiting a few milliseconds. So, the benefit of the pattern below is that if an error happens, the loop immediately restarts and the error will not appear because a ms has passed (it's due to concurrency problems -- let's ignore this for now).

To attempt to start and stop this loop, I have an endpoint that simply calls the loopFlagSwitch function.

import { NextApiRequest, NextApiResponse } from "next";
import { loopFlagSwitch } from "services/loop";

async function handler(req: NextApiRequest, res: NextApiResponse) {
  try {
    loopFlagSwitch(req.body.flag);
  } catch (error) {
    logger.info({ error: error });
  }
}

export default handler;

Problem is, even when this endpoint is called, the setTimeout loop keeps going. Why isn't it picking the change in flag?

Answer 1

clearTimeout()

The global clearTimeout() method cancels a timeout previously established by calling setTimeout().

To clear a timeout, use the id returned from setTimeout():

Usage

const myTimeout = setTimeout(function, milliseconds);
//Then you can to stop the execution by calling clearTimeout():

clearTimeout(myTimeout);

loopFlag as a condition

...
if (loopFlag === true) { 
    myTimeout();
} else {
    clearTimeout(myTimeout)
}
...

Add abortTimer function

Full code

export function loopFlagSwitch(flag) {
  flag === true ? loop : abortTimer()
}

// set timeout
var myTimeout = setTimeout(loop, 1000);


function abortTimer() { // to be called when you want to stop the timer
  clearTimeout(myTimeout);
}

export async function loop() {
    try {
      // Retrieve all unprocessed transactions
      let d = "Retrieve all unprocessed transactions"
      process.stdout.write(d + '\n');

      // Loop through transactions and do stuff
      for (let i = 0; i<10;  i++) {
        //stuff
        let c = "second loop"
        process.stdout.write(c + '\n');
      }
    } catch (e) {
      // handle error
      console.log("error ", e)
    }  finally {
      myTimeout = setTimeout(loop, 1000); // repeat myself 
    }
    
  }

  if (require.main === module) {
    loop(); // This is called when server starts, but not when file is imported
  }

Answer 2

The flag will not work because node doesn't maintain the state of a file, the import only cares about the things it obtains from a file, it doesn't mind about the state of the variables declared in it.

Even though the clearTimeout() function may be sufficient, i think there is an even better option you can use to stop this loop.

Use a JS Class!

Instead of using just a function without state. You could instantiate a class that runs on the server with an internal boolean that can be called "shouldKeepLooping" for example:

class NextJsLooper { // or whatever better name you can use

  private shouldKeepLooping: boolean

  constructor () {
    this.shouldKeepLooping = true
  }
  
  public shouldKeepLooping(value) { this.shouldKeepLooping = value }

  public async loop () {
    if (shouldKeepLooping) {
      //... rest of the loop code
      setTimeout(this.loop, 1000);
    }
  }
}

This way if you set the value to false it will automatically stop. Since this is a reference to the object.

Keep in mind that you would need to keep this instance alive as probably something global, and would need it to be accesible by nextJS.

You can use Symbol.for and the Node global to mantain the instance saved somewhere in the server!

Answer 3

What you've tried would work inside a regular web page, because the loopFlag variable would be in global (window) scope.

Next.js does not share global scope in the same manner. Therefore, you need to use a React Context in order to share access to the variable.

Answer 4

My suggestion is to introduce the use of signals.

Service like Pusher will trigger the event that will be listened by the transaction processor.

your transaction processing api / code above or any other

Signal actions like "start" and "stop" will be triggered anytime even in production by either frontend or through the pusher portal that will be used to change the loop flag to either true or false.

Answer 5

you can retrieve the thread in charge of the operation and interrupt after a given expected time,and log something to inform you about the time out in case that your operation took more than the necessary time.