#!/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"
        #newer versions of lsof show /dev/pts bind mounts
        #even after they are umounted
        cmd = "fuser -mk /new_boot"
        runcmd(cmd)
    except:
        logging.debug("!!!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 /root/linhes_install/mount2.28.2.tar.xz -C /root/linhes_install/'
    rc = runcmd(cmd)[0]
    if rc != 0 :
        error_out("Failed to extract static mount from /root/linhes_install/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 = '/root/linhes_install/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='/root/linhes_install/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 /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 /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 = '''# <file system>        <dir>         <type>    <options>          <dump> <pass> \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)

        mysqldb("start","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")

        #move_myth_home("backup")

        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

