# Copyright 2009 Google Inc. Released under the GPL v2
import re
class boottool(object):
"""
Common class for the client and server side boottool wrappers.
"""
def __init__(self):
self._xen_mode = False
def _run_boottool(self, *options):
"""
Override in derivations to execute the "boottool" command and return
the stdout output in case of success. In case of failure an exception
should be raised.
@param options: a sequence of command line arguments to give to the
boottool command
@return string with the stdout output of the boottool command.
@raise Exception in case of boottool command failure.
"""
raise NotImplementedError('_run_boottool not implemented!')
def get_type(self):
"""
Return the installed bootloader type.
"""
return self._run_boottool('--bootloader-probe').strip()
def get_architecture(self):
"""
Get the system architecture reported by the bootloader.
"""
return self._run_boottool('--arch-probe').strip()
def get_titles(self):
"""
Returns a list of boot entries titles.
"""
return [entry['title'] for entry in self.get_entries().itervalues()]
def get_default(self):
"""
Return an int with the # of the default bootloader entry.
"""
return int(self._run_boottool('--default').strip())
def set_default(self, index):
"""
Set the default boot entry.
@param index: entry index number to set as the default.
"""
assert index is not None
self._run_boottool('--set-default=%s' % index)
def get_default_title(self):
"""
Get the default entry title.
@return a string of the default entry title.
"""
return self.get_entry('default')['title']
def _parse_entry(self, entry_str):
"""
Parse entry as returned by boottool.
@param entry_str: one entry information as returned by boottool
@return: dictionary of key -> value where key is the string before
the first ":" in an entry line and value is the string after
it
"""
entry = {}
for line in entry_str.splitlines():
if len(line) == 0:
continue
name, value = line.split(':', 1)
name = name.strip()
value = value.strip()
if name == 'index':
# index values are integrals
value = int(value)
entry[name] = value
return entry
def get_entry(self, search_info):
"""
Get a single bootloader entry information.
NOTE: if entry is "fallback" and bootloader is grub
use index instead of kernel title ("fallback") as fallback is
a special option in grub
@param search_info: can be 'default', position number or title
@return a dictionary of key->value where key is the type of entry
information (ex. 'title', 'args', 'kernel', etc) and value
is the value for that piece of information.
"""
return self._parse_entry(self._run_boottool('--info=%s' % search_info))
def get_entries(self):
"""
Get all entries information.
@return: a dictionary of index -> entry where entry is a dictionary
of entry information as described for get_entry().
"""
raw = "\n" + self._run_boottool('--info=all')
entries = {}
for entry_str in raw.split("\nindex"):
if len(entry_str.strip()) == 0:
continue
entry = self._parse_entry("index" + entry_str)
entries[entry["index"]] = entry
return entries
def get_title_for_kernel(self, path):
"""
Returns a title for a particular kernel.
@param path: path of the kernel image configured in the boot config
@return: if the given kernel path is found it will return a string
with the title for the found entry, otherwise returns None
"""
entries = self.get_entries()
for entry in entries.itervalues():
if entry.get('kernel') == path:
return entry['title']
return None
def add_args(self, kernel, args):
"""
Add cmdline arguments for the specified kernel.
@param kernel: can be a position number (index) or title
@param args: argument to be added to the current list of args
"""
parameters = ['--update-kernel=%s' % kernel, '--args=%s' % args]
#add parameter if this is a Xen entry
if self._xen_mode:
parameters.append('--xen')
self._run_boottool(*parameters)
def remove_args(self, kernel, args):
"""
Removes specified cmdline arguments.
@param kernel: can be a position number (index) or title
@param args: argument to be removed of the current list of args
"""
parameters = ['--update-kernel=%s' % kernel, '--remove-args=%s' % args]
#add parameter if this is a Xen entry
if self._xen_mode:
parameters.append('--xen')
self._run_boottool(*parameters)
def __remove_duplicate_cmdline_args(self, cmdline):
"""
Remove the duplicate entries in cmdline making sure that the first
duplicate occurances are the ones removed and the last one remains
(this is in order to not change the semantics of the "console"
parameter where the last occurance has special meaning)
@param cmdline: a space separate list of kernel boot parameters
(ex. 'console=ttyS0,57600n8 nmi_watchdog=1')
@return: a space separated list of kernel boot parameters without
duplicates
"""
copied = set()
new_args = []
for arg in reversed(cmdline.split()):
if arg not in copied:
new_args.insert(0, arg)
copied.add(arg)
return ' '.join(new_args)
def add_kernel(self, path, title='autoserv', root=None, args=None,
initrd=None, default=False, position='end',
xen_hypervisor=None):
"""
Add a kernel entry to the bootloader (or replace if one exists
already with the same title).
@param path: string path to the kernel image file
@param title: title of this entry in the bootloader config
@param root: string of the root device
@param args: string with cmdline args
@param initrd: string path to the initrd file
@param default: set to True to make this entry the default one
(default False)
@param position: where to insert the new entry in the bootloader
config file (default 'end', other valid input 'start', or
# of the title)
@param xen_hypervisor: xen hypervisor image file (valid only when
xen mode is enabled)
"""
if title in self.get_titles():
self.remove_kernel(title)
parameters = ['--add-kernel=%s' % path, '--title=%s' % title]
if root:
parameters.append('--root=%s' % root)
if args:
parameters.append('--args=%s' %
self.__remove_duplicate_cmdline_args(args))
if initrd:
parameters.append('--initrd=%s' % initrd)
if default:
parameters.append('--make-default')
if position:
parameters.append('--position=%s' % position)
# add parameter if this is a Xen entry
if self._xen_mode:
parameters.append('--xen')
if xen_hypervisor:
parameters.append('--xenhyper=%s' % xen_hypervisor)
self._run_boottool(*parameters)
def remove_kernel(self, kernel):
"""
Removes a specific entry from the bootloader configuration.
@param kernel: can be 'start', 'end', entry position or entry title.
"""
self._run_boottool('--remove-kernel=%s' % kernel)
def boot_once(self, title=None):
"""
Sets a specific entry for the next boot, then falls back to the
default kernel.
@param kernel: title that identifies the entry to set for booting. If
evaluates to false, this becomes a no-op.
"""
if title:
self._run_boottool('--boot-once', '--title=%s' % title)
def enable_xen_mode(self):
"""
Enables xen mode. Future operations will assume xen is being used.
"""
self._xen_mode = True
def disable_xen_mode(self):
"""
Disables xen mode.
"""
self._xen_mode = False
def get_xen_mode(self):
"""
Returns a boolean with the current status of xen mode.
"""
return self._xen_mode