diff options
Diffstat (limited to 'abs/core/LinHES-config/mv_install.py')
| -rwxr-xr-x | abs/core/LinHES-config/mv_install.py | 1432 |
1 files changed, 1432 insertions, 0 deletions
diff --git a/abs/core/LinHES-config/mv_install.py b/abs/core/LinHES-config/mv_install.py new file mode 100755 index 0000000..19295ca --- /dev/null +++ b/abs/core/LinHES-config/mv_install.py @@ -0,0 +1,1432 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +import sys, os, commands, glob, time +import getopt, re, MySQLdb +import logging +try: + import parted +except: + print "module parted not found" + +def usage(): + print "help text:" + print "example usage: --rootdisk=sda --rootfs=ext4 --rootsize=34240 --datafs=ext4 --datasize=3400 --datadisk=sda --swapsize=340 -c full_install" + +def clean_upgrade(): + return False + +def error_out(errmsg): + cmd = '''echo %s >> /tmp/.install_error ''' %errmsg + runcmd(cmd) + logging.critical("***********************************") + logging.critical("error: %s",errmsg) + print "***********************************" + print "ERROR: mv_install.py: %s" %errmsg + print "***********************************" + sys.exit(1) + + +def update_db(value, data): + db = MySQLdb.connect(host="localhost", user="mythtv", passwd="mythtv", db="mythconverg") + try: + cursor = db.cursor() + cursor.execute("DELETE FROM settings where value=%s and hostname=%s;", (value, data_config.MVHOSTNAME)) + cursor.execute("REPLACE INTO settings set value=%s, data=%s, hostname=%s;", (value, data, data_config.MVHOSTNAME)) + logging.debug("Updated database with %s, %s", data, value) + except MySQLdb.Error, e: + logging.debug("Unable to update database with %s, %s", data, value) + + +def progress(pgnum): + progressline = str(pgnum) + "% complete" + logging.debug("Progress: %s", pgnum) + f = open('/tmp/.install_percent', 'w') + f.write(progressline) + f.close() + +def update_status(status): + logging.debug("Status: %s", status) + f = open('/tmp/.install_state', 'w') + f.write(str(status)) + f.close() + +def kill_dhcp_chroot(): + logging.debug("Killing off chroot dhcpcd") + stddir = os.getcwd() + piddir = ("%s/var/run/") %data_config.MOUNTPOINT + try: + os.chdir(piddir) + for FILE in glob.glob("dhcpcd-*.pid"): + f = open(FILE, 'r') + pid = f.readline() + f.close() + cmd = "kill -9 %s" %pid + runcmd(cmd) + os.remove(FILE) + os.chdir(stddir) + except: + pass + +def statgrab(disk): + cmd = "statgrab -M disk. |grep %s.write_bytes" % hostoptions["rootdisk"] + out = commands.getoutput(cmd) + try: + prewritebytes = out.split("=")[1].strip() + except: + prewritebytes = "1024" + outline = "STARTSIZE=%s" %prewritebytes + f = open('/tmp/.startsize.io', 'w') + f.write(str(outline)) + f.close() + +def backup_sql_check(): + logging.debug("Searching for backup file") + try: + hostoptions["backupfile"] + except: + logging.debug("Backup file var is empty") + return False + if os.path.exists(data_config.MOUNTPOINT+hostoptions["backupfile"]): + logging.debug("Backup file %s is present", data_config.MOUNTPOINT+hostoptions["backupfile"]) + return True + else: + logging.debug("Backup file %s is NOT present", data_config.MOUNTPOINT+hostoptions["backupfile"]) + return False + +def mdadm_find(PREFIX): + logging.debug("Searching for mdadm.conf") + if os.path.exists(PREFIX+"/etc/KnoppMyth-version"): + mdadmconf = "/etc/mdadm/mdadm.conf" + else: + mdadmconf = "/etc/mdadm.conf" + logging.debug("Using %s for mdadm.conf", mdadmconf) + return mdadmconf + +def mdadm_assemble_all(): + # read mdadm.conf and start the arrays + #ARRAY /dev/md5 uuid=19464854:03f71b1b:e0df2edd:246cc977 + logging.debug("Starting mdadm support") + mdadmconf_file = mdadm_find("/tmp") + cmd = "cdadm --assemble --scan -c /tmp/%s" %mdadmconf_file + runcmd(cmd) + mdadm_contents = '' + try: + f = open(mdadmconf_file, 'r') + mdadm_contents = f.readlines() + f.close() + except: + logging.debug(" Couldn't open mdadmconf file") + for line in mdadm_contents: + if line.startswith("ARRAY"): + logging.debug(" Found MD array: %s", line) + array = line.split()[1] + logging.info(" assembling array: %s", array) + cmd = "mdadm --assemble -c /tmp%s %s" %(mdadmconf_file, array) + runcmd(cmd) + time.sleep(2) + cmd = "fsck -p %s" %array + runcmd + +def copy_updates(): + try: + MVROOT = os.environ["MV_ROOT"] + except: + logging.debug("MVROOT was not defined, using the default value") + MVROOT = "/usr/MythVantage" + cp_and_log2(MVROOT+"/bin/", data_config.MOUNTPOINT+MVROOT+"/bin", "*.sh") + cp_and_log2(MVROOT+"/bin/", data_config.MOUNTPOINT+MVROOT+"/bin", "*.py") + +def timezone_to_db(timefile): + logging.info("importing timezone") + try: + f = open(timefile) + timezonecontents = f.readline().strip() + f.close() + except: + logging.debug("Couldn't open /tmp/etc/timezone, will not set the timezone") + return + update_db("HostTimeZone", timezonecontents); + tzsplit = timezonecontents.partition('/') + print tzsplit + if tzsplit[2] == '' : + update_db("HostTimeZoneRegion", tzsplit[0]) + else: + update_db("HostTimeZoneRegion", tzsplit[0]) + tztemp="HostTimeZoneRegion_%s" % tzsplit[0] + update_db(tztemp, tzsplit[2]) + + + +def cp_and_log(srcfile, destfile): + #return + if not os.path.exists(srcfile): + logging.info("%s is not present, skipping...", srcfile) + else: + cmd = ("rsync -arvp %s %s") %(srcfile, destfile) + runcmd(cmd) + +def cp_and_log2(srcfile, destfile, fileglob): + #return + logging.debug("cp_and_log2") + logging.debug("%s, %s, %s", srcfile, destfile, fileglob) + + if not os.path.exists(srcfile): + logging.info("%s is not present, skipping...", srcfile) + else: + if fileglob == '': + cmd = ("rsync -arvp %s %s") %(srcfile, destfile) + runcmd(cmd) + else: + fileglob = "*" + cmd = ("rsync -arvp %s/%s %s") %(srcfile, fileglob, destfile) + runcmd(cmd) + +def runcmd(cmd): + if data_config.NOOPDEBUG == "FALSE": + pass + else: + cmd = "echo "+cmd + logging.debug(" %s", cmd) + cmdout = commands.getstatusoutput(cmd) + logging.debug(" %s", cmdout) + return cmdout + +def mysqldb(cmd, inchroot): + if cmd == "start": + mycmd = " /etc/rc.d/mysqld start" + elif cmd == "stop": + mycmd = " /etc/rc.d/mysqld stop" + if inchroot == "chroot": + mycmd = " chroot /newboot %s" %mycmd + runcmd(mycmd) + + +def mount_bind_chroot(): + logging.debug("Mounting dev/proc/sysfs for chroot") + cmd = " mount --bind /dev %s" %data_config.MOUNTPOINT+"/dev" + runcmd(cmd) + cmd = " mount --bind /dev/pts %s" %data_config.MOUNTPOINT+"/dev/pts" + runcmd(cmd) + cmd = " mount --bind /proc %s" %data_config.MOUNTPOINT+"/proc" + runcmd(cmd) + cmd = " mount -t sysfs none %s" %data_config.MOUNTPOINT+"/sys" + runcmd(cmd) + + +def umount_bind_chroot(): + logging.debug("UnMounting dev/proc/sysfs for chroot") + cmd = " umount -l %s" %data_config.MOUNTPOINT+"/dev/pts" + runcmd(cmd) + cmd = " umount -l %s" %data_config.MOUNTPOINT+"/dev" + runcmd(cmd) + cmd = " umount -l %s" %data_config.MOUNTPOINT+"/proc" + runcmd(cmd) + cmd = " umount -l %s" %data_config.MOUNTPOINT+"/sys" + runcmd(cmd) + + +def blank_table(diskdevice): + logging.debug(" writing new parition table for %s", diskdevice) + logging.debug("parition table before:") + cmd = "fdisk -l %s" %diskdevice + runcmd(cmd) + + cmd = "echo w |fdisk %s" %diskdevice + runcmd(cmd) + + logging.debug("parition table after:") + cmd = "fdisk -l %s" %diskdevice + runcmd(cmd) + +def partitions_removeall(diskdevice, label): + logging.info("Removing all partitions for %s %s", label, diskdevice) + try: + device = parted.getDevice(diskdevice) + partdisk = parted.Disk(device) + partdisk.deleteAllPartitions() + if data_config.NOOPDEBUG == "FALSE": + partdisk.commit() + for partition in partdisk.partitions: + print "type: %s" %partition.type + except: + logging.debug(" Error reading parition table, attempting to write a blank one") + blank_table(diskdevice) + + +def create_partitions(diskdevice, size, ptype, startsector): + logging.debug("_____Create partitions______") + if size == "NO": + logging.info("Size is 0, skipping") + return "NO" + partlist = [] + newstart = 0 + totalused = 0 + device = parted.getDevice(diskdevice) + partdisk = parted.Disk(device) + for partition in partdisk.partitions: + if partition.type != parted.PARTITION_FREESPACE: + partlist.append((partition, + partition.path, + partition.getFlag(parted.PARTITION_BOOT), + partition.geometry.start, + partition.geometry.end, + partition.geometry.length, + partition.type, + partition.fileSystem)) + for slice in partlist: + (usedpartition, usedpath, usedbootable, usedstart, usedend, usedlength, usedtype, usedfs) = slice + #Start the new partition one after the end of last + newstart = usedend+1 + + if startsector == 0: + newstart = 0 + if size == "ALL": + logging.debug(" Using the rest of the disk %s", (device.length-newstart) ) + try: + geom = parted.Geometry(device=device, start=newstart, length=(device.length-newstart)) + except: + logging.info("An error occured, probably invalid parition size") + return + else: + # convert size in MB to a length on the device in sectors + length = (int(size) * (1024 * 1024)) / device.sectorSize + logging.debug("Size is %s", length) + try: + geom = parted.Geometry(device=device, start=newstart, length=length) + except: + logging.info("An error occured, probably invalid parition size") + error_out("invalid parition size") + + #collect device constraint + constraint = device.getConstraint() + # new partition + if ptype == "NORMAL": + newpart = parted.Partition(disk=partdisk, type=parted.PARTITION_NORMAL, geometry=geom) + elif ptype == "SWAP": + newpart = parted.Partition(disk=partdisk, type=parted.PARTITION_NORMAL, geometry=geom) + + #add the partition to the disk and commit changes + partdisk.addPartition(partition=newpart, constraint=constraint) + if data_config.NOOPDEBUG == "FALSE": + partdisk.commit() + logging.info("created partition %s of %dMB and added it to %s" % + (newpart.getDeviceNodeName(), newpart.getSize(), diskdevice)) + return newpart.getDeviceNodeName() + +def set_active_parition(diskdevice): + """ Set the bootable flag for this partition. """ + logging.debug(" Setting active parition") + device = parted.getDevice(diskdevice) + partdisk = parted.Disk(device) + try: + for partition in partdisk.partitions: + partition.setFlag(parted.PARTITION_BOOT) + partdisk.commit() + except: + logging.info(" Couldn't set the active partition") + logging.info(" Depending on your system this may not matter") + + +def partition_disk(): + global hostoptions + logging.info("Partitioning") + logging.debug("____start of partition_disk____") + rootdisk = hostoptions["rootdisk"] + datadisk = hostoptions["datadisk"] + label = "root" + partitions_removeall("/dev/"+rootdisk, label) + label = "data" + partitions_removeall("/dev/"+datadisk, label) + hostoptions["rootpartition"] = create_partitions("/dev/"+rootdisk, hostoptions["rootsize"], "NORMAL", 0) + set_active_parition("/dev/"+rootdisk) + hostoptions["swappartition"] = create_partitions("/dev/"+rootdisk, hostoptions["swapsize"], "SWAP", 1) + if datadisk != rootdisk: + hostoptions["datapartition"] = create_partitions("/dev/"+datadisk, hostoptions["datasize"], "NORMAL", 0) + else: + hostoptions["datapartition"] = create_partitions("/dev/"+datadisk, hostoptions["datasize"], "NORMAL", 1) + time.sleep(5) + +def fscmd(fstype): + fscmds = {"reiserfs":"mkreiserfs -q -l ROOT", "xfs": "mkfs -t xfs -f", "ext3": "mkfs.ext3", "jfs":"mkfs.jfs -q", "ext4":"mkfs.ext4", "Do_not_format":"noformat", "no_format":"noformat"} + try: + rc = fscmds[fstype] + except: + logging.critical(" %s is not a valid fs type, exiting now", fstype) + error_out("Error mvinstall during format") + return rc + + +def format_disk(install_type): + logging.info("______Starting Disk Format______") + rootfs = fscmd(hostoptions["rootfs"]) + datafs = fscmd(hostoptions["datafs"]) + + rootdisk = hostoptions["rootdisk"] + datadisk = hostoptions["datadisk"] + rootpartition = hostoptions["rootpartition"] + datapartition = hostoptions["datapartition"] + if install_type != "upgrade": + swapsize = hostoptions["swapsize"] + swappartition = hostoptions["swappartition"] + + logging.debug(" Format command for rootfs %s : %s ", rootfs, rootpartition) + if ( rootfs != "noformat"): + logging.info("Starting format of %s", rootpartition) + cmd = " %s /dev/%s" %( rootfs, rootpartition) + #os.system(cmd) + runcmd(cmd) + else: + logging.info("Will not format root partition: %s", rootpartition) + + logging.debug(" Format command for datafs %s : %s ", datafs, datapartition) + if (datafs != "noformat"): + logging.info("Starting format of %s", datapartition) + cmd = " %s /dev/%s" %( datafs, datapartition) + #os.system(cmd) + runcmd(cmd) + else: + logging.info("Will not format data partition: %s", datapartition) + + if install_type == "install": + if (hostoptions["swapsize"] != "NO"): + logging.info("Starting format for swap %s", swappartition) + cmd = " mkswap /dev/%s" % swappartition + #os.system(cmd) + runcmd(cmd) + else: + logging.debug(" Swap is set to NO, will not run mkswap") + + logging.debug("_____End of format______") + + +def mount_it(): + logging.info("______Mounting disk______") +# Create mount points + try: + mountpoint = data_config.MOUNTPOINT + mp = mountpoint + logging.info("Creating mountpoints %s", mp) + os.makedirs(mp) + except OSError: + logging.debug(" Could not create %s", mp) + +# Mount root + cmd = "mount /dev/%s %s" %(hostoptions["rootpartition"], mountpoint) + runcmd(cmd) + #logging.debug(cmd) + #cmdout=commands.getoutput(cmd) + #logging.debug(cmdout) +# Mount data +#make mountpoint after mounting / + try: + mountpoint = data_config.MOUNTPOINT + datapoint = data_config.DATAMOUNT + mp = mountpoint+datapoint + logging.info("Creating mountpoints %s", mp) + os.makedirs(mp) + except OSError: + logging.debug(" Could not create %s", mp) + + cmd = "mount /dev/%s %s" %(hostoptions["datapartition"], mp) + runcmd(cmd) + #logging.debug(cmd) + #cmdout=commands.getoutput(cmd) + #logging.debug(cmdout) + +def unmount_it(): + logging.info("______Unmounting disk______") + cmd = "umount %s" %(data_config.MOUNTPOINT+data_config.DATAMOUNT) + runcmd(cmd) + time.sleep(2) + + cmd = "swapoff /dev/%s" %(hostoptions["swappartition"]) + runcmd(cmd) + + cmd = "sync" + runcmd(cmd) + + cmd = "umount %s" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "sync" + runcmd(cmd) + + +def create_squashlist(): + logging.debug("Creating squashlist") + squashfile = data_config.SQUASHFILE + f = open(squashfile, 'w') + for i in data_config.SQUASHLIST: + f.write(i) + f.write("\n") + logging.debug(i) + f.close() + + +def copy_it(install_type): + logging.info("______Transferring to disk______") + logging.debug( install_type) + if ( install_type == "install"): + logging.info("Transferring system") + cmd = " unsquashfs -f -d %s /.livesys/medium/system.sqf" %(data_config.MOUNTPOINT) + runcmd(cmd) + #logging.debug(cmd) + #cmdout=commands.getoutput(cmd) + + if ( install_type == "upgrade"): + logging.info("Upgrading system") + create_squashlist() + cmd = " unsquashfs -e %s -f -d %s /.livesys/medium/system.sqf" %(data_config.SQUASHFILE, data_config.MOUNTPOINT) + runcmd(cmd) + #logging.debug(cmd) + #cmdout=commands.getoutput(cmd) +# Create the missing dir + i = ("sys", "proc", "dev", "tmp", "mnt", "media", "media/cdrom", "media/dvd", "var/log/mythtv") + mountpoint = data_config.MOUNTPOINT + for item in i: + try: + mp = mountpoint+"/"+item + logging.info("Creating mountpoints %s", mp) + os.makedirs(mp) + except OSError: + logging.debug(" __Could not create %s", mp) +# General fixup + cmd = "chmod 777 %s/tmp" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "mknod %s/dev/null c 1 5" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "mknod %s/dev/console c 5 1" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "chmod +s %s/usr/bin/Xorg" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "chmod +s %s/usr/bin/crontab" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "chmod +s %s/usr/bin/sudo" %(data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "chmod +s %s/bin/mount" %(data_config.MOUNTPOINT) + runcmd(cmd) + logging.debug("__End of copy_it__") + +def create_fstab(extralines): + logging.debug("______Creating new fstab file_______") + logging.info("Creating new fstab file") + fstabfile = data_config.MOUNTPOINT+"/etc/fstab" + fstab_list = [] + f = open(fstabfile, 'w') + line = '''# <file system> <dir> <type> <options> <dump> <pass> \n''' + fstab_list.append(line) + line = '''none /dev/pts devpts defaults 0 0 \n''' + fstab_list.append(line) + line = '''none /dev/shm tmpfs defaults 0 0\n''' + fstab_list.append(line) + line = '''/dev/sr0 /media/cdrom auto ro,user,noauto,unhide 0 0\n''' + fstab_list.append(line) + line = '''UUID=ROOTUID / auto defaults,noatime 0 1\n''' + fstab_list.append(line) + line = '''UUID=DATAUID %s auto defaults,noatime 0 1\n''' %(data_config.DATAMOUNT) + fstab_list.append(line) + line = '''UUID=SWAPUID swap swap defaults 0 0 \n''' + fstab_list.append(line) + for vline in extralines: + fstab_list.append(vline) + for outline in fstab_list: + logging.debug(outline) + f.write(outline) + f.close() + +def find_uuid(partition): + logging.info("Finding the UUID for %s...", partition) + cmd = "blkid -s UUID /dev/%s" %partition + tmpuuid = runcmd(cmd)[1] + splituuid = tmpuuid.partition("=") + uuid = splituuid[2].replace('"', "") + logging.info("The uuid is %s", uuid) + return uuid.strip() + +def pick_out_vg(): + logging.info("Searching for Volume Groups in old fstab") + vglines = [] + f = open("/tmp/etc/fstab", 'r') + oldfscontents = f.readlines() + for line in oldfscontents: + if line.startswith("/dev/vg"): + vglines.append(line) + templine = line.split() + mdir = templine[1] + if not os.path.exists (mdir): + logging.debug("Creating dir %s for VG mount", mdir) + os.makedirs (mdir) +# Might need to os.chown to mythtv:users + else: + logging.debug("Directory %s for VG mount already present", mdir) + return vglines + +def fstab_it(install_type): + logging.info("______Checking fstab______") + kmvg = [] + fstabfile = data_config.MOUNTPOINT+"/etc/fstab" +# Check for knoppmyth install, if found create new + if install_type == "upgrade": + if os.path.exists("/tmp/etc/KnoppMyth-version"): + logging.debug(" KnoppMyth-Version found, creating new fstab") + kmvg = pick_out_vg() + create_fstab(kmvg) + elif os.path.exists("/tmp/etc/fstab"): + logging.debug(" Upgrade and not Knoppmyth, using old fstab") + cp_and_log("/tmp/etc/fstab", fstabfile) +# Catch all for creating new fstab + if not os.path.exists(data_config.MOUNTPOINT+"/etc"): + os.makedirs(data_config.MOUNTPOINT+"/etc") + if not os.path.exists(fstabfile): + create_fstab(kmvg) + + logging.info("____UUID check for %s", "swap") + swapuuid = find_uuid(hostoptions["swappartition"]) + + logging.info("____UUID check for %s", "data") + datauuid = find_uuid(hostoptions["datapartition"]) + + logging.info("____UUID check for %s", "root") + rootuuid = find_uuid(hostoptions["rootpartition"]) + + fstabfile = data_config.MOUNTPOINT+"/etc/fstab" + logging.info("Correcting UUID's in %s", fstabfile) + f = open(fstabfile, 'r') + oldfscontents = f.readlines() + newfstab = [] + f.close() + for line in oldfscontents: + if line.startswith("UUID"): + templine = line.split() + if ( templine[1] == "/"): + logging.debug(" Found Root fstab line:") + logging.debug( templine) + templine[0] = "UUID=%s" %(rootuuid) + newline = '' + for i in templine: + newline+=i + newline+=" " + newline+="\n" + logging.debug(" New fstab line:") + logging.debug( newline) + newfstab.append(newline) + + if ( templine[1] == data_config.DATAMOUNT): + logging.debug(" Found DATA mount") + logging.debug( templine) + templine[0] = "UUID=%s" %(datauuid) + newline = '' + for i in templine: + newline+=i + newline+=" " + newline+="\n" + logging.debug(" New fstab line:") + logging.debug( newline) + newfstab.append(newline) + + if ( templine[1] == "swap"): + if len(swapuuid) <= 5: + logging.debug(" swapp uuid is to small") + else: + logging.debug(" Found swap partition") + logging.debug( templine) + templine[0] = "UUID=%s" %(swapuuid) + newline = '' + for i in templine: + newline+=i + newline+=" " + newline+="\n" + logging.debug(" New fstab line:") + logging.debug( newline) + newfstab.append(newline) + else: + logging.debug(" Line didn't match, adding to newfstab:") + logging.debug( line) + newfstab.append(line) + logging.info("Writing out newfstab") + logging.debug("______This is the new fstab_____") + f = open(fstabfile, 'w') + for line in newfstab: + logging.debug(line) + f.write(line) + #f.write("\n") + f.close() + +def grub_it(): + logging.info("______Start of grub install______") + cmd = " grub-install --recheck --no-floppy --root-directory=%s \"(hd0)\" " % data_config.MOUNTPOINT + logging.info("Running grub-install") + runcmd(cmd) + rootuuid = find_uuid(hostoptions["rootpartition"]) + cmd = " mkinitcpio -g %s/boot/kernel26.img" % data_config.MOUNTPOINT + logging.info("Running mkinitcpio") + runcmd(cmd) + logging.info("Adding root uuid to grub menu") + grubfile = data_config.MOUNTPOINT+"/boot/grub/menu.lst" + try: + f = open(grubfile, 'r') + oldgrub = f.readlines() + newgrub = [] + f.close() + for line in oldgrub: + if line.startswith("kernel"): + templine = line.split() + logging.debug(" Found kernel Root grubline:") + logging.debug( templine) + templine[2] = "root=/dev/disk/by-uuid/%s" %(rootuuid) + newline = '' + for i in templine: + newline+=i + newline+=" " + newline+="\n" + logging.debug(" New grub menu.lst line:") + logging.debug( newline) + newgrub.append(newline) + else: + logging.debug("Line didn't match, adding to newgrub:") + logging.debug( line) + newgrub.append( line) + logging.info("Writing out new grub file") + logging.debug("______This is the new grub_____") + f = open(grubfile, 'w') + for line in newgrub: + logging.debug(line) + f.write(line) + f.close() + except: + logging.debug("Couldn't open grub file") + +def fix_permissions(): + logging.info("Fixing permissions") + SE = os.environ["TEMPLATES"]+"/settings/syssettings" + cmd = " chmod -R 755 %s" %(data_config.MOUNTPOINT+SE) + runcmd(cmd) + cmd = " chmod 775 %s" %(data_config.MOUNTPOINT+"/etc/systemconfig") + runcmd(cmd) + cmd = " chmod 755 %s" %(data_config.MOUNTPOINT+"/root") + runcmd(cmd) + cmd = " chown root:mythtv %s" %(data_config.MOUNTPOINT+"/etc/systemconfig") + runcmd(cmd) + cmd = " chown -R mythtv:mythtv %s" %(data_config.MOUNTPOINT+SE) + runcmd(cmd) + cmd = " chown -R mythtv:mythtv %s" %(data_config.MOUNTPOINT+"/var/log/mythtv") + runcmd(cmd) + +def apply_new_auth(): + logging.info("_____Applying Password updates_______") + passfile = "/root/myth_user_call.out" + try: + MVROOT = os.environ["MV_ROOT"] + except: + logging.debug("MVROOT was not defined, using the default value") + MVROOT = "/usr/MythVantage" + if data_config.NOOPDEBUG == "FALSE": + cmdprefix = "chroot " + data_config.MOUNTPOINT + " " + MVROOT+"/bin/myth_user_call -i " + else: + cmdprefix = "echo chroot " + data_config.MOUNTPOINT + " " + MVROOT+"/bin/myth_user_call -i " + try: + f = open(passfile, 'r') + passcmds = f.readlines() + f.close() + for cmd in passcmds: + execmd = cmdprefix+cmd +# Using os.system because runcmd fails + logging.debug(execmd) + os.system(execmd) + except: + logging.debug("Applying password updates failed, couldn't open %s", passfile) + logging.debug + +def add_to_blacklist(module): + rcfile = data_config.MOUNTPOINT + "/etc/rc.conf" + logging.debug(" Attempting to add %s to blacklist", module) + newline='' + try: + f = open(rcfile, 'r') + conflines = f.readlines() + f.close() + except: + logging.critical(" *Couldn't open %s for reading",rcfile) + return + + try: + f = open(rcfile, 'w') + except: + logging.critical(" *Couldn't open %s for reading",rcfile) + return + + for line in conflines: + newline = line + if re.match("MOD_BLACKLIST",line): + logging.debug(line) + try: + lastpar = line.rindex(')') + logging.debug(" found ) at %s", lastpar) + newline = line[:lastpar] +" !" + module + " " + line[lastpar:] + logging.debug(newline) + except: + logging.debug("Couldn't find ending )") + newline = line + f.write(newline) + f.close() + + +def add_to_modulelist(module): + rcfile = data_config.MOUNTPOINT + "/etc/rc.conf" + logging.debug(" Attempting to add %s to modulelist", module) + newline='' + try: + f = open(rcfile, 'r') + conflines = f.readlines() + f.close() + except: + logging.critical(" *Couldn't open %s for reading",rcfile) + return + + try: + f = open(rcfile, 'w') + except: + logging.critical(" *Couldn't open %s for reading",rcfile) + return + + for line in conflines: + newline = line + if re.match("MODULES=",line): + logging.debug(line) + try: + lastpar = line.rindex(')') + logging.debug(" found ) at %s", lastpar) + newline = line[:lastpar] +" " + module + " " + line[lastpar:] + logging.debug(newline) + except: + logging.debug("Couldn't find ending )") + newline = line + f.write(newline) + f.close() + + + +def special_hardware_check(): + logging.info("_____Applying special boot parameters_______") + try: + f = open('/proc/cmdline', 'r') + bootoptions = f.readlines() + f.close() + except: + logging.critical(" *Couldn't open /proc/cmdline") + return + bootoptions = bootoptions[0].split() + logging.debug(" Boot options: %s", bootoptions) + for item in bootoptions: + logging.debug(item) + if re.match("disablemodules",item) != None : + logging.debug(" Found disabledmodules") + modulelist = item.split("=")[1] + for module in modulelist.split(','): + add_to_blacklist(module) + + if re.match("modules",item) != None : + logging.debug(" Found modules") + modulelist = item.split("=")[1] + for module in modulelist.split(','): + add_to_modulelist(module) + + if re.match("type",item) != None : + logging.debug(" Found special hardware type") + try: + typefile = open(data_config.MOUNTPOINT + "/myth/.special_hardware_type", 'w') + typelist = item.split("=")[1] + # there should be only one special hardware type, but this will handle multiples, just in case + for type in typelist.split(','): + typefile.write(type) + typefile.write("\n") + typefile.close() + except: + logging.debug("Couldn't write to file: ", typefile) + if re.match("no_meth",item) != None : + cmd = " touch %s%s/.no_meth" %(data_config.MOUNTPOINT, data_config.MYTHHOME) + runcmd(cmd) + +def swapsearch(): +#currently unused! + partlist = [] + stddir = os.getcwd() + os.chdir("/sys/block") + partitionlist = glob.glob("*") + for item in partitionlist: + try: + newitem = item.strip().rpartition(" ")[2] + if (not newitem == '') and (not newitem.startswith("loop")): + path = "/dev/"+newitem.strip() + path = path.strip() + device = parted.getDevice(path) + (cylinders, heads, sectors) = device.biosGeometry + sizeInBytes = device.length * device.sectorSize + disk = parted.Disk(device) + for partition in disk.partitions: + if partition.type == parted.PARTITION_PROTECTED or \ + partition.type == parted.PARTITION_METADATA or \ + partition.type == parted.PARTITION_FREESPACE: + continue + + partlist.append((partition, + partition.path, + partition.getFlag(parted.PARTITION_BOOT), + partition.geometry.start, + partition.geometry.end, + partition.geometry.length, + partition.type, + partition.fileSystem)) + for slice in partlist: + (partition, path, bootable, start, end, length, type, fs) = slice + if partition.getFlag(parted.PARTITION_SWAP) or fs.type == "linux-swap": + print "found swap" + print path + except: + pass + os.chdir(stddir) + +def sane_settings(file): + #Remove some settings from file_name + removeline = ("HOSTrootfstype", "HOSTrootfstype", "HOSTdatafstype", "HOSTOSsize", "HostUseALLdata", "HOSTDATAsize", "HOSTuprootfstype", "HostUseSWAP", "HOSTSWAPsize") + logging.debug("__Running sane settings") + try: + f = open(file, 'r') + filecontents = f.readlines() + f.close() + except: + logging.debug(" Couldn't find file %s to sane", file) + try: + f = open(file, 'w') + for line in filecontents: + for item in removeline: + if line.startsize(line.strip()): + logging.debug(" Found a line to remove in %s, %s", file, line) + else: + f.write(line) + except: + logging.debug(" Couldn't open file %s for writing", file) + logging.debug(" __End sane settings") + +def restore_default_settings(): + try: + MVROOT = os.environ["MV_ROOT"] + except: + logging.debug(" MVROOT was not defined, using the default value") + MVROOT = "/usr/MythVantage" + logging.info("Saving syssettings") + cmd = "%s/bin/restore_default_settings.sh -c save -t syssettings -h %s -d localhost" %(MVROOT, data_config.MVHOSTNAME) + runcmd(cmd) + SE = os.environ["TEMPLATES"]+"/settings/syssettings/" + cp_and_log(SE, data_config.MOUNTPOINT+SE) + cp_and_log("/etc/mtab", data_config.MOUNTPOINT+"/etc/mtab") + copy_updates() + fix_permissions() + +def full_install(hostoptions): + logging.info("______Start of full install______") + try: + MVROOT = os.environ["MV_ROOT"] + except: + logging.debug(" MVROOT was not defined, using the default value") + MVROOT = "/usr/MythVantage" + + try: + os.remove("/tmp/.this_is_upgrade") + except OSError: + logging.debug(" File /tmp/.this_is_upgrade not present, couldn't delete it") + pass +# Partition disk + statusmsg = "Partitioning %s" %( hostoptions["rootdisk"]) + update_status(statusmsg) + progress(1) + if data_config.NOOPDEBUG == "FALSE": + partition_disk() + else: + logging.debug(" Debug mode, skipping partitioning step") + +# Format disk + statusmsg = "Preparing %s" %( hostoptions["rootdisk"]) + update_status(statusmsg) + progress(2) + format_disk("install") + + +# Mount partitions + statusmsg = "Mounting %s" %( hostoptions["rootdisk"]) + update_status(statusmsg) + progress(3) + mount_it() + +# Find number of bytes written to disk before starting copy. This is used +# to have a somewhat decent progress indication. + statgrab( hostoptions["rootdisk"]) + msg = "Creating %s" %(systemconfig["hostname"]) + update_status(msg) + +# Copy system to disk + copy_it("install") +# Remove old fstab so that a new one is created + fstabfile = data_config.MOUNTPOINT+"/etc/fstab" + try: + os.remove(fstabfile) + except OSError: + logging.debug(" ERROR: deleting %s", fstabfile) + fstab_it("full_install") +# Configure system + msg = "Configuring system" + update_status(msg) + progress(98) + grub_it() + special_hardware_check() +# Configuring the system + logging.info("______Configuring system________") + cp_and_log("/etc/systemconfig", data_config.MOUNTPOINT+"/etc/systemconfig") + cp_and_log("/root/xorg.conf.install", data_config.MOUNTPOINT+"/etc/X11/xorg.conf.install") + restore_default_settings() + #try: + #MVROOT=os.environ["MV_ROOT"] + #except: + #logging.debug(" MVROOT was not defined, using the default value") + #MVROOT="/usr/MythVantage" + #logging.info("Saving syssettings") + #cmd="%s/bin/restore_default_settings.sh -c save -t syssettings -h %s -d localhost" %(MVROOT, data_config.MVHOSTNAME) + #runcmd(cmd) + #SE=os.environ["TEMPLATES"]+"/settings/syssettings" + #cp_and_log(SE, data_config.MOUNTPOINT+SE) + #cp_and_log("/etc/mtab", data_config.MOUNTPOINT+"/etc/mtab") + #cp_and_log2(MVROOT+"/bin/", data_config.MOUNTPOINT+MVROOT+"/bin/", "*.sh") + #cp_and_log2(MVROOT+"/bin/", data_config.MOUNTPOINT+MVROOT+"/bin/", "*.py") + #fix_permissions() + mount_bind_chroot() + apply_new_auth() + umount_bind_chroot() + if ( systemconfig["SystemType"] == "Master_backend" or systemconfig["SystemType"] == "Standalone" ): +# This install will need a DB, so install it + logging.info("______Installing Database in CHROOT________") + mysqldb("stop", '') + mount_bind_chroot() + cmd = " chroot %s %s/bin/install_db_chroot.sh |tee /tmp/chrootdb.out" %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + logging.info("Running systemconfig in chroot") + #cmd = " chroot %s %s/bin/systemconfig.sh misc, hostype, network, advanced, user, this_is_install" %(data_config.MOUNTPOINT, MVROOT) + cmd = "chroot %s %s/bin/systemconfig.sh all,this_is_install" %(data_config.MOUNTPOINT, MVROOT) + rc = runcmd(cmd)[0] + if rc != 0 : + error_out("Running systemconfig") + + mysqldb("stop", "chroot") + kill_dhcp_chroot() + logging.info("____End Database in CHROOT____") + mysqldb("start", '') + umount_bind_chroot() + else: + logging.info("______No database required, continuing configuration________") + mount_bind_chroot() + cmd = " chroot %s DISPLAY=127.0.0.1:0 %s/bin/MythVantage -t restore, default 1" %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) +# Need to check for to touch /tmp/.dbsysfailed + cmd = " chroot %s %s/bin/restore_default_settings.sh -c restore -t syssettings " %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + if ( 'x' == '1' ): + logging.debug("touching /tmp/.dbsysfailed") + else: + #cmd = " chroot %s %s/bin/systemconfig.sh misc, hostype, network, advanced, user, this_is_install" %(data_config.MOUNTPOINT, MVROOT) + cmd = "chroot %s %s/bin/systemconfig.sh all,this_is_install" %(data_config.MOUNTPOINT, MVROOT) + rc = runcmd(cmd)[0] + if rc != 0 : + error_out("Running systemconfig") + cmd = "chroot %s %s/bin/restore_default_settings.sh -c ACCESSCONTROL " %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + umount_bind_chroot() + cmd = " touch %s%s/.configure" %(data_config.MOUNTPOINT, data_config.MYTHHOME) + runcmd(cmd) + cmd = " chmod 777 %s%s/.configure" %(data_config.MOUNTPOINT, data_config.MYTHHOME) + runcmd(cmd) + + msg = "Done" + update_status(msg) + cp_and_log("/tmp/mythvantage_install.log", data_config.MOUNTPOINT+"/var/log/mythvantage_install.log") + cp_and_log("/tmp/mv_debug.log", data_config.MOUNTPOINT+"/var/log/mv_debug.log") + unmount_it() + logging.debug("_____End of full install_____") + +def find_upgrade(): + logging.info("_____Start of find_upgrade_____") + global hostoptions + #try to mount first partition of disk + #copy old /etc/systemconfig to live, import settings into db + #umount drive. + #check for clean upgrade + if ( clean_upgrade() ): + logging.info("Clean upgrade requested, not using old data") + return + mount_it() + oldbackupfile = data_config.MOUNTPOINT+"/root/backup/"+data_config.BACKUPFILE + newbackupfile = "/tmp/"+data_config.BACKUPFILE + if os.path.exists(oldbackupfile): + logging.debug("Setting backup file to %s", newbackupfile) + hostoptions["backupfile"] = newbackupfile + cp_and_log(oldbackupfile, newbackupfile) + + srcfile = data_config.MOUNTPOINT+"/etc/systemconfig" + logging.info("Searching for systemconfig file %s", srcfile) + if os.path.exists(srcfile): + logging.info("Found systemconfig file %s", srcfile) + TEMPLATES = os.environ["TEMPLATES"]+"/settings/syssettings" + cp_and_log2(data_config.MOUNTPOINT+TEMPLATES, data_config.TEMP_TEMPLATES, '') + sane_settings("/tmp/templates/settings/syssettings/settings.txt") + cp_and_log2(data_config.TEMP_TEMPLATES, TEMPLATES, '') + cp_and_log(srcfile, "/etc/systemconfig") + cp_and_log(data_config.MOUNTPOINT+"/etc/", "/tmp/etc/") + cp_and_log(data_config.MOUNTPOINT+"/var/lib/alsa/", "/tmp/alsa") + cp_and_log(data_config.MOUNTPOINT+"/var/lib/oss/", "/tmp/oss") + cp_and_log("/tmp/etc/mdadm.conf", "/etc/mdadm.conf") + else: + logging.info("Could not find systemconfig file %s", srcfile) + cp_and_log(data_config.MOUNTPOINT+"/etc/", "/tmp/etc/") + cp_and_log(data_config.MOUNTPOINT+"/var/lib/alsa/", "/tmp/alsa") + cp_and_log("/tmp/etc/mdadm.conf", "/etc") + timezone_to_db("/tmp/etc/timezone") + unmount_it() + logging.debug("End of find_upgrade") + +def upgrade_mount_search(): + #Search for data/myth partition based on contents of fstab + logging.debug("______Start of upgrade_mount_search_____") + cmd = "umount %s%s" %(data_config.MOUNTPOINT, data_config.DATAMOUNT) + runcmd(cmd) + fstab_list = [] + fstab_data_mount = '' + try: + f = open("/tmp/etc/fstab", 'r') + oldfscontents = f.readlines() + f.close() + ## ['UUID=', '/myth', 'auto', 'defaults, noatime', '0', '1'] + #for line in oldfscontents: + #mountdir=line.split() + #if mountdir[1] == (data_config.DATAMOUNT): + #fstablist.append(mountdir) + except: + logging.debug(" Couldn't open /tmp/etc/fstab") + for line in oldfscontents: + if line.startswith("#"): + continue + mountdir=line.split() + try: + if mountdir[1] == (data_config.DATAMOUNT): + fstablist.append(mountdir) + except: + continue + #search fstab for data/myth mountpoint + for i in fstab_list: + if i[1] == data_config.DATAMOUNT: + fstab_data_mount = i[0] + break + + #start software raid support if needed + for i in fstab_list: + if i[0].startswith("/dev/md"): + logging.debug(" starting software raid support") + mdadm_assemble_all + + + if re.search("UUID", fstab_data_mount): + fstab_data_uuid = fstab_data_mount.split("=")[1] + cmd = "blkid -t UUID=%s" %fstab_data_uuid + retcode = call(cmd, shell=True) + if retcode != 0: + logging.debug(" Couldn't find uuid %s, starting md support", fstab_data_uuid) + mdadm_assemble_all + #hoping everything is up and running and data/myth will be available for mount + cmd = "mount -U %s %s" %(fstab_data_uuid, data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "blkid -t UUID=%s|cut -d: -f1" %fstab_data_uuid + logging.debug(cmd) + datadisk = commands.getoutput(cmd) + cmd = "basename %s" %datadisk + datadisk = commands.getoutput(cmd) + else: + cmd = "mount %s %s" %(fstab_data_mount, data_config.MOUNTPOINT) + runcmd(cmd) + cmd = "basename %s" %fstab_data_mount + datadisk = commands.getoutput(cmd) + time.sleep(3) +# hostoptions["backupfile"]=data_config.BACKUPPATH+data_config.BACKUPFILE + if not backup_sql_check(): + newbackupfile = "/tmp/"+data_config.BACKUPFILE + if os.path.exists(newbackupfile): + logging.debug("Setting backup file to %s", newbackupfile) + cp_and_log(newbackupfile, data_config.MOUNTPOINT+newbackupfile) + hostoptions["backupfile"] = newbackupfile + else: + logging.info("Couldn't find any database to restore, upgrade will continue with a new database") + + + +def upgrade(hostoptions): + + try: + MVROOT = os.environ["MV_ROOT"] + except: + logging.debug("MVROOT was not defined, using the default value") + MVROOT = "/usr/MythVantage" + logging.info("______Start of upgrade______") + cmd = "touch /tmp/.this_is_upgrade" + runcmd(cmd) + if hostoptions["rootfs"] == "Do_not_format": + logging.info("Will not format root filesystem") + else: + statusmsg = "Preparing %s" %( hostoptions["rootdisk"]) + update_status(statusmsg) + progress(2) + format_disk("upgrade") + #sys.exit(2) + statusmsg = "Mounting %s" %( hostoptions["rootdisk"]) + update_status(statusmsg) + progress(3) + mount_it() + hostoptions["backupfile"] = data_config.BACKUPPATH+data_config.BACKUPFILE + statgrab( hostoptions["rootdisk"]) + msg = "Upgrading %s" %(systemconfig["hostname"]) + update_status(msg) + time.sleep(3) + copy_it("upgrade") + cmd = "rm -rf %s/etc.old" %data_config.MOUNTPOINT + runcmd(cmd) + cmd = "rm -rf %s/alsa.old" %data_config.MOUNTPOINT + runcmd(cmd) + + cp_and_log("/tmp/etc/", data_config.MOUNTPOINT+"/etc.old/") + cp_and_log("/tmp/alsa/", data_config.MOUNTPOINT+"/alsa.old/") + cp_and_log("/tmp/oss", data_config.MOUNTPOINT+"/var/lib/oss.old") + + srcfile = "%s/etc.old/ssh/" %(data_config.MOUNTPOINT) + destfile = "%s/etc/ssh/" %(data_config.MOUNTPOINT) + cp_and_log2(srcfile, destfile, '*.pub') + cp_and_log2(srcfile, destfile, '*.key') + cp_and_log2(srcfile, destfile, '*key') + + mdfile = mdadm_find("/tmp") + cp_and_log("/tmp"+mdfile, data_config.MOUNTPOINT+"/etc") + + srcfile = "%s/etc.old/asound.conf" %(data_config.MOUNTPOINT) + destfile = "%s/etc/asound.conf" %(data_config.MOUNTPOINT) + cp_and_log(srcfile, destfile) + + # R5.5 -> R6 + srcfile = "%s/alsa.old/asound.state" %(data_config.MOUNTPOINT) + destfile = "%s/etc/asound.state" %(data_config.MOUNTPOINT) + cp_and_log(srcfile, destfile) + # R6 -> R6 + srcfile = "%s/etc.old/asound.state" %(data_config.MOUNTPOINT) + destfile = "%s/etc/asound.state" %(data_config.MOUNTPOINT) + cp_and_log(srcfile, destfile) + + srcfile = "%s/etc.old/mplayer/mplayer.conf" %(data_config.MOUNTPOINT) + destfile = "%s/etc/mplayer/mplayer.conf" %(data_config.MOUNTPOINT) + cp_and_log(srcfile, destfile) + + if not os.path.exists("/tmp/etc/KnoppMyth-version"): + logging.debug(" standard upgrade, restoring auth files") + cp_and_log(data_config.MOUNTPOINT+"/etc.old/passwd", data_config.MOUNTPOINT+"/etc/passwd") + cp_and_log(data_config.MOUNTPOINT+"/etc.old/shadow", data_config.MOUNTPOINT+"/etc/shadow") + cp_and_log(data_config.MOUNTPOINT+"/etc.old/group", data_config.MOUNTPOINT+"/etc/group") + msg = "Configuring system" + + update_status(msg) + progress(98) + logging.info("______Configuring system________") + cp_and_log("/etc/systemconfig", data_config.MOUNTPOINT+"/etc/systemconfig") + if not backup_sql_check(): + upgrade_mount_search() + fstab_it("upgrade") + time.sleep(1) + grub_it() + time.sleep(1) + #needed to get around a bug with pacman + special_hardware_check() + cp_and_log("/root/xorg.conf.install", data_config.MOUNTPOINT+"/etc/X11/xorg.conf.install") + cp_and_log("/etc/mtab", data_config.MOUNTPOINT+"/etc/mtab") + if clean_upgrade() or os.path.exists("/tmp/etc/KnoppMyth-version"): + logging.debug("clean upgrade or knoppmyth upgrade detected, running restore settings") + restore_default_settings() + if clean_upgrade(): + file = "%s/%s/.kmupgrade" %(data_config.MOUNTPOINT, data_config.MYTHHOME) + cmd = "touch %s && chmod 777 %s" %(file, file) + runcmd(cmd) + copy_updates() + fix_permissions() + mount_bind_chroot() + logging.info("Running systemconfig in chroot") + #cmd = " chroot %s %s/bin/systemconfig.sh misc, hostype, network, advanced, user, this_is_install" %(data_config.MOUNTPOINT, MVROOT) + cmd = "chroot %s %s/bin/systemconfig.sh all,this_is_install" %(data_config.MOUNTPOINT, MVROOT) + rc = runcmd(cmd)[0] + if rc != 0 : + error_out("Running systemconfig") + mysqldb("stop", "") + if ( systemconfig["SystemType"] == "Master_backend" or systemconfig["SystemType"] == "Standalone" ): + if clean_upgrade() or not backup_sql_check(): + logging.info("Installing new database") + cmd = " chroot %s %s/bin/install_db_chroot.sh |tee /tmp/chrootdb.out" %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + else: + logging.info("Restoring database") + cmd = " chroot %s %s/bin/restore_km_db_chroot.sh %s|tee /tmp/chrootdb.out" %(data_config.MOUNTPOINT, MVROOT, hostoptions["backupfile"]) + runcmd(cmd) + + if os.path.exists("/tmp/etc/KnoppMyth-version"): + cmd = " chroot %s %s/bin/restore_default_settings.sh -c restore -t hostsettings " %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + logging.debug("Correcting permissions because of km->linhes upgrade") + cmd = " chown -R mythtv:mythtv %s" %(data_config.MOUNTPOINT+data_config.DATAMOUNT) + runcmd(cmd) + cmd = " chown -R root:root %s" %(data_config.MOUNTPOINT+data_config.DATAMOUNT+"/backup") + runcmd(cmd) + else: + cmd = " chroot %s %s/bin/restore_default_settings.sh -c restore -t syssettings " %(data_config.MOUNTPOINT, MVROOT) + runcmd(cmd) + + logging.info("Running systemconfig in chroot 2nd time") + #cmd = " chroot %s %s/bin/systemconfig.sh misc, hostype, network, advanced, user, this_is_install" %(data_config.MOUNTPOINT, MVROOT) + cmd = "chroot %s %s/bin/systemconfig.sh all,this_is_install" %(data_config.MOUNTPOINT, MVROOT) + rc = runcmd(cmd)[0] + if rc != 0 : + error_out("Running systemconfig") + #logging.info("Running systemconfig in chroot") + #cmd = " chroot %s %s/bin/systemconfig.sh advanced" %(data_config.MOUNTPOINT, MVROOT) + #runcmd(cmd) + mysqldb("stop", 'chroot') + apply_new_auth() + kill_dhcp_chroot() + umount_bind_chroot() + cp_and_log("/tmp/mythvantage_install.log", data_config.MOUNTPOINT+"/var/log/mythvantage_install.log") + cp_and_log("/tmp/mv_debug.log", data_config.MOUNTPOINT+"/var/log/mv_debug.log") + unmount_it() + msg = "Done" + update_status(msg) + mysqldb("start", '') + + + + +def main(argv): + global hostoptions + try: + opts, args = getopt.getopt(argv, 'c:h', ["help", "rootdisk=", "rootfs=", "rootsize=", "datafs=", "datasize=", "datadisk=", "swapsize=", "datapartition=" ] ) + except getopt.GetoptError, why: + print why + usage() + sys.exit(2) + hostoptions = {"op": 'null'} + for opt, arg in opts: + if opt in ("-h", "--help"): + usage() + sys.exit(0) + elif opt in ( "--rootdisk"): + hostoptions["rootdisk"] = arg + hostoptions["rootpartition"] = arg+str(1) + elif opt in ("--rootfs"): + hostoptions["rootfs"] = arg + elif opt in ("--rootsize"): + hostoptions["rootsize"] = arg + elif opt in ("--datafs"): + hostoptions["datafs"] = arg + elif opt in ("--datasize"): + hostoptions["datasize"] = arg + elif opt in ("--datadisk"): + hostoptions["datadisk"] = arg + elif opt in ("--datapartition"): + hostoptions["datapartition"] = arg + elif opt in ("--swapsize"): + hostoptions["swapsize"] = arg + + elif opt in ("-c"): + validop = ["full_install", "upgrade", "netboot", "find_upgrade"] + if arg not in validop: + logging.critical("-c %s is not a valid option", arg) + sys.exit(2) + else: + hostoptions["op"] = arg + try: + hostoptions["datadisk"] + except: + hostoptions["datadisk"] = hostoptions["rootdisk"] + hostoptions["datapartition"] = hostoptions["datadisk"]+str(3) + try: + hostoptions["datapartition"] + except: + hostoptions["datapartition"] = hostoptions["datadisk"]+str(3) + hostoptions["swappartition"] = hostoptions["rootdisk"] + str(2) + + + if ( hostoptions["op"] == "full_install" ) : + full_install(hostoptions) + elif (hostoptions["op"] == "upgrade" ) : + hostoptions["datafs"] = "no_format" + find_upgrade() + upgrade(hostoptions) + elif (hostoptions["op"] == "find_upgrade" ) : + find_upgrade() + return hostoptions + + +#____________________________________________setup the logging______________________________________________________ +LOG_FILENAME = '/tmp/mv_status.log' +DEBUGLOG = '/tmp/mv_debug.log' +logging.basicConfig(level=logging.DEBUG, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + datefmt='%m-%d %H:%M', + filename=DEBUGLOG, + filemode='a') +# define a Handler which writes INFO messages or higher to the sys.stderr +console = logging.StreamHandler() +console.setLevel(logging.INFO) +# set a format which is simpler for console use +#formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') +formatter = logging.Formatter("%(message)s") +# tell the handler to use this format +console.setFormatter(formatter) +# add the handler to the root logger +logging.getLogger('').addHandler(console) + +#infoformatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") +infoformatter = logging.Formatter("%(message)s") +infofile = logging.FileHandler(LOG_FILENAME, 'w') +infofile.setFormatter(infoformatter) +infofile.setLevel(logging.INFO) +logging.getLogger('').addHandler(infofile) + +#Read in systemconfig +global systemconfig +systemconfig = {} +file_name = "/etc/systemconfig" +try: + config_file = open(file_name) +except: + logging.debug("%s could not be opened", file_name) + config_file = '' + +for line in config_file: + line = line.strip() + if line and line[0] is not "#" and line[-1] is not "=": + var, val = line.rsplit("=", 1) + val = val.strip('"') + systemconfig[var.strip()] = val.strip() + + +if __name__ == "__main__": + config_file = "mv_config" + data_config = __import__(config_file, globals(), locals(), []) + logging.debug("___________START OF DEBUG_________________________") + cmdoptions = main(sys.argv[1:]) + logging.debug("______cmd line options______") + for i in cmdoptions.items(): + logging.debug (i) + logging.debug("______systemconfig______") + for i in systemconfig.items(): + logging.debug(i) + logging.debug("______hostoptions______") + for i in hostoptions.items(): + logging.debug(i) + pass + |