def boot(self):
if self.host.productVersion.endswith("-x64"):
arch = "amd64"
else:
arch = "x86"
# Construct a PXE target
pxe1 = xenrt.PXEBoot()
serport = self.host.lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = self.host.lookup("SERIAL_CONSOLE_BAUD", "115200")
pxe1.setSerial(serport, serbaud)
pxe2 = xenrt.PXEBoot()
serport = self.host.lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = self.host.lookup("SERIAL_CONSOLE_BAUD", "115200")
pxe2.setSerial(serport, serbaud)
pxe1.addEntry("ipxe", boot="ipxe")
pxe1.setDefault("ipxe")
pxe1.writeOut(self.host.machine)
winpe = pxe2.addEntry("winpe", boot="memdisk")
winpe.setInitrd("%s/tftp/winpe/winpe-%s.iso" %
(xenrt.TEC().lookup("LOCALURL"), arch))
winpe.setArgs("iso raw")
pxe2.setDefault("winpe")
filename = pxe2.writeOut(self.host.machine, suffix="_ipxe")
ipxescript = """set 209:string pxelinux.cfg/%s
chain tftp://${next-server}/%s
""" % (os.path.basename(filename), xenrt.TEC().lookup("PXELINUX_PATH",
"pxelinux.0"))
pxe2.writeIPXEConfig(self.host.machine, ipxescript)
self.host.machine.powerctl.cycle()
xenrt.sleep(60)
self.waitForBoot()
def run(self, arglist):
pxe = xenrt.PXEBoot()
pxe.copyIn("%s/%s.c32" % (xenrt.TEC().getWorkdir(), self.TEST))
entry = pxe.addEntry(self.TEST, boot="linux")
entry.linuxSetKernel("%s.c32" % (self.TEST))
pxe.setDefault(self.TEST)
pxe.writeOut(None, forcemac=self.testmac)
self.testguest.lifecycleOperation("vm-start")
self.testguest.poll("UP", pollperiod=5)
domainid = self.testguest.getDomid()
xenrt.TEC().logverbose("Waiting for test to complete...")
time.sleep(30)
self.testguest.shutdown(force=True)
results = {}
data = self.host.execdom0("cat %s/console.%s.log" %
(xenrt.TEC().lookup("GUEST_CONSOLE_LOGDIR"),
domainid))
file("%s/%s.out" % (xenrt.TEC().getLogdir(), self.TEST), "w").write(data)
data = filter(re.compile("XenTest").search, data.split("boot:"))
for item in data:
testname = re.search("XenTest: (?P<test>.*)", item).group("test").strip()
results[testname] = item.strip()
for key in results:
failure = re.search("FAIL .*", results[key])
if failure:
raise xenrt.XRTFailure("XenTest subcase %s failed: %s" %
(key, failure.group()))
def createPXEFileForMac(self, mac):
pxe = xenrt.PXEBoot(abspath=True, removeOnExit=True)
pxecfg = pxe.addEntry("cleanrd", default=1, boot="linux")
barch = self.pool.master.getBasicArch()
pxecfg.linuxSetKernel("clean/vmlinuz-xenrt-%s" % (barch))
pxecfg.linuxArgsKernelAdd("root=/dev/ram0")
pxecfg.linuxArgsKernelAdd("console=tty0")
pxecfg.linuxArgsKernelAdd("maxcpus=1")
pxecfg.linuxArgsKernelAdd("console=ttyS0,115200n8")
pxecfg.linuxArgsKernelAdd("ramdisk_size=%d" % (self.RAMDISK_SIZE))
pxecfg.linuxArgsKernelAdd("ro")
pxecfg.linuxArgsKernelAdd("initrd=clean/cleanroot-%s.img.gz" % (barch))
pxefile = pxe.writeOut(None, forcemac=mac)
def install(self,
cd=None,
primarydisk=None,
guestdisks=["sda"],
source="url",
timezone="UTC",
interfaces=[(None, "yes", "dhcp", None, None, None)],
ntpserver=None,
nameserver=None,
hostname=None,
installSRType=None,
bootloader=None,
overlay=None,
suppackcds=None):
xenrt.TEC().progress("Installing ESXi %s" % self.esxiVersion)
workdir = xenrt.TEC().getWorkdir()
# Get a PXE directory to put boot files in
pxe = xenrt.PXEBoot()
# Create an NFS directory for images, signals, etc.
nfsdir = xenrt.NFSDirectory()
isoname = "/usr/groups/xenrt/esx/ESXi-%s.iso" % self.esxiVersion
esxiso = xenrt.TEC().getFile(isoname)
if not esxiso:
raise xenrt.XRTError("Couldn't find ISO %s" % (isoname))
mount = xenrt.rootops.MountISO(esxiso)
mountpoint = mount.getMount()
pxe.copyIn("%s/*" % (mountpoint))
# create kickstart file
ksname = "kickstart-%s.cfg" % (self.getName())
kspath = "%s/%s" % (workdir, ksname)
ks = file(kspath, "w")
kstext = """
vmaccepteula
rootpw %s
clearpart --alldrives --overwritevmfs
install --firstdisk --overwritevmfs
network --bootproto=dhcp --device=vmnic0
%%firstboot --interpreter=busybox
vim-cmd hostsvc/enable_ssh
vim-cmd hostsvc/start_ssh
vim-cmd hostsvc/enable_esx_shell
vim-cmd hostsvc/start_esx_shell
esxcli system settings advanced set -o /UserVars/SuppressShellWarning -i 1
esxcli network firewall set --enabled false
esxcli network vswitch standard policy security set --allow-promiscuous true -v vSwitch0
esxcli system settings advanced set -i 1 -o /Misc/LogToSerial
esxcli system settings advanced set -i 115200 -o /Misc/SerialBaudRate
esxcli system settings advanced set -i 1 -o /Misc/DebugLogToSerial
esxcli system settings advanced set -s NONE -o /Misc/LogPort
esxcli system settings advanced set -s COM1 -o /Misc/LogPort
%%post --interpreter=busybox
exec < /dev/console > /dev/console 2> /dev/console
touch /vmfs/volumes/remote-install-location/.xenrtsuccess
sleep 30
reboot
""" % xenrt.TEC().lookup("ROOT_PASSWORD")
ks.write(kstext)
ks.close()
nfsdir.copyIn(kspath)
xenrt.TEC().copyToLogDir(kspath, target=ksname)
# tweak mboot config file
origbootcfg = file("%s/%s" % (mountpoint, "boot.cfg"), "r")
bootcfgpath = "%s/%s" % (workdir, "boot.cfg")
bootcfg = file(bootcfgpath, "w")
bootcfgtext = origbootcfg.read()
bootcfgtext = re.sub(r"/", r"",
bootcfgtext) # get rid of all absolute paths...
bootcfgtext += "prefix=%s" % pxe.makeBootPath(
"") # ... and use our PXE path as a prefix instead
bootcfgtext = re.sub(
r"--- useropts\.gz", r"", bootcfgtext
) # this file seems to cause only trouble, and getting rid of it seems to have no side effects...
bootcfgtext = re.sub(r"--- jumpstrt\.gz", r"",
bootcfgtext) # this file (in ESXi 5.5) is similar
if self.esxiVersion < "5.5":
deferToolsPackInstallation = False
else:
bootcfgtext2 = re.sub(
r"--- tools.t00", r"", bootcfgtext
) # this file is too large to get over netboot from atftpd (as used in CBGLAB01), so we will install it after host-installation
deferToolsPackInstallation = (bootcfgtext2 <> bootcfgtext)
bootcfgtext = bootcfgtext2
bootcfgtext = re.sub(
r"(kernelopt=.*)", r"\1 debugLogToSerial=1 logPort=com1 ks=%s" %
("nfs://%s%s" % (nfsdir.getHostAndPath(ksname))), bootcfgtext)
bootcfg.write(bootcfgtext)
bootcfg.close()
origbootcfg.close()
# remove the old boot.cfg (as it is read-only, it won't let you update in place)
os.remove(os.path.join(pxe.path(), "boot.cfg"))
pxe.copyIn(bootcfgpath)
xenrt.TEC().copyToLogDir(bootcfgpath,
target="bootcfg-%s.cfg" % (self.getName()))
# add boot entry
# NB: we are not actually booting a linux kernel
pxecfg = pxe.addEntry("esx", default=1, boot="linux")
pxecfg.linuxSetKernel("mboot.c32")
pxecfg.linuxArgsKernelAdd("-c %s" % pxe.makeBootPath("boot.cfg"))
chain = self.getChainBoot()
if chain:
pxe.addEntry("local", boot="chainlocal", options=chain)
else:
pxe.addEntry("local", boot="local")
# Set up PXE for installer boot
pxefile = pxe.writeOut(self.machine)
pfname = os.path.basename(pxefile)
xenrt.TEC().copyToLogDir(pxefile, target="%s.pxe.txt" % (pfname))
# Reboot the host into the installer
self.machine.powerctl.cycle()
xenrt.TEC().progress("Rebooted host to start installation.")
# Monitor for installation complete
xenrt.waitForFile("%s/.xenrtsuccess" % (nfsdir.path()),
1800,
desc="Installer boot on !%s" % (self.getName()))
# Boot the local disk - we need to update this before the machine
# reboots after setting the signal flag.
pxe.setDefault("local")
pxe.writeOut(self.machine)
xenrt.sleep(30)
self.waitForSSH(900, desc="Host boot (!%s)" % (self.getName()))
# If we skipped tools.t00 above due to tftp issues, install it now. It's just a .tar.gz file.
if deferToolsPackInstallation:
xenrt.TEC().progress("Manually installing tools.t00")
toolsFile = "%s/tools.t00" % (mountpoint)
# Use the first-named datastore to temporarily dump the file. (Alternatively, could use /tardisks?)
firstDatastore = self.getDefaultDatastore()
destFilePath = "/vmfs/volumes/%s/tools.t00" % (firstDatastore)
sftp = self.sftpClient()
try:
sftp.copyTo(toolsFile, destFilePath)
finally:
sftp.close()
self.execdom0("tar xvfz %s -C /locker/packages" % (destFilePath))
self.execdom0("rm -f %s" % (destFilePath))
# We're done with the ISO now
mount.unmount()
nfsdir.remove()
self.installSRType = installSRType
xenrt.TEC().progress("Completed installation of ESXi host")
def installWindows(self, version, build, arch):
self.windows = True
if not os.path.exists(
"%s/%s/%s/autoinstall-%s.zip" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch)):
if not os.path.exists(
"%s/%s/%s/autoinstall-%s.tar" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch)):
raise xenrt.XRTError("No install files found for %s build %s" %
(version, build))
if version == "longhorn" or version[0:7] == "vistaee":
method = "longhorn"
else:
method = "normal"
self.distro = version
xenrt.TEC().progress("Preparing TFTP...")
tftp = "%s/xenrt/native" % (xenrt.TEC().lookup("TFTP_BASE"))
if not os.path.exists(tftp):
xenrt.sudo("mkdir -p %s" % (tftp))
xenrt.getTestTarball("native", extract=True)
xenrt.sudo("rsync -avxl %s/winpe32.wim %s/winpe.wim" %
(xenrt.TEC().lookup("IMAGES_ROOT"), tftp))
# Get a PXE directory to put boot files in.
xenrt.TEC().progress("Preparing PXE...")
serport = xenrt.TEC().lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = xenrt.TEC().lookup("SERIAL_CONSOLE_BAUD", "115200")
pxe = xenrt.PXEBoot()
pxe.copyIn("%s/native/pxe/pxeboot.0" % (xenrt.TEC().getWorkdir()))
xenrt.sudo("rsync -avxl %s/native/pxe/32/BCD %s/BCD" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/native/pxe/boot.sdi %s/boot.sdi" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/native/pxe/bootmgr.exe %s/bootmgr.exe" %
(xenrt.TEC().getWorkdir(), tftp))
# Set the boot files and options for PXE
pxe.setSerial(serport, serbaud)
pxe.addEntry("local", boot="local")
pxecfg = pxe.addEntry("winpe", default=1, boot="linux")
pxecfg.linuxSetKernel("pxeboot.0")
xenrt.TEC().progress("Preparing web directory")
w = xenrt.WebDirectory()
f = file("%s/native/pe/perun.cmd" % (xenrt.TEC().getWorkdir()), "r")
perun = f.read()
f.close()
if method == "longhorn":
t = xenrt.TempDirectory()
xenrt.command("tar xf %s/%s/%s/autoinstall-%s.tar -C %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
w.copyIn("%s/install/unattend.xml" % (t.path()))
perun += "wget %FILES%/unattend.xml\n"
# Count the number of install.wim fragments.
catcmd = "cat "
partpath = "%s/install/install.part" % (t.path())
numparts = len(glob.glob("%s*" % (partpath)))
for i in range(1, numparts + 1):
# Download install.wim fragment.
perun += "wget %%FILES%%/%s%d\n" % (os.path.basename(partpath),
i)
# Make sure fragments get recombined.
catcmd += "%s%d " % (os.path.basename(partpath), i)
# Make fragment available over the network.
w.copyIn("%s%d" % (partpath, i))
catcmd += "> c:\\win\\sources\\install.wim\n"
perun += catcmd
w.copyIn("%s/install/install.zip" % (t.path()), target="win.zip")
t.remove()
# 32-bit installs just require the one stage.
if arch == "x86-32":
perun += "c:\\win\\sources\\setup.exe /unattend:c:\\unattend.xml"
else:
t = xenrt.TempDirectory()
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip unattend.txt -d %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch,
t.path()))
try:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip runonce.cmd -d %s" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch,
t.path()))
except:
try:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip win/i386/runonce.cmd -d %s"
% (xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
except:
xenrt.command(
"unzip %s/%s/%s/autoinstall-%s.zip win/I386/runonce.cmd -d %s"
% (xenrt.TEC().lookup("IMAGES_ROOT"), version, build,
arch, t.path()))
xenrt.command("mv %s/win/?386/runonce.cmd %s/runonce.cmd" %
(t.path(), t.path()))
xenrt.command("chmod a+rwx %s/runonce.cmd" % (t.path()))
perun += """
wget %FILES%/runonce.cmd
wget %FILES%/unattend.txt
bootsect /nt52 c: /force
c:\win\i386\winnt32.exe /makelocalsource /syspart:c: /s:c:\win\i386 /unattend:c:\unattend.txt /cmd:c:\runonce.cmd
wpeutil reboot
"""
f = file("%s/runonce.cmd" % (t.path()), "r")
data = f.read()
f.close()
# HACK to support Broadcom NICs on those machines that have them.
if xenrt.TEC().lookup("BROADCOM_POSTINSTALL", False, boolean=True):
data = string.replace(data, "EXIT", "")
data = data + 'REG ADD %KEY%\\050 /VE /D "Broadcom Driver" /f\n'
data = data + 'REG ADD %KEY%\\050 /V 1 /D ' \
'"%systemdrive%\\win\\post\\Broadcom\\setup.exe ' \
'/s /v/qn" /f\n'
data = data + "EXIT\n"
xenrt.TEC().copyToLogDir("%s/runonce.cmd" % (t.path()))
f = file("%s/runonce.cmd" % (t.path()), "w")
f.write(data)
f.close()
w.copyIn("%s/unattend.txt" % (t.path()))
w.copyIn("%s/runonce.cmd" % (t.path()))
w.copyIn("%s/%s/%s/autoinstall-%s.zip" %
(xenrt.TEC().lookup("IMAGES_ROOT"), version, build, arch),
target="win.zip")
t.remove()
# Copy common files.
w.copyIn("%s/native/pe/makepart.txt" % (xenrt.TEC().getWorkdir()))
perun_dir = os.path.dirname(xenrt.TEC().lookup("WINPE_START_FILE"))
if not os.path.exists(perun_dir):
xenrt.sudo("mkdir -p %s" % (perun_dir))
# Replace variables in perun.cmd.
perun = string.replace(perun, "%FILES%", "%s" % (w.getURL("/")))
f = file("%s/perun.cmd" % (xenrt.TEC().getWorkdir()), "w")
f.write(perun)
f.close()
xenrt.TEC().copyToLogDir("%s/perun.cmd" % (xenrt.TEC().getWorkdir()))
# Put perun.cmd where WinPE expects it.
lock = xenrt.resources.CentralResource()
for i in range(10):
try:
lock.acquire("WINPE_START_FILE")
break
except:
if i == 9:
raise xenrt.XRTError("Couldn't get lock on WINPE "
"bootstrap file.")
xenrt.sleep(60)
xenrt.sudo(
"cp %s/perun.cmd %s" %
(xenrt.TEC().getWorkdir(), xenrt.TEC().lookup("WINPE_START_FILE")))
# Start install.
xenrt.TEC().progress("Starting installation")
pxefile = pxe.writeOut(self.machine)
pfname = os.path.basename(pxefile)
xenrt.TEC().copyToLogDir(pxefile, target="%s.pxe.txt" % (pfname))
self.machine.powerctl.cycle()
xenrt.TEC().progress("Rebooted host to start installation.")
xenrt.sleep(120)
lock.release()
# 64-bit requires a two-stage installation.
if arch == "x86-64":
# Wait for first stage to complete.
xenrt.sleep(360)
xenrt.TEC().progress("Preparing TFTP for second stage.")
xenrt.sudo("rsync -avxl %s/native/pxe/64/ %s/" %
(xenrt.TEC().getWorkdir(), tftp))
xenrt.sudo("rsync -avxl %s/winpe64.wim %s/winpe.wim" %
(xenrt.TEC().lookup("IMAGES_ROOT"), tftp))
self.machine.powerctl.cycle()
xenrt.TEC().progress(
"Rebooted host into second installation stage.")
# Wait for PXE boot.
xenrt.sleep(120)
pxe.setDefault("local")
pxe.writeOut(self.machine)
# Wait for Windows to boot.
xenrt.TEC().progress("Waiting for host to boot")
self.waitforxmlrpc(7200)
w.remove()
if method == "longhorn":
self.winRegAdd(
"HKLM", "SYSTEM\\CurrentControlSet\\Control\\Terminal Server",
"fDenyTSConnections", "DWORD", 0)
self.winRegAdd("HKLM", "SYSTEM\\CurrentControlSet\\Control\\Lsa",
"LMCompatibilityLevel", "DWORD", 1)
if not method == "longhorn":
bootini = self.xmlrpcReadFile("c:\\boot.ini").strip()
if self.memory:
bootini += " /MAXMEM=%d" % (self.memory)
if self.vcpus:
bootini += " /NUMPROC=%d" % (self.vcpus)
self.xmlrpcRemoveFile("c:\\boot.ini")
self.xmlrpcCreateFile("c:\\boot.ini", xmlrpclib.Binary(bootini))
self.xmlrpcReboot()
xenrt.sleep(180)
self.waitforxmlrpc(300)
self.tailor()
def installWindows(self):
# Set up the ISO
mount = xenrt.mountStaticISO(self.productVersion)
nfsdir = xenrt.NFSDirectory()
xenrt.command("ln -sfT %s %s/iso" % (mount, nfsdir.path()))
os.makedirs("%s/custom" % nfsdir.path())
shutil.copy("%s/iso/Autounattend.xml" % nfsdir.path(),
"%s/custom/Autounattend.xml" % nfsdir.path())
xenrt.command(
"""sed -i "s#<CommandLine>.*</CommandLine>#<CommandLine>c:\\\\\\\\install\\\\\\\\runonce.cmd</CommandLine>#" %s/custom/Autounattend.xml"""
% nfsdir.path())
shutil.copytree("%s/iso/$OEM$" % nfsdir.path(),
"%s/custom/oem" % nfsdir.path())
xenrt.command("chmod u+w %s/custom/oem/\\$1/install" % nfsdir.path())
with open("%s/custom/oem/$1/install/runonce.cmd" % nfsdir.path(),
"w") as f:
f.write("%systemdrive%\install\python\python.cmd\r\n")
f.write("EXIT\r\n")
# First boot into winpe
winpe = WinPE(self)
winpe.boot()
xenrt.TEC().logverbose("WinPE booted, wiping disk")
# Wipe the disks and reboot
winpe.xmlrpc.write_file("x:\\diskpart.txt",
"list disk\nselect disk 0\nclean\nexit")
winpe.xmlrpc.exec_shell("diskpart.exe /s x:\\diskpart.txt")
xenrt.TEC().logverbose("Rebooting WinPE")
winpe.reboot()
xenrt.TEC().logverbose("WinPE rebooted, mounting shares")
winpe.xmlrpc.exec_shell("net use y: %s\\iso" % nfsdir.getCIFSPath())
winpe.xmlrpc.exec_shell("net use z: %s\\custom" % nfsdir.getCIFSPath())
xenrt.TEC().logverbose("Starting installer")
# Mount the install share and start the installer
winpe.xmlrpc.start_shell(
"y:\\setup.exe /unattend:z:\\autounattend.xml /m:z:\\oem")
# Now Construct a PXE target for local boot
pxe = xenrt.PXEBoot()
serport = self.lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = self.lookup("SERIAL_CONSOLE_BAUD", "115200")
pxe.setSerial(serport, serbaud)
chain = self.getChainBoot()
if chain:
pxe.addEntry("local", boot="chainlocal", options=chain)
else:
pxe.addEntry("local", boot="local")
pxe.setDefault("local")
pxe.writeOut(self.machine)
# Wait for Windows to be ready
self.waitForDaemon(7200)
try:
self.xmlrpcUpdate()
except:
xenrt.TEC().logverbose("Warning - could not update XML/RPC daemon")
if self.xmlrpcFileExists("c:\\xenrtinstalled.stamp"):
raise xenrt.XRTFailure(
"Installation stamp file already exists, this must be a previous installation"
)
self.xmlrpcWriteFile("c:\\xenrtinstalled.stamp", "Installed")
self.xmlrpcWriteFile("c:\\onboot.cmd",
"echo Booted > c:\\booted.stamp")
self.winRegAdd("HKLM", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\"
"Run", "Booted", "SZ", "c:\\onboot.cmd")
self.installAdditionalNICDrivers()
# Disable NLA requirement for RDP
self.xmlrpcExec(
"""(Get-WmiObject -class "Win32_TSGeneralSetting" -Namespace root\\cimv2\\terminalservices -ComputerName $env:ComputerName -Filter "TerminalName='RDP-tcp'").SetUserAuthenticationRequired(0)""",
powershell=True)
def install(self):
f = xenrt.TEC().getFile("/usr/groups/xenrt/oraclevm/%s/ovm.iso" %
(self.productVersion))
d = xenrt.NFSDirectory()
m = xenrt.MountISO(f)
d.copyIn("%s/*" % m.getMount())
m.unmount()
host, path = d.getHostAndPath("")
pw = crypt.crypt(xenrt.TEC().lookup("ROOT_PASSWORD"), "Xa")
ksd = xenrt.NFSDirectory()
ks = """lang en_US
#langsupport en_US
eula Accepted
keyboard us
#mouse genericusb
timezone --utc America/Los_Angeles
rootpw --iscrypted %s
zerombr
bootloader --location=mbr
install
nfs --server %s --dir %s
clearpart --all
part /boot --fstype ext3 --size 512 --ondisk sda
part swap --size 4096 --ondisk sda
part / --fstype ext3 --size 1 --grow --ondisk sda
network --bootproto dhcp --device eth0
ovsagent --iscrypted %s
ovsmgmntif eth0
auth --useshadow --enablemd5
firewall --disabled
#Do not configure the X Window System
skipx
text
%%packages
@Everything
%%pre
dd if=/dev/zero of=/dev/sda bs=1024 count=1024
%%post --nochroot
%%post
mkdir /tmp/xenrttmpmount
mount -onolock -t nfs %s /tmp/xenrttmpmount
touch /tmp/xenrttmpmount/.xenrtsuccess
umount /tmp/xenrttmpmount
""" % (pw, host, path, pw, ksd.getMountURL(""))
with open("%s/ks.cfg" % ksd.path(), "w") as f:
f.write(ks)
pxe = xenrt.PXEBoot()
pxe.addEntry("local", boot="local")
serport = self.lookup("SERIAL_CONSOLE_PORT", "0")
serbaud = self.lookup("SERIAL_CONSOLE_BAUD", "115200")
comport = str(int(serport) + 1)
if self.lookup("PXE_NO_SERIAL", False, boolean=True):
pxe.setSerial(None, None)
else:
pxe.setSerial(serport, serbaud)
chain = self.getChainBoot()
if chain:
pxe.addEntry("local", boot="chainlocal", options=chain)
else:
pxe.addEntry("local", boot="local")
pxe.copyIn("%s/isolinux/xen.gz" % d.path())
pxe.copyIn("%s/isolinux/vmlinuz" % d.path())
pxe.copyIn("%s/isolinux/initrd.img" % d.path())
install = pxe.addEntry("ovminstall", boot="mboot")
install.mbootSetKernel("%s/xen.gz" % pxe.path())
install.mbootSetModule1("%s/vmlinuz" % pxe.path())
install.mbootSetModule2("%s/initrd.img" % pxe.path())
install.mbootArgsModule1Add("ks=nfs:%sks.cfg" % ksd.getMountURL(""))
install.mbootArgsModule1Add("ksdevice=eth0")
install.mbootArgsModule1Add("ip=dhcp")
#install.mbootArgsKernelAdd("com%s=%s,8n1" % (comport, serbaud))
#install.mbootArgsModule1Add("console=tty0")
#install.mbootArgsModule1Add("console=ttyS%s,%sn8" % (serport, serbaud))
pxe.setDefault("ovminstall")
pxe.writeOut(self.machine)
self.machine.powerctl.cycle()
xenrt.waitForFile("%s/.xenrtsuccess" % ksd.path(),
3600,
desc="Installer boot on !%s" % (self.getName()))
xenrt.sleep(30)
pxe.setDefault("local")
pxe.writeOut(self.machine)
self.machine.powerctl.cycle()
self.waitForSSH(1800, desc="Host boot (!%s)" % (self.getName()))