y += 1                    lines.append(ret)                    continue                # if we got boot, then we want to boot the entered image                 img = grub.GrubConf.GrubImage(lines)                self.cf.add_image(img)                self.selected_image = len(self.cf.images) - 1                self.isdone = True                break            # else, we cancelled and should just go back            break    def read_config(self, fn, fs = None):        """Read the given file to parse the config.  If fs = None, then        we're being given a raw config file rather than a disk image."""                if not os.access(fn, os.R_OK):            raise RuntimeError, "Unable to access %s" %(fn,)        if platform.machine() == 'ia64':            self.cf = grub.LiloConf.LiloConfigFile()            # common distributions            file_list = ("/efi/debian/elilo.conf", "/efi/gentoo/elilo.conf",                          "/efi/redflag/elilo.conf", "/efi/redhat/elilo.conf",                          "/efi/SuSE/elilo.conf",)            # fallbacks            file_list += ("/efi/boot/elilo.conf", "/elilo.conf",)        else:            self.cf = grub.GrubConf.GrubConfigFile()            file_list = ("/boot/grub/menu.lst", "/boot/grub/grub.conf",                         "/grub/menu.lst", "/grub/grub.conf")        if not fs:            # set the config file and parse it            self.cf.filename = fn            self.cf.parse()            return        for f in file_list:            if fs.file_exists(f):                self.cf.filename = f                break        if self.cf.filename is None:            raise RuntimeError, "couldn't find bootloader config file in the image provided."        f = fs.open_file(self.cf.filename)        buf = f.read()        del f        self.cf.parse(buf)    def run(self):        timeout = int(self.cf.timeout)        self.selected_image = self.cf.default        self.isdone = False        while not self.isdone:            self.run_main(timeout)            timeout = -1                    return self.selected_image    def run_main(self, timeout = -1):        def draw():            # set up the screen            self.draw_main_windows()            self.text_win.addstr(0, 0, "Use the U and D keys to select which entry is highlighted.")            self.text_win.addstr(1, 0, "Press enter to boot the selected OS. 'e' to edit the")            self.text_win.addstr(2, 0, "commands before booting, 'a' to modify the kernel arguments ")            self.text_win.addstr(3, 0, "before booting, or 'c' for a command line.")            self.text_win.addch(0, 8, curses.ACS_UARROW)            self.text_win.addch(0, 14, curses.ACS_DARROW)            (y, x) = self.text_win.getmaxyx()            self.text_win.move(y - 1, x - 1)            self.text_win.refresh()        # now loop until we hit the timeout or get a go from the user        mytime = 0        self.start_image = 0        while (timeout == -1 or mytime < int(timeout)):            draw()            if timeout != -1 and mytime != -1:                 self.screen.addstr(20, 5, "Will boot selected entry in %2d seconds"                                   %(int(timeout) - mytime))            else:                self.screen.addstr(20, 5, " " * 80)            self.fill_entry_list()            c = self.screen.getch()            if c == -1:                # Timed out waiting for a keypress                if mytime != -1:                    mytime += 1                    if mytime >= int(timeout):                        self.isdone = True                        break            else:                # received a keypress: stop the timer                mytime = -1                self.screen.timeout(-1)            # handle keypresses            if c == ord('c'):                self.command_line_mode()                break            elif c == ord('a'):                # find the kernel line, edit it and then boot                img = self.cf.images[self.selected_image]                for line in img.lines:                    if line.startswith("kernel"):                        l = self.edit_line(line)                        if l is not None:                            img.set_from_line(l, replace = True)                            self.isdone = True                            break                break            elif c == ord('e'):                img = self.cf.images[self.selected_image]                self.edit_entry(img)                break            elif c in (curses.KEY_ENTER, ord('\n'), ord('\r')):                self.isdone = True                break            elif c == curses.KEY_UP:                self.selected_image -= 1            elif c == curses.KEY_DOWN:                self.selected_image += 1#            elif c in (ord('q'), 27): # 27 == esc#                self.selected_image = -1#                self.isdone = True#                break            # bound at the top and bottom            if self.selected_image < 0:                self.selected_image = 0            elif self.selected_image >= len(self.cf.images):                self.selected_image = len(self.cf.images) - 1        def get_entry_idx(cf, entry):    # first, see if the given entry is numeric    try:        idx = string.atoi(entry)        return idx    except ValueError:        pass    # it's not, now check the labels for a match    for i in range(len(cf.images)):        if entry == cf.images[i].title:            return i    return Nonedef run_grub(file, entry, fs):    global g    global sel    def run_main(scr, *args):        global sel        global g        sel = g.run()    g = Grub(file, fs)    if interactive:        curses.wrapper(run_main)    else:        sel = g.cf.default    # set the entry to boot as requested    if entry is not None:        idx = get_entry_idx(g.cf, entry)        if idx is not None and idx > 0 and idx < len(g.cf.images):           sel = idx    if sel == -1:        print "No kernel image selected!"        sys.exit(1)    img = g.cf.images[sel]    grubcfg = { "kernel": None, "ramdisk": None, "args": None }    grubcfg["kernel"] = img.kernel[1]    if img.initrd:        grubcfg["ramdisk"] = img.initrd[1]    if img.args:        grubcfg["args"] = img.args    return grubcfg# If nothing has been specified, look for a Solaris domU. If found, perform the# necessary tweaks.def sniff_solaris(fs, cfg):    if not fs.file_exists("/platform/i86xpv/kernel/unix"):        return cfg        # darned python    longmode = (sys.maxint != 2147483647L)    if not longmode:        longmode = os.uname()[4] == "x86_64"    if not longmode:        if (os.access("/usr/bin/isainfo", os.R_OK) and            os.popen("/usr/bin/isainfo -b").read() == "64\n"):            longmode = True    if not cfg["kernel"]:        cfg["kernel"] = "/platform/i86xpv/kernel/unix"        cfg["ramdisk"] = "/platform/i86pc/boot_archive"        if longmode:            cfg["kernel"] = "/platform/i86xpv/kernel/amd64/unix"            cfg["ramdisk"] = "/platform/i86pc/amd64/boot_archive"    # Unpleasant. Typically we'll have 'root=foo -k' or 'root=foo /kernel -k',    # and we need to maintain Xen properties (root= and ip=) and the kernel    # before any user args.        xenargs = ""    userargs = ""        if not cfg["args"]:        cfg["args"] = cfg["kernel"]    else:        for arg in cfg["args"].split():            if re.match("^root=", arg) or re.match("^ip=", arg):                xenargs += arg + " "            elif arg != cfg["kernel"]:                userargs += arg + " "        cfg["args"] = xenargs + " " + cfg["kernel"] + " " + userargs    return cfg if __name__ == "__main__":    sel = None        def usage():        print >> sys.stderr, "Usage: %s [-q|--quiet] [-i|--interactive] [--output=] [--kernel=] [--ramdisk=] [--args=] [--entry=] <image>" %(sys.argv[0],)    try:        opts, args = getopt.gnu_getopt(sys.argv[1:], 'qih::',                                   ["quiet", "interactive", "help", "output=",                                    "entry=", "kernel=", "ramdisk=", "args=",                                    "isconfig"])    except getopt.GetoptError:        usage()        sys.exit(1)    if len(args) < 1:        usage()        sys.exit(1)    file = args[0]            output = None    entry = None    interactive = True    isconfig = False    # what was passed in    incfg = { "kernel": None, "ramdisk": None, "args": None }    # what grub or sniffing chose    chosencfg = { "kernel": None, "ramdisk": None, "args": None }    # what to boot    bootcfg = { "kernel": None, "ramdisk": None, "args": None }    for o, a in opts:        if o in ("-q", "--quiet"):            interactive = False        elif o in ("-i", "--interactive"):            interactive = True        elif o in ("-h", "--help"):            usage()            sys.exit()        elif o in ("--output",):            output = a        elif o in ("--kernel",):            incfg["kernel"] = a        elif o in ("--ramdisk",):            incfg["ramdisk"] = a        elif o in ("--args",):            incfg["args"] = a        elif o in ("--entry",):            entry = a            # specifying the entry to boot implies non-interactive            interactive = False        elif o in ("--isconfig",):            isconfig = True    if output is None or output == "-":        fd = sys.stdout.fileno()    else:        fd = os.open(output, os.O_WRONLY)    # debug    if isconfig:        chosencfg = run_grub(file, entry)        print "  kernel: %s" % chosencfg["kernel"]        if img.initrd:            print "  initrd: %s" % chosencfg["ramdisk"]        print "  args: %s" % chosencfg["args"]        sys.exit(0)    # if boot filesystem is set then pass to fsimage.open    bootfsargs = '"%s"' % incfg["args"]    bootfsgroup = re.findall('zfs-bootfs=(.*?)[\s\,\"]', bootfsargs)    if bootfsgroup:        fs = fsimage.open(file, get_fs_offset(file), bootfsgroup[0])    else:        fs = fsimage.open(file, get_fs_offset(file))    chosencfg = sniff_solaris(fs, incfg)    if not chosencfg["kernel"]:        chosencfg = run_grub(file, entry, fs)    data = fs.open_file(chosencfg["kernel"]).read()    (tfd, bootcfg["kernel"]) = tempfile.mkstemp(prefix="boot_kernel.",        dir="/var/run/xend/boot")    os.write(tfd, data)    os.close(tfd)    if chosencfg["ramdisk"]:        data = fs.open_file(chosencfg["ramdisk"],).read()        (tfd, bootcfg["ramdisk"]) = tempfile.mkstemp(prefix="boot_ramdisk.",            dir="/var/run/xend/boot")        os.write(tfd, data)        os.close(tfd)    else:        initrd = None    sxp = "linux (kernel %s)" % bootcfg["kernel"]    if bootcfg["ramdisk"]:        sxp += "(ramdisk %s)" % bootcfg["ramdisk"]    if chosencfg["args"]:        zfsinfo = fsimage.getbootstring(fs)        if zfsinfo is None:            sxp += "(args \"%s\")" % chosencfg["args"]        else:            e = re.compile("zfs-bootfs=[\w\-\.\:@/]+" )            (chosencfg["args"],count) = e.subn(zfsinfo, chosencfg["args"])            if count == 0:               chosencfg["args"] += " -B %s" % zfsinfo            sxp += "(args \"%s\")" % (chosencfg["args"])    sys.stdout.flush()    os.write(fd, sxp)