def take_action(self, parsed_args):
     self.log.debug("take_action(%s)" % parsed_args)
     _, ansible_dir = self.get_ansible_key_and_dir(
         no_workflow=True,
         stack=parsed_args.stack,
         orchestration=self.app.client_manager.orchestration)
     deployment.config_download(
         log=self.log,
         clients=self.app.client_manager,
         stack=oooutils.get_stack(self.app.client_manager.orchestration,
                                  parsed_args.stack),
         output_dir=ansible_dir,
         verbosity=oooutils.playbook_verbosity(self=self),
         ansible_playbook_name=constants.EXTERNAL_UPDATE_PLAYBOOKS,
         extra_vars=oooutils.parse_extra_vars(
             extra_var_strings=parsed_args.extra_vars),
         inventory_path=oooutils.get_tripleo_ansible_inventory(
             parsed_args.static_inventory,
             parsed_args.ssh_user,
             parsed_args.stack,
             return_inventory_file_path=True),
         tags=parsed_args.tags,
         skip_tags=parsed_args.skip_tags,
         limit_hosts=oooutils.playbook_limit_parse(
             limit_nodes=parsed_args.limit))
     self.log.info("Completed Overcloud External Update Run.")
    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)" % parsed_args)
        # NOTE(cloudnull): The string option "all" was a special default
        #                  that is no longer relevant. To retain compatibility
        #                  this condition has been put in place.
        if not parsed_args.playbook or parsed_args.playbook == ['all']:
            playbook = constants.MAJOR_UPGRADE_PLAYBOOKS
        else:
            playbook = parsed_args.playbook

        _, ansible_dir = self.get_ansible_key_and_dir(
            no_workflow=parsed_args.no_workflow,
            stack=parsed_args.stack,
            orchestration=self.app.client_manager.orchestration)
        deployment.config_download(
            log=self.log,
            clients=self.app.client_manager,
            stack=oooutils.get_stack(self.app.client_manager.orchestration,
                                     parsed_args.stack),
            output_dir=ansible_dir,
            verbosity=oooutils.playbook_verbosity(self=self),
            ansible_playbook_name=playbook,
            inventory_path=oooutils.get_tripleo_ansible_inventory(
                parsed_args.static_inventory,
                parsed_args.ssh_user,
                parsed_args.stack,
                return_inventory_file_path=True),
            tags=parsed_args.tags,
            skip_tags=parsed_args.skip_tags,
            limit_hosts=oooutils.playbook_limit_parse(
                limit_nodes=parsed_args.limit))
        self.log.info("Completed Overcloud Major Upgrade Run.")
    def take_action(self, parsed_args):
        self.log.debug("take_action(%s)" % parsed_args)
        self._setup_clients(parsed_args)

        # Swiftclient logs things like 404s at error level, which is a problem
        # because we use EAFP to check for the existence of files.  Turn off
        # most swiftclient logging to avoid cluttering up our output with
        # pointless tracebacks.
        sc_logger = logging.getLogger("swiftclient")
        sc_logger.setLevel(logging.CRITICAL)

        self._validate_args(parsed_args)

        # Throw warning if deprecated service is enabled and
        # ask user if deployment should still be continued.
        if parsed_args.environment_files:
            utils.check_deprecated_service_is_enabled(
                parsed_args.environment_files)

        stack = utils.get_stack(self.orchestration_client, parsed_args.stack)

        self._update_parameters(parsed_args, stack)

        stack_create = stack is None
        if stack_create:
            self.log.info("No stack found, will be doing a stack create")
        else:
            self.log.info("Stack found, will be doing a stack update")

        if parsed_args.dry_run:
            print("Validation Finished")
            return

        start = time.time()

        if not parsed_args.config_download_only:
            self._deploy_tripleo_heat_templates_tmpdir(stack, parsed_args)

        # Get a new copy of the stack after stack update/create. If it was
        # a create then the previous stack object would be None.
        stack = utils.get_stack(self.orchestration_client, parsed_args.stack)

        if parsed_args.update_plan_only:
            # If we are only updating the plan, then we either wont have a
            # stack yet or there wont be any changes and the following code
            # wont do anything.
            return

        if parsed_args.config_download:
            print("Deploying overcloud configuration")
            deployment.set_deployment_status(
                clients=self.clients,
                plan=stack.stack_name,
                status='DEPLOYING'
            )

            try:
                if not parsed_args.config_download_only:
                    deployment.get_hosts_and_enable_ssh_admin(
                        stack,
                        parsed_args.overcloud_ssh_network,
                        parsed_args.overcloud_ssh_user,
                        self.get_key_pair(parsed_args),
                        parsed_args.overcloud_ssh_port_timeout,
                        verbosity=utils.playbook_verbosity(self=self)
                    )

                if parsed_args.config_download_timeout:
                    timeout = parsed_args.config_download_timeout
                else:
                    used = int((time.time() - start) // 60)
                    timeout = parsed_args.timeout - used
                    if timeout <= 0:
                        raise exceptions.DeploymentError(
                            'Deployment timed out after %sm' % used)

                deployment_options = {}
                if parsed_args.deployment_python_interpreter:
                    deployment_options['ansible_python_interpreter'] = \
                        parsed_args.deployment_python_interpreter

                deployment.config_download(
                    self.log,
                    self.clients,
                    stack,
                    parsed_args.overcloud_ssh_network,
                    parsed_args.output_dir,
                    parsed_args.override_ansible_cfg,
                    timeout=parsed_args.overcloud_ssh_port_timeout,
                    verbosity=utils.playbook_verbosity(self=self),
                    deployment_options=deployment_options,
                    in_flight_validations=parsed_args.inflight,
                    deployment_timeout=timeout,
                    tags=parsed_args.tags,
                    skip_tags=parsed_args.skip_tags,
                    limit_hosts=utils.playbook_limit_parse(
                        limit_nodes=parsed_args.limit
                    )
                )
                deployment.set_deployment_status(
                    clients=self.clients,
                    plan=stack.stack_name,
                    status='DEPLOY_SUCCESS')
            except Exception:
                deployment.set_deployment_status(
                    clients=self.clients,
                    plan=stack.stack_name,
                    status='DEPLOY_FAILED'
                )
                raise

        # Force fetching of attributes
        stack.get()

        rcpath = deployment.create_overcloudrc(container=stack.stack_name,
                                               no_proxy=parsed_args.no_proxy)

        # Copy clouds.yaml to the cloud user directory
        user = getpwuid(os.stat(constants.CLOUD_HOME_DIR).st_uid).pw_name
        utils.copy_clouds_yaml(user)
        utils.create_tempest_deployer_input()

        # Run postconfig on create or force. Use force to makes sure endpoints
        # are created with deploy reruns and upgrades
        if (stack_create or parsed_args.force_postconfig
                and not parsed_args.skip_postconfig):
            self._deploy_postconfig(stack, parsed_args)

        overcloud_endpoint = utils.get_overcloud_endpoint(stack)

        horizon_url = deployment.get_horizon_url(stack=stack.stack_name)

        print("Overcloud Endpoint: {0}".format(overcloud_endpoint))
        print("Overcloud Horizon Dashboard URL: {0}".format(horizon_url))
        print("Overcloud rc file: {0}".format(rcpath))
        print("Overcloud Deployed")