代码改变世界

Linux安装程序Anaconda分析(续)

2012-02-27 10:07  htc开发  阅读(1647)  评论(0)  编辑  收藏  举报
 (1) disptach.py: 下面我们看一下Dispatcher类的主要接口。
    1）gotoNext & gotoPrev：这两个接口分别从当前安装步骤前进（后退）到下一个（上一个）具有用户界面的安装步骤，在图形界面安装模式下，由InstallControlWindow类调用，在字符模式下，由InstallInterface类（在text.py和cmdline.py中）调用。这两个函数只是简单的设置安装方向，然后调用moveStep函数，其核心操作是moveStep。

    2）moveStep：我们来重点分析movestep函数，代码如下：

[python] view plaincopy
  1. def moveStep(self):  
  2.     if self.step == None:  
  3.         self.step = self.firstStep  
  4.     else:  
  5.         if self.step >= len(installSteps):  
  6.             return None  
  7.   
  8.         log.info("leaving (%d) step %s" %(self._getDir(), installSteps[self.step][0]))  
  9.         self.step = self.step + self._getDir()  
  10.   
  11.         if self.step >= len(installSteps):  
  12.             return None  
  13.   
  14.     while self.step >= self.firstStep and self.step < len(installSteps) \  
  15.         and (self.stepInSkipList(self.step) or self.stepIsDirect(self.step)):  
  16.   
  17.         if self.stepIsDirect(self.step) and not self.stepInSkipList(self.step):  
  18.             (stepName, stepFunc) = installSteps[self.step]  
  19.             log.info("moving (%d) to step %s" %(self._getDir(), stepName))  
  20.             log.debug("%s is a direct step" %(stepName,))  
  21.             rc = stepFunc(self.anaconda)  
  22.             if rc in [DISPATCH_BACK, DISPATCH_FORWARD]:  
  23.                 self._setDir(rc)  
  24.             log.info("leaving (%d) step %s" %(self._getDir(), stepName))  
  25.             # if anything else, leave self.dir alone  
  26.   
  27.         self.step = self.step + self._getDir()  
  28.         if self.step == len(installSteps):  # 安装过程完成，退出循环  
  29.             return None  
  30.   
  31.     if (self.step < 0):  
  32.         # pick the first step not in the skip list  
  33.         self.step = 0  
  34.         while self.skipSteps.has_key(installSteps[self.step][0]):  
  35.             self.step = self.step + 1   # 步数加一，向前  
  36.     elif self.step >= len(installSteps):  
  37.         self.step = len(installSteps) - 1  
  38.         while self.skipSteps.has_key(installSteps[self.step][0]):  
  39.             self.step = self.step - 1  
  40.     log.info("moving (%d) to step %s" %(self._getDir(), installSteps[self.step][0]))  
    我们重点看一下程序while循环体，首先看一下循环条件：当下一个安装步骤是合法的，即在第一个安装步骤和最后一个安装步骤之间，并且(and)该步骤被跳过或者该步骤是一个无用户界面的安装步骤，即installSteps的条目的第二个元素是一个function，则进入循环体。进入循环后，Dispatcher直接调用该函数stepFunc执行安装操作。如果下一个安装步骤依然无用户界面，则步数加一向前，继续循环，直到下一个没有被跳过的具有用户界面的安装步骤，对于图形安装模式，Dispatcher将控制权交给guid.py中的InstallControlWindow，对于字符安装模式，Dispatcher将控制权交给InstallInterface。如果安装过程完成则退出循环。
    3）currentStep：Dispatcher类的另一个主要接口，取得当前的安装步骤及其相关信息返回给调用者。在图形安装模式下，该函数主要在InstallControlWindow调度图形用户界面类时调用，在字符模式下，主要在InstallInterface调度字符用户界面时调用，这两个类通过该接口取得当前安装步骤的用户界面对应类及创建该用户界面类的实例所需的信息。
[python] view plaincopy
  1. def currentStep(self):  
  2.       if self.step == None:  
  3.           self.gotoNext()  
  4.       elif self.step >= len(installSteps):  
  5.           return (None, None)  
  6.   
  7.       stepInfo = installSteps[self.step]  
  8.       step = stepInfo[0]  
  9.   
  10.       return (step, self.anaconda)  
    另外，Dispatcher类的主要接口还有skipStep(self, stepToSkip, skip = 1, permanent = 0)是跳过安装步骤的函数。setStepList(self, *steps)是安装步骤设置函数，主要由安装类型实例调用，每个安装类型会根据自身的特点设置安装步骤。这些接口的实现逻辑都比较简单，这里不一一给出分析了。
    （2）gui.py: 核心是字符安装模式的InstallInterface类和图形安装模式InstallControlWindow类的实现。看InstallControlWindow中的接口。

    1）数据结构stepTopClass: 该字典中记录了安装过程中所有的具有图形用户界面的安装步骤。

[python] view plaincopy
  1. stepToClass = {  
  2.     "language" : ("language_gui", "LanguageWindow"),  
  3.     "keyboard" : ("kbd_gui", "KeyboardWindow"),  
  4.     "filtertype" : ("filter_type", "FilterTypeWindow"),  
  5.     "filter" : ("filter_gui", "FilterWindow"),   
  6.     "zfcpconfig" : ("zfcp_gui", "ZFCPWindow"),  
  7.     "partition" : ("partition_gui", "PartitionWindow"),  
  8.     "parttype" : ("autopart_type", "PartitionTypeWindow"),  
  9.     "cleardiskssel": ("cleardisks_gui", "ClearDisksWindow"),  
  10.     "findinstall" : ("examine_gui", "UpgradeExamineWindow"),  
  11.     "addswap" : ("upgrade_swap_gui", "UpgradeSwapWindow"),  
  12.     "upgrademigratefs" : ("upgrade_migratefs_gui", "UpgradeMigrateFSWindow"),  
  13.     "bootloader": ("bootloader_main_gui", "MainBootloaderWindow"),  
  14.     "upgbootloader": ("upgrade_bootloader_gui", "UpgradeBootloaderWindow"),  
  15.     "network" : ("network_gui", "NetworkWindow"),  
  16.     "timezone" : ("timezone_gui", "TimezoneWindow"),  
  17.     "accounts" : ("account_gui", "AccountWindow"),  
  18.     "tasksel": ("task_gui", "TaskWindow"),      
  19.     "group-selection": ("package_gui", "GroupSelectionWindow"),  
  20.     "install" : ("progress_gui", "InstallProgressWindow"),  
  21.     "complete" : ("congrats_gui", "CongratulationWindow"),  
  22. }  
    每一个条目从左到右依次是安装步骤名称、图形界面类所在模块，图形界面类的名称。如language为安装步骤名称，language_gui为该步骤对应的图形界面类所在模块language_gui.py，LanguageWindow为图形界面对应的类名。
    2）run: 启动图形安装界面的入口函数。该函数调用了setup_window接口，该接口调用gtk"绘制"图形安装界面的主窗体，然后控制权交给了gtk。
[python] view plaincopy
  1. def run (self):  
  2.     self.setup_theme()  
  3.     self.setup_window(False)  
  4.     gtk.main()  
    3）nextClicked & prevClicked：这两个接口分别执行从当前图形安装界面向前（向后）到下一个图形安装界面的操作，我们可以想象安装过程中当用户点击"下一步" 或"上一步"按钮时，这两个函数被调用。这两个函数首先调用主流程控制Dispatcher实例向前（向后）前进到下一个图形安装界面，然后调用setScreen函数设置图形界面。
[python] view plaincopy
  1.    def prevClicked (self, *args):  
  2.        try:  
  3.            self.currentWindow.getPrev ()  
  4.        except StayOnScreen:  
  5.            return  
  6.   
  7.        self.anaconda.dispatch.gotoPrev()  
  8.        self.setScreen ()  
  9.   
  10.    def nextClicked (self, *args):  
  11.        try:  
  12.            rc = self.currentWindow.getNext ()  
  13.        except StayOnScreen:  
  14.            return  
  15.   
  16.        self.anaconda.dispatch.gotoNext()  
  17.        self.setScreen ()  
  18. 4）setScreen: 用于设置图形界面。代码如下：  
  19.    def setScreen (self):  
  20.     # 取得当前安装步骤信息  
  21.        (step, anaconda) = self.anaconda.dispatch.currentStep()  
  22.        if step is None:  
  23.            gtk.main_quit()  
  24.            return  
  25.   
  26.        if not stepToClass[step]:    # 不在其中，则直接跳到下一步  
  27.            if self.anaconda.dispatch.dir == DISPATCH_FORWARD:  
  28.                return self.nextClicked()  
  29.            else:  
  30.                return self.prevClicked()  
  31.   
  32.        (file, className) = stepToClass[step]    # 获得图形界面类所在模块及其类名  
  33.        newScreenClass = None  
  34.   
  35.        while True:  
  36.            try:  
  37.                found = imp.find_module(file, iw.__path__)  
  38.                moduleName = 'pyanaconda.iw.%s' % file  
  39.                loaded = imp.load_module(moduleName, *found) # 载入该图形界面模块  
  40.                newScreenClass = loaded.__dict__[className]  
  41.                break  
  42.            except ImportError, e:  
  43.                stdout_log.error("loading interface component %s" % className)  
  44.                stdout_log.error(traceback.format_exc())  
  45.                win = MessageWindow(_("Error!"),  
  46.                                    _("An error occurred when attempting "  
  47.                                      "to load an installer interface "  
  48.                                      "component.\n\nclassName = %s")  
  49.                                    % (className,),  
  50.                                    type="custom", custom_icon="warning",  
  51.                                    custom_buttons=[_("_Exit"),  
  52.                                                    _("_Retry")])  
  53.                if not win.getrc():  
  54.                    msg =  _("The system will now reboot.")  
  55.                    buttons = [_("_Reboot")]  
  56.   
  57.                    MessageWindow(_("Exiting"),  
  58.                                  msg,  
  59.                                  type="custom",  
  60.                                  custom_icon="warning",  
  61.                                  custom_buttons=buttons)  
  62.                    sys.exit(0)  
  63.   
  64.        ics = InstallControlState (self)  
  65.     # 设置是否是可以返回上一步  
  66.        ics.setPrevEnabled(self.anaconda.dispatch.canGoBack())  
  67.        self.destroyCurrentWindow()      # 销毁原来的图形安装界面  
  68.        self.currentWindow = newScreenClass(ics) # 创建新的图形安装界面并设为当前界面  
  69.   
  70.        new_screen = self.currentWindow.getScreen(anaconda)      # 生成安装步骤的界面  
  71.   
  72.        # If the getScreen method returned None, that means the screen did not  
  73.        # want to be displayed for some reason and we should skip to the next  
  74.        # step.  However, we do not want to remove the current step from the  
  75.        # list as later events may cause the screen to be displayed.  
  76.        if not new_screen:  
  77.            if self.anaconda.dispatch.dir == DISPATCH_FORWARD:  
  78.                self.anaconda.dispatch.gotoNext()  
  79.            else:  
  80.                self.anaconda.dispatch.gotoPrev()  
  81.   
  82.            return self.setScreen()  
  83.   
  84.        self.update (ics)  
  85.   
  86.        self.installFrame.add(new_screen)  
  87.        self.installFrame.show_all()  
  88.   
  89.        self.currentWindow.focus()  
  90.   
  91.        self.handle = gobject.idle_add(self.handleRenderCallback)  
  92.   
  93.        if self.reloadRcQueued:  
  94.            self.window.reset_rc_styles()  
  95.            self.reloadRcQueued = 0  
    前面的nextClicked和prevClicked函数已经通过Dispatcher将要进行的安装步骤标记为当前安装步骤，所以该函数首先通过Dispatcher的currentStep从Dispatcher的数据结构installSteps中取得当前安装步骤名称及相关信息，接下来，做了一下判断，如果Dispatcher的当前安装步骤不在字典stepToClass中，则忽略该步骤，调用nextClicked或prevClicked继续下一个图形界面安装步骤，直到下一个步骤在字典stepToClass中。验证通过后，从字典stepToClass中取得当前图形安装界面对应的类及该类所在模块，然后导入该模块并创建图形安装界面的实例，销毁前一个图形安装界面，并将新创建的图形界面实例置为当前安装界面，调用图形安装界面实例的getScreen函数生成该安装步骤的图形用户界面，然后显示。
    至此，InstallControlWindow的主要逻辑已经分析完了，接下来涉及每个具体安装界面及其安装操作读者可以到iw目录下逐个深入分析。
    （3）anaconda主程序： 图形环境运行是建立在X Server基础上的，对于图形模式，anaconda需要先运行X服务器，然后启动图形模式安装过程。而对于字符模式，anaconda的主执行体就作了一件事，启动字符模式安装过程。
[python] view plaincopy
  1. if __name__ == "__main__":  
  2.     setupPythonPath()  
  3.   
  4.     # ......  
  5.   
  6.     # 解析启动本脚本时传入的参数  
  7.     (opts, args) = parseOptions()  
  8.     from pyanaconda.flags import flags  
  9.     if opts.images:  
  10.         flags.imageInstall = True  
  11.   
  12.     # 设置log  
  13.     import logging  
  14.     from pyanaconda import anaconda_log  
  15.     anaconda_log.init()  
  16.   
  17.     log = logging.getLogger("anaconda")  
  18.     stdoutLog = logging.getLogger("anaconda.stdout")  
  19.   
  20.     # ......  
  21.   
  22.     from pyanaconda import Anaconda  
  23.     anaconda = Anaconda()   # 创建主执行体实例  
  24.     warnings.showwarning = AnacondaShowWarning  
  25.     iutil.setup_translations(gettext)  
  26.   
  27.     # ......  
  28.   
  29.     # 检测内存，现在只用在文本模式下  
  30.     check_memory(anaconda, opts, 't')  
  31.   
  32.     if opts.unsupportedMode:  
  33.         stdoutLog.error("Running anaconda in %s mode is no longer supported." % opts.unsupportedMode)  
  34.         sys.exit(0)  
  35.   
  36.     # ......  
  37.   
  38.     # kickstart文件解析  
  39.     if opts.ksfile:  
  40.         kickstart.preScriptPass(anaconda, opts.ksfile)  
  41.         anaconda.ksdata = kickstart.parseKickstart(anaconda, opts.ksfile)  
  42.         opts.rescue = opts.rescue or anaconda.ksdata.rescue.rescue  
  43.   
  44.     # ......  
  45.     # 如果没有X server，使用文本模式  
  46.     if not flags.livecdInstall and not iutil.isS390() and not os.access("/usr/bin/Xorg", os.X_OK):  
  47.          stdoutLog.warning(_("Graphical installation is not available. "  
  48.                              "Starting text mode."))  
  49.          time.sleep(2)  
  50.          anaconda.displayMode = 't'  
  51.   
  52.     # ......  
  53.     # 启动本地的X server  
  54.     if anaconda.displayMode == 'g' and not flags.preexisting_x11 and not flags.usevnc:  
  55.         try:  
  56.             # start X with its USR1 handler set to ignore.  this will make it send  
  57.             # us SIGUSR1 if it succeeds.  if it fails, catch SIGCHLD and bomb out.  
  58.   
  59.             def sigchld_handler(num, frame):  
  60.                 raise OSError(0, "SIGCHLD caught when trying to start the X server.")  
  61.   
  62.             def sigusr1_handler(num, frame):  
  63.                 log.debug("X server has signalled a successful start.")  
  64.   
  65.             def preexec_fn():  
  66.                 signal.signal(signal.SIGUSR1, signal.SIG_IGN)  
  67.   
  68.             old_sigusr1 = signal.signal(signal.SIGUSR1, sigusr1_handler)  
  69.             old_sigchld = signal.signal(signal.SIGCHLD, sigchld_handler)  
  70.             xout = open("/dev/tty5", "w")  
  71.   
  72.             # 启动X server  
  73.             proc = subprocess.Popen(["Xorg", "-br", "-logfile", "/tmp/X.log",  
  74.                                      ":1", "vt6", "-s", "1440", "-ac",  
  75.                                      "-nolisten", "tcp", "-dpi", "96",  
  76.                                      "-noreset"],  
  77.                                      close_fds=True, stdout=xout, stderr=xout,  
  78.                                      preexec_fn=preexec_fn)  
  79.   
  80.             signal.pause()  
  81.   
  82.             os.environ["DISPLAY"] = ":1"  
  83.             doStartupX11Actions()  
  84.         except (OSError, RuntimeError) as e:  
  85.             stdoutLog.warning(" X startup failed, falling back to text mode")  
  86.             anaconda.displayMode = 't'  
  87.             graphical_failed = 1  
  88.             time.sleep(2)  
  89.         finally:  
  90.             signal.signal(signal.SIGUSR1, old_sigusr1)  
  91.             signal.signal(signal.SIGCHLD, old_sigchld)  
  92.   
  93.     set_x_resolution(opts.runres)  
  94.   
  95.     # ......  
  96.   
  97.     # 初始化UI界面  
  98.     anaconda.initInterface()  
  99.     anaconda.instClass.configure(anaconda)  
  100.   
  101.     # ......  
  102.   
  103.     # 启动安装过程  
  104.     try:  
  105.         anaconda.intf.run(anaconda)  
  106.     except SystemExit, code:  
  107.         anaconda.intf.shutdown()  
  108.   
  109.     if anaconda.ksdata and anaconda.ksdata.reboot.eject:  
  110.         for drive in anaconda.storage.devicetree.devices:  
  111.             if drive.type != "cdrom":  
  112.                 continue  
  113.   
  114.             log.info("attempting to eject %s" % drive.path)  
  115.             drive.eject()  
  116.   
  117.     del anaconda.intf  
    主要工作包括引用模块路径设置、参数解析、设置log、内存检测、安装类型设置，然后调用pyanaconda/__init__.py::Anaconda类创建主执行体实例anaconda，接着解析kickstart文件，调用/usr/bin/Xorg（位于解开后的install.img中）程序启动X server，调用Anaconda类的initInterface()初始化界面，调用intf（是InstallInterface类的实例）的run()启动安装过程。对于字符安装模式，是直接调用InstallInterface实例的run接口。而对于图形安装模式，则是由InstallInterface实例的run接口间接的调用installcontrolwindow实例的run接口，从而启动图形界面。
    （4）pyanaconda/__init__.py: 里面有Anaconda类，负责具体的启动安装过程。前面说过，安装的流程由Dispatcher控制，对于图形模式，图形模式的前端显示及与用户的交互由InstallControlWindow调度，而字符模式的前端显示层由InstallInterface调度。因此，启动安装过程，实际就是创建主要控制类的实例，调用实例的接口，启动安装过程，然后再由这几个主要的控制类的实例创建具体安装界面，创建安装行为类的实例，调用具体的函数完成具体的安装过程。
[python] view plaincopy
  1. class Anaconda(object):  
  2.     def __init__(self):  
  3.         import desktop, dispatch, firewall, security  
  4.         import system_config_keyboard.keyboard as keyboard  
  5.         from flags import flags  
  6.   
  7.         # ......  
  8.         # 创建dispatch实例  
  9.         self.dispatch = dispatch.Dispatcher(self)  
  10.         # ......  
  11.   
  12.     # ......  
  13.   
  14.     intf = property(_getInterface, _setInterface, _delInterface)  
  15.   
  16.     # ......  
  17.   
  18.     def initInterface(self):  
  19.         if self._intf:  
  20.             raise RuntimeError, "Second attempt to initialize the InstallInterface"  
  21.   
  22.         # 设置图形模式需要的链接  
  23.         if self.displayMode == 'g':  
  24.             stdoutLog.info (_("Starting graphical installation."))  
  25.   
  26.             try:  
  27.                 from gui import InstallInterface  
  28.             except Exception, e:  
  29.                 from flags import flags  
  30.                 stdoutLog.error("Exception starting GUI installer: %s" %(e,))  
  31.                 # if we're not going to really go into GUI mode, we need to get  
  32.                 # back to vc1 where the text install is going to pop up.  
  33.                 if not flags.livecdInstall:  
  34.                     isys.vtActivate (1)  
  35.                 stdoutLog.warning("GUI installer startup failed, falling back to text mode.")  
  36.                 self.displayMode = 't'  
  37.                 if 'DISPLAY' in os.environ.keys():  
  38.                     del os.environ['DISPLAY']  
  39.                 time.sleep(2)  
  40.   
  41.         if self.displayMode == 't':  
  42.             from text import InstallInterface  
  43.             if not os.environ.has_key("LANG"):  
  44.                 os.environ["LANG"] = "en_US.UTF-8"  
  45.   
  46.         if self.displayMode == 'c':  
  47.             from cmdline import InstallInterface  
  48.   
  49.         self._intf = InstallInterface()     # 创建InstallInterface实例  
  50.         return self._intf  
    主要的工作包括创建dispatch实例，初始化界面，创建InstallInterface实例，它最后会创建InstallControlWindow实例，生成图形界面。
    整个Anaconda的运行流程如下图：

图2 Anaconda运行流程