docstr: Rollback the current production Lambda version(s) by 1.
  
  Args:
      options: Argparse parsed options
      config (dict): Parsed configuration from conf/
  
  Returns:
      bool: False if errors occurred, True otherwise
code: def handler(cls, options, config):
      """Rollback the current production Lambda version(s) by 1.
  
      Args:
          options: Argparse parsed options
          config (dict): Parsed configuration from conf/
  
      Returns:
          bool: False if errors occurred, True otherwise
      """
      # Make sure the Terraform code is up to date
      if not terraform_generate_handler(config=config):
          return False
  
      functions = function_map()
      targeted_funcs = set(options.functions)
      functions = {
          key: value
          for key, value in functions.items()
          if key in targeted_funcs
      }
  
      LOGGER.info("Rolling back: %s", ", ".join(sorted(functions)))
  
      prefix = config["global"]["account"]["prefix"]
      clusters = sorted(options.clusters or config.clusters())
      client = boto3.client("lambda")
  
      # Track the success of rolling back the functions
      success = True
      for func, suffix in functions.items():
          if (
              suffix
          ):  # A suffix implies this is a standard function naming convention
              success = success and _rollback_production(
                  client, "{}_streamalert_{}".format(prefix, suffix)
              )
          elif (
              func == "apps"
          ):  # Apps need special handling due to unique naming
              for cluster in clusters:
                  cluster_modules = config["clusters"][cluster][
                      "modules"
                  ]
                  apps_config = cluster_modules.get(
                      "streamalert_apps", {}
                  )
                  for lambda_name in sorted(apps_config):
                      success = success and _rollback_production(
                          client, lambda_name
                      )
          elif (
              func == "classifier"
          ):  # Classifers need special handling due to clustering
              for cluster in clusters:
                  success = success and _rollback_production(
                      client,
                      "{}_{}_streamalert_{}".format(
                          prefix, cluster, func
                      ),
                  )
  
      return success
  
file_path: streamalert/streamalert_cli/manage_lambda/rollback.py
imports: import boto3
  from botocore.exceptions import ClientError
  from streamalert.shared.logger import get_logger
  from streamalert_cli.terraform.generate import terraform_generate_handler
  from streamalert_cli.utils import add_default_lambda_args, CLICommand, function_map, set_parser_epilog
label_desc: Use image node_id 2 for calling the RollbackCommand obj's underlying member method code with example usage: obj.handler(cls, options, config) and returns: success, False