pg-boss 9.0.2 → 10.0.0-beta1

package/src/boss.js

@@ -1,12 +1,6 @@
 const EventEmitter = require('events')
 const plans = require('./plans')
-const { states } = require('./plans')
-const { COMPLETION_JOB_PREFIX } = plans
-
-const queues = {
-  MAINTENANCE: '__pgboss__maintenance',
-  MONITOR_STATES: '__pgboss__monitor-states'
-}
+const { delay } = require('./tools')
 
 const events = {
   error: 'error',
@@ -23,165 +17,135 @@ class Boss extends EventEmitter {
     this.manager = config.manager
 
     this.maintenanceIntervalSeconds = config.maintenanceIntervalSeconds
-
-    this.monitorStates = config.monitorStateIntervalSeconds !== null
-
-    if (this.monitorStates) {
-      this.monitorIntervalSeconds = config.monitorStateIntervalSeconds
-    }
+    this.monitorStateIntervalSeconds = config.monitorStateIntervalSeconds
 
     this.events = events
 
-    this.expireCommand = plans.locked(config.schema, plans.expire(config.schema))
+    this.failJobsByTimeoutCommand = plans.locked(config.schema, plans.failJobsByTimeout(config.schema))
     this.archiveCommand = plans.locked(config.schema, plans.archive(config.schema, config.archiveInterval, config.archiveFailedInterval))
-    this.purgeCommand = plans.locked(config.schema, plans.purge(config.schema, config.deleteAfter))
+    this.dropCommand = plans.locked(config.schema, plans.drop(config.schema, config.deleteAfter))
     this.getMaintenanceTimeCommand = plans.getMaintenanceTime(config.schema)
     this.setMaintenanceTimeCommand = plans.setMaintenanceTime(config.schema)
+    this.getMonitorTimeCommand = plans.getMonitorTime(config.schema)
+    this.setMonitorTimeCommand = plans.setMonitorTime(config.schema)
     this.countStatesCommand = plans.countStates(config.schema)
 
     this.functions = [
       this.expire,
       this.archive,
-      this.purge,
+      this.drop,
       this.countStates,
-      this.getQueueNames
+      this.maintain
     ]
   }
 
   async supervise () {
-    this.metaMonitor()
+    this.maintenanceInterval = setInterval(() => this.onSupervise(), this.maintenanceIntervalSeconds * 1000)
+  }
 
-    await this.manager.deleteQueue(COMPLETION_JOB_PREFIX + queues.MAINTENANCE)
-    await this.manager.deleteQueue(queues.MAINTENANCE)
+  async monitor () {
+    this.monitorInterval = setInterval(() => this.onMonitor(), this.monitorStateIntervalSeconds * 1000)
+  }
 
-    await this.maintenanceAsync()
+  async onMonitor () {
+    let locker
 
-    const maintenanceWorkOptions = {
-      newJobCheckIntervalSeconds: Math.max(1, this.maintenanceIntervalSeconds / 2)
-    }
-
-    await this.manager.work(queues.MAINTENANCE, maintenanceWorkOptions, (job) => this.onMaintenance(job))
+    try {
+      if (this.monitoring) {
+        return
+      }
 
-    if (this.monitorStates) {
-      await this.manager.deleteQueue(COMPLETION_JOB_PREFIX + queues.MONITOR_STATES)
-      await this.manager.deleteQueue(queues.MONITOR_STATES)
+      this.monitoring = true
 
-      await this.monitorStatesAsync()
+      if (this.config.__test__delay_monitor) {
+        await delay(this.config.__test__delay_monitor)
+      }
 
-      const monitorStatesWorkOptions = {
-        newJobCheckIntervalSeconds: Math.max(1, this.monitorIntervalSeconds / 2)
+      if (this.config.__test__throw_monitor) {
+        throw new Error(this.config.__test__throw_monitor)
       }
 
-      await this.manager.work(queues.MONITOR_STATES, monitorStatesWorkOptions, (job) => this.onMonitorStates(job))
-    }
-  }
+      locker = await this.db.lock({ key: 'monitor' })
 
-  metaMonitor () {
-    this.metaMonitorInterval = setInterval(async () => {
-      try {
-        if (this.config.__test__throw_meta_monitor) {
-          throw new Error(this.config.__test__throw_meta_monitor)
-        }
-
-        const { secondsAgo } = await this.getMaintenanceTime()
-
-        if (secondsAgo > this.maintenanceIntervalSeconds * 2) {
-          await this.manager.deleteQueue(queues.MAINTENANCE, { before: states.completed })
-          await this.maintenanceAsync()
-        }
-      } catch (err) {
-        this.emit(events.error, err)
-      }
-    }, this.maintenanceIntervalSeconds * 2 * 1000)
-  }
+      const { secondsAgo } = await this.getMonitorTime()
 
-  async maintenanceAsync (options = {}) {
-    const { startAfter } = options
+      if (secondsAgo > this.monitorStateIntervalSeconds && !this.stopped) {
+        const states = await this.countStates()
+        this.setMonitorTime()
+        this.emit(events.monitorStates, states)
+      }
+    } catch (err) {
+      this.emit(events.error, err)
+    } finally {
+      if (locker?.locked) {
+        await locker.unlock()
+      }
 
-    options = {
-      startAfter,
-      retentionSeconds: this.maintenanceIntervalSeconds * 4,
-      singletonKey: queues.MAINTENANCE,
-      onComplete: false
+      this.monitoring = false
     }
-
-    await this.manager.send(queues.MAINTENANCE, null, options)
   }
 
-  async monitorStatesAsync (options = {}) {
-    const { startAfter } = options
+  async onSupervise () {
+    let locker
 
-    options = {
-      startAfter,
-      retentionSeconds: this.monitorIntervalSeconds * 4,
-      singletonKey: queues.MONITOR_STATES,
-      onComplete: false
-    }
+    try {
+      if (this.maintaining) {
+        return
+      }
 
-    await this.manager.send(queues.MONITOR_STATES, null, options)
-  }
+      this.maintaining = true
+
+      if (this.config.__test__delay_maintenance && !this.stopped) {
+        this.__testDelayPromise = delay(this.config.__test__delay_maintenance)
+        await this.__testDelayPromise
+      }
 
-  async onMaintenance (job) {
-    try {
       if (this.config.__test__throw_maint) {
         throw new Error(this.config.__test__throw_maint)
       }
 
-      const started = Date.now()
-
-      await this.expire()
-      await this.archive()
-      await this.purge()
-
-      const ended = Date.now()
+      if (this.stopped) {
+        return
+      }
 
-      await this.setMaintenanceTime()
+      locker = await this.db.lock({ key: 'maintenance' })
 
-      this.emit('maintenance', { ms: ended - started })
+      const { secondsAgo } = await this.getMaintenanceTime()
 
-      if (!this.stopped) {
-        await this.manager.complete(job.id) // pre-complete to bypass throttling
-        await this.maintenanceAsync({ startAfter: this.maintenanceIntervalSeconds })
+      if (secondsAgo > this.maintenanceIntervalSeconds) {
+        const result = await this.maintain()
+        this.emit(events.maintenance, result)
       }
     } catch (err) {
       this.emit(events.error, err)
+    } finally {
+      if (locker?.locked) {
+        await locker.unlock()
+      }
+
+      this.maintaining = false
     }
   }
 
-  async onMonitorStates (job) {
-    try {
-      if (this.config.__test__throw_monitor) {
-        throw new Error(this.config.__test__throw_monitor)
-      }
+  async maintain () {
+    const started = Date.now()
 
-      const states = await this.countStates()
+    !this.stopped && await this.expire()
+    !this.stopped && await this.archive()
+    !this.stopped && await this.drop()
 
-      this.emit(events.monitorStates, states)
+    const ended = Date.now()
 
-      if (!this.stopped && this.monitorStates) {
-        await this.manager.complete(job.id) // pre-complete to bypass throttling
-        await this.monitorStatesAsync({ startAfter: this.monitorIntervalSeconds })
-      }
-    } catch (err) {
-      this.emit(events.error, err)
-    }
+    await this.setMaintenanceTime()
+
+    return { ms: ended - started }
   }
 
   async stop () {
-    if (this.config.__test__throw_stop) {
-      throw new Error(this.config.__test__throw_stop)
-    }
-
     if (!this.stopped) {
-      if (this.metaMonitorInterval) {
-        clearInterval(this.metaMonitorInterval)
-      }
-
-      await this.manager.offWork(queues.MAINTENANCE)
-
-      if (this.monitorStates) {
-        await this.manager.offWork(queues.MONITOR_STATES)
-      }
+      if (this.__testDelayPromise) this.__testDelayPromise.abort()
+      if (this.maintenanceInterval) clearInterval(this.maintenanceInterval)
+      if (this.monitorInterval) clearInterval(this.monitorInterval)
 
       this.stopped = true
     }
@@ -193,7 +157,7 @@ class Boss extends EventEmitter {
     Object.keys(stateCountDefault)
       .forEach(key => { stateCountDefault[key] = 0 })
 
-    const counts = await this.executeSql(this.countStatesCommand)
+    const counts = await this.db.executeSql(this.countStatesCommand)
 
     const states = counts.rows.reduce((acc, item) => {
       if (item.name) {
@@ -213,43 +177,44 @@ class Boss extends EventEmitter {
   }
 
   async expire () {
-    await this.executeSql(this.expireCommand)
+    await this.db.executeSql(this.failJobsByTimeoutCommand)
   }
 
   async archive () {
-    await this.executeSql(this.archiveCommand)
+    await this.db.executeSql(this.archiveCommand)
   }
 
-  async purge () {
-    await this.executeSql(this.purgeCommand)
+  async drop () {
+    await this.db.executeSql(this.dropCommand)
   }
 
   async setMaintenanceTime () {
-    await this.executeSql(this.setMaintenanceTimeCommand)
+    await this.db.executeSql(this.setMaintenanceTimeCommand)
   }
 
   async getMaintenanceTime () {
-    if (!this.stopped) {
-      const { rows } = await this.db.executeSql(this.getMaintenanceTimeCommand)
+    const { rows } = await this.db.executeSql(this.getMaintenanceTimeCommand)
 
-      let { maintained_on: maintainedOn, seconds_ago: secondsAgo } = rows[0]
+    let { maintained_on: maintainedOn, seconds_ago: secondsAgo } = rows[0]
 
-      secondsAgo = secondsAgo !== null ? parseFloat(secondsAgo) : this.maintenanceIntervalSeconds * 10
+    secondsAgo = secondsAgo !== null ? parseFloat(secondsAgo) : 999_999_999
 
-      return { maintainedOn, secondsAgo }
-    }
+    return { maintainedOn, secondsAgo }
   }
 
-  getQueueNames () {
-    return queues
+  async setMonitorTime () {
+    await this.db.executeSql(this.setMonitorTimeCommand)
   }
 
-  async executeSql (sql, params) {
-    if (!this.stopped) {
-      return await this.db.executeSql(sql, params)
-    }
+  async getMonitorTime () {
+    const { rows } = await this.db.executeSql(this.getMonitorTimeCommand)
+
+    let { monitored_on: monitoredOn, seconds_ago: secondsAgo } = rows[0]
+
+    secondsAgo = secondsAgo !== null ? parseFloat(secondsAgo) : 999_999_999
+
+    return { monitoredOn, secondsAgo }
   }
 }
 
 module.exports = Boss
-module.exports.QUEUES = queues

package/src/contractor.js

@@ -47,6 +47,20 @@ class Contractor {
     }
   }
 
+  async check () {
+    const installed = await this.isInstalled()
+
+    if (!installed) {
+      throw new Error('pg-boss is not installed')
+    }
+
+    const version = await this.version()
+
+    if (schemaVersion !== version) {
+      throw new Error('pg-boss database requires migrations')
+    }
+  }
+
   async create () {
     try {
       const commands = plans.create(this.config.schema, schemaVersion)

package/src/db.js

@@ -1,5 +1,6 @@
 const EventEmitter = require('events')
 const pg = require('pg')
+const { advisoryLock } = require('./plans')
 
 class Db extends EventEmitter {
   constructor (config) {
@@ -25,10 +26,49 @@ class Db extends EventEmitter {
 
   async executeSql (text, values) {
     if (this.opened) {
+      // if (this.config.debug === true) {
+      //   console.log(`${new Date().toISOString()}: DEBUG SQL`)
+      //   console.log(text)
+
+      //   if (values) {
+      //     console.log(`${new Date().toISOString()}: DEBUG VALUES`)
+      //     console.log(values)
+      //   }
+      // }
+
       return await this.pool.query(text, values)
     }
   }
 
+  async lock ({ timeout = 30, key } = {}) {
+    // const lockedClient = new pg.Client(this.config)
+    // await lockedClient.connect()
+    const lockedClient = await this.pool.connect()
+
+    const query = `
+        BEGIN;
+        SET LOCAL lock_timeout = '${timeout}s';
+        SET LOCAL idle_in_transaction_session_timeout = '3600s';
+        ${advisoryLock(this.config.schema, key)};
+    `
+
+    await lockedClient.query(query)
+
+    const locker = {
+      locked: true,
+      unlock: async function () {
+        try {
+          await lockedClient.query('COMMIT')
+          await lockedClient.end()
+        } finally {
+          this.locked = false
+        }
+      }
+    }
+
+    return locker
+  }
+
   static quotePostgresStr (str) {
     const delimeter = '$sanitize$'
     if (str.includes(delimeter)) {

package/src/index.js

@@ -6,7 +6,7 @@ const Manager = require('./manager')
 const Timekeeper = require('./timekeeper')
 const Boss = require('./boss')
 const Db = require('./db')
-const delay = require('delay')
+const { delay } = require('./tools')
 
 const events = {
   error: 'error',
@@ -72,16 +72,7 @@ class PgBoss extends EventEmitter {
     }
 
     function promoteFunction (obj, func) {
-      this[func.name] = (...args) => {
-        const shouldRun = !this.started || !((func.name === 'work' || func.name === 'onComplete') && (this.stopped || this.stoppingOn))
-
-        if (shouldRun) {
-          return func.apply(obj, args)
-        } else {
-          const state = this.stoppingOn ? 'stopping' : this.stopped ? 'stopped' : !this.started ? 'not started' : 'started'
-          return Promise.reject(new Error(`pg-boss is ${state}.`))
-        }
-      }
+      this[func.name] = (...args) => func.apply(obj, args)
     }
 
     function promoteEvent (emitter, event) {
@@ -90,42 +81,49 @@ class PgBoss extends EventEmitter {
   }
 
   async start () {
-    if (!this.stopped) {
-      return this
+    if (this.starting || this.started) {
+      return
     }
 
+    this.starting = true
+
     if (this.db.isOurs && !this.db.opened) {
       await this.db.open()
     }
 
-    await this.contractor.start()
-
-    this.stopped = false
-    this.started = true
+    if (this.config.migrate) {
+      await this.contractor.start()
+    } else {
+      await this.contractor.check()
+    }
 
     this.manager.start()
 
-    if (!this.config.noSupervisor) {
+    if (this.config.supervise) {
       await this.boss.supervise()
     }
 
-    if (!this.config.noScheduling) {
+    if (this.config.monitorStateIntervalSeconds) {
+      await this.boss.monitor()
+    }
+
+    if (this.config.schedule) {
       await this.timekeeper.start()
     }
 
+    this.starting = false
+    this.started = true
+    this.stopped = false
+
     return this
   }
 
   async stop (options = {}) {
-    if (this.stoppingOn) {
+    if (this.stoppingOn || this.stopped) {
       return
     }
 
-    if (this.stopped) {
-      this.emit(events.stopped)
-    }
-
-    let { destroy = false, graceful = true, timeout = 30000 } = options
+    let { destroy = false, graceful = true, timeout = 30000, wait = true } = options
 
     timeout = Math.max(timeout, 1000)
 
@@ -133,47 +131,59 @@ class PgBoss extends EventEmitter {
 
     await this.manager.stop()
     await this.timekeeper.stop()
+    await this.boss.stop()
 
-    const shutdown = async () => {
-      this.stopped = true
-      this.stoppingOn = null
+    await new Promise((resolve, reject) => {
+      const shutdown = async () => {
+        try {
+          if (this.config.__test__throw_shutdown) {
+            throw new Error(this.config.__test__throw_shutdown)
+          }
 
-      if (this.db.isOurs && this.db.opened && destroy) {
-        await this.db.close()
-      }
+          await this.manager.failWip()
 
-      this.emit(events.stopped)
-    }
+          if (this.db.isOurs && this.db.opened && destroy) {
+            await this.db.close()
+          }
 
-    if (!graceful) {
-      await this.boss.stop()
-      await shutdown()
-      return
-    }
+          this.stopped = true
+          this.stoppingOn = null
+          this.started = false
 
-    setImmediate(async () => {
-      let closing = false
+          this.emit(events.stopped)
+          resolve()
+        } catch (err) {
+          this.emit(events.error, err)
+          reject(err)
+        }
+      }
 
-      try {
-        while (Date.now() - this.stoppingOn < timeout) {
-          if (this.manager.getWipData({ includeInternal: closing }).length === 0) {
-            if (closing) {
-              break
-            }
+      if (!graceful) {
+        return shutdown()
+      }
 
-            closing = true
+      if (!wait) {
+        resolve()
+      }
 
-            await this.boss.stop()
+      setImmediate(async () => {
+        try {
+          if (this.config.__test__throw_stop_monitor) {
+            throw new Error(this.config.__test__throw_stop_monitor)
           }
 
-          await delay(1000)
-        }
+          const isWip = () => this.manager.getWipData({ includeInternal: false }).length > 0
 
-        await this.boss.stop()
-        await shutdown()
-      } catch (err) {
-        this.emit(events.error, err)
-      }
+          while ((Date.now() - this.stoppingOn) < timeout && isWip()) {
+            await delay(500)
+          }
+
+          await shutdown()
+        } catch (err) {
+          reject(err)
+          this.emit(events.error, err)
+        }
+      })
     })
   }
 }