feat(update): add support for automatically rolling back failed updates

Author: vikaspotluri123

lib/commands/update.js

@@ -114,7 +114,9 @@ class UpdateCommand extends Command {
                     return;
                 }
 
-                return this.ui.listr(tasks, context);
+                return this.ui.listr(tasks, context).catch(error =>
+                    this.rollbackFromFail(error, context.version, argv['auto-rollback'])
+                );
             });
         });
     }
@@ -196,6 +198,24 @@ class UpdateCommand extends Command {
         });
     }
 
+    rollbackFromFail(error, newVer, force = false) {
+        const oldVer = this.system.getInstance().cliConfig.get('previous-version');
+        const question = `Unable to upgrade Ghost from v${oldVer} to v${newVer}. Would you like to revert back to v${oldVer}?`;
+        const promise = force ? Promise.resolve(true) : this.ui.confirm(question, true);
+
+        this.ui.error(error);
+
+        return promise.then(answer => {
+            if (!answer) {
+                return Promise.resolve();
+            }
+
+            return this.run({
+                rollback: true
+            });
+        });
+    }
+
     link(context) {
         const symlinkSync = require('symlink-or-copy').sync;
 
@@ -233,6 +253,11 @@ UpdateCommand.options = {
         describe: 'Limit update to Ghost 1.x releases',
         type: 'boolean',
         default: false
+    },
+    'auto-rollback': {
+        description: '[--no-auto-rollback] Enable/Disable automatically rolling back Ghost if updating fails',
+        type: 'boolean',
+        default: false
     }
 };
 UpdateCommand.checkVersion = true;

test/unit/commands/update-spec.js

@@ -480,6 +480,44 @@ describe('Unit: Commands > Update', function () {
                 expect(stopStub.called).to.be.false;
             });
         });
+
+        it('attempts to auto-rollback on error', function () {
+            const UpdateCommand = require(modulePath);
+            const config = configStub();
+            const errObj = new Error('should_rollback')
+            config.get.withArgs('cli-version').returns('1.0.0');
+            config.get.withArgs('active-version').returns('1.1.0');
+            config.get.withArgs('previous-version').returns('1.0.0');
+
+            const ui = {
+                log: sinon.stub(),
+                listr: sinon.stub().rejects(errObj),
+                run: sinon.stub().callsFake(fn => fn())
+            };
+            const system = {getInstance: sinon.stub()};
+            class TestInstance extends Instance {
+                get cliConfig() { return config; }
+            }
+            const fakeInstance = sinon.stub(new TestInstance(ui, system, '/var/www/ghost'));
+            system.getInstance.returns(fakeInstance);
+            fakeInstance.running.resolves(false);
+
+            const cmdInstance = new UpdateCommand(ui, system);
+            const rollback = cmdInstance.rollbackFromFail = sinon.stub().rejects(new Error('rollback_successful'));
+            cmdInstance.runCommand = sinon.stub().resolves(true);
+            cmdInstance.version = sinon.stub().callsFake(context => {
+                context.version = '1.1.1';
+                return true;
+            });
+
+            return cmdInstance.run({}).then(() => {
+                expect(false, 'Promise should have rejected').to.be.true;
+            }).catch(error => {
+                expect(error.message).to.equal('rollback_successful');
+                expect(rollback.calledOnce).to.be.true;
+                expect(rollback.calledWithExactly(errObj, '1.1.1', undefined)).to.be.true;
+            });
+        });
     });
 
     describe('downloadAndUpdate task', function () {
@@ -796,6 +834,63 @@ describe('Unit: Commands > Update', function () {
         });
     });
 
+    describe('rollbackFromFail', function () {
+        let ui, system;
+
+        beforeEach(function () {
+            const cliConfig = {get: () => '1.0.0'}
+            ui = {
+                confirm: sinon.stub(),
+                error: () => true
+            };
+
+            system = {
+                getInstance() {
+                    return {cliConfig};
+                }
+            };
+        });
+
+        it('Asks to rollback by default', function () {
+            const UpdateCommand = require(modulePath);
+            const expectedQuestion = 'Unable to upgrade Ghost from v1.0.0 to v1.1.1. Would you like to revert back to v1.0.0?'
+            const update = new UpdateCommand(ui, system, '/var/www/ghost');
+            ui.confirm.rejects(new Error('CONFIRMED'));
+
+            return update.rollbackFromFail(false, '1.1.1').then(() => {
+                expect(false, 'Promise should have rejected').to.be.true;
+            }).catch(error => {
+                expect(error.message).to.equal('CONFIRMED');
+                expect(ui.confirm.calledOnce).to.be.true;
+                expect(ui.confirm.calledWithExactly(expectedQuestion, true)).to.be.true;
+            });
+        });
+
+        it('Listens to the user', function () {
+            const UpdateCommand = require(modulePath);
+            const update = new UpdateCommand(ui, system, '/var/www/ghost');
+
+            ui.confirm.resolves(false);
+            update.run = sinon.stub().resolves();
+
+            return update.rollbackFromFail(false, '1.1.1').then(() => {
+                expect(ui.confirm.calledOnce).to.be.true;
+                expect(update.run.called).to.be.false;
+            });
+        });
+
+        it('Re-runs `run` using rollback', function () {
+            const UpdateCommand = require(modulePath);
+            const update = new UpdateCommand(ui, system, '/var/www/ghost');
+
+            update.run = sinon.stub().resolves();
+            return update.rollbackFromFail(false, '1.1.1', true).then(() => {
+                expect(update.run.calledOnce).to.be.true;
+                expect(update.run.calledWithExactly({rollback: true})).to.be.true;
+            });
+        });
+    });
+
     describe('link', function () {
         const UpdateCommand = require(modulePath);