Revert "Merge remote branch 'cros/upstream' into autotest-rebase"

client/tests/kvm/scripts/unattended.py

 #!/usr/bin/python
 """
 Simple script to setup unattended installs on KVM guests.
 """
 # -*- coding: utf-8 -*-
 import os, sys, shutil, tempfile, re, ConfigParser, glob, inspect
 import common
 
 
 SCRIPT_DIR = os.path.dirname(sys.modules[__name__].__file__)
@@ skipping 224 matching lines @@
         run(g_cmd, info='Could not generate iso with answer file')
 
         os.chmod(self.path, 0755)
         cleanup(self.mount)
         print "Disk %s successfuly set" % self.path
 
 
 class UnattendedInstall(object):
     """
     Creates a floppy disk image that will contain a config file for unattended
-    OS install. The parameters to the script are retrieved from environment
-    variables.
+    OS install. Optionally, sets up a PXE install server using qemu built in
+    TFTP and DHCP servers to install a particular operating system. The
+    parameters to the script are retrieved from environment variables.
     """
     def __init__(self):
         """
         Gets params from environment variables and sets class attributes.
         """
         images_dir = os.path.join(KVM_TEST_DIR, 'images')
         self.deps_dir = os.path.join(KVM_TEST_DIR, 'deps')
         self.unattended_dir = os.path.join(KVM_TEST_DIR, 'unattended')
 
         attributes = ['kernel_args', 'finish_program', 'cdrom_cd1',
                       'unattended_file', 'medium', 'url', 'kernel', 'initrd',
-                      'nfs_server', 'nfs_dir', 'install_virtio', 'floppy',
-                      'cdrom_unattended', 'boot_path', 'extra_params']
-
+                      'nfs_server', 'nfs_dir', 'pxe_dir', 'pxe_image',
+                      'pxe_initrd', 'install_virtio', 'tftp',
+                      'floppy', 'cdrom_unattended']
         for a in attributes:
             self._setattr(a)
 
         if self.install_virtio == 'yes':
             v_attributes = ['virtio_floppy', 'virtio_storage_path',
                             'virtio_network_path', 'virtio_oemsetup_id',
                             'virtio_network_installer']
             for va in v_attributes:
                 self._setattr(va)
 
+        # Silly attribution just to calm pylint down...
+        self.tftp = self.tftp
+        if self.tftp:
+            self.tftp = os.path.join(KVM_TEST_DIR, self.tftp)
+            if not os.path.isdir(self.tftp):
+                os.makedirs(self.tftp)
+
         if self.cdrom_cd1:
             self.cdrom_cd1 = os.path.join(KVM_TEST_DIR, self.cdrom_cd1)
         self.cdrom_cd1_mount = tempfile.mkdtemp(prefix='cdrom_cd1_', dir='/tmp')
         if self.medium == 'nfs':
             self.nfs_mount = tempfile.mkdtemp(prefix='nfs_', dir='/tmp')
 
         if self.floppy:
             self.floppy = os.path.join(KVM_TEST_DIR, self.floppy)
             if not os.path.isdir(os.path.dirname(self.floppy)):
                 os.makedirs(os.path.dirname(self.floppy))
 
-        self.image_path = os.path.dirname(self.kernel)
+        self.image_path = KVM_TEST_DIR
+        self.kernel_path = os.path.join(self.image_path, self.kernel)
+        self.initrd_path = os.path.join(self.image_path, self.initrd)
 
 
     def _setattr(self, key):
         """
         Populate class attributes with contents of environment variables.
 
         Example: KVM_TEST_medium will populate self.medium.
 
         @param key: Name of the class attribute we desire to have.
         """
@@ skipping 98 matching lines @@
             if self.cdrom_unattended:
                 boot_disk = CdromDisk(self.cdrom_unattended)
             elif self.floppy:
                 boot_disk = FloppyDisk(self.floppy)
             else:
                 raise SetupError("Neither cdrom_unattended nor floppy set "
                                  "on the config file, please verify")
             boot_disk.setup_answer_file(dest_fname, answer_contents)
 
         elif self.unattended_file.endswith('.xml'):
-            if "autoyast" in self.extra_params:
+            if self.tftp:
                 # SUSE autoyast install
                 dest_fname = "autoinst.xml"
                 if self.cdrom_unattended:
                     boot_disk = CdromDisk(self.cdrom_unattended)
                 elif self.floppy:
                     boot_disk = FloppyDisk(self.floppy)
                 else:
                     raise SetupError("Neither cdrom_unattended nor floppy set "
                                      "on the config file, please verify")
                 boot_disk.setup_answer_file(dest_fname, answer_contents)
 
             else:
                 # Windows unattended install
                 dest_fname = "autounattend.xml"
                 boot_disk = FloppyDisk(self.floppy)
                 boot_disk.setup_answer_file(dest_fname, answer_contents)
                 if self.install_virtio == "yes":
                     boot_disk.setup_virtio_win2008(self.virtio_floppy)
                 boot_disk.copy_to(self.finish_program)
 
         else:
             raise SetupError('Unknown answer file %s' %
                              self.unattended_file)
 
         boot_disk.close()
 
 
-    def setup_cdrom(self):
+    def setup_pxe_boot(self):
         """
-        Mount cdrom and copy vmlinuz and initrd.img.
+        Sets up a PXE boot environment using the built in qemu TFTP server.
+        Copies the PXE Linux bootloader pxelinux.0 from the host (needs the
+        pxelinux package or equivalent for your distro), and vmlinuz and
+        initrd.img files from the CD to a directory that qemu will serve trough
+        TFTP to the VM.
         """
-        print "Copying vmlinuz and initrd.img from cdrom"
-        m_cmd = ('mount -t iso9660 -v -o loop,ro %s %s' %
-                 (self.cdrom_cd1, self.cdrom_cd1_mount))
-        run(m_cmd, info='Could not mount CD image %s.' % self.cdrom_cd1)
+        print "Setting up PXE boot using TFTP root %s" % self.tftp
+
+        pxe_file = None
+        pxe_paths = ['/usr/lib/syslinux/pxelinux.0',
+                     '/usr/share/syslinux/pxelinux.0']
+        for path in pxe_paths:
+            if os.path.isfile(path):
+                pxe_file = path
+                break
+
+        if not pxe_file:
+            raise SetupError('Cannot find PXE boot loader pxelinux.0. Make '
+                             'sure pxelinux or equivalent package for your '
+                             'distro is installed.')
+
+        pxe_dest = os.path.join(self.tftp, 'pxelinux.0')
+        shutil.copyfile(pxe_file, pxe_dest)
 
         try:
-            img_path_cmd = ("mkdir -p %s" % self.image_path)
-            run(img_path_cmd, info=("Could not create image path dir %s" %
-                                    self.image_path))
-            kernel_fetch_cmd = ("cp %s/%s/%s %s" %
-                                (self.cdrom_cd1_mount, self.boot_path,
-                                 os.path.basename(self.kernel), self.kernel))
-            run(kernel_fetch_cmd, info=("Could not copy the vmlinuz from %s" %
-                                        self.cdrom_cd1_mount))
-            initrd_fetch_cmd = ("cp %s/%s/%s %s" %
-                                (self.cdrom_cd1_mount, self.boot_path,
-                                 os.path.basename(self.initrd), self.initrd))
-            run(initrd_fetch_cmd, info=("Could not copy the initrd.img from "
-                                        "%s" % self.cdrom_cd1_mount))
+            m_cmd = ('mount -t iso9660 -v -o loop,ro %s %s' %
+                     (self.cdrom_cd1, self.cdrom_cd1_mount))
+            run(m_cmd, info='Could not mount CD image %s.' % self.cdrom_cd1)
+
+            pxe_dir = os.path.join(self.cdrom_cd1_mount, self.pxe_dir)
+            pxe_image = os.path.join(pxe_dir, self.pxe_image)
+            pxe_initrd = os.path.join(pxe_dir, self.pxe_initrd)
+
+            if not os.path.isdir(pxe_dir):
+                raise SetupError('The ISO image does not have a %s dir. The '
+                                 'script assumes that the cd has a %s dir '
+                                 'where to search for the vmlinuz image.' %
+                                 (self.pxe_dir, self.pxe_dir))
+
+            if not os.path.isfile(pxe_image) or not os.path.isfile(pxe_initrd):
+                raise SetupError('The location %s is lacking either a vmlinuz '
+                                 'or a initrd.img file. Cannot find a PXE '
+                                 'image to proceed.' % self.pxe_dir)
+
+            tftp_image = os.path.join(self.tftp, 'vmlinuz')
+            tftp_initrd = os.path.join(self.tftp, 'initrd.img')
+            shutil.copyfile(pxe_image, tftp_image)
+            shutil.copyfile(pxe_initrd, tftp_initrd)
+
         finally:
             cleanup(self.cdrom_cd1_mount)
 
+        pxe_config_dir = os.path.join(self.tftp, 'pxelinux.cfg')
+        if not os.path.isdir(pxe_config_dir):
+            os.makedirs(pxe_config_dir)
+        pxe_config_path = os.path.join(pxe_config_dir, 'default')
+
+        pxe_config = open(pxe_config_path, 'w')
+        pxe_config.write('DEFAULT pxeboot\n')
+        pxe_config.write('TIMEOUT 20\n')
+        pxe_config.write('PROMPT 0\n')
+        pxe_config.write('LABEL pxeboot\n')
+        pxe_config.write('     KERNEL vmlinuz\n')
+        pxe_config.write('     APPEND initrd=initrd.img %s\n' %
+                         self.kernel_args)
+        pxe_config.close()
+
+        print "PXE boot successfuly set"
+
 
     def setup_url(self):
         """
         Download the vmlinuz and initrd.img from URL.
         """
-        print "Downloading vmlinuz and initrd.img from URL"
+        print "Downloading the vmlinuz and initrd.img"
         os.chdir(self.image_path)
 
-        kernel_fetch_cmd = "wget -q %s/%s/%s" % (self.url, self.boot_path,
-                                                 os.path.basename(self.kernel))
-        initrd_fetch_cmd = "wget -q %s/%s/%s" % (self.url, self.boot_path,
-                                                 os.path.basename(self.initrd))
+        kernel_fetch_cmd = "wget -q %s/isolinux/%s" % (self.url, self.kernel)
+        initrd_fetch_cmd = "wget -q %s/isolinux/%s" % (self.url, self.initrd)
 
         if os.path.exists(self.kernel):
             os.unlink(self.kernel)
         if os.path.exists(self.initrd):
             os.unlink(self.initrd)
 
         run(kernel_fetch_cmd, info="Could not fetch vmlinuz from %s" % self.url)
         run(initrd_fetch_cmd, info=("Could not fetch initrd.img from %s" %
                                     self.url))
+        print "Download of vmlinuz and initrd.img finished"
 
 
     def setup_nfs(self):
         """
         Copy the vmlinuz and initrd.img from nfs.
         """
         print "Copying the vmlinuz and initrd.img from nfs"
 
         m_cmd = ("mount %s:%s %s -o ro" %
                  (self.nfs_server, self.nfs_dir, self.nfs_mount))
         run(m_cmd, info='Could not mount nfs server')
 
         try:
-            kernel_fetch_cmd = ("cp %s/%s/%s %s" %
-                                (self.nfs_mount, self.boot_path,
-                                os.path.basename(self.kernel), self.image_path))
+            kernel_fetch_cmd = ("cp %s/isolinux/%s %s" %
+                                (self.nfs_mount, self.kernel, self.image_path))
             run(kernel_fetch_cmd, info=("Could not copy the vmlinuz from %s" %
                                         self.nfs_mount))
-            initrd_fetch_cmd = ("cp %s/%s/%s %s" %
-                                (self.nfs_mount, self.boot_path,
-                                os.path.basename(self.initrd), self.image_path))
+            initrd_fetch_cmd = ("cp %s/isolinux/%s %s" %
+                                (self.nfs_mount, self.initrd, self.image_path))
             run(initrd_fetch_cmd, info=("Could not copy the initrd.img from "
                                         "%s" % self.nfs_mount))
         finally:
             cleanup(self.nfs_mount)
 
 
     def setup(self):
         """
         Configure the environment for unattended install.
 
         Uses an appropriate strategy according to each install model.
         """
         print "Starting unattended install setup"
         print
 
         print "Variables set:"
         for member in inspect.getmembers(self):
             name, value = member
             attribute = getattr(self, name)
             if not (name.startswith("__") or callable(attribute) or not value):
                 print "    %s: %s" % (name, value)
         print
 
         if self.unattended_file and (self.floppy or self.cdrom_unattended):
             self.setup_boot_disk()
         if self.medium == "cdrom":
-            if self.kernel and self.initrd:
-                self.setup_cdrom()
+            if self.tftp:
+                self.setup_pxe_boot()
         elif self.medium == "url":
             self.setup_url()
         elif self.medium == "nfs":
             self.setup_nfs()
         else:
             raise SetupError("Unexpected installation method %s" %
                              self.medium)
         print "Unattended install setup finished successfuly"
 
 
 if __name__ == "__main__":
     os_install = UnattendedInstall()
     os_install.setup()