feat(config): run clean after import (#623)

src/index.js

@@ -567,9 +567,7 @@ export default async function main (args) {
   await xo.start()
 
   // Trigger a clean job.
-  debug('Cleaning: starting…')
   await xo.clean()
-  debug('Cleaning: finished')
 
   // Express is used to manage non WebSocket connections.
   const express = createExpressApp()

src/xo-mixins/config-management.js

@@ -6,7 +6,8 @@ import { mapValues } from 'lodash'
 const debug = createDebug('xo:config-management')
 
 export default class ConfigManagement {
-  constructor () {
+  constructor (app) {
+    this._app = app
     this._depTree = new DepTree()
     this._managers = { __proto__: null }
   }
@@ -36,5 +37,6 @@ export default class ConfigManagement {
         await manager.importer(data)
       }
     }
+    await this._app.clean()
   }
 }

src/xo-mixins/hooks.js

@@ -0,0 +1,76 @@
+import createLogger from 'debug'
+
+const debug = createLogger('xo:hooks')
+
+function emitAsync (event) {
+  let opts
+  let i = 1
+
+  // an option object has been passed as first param
+  if (typeof event !== 'string') {
+    opts = event
+    event = arguments[i++]
+  }
+
+  const n = arguments.length - i
+  const args = new Array(n)
+  for (let j = 0; j < n; ++j) {
+    args[j] = arguments[j + i]
+  }
+
+  const onError = opts != null && opts.onError
+
+  return Promise.all(this.listeners(event).map(
+    listener => new Promise(resolve => {
+      resolve(listener.apply(this, args))
+    }).catch(onError)
+  ))
+}
+
+const makeSingletonHook = (hook, postEvent) => {
+  let promise
+  return function () {
+    if (promise === undefined) {
+      promise = runHook(this, hook)
+      promise.then(() => {
+        this.removeAllListeners(hook)
+        this.emit(postEvent)
+        this.removeAllListeners(postEvent)
+      })
+    }
+    return promise
+  }
+}
+
+const runHook = (app, hook) => {
+  debug(`${hook} start…`)
+  const promise = emitAsync.call(app, {
+    onError: error => console.error(
+      `[WARN] hook ${hook} failure:`,
+      (error != null && error.stack) || error
+    )
+  }, hook)
+  promise.then(() => {
+    debug(`${hook} finished`)
+  })
+  return promise
+}
+
+export default {
+  // Run *clean* async listeners.
+  //
+  // They normalize existing data, clear invalid entries, etc.
+  clean () {
+    return runHook(this, 'clean')
+  },
+
+  // Run *start* async listeners.
+  //
+  // They initialize the application.
+  start: makeSingletonHook('start', 'started'),
+
+  // Run *stop* async listeners.
+  //
+  // They close connections, unmount file systems, save states, etc.
+  stop: makeSingletonHook('stop', 'stopped')
+}

src/xo.js

@@ -60,76 +60,6 @@ export default class Xo extends EventEmitter {
 
   // -----------------------------------------------------------------
 
-  async clean () {
-    const handleCleanError = error => {
-      console.error(
-        '[WARN] clean error:',
-        (error && error.stack) || error
-      )
-    }
-    await Promise.all(mapToArray(
-      this.listeners('clean'),
-
-      listener => new Promise(resolve => {
-        resolve(listener.call(this))
-      }).catch(handleCleanError)
-    ))
-  }
-
-  // -----------------------------------------------------------------
-
-  async start () {
-    this.start = noop
-
-    this._watchObjects()
-
-    // ---------------------------------------------------------------
-
-    const handleStartError = error => {
-      console.error(
-        '[WARN] start error:',
-        (error && error.stack) || error
-      )
-    }
-    await Promise.all(mapToArray(
-      this.listeners('start'),
-
-      listener => new Promise(resolve => {
-        resolve(listener.call(this))
-      }).catch(handleStartError)
-    ))
-    this.removeAllListeners('start')
-
-    this.emit('started')
-    this.removeAllListeners('started')
-  }
-
-  // -----------------------------------------------------------------
-
-  async stop () {
-    this.stop = noop
-
-    const handleStopError = error => {
-      console.error(
-        '[WARN] stop error:',
-        (error && error.stack) || error
-      )
-    }
-    await Promise.all(mapToArray(
-      this.listeners('stop'),
-
-      listener => new Promise(resolve => {
-        resolve(listener.call(this))
-      }).catch(handleStopError)
-    ))
-    this.removeAllListeners('stop')
-
-    this.emit('stopped')
-    this.removeAllListeners('stopped')
-  }
-
-  // -----------------------------------------------------------------
-
   // Returns an object from its key or UUID.
   getObject (key, type) {
     const {