db-migrate 1.0.0-beta.35 → 1.0.0-beta.36

package/lib/commands/set-default-argv.js

@@ -17,7 +17,9 @@ module.exports = function (internals, isModule) {
     'vcseeder-dir': internals.cwd + '/VCSeeder',
     'staticseeder-dir': internals.cwd + '/Seeder',
     'ignore-completed-migrations': false,
-    'backup-state': false
+    'backup-state': false,
+    'lock-timeout': 60000,
+    'lock-interval': 1000
   };
 
   if (!isModule) {
@@ -116,6 +118,17 @@ module.exports = function (internals, isModule) {
       .string('log-level')
       .describe('backup-state', 'For use with fix, to take a backup of the current state before continuing.')
       .boolean('backup-state')
+      .describe(
+        'lock-timeout',
+        'Milliseconds without any sign of life after which a migration lock' +
+          ' held by another process is considered stale and taken over.'
+      )
+      .number('lock-timeout')
+      .describe(
+        'lock-interval',
+        'Milliseconds between checks while waiting for the migration lock.'
+      )
+      .number('lock-interval')
       .parse();
   } else {
     internals.argv = Object.assign(defaultConfig, internals.cmdOptions);

package/lib/state.js

@@ -1,68 +1,284 @@
 const MSTATE = '__dbmigrate_state__';
 const SSTATE = '__dbmigrate_schema__';
-const RUNON = 'run_on';
 
 const log = require('db-migrate-shared').log;
 const fs = require('fs').promises;
 const path = require('path');
 const crypto = require('crypto');
+const { performance } = require('perf_hooks');
 
 const ID = crypto.randomBytes(32).toString('base64');
+
+const LOCK_TIMEOUT = 60000;
+const LOCK_INTERVAL = 1000;
+
+/**
+ * active: a lock session is running, from acquire until release, even if
+ *         the lock got lost in between
+ * owner: we currently hold the lock
+ * current: the last MSTATE row we wrote and verified, the expected
+ *          value for our next compare and swap
+ * queue: serializes our own writes, so heartbeat and state updates
+ *        never race each other on the same expected row
+ */
+let active = false;
 let owner = false;
+let current = null;
+let heartbeat = null;
+let queue = Promise.resolve();
+
+const nonce = () => crypto.randomBytes(8).toString('hex');
+
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const lockOptions = internals => {
+  const argv = internals.argv || {};
+  return {
+    timeout: Number(argv['lock-timeout']) || LOCK_TIMEOUT,
+    interval: Number(argv['lock-interval']) || LOCK_INTERVAL
+  };
+};
+
+const read = (driver, internals) =>
+  driver._getKV(internals.migrationState, MSTATE);
+
+const holder = row => JSON.parse(row.value).s.ID;
+
+const heldByOther = row => {
+  const id = holder(row);
+  return !!id && id !== ID;
+};
+
+/**
+ * Atomic update of the lock row. The where clause contains the value we
+ * have read before, which carries the date and a nonce renewed on every
+ * write. If anybody else wrote in between, the update matches no row.
+ * Whoever wins, sees his own value on re-read.
+ */
+const cas = (driver, internals, expected, value) =>
+  driver._updateKVC(
+    internals.migrationState,
+    MSTATE,
+    value,
+    'value',
+    expected.value
+  );
+
+/**
+ * Concurrent CREATE TABLE IF NOT EXISTS can still collide (e.g. on pg_type
+ * in postgres) when several processes start on an empty database. The
+ * second attempt finds the table and is a noop.
+ */
+const createConcurrently = async create => {
+  try {
+    await create();
+  } catch (err) {
+    log.verbose('[state] create failed, retrying once', err.message);
+    await create();
+  }
+};
+
+/**
+ * The stored schema starts as '{}', keep the structure the walker expects.
+ */
+const parseSchema = value =>
+  Object.assign({ i: {}, c: {}, f: {}, e: {} }, JSON.parse(value));
+
+const stopHeartbeat = () => {
+  if (heartbeat) {
+    clearInterval(heartbeat);
+    heartbeat = null;
+  }
+};
+
+const write = (driver, internals, mutate) => {
+  const run = queue.then(async () => {
+    if (!owner) {
+      throw new Error('[state] the migration lock is not held by this process');
+    }
+
+    const state = JSON.parse(current.value);
+    Object.assign(state.s, { ID, date: new Date(), n: nonce() });
+    mutate(state.s);
+
+    const value = JSON.stringify(state);
+    await cas(driver, internals, current, value);
+    const row = await read(driver, internals);
+
+    if (!row || row.value !== value) {
+      owner = false;
+      current = null;
+      stopHeartbeat();
+      throw new Error('[state] lost the migration lock to another process');
+    }
+
+    current = row;
+  });
+
+  queue = run.catch(() => {});
+  return run;
+};
+
+const claim = (row, driver, internals) => {
+  if (!row || holder(row) !== ID) {
+    return false;
+  }
+
+  active = true;
+  owner = true;
+  current = row;
+
+  const { timeout } = lockOptions(internals);
+  heartbeat = setInterval(() => {
+    write(driver, internals, () => {}).catch(err => log.error(err.message));
+  }, Math.max(Math.floor(timeout / 3), 1));
+  heartbeat.unref();
+
+  return true;
+};
 
 module.exports = {
+  createConcurrently,
+
+  // for tests, simulates a process which died while holding the lock
+  __stopHeartbeat: stopHeartbeat,
+
   /**
-   * Lock state will add the basic state controller an ID
-   * and a process controlled date.
-   * It is important that all systems are in sync. We will use the
-   * database clock instead if possible.
+   * Drivers declare that their state methods were verified for locking,
+   * with an atomic _updateKVC and run_on set by the database clock.
    */
-  lockState: async function (driver, state, internals) {
-    if (!state) {
-      owner = true;
-      return driver._insertKV(
-        internals.migrationState,
-        MSTATE,
-        JSON.stringify({
-          s: {
-            step: 0,
-            fin: 0,
-            ID,
-            date: new Date()
-          }
-        })
-      );
-    } else {
-      let runOn = state.run_on;
-      state = state.value;
-      state = JSON.parse(state);
+  supportsLock: function (driver) {
+    return !!(
+      driver &&
+      driver._meta &&
+      driver._meta.supports &&
+      driver._meta.supports.locking === true
+    );
+  },
 
-      if (!state.s.ID || state.s.ID !== ID) {
-        owner = true;
-        state.s.ID = ID;
+  /**
+   * Try to acquire the migration lock once. Resolves to true if this process
+   * is the owner afterwards. A lock held by another process is only taken
+   * over, if it is the exact row waitForRelease reported as stale.
+   */
+  acquire: async function (driver, internals, stale = null, retries = 3) {
+    if (owner) {
+      return true;
+    }
+
+    const row = await read(driver, internals);
+
+    if (!row) {
+      try {
+        await driver._insertKV(
+          internals.migrationState,
+          MSTATE,
+          JSON.stringify({
+            s: { step: 0, fin: 1, ID, date: new Date(), n: nonce() }
+          })
+        );
+      } catch (err) {
+        // somebody else inserted the row first, the re-read decides
+        log.verbose('[state] lock insert failed', err.message);
       }
 
-      const d = new Date();
+      return claim(await read(driver, internals), driver, internals);
+    }
 
-      state.s.date = d;
-      await driver._updateKVC(
-        internals.migrationState,
-        MSTATE,
-        JSON.stringify(state),
-        RUNON,
-        runOn
+    if (heldByOther(row)) {
+      if (!stale || stale.value !== row.value) {
+        return false;
+      }
+
+      const { s } = JSON.parse(row.value);
+      log.warn(
+        `[state] taking over a stale migration lock from ${s.date}` +
+          (s.fin === 0
+            ? `, the previous run was interrupted during a migration at step ${s.step}`
+            : '')
+      );
+    }
+
+    const state = JSON.parse(row.value);
+    Object.assign(state.s, { ID, date: new Date(), n: nonce() });
+    await cas(driver, internals, row, JSON.stringify(state));
+
+    const after = await read(driver, internals);
+    if (claim(after, driver, internals)) {
+      return true;
+    }
+
+    // Nobody holds the lock, still our update did not apply. Either another
+    // process acquired and released in between, or the compare and swap does
+    // not work with this driver at all, which must not end in a busy loop.
+    if (after && !heldByOther(after)) {
+      if (retries > 0) {
+        return module.exports.acquire(driver, internals, null, retries - 1);
+      }
+
+      throw new Error(
+        '[state] could not acquire the migration lock although it is free, ' +
+          'the driver does not seem to support compare and swap on the state'
       );
+    }
 
-      state = await driver._getKV(internals.migrationState, MSTATE);
+    return false;
+  },
 
-      runOn = state.run_on;
-      state = state.value;
-      state = JSON.parse(state);
+  /**
+   * Wait until the lock is released. A lock whose row did not change for
+   * lock-timeout ms is considered stale, its holder is gone. This is
+   * measured on our own monotonic clock, so no clocks have to be in sync.
+   *
+   * Resolves to the stale row, or null if the lock was released properly.
+   */
+  waitForRelease: async function (driver, internals) {
+    const { timeout, interval } = lockOptions(internals);
+    let seen = null;
+    let since = 0;
+
+    for (;;) {
+      const row = await read(driver, internals);
+
+      if (!row || !heldByOther(row)) {
+        return null;
+      }
 
-      if (state.s.ID !== ID) {
-        owner = false;
+      const now = performance.now();
+      if (
+        !seen ||
+        seen.value !== row.value ||
+        String(seen.run_on) !== String(row.run_on)
+      ) {
+        seen = row;
+        since = now;
+      } else if (now - since >= timeout) {
+        return row;
       }
+
+      await delay(interval);
+    }
+  },
+
+  release: async function (driver, internals) {
+    stopHeartbeat();
+
+    if (!owner) {
+      active = false;
+      return;
+    }
+
+    try {
+      await write(driver, internals, s => {
+        s.ID = 0;
+      });
+    } catch (err) {
+      log.warn(err.message);
     }
+
+    active = false;
+    owner = false;
+    current = null;
   },
 
   isOwner: function () {
@@ -70,7 +286,7 @@ module.exports = {
   },
 
   init: async function (driver, internals, { emptyState, backupState }) {
-    await driver._createKV(internals.migrationState);
+    await createConcurrently(() => driver._createKV(internals.migrationState));
     const _schema = await driver._getKV(internals.migrationState, SSTATE);
 
     if (_schema && backupState) {
@@ -91,21 +307,34 @@ module.exports = {
 
     const schema = emptyState !== true ? _schema : null;
     if (schema) {
-      internals.schema = JSON.parse(schema.value);
+      internals.schema = parseSchema(schema.value);
     } else if (!emptyState) {
-      await driver._insertKV(internals.migrationState, SSTATE, '{}');
+      try {
+        await driver._insertKV(internals.migrationState, SSTATE, '{}');
+      } catch (err) {
+        // another process initialized the state at the same time
+        const row = await driver._getKV(internals.migrationState, SSTATE);
+        if (!row) {
+          throw err;
+        }
+
+        internals.schema = parseSchema(row.value);
+      }
     }
+  },
 
-    if (!internals.dryRun) {
-      const state = await driver._getKV(internals.migrationState, MSTATE);
-      return module.exports.lockState(driver, state, internals);
+  /**
+   * Another process may have migrated while we were waiting for the lock,
+   * so the schema loaded during init is outdated.
+   */
+  reloadSchema: async function (driver, internals) {
+    const schema = await driver._getKV(internals.migrationState, SSTATE);
+    if (schema) {
+      internals.schema = parseSchema(schema.value);
     }
-
-    return Promise.resolve();
   },
 
   startMigration: async function (driver, file, internals) {
-    const state = await driver._getKV(internals.migrationState, MSTATE);
     const mig = await driver._getKV(internals.migrationState, file.name);
 
     if (mig && mig.value !== '{}') {
@@ -116,7 +345,10 @@ module.exports = {
       return Promise.resolve();
     }
 
-    await module.exports.lockState(driver, state, internals);
+    await module.exports.progress(driver, internals, s => {
+      s.step = 0;
+      s.fin = 0;
+    });
 
     if (!mig) {
       return driver._insertKV(
@@ -129,64 +361,55 @@ module.exports = {
     }
   },
 
-  update: async function (driver, file, state, internals) {
-    log.verbose(`[state] update state`);
-    if (internals.dryRun) {
-      return Promise.resolve();
+  /**
+   * Write migration progress into the lock row. While holding the lock this
+   * is a compare and swap, which fails if we lost the lock. Without a lock
+   * (driver does not support it) the row is written unconditionally.
+   */
+  progress: async function (driver, internals, mutate) {
+    if (active) {
+      return write(driver, internals, mutate);
     }
 
-    await driver._updateKV(internals.migrationState, SSTATE, JSON.stringify(internals.schema));
+    const row = await read(driver, internals);
+    const state = row
+      ? JSON.parse(row.value)
+      : { s: { step: 0, fin: 0, ID: 0 } };
+    state.s.date = new Date();
+    mutate(state.s);
+
+    if (!row) {
+      return driver._insertKV(
+        internals.migrationState,
+        MSTATE,
+        JSON.stringify(state)
+      );
+    }
 
     return driver._updateKV(
       internals.migrationState,
-      file.name,
+      MSTATE,
       JSON.stringify(state)
     );
   },
 
-  get: function (driver, file, internals) {
-    return driver._getKV(internals.migrationState, file.name);
-  },
-
-  tick: async function (driver, internals) {
+  update: async function (driver, file, state, internals) {
+    log.verbose(`[state] update state`);
     if (internals.dryRun) {
       return Promise.resolve();
     }
 
-    let state = await driver._getKV(
-      internals.migrationState,
-      MSTATE
-    );
-
-    let runOn = state.run_on;
-    state = state.value;
-    state = JSON.parse(state);
-
-    if (!state.s.ID || state.s.ID !== ID) {
-      owner = true;
-      state.s.ID = ID;
-    }
-
-    const d = new Date();
+    await driver._updateKV(internals.migrationState, SSTATE, JSON.stringify(internals.schema));
 
-    state.s.date = d;
-    await driver._updateKVC(
+    return driver._updateKV(
       internals.migrationState,
-      MSTATE,
-      JSON.stringify(state),
-      RUNON,
-      runOn
+      file.name,
+      JSON.stringify(state)
     );
+  },
 
-    state = await driver._getKV(internals.migrationState, MSTATE);
-
-    runOn = state.run_on;
-    state = state.value;
-    state = JSON.parse(state);
-
-    if (state.s.ID !== ID) {
-      owner = false;
-    }
+  get: function (driver, file, internals) {
+    return driver._getKV(internals.migrationState, file.name);
   },
 
   step: async function (driver, step, internals) {
@@ -195,18 +418,9 @@ module.exports = {
       return Promise.resolve();
     }
 
-    let { value: state } = await driver._getKV(
-      internals.migrationState,
-      MSTATE
-    );
-    state = JSON.parse(state);
-    state.s.date = new Date();
-    state.s.step = step;
-    return driver._updateKV(
-      internals.migrationState,
-      MSTATE,
-      JSON.stringify(state)
-    );
+    return module.exports.progress(driver, internals, s => {
+      s.step = step;
+    });
   },
 
   deleteState: function (driver, file, internals) {
@@ -218,21 +432,9 @@ module.exports = {
       return Promise.resolve();
     }
 
-    let { value: state } = await driver._getKV(
-      internals.migrationState,
-      MSTATE
-    );
-    state = JSON.parse(state);
-    state.s.date = new Date();
-    state.s.fin = 1;
-
-    // unlock from current process
-    state.s.ID = 0;
-
-    return driver._updateKV(
-      internals.migrationState,
-      MSTATE,
-      JSON.stringify(state)
-    );
+    // the lock itself stays until the walker releases it
+    return module.exports.progress(driver, internals, s => {
+      s.fin = 1;
+    });
   }
 };

package/lib/walker.js

@@ -63,7 +63,9 @@ const Walker = function (driver, directory, mode, intern, prefix, opts = {}) {
 Walker.prototype = {
   createTables: async function (options) {
     await State.init(this._pdriver, this.internals, options);
-    return this._driver._createList(this.internals.migrationTable);
+    return State.createConcurrently(() =>
+      this._driver._createList(this.internals.migrationTable)
+    );
   },
 
   createMigrationsTable: function (options = {}) {
@@ -90,6 +92,52 @@ Walker.prototype = {
     return this.createTables(options);
   },
 
+  /**
+   * Determine what to run first, only lock when there is actually something
+   * to run. If another process holds the lock, wait for its release and
+   * determine again, the other process might have done the work already.
+   * Once we hold the lock, state and pending migrations are read again.
+   */
+  _withLock: async function (determine, run) {
+    if (this.prefix !== 'migration' || this.internals.dryRun) {
+      return run(await determine());
+    }
+
+    if (!State.supportsLock(this._pdriver)) {
+      log.warn(
+        this.title +
+          'Your database driver does not support migration locking, ' +
+          'concurrent processes are not prevented from migrating at the ' +
+          'same time. Update your driver to a version supporting it.'
+      );
+      return run(await determine());
+    }
+
+    let stale = null;
+    let toRun = await determine();
+
+    while (toRun.length > 0) {
+      if (await State.acquire(this._pdriver, this.internals, stale)) {
+        break;
+      }
+
+      log.info(this.title + 'Waiting for the migration lock of another process');
+      stale = await State.waitForRelease(this._pdriver, this.internals);
+      toRun = await determine();
+    }
+
+    if (toRun.length === 0) {
+      return run(toRun);
+    }
+
+    try {
+      await State.reloadSchema(this._pdriver, this.internals);
+      return await run(await determine());
+    } finally {
+      await State.release(this._pdriver, this.internals);
+    }
+  },
+
   writeMigrationRecord: function (migration, callback) {
     const onComplete = err => {
       if (err) {
@@ -149,96 +197,84 @@ Walker.prototype = {
   up: function (options, callback) {
     const partialName = options.destination;
     const count = options.count;
-    const files = Promise.all([
-      File.loadFromFileystem(this.directory, this.prefix, this.internals),
-      File.loadFromDatabase(
-        this.directory,
-        this.prefix,
-        this._driver,
-        this.internals
-      )
-    ]).spread((allFiles, completedFiles) => {
-      const toRun = dbmUtil.filterUp(
-        allFiles,
-        completedFiles,
-        partialName,
-        count
+    const determine = () =>
+      Promise.all([
+        File.loadFromFileystem(this.directory, this.prefix, this.internals),
+        File.loadFromDatabase(
+          this.directory,
+          this.prefix,
+          this._driver,
+          this.internals
+        )
+      ]).spread((allFiles, completedFiles) =>
+        dbmUtil.filterUp(allFiles, completedFiles, partialName, count)
       );
 
-      if (toRun.length === 0) {
-        log.info(this.title + 'Nothing to run');
-      }
-
-      if (this.internals.check) {
-        const toRunNames = toRun.map(migration => migration.name);
-        log.info(this.title + 'run:', toRunNames);
-        return toRunNames;
-      }
-
-      return toRun;
-    });
-
     if (this.internals.check) {
-      return files.nodeify(callback);
+      return determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
     }
 
-    return files
-      .each(file => {
-        log.verbose(this.title + 'preparing to run up:', file.name);
-        const _meta = file.get()._meta || {};
-        const version = _meta.version || 1;
-        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
-        return require(`./executors/versioned/v${version}`).up(
-          this,
-          this.driver,
-          file
-        );
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
+        }
+
+        return Promise.each(toRun, file => {
+          log.verbose(this.title + 'preparing to run up:', file.name);
+          const _meta = file.get()._meta || {};
+          const version = _meta.version || 1;
+          this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+          return require(`./executors/versioned/v${version}`).up(
+            this,
+            this.driver,
+            file
+          );
+        });
       })
-      .nodeify(callback);
+    ).nodeify(callback);
   },
 
   down: function (options, callback) {
     const partialName = options.destination;
     const count = options.count;
-
-    const files = File.loadFromDatabase(
-      this.directory,
-      this.prefix,
-      this._driver,
-      this.internals
-    ).then(completedFiles => {
-      const toRun = dbmUtil.filterDown(completedFiles, partialName, count);
-
-      if (toRun.length === 0) {
-        log.info(this.title + 'Nothing to run');
-      }
-
-      if (this.internals.check) {
-        const toRunNames = toRun.map(migration => migration.name);
-        log.info(this.title + 'run:', toRunNames);
-        return toRunNames;
-      }
-
-      return toRun;
-    });
+    const determine = () =>
+      File.loadFromDatabase(
+        this.directory,
+        this.prefix,
+        this._driver,
+        this.internals
+      ).then(completedFiles =>
+        dbmUtil.filterDown(completedFiles, partialName, count)
+      );
 
     if (this.internals.check) {
-      return files.nodeify(callback);
+      return determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
     }
 
-    return files
-      .each(file => {
-        log.verbose(this.title + 'preparing to run down:', file.name);
-        const _meta = file.get()._meta || {};
-        const version = _meta.version || 1;
-        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
-        return require(`./executors/versioned/v${version}`).down(
-          this,
-          this.driver,
-          file
-        );
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
+        }
+
+        return Promise.each(toRun, file => {
+          log.verbose(this.title + 'preparing to run down:', file.name);
+          const _meta = file.get()._meta || {};
+          const version = _meta.version || 1;
+          this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+          return require(`./executors/versioned/v${version}`).down(
+            this,
+            this.driver,
+            file
+          );
+        });
       })
-      .nodeify(callback);
+    ).nodeify(callback);
   },
 
   fix: function (options, callback) {
@@ -255,49 +291,56 @@ Walker.prototype = {
       return a.localeCompare(b);
     };
 
-    const files = File.loadFromDatabase(
-      this.directory,
-      this.prefix,
-      this._driver,
-      this.internals
-    ).then(completedFiles => {
-      const toRun = dbmUtil.filterDown(completedFiles, partialName, count).sort(sortFn);
-
-      if (toRun.length === 0) {
-        log.info(this.title + 'Nothing to run');
-      }
-
-      if (this.internals.check) {
-        const toRunNames = toRun.map(migration => migration.name);
-        log.info(this.title + 'run:', toRunNames);
-        return toRunNames;
-      }
-
-      return toRun;
-    });
+    const determine = () =>
+      File.loadFromDatabase(
+        this.directory,
+        this.prefix,
+        this._driver,
+        this.internals
+      ).then(completedFiles =>
+        dbmUtil.filterDown(completedFiles, partialName, count).sort(sortFn)
+      );
 
     if (this.internals.check) {
-      return files.nodeify(callback);
+      return determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
     }
 
-    return files
-      .each(file => {
-        log.verbose(this.title + 'preparing to run fix:', file.name);
-        const _meta = file.get()._meta || {};
-        const version = _meta.version || 1;
-        if (version < 2) {
-          log.warn(`${this.title} skipping "${file.name}" as v1 migrations do not maintain a schema`);
-          return Promise.resolve();
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
         }
 
-        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
-        return require(`./executors/versioned/v${version}`).fix(
-          this,
-          this.driver,
-          file
-        );
+        return Promise.each(toRun, file => {
+          log.verbose(this.title + 'preparing to run fix:', file.name);
+          const _meta = file.get()._meta || {};
+          const version = _meta.version || 1;
+          if (version < 2) {
+            log.warn(`${this.title} skipping "${file.name}" as v1 migrations do not maintain a schema`);
+            return Promise.resolve();
+          }
+
+          this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+          return require(`./executors/versioned/v${version}`).fix(
+            this,
+            this.driver,
+            file
+          );
+        });
       })
-      .nodeify(callback);
+    ).nodeify(callback);
+  },
+
+  _checkResult: function (toRun) {
+    if (toRun.length === 0) {
+      log.info(this.title + 'Nothing to run');
+    }
+
+    const toRunNames = toRun.map(migration => migration.name);
+    log.info(this.title + 'run:', toRunNames);
+    return toRunNames;
   },
 
   check: function (options, callback) {

package/package.json

@@ -31,7 +31,7 @@
     "programable",
     "api"
   ],
-  "version": "1.0.0-beta.35",
+  "version": "1.0.0-beta.36",
   "engines": {
     "node": ">=8.0.0"
   },

package/tttt.js

@@ -1,2 +0,0 @@
-
-