#!/usr/bin/python2 # -*- coding: utf-8 -*- import sys, os, commands, glob, time import getopt, re, MySQLdb import logging try: import parted except: print "module parted not found" sys.exit(1) 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" print "" print "Alt usage involves reading config from a file" print "The conf file is read when no command line options are given" print " /etc/systemconfig must also be present " print "Create /etc/install_layout, with contents similiar to this. Sizes are in MB" print " rootdisk=sda" print " rootfs=ext4" print " rootsize=5000" print " datafs=reiserfs" print " datasize=all" print " datadisk=sda" print " swapsize=200" print " op=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 #force kill try: cmd = "lsof -t /new_boot|xargs kill -9" runcmd(cmd) except: print " !!!Problem killing all /new_boot pids" 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"].strip() 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 inchroot == "chroot": if cmd == "start": cmd = "chroot /new_boot /etc/rc.d/mysqld start" elif cmd == "stop": cmd = " chroot /new_boot /etc/rc.d/mysqld stop" else: if cmd == "start": cmd = "systemctl start mysqld.service" elif cmd == "stop": cmd = "systemctl stop mysqld.service" #if inchroot == "chroot": # mycmd = " chroot /new_boot %s" %mycmd runcmd(cmd) 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) cmd = "parted %s --script -- mklabel msdos" %diskdevice runcmd(cmd) logging.debug("partition 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: cmd = "parted %s --script -- mklabel msdos" %diskdevice runcmd(cmd) 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 find_next_start_sector(partition_list): newstart = 0 partlist = [] for partition in partition_list: 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 # print slice #Start the new partition one after the end of last newstart = usedend + 3 return newstart def create_partitions(diskdevice, size, ptype, startsector): logging.debug("_____Create partitions______") if size == "NO": logging.info("Size is 0, skipping") return "NO" # newstart = 0 totalused = 0 device = parted.getDevice(diskdevice) logging.debug(" Sector size is %s %s", diskdevice , device.sectorSize) partdisk = parted.Disk(device) #first set to all paritions partition_list = partdisk.partitions if ptype == "LOGICAL": #check for other logical: logical_partitions=partdisk.getLogicalPartitions() if logical_partitions == [] : logging.info(" First Logical drive, working with extended partition") newstart = partdisk.getExtendedPartition().geometry.start + 3 else: newstart = find_next_start_sector(logical_partitions) else: #all partitions partitionlist = partdisk.partitions newstart = find_next_start_sector(partition_list) if startsector == 0: newstart = 2048 if size == "all": logging.debug(" Using the rest of the disk %s", (device.length-newstart - 2048) ) try: geom = parted.Geometry(device=device, start=newstart, length=(device.length-newstart - 2048)) 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) if length > device.length: length = device.length - newstart logging.info("* Size is larger then disk, reducing size") logging.debug("* New 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() #constraint = parted.Constraint(device=device) constraint = parted.Constraint(exactGeom = geom ) # new partition if ptype == "NORMAL": newpart = parted.Partition(disk=partdisk, type=parted.PARTITION_NORMAL, geometry=geom) elif ptype == "EXTENDED": newpart = parted.Partition(disk=partdisk, type=parted.PARTITION_EXTENDED, geometry=geom) elif ptype == "LOGICAL": newpart = parted.Partition(disk=partdisk, type=parted.PARTITION_LOGICAL, 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 %s partition %s of %dMB and added it to %s" % (ptype,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) ##create extended partition #hostoptions["extended_partition"] = create_partitions("/dev/"+rootdisk, "all", "EXTENDED", 1) ##create the logical in the extended #hostoptions["home_partition"] = create_partitions("/dev/"+rootdisk, hostoptions["homesize"], "LOGICAL", 1) #hostoptions["sql_partition"] = create_partitions("/dev/"+rootdisk, hostoptions["sqlsize"], "LOGICAL", 1) #if datadisk != rootdisk: #hostoptions["datapartition"] = create_partitions("/dev/"+datadisk, hostoptions["datasize"], "NORMAL", 0) #else: #hostoptions["datapartition"] = create_partitions("/dev/"+datadisk, hostoptions["datasize"], "LOGICAL", 1) #logging.debug("sleeping for 5 seconds") #time.sleep(5) #parted /dev/sda -a optimal --script mklabel gpt #parted /dev/sda -a optimal --script unit MB -- mkpart primary 1 500 #parted /dev/sda -a optimal --script unit MB -- mkpart swap 501 600 #parted /dev/sda -a optimal --script unit MB -- mkpart primary 601 601 #parted /dev/sda -a optimal --script unit MB -- mkpart primary 601 601 #parted /dev/sda -a optimal --script unit MB -- mkpart primary 604 700 #parted /dev/sda -a optimal --script unit MB -- mkpart primary 700 800 #parted /dev/sda -a optimal --script unit MB -- mkpart primary 800 -1 def create_partitions_gpt(diskdevice, start,size,partition_type): logging.debug("_____Create partitions gpt ______") if size == "NO" or size == "no": logging.info("Size is 0, skipping") last_sector = start elif size == "all" or size == "ALL": logging.info("Size is all, using rest of disk") last_sector = "-1" else: last_sector = start + int(size) cmd = "parted %s -a optimal --script unit MB -- mkpart primary %s %s" %(diskdevice, start, last_sector) runcmd(cmd) newstart = last_sector #print newstart return newstart def partition_disk(): global hostoptions logging.info("Partitioning") logging.debug("____start of partition_disk____") rootdisk = "/dev/%s" %(hostoptions["rootdisk"]) datadisk = "/dev/%s" %(hostoptions["datadisk"]) label = "root" partitions_removeall(rootdisk, label) label = "data" partitions_removeall(datadisk, label) #create gpt table cmd = "parted %s -a optimal --script mklabel gpt" %rootdisk runcmd(cmd) cmd = "parted %s -a optimal --script mklabel gpt" %datadisk runcmd(cmd) start_sector = 1 start_sector = create_partitions_gpt(rootdisk, start_sector, hostoptions["rootsize"], "primary") start_sector = create_partitions_gpt(rootdisk, start_sector, hostoptions["swapsize"], "primary") hostoptions["rootpartition"] = hostoptions["rootdisk"]+str(1) hostoptions["swappartition"] = hostoptions["rootdisk"] + str(2) hostoptions["home_partition"] = hostoptions["rootdisk"]+str(5) hostoptions["sql_partition"] = hostoptions["rootdisk"]+str(6) hostoptions["datapartition"] = hostoptions["datadisk"]+str(7) #create 1 blank to match up with extended/logical layout from 8.0 start_sector = create_partitions_gpt(rootdisk, start_sector, "NO", "primary") #create gtp boot start_sector = start_sector + 1 start_sector = create_partitions_gpt(rootdisk, start_sector, 2 , "primary") cmd = "parted %s set 4 bios_grub on" %rootdisk runcmd(cmd) #create home_partition start_sector = start_sector + 1 start_sector = create_partitions_gpt(rootdisk, start_sector, hostoptions["homesize"], "primary") ##create mysql start_sector = start_sector + 1 start_sector = create_partitions_gpt(rootdisk, start_sector, hostoptions["sqlsize"], "primary") start_sector = start_sector + 1 #create data if datadisk != rootdisk: create_partitions_gpt(datadisk, 1, hostoptions["datasize"], "primary") else: create_partitions_gpt(datadisk, start_sector, hostoptions["datasize"], "primary") #set active logging.debug("setting active partition for mbr") cmd = "parted %s set 1 boot on" %rootdisk runcmd(cmd) cmd = "sfdisk --force -A1 %s" %rootdisk runcmd(cmd) logging.debug("sleeping for 5 seconds") 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":"no_format", "no_format":"no_format", "btrfs":"mkfs.btrfs"} 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"]) sqlfs = fscmd(hostoptions["sqlfs"]) homefs = fscmd(hostoptions["homefs"]) rootdisk = hostoptions["rootdisk"] datadisk = hostoptions["datadisk"] rootpartition = hostoptions["rootpartition"] datapartition = hostoptions["datapartition"] homepartition = hostoptions["home_partition"] sqlpartition = hostoptions["sql_partition"] #if install_type != "upgrade": #swapsize = hostoptions["swapsize"] #swappartition = hostoptions["swappartition"] if install_type == "install": swappartition = hostoptions["swappartition"] 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(" Format command for rootfs %s : %s ", rootfs, rootpartition) if ( rootfs != "no_format"): logging.info(" Starting %s format of %s", rootfs, 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 != "no_format"): logging.info(" Starting format %s of %s", datafs, datapartition) cmd = " %s /dev/%s" %( datafs, datapartition) #os.system(cmd) runcmd(cmd) else: logging.info(" Will not format data partition: %s", datapartition) #for upgrades format is set to no_format if ( homefs != "no_format"): logging.info(" Starting format %s of %s", homefs, homepartition) cmd = " %s /dev/%s" %( homefs, homepartition) #os.system(cmd) runcmd(cmd) else: logging.info(" Will not format home partition: %s", homepartition) if ( sqlfs != "no_format"): logging.info(" Starting format %s of %s", sqlfs, sqlpartition) cmd = " %s /dev/%s" %( sqlfs, sqlpartition) #os.system(cmd) runcmd(cmd) else: logging.info(" Will not format sql partition: %s", sqlpartition) logging.debug(" Format command for datafs %s : %s ", datafs, datapartition) if (datafs != "no_format"): logging.info(" Starting format %s of %s", datafs, datapartition) cmd = " %s /dev/%s" %( datafs, datapartition) #os.system(cmd) runcmd(cmd) else: logging.info(" Will not format data partition: %s", datapartition) 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) # 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) #mount home try: mountpoint = data_config.MOUNTPOINT homepoint = data_config.HOMEMOUNT mp = mountpoint+homepoint logging.info(" Creating mountpoints %s", mp) os.makedirs(mp) except OSError: logging.debug(" Could not create %s", mp) cmd = "mount /dev/%s %s" %(hostoptions["home_partition"], mp) runcmd(cmd) #mount sql try: mountpoint = data_config.MOUNTPOINT sqlpoint = data_config.SQLMOUNT mp = mountpoint+sqlpoint logging.info(" Creating mountpoints %s", mp) os.makedirs(mp) except OSError: logging.debug(" Could not create %s", mp) cmd = "mount /dev/%s %s" %(hostoptions["sql_partition"], mp) runcmd(cmd) def unmount_it(): logging.info("______Unmounting disk______") cmd = "mount -v |grep new_boot" mp_list=[] mplist=[] mountpoint = runcmd(cmd)[1] mplist="".join(mountpoint).split("\n") for i in mplist: mp = i.split()[2] mp_list.append(mp) mp_list.sort(key = len, reverse=True) for i in mp_list: cmd = "umount %s" %(i) runcmd(cmd) time.sleep(1) cmd = "umount %s" %(data_config.MOUNTPOINT+data_config.DATAMOUNT) runcmd(cmd) time.sleep(2) cmd = "umount %s" %(data_config.MOUNTPOINT+data_config.HOMEMOUNT) runcmd(cmd) time.sleep(2) cmd = "umount %s" %(data_config.MOUNTPOINT+data_config.SQLMOUNT) 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 swapon(): logging.info("______starting swap______") cmd = "swapon /dev/%s" %(hostoptions["swappartition"]) 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 mount_for_copy_it(): #Use static build mount and umount from mount2.28.2.tar.xz #Versions of util-linux mount after 2.28.2 do not allow 1 image to be # mounted to multiple loop devices. #Our ISO mounts airootfs.img to both / and /image_mount cmd = 'tar -xvf /tmp/mount2.28.2.tar.xz -C /tmp/' rc = runcmd(cmd)[0] if rc != 0 : error_out("Failed to extract static mount from /tmp/mount2.28.2.tar.xz") mounts = {} mounts['/image_mount'] = 'airootfs' for image_mount, fsimage in mounts.iteritems(): try: os.makedirs(image_mount) except: pass cmd = '/tmp/mount /run/archiso/sfs/%s/%s.img %s' %(fsimage,fsimage,image_mount) rc = runcmd(cmd)[0] if rc != 0 : error_out("Mount image %s" %fsimage) def umount_for_copy_it(): mounts = {} mounts['/image_mount'] = 'airootfs' for image_mount, fsimage in mounts.iteritems(): cmd='/tmp/umount %s' %(image_mount) rc = runcmd(cmd)[0] if rc != 0 : error_out("unMount image %s" %image_mount) def copy_it(install_type): logging.info("______Transferring to disk______") mount_for_copy_it() logging.debug( install_type) if ( install_type == "install"): logging.info("Transferring system") cmdlist = ['rsync -arp --exclude var-lib-pacman --exclude boot-orig --exclude tmp/mount2.28.2.tar.xz /image_mount/* /new_boot'] for cmd in cmdlist: rc = runcmd(cmd)[0] if rc != 0 : error_out("Running %s" %cmd) if ( install_type == "upgrade"): logging.info("Upgrading system") cmdlist = ['rsync -arp --exclude var-lib-pacman --exclude boot-orig --exclude tmp/mount2.28.2.tar.xz --exclude /home --exclude /data/srv/mysql /image_mount/* /new_boot'] for cmd in cmdlist: rc = runcmd(cmd)[0] if rc != 0 : error_out("Running %s" %cmd) # Create the missing dir i = ("sys", "proc", "dev", "tmp", "mnt", "media", "media/cdrom", "media/dvd", "var/lock", "var/tmp", "usr/lib/locale") 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) #copy of locale cp_and_log("/usr/lib/locale/locale-archive", data_config.MOUNTPOINT+"/usr/lib/locale/locale-archive") #copy dhcpcd lease and duid file #needed to retain dhcp address between reboots. cp_and_log("/etc/dhcpcd.duid", data_config.MOUNTPOINT+"/etc/dhcpcd.duid") cp_and_log("/var/lib/dhcpcd/*.lease", data_config.MOUNTPOINT+"/var/lib/dhcpcd/") # General fixup cmd = "chmod 777 %s/tmp" %(data_config.MOUNTPOINT) runcmd(cmd) cmd = "chmod 1777 %s/var/lock" %(data_config.MOUNTPOINT) runcmd(cmd) cmd = "chmod 1777 %s/var/tmp" %(data_config.MOUNTPOINT) runcmd(cmd) cmd = "chmod 755 %s/usr/lib/locale" %(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) #sys.exit(3) apply_pristine() post_process() umount_for_copy_it() 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 = '''# \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 / %s defaults,noatime 0 1\n''' %(hostoptions["rootfs"]) fstab_list.append(line) line = '''UUID=DATAUID %s %s defaults,noatime 0 1\n''' %(data_config.DATAMOUNT,hostoptions["datafs"]) fstab_list.append(line) line = '''UUID=HOMEUID %s %s defaults,noatime 0 1\n''' %(data_config.HOMEMOUNT,hostoptions["homefs"]) fstab_list.append(line) line = '''UUID=SQLUID %s %s defaults,noatime 0 1\n''' %(data_config.SQLMOUNT,hostoptions["sqlfs"]) 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 acl_options(partition): logging.info(" Finding mount options for %s...", partition) acl_fs_list=["ext3","ext4"] options = "defaults,noatime" cmd = "/sbin/fsck -N /dev/%s" %partition cmdoutput = runcmd(cmd)[1] output = cmdoutput.split("\n") fs_map=[] for i in output: if i.startswith("["): split_line=i.split() #find mount_p and remove the last char mount_p = split_line[3][:-1] fstype = split_line[4].split(".")[1] append_tuple=(mount_p,fstype) fs_map.append(append_tuple) rc = False print fs_map for i in fs_map: if i[0] == "/dev/%s" %partition: if i[1] in acl_fs_list: rc=True logging.info(" Will add acl to the list of options: %s ", rc ) return rc 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"]) datacl = acl_options(hostoptions["datapartition"]) logging.info("____UUID check for %s", "root") rootuuid = find_uuid(hostoptions["rootpartition"]) rootacl = acl_options(hostoptions["rootpartition"]) logging.info("____UUID check for %s", "home") homeuuid = find_uuid(hostoptions["home_partition"]) homeacl = acl_options(hostoptions["home_partition"]) logging.info("____UUID check for %s", "sql") sqluuid = find_uuid(hostoptions["sql_partition"]) sqlacl = acl_options(hostoptions["sql_partition"]) 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.strip("\n") == '': continue #FIX ALL MOUNTS THAT START WITH UUID if line.startswith("UUID"): templine = line.split() if ( templine[1] == "/"): logging.debug(" Found Root fstab line:") logging.debug( templine) templine[0] = "UUID=%s" %(rootuuid) if rootacl: templine[3] = templine[3]+",acl" newline = '' for i in templine: newline+=i newline+=" " newline+="\n" logging.debug(" New fstab line:") logging.debug( newline) newfstab.append(newline) elif ( templine[1] == data_config.DATAMOUNT): logging.debug(" Found DATA mount") logging.debug( templine) templine[0] = "UUID=%s" %(datauuid) if datacl: templine[3] = templine[3]+",acl" newline = '' for i in templine: newline+=i newline+=" " newline+="\n" logging.debug(" New fstab line:") logging.debug( newline) newfstab.append(newline) elif ( templine[1] == data_config.HOMEMOUNT): logging.debug(" Found HOME mount") logging.debug( templine) templine[0] = "UUID=%s" %(homeuuid) if homeacl: templine[3] = templine[3]+",acl" newline = '' for i in templine: newline+=i newline+=" " newline+="\n" logging.debug(" New fstab line:") logging.debug( newline) newfstab.append(newline) elif ( templine[1] == data_config.SQLMOUNT): logging.debug(" Found database mount") logging.debug( templine) templine[0] = "UUID=%s" %(sqluuid) if sqlacl: templine[3] = templine[3]+",acl" newline = '' for i in templine: newline+=i newline+=" " newline+="\n" logging.debug(" New fstab line:") logging.debug( newline) newfstab.append(newline) elif ( 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) 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: if line.strip("\n") == '': continue logging.debug(line) f.write(line) #f.write("\n") f.close() def install_kernel_it(): logging.info("______Start of kernel install______") cmd = "chroot %s pacman --noconfirm -S linux" %(data_config.MOUNTPOINT) logging.info(" Running pacman to install kernelinstall") runcmd(cmd) def grub_it(): logging.info("______Start of grub install______") cmd = "chroot %s grub-install --target=i386-pc --recheck --debug /dev/%s" %(data_config.MOUNTPOINT,hostoptions["rootdisk"]) logging.info(" Running grub-install") runcmd(cmd) cmd = " mkinitcpio -g %s/boot/initramfs-linux.img" %(data_config.MOUNTPOINT) logging.info("Running mkinitcpio") runcmd(cmd) newgrub = [] grubfile = data_config.MOUNTPOINT+"/etc/default/grub" try: f = open(grubfile, 'r') oldgrub = f.readlines() f.close() except: logging.debug(" Couldn't open grub file for reading") pass time_line = "GRUB_TIMEOUT=" hidden_time = "GRUB_HIDDEN_TIMEOUT=" color_line_normal = "GRUB_COLOR_NORMAL" color_line_highlight = "GRUB_COLOR_HIGHLIGHT" for line in oldgrub: new_line=line if line.find(time_line) != -1 : new_line="GRUB_TIMEOUT=0\n" if line.find(color_line_normal) != -1 : #new_line=line.lstrip('''#''') new_line='''GRUB_COLOR_NORMAL="white/blue"\n''' if line.find(color_line_highlight) != -1 : #new_line=line.lstrip('''#''') new_line='''GRUB_COLOR_HIGHLIGHT="black/yellow"\n''' if line.find(hidden_time) != -1 : new_line="GRUB_HIDDEN_TIMEOUT=3\n" newgrub.append(new_line) if len(newgrub) > 0: try: f = open(grubfile, 'w') for line in newgrub: logging.debug(line) f.write(line) f.close() except: logging.debug(" Couldn't open grub file for writing") cmd="chroot %s grub-mkconfig -o /boot/grub/grub.cfg" %data_config.MOUNTPOINT runcmd(cmd) def double_mount(fe_only=False, upgrade=False): logging.info(" double bind mount attempt") cmd = "mkdir %s/run/dbus" %data_config.MOUNTPOINT runcmd(cmd) cmd = " mount --bind /run/dbus %s/run/dbus" %data_config.MOUNTPOINT runcmd(cmd) for i in range(0,5): if upgrade == True: cmd = "chroot " + data_config.MOUNTPOINT +" /usr/LH/bin/add_storage.py --reconstruct --no_mount" else: if fe_only == True: cmd = "chroot " + data_config.MOUNTPOINT +" /usr/LH/bin/add_storage.py --double_myth --no_mount" else: #cmd = "chroot " + data_config.MOUNTPOINT +" /usr/LH/bin/add_storage.py --double_myth --no_mount" cmd = "chroot " + data_config.MOUNTPOINT +" /usr/LH/bin/add_storage.py --double_myth --add_sg" if runcmd(cmd)[0] == 0: logging.debug(" Add storage worked, breaking out of loop") break cmd = " umount %s/run/dbus" %data_config.MOUNTPOINT runcmd(cmd) def move_myth_home(op): logging.debug(" storage op %s" %op ) if op == "restore": destfile = "/storage/data/" srcfile = "/storage/data.old/*" cmd = 'chroot %s bash -c "mv %s %s"' %(data_config.MOUNTPOINT,srcfile,destfile) runcmd(cmd) rmfile = "%s/storage/data.old" %data_config.MOUNTPOINT cmd = "rmdir %s" %rmfile runcmd(cmd) if op == "backup": srcfile = "%s/storage/data" %data_config.MOUNTPOINT destfile = "%s/storage/data.old" %data_config.MOUNTPOINT cmd = "mv %s %s" %(srcfile,destfile) runcmd(cmd) def genlocale(): return logging.info("Generating locales") locale_list=[ "en_US ISO-8859-1", "en_US.UTF-8 UTF-8" , "de_DE.UTF-8", "da_DK.utf8", "en_DK.utf8", "it_IT.utf8", "de_DE.UTF-8"] #locale_list=['UTF-8', 'en_US ISO-8859-1'] localefile="%s/etc/locale.gen" %data_config.MOUNTPOINT f = open(localefile) lines = f.readlines() f.close() f = open(localefile,'w') for line in lines: outline = line for locale in locale_list: #print locale, line if locale in line: outline = line.replace('#','') f.write(outline) f.close() #cp_and_log("/tmp/locale.gen.new", data_config.MOUNTPOINT+"/etc/locale.gen") cmd = "chroot " + data_config.MOUNTPOINT +" /usr/sbin/locale-gen" runcmd(cmd) 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) cmd = " chmod +s %s" %(data_config.MOUNTPOINT+"/usr/bin/ping") runcmd(cmd) def apply_new_auth(): logging.info("_____Applying Password updates_______") passfile = "/root/myth_user_call.out" try: MVROOT = os.environ["MV_ROOT"].strip() 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/modprobe.d/install-blacklist.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, 'a') except: logging.critical(" *Couldn't open %s for reading",rcfile) return line = "blacklist %s \n" %module f.write(line) line = "install %s /bin/false \n" %module f.write(line) f.close() #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/modules-load.d/install-autoload.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, 'a+') except: logging.critical(" *Couldn't open %s for writing",rcfile) return line = "%s" %module f.write(line) f.write("\n") f.close() #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(): outlist = [] 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) or (re.match("modprobe.blacklist",item) != None ): logging.debug(" Found disabledmodules") outlist.append(item) modulelist = item.split("=")[1] for module in modulelist.split(','): add_to_blacklist(module) if re.match("modules",item) != None : logging.debug(" Found modules") outlist.append(item) 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) if len(outlist) != 0: outfile = data_config.MOUNTPOINT + "/etc/grub.d/install_modules" logging.debug(" Writing out %s" %outfile) try: f = open(outfile, 'w') templine = ' '.join(outlist) outline = '''install_modules='%s' \n''' %templine f.write(outline) f.write("\n") f.close() except: logging.critical(" *Couldn't write %s" %outfile) return 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/myth_settings_wrapper.sh -c save -t syssettings -h %s -d localhost" %(MVROOT, data_config.MVHOSTNAME) runcmd(cmd) SE = os.environ["TEMPLATES"]+"/settings/syssettings/" #this is needed because the settings dir is no longer part of the templates pkg cmd="mkdir -p %s" %(data_config.MOUNTPOINT+SE) runcmd(cmd) cp_and_log(SE, data_config.MOUNTPOINT+SE) cp_and_log("/etc/mtab", data_config.MOUNTPOINT+"/etc/mtab") copy_updates() fix_permissions() def apply_pristine(): logging.info("_____Applying Pristine files_______") if data_config.NOOPDEBUG == "FALSE": cmd = "chroot " + data_config.MOUNTPOINT + " " + "tar -xvf /pristine.tar" else: cmd = "echo chroot " + data_config.MOUNTPOINT + " " + "tar -xvf /pristine.tar" try: # Using os.system because runcmd fails logging.debug(cmd) os.system(cmd) except: logging.debug("Applying pristine files failed %s", passfile) logging.debug try: removefile="%s/pristine.tar" %(data_config.MOUNTPOINT) os.remove(removefile) except OSError: logging.debug(" Couldn't remove pristine.tar") pass def post_process(): logging.info("_____Post processing_______") if data_config.NOOPDEBUG == "FALSE": cmd = "chroot " + data_config.MOUNTPOINT + " " + "/root/.post_process/go.sh" else: cmd = "echo chroot " + data_config.MOUNTPOINT + " " + "/root/.post_process/go.sh" try: # Using os.system because runcmd fails logging.debug(cmd) os.system(cmd) except: logging.debug("Applying post_process_failed %s", passfile) logging.debug def full_install(hostoptions): logging.info("______Start of full install______") try: MVROOT = os.environ["MV_ROOT"].strip() 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") #sys.exit(0) # 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() swapon() #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") #at this point /storage exisit and is populated with myth home dir #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) special_hardware_check() mount_bind_chroot() install_kernel_it() grub_it() umount_bind_chroot() genlocale() #currently does nothing logging.info("______Configuring system________") cp_and_log("/etc/systemconfig", data_config.MOUNTPOINT+"/etc/systemconfig") cp_and_log("/etc/install_layout", data_config.MOUNTPOINT+"/etc/install_layout") cp_and_log("/root/xorg.conf.install", data_config.MOUNTPOINT+"/etc/X11/xorg.conf.install") restore_default_settings() #also calls copy_updates, fix permissions #setup symlink mount_bind_chroot() logging.info("Running systemconfig in chroot") cmd = "chroot %s %s/bin/systemconfig.sh config_xml,this_is_install" %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) umount_bind_chroot() 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 all,this_is_install" %(data_config.MOUNTPOINT, MVROOT) rc = runcmd(cmd)[0] if rc != 0 : error_out("Running systemconfig") #move_myth_home("backup") mysqldb("start","chroot") double_mount() mysqldb("stop", "chroot") #move_myth_home("restore") #restoring after the bind mound/symlink has occured #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) #move_myth_home("backup") if systemconfig["SystemType"] == "Slave_backend": double_mount() else: double_mount(fe_only=True) #move_myth_home("restore") # Need to check for to touch /tmp/.dbsysfailed #cmd = " chroot %s %s/bin/myth_settings_wrapper.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") #restore defaults here! cmd = "chroot %s %s/bin/myth_settings_wrapper.sh -c restore -t distro_default " %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) cmd = "chroot %s %s/bin/myth_settings_wrapper.sh -c restore -t syssettings " %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) cmd = "chroot %s %s/bin/myth_settings_wrapper.sh -c ACCESSCONTROL " %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) #run hostype again to set BackendServerIP. This value is overwritten with distro_default restore cmd = "chroot %s %s/bin/systemconfig.sh hostype,this_is_install" %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) umount_bind_chroot() cmd = "chroot %s touch %s/.configure" %(data_config.MOUNTPOINT, data_config.MYTHHOME) runcmd(cmd) cmd = "chroot %s chmod 777 %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") kill_dhcp_chroot() 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" TEMPLATE_ = os.environ["TEMPLATES"]+"/settings" 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, TEMPLATE_, '*') 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") cp_and_log("/tmp/etc/dhcpcd.duid", "/etc/dhcpcd.duid") else: logging.info("Could not find systemconfig file %s", srcfile) cp_and_log(data_config.MOUNTPOINT+"/etc/", "/tmp/etc/") cp_and_log("/tmp/etc/dhcpcd.duid", "/etc/dhcpcd.duid") 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 = '' oldfscontents="#" 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"].strip() except: logging.debug("MVROOT was not defined, using the default value") MVROOT = "/usr/MythVantage" hostoptions["backupfile"] = data_config.BACKUPPATH+data_config.BACKUPFILE logging.info("______Start of upgrade______") cmd = "touch /tmp/.this_is_upgrade" runcmd(cmd) #format disk 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") #mount partitions statusmsg = "Mounting %s" %( hostoptions["rootdisk"]) update_status(statusmsg) progress(3) mount_it() swapon() hostoptions["backupfile"] = data_config.BACKUPPATH+data_config.BACKUPFILE #Find number of bytes written to disk before starting copy. This is used to #give a somewhat decent progress indication statgrab( hostoptions["rootdisk"]) msg = "Upgrading %s" %(systemconfig["hostname"]) update_status(msg) time.sleep(3) #copy system to disk copy_it("upgrade") #Restore /etc and key files. This is the copy found when running find_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') srcfile = "%s/etc.old/storage.d/" %(data_config.MOUNTPOINT) destfile = "%s/etc/storage.d/" %(data_config.MOUNTPOINT) cp_and_log2(srcfile, destfile, '*.conf') cp_and_log2(srcfile, destfile, '*.pkl') #ctn interfaces srcfile = "%s/etc.old/net/ifaces/" %(data_config.MOUNTPOINT) destfile = "%s/etc/net/ifaces/" %(data_config.MOUNTPOINT) cp_and_log2(srcfile, destfile, 'ctn*') 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") #configure system msg = "Configuring system" update_status(msg) progress(98) logging.info("______Configuring system________") cp_and_log("/etc/systemconfig", data_config.MOUNTPOINT+"/etc/systemconfig") #New partition layout, we do not need to search for backup file #if not backup_sql_check(): #upgrade_mount_search() #check fstab, see if it needs any updates fstab_it("upgrade") time.sleep(1) special_hardware_check() mount_bind_chroot() grub_it() umount_bind_chroot() genlocale() time.sleep(1) cp_and_log("/root/xorg.conf.install", data_config.MOUNTPOINT+"/etc/X11/xorg.conf.install") #this was needed to get around a pacman bug 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) #these are also run by restore_default_settings in install copy_updates() fix_permissions() mount_bind_chroot() apply_new_auth() umount_bind_chroot() #logging.info("Running systemconfig in chroot") #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(): mysqldb("stop", "") mount_bind_chroot() logging.info("Installing new database") cmd = "chroot %s %s/bin/install_db_chroot.sh |tee /tmp/chrootdb.out" %(data_config.MOUNTPOINT, MVROOT) runcmd(cmd) umount_bind_chroot() #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/myth_settings_wrapper.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/myth_settings_wrapper.sh -c restore -t syssettings " %(data_config.MOUNTPOINT, MVROOT) #runcmd(cmd) #run systemconfig in chroot mount_bind_chroot() #make symlink only..no need to double_mount as fstab should already have that, unless it's a clean upgrade double_mount(upgrade=True) logging.info("Running systemconfig in chroot") 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") umount_bind_chroot() kill_dhcp_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): print install_conf global hostoptions hostoptions = {} conflist=["op", "rootdisk","rootfs","rootsize", "datafs","datasize","datadisk","datapartition", "swapsize", "homesize","homefs", "sqlsize","sqlfs", "uprootfs"] for i in conflist: try: hostoptions[i] = install_conf[i].lower() except: pass try: #op is not set for find_upgrade if hostoptions["op"] == "upgrade": #rootfs is used by both upgrade and install hostoptions["rootfs"] == hostoptions["uprootfs"] except: pass 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 validop = ["full_install", "upgrade", "netboot", "find_upgrade"] if hostoptions["op"] not in validop: logging.critical("-c %s is not a valid option", hostoptions["op"]) sys.exit(2) if ( hostoptions["op"] == "upgrade") or ( hostoptions["op"] == "find_upgrade" ) or (data_config.NOOPDEBUG != "FALSE"): hostoptions["datafs"] = "no_format" hostoptions["homefs"] = "no_format" hostoptions["sqlfs"] = "no_format" print "hi" #hardcoding partitions hostoptions["rootpartition"] = hostoptions["rootdisk"]+str(1) ##hardcoded partition 1 hostoptions["swappartition"] = hostoptions["rootdisk"] + str(2) try: hostoptions["datadisk"] except: hostoptions["datadisk"] = hostoptions["rootdisk"] #home/sql do not needed to be valid values for the upgrade, but using real values for reference try: hostoptions["home_partition"] except: hostoptions["home_partition"] = hostoptions["rootdisk"]+str(5) try: hostoptions["sql_partition"] except: hostoptions["sql_partition"] = hostoptions["rootdisk"]+str(6) try: hostoptions["datapartition"] except: hostoptions["datapartition"] = hostoptions["datadisk"]+str(7) if ( hostoptions["op"] == "full_install" ) : full_install(hostoptions) elif (hostoptions["op"] == "upgrade" ) : 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() #Read in install_conf global install_conf install_conf = {} file_name = "/etc/install_layout" 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('"') install_conf[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