Gel4y Mini Shell

Edit file

File name : anaconda.py

Content :

# anaconda: The Red Hat Linux Installation program
#
# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
# Red Hat, Inc.  All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

import os
import sys
from glob import glob
from tempfile import mkstemp
import threading

from pyanaconda import addons
from pyanaconda.core.constants import DisplayModes
from pyanaconda.core import constants
from pyanaconda.core.startup.dbus_launcher import AnacondaDBusLauncher
from pyanaconda.core.util import open_with_perm
from pyanaconda.payload.source import SourceFactory, PayloadSourceTypeUnrecognized
from pyanaconda.payload.flatpak import FlatpakPayload

from pyanaconda.anaconda_loggers import get_stdout_logger
stdoutLog = get_stdout_logger()

from pyanaconda.anaconda_loggers import get_module_logger
log = get_module_logger(__name__)

class Anaconda(object):
    def __init__(self):
        self._display_mode = None
        self._interactive_mode = True
        self.gui_startup_failed = False
        self._intf = None
        self.ksdata = None
        self.additional_repos = None
        self.opts = None
        self._payload = None
        self.mehConfig = None

# Data for inhibiting the screensaver
        self.dbus_session_connection = None
        self.dbus_inhibit_id = None

# This is used to synchronize Gtk.main calls between the graphical
        # interface and error dialogs. Whoever gets to their initialization code
        # first will lock gui_initializing
        self.gui_initialized = threading.Lock()

# Create class for launching our dbus session
        self._dbus_launcher = None

def set_from_opts(self, opts):
        """Load argument to variables from self.opts."""
        self.opts = opts
        self.additional_repos = opts.addRepo

@property
    def dbus_launcher(self):
        if not self._dbus_launcher:
            self._dbus_launcher = AnacondaDBusLauncher()

return self._dbus_launcher

@property
    def payload(self):
        # Try to find the payload class.  First try the install
        # class.  If it doesn't give us one, fall back to the default.
        if not self._payload:
            if self.ksdata.ostreesetup.seen:
                if FlatpakPayload.is_available():
                    from pyanaconda.payload.rpmostreepayload import RPMOSTreePayloadWithFlatpaks
                    klass = RPMOSTreePayloadWithFlatpaks
                else:
                    from pyanaconda.payload.rpmostreepayload import RPMOSTreePayload
                    klass = RPMOSTreePayload
            elif self.opts.liveinst:
                from pyanaconda.payload.live import LiveOSPayload
                klass = LiveOSPayload
            elif self.ksdata.liveimg.seen:
                from pyanaconda.payload.live import LiveImagePayload
                klass = LiveImagePayload
            else:
                from pyanaconda.payload.dnf import DNFPayload
                klass = DNFPayload

self._payload = klass(self.ksdata)

return self._payload

@staticmethod
    def get_protected_devices(opts):
        specs = []

# methodstr and stage2 become strings in ways that pylint can't figure out
        # pylint: disable=unsubscriptable-object
        if opts.method and SourceFactory.is_harddrive(opts.method):
            specs.append(opts.method[3:].split(":", 3)[0])

if opts.stage2 and SourceFactory.is_harddrive(opts.stage2):
            specs.append(opts.stage2[3:].split(":", 3)[0])

for additional_repo in opts.addRepo:
            _name, repo_url = Anaconda._get_additional_repo_name(additional_repo)
            if SourceFactory.is_harddrive(repo_url):
                specs.append(repo_url[3:].split(":", 3)[0])

# zRAM swap devices need to be protected
        for zram_dev in glob("/dev/zram*"):
            specs.append(zram_dev)

return specs

@staticmethod
    def _get_additional_repo_name(repo):
        try:
            name, rest = repo.split(',', maxsplit=1)
        except ValueError:
            raise RuntimeError("addrepo boot option has incorrect format. Correct format is: "
                               "inst.addrepo=<name>,<url>") from None
        return name, rest

@property
    def display_mode(self):
        return self._display_mode

@display_mode.setter
    def display_mode(self, new_mode):
        if isinstance(new_mode, DisplayModes):
            if self._display_mode:
                old_mode = self._display_mode
                log.debug("changing display mode from %s to %s",
                          old_mode.value, new_mode.value)
            else:
                log.debug("setting display mode to %s", new_mode.value)
            self._display_mode = new_mode
        else:  # unknown mode name - ignore & log an error
            log.error("tried to set an unknown display mode name: %s", new_mode.value)

@property
    def interactive_mode(self):
        return self._interactive_mode

@interactive_mode.setter
    def interactive_mode(self, value):
        if self._interactive_mode != value:
            self._interactive_mode = value
            if value:
                log.debug("working in interative mode")
            else:
                log.debug("working in noninteractive mode")

@property
    def gui_mode(self):
        """Report if Anaconda should run with the GUI."""
        return self._display_mode == DisplayModes.GUI

@property
    def tui_mode(self):
        """Report if Anaconda should run with the TUI."""
        return self._display_mode == DisplayModes.TUI

def log_display_mode(self):
        if not self.display_mode:
            log.error("Display mode is not set!")
            return

log.info("Display mode is set to '%s %s'.",
                 constants.INTERACTIVE_MODE_NAME[self.interactive_mode],
                 constants.DISPLAY_MODE_NAME[self.display_mode])

def add_additional_repositories_to_ksdata(self):
        from pyanaconda.kickstart import RepoData

for add_repo in self.additional_repos:
            name, repo_url = self._get_additional_repo_name(add_repo)
            try:
                source = SourceFactory.parse_repo_cmdline_string(repo_url)
            except PayloadSourceTypeUnrecognized:
                log.error("Type for additional repository %s is not recognized!", add_repo)
                return

repo = RepoData(name=name, baseurl=repo_url, install=False)

if source.is_nfs or source.is_http or source.is_https or source.is_ftp \
                    or source.is_file:
                repo.enabled = True
            elif source.is_harddrive:
                repo.enabled = True
                repo.partition = source.partition
                repo.iso_path = source.path
                repo.baseurl = "file://"
            else:
                log.error("Source type %s for additional repository %s is not supported!",
                          source.source_type.value, add_repo)
                continue

self._check_repo_name_uniqueness(repo)
            self.ksdata.repo.dataList().append(repo)

def _check_repo_name_uniqueness(self, repo):
        """Log if we are adding repository with already used name

In automatic kickstart installation this will result in using the first defined repo.
        """
        if repo in self.ksdata.repo.dataList():
            log.warning("Repository name %s is not unique. Only the first repo will be used!",
                        repo.name)

def dumpState(self):
        from meh import ExceptionInfo
        from meh.dump import ReverseExceptionDump
        from inspect import stack as _stack
        from traceback import format_stack

# Skip the frames for dumpState and the signal handler.
        stack = _stack()[2:]
        stack.reverse()
        exn = ReverseExceptionDump(ExceptionInfo(None, None, stack),
                                   self.mehConfig)

# gather up info on the running threads
        threads = "\nThreads\n-------\n"

# Every call to sys._current_frames() returns a new dict, so it is not
        # modified when threads are created or destroyed. Iterating over it is
        # thread safe.
        for thread_id, frame in sys._current_frames().items():
            threads += "\nThread %s\n" % (thread_id,)
            threads += "".join(format_stack(frame))

# dump to a unique file
        (fd, filename) = mkstemp(prefix="anaconda-tb-", dir="/tmp")
        dump_text = exn.traceback_and_object_dump(self)
        dump_text += threads
        dump_text_bytes = dump_text.encode("utf-8")
        os.write(fd, dump_text_bytes)
        os.close(fd)

# append to a given file
        with open_with_perm("/tmp/anaconda-tb-all.log", "a+", 0o600) as f:
            f.write("--- traceback: %s ---\n" % filename)
            f.write(dump_text + "\n")

@property
    def intf(self):
        """The user interface."""
        return self._intf

def initInterface(self):
        if self._intf:
            raise RuntimeError("Second attempt to initialize the InstallInterface")

if self.gui_mode:
            from pyanaconda.ui.gui import GraphicalUserInterface
            # Run the GUI in non-fullscreen mode, so live installs can still
            # use the window manager
            self._intf = GraphicalUserInterface(None, self.payload,
                                                gui_lock=self.gui_initialized,
                                                fullscreen=False)

# needs to be refreshed now we know if gui or tui will take place
            addon_paths = addons.collect_addon_paths(constants.ADDON_PATHS,
                                                     ui_subdir="gui")
        elif self.tui_mode:
            # TUI and noninteractive TUI are the same in this regard
            from pyanaconda.ui.tui import TextUserInterface
            self._intf = TextUserInterface(None, self.payload)

# needs to be refreshed now we know if gui or tui will take place
            addon_paths = addons.collect_addon_paths(constants.ADDON_PATHS,
                                                     ui_subdir="tui")
        elif not self.display_mode:
            raise RuntimeError("Display mode not set.")
        else:
            # this should generally never happen, as display_mode now won't let
            # and invalid value to be set, but let's leave it here just in case
            # something ultra crazy happens
            raise RuntimeError("Unsupported display mode: %s" % self.display_mode)

if addon_paths:
            self._intf.update_paths(addon_paths)