Renamed project and package com.gluster.storage.management.server to com.gluster.storage.management.gateway

8 files changed, 2211 insertions, 0 deletions

diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/Globals.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/Globals.py
new file mode 100644
index 00000000..f8a07c25
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/Globals.py
@@ -0,0 +1,123 @@
+#  Copyright (C) 2010 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Storage Platform.
+#
+#  Gluster Storage Platform is free software; you can redistribute it
+#  and/or modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 3 of
+#  the License, or (at your option) any later version.
+#
+#  Gluster Storage Platform is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+#  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see
+#  <http://www.gnu.org/licenses/>.
+
+MULTICAST_GROUP = '224.224.1.1'
+MULTICAST_PORT  = 5353
+GLUSTER_PLATFORM_VERSION = "3.2"
+
+## System configuration constants
+SYSCONFIG_NETWORK_DIR  = "/etc/sysconfig/network-scripts"
+DNSMASQ_CONF_DIR       = "/etc/dnsmasq.d"
+
+FSTAB_FILE             = "/etc/fstab"
+NFS_EXPORTS_FILE       = "/etc/exports"
+SAMBA_CONF_FILE        = "/etc/samba/smb.conf"
+TIMEZONE_FILE          = "/etc/timezone"
+ZONEINFO_DIR           = "/usr/share/zoneinfo"
+LOCALTIME_FILE         = "/etc/localtime"
+KERBEROS_CONF_FILE     = "/etc/krb5.conf"
+NSSWITCH_CONF_FILE     = "/etc/nsswitch.conf"
+NTP_CONF_FILE          = "/etc/ntp.conf"
+MODPROBE_CONF_FILE     = "/etc/modprobe.d/bonding.conf"
+SYSCONFIG_NETWORK_FILE = "/etc/sysconfig/network"
+RESOLV_CONF_FILE       = "/etc/resolv.conf"
+DNSMASQ_LEASE_FILE     = "/var/tmp/dnsmasq.leases"
+LIVE_MODE_FILE         = "/etc/live"
+ADD_SERVER_COMPLETED_FILE   = "/var/tmp/installation-completed"
+
+DNSMASQ_DNS_CONF_FILE  = DNSMASQ_CONF_DIR + "/dns.conf"
+DNSMASQ_DHCP_CONF_FILE = DNSMASQ_CONF_DIR + "/dhcp.conf"
+##
+
+## Base constants
+MAX_PARTITION_SIZE = 16777216 # 16 TB
+OS_PARTITION_SIZE  = 4000     # 4 GB
+SESSION_TIMEOUT    = 1800     # 30 minutes
+SERVER_AGENT_PORT  = 50000
+
+BOOT_PARTITION_LABEL      = "GLUSTEROS"
+DATA_PARTITION_LABEL      = "GLUSTERDATA"
+VOLUME_USER_DESCRIPTION   = "Gluster Volume User"
+SERVER_AGENT_RUN_USERNAME = "gluster"
+INSTALLER_SERVER_NAME     = "$installer$"
+
+GLUSTER_BASE_DIR         = "/etc/glustermg"
+GLUSTER_LUN_DIR          = "/data"
+REEXPORT_DIR             = "/reexport"
+NFS_EXPORT_DIR           = "/nfs"
+CIFS_EXPORT_DIR          = "/cifs"
+WEBDAV_DOCUMENT_ROOT_DIR = "/var/www/html"
+UPDATES_DIR              = "/UPDATES"
+TRANSPORT_HOME_DIR       = "/transport"
+GLUSTERFS_LOG_DIR        = "/var/log/glusterfs"
+LOG_DIR                  = "/var/log/glustermg"
+
+GLUSTER_UPDATES_FILE        = "updates.xml"
+INSTALLER_STATUS_FILE       = "/var/log/install-server-status.log"
+INSTALL_PLATFORM_LOCK_FILE  = "/var/lock/install-gluster-platform.lock"
+LAST_ACCESSED_NETWORK_FILE  = "last-accessed-network"
+PREPARE_DATA_DISK_LOCK_FILE = "/var/tmp/prepare-data-disk.lock"
+##
+
+## Derived constants
+GLUSTER_CONF_DIR   = GLUSTER_BASE_DIR + "/conf"
+GLUSTER_TMP_DIR    = GLUSTER_BASE_DIR + "/tmp"
+VOLUME_CONF_DIR    = GLUSTER_BASE_DIR + "/volumes"
+SERVER_CONF_DIR    = GLUSTER_BASE_DIR + "/servers"
+DNS_RECORDS_DIR    = GLUSTER_BASE_DIR + "/dns-records"
+INSTALLER_CONF_DIR = SERVER_CONF_DIR + "/" + INSTALLER_SERVER_NAME
+
+GSN_USER_INFO_FILE                  = GLUSTER_BASE_DIR + "/gsn-user.info"
+GLUSTER_VERSION_FILE                = GLUSTER_BASE_DIR + "/version"
+GLUSTER_UPDATE_SITE_FILE            = GLUSTER_BASE_DIR + "/update-site"
+GLUSTER_DIRECTORY_SERVICE_CONF_FILE = GLUSTER_BASE_DIR + "/directory.xml"
+GLUSTER_TIME_CONF_FILE              = GLUSTER_BASE_DIR + "/timeconfig.xml"
+TRANSACTION_KEY_FILE                = GLUSTER_BASE_DIR + "/transaction.key"
+SERVER_COUNT_FILE                   = GLUSTER_BASE_DIR + "/server-count"
+SIGNATURE_FILE                      = GLUSTER_BASE_DIR + "/.signature"
+GLUSTER_SERVER_POOL_FILE            = GLUSTER_BASE_DIR + "/pool"
+GLUSTER_ADMIN_FILE                  = GLUSTER_BASE_DIR + "/.password"
+
+VOLUME_SMBCONF_FILE = VOLUME_CONF_DIR + "/volumes.smbconf.list"
+
+GLOBAL_NETWORK_FILE         = INSTALLER_CONF_DIR + "/network.xml"
+INSTALL_SERVER_CONF_FILE    = INSTALLER_CONF_DIR + "/installer.xml"
+INSTALLER_INFO_FILE         = INSTALLER_CONF_DIR + "/installer.info"
+INSTALLED_SERVER_COUNT_FILE = INSTALLER_CONF_DIR + "/installed-server-count"
+
+SESSION_FILE = GLUSTER_TMP_DIR + "/login.sessions"
+
+GENERAL_LOG_FILE         = LOG_DIR + "/general.log"
+INSTALLER_LOG_FILE       = LOG_DIR + "/installer.log"
+PEER_AGENT_LOG_FILE    = LOG_DIR + "/peeragent.log"
+SERVER_AGENT_LOG_FILE    = LOG_DIR + "/serveragent.log"
+TRANSPORT_AGENT_LOG_FILE = LOG_DIR + "/transport.log"
+##
+
+
+## Global variables
+## TODO: These should be removed
+DOWNLOAD_GLUSTER_UPDATE_PROCESS = None
+DOWNLOAD_GLUSTER_UPDATE_LEVEL = None
+DOWNLOAD_GLUSTER_CURRENT_UPDATE_LEVEL = None
+DOWNLOAD_GLUSTER_UPDATE_MD5SUM = None
+REQUEST_MAP = {}
+VERSION_DICTONARY = {}
+##
+
+AWS_WEB_SERVICE_URL = "http://169.254.169.254/latest"
+REAL_SAMBA_CONF_FILE = "/etc/samba/real.smb.conf"
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/Protocol.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/Protocol.py
new file mode 100644
index 00000000..ff073593
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/Protocol.py
@@ -0,0 +1,438 @@
+#  Copyright (C) 2009 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Storage Platform.
+#
+#  Gluster Storage Platform is free software; you can redistribute it
+#  and/or modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 3 of
+#  the License, or (at your option) any later version.
+#
+#  Gluster Storage Platform is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+#  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see
+#  <http://www.gnu.org/licenses/>.
+
+import xml
+import xml.parsers.expat
+import xml.dom.minidom as MDOM
+import os
+import Globals
+import copy
+import Utils
+
+XML_STRING = 0
+XML_FILE = 1
+
+class XDOM:
+    _domObj = None
+
+    def __init__(self):
+        self._domObj = MDOM.Document()
+        return
+
+    @classmethod
+    def getText(self, nodeList):
+        rc = ""
+        for node in nodeList:
+            if node.nodeType == node.TEXT_NODE:
+                rc = rc + node.data
+        return rc.strip()
+
+    def parseString(self, requestString):
+        try:
+            self._domObj = MDOM.parseString(requestString)
+        except xml.parsers.expat.ExpatError, e:
+            Utils.log("XML string parse error: %s" % str(e))
+            return False
+        return True
+
+    def parseFile(self, fileName):
+        try:
+            self._domObj = MDOM.parse(fileName)
+        except IOError, e:
+            Utils.log("error reading file: %s" % str(e))
+            return False
+        except xml.parsers.expat.ExpatError, e:
+            Utils.log("XML file %s parse error: %s" % (fileName, str(e)))
+            return False
+        return True
+
+    def setDomObj(self, dom):
+        if dom and type(dom) != type([]):
+            self._domObj = dom
+            return True
+        return False
+
+    def createTextNode(self, text):
+        if not self._domObj:
+            return False
+        if not text:
+            return False
+        return self._domObj.createTextNode(str(text))
+
+    def createTag(self, tag, text=None):
+        if not self._domObj:
+            return None
+        if tag == None:
+            return None
+
+        tagE = self._domObj.createElement(str(tag))
+        if text:
+            tagEText = self._domObj.createTextNode(str(text))
+            tagE.appendChild(tagEText)
+        return tagE
+
+    def addTag(self, tag):
+        if not self._domObj:
+            return False
+        if not tag:
+            return False
+
+        self._domObj.appendChild(tag)
+        return True
+
+    def createTagRoute(self, tagRoute, text=None):
+        if not tagRoute:
+            return False
+
+        tagList = tagRoute.split(".")
+        tag = None
+        previousTag = None
+        for tagName in tagList[:-1]:
+            newTag = self.createTag(tagName, None)
+            if not tag:
+                tag = newTag
+                previousTag = newTag
+                continue
+            previousTag.appendChild(newTag)
+            previousTag = newTag
+
+        if previousTag:
+            previousTag.appendChild(self.createTag(tagList[-1], text))
+        else:
+            tag = self.createTag(tagList[-1], text)
+        return tag
+
+    def appendTagRoute(self, tagRoute, value=None):
+        if not self._domObj:
+            return False
+        if not tagRoute:
+            return False
+
+        parentTagE = self._domObj
+
+        tagNameList = tagRoute.split(".")
+        newTagRoute = tagNameList.pop(-1)
+
+        for i in range(len(tagNameList), 0, -1):
+            tagE = self.getElementsByTagRoute(".".join(tagNameList[:i]))
+            if tagE:
+                parentTagE = tagE[0]
+                break
+            newTagRoute = tagNameList[i-1] + "." + newTagRoute
+
+        newTagE = self.createTagRoute(newTagRoute, value)
+        if not newTagE:
+            return False
+        try:
+            parentTagE.appendChild(newTagE)
+        except xml.dom.HierarchyRequestErr, e:
+            Utils.log("error occured.  %s" + str(e))
+            return False
+        return True
+
+    def setTextByTagRoute(self, tagRoute, tagValue):
+        if not self._domObj:
+            return None
+
+        if not tagRoute:
+            return None
+
+        tagE  = self.getElementsByTagRoute(tagRoute)
+        if not tagE:
+            return False
+
+        parentTagE = self.getElementsByTagRoute(".".join(tagRoute.split(".")[:-1]))
+        if not parentTagE:
+            return False
+        
+        parentTagE[0].childNodes.remove(tagE[0])
+        parentTagE[0].appendChild(self.createTag(tagRoute.split(".")[-1], tagValue))
+        return True
+
+    def getElementsByTagRoute(self, tagRoute):
+        if not self._domObj:
+            return None
+        
+        if not tagRoute:
+            return None
+
+        x = None
+        for tag in tagRoute.split("."):
+            if x is None:
+                x = self._domObj.getElementsByTagName(tag)
+                continue
+            if x == []:
+                break
+            x = x[0].getElementsByTagName(tag)
+        return x
+
+    def getTextByTagRoute(self, tagRoute):
+        if not self._domObj:
+            return None
+
+        x = self.getElementsByTagRoute(tagRoute)
+        if x:
+            return self.getText(x[0].childNodes)
+        return None
+
+    def getElementsByTagName(self, name):
+        if not self._domObj:
+            return None
+        return self._domObj.getElementsByTagName(name)
+
+    def writexml(self, fileName, indent="", addindent="", newl=""):
+        if not self._domObj:
+            return None
+        try:
+            fp = open(fileName, "w")
+            self._domObj.writexml(fp, indent, addindent, newl)
+            fp.close()
+            return True
+        except IOError:
+            return False
+
+    def toString(self, indent="  ", newl="\n", encoding = None):
+        if not self._domObj:
+            return None
+        return self._domObj.toprettyxml(indent, newl, encoding)
+
+    def toxml(self, encoding = None):
+        if not self._domObj:
+            return None
+        return self._domObj.toxml(encoding)
+
+    def toprettyxml(self, indent="  ", newl="\n", encoding = None):
+        return self.toString(indent, newl, encoding)
+
+    def getAttribute(self, attributeName):
+        if not attributeName:
+            return None
+        try:
+            return self.getElementsByTagName("command")[0].getAttribute(attributeName)
+        except IndexError:
+            return False
+
+    def setAttribute(self, attributeName, attributeValue):
+        if not (attributeName and attributeValue):
+            return None
+        try:
+            return self.getElementsByTagName("command")[0].setAttribute(attributeName, attributeValue)
+        except IndexError:
+            return False
+
+    def getRequestCommand(self):
+        return self.getAttribute("request")
+
+    def getResponseCommand(self):
+        return self.getAttribute("response")
+
+    def getResponseCode(self):
+        return self.getAttribute("response-code")
+
+    def getMessageId(self):
+        return self.getAttribute("id")
+
+    def getVersion(self):
+        return self.getAttribute("version")
+
+    def getRequestAction(self):
+        return self.getAttribute("action")
+
+    def setVersion(self, value):
+        return self.setAttribute("version", value)
+
+    def setRequestAction(self, value):
+        return self.setAttribute("action", value)
+            
+    def createCommandTag(self, command, responseCode, id, version=Globals.GLUSTER_PLATFORM_VERSION):
+        commandTag = self._domObj.createElement("command")
+        commandTag.setAttribute("response", command)
+        commandTag.setAttribute("response-code", responseCode)
+        commandTag.setAttribute("id", id)
+        commandTag.setAttribute("version", version)
+        return commandTag
+##--end of XDOM
+
+class RequestXml(XDOM):
+    def __init__(self, requestString, type=None):
+        if None == requestString:
+            XDOM.__init__(self)
+            return
+        try:
+            if None == type:
+                if os.path.isfile(requestString):
+                    self._domObj = MDOM.parse(requestString)
+                else:
+                    self._domObj = MDOM.parseString(requestString)
+            elif XML_FILE == type:
+                self._domObj = MDOM.parse(requestString)
+            elif XML_STRING == type:
+                self._domObj = MDOM.parseString(requestString)
+        except IOError:
+            XDOM.__init__(self)
+        except xml.parsers.expat.ExpatError:
+            XDOM.__init__(self)
+
+##--end of RequestXML
+
+class ResponseXml(XDOM):
+    _commandTag = None
+    def __init__(self, command, responseCode, id, version=Globals.GLUSTER_PLATFORM_VERSION):
+        XDOM.__init__(self)
+        if command and responseCode and id:
+            self._commandTag = self.createCommandTag(command, responseCode, id, version)
+            self._domObj.appendChild(self._commandTag)
+
+    def appendCommand(self, command, responseCode, id, version=Globals.GLUSTER_PLATFORM_VERSION):
+        if command and responseCode and id:
+            self._commandTag = self.createCommandTag(command, responseCode, id, version)
+            self._domObj.appendChild(self._commandTag)
+            return True
+        return False
+
+    def append(self, tagName, tagValue=None):
+        if not self._commandTag:
+            return False
+        tag = self.createTag(tagName, tagValue)
+        if tag:
+            self._commandTag.appendChild(tag)
+            return True
+        return False
+
+    def appendTag(self, tag):
+        if not tag:
+            return False
+        if not self._commandTag:
+            return False
+        self._commandTag.appendChild(tag)
+        return True
+
+    def appendTagRoute(self, tagRoute, value=None):
+        if not self._commandTag:
+            return False
+        if not tagRoute:
+            return False
+
+        parentTagE = self._commandTag
+
+        tagNameList = tagRoute.split(".")
+        newTagRoute = tagNameList.pop(-1)
+
+        for i in range(len(tagNameList), 0, -1):
+            tagE = self.getElementsByTagRoute(".".join(["command"] + tagNameList[:i]))
+            if tagE:
+                parentTagE = tagE[0]
+                break
+            newTagRoute = tagNameList[i-1] + "." + newTagRoute
+
+        newTagE = self.createTagRoute(newTagRoute, value)
+        if not newTagE:
+            return False
+        try:
+            parentTagE.appendChild(newTagE)
+        except xml.dom.HierarchyRequestErr, e:
+            Utils.log("error occured.  %s" + str(e))
+            return False
+        return True
+
+    def appendTagRouteOld(self, tagRoute, value=None):
+        if not tagRoute:
+            return False
+        if not self._commandTag:
+            return False
+        
+        tmpTagRoute = ""
+        previousTagE = self._commandTag
+        tagE = None
+        for tagName in tagRoute.split("."):
+            if not tmpTagRoute:
+                tagE = self.getElementsByTagRoute("command." + tagName)
+            else:
+                tagE = self.getElementsByTagRoute("command." + tmpTagRoute + "." + tagName)
+            if not tagE:
+                break
+            if len(tagE) != 1:
+                return False
+            previousTagE = tagE[0]
+            if not tmpTagRoute:
+                tmpTagRoute = tagName
+            else:
+                tmpTagRoute = tmpTagRoute + "." + tagName
+
+        if tmpTagRoute == tagRoute:
+            return False
+        newTagRoute = tagRoute[len(tmpTagRoute):]
+        if newTagRoute[0] == '.':
+            newTagRoute = newTagRoute[1:]
+
+        if previousTagE.childNodes and previousTagE.childNodes[0].nodeType == previousTagE.TEXT_NODE:
+            return False
+        previousTagE.appendChild(self.createTagRoute(newTagRoute, value))
+        return True
+##--end of ResponseXml
+
+def test():
+    #volumes = RequestXml(VolumeFile, XML_FILE).getElementsByTagRoute("volume-list.volume")
+    requestStr = '''<command request="create-volume" id="123" version="3.1">
+<volume>
+<name>movies1</name>
+<type>cluster mirror</type>
+<start>512000</start>
+<server>zresearch</server>
+<vacl>192.168.20.*</vacl>
+<vacl>192.168.30.*</vacl>
+<nfs>
+<export>no</export>
+</nfs>
+<cifs>
+<export>no</export>
+</cifs>
+<webdav>
+<export>no</export>
+</webdav>
+</volume>
+</command>'''
+
+    requestXml = RequestXml(requestStr)
+    print requestXml.getAttribute("")
+
+def test1():
+    rs = ResponseXml("create-volume", "OK", "xyz")
+    rs.appendTagRoute("volume.detail.name", "music")
+    print rs.toprettyxml()
+    rs.append("volume", "data")
+    print rs.toprettyxml()
+    rs.appendTagRoute("volume.detail.ipaddr", "192.168.10.1")
+    print rs.toprettyxml()
+    print rs.appendTagRoute("volume.detail.ipaddr.v6", "ff:ff::ff::")
+    print rs.toprettyxml()
+
+    print rs.getTextByTagRoute("command.volume.detail")
+
+def test2():
+    rs = ResponseXml("download-volume-logs", "OK", "xyz")
+    te = rs.createTag("interface", None)
+    te.appendChild(rs.createTag("device", "DEVICE1"))
+    te.appendChild(rs.createTag("description", "my device one"))
+    rs.appendTag(te)
+
+    te = rs.createTag("interface", None)
+    te.appendChild(rs.createTag("device", "DEVICE2"))
+    te.appendChild(rs.createTag("description", "my device two"))
+    rs.appendTag(te)
+    print rs.toprettyxml()
+
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/Utils.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/Utils.py
new file mode 100644
index 00000000..3408c14a
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/Utils.py
@@ -0,0 +1,1059 @@
+#  Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Storage Platform.
+#
+#  Gluster Storage Platform is free software; you can redistribute it
+#  and/or modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 3 of
+#  the License, or (at your option) any later version.
+#
+#  Gluster Storage Platform is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+#  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see
+#  <http://www.gnu.org/licenses/>.
+
+import sys
+import os
+import re
+import socket
+import struct
+import syslog
+import subprocess
+#import spwd
+import time
+#import uuid
+import tempfile
+import grp
+import pwd
+import inspect
+from datetime import datetime
+import urllib
+
+import Globals
+import Protocol
+
+RUN_COMMAND_ERROR = -1024
+LOG_SYSLOG = 1
+SYSLOG_REQUIRED = False
+LOG_FILE_NAME = None
+LOG_FILE_OBJ = None
+
+
+def _getLogCode(priority):
+    if syslog.LOG_EMERG == priority:
+        return "M"
+    elif syslog.LOG_ALERT == priority:
+        return "A"
+    elif syslog.LOG_CRIT == priority:
+        return "C"
+    elif syslog.LOG_ERR == priority:
+        return "E"
+    elif syslog.LOG_WARNING == priority:
+        return "W"
+    elif syslog.LOG_NOTICE == priority:
+        return "N"
+    elif syslog.LOG_INFO == priority:
+        return "I"
+    elif syslog.LOG_DEBUG == priority:
+        return "D"
+    else: # UNKNOWN
+        return "X"
+
+
+def setLogFile(fileName):
+    global LOG_FILE_NAME
+
+    if fileName:
+        LOG_FILE_NAME = fileName
+        return True
+    return False
+
+
+def closeLog():
+    global LOG_FILE_OBJ
+    global SYSLOG_REQUIRED
+
+    if SYSLOG_REQUIRED:
+        syslog.closelog()
+        SYSLOG_REQUIRED = False
+        return True
+
+    if LOG_FILE_OBJ:
+        try:
+            LOG_FILE_OBJ.close()
+            LOG_FILE_OBJ = None
+        except IOError, e:
+            sys.stderr.write("Failed to close file: %s\n" % e)
+            return False
+    return True
+
+
+def openLog(fileName=None):
+    global LOG_FILE_NAME
+    global LOG_FILE_OBJ
+    global SYSLOG_REQUIRED
+
+    if fileName == LOG_SYSLOG:
+        syslog.openlog(os.path.basename(sys.argv[0]))
+        SYSLOG_REQUIRED = True
+        return True
+
+    if fileName:
+        LOG_FILE_NAME = fileName
+
+    if not LOG_FILE_NAME:
+        return False
+
+    closeLog()
+
+    try:
+        LOG_FILE_OBJ = open(LOG_FILE_NAME, "a")
+    except IOError, e:
+        sys.stderr.write("Failed to open file %s: %s\n" % (LOG_FILE_NAME, e))
+        return False
+    return True
+
+def record(priority, message=None):
+    global LOG_FILE_OBJ
+    global SYSLOG_REQUIRED
+
+    stack = inspect.stack()[1]
+    if stack[3] == "<module>":
+        prefix = "%s:%s:%s" % (stack[1], stack[2], stack[3])
+    else:
+        prefix = "%s:%s:%s()" % (stack[1], stack[2], stack[3])
+
+    if type(priority) == type("") or type(priority) == type(u""):
+        logPriority = syslog.LOG_INFO
+        logMessage = priority
+    else:
+        logPriority = priority
+        logMessage = message
+
+    if SYSLOG_REQUIRED:
+        syslog.syslog(logPriority, "[%s]: %s" % (prefix, logMessage))
+        return
+
+    fp = sys.stderr
+    if LOG_FILE_OBJ:
+        fp = LOG_FILE_OBJ
+
+    fp.write("[%s] %s [%s]: %s" % (str(datetime.now()), _getLogCode(logPriority), prefix, logMessage))
+    if logMessage[-1] != '\n':
+        fp.write("\n")
+    fp.flush()
+    return
+
+
+def trace(message):
+    if message:
+        log(syslog.LOG_DEBUG, message)
+
+
+def isString(value):
+    return (type(value) == type("") or type(value) == type(u""))
+
+
+def getTempFileName():
+    filedesc, filename = tempfile.mkstemp(prefix="GSP_")
+    os.close(filedesc)
+    return filename
+
+
+def runCommandBG(command, stdinFileObj=None, stdoutFileObj=None, stderrFileObj=None,
+                 shell=False, root=None):
+    log("runCommandBG(): Trying to execute command [%s]" % command)
+
+    if shell:
+        if not isString(command):
+            return None
+    else:
+        if isString(command):
+            command = command.split()
+
+    if root == True:
+        if shell:
+            command = "sudo " + command
+        else:
+            command = ['sudo'] + command
+    elif isString(root):
+        if shell:
+            command = "sudo -u " + root + " " + command
+        else:
+            command = ['sudo', '-u', root] + command
+
+    if not stdinFileObj:
+        stdinFileObj=subprocess.PIPE
+    if not stdoutFileObj:
+        stdoutFileObj=subprocess.PIPE
+    if not stderrFileObj:
+        stderrFileObj=subprocess.PIPE
+
+    try:
+        process = subprocess.Popen(command,
+                                   bufsize=-1,
+                                   stdin=stdinFileObj,
+                                   stdout=stdoutFileObj,
+                                   stderr=stderrFileObj,
+                                   shell=shell)
+        return process
+    except OSError, e:
+        log("runCommandBG(): Failed to run command [%s]: %s" % (command, e))
+    return None
+
+
+def runCommand(command,
+               input='', output=False,
+               shell=False, root=None):
+    rv = {}
+    rv["Status"] = RUN_COMMAND_ERROR
+    rv["Stdout"] = None
+    rv["Stderr"] = None
+
+    try:
+        stdinFileName = getTempFileName()
+        stdinFileObj = open(stdinFileName, "w")
+        stdinFileObj.write(input)
+        stdinFileObj.close()
+        stdinFileObj = open(stdinFileName, "r")
+
+        stdoutFileName = getTempFileName()
+        stdoutFileObj = open(stdoutFileName, "w")
+
+        stderrFileName = getTempFileName()
+        stderrFileObj = open(stderrFileName, "w")
+    except IOError, e:
+        log("Failed to create temporary file for executing command [%s]: %s" % (command, e))
+        if output:
+            return rv
+        return rv["Status"]
+
+    stdoutContent = None
+    stderrContent = None
+
+    process = runCommandBG(command,
+                           stdinFileObj=stdinFileObj,
+                           stdoutFileObj=stdoutFileObj,
+                           stderrFileObj=stderrFileObj,
+                           shell=shell, root=root)
+    if process:
+        rv['Status'] = process.wait()
+        rv['Stdout'] = open(stdoutFileName).read()
+        rv['Stderr'] = open(stderrFileName).read()
+
+    os.remove(stdinFileName)
+    os.remove(stdoutFileName)
+    os.remove(stderrFileName)
+
+    log("runCommand(): execution status of command [%s] = [%s]" % (command, rv))
+
+    if output:
+        return rv
+    return rv["Status"]
+
+
+def runCommandFG(command, stdout=False, stderr=False,
+                 shell=False, root=None):
+    if stdout or stderr:
+        output = True
+    else:
+        output = False
+    return runCommand(command, output=output, shell=shell, root=root)
+
+
+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 computeHostName(hostName):
+    if not hostName:
+        return False
+
+    hostPrefix = ""
+    for i in range(len(hostName), 0, -1):
+        pos = i - 1
+        if hostName[pos].isdigit():
+            continue
+        break
+    hostPrefix = hostName[:pos+1]
+    try:
+        hostIndex = int(hostName[pos+1:]) 
+    except ValueError:
+        hostIndex = 0
+    # TODO: Check the availablity of the (server) name
+    return "%s%s" % (hostPrefix, hostIndex + 1)
+
+
+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 getDownloadStatus(fileName):
+    try:
+        lines = [line for line in open(fileName)
+                 if "saved" in line or "%" in line]
+    except IOError:
+        return 0
+    if not lines:
+        return 0
+    if "saved" in lines[-1]:
+        return 100
+    return lines[-1].split("%")[0].split()[-1]
+
+
+def getMeminfo():
+    """-> dict of data from meminfo (str:int).
+    Values are in kilobytes.
+    """
+    import re
+    re_parser = re.compile(r'^(?P<key>\S*):\s*(?P<value>\d*)\s*kB' )
+    result = {}
+    for line in open('/proc/meminfo'):
+        match = re_parser.match(line)
+        if not match:
+            continue # skip lines that don't parse
+        key, value = match.groups(['key', 'value'])
+        result[key] = int(value)
+    result['MemUsed'] = (result['MemTotal'] - result['MemFree'])
+    return result
+
+
+def getCpuUsage():
+    """-> dict of cpuid : (usertime, nicetime, systemtime, idletime)
+    cpuid "cpu" means the total for all CPUs.
+    cpuid "cpuN" means the value for CPU N.
+    """
+    wanted_records = [line for line in open('/proc/stat') if
+                      line.startswith('cpu')]
+    result = {}
+    for cpuline in wanted_records:
+        fields = cpuline.split()[:5]
+        data = map(int, fields[1:])
+        result[fields[0]] = tuple(data)
+    return result
+
+def _getCpuStatList():
+    try:
+        fp = open("/proc/stat")
+        cpuStatList = map(float, fp.readline().split()[1:])
+        fp.close()
+        return cpuStatList
+    except IOError, e:
+        Utils.log("Failed to open /proc/stat: %s" % str(e))
+    return None
+
+def getCpuUsageAvg():
+    st1 = _getCpuStatList()
+    time.sleep(2)
+    st2 = _getCpuStatList()
+    if not (st1 and st2):
+        return None
+    delta = [st2[i] - st1[i] for i in range(len(st1))]
+    cpuPercent = sum(delta[:3]) / delta[3] * 100.0
+    return str('%.4f' % cpuPercent)
+
+def getLoadavg():
+    try:
+        loadavgstr = open('/proc/loadavg', 'r').readline().strip()
+    except IOError:
+        syslog.syslog(syslog.LOG_ERR, "failed to find cpu load")
+        return None
+
+    data = map(float, loadavgstr.split()[1:])
+    # returns 1 minute load average
+    return data[0]
+
+
+def getInfinibandPortStatus():
+
+    """ Check for availability of infiniband port 
+    and return which port is active in a key pair value
+    """
+
+    # Check for existence of infiniband ports
+    value = os.popen ("ls /sys/class/infiniband").readline().strip()
+
+    if not value:
+        return None
+
+    portlist = os.popen ("echo /sys/class/infiniband/*/ports/*").readline().split()
+    
+    portkeys = {}
+    
+    for port in portlist:
+        value = os.popen ("cat %s/state" % 
+                          port.strip()).readline().split(':')[1].strip()
+        portkeys[port.strip()] = value
+        
+    return portkeys
+        
+
+def getServerCount():
+    try:
+        return int(open(Globals.SERVER_COUNT_FILE).read().strip())
+    except IOError:
+        log("failed to read file %s" % Globals.SERVER_COUNT_FILE)
+        return 1
+    except ValueError:
+        log("invalid number format in file %s" % Globals.SERVER_COUNT_FILE)
+        return 1
+
+
+def setServerCount(count):
+    try:
+        open(Globals.SERVER_COUNT_FILE, "w").write("%s\n" % count)
+        return True
+    except IOError:
+        log("failed to write file %s" % Globals.SERVER_COUNT_FILE)
+        return False
+
+
+def getInstalledServerCount():
+    try:
+        return int(open(Globals.INSTALLED_SERVER_COUNT_FILE).read().strip())
+    except IOError:
+        log("failed to read file %s" % Globals.INSTALLED_SERVER_COUNT_FILE)
+        return 1
+    except ValueError:
+        log("invalid number format in file %s" % Globals.INSTALLED_SERVER_COUNT_FILE)
+        return 1
+
+
+def setInstalledServerCount(count):
+    try:
+        open(Globals.INSTALLED_SERVER_COUNT_FILE, "w").write("%s\n" % count)
+        return True
+    except IOError:
+        log("failed to write file %s" % Globals.INSTALLED_SERVER_COUNT_FILE)
+        return False
+
+
+def getLastInstalledServerIpList():
+    ipList = {}
+    networkDom = Protocol.XDOM()
+    if not networkDom.parseFile(Globals.GLOBAL_NETWORK_FILE):
+        log("failed to parse file %s" % Globals.GLOBAL_NETWORK_FILE)
+    for tagE in networkDom.getElementsByTagRoute("server.interface"):
+        interfaceDom = Protocol.XDOM()
+        interfaceDom.setDomObj(tagE)
+        ipAddress = interfaceDom.getTextByTagRoute("ipaddr")
+        if ipAddress:
+            ipList[interfaceDom.getTextByTagRoute("device")] = ipAddress
+    return ipList
+
+
+def getFreeIpAddress(device=None):
+    serverCount = getServerCount()
+    installedServerCount = getInstalledServerCount()
+    if serverCount == installedServerCount:
+        return None
+
+    availableServerCount = serverCount - installedServerCount
+    ipList = getLastInstalledServerIpList()
+    
+    if not ipList:
+        return None
+
+    if device:
+        if device not in ipList.keys():
+            return None
+        deviceIpAddress = ipList[device]
+    else:
+        deviceIpAddress = ipList.values()[0]
+    ipNumber = IP2Number(deviceIpAddress)
+
+    for i in range((ipNumber + availableServerCount), ipNumber, -1):
+        ipAddress = Number2IP(i)
+        if runCommandFG(["ping", "-qnc", "1", ipAddress]) != 0:
+            return ipAddress
+    return None
+
+
+def getPasswordHash(userName):
+    try:
+        #return spwd.getspnam(userName).sp_pwd
+        return "Not implimented"
+    except KeyError:
+        return None
+
+
+def getTransactionKey():
+    try:
+        tokens = open(Globals.TRANSACTION_KEY_FILE).read().split(',')
+    except IOError:
+        return None, None
+    return tokens
+
+
+def generateSignature():
+    #return str(uuid.uuid4()) + ('--%f' % time.time())
+    return ('--%f' % time.time())
+
+
+def getSignature():
+    try:
+        return open(Globals.SIGNATURE_FILE).read().strip()
+    except IOError:
+        log(syslog.LOG_ERR, "unable to read signaure from %s file" % Globals.SIGNATURE_FILE)
+        return False
+
+
+def storeSignature(signature, fileName=Globals.SIGNATURE_FILE):
+    try:
+        open(fileName, "w").write(signature + "\n")
+    except IOError:
+        log(syslog.LOG_ERR, "unable to write signature %s to %s file" % (signature, fileName))
+        return False
+    return True
+
+
+def isUserExist(userName):
+    try:
+        grp.getgrnam(userName).gr_gid
+        return True
+    except KeyError:
+        pass
+    try:
+        pwd.getpwnam(userName).pw_uid
+        return True
+    except KeyError:
+        pass
+    return False
+
+
+def getGsnUserInfo(fileName=Globals.GSN_USER_INFO_FILE):
+    userInfo = {}
+    userInfo["UserId"] = None
+    userInfo["Password"] = None
+    try:
+        for line in open(fileName):
+            line = line.strip()
+            k = line[:line.index("=")]
+            v = line[line.index("=") + 1:]
+            if v[0] == "'" or v[0] == '"':
+                v = v[1:]
+            if v[-1] == "'" or v[-1] == '"':
+                v = v[:-1]
+            if k.upper() == "GSN_ID":
+                userInfo["UserId"] = v
+            if k.upper() == "GSN_PASSWORD":
+                userInfo["Password"] = v
+    except IOError, e:
+        log("Failed to read file %s: %s" % (fileName, e))
+    return userInfo
+
+
+def setGsnUserInfo(userInfo, fileName=Globals.GSN_USER_INFO_FILE):
+    try:
+        fp = open(fileName, "w")
+        fp.write("GSN_ID=%s\n" % userInfo["UserId"])
+        fp.write("GSN_PASSWORD=%s\n" % userInfo["Password"])
+        fp.close()
+        return True
+    except IOError, e:
+        log("Failed to write file %s: %s" % (fileName, e))
+    return False
+
+
+def getPlatformVersion(fileName=Globals.GLUSTER_VERSION_FILE):
+    versionInfo = {}
+    versionInfo["Version"] = None
+    versionInfo["Update"] = None
+    try:
+        lines = open(Globals.GLUSTER_VERSION_FILE).readlines()
+        for line in open(fileName):
+            line = line.strip()
+            k = line[:line.index("=")]
+            v = line[line.index("=") + 1:]
+            if v[0] == "'" or v[0] == '"':
+                v = v[1:]
+            if v[-1] == "'" or v[-1] == '"':
+                v = v[:-1]
+            if k.upper() == "VERSION":
+                versionInfo["Version"] = v
+            if k.upper() == "UPDATE":
+                versionInfo["Update"] = v
+    except IOError, e:
+        log("Failed to read file %s: %s" % (fileName, e))
+    return versionInfo
+
+
+def setPlatformVersion(versionInfo, fileName=Globals.GLUSTER_VERSION_FILE):
+    if isString(versionInfo):
+        tokens = versionInfo.strip().split(".")
+        if len(tokens) < 2:
+            log("Invalid version format %s. Expecting <MAJOR>.<MINOR>.<PATCHLEVEL>" % versionInfo)
+            return False
+        version = ".".join(tokens[:2])
+        update = ".".join(tokens[2:])
+        if not update:
+            update = "0"
+    else:
+        version = versionInfo["Version"]
+        update = versionInfo["Update"]
+    try:
+        fp = open(fileName, "w")
+        fp.write("VERSION=%s\n" % version)
+        fp.write("UPDATE=%s\n" % update)
+        fp.close()
+        return True
+    except IOError, e:
+        log("Failed to write file %s: %s" % (fileName, e))
+    return False
+
+
+def getGlusterUpdateDom(serverVersion):
+    errorMessage = ""
+    updateInfoDom = None
+    try:
+        baseUrl = open(Globals.GLUSTER_UPDATE_SITE_FILE).read().strip()
+    except IOError, e:
+        log("Failed to read file %s: %s" % (Globals.GLUSTER_UPDATE_SITE_FILE, e))
+        errorMessage = "Failed to read update site file"
+        return updateInfoDom, errorMessage
+
+    try:
+        url = "%s/%s/%s" % (baseUrl, serverVersion, Globals.GLUSTER_UPDATES_FILE)
+        connection = urllib.urlopen(url)
+        if connection.getcode() != 200:
+            connection.close()
+            errorMessage = "Error received from server to open URL %s" % url
+            return updateInfoDom, errorMessage
+        updateInfoString = connection.read()
+        connection.close()
+    except IOError, e:
+        log("Failed to get update information from URL %s: %s" % (url, e))
+        errorMessage = "Error getting update information"
+        return updateInfoDom, errorMessage
+
+    updateInfoDom = Protocol.XDOM()
+    if not updateInfoDom.parseString(updateInfoString):
+        log("XML parse error on update information content [%s]" % updateInfoString)
+        errorMessage = "Parse error on update information"
+        updateInfoDom = None
+    return updateInfoDom, errorMessage
+
+
+def removeFile(fileName, root=False):
+    if root:
+        if runCommand("rm %s" % fileName, root=True) == 0:
+            return True
+        return False
+    try:
+        os.remove(fileName)
+        return True
+    except OSError, e:
+        log("Failed to remove file %s: %s" % (fileName, e))
+    return False
+
+
+def isLiveMode():
+    return os.path.exists(Globals.LIVE_MODE_FILE)
+
+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)
+
+def log(priority, message=None):
+    if type(priority) == type(""):
+        logPriority = syslog.LOG_INFO
+        logMessage = priority
+    else:
+        logPriority = priority
+        logMessage = message
+    if not logMessage:
+        return
+    #if Globals.DEBUG:
+    #    sys.stderr.write(logMessage)
+    else:
+        syslog.syslog(logPriority, logMessage)
+    return
+
+
+def stripEmptyLines(content):
+    ret = ""
+    for line in content.split("\n"):
+        if line.strip() != "":
+            ret += line
+    return ret
+
+
+def getDeviceFormatStatusFile(device):
+    return "/var/tmp/format_%s.status" % device.replace('/', '_')
+
+def getDeviceFormatLockFile(device):
+    return "/var/lock/format_%s.lock" % device.replace('/', '_')
+
+def getDeviceFormatOutputFile(device):
+    return "/var/tmp/format_%s.out" % device.replace('/', '_')
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/XmlHandler.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/XmlHandler.py
new file mode 100644
index 00000000..72164ffb
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/XmlHandler.py
@@ -0,0 +1,346 @@
+#  Copyright (C) 2009 Gluster, Inc. <http://www.gluster.com>

+#  This file is part of Gluster Storage Platform.

+#

+#  Gluster Storage Platform is free software; you can redistribute it

+#  and/or modify it under the terms of the GNU General Public License

+#  as published by the Free Software Foundation; either version 3 of

+#  the License, or (at your option) any later version.

+#

+#  Gluster Storage Platform is distributed in the hope that it will be

+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty

+#  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+#  GNU General Public License for more details.

+#

+#  You should have received a copy of the GNU General Public License

+#  along with this program.  If not, see

+#  <http://www.gnu.org/licenses/>.

+

+import xml

+import xml.parsers.expat

+import xml.dom.minidom as MDOM

+import os

+import Globals

+import copy

+import Utils

+

+XML_STRING = 0

+XML_FILE = 1

+

+class XDOM:

+    _domObj = None

+

+    def __init__(self):

+        self._domObj = MDOM.Document()

+        return

+

+    @classmethod

+    def getText(self, nodeList):

+        rc = ""

+        for node in nodeList:

+            if node.nodeType == node.TEXT_NODE:

+                rc = rc + node.data

+        return rc

+

+    def parseString(self, requestString):

+        try:

+            self._domObj = MDOM.parseString(requestString)

+        except xml.parsers.expat.ExpatError, e:

+            Utils.log("XML string parse error: %s" % str(e))

+            return False

+        return True

+

+    def parseFile(self, fileName):

+        try:

+            self._domObj = MDOM.parse(fileName)

+        except IOError, e:

+            Utils.log("error reading file: %s" % str(e))

+            return False

+        except xml.parsers.expat.ExpatError, e:

+            Utils.log("XML file %s parse error: %s" % (fileName, str(e)))

+            return False

+        return True

+

+    def setDomObj(self, dom):

+        if dom and type(dom) != type([]):

+            self._domObj = dom

+            return True

+        return False

+

+    def createTag(self, tag, text=None):

+        if not self._domObj:

+            return None

+        if tag == None:

+            return None

+

+        tagE = self._domObj.createElement(str(tag))

+        if text:

+            tagEText = self._domObj.createTextNode(str(text))

+            tagE.appendChild(tagEText)

+        return tagE

+

+    def addTag(self, tag):

+        if not self._domObj:

+            return False

+        if not tag:

+            return False

+

+        self._domObj.appendChild(tag)

+        return True

+

+    def createTagRoute(self, tagRoute, text=None):

+        if not tagRoute:

+            return False

+

+        tagList = tagRoute.split(".")

+        tag = None

+        previousTag = None

+        for tagName in tagList[:-1]:

+            newTag = self.createTag(tagName, None)

+            if not tag:

+                tag = newTag

+                previousTag = newTag

+                continue

+            previousTag.appendChild(newTag)

+            previousTag = newTag

+

+        if previousTag:

+            previousTag.appendChild(self.createTag(tagList[-1], text))

+        else:

+            tag = self.createTag(tagList[-1], text)

+        return tag

+

+    def appendTagRoute(self, tagRoute, value=None):

+        if not self._domObj:

+            return False

+        if not tagRoute:

+            return False

+

+        parentTagE = self._domObj

+

+        tagNameList = tagRoute.split(".")

+        newTagRoute = tagNameList.pop(-1)

+

+        for i in range(len(tagNameList), 0, -1):

+            tagE = self.getElementsByTagRoute(".".join(tagNameList[:i]))

+            if tagE:

+                parentTagE = tagE[0]

+                break

+            newTagRoute = tagNameList[i-1] + "." + newTagRoute

+

+        newTagE = self.createTagRoute(newTagRoute, value)

+        if not newTagE:

+            return False

+        try:

+            parentTagE.appendChild(newTagE)

+        except xml.dom.HierarchyRequestErr, e:

+            Utils.log("error occured.  %s" + str(e))

+            return False

+        return True

+

+    def setTextByTagRoute(self, tagRoute, tagValue):

+        if not self._domObj:

+            return None

+

+        if not tagRoute:

+            return None

+

+        tagE  = self.getElementsByTagRoute(tagRoute)

+        if not tagE:

+            return False

+

+        parentTagE = self.getElementsByTagRoute(".".join(tagRoute.split(".")[:-1]))

+        if not parentTagE:

+            return False

+        

+        parentTagE[0].childNodes.remove(tagE[0])

+        parentTagE[0].appendChild(self.createTag(tagRoute.split(".")[-1], tagValue))

+        return True

+

+    def getElementsByTagRoute(self, tagRoute):

+        if not self._domObj:

+            return None

+        

+        if not tagRoute:

+            return None

+

+        x = None

+        for tag in tagRoute.split("."):

+            if x is None:

+                x = self._domObj.getElementsByTagName(tag)

+                continue

+            if x == []:

+                break

+            x = x[0].getElementsByTagName(tag)

+        return x

+

+    def getTextByTagRoute(self, tagRoute):

+        if not self._domObj:

+            return None

+

+        x = self.getElementsByTagRoute(tagRoute)

+        if x:

+            return self.getText(x[0].childNodes)

+        return None

+

+    def getElementsByTagName(self, name):

+        if not self._domObj:

+            return None

+        return self._domObj.getElementsByTagName(name)

+

+    def writexml(self, fileName, indent="", addindent="", newl=""):

+        if not self._domObj:

+            return None

+        try:

+            fp = open(fileName, "w")

+            self._domObj.writexml(fp, indent, addindent, newl)

+            fp.close()

+            return True

+        except IOError:

+            return False

+

+    def toString(self, indent="  ", newl="\n", encoding = None):

+        if not self._domObj:

+            return None

+        return self._domObj.toprettyxml(indent, newl, encoding)

+

+    def toxml(self, encoding = None):

+        if not self._domObj:

+            return None

+        return self._domObj.toxml(encoding)

+

+    def toprettyxml(self, indent="  ", newl="\n", encoding = None):

+        return self.toString(indent, newl, encoding)

+

+    def createResponseTag(self):

+        responseTag = self._domObj.createElement("response")

+        return responseTag

+##--end of XDOM

+

+class RequestXml(XDOM):

+    def __init__(self, requestString, type=None):

+        if None == requestString:

+            XDOM.__init__(self)

+            return

+        try:

+            if None == type:

+                if os.path.isfile(requestString):

+                    self._domObj = MDOM.parse(requestString)

+                else:

+                    self._domObj = MDOM.parseString(requestString)

+            elif XML_FILE == type:

+                self._domObj = MDOM.parse(requestString)

+            elif XML_STRING == type:

+                self._domObj = MDOM.parseString(requestString)

+        except IOError:

+            XDOM.__init__(self)

+        except xml.parsers.expat.ExpatError:

+            XDOM.__init__(self)

+

+##--end of RequestXML

+

+

+class ResponseXml(XDOM):

+    _responseTag = None

+    def __init__(self):

+        XDOM.__init__(self)

+        self._responseTag = self.createResponseTag()

+        self._domObj.appendChild(self._responseTag)

+

+    @classmethod

+    def errorResponse(self, message):

+        if not self.responseTag:

+            return False

+        self.appendTagRoute("status.code", "-1");

+        self.appendTagRoute("status.message", message)

+

+    def append(self, tagName, tagValue=None):

+        if not self._responseTag:

+            return False

+        tag = self.createTag(tagName, tagValue)

+        if tag:

+            self._responseTag.appendChild(tag)

+            return True

+        return False

+

+    def appendTag(self, tag):

+        if not tag:

+            return False

+        if not self._responseTag:

+            return False

+        self._responseTag.appendChild(tag)

+        return True

+

+    def appendTagRoute(self, tagRoute, value=None):

+        if not self._responseTag:

+            return None

+        if not tagRoute:

+            return None

+

+        parentTagE = self._responseTag

+

+        tagNameList = tagRoute.split(".")

+        newTagRoute = tagNameList.pop(-1)

+

+        for i in range(len(tagNameList), 0, -1):

+            tagE = self.getElementsByTagRoute(".".join(["response"] + tagNameList[:i]))

+            if tagE:

+                parentTagE = tagE[0]

+                break

+            newTagRoute = tagNameList[i-1] + "." + newTagRoute

+

+        newTagE = self.createTagRoute(newTagRoute, value)

+        if not newTagE:

+            return None

+        try:

+            parentTagE.appendChild(newTagE)

+        except xml.dom.HierarchyRequestErr, e:

+            Utils.log("error occured.  %s" + str(e))

+            return None

+        return newTagE

+

+    def appendTagRouteOld(self, tagRoute, value=None):

+        if not self._responseTag:

+            return False

+        if not tagRoute:

+            return False

+

+        parentTagE = self._responseTag

+

+        tagNameList = tagRoute.split(".")

+        newTagRoute = tagNameList.pop(-1)

+

+        for i in range(len(tagNameList), 0, -1):

+            tagE = self.getElementsByTagRoute(".".join(["response"] + tagNameList[:i]))

+            if tagE:

+                parentTagE = tagE[0]

+                break

+            newTagRoute = tagNameList[i-1] + "." + newTagRoute

+

+        newTagE = self.createTagRoute(newTagRoute, value)

+        if not newTagE:

+            return False

+        try:

+            parentTagE.appendChild(newTagE)

+        except xml.dom.HierarchyRequestErr, e:

+            Utils.log("error occured.  %s" + str(e))

+            return False

+        return True

+##--end of ResponseXml

+

+def test():

+    rs = ResponseXml()

+    rs.appendTagRoute("status.code", "0"); 

+    rs.appendTagRoute("status.message", "SUCCESS")

+    serverTag = rs.appendTagRoute("server.name", "Server1")

+    networkInterfaces  = rs.appendTagRoute("server.networkInterfaces", None)

+    networkTag = rs.createTag("networkInterface", None)

+    networkTag.appendChild(rs.createTag("name", "interface1"))

+    networkTag.appendChild(rs.createTag("ipaddress", "192.168.1.40"))

+    networkInterfaces.appendChild(networkTag)

+    networkTag = rs.createTag("networkInterface", None)

+    networkTag.appendChild(rs.createTag("name", "interface2"))

+    networkTag.appendChild(rs.createTag("ipaddress", "192.168.1.41"))

+    networkInterfaces.appendChild(networkTag)

+    print rs.toprettyxml()

+

+#test()

diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/add_user_cifs_all.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/add_user_cifs_all.py
new file mode 100755
index 00000000..e4b48658
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/add_user_cifs_all.py
@@ -0,0 +1,66 @@
+#!/usr/bin/python
+#  Copyright (C) 2011 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Management Gateway.
+#
+
+import os
+import sys
+import Utils
+
+
+defaultUid = 1024000
+cifsUserFile = "/etc/glustermg/.users.cifs"
+
+
+def getLastUid():
+    if not os.path.exists(cifsUserFile):
+        return defaultUid
+    try:
+        fp = open(cifsUserFile)
+        content = fp.read()
+        fp.close()
+    except IOError, e:
+        Utils.log("failed to read file %s: %s" % (cifsUserFile, str(e)))
+        return False
+
+    lines = content.strip().split()
+    if not lines:
+        return defaultUid
+    return int(lines[-1].split(":")[0])
+
+
+def setUid(uid, userName):
+    try:
+        fp = open(cifsUserFile, "a")
+        fp.write("%s:%s\n" % (uid, userName))
+        fp.close()
+        return True
+    except IOError, e:
+        Utils.log("failed to write file %s: %s" % (cifsUserFile, str(e)))
+        return False
+
+
+def main():
+    if len(sys.argv) < 4:
+        sys.stderr.write("usage: %s SERVER_FILE USERNAME PASSWORD\n" % os.path.basename(sys.argv[0]))
+        sys.exit(-1)
+
+    serverFile = sys.argv[1]
+    userName = sys.argv[2]
+    password = sys.argv[3]
+
+    uid = getLastUid()
+    if not uid:
+        sys.exit(10)
+
+    uid += 1
+
+    rv = Utils.runCommand("grun.py %s add_user_cifs.py %s %s %s" % (serverFile, uid, userName, password))
+    if rv == 0:
+        if not setUid(uid, userName):
+            sys.exit(11)
+    sys.exit(rv)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/delete_user_cifs_all.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/delete_user_cifs_all.py
new file mode 100755
index 00000000..38dd8109
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/delete_user_cifs_all.py
@@ -0,0 +1,53 @@
+#!/usr/bin/python
+#  Copyright (C) 2011 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Management Gateway.
+#
+
+import os
+import sys
+import Utils
+
+
+cifsUserFile = "/etc/glustermg/.users.cifs"
+
+
+def removeUser(userName):
+    try:
+        fp = open(cifsUserFile)
+        content = fp.read()
+        fp.close()
+    except IOError, e:
+        Utils.log("failed to read file %s: %s" % (cifsUserFile, str(e)))
+        return False
+
+    try:
+        fp = open(cifsUserFile, "w")
+        lines = content.strip().split()
+        for line in lines:
+            if line.split(":")[1] == userName:
+                continue
+            fp.write("%s\n" % line)
+        fp.close()
+    except IOError, e:
+        Utils.log("failed to write file %s: %s" % (cifsUserFile, str(e)))
+        return False
+    return True
+
+
+def main():
+    if len(sys.argv) < 3:
+        sys.stderr.write("usage: %s SERVER_LIST USERNAME\n" % os.path.basename(sys.argv[0]))
+        sys.exit(-1)
+
+    serverList = sys.argv[1]
+    userName = sys.argv[2]
+
+    rv = Utils.runCommand("grun.py %s delete_user_cifs.py %s" % (serverList, userName))
+    if rv == 0:
+        if not removeUser(userName):
+            sys.exit(10)
+    sys.exit(rv)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/grun.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/grun.py
new file mode 100755
index 00000000..ae93b7f2
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/grun.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python
+#  Copyright (C) 2011 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Management Gateway.
+#
+
+import os
+import sys
+import Utils
+
+
+def main():
+    sshCommandPrefix = "ssh -q -o BatchMode=yes -o GSSAPIAuthentication=no -o PasswordAuthentication=no -o StrictHostKeyChecking=no".split()
+
+    if len(sys.argv) < 3:
+        sys.stderr.write("usage: %s SERVER_FILE COMMAND [ARGUMENTS]\n" % os.path.basename(sys.argv[0]))
+        sys.exit(-1)
+    serverFile = sys.argv[1]
+    command = sys.argv[2:]
+
+    try:
+        fp = open(serverFile)
+        serverNameList = fp.readlines()
+        fp.close()
+    except IOError, e:
+        Utils.log("Failed to read server file %s: %s\n" % (serverFile, str(e)))
+        sys.exit(1)
+
+    for serverName in serverNameList:
+        rv = Utils.runCommand(sshCommandPrefix + [serverName.strip()] + command)
+        print rv
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/com.gluster.storage.management.gateway/WebContent/scripts/multicast-discover-servers.py b/src/com.gluster.storage.management.gateway/WebContent/scripts/multicast-discover-servers.py
new file mode 100755
index 00000000..ac434827
--- /dev/null
+++ b/src/com.gluster.storage.management.gateway/WebContent/scripts/multicast-discover-servers.py
@@ -0,0 +1,90 @@
+#!/usr/bin/python
+#  Copyright (C) 2009 Gluster, Inc. <http://www.gluster.com>
+#  This file is part of Gluster Storage Platform.
+#
+#  Gluster Storage Platform is free software; you can redistribute it
+#  and/or modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 3 of
+#  the License, or (at your option) any later version.
+#
+#  Gluster Storage Platform is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+#  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see
+#  <http://www.gnu.org/licenses/>.
+
+import sys
+import socket
+import signal
+import struct
+import syslog
+import Globals
+import time
+import Utils
+from XmlHandler import *
+
+class TimeoutException(Exception):
+    pass
+
+def timeoutSignal(signum, frame):
+    raise TimeoutException, "Timed out"
+
+def serverDiscoveryRequest(multiCastGroup, port):
+    servers = []
+    # Sending request to all the servers
+    socketSend = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+    socketSend.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+    socketSend.sendto("ServerDiscovery", (multiCastGroup, port))
+
+    # Waiting for the response
+    socketReceive = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+    socketReceive.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    socketReceive.bind(('', port))
+    mreq = struct.pack("4sl", socket.inet_aton(multiCastGroup), socket.INADDR_ANY)
+
+    socketReceive.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+    sendtime = time.time()
+    socketSend.sendto("<request><name>ServerDiscovery</name><time>%s</time></request>" % (sendtime), (multiCastGroup, port))
+
+    try:
+        while True:
+            response = socketReceive.recvfrom(200)
+            if not response:
+                continue
+            dom = XDOM()
+            dom.parseString(response[0])
+            if not dom:
+                continue
+            if dom.getTextByTagRoute("request.name"):
+                continue
+            responsetime = dom.getTextByTagRoute("response.time")
+            servername = dom.getTextByTagRoute("response.servername")
+            if responsetime == str(sendtime):
+                servers.append(servername)
+            signal.signal(signal.SIGALRM, timeoutSignal)
+            signal.alarm(3)
+    except TimeoutException:
+        return servers
+    return None
+
+def main():
+    syslog.openlog("discovery server request")
+    servers = serverDiscoveryRequest(Globals.MULTICAST_GROUP, Globals.MULTICAST_PORT)
+    if not servers:
+        Utils.log(syslog.LOG_ERR, "Failed to discover new servers")
+        sys.exit(-1)
+
+    servers = set(servers)
+    try:
+        for server in servers:
+            print server
+    except IOError:
+        Utils.log(syslog.LOG_ERR, "Unable to open file %s" % Globals.DISCOVERED_SERVER_LIST_FILENAME)
+        sys.exit(-1)
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()