es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Resolviendo una promesa cuando se desea.

02 Aug, 2023 Programación

Quiero sincronizar constantemente datos de un sitio web, sin embargo solo tengo 300 llamadas/15 minutos. Por lo tanto, pensé que podría poner todas mis solicitudes de sincronización (alrededor de 1000) en un arreglo y luego resolver solo 300 de ellas cada 15 minutos hasta que el arreglo de solicitudes esté vacío y luego comenzar de nuevo. Sin embargo, cuando hago lo siguiente:

  let requests = []
  params = 'invoice-items?invoice_id='
  let positions = null
  for (const invoice of invoices) {
    requests.push(new Promise(async (resolve, reject) => {
      positions = await getBillomatData(params + invoice.id, null, 0, null)
      await updateDatabase(positions, models.billomat.Position)
    }))
  }

  console.log(requests[0])
  await requests[0]
  console.log(requests[0])

Tan pronto como espero la solicitud en requests[0], ejecuta todas las solicitudes y supero el límite de llamadas.

Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Parece que el problema radica en el hecho de que estás utilizando await en un array de promesas (requests[0]), lo que hace que todas las promesas en el array se resuelvan al mismo tiempo. En cambio, deberías resolver solo las primeras 300 promesas del array a la vez, y luego esperar 15 minutos antes de resolver el siguiente lote de promesas.

    Una forma de lograr esto es utilizar un bucle que verifique la longitud del array requests, resuelva las primeras 300 promesas y luego espere durante 15 minutos antes de pasar al siguiente lote. Así es como puedes modificar tu código para implementar esto:

    let requests = []
params = 'invoice-items?invoice_id='
let positions = null
for (const invoice of invoices) {
  requests.push(new Promise(async (resolve, reject) => {
    positions = await getBillomatData(params + invoice.id, null, 0, null)
    await updateDatabase(positions, models.billomat.Position)
  }))
}

while (requests.length) {
  const batch = requests.splice(0, 300)
  await Promise.all(batch)
  await new Promise(resolve => setTimeout(resolve, 900000)) // 15 minutos
}

    En este código actualizado, primero creamos un array vacío requests y lo llenamos con promesas que obtienen y actualizan datos. Luego, utilizamos un bucle while que se ejecuta hasta que el array requests esté vacío. En cada iteración del bucle, dividimos las primeras 300 promesas del array en un nuevo array batch, utilizamos Promise.all para resolver todas las promesas del lote, y luego utilizamos setTimeout para esperar durante 15 minutos. Finalmente, el bucle se repite con las promesas restantes en el array requests.

    Este código debería asegurarse de que te mantengas dentro del límite de llamadas y sincronices todos tus datos con el tiempo.

Comments are closed.