Updated DiskUtils with raid disk details and review changes

3 files changed, 760 insertions, 63 deletions

diff --git a/src/com.gluster.storage.management.server.scripts/src/DiskUtils.py b/src/com.gluster.storage.management.server.scripts/src/DiskUtils.py
index 8571a807..fc209c96 100644
--- a/src/com.gluster.storage.management.server.scripts/src/DiskUtils.py
+++ b/src/com.gluster.storage.management.server.scripts/src/DiskUtils.py
@@ -17,6 +17,7 @@
 
 import os
 import glob
+from copy import deepcopy
 import dbus
 import syslog
 import Globals
@@ -25,6 +26,7 @@ import time
 import Utils
 import Disk
 import Protocol
+from FsTabUtils import *
 
 ONE_MB_SIZE = 1048576
 
@@ -76,7 +78,7 @@ def getUuidByDiskPartition(device):
 
 
 def getDiskPartitionUuid(partition):
-    Utils.log("WARNING: getDiskPartitionUuid() is deprecated by getUuidByDiskPartition()")
+    Common.log("WARNING: getDiskPartitionUuid() is deprecated by getUuidByDiskPartition()")
     return getUuidByDiskPartition(partition)
 
 
@@ -90,7 +92,7 @@ def getDiskPartitionByLabel(label):
 
 
 def getDeviceByLabel(label):
-    Utils.log("WARNING: getDeviceByLabel() is deprecated by getDiskPartitionByLabel()")
+    Common.log("WARNING: getDeviceByLabel() is deprecated by getDiskPartitionByLabel()")
     return getDiskPartitionByLabel(label)
 
 
@@ -115,8 +117,45 @@ def getRootPartition(fsTabFile=Globals.FSTAB_FILE):
     return None
 
 
+def getRaidDisk():
+    array = []
+    arrayList = []
+    mdFound = False
+    
+    try:
+        fp = open("/proc/mdstat")
+        for line in fp:
+            str = line.strip()
+            if str.startswith("md"):
+                array.append(str)
+                mdFound = True
+                continue
+            if mdFound:
+                if str:
+                    array.append(str)
+                else:
+                    arrayList.append(array)
+                    array = []
+                    mdFound = False
+        fp.close()
+    except IOError, e:
+        return None
+                
+    raidList = {}
+    for array in arrayList:
+        raid = {}
+        tokens = array[0].split()
+        raid['status'] = tokens[2]
+        raid['type'] = tokens[3]
+
+        raid['disks'] = [x.split('[')[0] for x in tokens[4:]]
+        raid['size'] = float(array[1].split()[0]) / 1024.0
+        raidList[tokens[0]] = raid
+    return raidList
+
+
 def getOsDisk():
-    Utils.log("WARNING: getOsDisk() is deprecated by getRootPartition()")
+    Common.log("WARNING: getOsDisk() is deprecated by getRootPartition()")
     return getRootPartition()
 
 
@@ -133,8 +172,6 @@ def getDiskInfo(diskDeviceList=None):
 
     diskInfo = {}
     diskList = []
-    totalDiskSpace = 0
-    totalDiskUsage = 0
     for udi in storageUdiList:
         halDeviceObj = dbusSystemBus.get_object("org.freedesktop.Hal", udi)
         halDevice = dbus.Interface(halDeviceObj,
@@ -142,7 +179,6 @@ def getDiskInfo(diskDeviceList=None):
         if halDevice.GetProperty("storage.drive_type") in ["cdrom", "floppy"] or \
                 halDevice.GetProperty("block.is_volume"):
             continue
-
         disk = {}
         disk["Device"] = str(halDevice.GetProperty('block.device'))
         if diskDeviceList and disk["Device"] not in diskDeviceList:
@@ -154,6 +190,18 @@ def getDiskInfo(diskDeviceList=None):
             disk["Size"] = long(halDevice.GetProperty('storage.size')) / 1024**2
         disk["Interface"] = str(halDevice.GetProperty('storage.bus'))
         disk["DriveType"] = str(halDevice.GetProperty('storage.drive_type'))
+        disk["Status"] = None
+        if isDiskInFormatting(disk["Device"]):
+            disk["Status"] = "formatting in progress"
+        disk["Uuid"] = None
+        disk["Init"] = False
+        disk["Type"] = False
+        disk["FsType"] = None
+        disk["FsVersion"] = None
+        disk["MountPoint"] = None
+        disk["ReadOnlyAccess"] = None
+        disk["SpaceInUse"] = None
+        
         partitionList = []
         partitionUdiList = halManager.FindDeviceStringMatch("info.parent", udi)
         diskSpaceInUse = 0
@@ -164,35 +212,61 @@ def getDiskInfo(diskDeviceList=None):
                                                 "org.freedesktop.Hal.Device")
             if not partitionHalDevice.GetProperty("block.is_volume"):
                 continue
-            partition = {}
-            partition["Device"] = str(partitionHalDevice.GetProperty('block.device'))
-            partition["Uuid"] = str(partitionHalDevice.GetProperty('volume.uuid'))
-            partition["Size"] = long(partitionHalDevice.GetProperty('volume.size')) / 1024**2
-            partition["Fstype"] = str(partitionHalDevice.GetProperty('volume.fstype'))
-            partition["Fsversion"] = str(partitionHalDevice.GetProperty('volume.fsversion'))
-            partition["Label"] = str(partitionHalDevice.GetProperty('volume.label'))
-            partition["mountPoint"] = str(partitionHalDevice.GetProperty('volume.mount_point'))
-            partition["readOnlyAccess"] = str(partitionHalDevice.GetProperty('volume.is_mounted_read_only'))
-            partition["Used"] = 0L
+            partitionDevice = str(partitionHalDevice.GetProperty('block.device'))
             if partitionHalDevice.GetProperty("volume.is_mounted"):
                 rv = Utils.runCommandFG(["df", str(partitionHalDevice.GetProperty('volume.mount_point'))], stdout=True)
                 if rv["Status"] == 0:
                     try:
-                        partition["Used"] = long(rv["Stdout"].split("\n")[1].split()[2]) / 1024
-                        diskSpaceInUse += partition["Used"]
+                        used = long(rv["Stdout"].split("\n")[1].split()[2]) / 1024
+                        diskSpaceInUse += used
                     except IndexError:
                         pass
                     except ValueError:
                         pass
+
+            if disk["Device"] == partitionDevice:
+                disk["Uuid"] = str(partitionHalDevice.GetProperty('volume.uuid'))
+                disk["Init"] = True # TODO: use isDataDiskPartitionFormatted function to cross verify this!
+                mountPoint = str(partitionHalDevice.GetProperty('volume.mount_point'))
+                if "/export/" in mountPoint:
+                    disk["Type"] = True
+                disk["FsType"] = str(partitionHalDevice.GetProperty('volume.fstype'))
+                disk["FsVersion"] = str(partitionHalDevice.GetProperty('volume.fsversion'))
+                disk["MountPoint"] = str(partitionHalDevice.GetProperty('volume.mount_point'))
+                disk["ReadOnlyAccess"] = str(partitionHalDevice.GetProperty('volume.is_mounted_read_only'))
+                if not disk["Size"]:
+                    disk["Size"] = long(partitionHalDevice.GetProperty('volume.size')) / 1024**2
+                disk["SpaceInUse"] = used
+                continue
+            
+            partition = {}
+            partition["Init"] = False
+            partition["Type"] = False
+            partition["Status"] = None
+            if isDiskInFormatting(partitionDevice):
+                partition["Status"] = "formatting in progress"
+            partition["Interface"] = None # Partition will not have bus details, info.interfaces can be used here!
+            partition["Device"] = partitionDevice
+            partition["Uuid"] = str(partitionHalDevice.GetProperty('volume.uuid'))
+            partition["Size"] = long(partitionHalDevice.GetProperty('volume.size')) / 1024**2
+            partition["FsType"] = str(partitionHalDevice.GetProperty('volume.fstype'))
+            partition["FsVersion"] = str(partitionHalDevice.GetProperty('volume.fsversion'))
+            partition["Label"] = str(partitionHalDevice.GetProperty('volume.label'))
+            partition["MountPoint"] = str(partitionHalDevice.GetProperty('volume.mount_point'))
+            partition["Size"] = long(partitionHalDevice.GetProperty('volume.size')) / 1024**2
+            partition["SpaceInUse"] = used
+            if partition["MountPoint"] or isDataDiskPartitionFormatted(partitionDevice):
+                partition["Init"] = True
+            if "/export/" in partition["MountPoint"]:
+                partition["Type"] = True
+            partition["ReadOnlyAccess"] = str(partitionHalDevice.GetProperty('volume.is_mounted_read_only'))
+    
             partitionList.append(partition)
         disk["Partitions"] = partitionList
-        disk["Used"] = diskSpaceInUse
-        totalDiskSpace += disk["Size"]
-        totalDiskUsage += disk["Used"]
+        if not disk["SpaceInUse"]:
+            disk["SpaceInUse"] = diskSpaceInUse
         diskList.append(disk)
     diskInfo["disks"] = diskList
-    diskInfo["totalDiskSpace"] = totalDiskSpace
-    diskInfo["diskSpaceInUse"] = totalDiskUsage
     return diskInfo
 
 def getDiskList(diskDeviceList=None):
@@ -202,7 +276,7 @@ def readFsTab(fsTabFile=Globals.FSTAB_FILE):
     try:
         fsTabfp = open(fsTabFile)
     except IOError, e:
-        Utils.log("readFsTab(): " + str(e))
+        Common.log("readFsTab(): " + str(e))
         return None
     
     fsTabEntryList = []
@@ -228,7 +302,6 @@ def readFsTab(fsTabFile=Globals.FSTAB_FILE):
             pass
         if fsTabEntry["Device"] and fsTabEntry["MountPoint"] and fsTabEntry["FsType"] and fsTabEntry["Options"]:
             fsTabEntryList.append(fsTabEntry)
-            
     fsTabfp.close()
     return fsTabEntryList
         
@@ -274,7 +347,7 @@ def getDiskSizeInfo(partition):
     rv = Utils.runCommandFG(command, stdout=True, root=True)
     message = Common.stripEmptyLines(rv["Stdout"])
     if rv["Stderr"]:
-        Common.Utils.log(syslog.LOG_ERR, "failed to get disk details. %s" % Common.stripEmptyLines(rv["Stdout"]))
+        Common.log(syslog.LOG_ERR, "failed to get disk details. %s" % Common.stripEmptyLines(rv["Stdout"]))
         return None, None, None
     for line in rv["Stdout"].split("\n"):
         tokens = line.split()
@@ -304,7 +377,7 @@ def getDiskSizeInfo(partition):
     rv = Utils.runCommandFG(command, stdout=True, root=True)
     message = Common.stripEmptyLines(rv["Stdout"])
     if rv["Stderr"]:
-        Common.Utils.log(syslog.LOG_ERR, "failed to get disk details. %s" % Common.stripEmptyLines(rv["Stdout"]))
+        Common.log(syslog.LOG_ERR, "failed to get disk details. %s" % Common.stripEmptyLines(rv["Stdout"]))
         return None, None, None
     
     lines = rv["Stdout"].split(";\n")
@@ -325,7 +398,7 @@ def refreshHal():
     rv = Utils.runCommandFG(["lshal"], stdout=True, root=True)
     if rv["Stderr"]:
         error = Common.stripEmptyLines(rv["Stderr"])
-        Common.Utils.log(syslog.LOG_ERR, "failed to execute lshal command. Error: %s" % error)
+        Common.log(syslog.LOG_ERR, "failed to execute lshal command. Error: %s" % error)
         return False
     return True
 
@@ -369,52 +442,360 @@ def getDiskDom(diskDeviceList=None, bootPartition=None, skipDisk=None):
     if not diskList:
         return None
 
+    raidDiskPartitions = []
+    raidDisk = getRaidDisk()
+    for partition in raidDisk.values():
+        raidDiskPartitions += partition['disks']
+
     diskDom = Protocol.XDOM()
     disksTag = diskDom.createTag("disks", None)
-    disksTag.appendChild(diskDom.createTag("totalDiskSpace", diskInfo["totalDiskSpace"]))
-    disksTag.appendChild(diskDom.createTag("diskSpaceInUse", diskInfo["diskSpaceInUse"]))
+    raidPartitions = {}
+    raidDisks = {}
     if not bootPartition:
         bootPartition = getRootPartition()
     for disk in diskList:
         if skipDisk and disk["Device"] in skipDisk:
             continue
         diskTag = diskDom.createTag("disk", None)
-        diskTag.appendChild(diskDom.createTag("device", getDeviceName(disk["Device"])))
+        diskDevice = getDeviceName(disk["Device"])
+        diskTag.appendChild(diskDom.createTag("name", diskDevice))
         diskTag.appendChild(diskDom.createTag("description", disk["Description"]))
-        diskTag.appendChild(diskDom.createTag("size", str(disk["Size"])))
-        diskTag.appendChild(diskDom.createTag("used", str(disk["Used"])))
+        diskTag.appendChild(diskDom.createTag("uuid", disk["Uuid"]))
+        diskTag.appendChild(diskDom.createTag("status", disk["Status"]))
+        diskTag.appendChild(diskDom.createTag("init", str(disk["Init"]).lower()))
+        diskTag.appendChild(diskDom.createTag("type", str(disk["Type"]).lower()))
         diskTag.appendChild(diskDom.createTag("interface", disk["Interface"]))
-        if disk["Partitions"]:
-            diskTag.appendChild(diskDom.createTag("init", "yes"))
-        else:
-            diskTag.appendChild(diskDom.createTag("init", "no"))
+        diskTag.appendChild(diskDom.createTag("fsType", disk["FsType"]))
+        diskTag.appendChild(diskDom.createTag("fsVersion", disk["FsVersion"]))
+        diskTag.appendChild(diskDom.createTag("mountPoint", disk["MountPoint"]))
+        diskTag.appendChild(diskDom.createTag("size", disk["Size"]))
+        diskTag.appendChild(diskDom.createTag("spaceInUse", disk["SpaceInUse"]))
+        partitionsTag = diskDom.createTag("partitions", None)
         for partition in disk["Partitions"]:
             partitionTag = diskDom.createTag("partition", None)
             device =  getDeviceName(partition["Device"])
             partitionTag.appendChild(diskDom.createTag("name", device))
-            partitionTag.appendChild(diskDom.createTag("mountPoint", partition['mountPoint']))
-            if not partition["Uuid"]:
-                partitionTag.appendChild(diskDom.createTag("uuid", getUuidByDiskPartition("/dev/" + device)))
-            else:
+            if partition["Uuid"]: #TODO: Move this verification and findings to getDiskInfo function
                 partitionTag.appendChild(diskDom.createTag("uuid", partition["Uuid"]))
-            partitionTag.appendChild(diskDom.createTag("size", str(partition["Size"])))
-            partitionTag.appendChild(diskDom.createTag("free", str((partition["Size"] - partition["Used"]))))
-            partitionTag.appendChild(diskDom.createTag("used", partition["Used"]))
-            partitionTag.appendChild(diskDom.createTag("filesystem", partition["Fstype"]))
-            partitionTag.appendChild(diskDom.createTag("readOnlyAccess", partition["readOnlyAccess"]))
-            if partition['mountPoint'] or isDataDiskPartitionFormatted(partition["Device"]):
-                partitionTag.appendChild(diskDom.createTag("status", "READY"))
-            else:
-                partitionTag.appendChild(diskDom.createTag("status", "UNINITIALIZED"))
-            if "/export/" in partition["mountPoint"]:
-                partitionTag.appendChild(diskDom.createTag("dataDisk", "True"))
             else:
-                partitionTag.appendChild(diskDom.createTag("dataDisk", "False"))
-            if "/" == partition["mountPoint"]:
-                partitionTag.appendChild(diskDom.createTag("boot", "yes"))
-            else:
-                partitionTag.appendChild(diskDom.createTag("boot", "no"))
-            diskTag.appendChild(partitionTag)
-        disksTag.appendChild(diskTag)
+                partitionTag.appendChild(diskDom.createTag("uuid", getUuidByDiskPartition("/dev/" + device)))
+            partitionTag.appendChild(diskDom.createTag("status", partition["Status"]))
+            partitionTag.appendChild(diskDom.createTag("init", str(partition["Init"]).lower()))
+            partitionTag.appendChild(diskDom.createTag("type", str(partition["Type"]).lower()))
+            partitionTag.appendChild(diskDom.createTag("interface", partition["Interface"]))
+            partitionTag.appendChild(diskDom.createTag("filesystem", partition["FsType"]))
+            partitionTag.appendChild(diskDom.createTag("mountPoint", partition['MountPoint']))
+            partitionTag.appendChild(diskDom.createTag("size", partition["Size"]))
+            partitionTag.appendChild(diskDom.createTag("spaceInUse", partition["SpaceInUse"]))
+            if device in raidDiskPartitions:
+                raidPartitions[device] = partitionTag
+                continue
+            partitionsTag.appendChild(partitionTag)
+        diskTag.appendChild(partitionsTag)
+
+        if diskDevice in raidDiskPartitions:
+            raidDisks[diskDevice] = diskTag
+        else:
+            disksTag.appendChild(diskTag)
+
+
+    for rdisk in raidDisk.keys():
+        raidDiskTag = diskDom.createTag("disk", None)
+        raidDiskTag.appendChild(diskDom.createTag("name", rdisk))
+        if 'active' == raidDisk[rdisk]['status']:
+            raidDiskTag.appendChild(diskDom.createTag("status", "true"))
+        else:
+            raidDiskTag.appendChild(diskDom.createTag("status", "false"))
+        raidDiskTag.appendChild(diskDom.createTag("interface", raidDisk[rdisk]['type']))
+        raidDiskTag.appendChild(diskDom.createTag("size", raidDisk[rdisk]['size']))
+        raidDisksTag = diskDom.createTag("raidDisks", None)
+        raidDiskPartitionsTag = diskDom.createTag("partitions", None)
+        for disk in raidDisk[rdisk]['disks']:
+            if raidPartitions.has_key(disk):
+                raidDiskPartitionsTag.appendChild(raidPartitions[disk])
+            if raidDisks.has_key(disk):
+                raidDisksTag.appendChild(raidDisks[disk])
+        raidDisksTag.appendChild(raidDiskPartitionsTag)
+        raidDiskTag.appendChild(raidDisksTag)
+        disksTag.appendChild(raidDiskTag)
+    #disksTag.appendChild(raidDisksTag)
     diskDom.addTag(disksTag)
     return diskDom
+
+
+def initializeDisk(disk, boot=False, startSize=0, sudo=False):
+    if boot and startSize > 0:
+        return False
+
+    disk = getDevice(disk)
+    diskObj = getDiskList(disk)[0]
+
+    if boot or startSize == 0:
+        command = "dd if=/dev/zero of=%s bs=1024K count=1" % diskObj["Device"]
+        if runCommandFG(command, root=sudo) != 0:
+            if boot:
+                Common.log("failed to clear boot sector of disk %s" % diskObj["Device"])
+                return False
+            Common.log("failed to clear boot sector of disk %s.  ignoring" % diskObj["Device"])
+
+        command = "parted -s %s mklabel gpt" % diskObj["Device"]
+        if runCommandFG(command, root=sudo) != 0:
+            return False
+
+    if boot:
+        command = "parted -s %s mkpart primary ext3 0MB %sMB" % (diskObj["Device"], Globals.OS_PARTITION_SIZE)
+        if runCommandFG(command, root=sudo) != 0:
+            return False
+        command = "parted -s %s set 1 boot on" % (diskObj["Device"])
+        if runCommandFG(command, root=sudo) != 0:
+            return False
+        startSize = Globals.OS_PARTITION_SIZE
+
+    size = (diskObj["Size"] / ONE_MB_SIZE) - startSize
+    while size > Globals.MAX_PARTITION_SIZE:
+        endSize = startSize + Globals.MAX_PARTITION_SIZE
+        command = "parted -s %s mkpart primary ext3 %sMB %sMB" % (diskObj["Device"], startSize, endSize)
+        if runCommandFG(command, root=sudo) != 0:
+            return False
+        size -= Globals.MAX_PARTITION_SIZE
+        startSize = endSize
+
+    if size:
+        command = "parted -s %s mkpart primary ext3 %sMB 100%%" % (diskObj["Device"], startSize)
+        if runCommandFG(command, root=sudo) != 0:
+            return False
+
+    if runCommandFG("udevadm settle", root=sudo) != 0:
+        if runCommandFG("udevadm settle", root=sudo) != 0:
+            Common.log("udevadm settle for disk %s failed.  ignoring" % diskObj["Device"])
+    time.sleep(1)
+
+    if runCommandFG("partprobe %s" % diskObj["Device"], root=sudo) != 0:
+        Common.log("partprobe %s failed" % diskObj["Device"])
+        return False
+
+    if runCommandFG("gptsync %s" % diskObj["Device"], root=sudo) != 0:
+        Common.log("gptsync %s failed.  ignoring" % diskObj["Device"])
+
+    # wait forcefully to appear devices in /dev
+    time.sleep(2)
+    return True
+
+
+def initializeOsDisk(diskObj):
+    Common.log("WARNING: initializeOsDisk() is deprecated by initializeDisk(boot=True)")
+    return initializeDisk(diskObj, boot=True)
+
+
+def initializeDataDisk(diskObj):
+    Common.log("WARNING: initializeDataDisk() is deprecated by initializeDisk()")
+    return initializeDisk(diskObj)
+
+def getBootPartition(serverName):
+    diskDom = XDOM()
+    diskDom.parseFile("%s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName))
+    if not diskDom:
+        return None
+    partitionDom  = XDOM()
+    partitionUuid = None
+    partitionName = None
+    for partitionTag in diskDom.getElementsByTagRoute("disk.partition"):
+        partitionDom.setDomObj(partitionTag)
+        boot = partitionDom.getTextByTagRoute("boot")
+        if boot and boot.strip().upper() == 'YES':
+            partitionUuid = partitionDom.getTextByTagRoute("uuid")
+            partitionName = partitionDom.getTextByTagRoute("device")
+            break
+    if not (partitionUuid and partitionName):
+        return None
+     
+    # check device label name
+    deviceBaseName = os.path.basename(partitionName)
+    process = runCommandBG(['sudo', 'e2label', partitionName])
+    if type(process) == type(True):
+        return None
+    if process.wait() != 0:
+        return None
+    output = process.communicate()
+    deviceLabel = output[0].split()[0]
+    if deviceLabel != Globals.BOOT_PARTITION_LABEL:
+        return None
+
+    # check uuid in etc/fstab
+    try:
+        fstabEntries = open(Globals.FSTAB_FILE).readlines()
+    except IOError:
+        fstabEntries = []
+    found = False
+    for entry in fstabEntries:
+        entry = entry.strip()
+        if not entry:
+            continue
+        if entry.split()[0] == "UUID=" + partitionUuid:
+            found = True
+            break
+    if not found:
+        return None
+    return partitionName
+
+
+def isDiskInFormatting(device):
+    DEVICE_FORMAT_LOCK_FILE = "/var/lock/%s.lock" % device
+    return os.path.exists(DEVICE_FORMAT_LOCK_FILE)
+
+
+def isDiskInFormat(device):
+    Common.log("WARNING: isDiskInFormat() is deprecated by isDataDiskPartitionFormatted()")
+    return isDataDiskPartitionFormatted(device)
+
+
+def diskOrder(serverExportList):
+    newServerExportList = []
+    while serverExportList:
+        serverExport = deepcopy(serverExportList[0])
+        if newServerExportList and serverExport.split(":")[0] == newServerExportList[-1].split(":")[0]:
+            inserted = False
+            for i in range(0, len(newServerExportList) - 1):
+                if serverExport.split(":")[0] == newServerExportList[i].split(":")[0]:
+                    continue
+                if i == 0:
+                    newServerExportList.insert(i, serverExport)
+                    inserted = True
+                    break
+                if serverExport.split(":")[0] == newServerExportList[i - 1].split(":")[0]:
+                    continue
+                newServerExportList.insert(i, serverExport)
+                inserted = True
+                break
+            if not inserted:
+                newServerExportList.append(serverExport)
+        else:
+            newServerExportList.append(serverExport)
+        serverExportList.remove(serverExport)
+        i = 0
+        while serverExportList and i < len(serverExportList):
+            if serverExport.split(":")[0] == serverExportList[i].split(":")[0]:
+                i += 1
+                continue
+            serverExport = deepcopy(serverExportList[i])
+            newServerExportList.append(serverExport)
+            serverExportList.remove(serverExport)
+    return newServerExportList
+
+
+def updateServerDiskConfig(serverName, diskDom, requestFlag=True, partitionFlag=True):
+    command = "command.server."
+    if not requestFlag:
+        command = ""
+    diskList = {}
+    for tagE in diskDom.getElementsByTagRoute(command + "disk"):
+        diskList[diskDom.getTextByTagRoute(command + "device")] = tagE
+    configDom = XDOM()
+    if not configDom.parseFile("%s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName)):
+        return diskDom.writexml("%s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName))
+    diskTag = configDom.getElementsByTagRoute("disks.disk")
+    disks = configDom.getElementsByTagRoute("disks")
+    if not (diskTag or disks):
+        return None
+    for tagE in diskTag:
+        diskDom = XDOM()
+        diskDom.setDomObj(tagE)
+        device = diskDom.getTextByTagRoute("device")
+        if partitionFlag and device in diskList:
+            disks[0].removeChild(tagE)
+            disks[0].appendChild(deepcopy(diskList[device]))
+            continue
+        if not partitionFlag and device in diskList:
+            partitionList = []
+            for childNodeTag in tagE.childNodes:
+                if childNodeTag.nodeName == 'partition':
+                    partitionList.append(childNodeTag)
+            tagE.childNodes = []
+            tagE.childNodes = diskList[device].childNodes + partitionList
+    return configDom.writexml("%s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName))
+
+
+def compareDisksDom(diskDomA, diskDomB, requestFlag=True):
+    command = "command.server.disk."
+    if not requestFlag:
+        command = ""
+    sourceDiskList = {}
+    sourceDisk = {}
+    for tagE in diskDomA.getElementsByTagRoute("disk"):
+        sourceDisk["description"] = diskDomA.getTextByTagRoute("description")
+        sourceDisk["size"] = diskDomA.getTextByTagRoute("size")
+        sourceDisk["init"] = diskDomA.getTextByTagRoute("init")
+        sourceDisk["interface"] = diskDomA.getTextByTagRoute("interface")
+        sourceDiskList[diskDomA.getTextByTagRoute("device")] = sourceDisk
+    objDiskList = {}
+    objDisk = {}
+    for tagE in diskDomB.getElementsByTagRoute("disk"):
+        objDisk["description"] = diskDomB.getTextByTagRoute("description")
+        objDisk["size"] = diskDomB.getTextByTagRoute("size")
+        objDisk["init"] = diskDomB.getTextByTagRoute("init")
+        objDisk["interface"] = diskDomB.getTextByTagRoute("interface")
+        objDiskList[diskDomB.getTextByTagRoute("device")] = objDisk
+    return sourceDiskList == objDiskList
+
+ 
+def compareDiskDom(diskDomA, diskDomB, requestFlag=True):
+    command = "command.server.disk."
+    if not requestFlag:
+        command = ""
+    sourceDisk = {}
+    sourceDisk["device"] = diskDomA.getTextByTagRoute("device")
+    sourceDisk["description"] = diskDomA.getTextByTagRoute("description")
+    sourceDisk["size"] = diskDomA.getTextByTagRoute("size")
+    sourceDisk["init"] = diskDomA.getTextByTagRoute("init")
+    sourceDisk["interface"] = diskDomA.getTextByTagRoute("interface")
+    for tagE in diskDomA.getElementsByTagRoute("partition"):
+        sourceDiskPartitions = {}
+        partitionDom = XDOM()
+        partitionDom.setDomObj(tagE)
+        sourceDiskPartitions["size"] = partitionDom.getTextByTagRoute("size")
+        #sourceDiskPartitions["free"] = partitionDom.getTextByTagRoute("free")
+        sourceDiskPartitions["format"] = partitionDom.getTextByTagRoute("format")
+        sourceDiskPartitions["uuid"] = partitionDom.getTextByTagRoute("uuid")
+        sourceDisk[partitionDom.getTextByTagRoute("device")] = sourceDiskPartitions
+
+    objDisk = {}
+    objDisk["device"] = diskDomB.getTextByTagRoute(command + "device")
+    objDisk["description"] = diskDomB.getTextByTagRoute(command + "description")
+    objDisk["size"] = diskDomB.getTextByTagRoute(command + "size")
+    objDisk["init"] = diskDomB.getTextByTagRoute(command + "init")
+    objDisk["interface"] = diskDomB.getTextByTagRoute(command + "interface")
+    for tagE in diskDomB.getElementsByTagRoute(command + "partition"):
+        objDiskPartitions = {}
+        partitionDom = XDOM()
+        partitionDom.setDomObj(tagE)
+        objDiskPartitions["size"] = partitionDom.getTextByTagRoute("size")
+        #objDiskPartitions["free"] = partitionDom.getTextByTagRoute("free")
+        objDiskPartitions["format"] = partitionDom.getTextByTagRoute("format")
+        objDiskPartitions["uuid"] = partitionDom.getTextByTagRoute("uuid")
+        objDisk[partitionDom.getTextByTagRoute("device")] = objDiskPartitions
+    return sourceDisk == objDisk
+
+
+def getServerConfigDiskDom(serverName, diskName=None):
+    diskConfigDom = XDOM()
+    if not diskConfigDom.parseFile("%s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName)):
+        Common.log("Unable to parse %s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName))
+        return None
+    diskTag = diskConfigDom.getElementsByTagRoute("disks.disk")
+    if not diskTag:
+        Common.log("Unable to reterive disk information %s/%s/disk.xml" % (Globals.SERVER_VOLUME_CONF_DIR, serverName))
+        return None
+    if diskName:
+        for tagE in diskTag:
+            diskDom = XDOM()
+            diskDom.setDomObj(tagE)
+            if diskName == diskDom.getTextByTagRoute("device"):
+                return diskDom
+        return None
+
+    for tagE in diskTag:
+        for partitionTag in tagE.getElementsByTagName("partition"):
+            tagE.removeChild(partitionTag)
+    return diskConfigDom
+
+
diff --git a/src/com.gluster.storage.management.server.scripts/src/NetworkUtils.py b/src/com.gluster.storage.management.server.scripts/src/NetworkUtils.py
index 7a854564..da212a9b 100755
--- a/src/com.gluster.storage.management.server.scripts/src/NetworkUtils.py
+++ b/src/com.gluster.storage.management.server.scripts/src/NetworkUtils.py
@@ -194,7 +194,7 @@ def getNetSpeed(deviceName):
     for line in rv["Stdout"].split("\n"):
         tokens = line.strip().split(":")
         if tokens[0].upper() == "SPEED":
-            return tokens[1].strip().upper()
+            return tokens[1].strip().upper().split("MB")[0]
     return None
 
 def getLinkStatus(deviceName):
@@ -264,9 +264,7 @@ def setBondMode(deviceName, mode, fileName=None):
 
 def getNetDeviceList(root=""):
     netDeviceList = []
-
     for deviceName in os.listdir("/sys/class/net/"):
-    #for device in getHardwareList():
         netDevice = {}
         netDevice["device"] = None
         netDevice["description"] = None
@@ -298,11 +296,11 @@ def getNetDeviceList(root=""):
         netDevice["mode"] = getBondMode(deviceName, root + Globals.MODPROBE_CONF_FILE)
         netDevice["model"] = getNetModel(deviceName)
         netDevice["speed"] = getNetSpeed(deviceName)
-
         try:
             netDevice["hwaddr"] = open("/sys/class/net/%s/address" % deviceName).read().strip()
         except IOError:
             pass
+        
         netDeviceList.append(netDevice)
 
         conf = readIfcfgConfFile(deviceName, root)
diff --git a/src/com.gluster.storage.management.server.scripts/src/Utils.py b/src/com.gluster.storage.management.server.scripts/src/Utils.py
index 6e33af0b..38d009f6 100644
--- a/src/com.gluster.storage.management.server.scripts/src/Utils.py
+++ b/src/com.gluster.storage.management.server.scripts/src/Utils.py
@@ -712,3 +712,321 @@ def isLiveMode():
 
 def convertKbToMb(kb):
     return kb / 1024.0
+
+
+def getIPIndex(indexFile):
+    try:
+        fp = open(indexFile)
+        line = fp.readline()
+        fp.close()
+        index = int(line)
+    except IOError:
+        index = 0
+    except ValueError:
+        index = False
+    return index
+
+def setIPIndex(index, indexFile):
+    try:
+        fp = open(indexFile, "w")
+        fp.write(str(index))
+        fp.close()
+    except IOError:
+        return False
+    return True
+
+def IP2Number(ipString):
+    try:
+        return socket.htonl(struct.unpack("I", socket.inet_aton(ipString))[0])
+    except socket.error:
+        return None
+    except TypeError:
+        return None
+    except struct.error:
+        return None
+
+def Number2IP(number):
+    try:
+        return socket.inet_ntoa(struct.pack("I", socket.ntohl(number)))
+    except socket.error:
+        return None
+    except AttributeError:
+        return None
+    except ValueError:
+        return None
+
+def hasEntryFoundInFile(searchString, dnsEntryFileName):
+    try:
+        addServerEntryList = open(dnsEntryFileName).read().split()
+    except IOError:
+        return None
+    if searchString in addServerEntryList:
+        return True
+    return False
+
+
+def computeIpAddress(ipAddress, startIp, endIp):
+    startIpNumber = IP2Number(startIp)
+    endIpNumber = IP2Number(endIp)
+    if not ipAddress:
+        return startIp
+    nextIpNumber = IP2Number(ipAddress)
+    while True:  
+        nextIpNumber = nextIpNumber + 1
+        ipAddress = Number2IP(nextIpNumber)
+        rv = runCommandFG(["ping", "-qnc", "1", ipAddress])
+        if type(rv) == type(True):
+            return False
+        if rv != 0:
+            break
+
+    if nextIpNumber >= startIpNumber and nextIpNumber <= endIpNumber:
+        return ipAddress
+
+    nextIpNumber = IP2Number(startIp)
+    while True:
+        ipAddress = Number2IP(nextIpNumber)
+        nextIpNumber = nextIpNumber + 1
+        rv = runCommandFG(["ping", "-qnc", "1", ipAddress])
+        if type(rv) == type(True):
+            return False
+        if rv != 0:
+            break
+
+    if IP2Number(ipAddress) >= startIpNumber and IP2Number(ipAddress) <= endIpNumber:
+        return ipAddress
+    return False
+
+
+def setHostNameAndIp(hostName, ipAddress, lastAddServerDetailFile):
+    try:
+        fp = open(lastAddServerDetailFile, "w")
+        fp.write("HOSTNAME=" + hostName + "\n")
+        fp.write("IPADDRESS=" + ipAddress);
+        fp.close()
+    except IOError:
+        return False
+    return True
+
+def getPort():
+    try:
+        fd = open(Globals.PORT_FILE, "r")
+        portString = fd.readline()
+        fd.close()
+        port = int(portString)
+    except IOError:
+        port = Globals.DEFAULT_PORT - 2
+    except ValueError:
+        port = Globals.DEFAULT_PORT - 2
+    return port
+
+def setPort(port):
+    try:
+        fd = open(Globals.PORT_FILE, "w")
+        fd.write(str(port))
+        fd.close()
+    except IOError:
+        return False
+    return True
+
+def getServerAgentCredentials():
+    try:
+        lines = open(Globals.SERVERAGENT_AUTH_FILE).readlines()
+    except IOError:
+        return None,None
+
+    userName = None
+    password = None
+
+    for l in lines:
+        if l[-1] == '\n':
+            l = l[:-1]
+        k = l[:l.index('=')]
+        v = l[l.index('=') + 1:]
+        if v[0] == "'" or v[0] == '"':
+            v = v[1:]
+        if v[-1] == "'" or v[-1] == '"':
+            v = v[:-1]
+        if k.upper() == "AGENT_ID":
+            userName = v
+        if k.upper() == "AGENT_PASSWORD":
+            password = v
+
+    return userName, password
+
+def getGatewayAgentCredentials():
+    try:
+        lines = open(Globals.GATEWAYAGENT_AUTH_FILE).readlines()
+    except IOError:
+        return None
+
+    #userName = None
+    password = None
+
+    for l in lines:
+        if l[-1] == '\n':
+            l = l[:-1]
+        k = l[:l.index('=')]
+        v = l[l.index('=') + 1:]
+        if v[0] == "'" or v[0] == '"':
+            v = v[1:]
+        if v[-1] == "'" or v[-1] == '"':
+            v = v[:-1]
+        #if k.upper() == "AGENT_ID":
+        #    userName = v
+        if k.upper() == "AGENT_PASSWORD":
+            password = v
+
+    return password
+
+def getWebAgentCredentials():
+    try:
+        lines = open(Globals.WEBAGENT_AUTH_FILE).readlines()
+    except IOError:
+        return None,None
+
+    userName = None
+    password = None
+
+    for l in lines:
+        if l[-1] == '\n':
+            l = l[:-1]
+        k = l[:l.index('=')]
+        v = l[l.index('=') + 1:]
+        if v[0] == "'" or v[0] == '"':
+            v = v[1:]
+        if v[-1] == "'" or v[-1] == '"':
+            v = v[:-1]
+        if k.upper() == "AGENT_ID":
+            userName = v
+        if k.upper() == "AGENT_PASSWORD":
+            password = v
+
+    return userName, password
+
+def daemonize():
+    try: 
+        pid = os.fork() 
+        if pid > 0:
+            # exit first parent
+            sys.exit(0) 
+    except OSError, e: 
+        #sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+        return False
+	
+    # decouple from parent environment
+    os.chdir("/") 
+    os.setsid() 
+    os.umask(0) 
+	
+    # do second fork
+    try: 
+        pid = os.fork() 
+        if pid > 0:
+            # exit from second parent
+            sys.exit(0) 
+    except OSError, e: 
+        #sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+        return False 
+	
+    # redirect standard file descriptors
+    sys.stdout.flush()
+    sys.stderr.flush()
+    si = file("/dev/null", 'r')
+    so = file("/dev/null", 'a+')
+    se = file("/dev/null", 'a+', 0)
+    os.dup2(si.fileno(), sys.stdin.fileno())
+    os.dup2(so.fileno(), sys.stdout.fileno())
+    os.dup2(se.fileno(), sys.stderr.fileno())
+    return True
+
+def getFreeIpAddress():
+    startRange, endRange = getStoragePoolInfo()
+    if not (startRange and endRange):
+        return None
+
+    startIpNumber = IP2Number(startRange)
+    endIpNumber = IP2Number(endRange)
+
+    for ipNumber in range(endIpNumber, startIpNumber, -1):
+        rv = runCommandFG(["ping", "-qnc", "1", Number2IP(ipNumber)])
+        if type(rv) == type(True):
+            return None
+        if rv != 0:
+            return Number2IP(ipNumber)
+    return None
+
+def getDhcpServerStatus():
+    status = runCommandFG(["sudo", "service", "dnsmasq", " status"])
+    if type(status) == type(True) or 0 != status:
+        return False
+    return True
+
+def startDhcpServer():
+    status = runCommandFG(["sudo", "service", "dnsmasq", " start"])
+    if type(status) == type(True) or 0 != status:
+        return False
+    return True
+
+def stopDhcpServer():
+    status = runCommandFG(["sudo", "service", "dnsmasq", " stop"])
+    if type(status) == type(True) or 0 != status:
+        return False
+    return True
+
+def getStoragePoolInfo():
+    startRange = None
+    endRange = None
+    try:
+        for line in open(Globals.GLUSTER_SERVER_POOL_FILE):
+            tokens = line.split("=")
+            if tokens[0] == "STARTRANGE":
+                startRange = tokens[1].strip()
+            if tokens[0] == "ENDRANGE":
+                endRange = tokens[1].strip()
+    except IOError:
+        log(syslog.LOG_ERR, "unable to read %s file" % Globals.GLUSTER_SERVER_POOL_FILE)
+    return startRange, endRange
+
+def configureDnsmasq(serverIpAddress, dhcpIpAddress):
+    dnsmasqConfFile = Globals.GLUSTER_CONF_CONF_DIR + "/dnsmasq.conf"
+    serverPortString = "68"
+    try:
+        for arg in open("/proc/cmdline").read().strip().split():
+            token = arg.split("=")
+            if token[0] == "dhcp":
+                serverPortString = token[1]
+                break
+    except IOError:
+        log(syslog.LOG_ERR, "Failed to read /proc/cmdline.  Continuing with default port 68")
+    try:
+        serverPort = int(serverPortString)
+    except ValueError:
+        log(syslog.LOG_ERR, "Invalid dhcp port '%s' in /proc/cmdline.  Continuing with default port 68" % serverPortString)
+        serverPort = 68
+
+    try:
+        fp = open(dnsmasqConfFile, "w")
+        fp.write("no-hosts\n")
+        #fp.write("addn-hosts=%s\n" % Globals.GLUSTER_DNS_ENTRIES)
+        fp.write("bind-interfaces\n")
+        fp.write("except-interface=lo\n")
+        fp.write("dhcp-range=%s,%s\n" % (dhcpIpAddress, dhcpIpAddress))
+        fp.write("dhcp-lease-max=1\n")
+        #fp.write("dhcp-option=option:router,%s\n" % serverIp)
+        #fp.write("dhcp-option=option:ntp-server,%s\n" % serverIp)
+        fp.write("dhcp-alternate-port=%s\n" % serverPort)
+        fp.write("server=%s\n" % serverIpAddress)
+        fp.write("dhcp-script=/usr/sbin/server-info\n")
+        fp.close()
+    except IOError:
+        log(syslog.LOG_ERR, "unable to write dnsmasq configuration %s" % dnsmasqConfFile)
+        return False
+    status = runCommandFG(["sudo", "cp", "-f", Globals.GLUSTER_CONF_CONF_DIR + "/dnsmasq.conf", Globals.DNSMASQ_CONF_FILE])
+    if type(status) == type(True) or 0 != status:
+        log(syslog.LOG_ERR, "unable to copy dnsmasq configuration to " + Globals.DNSMASQ_CONF_FILE)
+        return False
+    return True
+
+def configureDhcpServer(serverIpAddress, dhcpIpAddress):
+    return configureDnsmasq(serverIpAddress, dhcpIpAddress)