serverless/lib/plugins/aws/rollback.js

import validate from './lib/validate.js'
import setBucketName from './lib/set-bucket-name.js'
import updateStack from './lib/update-stack.js'
import monitorStack from './lib/monitor-stack.js'
import waitForChangeSetCreation from './lib/wait-for-change-set-creation.js'
import getCreateChangeSetParams from './lib/get-create-change-set-params.js'
import getExecuteChangeSetParams from './lib/get-execute-change-set-params.js'
import getSharedStackActionParams from './lib/get-shared-stack-action-params.js'
import getCreateStackParams from './lib/get-create-stack-params.js'
import getUpdateStackParams from './lib/get-update-stack-params.js'
import findAndGroupDeployments from './utils/find-and-group-deployments.js'
import ServerlessError from '../../serverless-error.js'
import utils from '@serverlessinc/sf-core/src/utils.js'

const { log, progress, style } = utils

class AwsRollback {
  constructor(serverless, options) {
    this.serverless = serverless
    this.options = options
    this.provider = this.serverless.getProvider('aws')

    const mainProgress = progress.get('main')

    Object.assign(
      this,
      validate,
      setBucketName,
      updateStack,
      monitorStack,
      waitForChangeSetCreation,
      getCreateChangeSetParams,
      getExecuteChangeSetParams,
      getCreateStackParams,
      getUpdateStackParams,
      getSharedStackActionParams,
    )

    this.hooks = {
      'before:rollback:initialize': async () => this.validate(),

      'rollback:rollback': async () => {
        if (!this.options.timestamp) {
          log.notice(
            'Select a "timestamp" from the deploy list below and run "sls rollback -t <timestamp>" to rollback your service to a specific version.',
          )
          await this.serverless.pluginManager.spawn('deploy:list')
          return
        }

        log.notice(
          `Rolling back ${this.serverless.service.service} to timestamp "${this.options.timestamp}"`,
        )

        log.info() // Ensure gap between verbose logging

        mainProgress.notice('Validating')
        await this.setBucketName()
        await this.setStackToUpdate()

        mainProgress.notice('Updating AWS CloudFormation stack')
        const result = await this.updateStack()

        if (result) {
          log.success(
            `Service rolled back to timestamp "${
              this.options.timestamp
            }" ${style.aside(
              `(${Math.floor(
                (Date.now() -
                  this.serverless.pluginManager.commandRunStartTime) /
                  1000,
              )}s)`,
            )}`,
          )
        } else {
          log.aside(
            `No updates to be performed. Rollback skipped. ${style.aside(
              `(${Math.floor(
                (Date.now() -
                  this.serverless.pluginManager.commandRunStartTime) /
                  1000,
              )}s)`,
            )}`,
          )
        }
      },
    }
  }

  async setStackToUpdate() {
    const logger = log.get('console')
    const service = this.serverless.service
    const serviceName = this.serverless.service.service
    const stage = this.provider.getStage()
    const deploymentPrefix = this.provider.getDeploymentPrefix()
    const prefix = `${deploymentPrefix}/${serviceName}/${stage}`

    let response
    try {
      response = await this.provider.request('S3', 'listObjectsV2', {
        Bucket: this.bucketName,
        Prefix: prefix,
      })
    } catch (err) {
      if (err.code === 'AWS_S3_LIST_OBJECTS_V2_ACCESS_DENIED') {
        throw new ServerlessError(
          'Could not list objects in the deployment bucket. Make sure you have sufficient permissions to access it.',
          err.code,
        )
      }
      throw err
    }

    const deployments = findAndGroupDeployments(
      response,
      deploymentPrefix,
      serviceName,
      stage,
    )

    if (deployments.length === 0) {
      const msg = "Couldn't find any existing deployments."
      const hint = 'Please verify that stage and region are correct.'
      throw new ServerlessError(
        `${msg} ${hint}`,
        'ROLLBACK_DEPLOYMENTS_NOT_FOUND',
      )
    }

    let date = new Date(this.options.timestamp)

    // The if below is added due issues#5664 - Check it for more details
    if (date instanceof Date === false || isNaN(date.valueOf())) {
      date = new Date(Number(this.options.timestamp))
    }

    const dateString = `${date.getTime().toString()}-${date.toISOString()}`
    const exists = deployments.some((deployment) =>
      deployment.some(
        (item) =>
          item.directory === dateString &&
          item.file === this.provider.naming.getCompiledTemplateS3Suffix(),
      ),
    )

    if (!exists) {
      const msg = `Couldn't find a deployment for the timestamp: ${this.options.timestamp}.`
      const hint =
        'Please verify that the timestamp, stage and region are correct.'
      throw new ServerlessError(
        `${msg} ${hint}`,
        'ROLLBACK_DEPLOYMENT_NOT_FOUND',
      )
    }

    service.package.artifactDirectoryName = `${prefix}/${dateString}`
    const stateString = await (async () => {
      try {
        return (
          await this.provider.request('S3', 'getObject', {
            Bucket: this.bucketName,
            Key: `${
              service.package.artifactDirectoryName
            }/${this.provider.naming.getServiceStateFileName()}`,
          })
        ).Body
      } catch (error) {
        if (error.code === 'AWS_S3_GET_OBJECT_NO_SUCH_KEY') return null
        throw error
      }
    })()
    const state = stateString ? JSON.parse(stateString) : {}
    logger.debug('resolved state %o', state)
    if (state.console) {
      throw new ServerlessError(
        'Cannot rollback deployment: Target deployment was packaged with old ' +
          'Serverless Console integration, which is no longer supported',
        'CONSOLE_ACTIVATION_MISMATCH_ROLLBACK',
      )
    }
  }
}

export default AwsRollback