Як я можу переконатися, що робота не працює двічі в Bull?

Я маю дві функції, scheduleScan() і scan().

scan()дзвінки, scheduleScan() коли немає нічого іншого, крім планування нового сканування , такscheduleScan() можна запланувати а scan(). Але є проблема, деякі роботи виконуються двічі.

Я хочу переконатися, що в будь-який час обробляється лише одна робота. Як я можу цього досягти? Я вірю, що це має щось спільнеdone() (він був у скануванні (), видалено зараз), але я не зміг знайти рішення.

Версія бика: 3.12.1

Важливе запізніле редагування: scan() викликає інші функції, вони можуть або не можуть викликати інші функції, але всі вони функції синхронізації, тому вони викликають функцію лише тоді, коли власні завдання виконані, є лише один шлях вперед. Наприкінці "дерева" я його називаю, остання функція викликає rasporedScan (), але не може бути виконано два одночасні завдання. Кожна робота починається scan(), до речі, і закінчуєтьсяscheduleScan(stock, period, milliseconds, 'called by file.js')

export function update(job) {
  // does some calculations, then it may call scheduleScan() or
  // it may call another function, and that could be the one calling
  // scheduleScan() function.
  // For instance, a function like finalize()
}

export function scan(job) {
  update(job)
}


import moment from 'moment'
import stringHash from 'string-hash'
const opts = { redis: { port: 6379, host: '127.0.0.1', password: mypassword' } }
let queue = new Queue('scan', opts)

queue.process(1, (job) => {
  job.progress(100).then(() => {
    scan(job)
  })
})

export function scheduleScan (stock, period, milliseconds, triggeredBy) {
  let uniqueId = stringHash(stock + ':' + period)

  queue.getJob(uniqueId).then(job => {
    if (!job) {
      if (milliseconds) {
        queue.add({ stock, period, triggeredBy }, { delay: milliseconds, jobId: uniqueId }).then(() => {
          // console.log('Added with ms: ' + stock + ' ' + period)
        }).catch(err => {
          if (err) {
            console.log('Can not add because it exists ' + new Date())
          }
        })
      } else {
        queue.add({ stock, period, triggeredBy }, { jobId: uniqueId }).then(() => {
          // console.log('Added without ms: ' + stock + ' ' + period)
        }).catch(err => {
          if (err) {
            console.log('Can not add because it exists ' + new Date())
          }
        })
      }
    } else {
      job.getState().then(state => {
        if (state === 'completed') {
          job.remove().then(() => {
            if (milliseconds) {
              queue.add({ stock, period, triggeredBy }, { delay: milliseconds, jobId: uniqueId }).then(() => {
                // console.log('Added with ms: ' + stock + ' ' + period)
              }).catch(err => {
                if (err) {
                  console.log('Can not add because it exists ' + new Date())
                }
              })
            } else {
              queue.add({ stock, period, triggeredBy }, { jobId: uniqueId }).then(() => {
                // console.log('Added without ms: ' + stock + ' ' + period)
              }).catch(err => {
                if (err) {
                  console.log('Can not add because it exists ' + new Date())
                }
              })
            }
          }).catch(err => {
            if (err) {
              // console.log(err)
            }
          })
        }
      }).catch(err => {
        // console.log(err)
      })
    }
  })
}

Я вважаю, що проблема scanполягає в асинхронізації. Тому ваша job.progressфункція дзвонить, scanа потім негайно дзвонитьdone дозволяючи черзі обробляти інше завдання.

Рішенням може бути передача doneзворотного дзвінка як параметр вашому scanтаscheduleScan функціям та виклик його, як тільки ви закінчите роботу (або помилка).

Іншим (кращим) рішенням може бути забезпечення того, що ви завжди повертаєтесь Promiseіз scanта scheduleScan, а потім чекаєте обіцянки вирішити, а потім зателефонувати done. Якщо ви робите це, переконайтеся, що ви ланцюжок усіх своїх обіцянок повертає у вашій scheduleScanфункції.

queue.process(1, (job, done) => {
  job.progress(100).then(() => {
    scan(job)
        .then(done)
        .catch(done)
  })
})

export function scan() {
   // business logic
   return scheduleScan()
}

// Chain all of your promise returns. Otherwise
// the scan function will return sooner and allow done to be called
// prior to the scheduleScan function finishing it's execution
export function scheduleScan() {
    return queue.getJob(..).then(() => {
        ....
        return queue.add()...
        ....
        return queue.add(...)
            .catch(e => {
                 console.log(e);
                 // propogate errors!
                 throw e;
             })

}

Функція сканування - це асинхронна функція. У своїй queue.process()функції ви повинні дочекатися функції сканування, а потім викликати done()зворотний дзвінок.

export async function scan(job) {
  // it does some calculations, then it creates a new schedule.
  return scheduleScan(stock, period, milliseconds, "scan.js");
}

queue.process(1, (job, done) => {
  job.progress(100).then(async() => {
    await scan(job);
    done();
  });
});

export async function scheduleScan(stock, period, milliseconds, triggeredBy) {
    let uniqueId = stringHash(stock + ":" + period);
    try {
      const existingJob = await queue.getJob(uniqueId);
      if (!existingJob) {
        const job = await addJob({
          queue,
          stock,
          period,
          uniqueId,
          milliseconds,
          triggeredBy
        });
        return job;
      } else {
        const jobState = await existingJob.getState();
        if (jobState === "completed") {
          await existingJob.remove();
          const newJob = await addJob({
            queue,
            stock,
            period,
            uniqueId,
            milliseconds,
            triggeredBy
          });
          return newJob;
        }
      }
    } catch (err) {
      throw new Error(err);
    }
}

export function addJob({ queue, stock, period, milliseconds, triggeredBy }) {
  if (milliseconds) {
    return queue.add(
      { stock, period, triggeredBy },
      { delay: milliseconds, jobId: uniqueId }
    );
  } else {
    return queue.add({ stock, period, triggeredBy }, { jobId: uniqueId });
  }
}

Спробуйте це! Я спробував трохи переробити код за допомогою функції async-await.