pg-boss 9.0.3 → 10.0.0-beta10

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,177 +17,131 @@ 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.getMaintenanceTimeCommand = plans.getMaintenanceTime(config.schema)
-    this.setMaintenanceTimeCommand = plans.setMaintenanceTime(config.schema)
+    this.dropCommand = plans.locked(config.schema, plans.drop(config.schema, config.deleteAfter))
+    this.trySetMaintenanceTimeCommand = plans.trySetMaintenanceTime(config.schema)
+    this.trySetMonitorTimeCommand = plans.trySetMonitorTime(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()
-
-    await this.manager.deleteQueue(COMPLETION_JOB_PREFIX + queues.MAINTENANCE)
-    await this.manager.deleteQueue(queues.MAINTENANCE)
-
-    await this.maintenanceAsync()
-
-    const maintenanceWorkOptions = {
-      newJobCheckIntervalSeconds: Math.max(1, this.maintenanceIntervalSeconds / 2)
-    }
+    this.maintenanceInterval = setInterval(() => this.onSupervise(), this.maintenanceIntervalSeconds * 1000)
+  }
 
-    await this.manager.work(queues.MAINTENANCE, maintenanceWorkOptions, (job) => this.onMaintenance(job))
+  async monitor () {
+    this.monitorInterval = setInterval(() => this.onMonitor(), this.monitorStateIntervalSeconds * 1000)
+  }
 
-    if (this.monitorStates) {
-      await this.manager.deleteQueue(COMPLETION_JOB_PREFIX + queues.MONITOR_STATES)
-      await this.manager.deleteQueue(queues.MONITOR_STATES)
+  async onMonitor () {
+    try {
+      if (this.monitoring) {
+        return
+      }
 
-      await this.monitorStatesAsync()
+      this.monitoring = true
 
-      const monitorStatesWorkOptions = {
-        newJobCheckIntervalSeconds: Math.max(1, this.monitorIntervalSeconds / 2)
+      if (this.config.__test__delay_monitor) {
+        await delay(this.config.__test__delay_monitor)
       }
 
-      await this.manager.work(queues.MONITOR_STATES, monitorStatesWorkOptions, (job) => this.onMonitorStates(job))
-    }
-  }
+      if (this.config.__test__throw_monitor) {
+        throw new Error(this.config.__test__throw_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)
+      if (this.stopped) {
+        return
       }
-    }, this.maintenanceIntervalSeconds * 2 * 1000)
-  }
 
-  async maintenanceAsync (options = {}) {
-    const { startAfter } = options
+      const { rows } = await this.db.executeSql(this.trySetMonitorTimeCommand, [this.config.monitorStateIntervalSeconds])
 
-    options = {
-      startAfter,
-      retentionSeconds: this.maintenanceIntervalSeconds * 4,
-      singletonKey: queues.MAINTENANCE,
-      onComplete: false
+      if (rows.length === 1 && !this.stopped) {
+        const states = await this.countStates()
+        this.emit(events.monitorStates, states)
+      }
+    } catch (err) {
+      this.emit(events.error, err)
+    } finally {
+      this.monitoring = false
     }
-
-    await this.manager.send(queues.MAINTENANCE, null, options)
   }
 
-  async monitorStatesAsync (options = {}) {
-    const { startAfter } = options
+  async onSupervise () {
+    try {
+      if (this.maintaining) {
+        return
+      }
 
-    options = {
-      startAfter,
-      retentionSeconds: this.monitorIntervalSeconds * 4,
-      singletonKey: queues.MONITOR_STATES,
-      onComplete: false
-    }
+      this.maintaining = true
 
-    await this.manager.send(queues.MONITOR_STATES, null, options)
-  }
+      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()
-
-      await this.setMaintenanceTime()
+      if (this.stopped) {
+        return
+      }
 
-      this.emit('maintenance', { ms: ended - started })
+      const { rows } = await this.db.executeSql(this.trySetMaintenanceTimeCommand, [this.config.maintenanceIntervalSeconds])
 
-      if (!this.stopped) {
-        await this.manager.complete(job.id) // pre-complete to bypass throttling
-        await this.maintenanceAsync({ startAfter: this.maintenanceIntervalSeconds })
+      if (rows.length === 1 && !this.stopped) {
+        const result = await this.maintain()
+        this.emit(events.maintenance, result)
       }
     } catch (err) {
       this.emit(events.error, err)
+    } finally {
+      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)
-    }
+    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
     }
   }
 
   async countStates () {
-    const stateCountDefault = { ...plans.states }
+    const stateCountDefault = { ...plans.JOB_STATES }
 
-    Object.keys(stateCountDefault)
-      .forEach(key => { stateCountDefault[key] = 0 })
+    for (const key of Object.keys(stateCountDefault)) {
+      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 +161,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

@@ -21,32 +21,53 @@ class Contractor {
     this.config = config
     this.db = db
     this.migrations = this.config.migrations || migrationStore.getAll(this.config.schema)
+
+    // exported api to index
+    this.functions = [
+      this.schemaVersion,
+      this.isInstalled
+    ]
   }
 
-  async version () {
+  async schemaVersion () {
     const result = await this.db.executeSql(plans.getVersion(this.config.schema))
     return result.rows.length ? parseInt(result.rows[0].version) : null
   }
 
   async isInstalled () {
     const result = await this.db.executeSql(plans.versionTableExists(this.config.schema))
-    return result.rows.length ? result.rows[0].name : null
+    return !!result.rows[0].name
   }
 
   async start () {
     const installed = await this.isInstalled()
 
     if (installed) {
-      const version = await this.version()
+      const version = await this.schemaVersion()
 
       if (schemaVersion > version) {
-        await this.migrate(version)
+        throw new Error('Migrations are not supported to v10')
+        // await this.migrate(version)
       }
     } else {
       await this.create()
     }
   }
 
+  async check () {
+    const installed = await this.isInstalled()
+
+    if (!installed) {
+      throw new Error('pg-boss is not installed')
+    }
+
+    const version = await this.schemaVersion()
+
+    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

@@ -10,6 +10,10 @@ class Db extends EventEmitter {
     this.config = config
   }
 
+  events = {
+    error: 'error'
+  }
+
   async open () {
     this.pool = new pg.Pool(this.config)
     this.pool.on('error', error => this.emit('error', error))
@@ -25,16 +29,18 @@ class Db extends EventEmitter {
 
   async executeSql (text, values) {
     if (this.opened) {
-      return await this.pool.query(text, values)
-    }
-  }
+      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)
+        }
+      }
 
-  static quotePostgresStr (str) {
-    const delimeter = '$sanitize$'
-    if (str.includes(delimeter)) {
-      throw new Error(`Attempted to quote string that contains reserved Postgres delimeter: ${str}`)
+      return await this.pool.query(text, values)
     }
-    return `${delimeter}${str}${delimeter}`
   }
 }