Beispiel #1
0
    def prepare_scan_system(self):
        """
        Prepare system for scan.

        In case the result of previous assessment is detected, remove it
        and prepare new directory structure that will be used for next scan.
        Additionaly process scripts generating common data about the current
        system, generate final XCCDF compose from the original set of modules
        identified for run and in the end process initial script of modules to
        complete expected environment for the scan.
        """
        # First of all we need to delete the older one assessment
        self.clean_scan()
        self.prepare_scan_directories()
        self.common = Common(self.conf)
        if not self.conf.skip_common:
            if not self.common.common_results():
                return ReturnValues.SCRIPT_TXT_MISSING

        # Generate final XCCDF compose under self.module_set_copy_path
        xccdf_compose = XCCDFCompose(self.module_set_path,
                                     self.module_set_copy_path)
        ret_val = xccdf_compose.generate_xml()
        if ret_val != 0:
            return ret_val
        self.run_init()
        return 0
Beispiel #2
0
    def run(self):
        """run analysis"""
        version_msg = "Preupgrade Assistant version: %s" % VERSION
        if self.conf.version:
            print(version_msg)
            return 0

        logger_debug.debug(version_msg)
        if self.conf.list_contents_set:
            for dir_name, dummy_content in six.iteritems(
                    list_contents(self.conf.source_dir)):
                log_message("%s" % dir_name)
            return 0

        if not self.conf.scan and not self.conf.contents and not self.conf.list_rules:
            ret_val = self._check_available_contents()
            if int(ret_val) != 0:
                return ret_val

        if self.conf.list_rules:
            ret_val = self._check_available_contents()
            if int(ret_val) != 0:
                return ret_val
            rules = [
                self.conf.scan + ':' + x
                for x in XccdfHelper.get_list_rules(self.conf.scan)
            ]
            log_message('\n'.join(rules))
            return 0

        if self.conf.upload:
            if not self.upload_results():
                return ReturnValues.SEND_REPORT_TO_UI
            return 0

        if self.conf.mode and self.conf.select_rules:
            log_message(settings.options_not_allowed)
            return ReturnValues.MODE_SELECT_RULES

        if not self.conf.riskcheck and not self.conf.cleanup and not self.conf.kickstart:
            # If force option is not mentioned and user select NO then exits
            if not self.conf.force:
                text = ""
                if self.conf.dst_arch:
                    correct_option = [
                        x for x in settings.migration_options
                        if self.conf.dst_arch == x
                    ]
                    if not correct_option:
                        log_message("Specify the correct --dst-arch option.")
                        log_message("There are '%s' or '%s' available." %
                                    (settings.migration_options[0],
                                     settings.migration_options[1]))
                        return ReturnValues.RISK_CLEANUP_KICKSTART
                if SystemIdentification.get_arch(
                ) == "i386" or SystemIdentification.get_arch() == "i686":
                    if not self.conf.dst_arch:
                        text = '\n' + settings.migration_text
                logger_debug.debug("Architecture '%s'. Text '%s'.",
                                   SystemIdentification.get_arch(), text)
                if not show_message(settings.warning_text + text):
                    # We do not want to continue
                    return ReturnValues.RISK_CLEANUP_KICKSTART

        if self.conf.text:
            # Test whether w3m, lynx and elinks packages are installed
            found = False
            for pkg in SystemIdentification.get_convertors():
                if xml_manager.get_package_version(pkg):
                    self.text_convertor = pkg
                    found = True
                    break
            if not found:
                log_message(
                    settings.converter_message.format(' '.join(
                        SystemIdentification.get_convertors())))
                return ReturnValues.MISSING_TEXT_CONVERTOR

        if os.geteuid() != 0:
            print("Need to be root", end="\n")
            if not self.conf.debug:
                return ReturnValues.ROOT

        if self.conf.cleanup:
            self.clean_preupgrade_environment()
            return 0

        self.openscap_helper = OpenSCAPHelper(self.conf.assessment_results_dir,
                                              self.conf.result_prefix,
                                              self.conf.xml_result_name,
                                              self.conf.html_result_name,
                                              self.content)
        if self.conf.riskcheck:
            if not os.path.exists(
                    self.openscap_helper.get_default_xml_result_path()):
                log_message(
                    "The 'preupg' command was not run yet. Run it to check for possible risks."
                )
                return ReturnValues.PREUPG_BEFORE_KICKSTART
            return_val = XccdfHelper.check_inplace_risk(
                self.openscap_helper.get_default_xml_result_path(),
                self.conf.verbose)
            return return_val

        if self.conf.kickstart:
            if not os.path.exists(
                    self.openscap_helper.get_default_xml_result_path()):
                log_message(
                    "The 'preupg' command was not run yet. Run it before the Kickstart generation."
                )
                return ReturnValues.PREUPG_BEFORE_KICKSTART
            kg = KickstartGenerator(self.conf, settings.KS_DIR,
                                    settings.KS_PATH)
            kg.main()
            return 0

        if self.conf.scan:
            self.content = os.path.join(self.conf.source_dir, self.conf.scan,
                                        settings.content_file)
            if self.conf.scan.startswith("/"):
                log_message(
                    'Specify the correct upgrade path parameter like -s RHEL6_7'
                )
                log_message(
                    "Upgrade path is provided by the 'preupg --list' command.")
                self._check_available_contents()
                log_message("The available upgrade paths: '%s'" %
                            '\n'.join(self.list_scans))
                return ReturnValues.SCENARIO
            if not os.path.isdir(
                    os.path.join(self.conf.source_dir, self.conf.scan)):
                log_message(
                    'Specify the correct upgrade path parameter like -s RHEL6_7'
                )
                self._check_available_contents()
                log_message(
                    "Upgrade path is provided by the 'preupg --list' command.")
                log_message("The available upgrade paths: '%s'" %
                            '\n'.join(self.list_scans))
                return ReturnValues.SCENARIO

        if self.conf.contents:
            self.content = os.path.join(os.getcwd(), self.conf.contents)
            # From content path like content-users/RHEL6_7 we need
            # to get content-users dir
            content_dir = self.conf.contents[:self.conf.contents.
                                             find(self.get_scenario())]
            self.conf.source_dir = os.path.join(os.getcwd(), content_dir)

        self.common = Common(self.conf)
        if not self.conf.skip_common:
            if not self.common.common_results():
                return ReturnValues.SCRIPT_TXT_MISSING

        if self.conf.scan or self.conf.contents:
            if not os.path.exists(settings.openscap_binary):
                log_message("Oscap with SCE enabled is not installed")
                return ReturnValues.MISSING_OPENSCAP
            if not os.access(settings.openscap_binary, os.X_OK):
                log_message("Oscap with SCE %s is not executable" %
                            settings.openscap_binary)
                return ReturnValues.MISSING_OPENSCAP

            current_dir = os.getcwd()
            os.chdir("/tmp")
            retval = self.scan_system()
            if int(retval) != 0:
                return retval
            self.summary_report(self.tar_ball_name)
            self.common.copy_common_files()
            KickstartGenerator.kickstart_scripts()
            FileHelper.remove_home_issues()
            if self.conf.upload:
                self.upload_results(self.tar_ball_name)
            os.chdir(current_dir)
            return self.report_return_value

        log_message('Nothing to do. Give me a task, please.')
        self.conf.settings[2].parser.print_help()
        return 0