#!/usr/bin/env python

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import sys
import os
import subprocess
import cloudtool
import urllib2
from optparse import OptionParser, OptionGroup, OptParseError, BadOptionError, OptionError, OptionConflictError, OptionValueError
import xml.dom.minidom

NetAppServerIP=None
NetAppUserName=None
NetAppPassword=None
CloudStackSvrIP=None
CloudStackSvrPort=8096


cmds=["createvol","deletevol", "listvol", "createlun", "listlun", "destroylun", "assoclun", "disassoclun", "createpool", "modifypool", "destroypool", "listpools"]
header = "Volume Manager CLI, the available COMMANDS are:"


def cmd_help():
    print header
    print
    print "createpool    add a new pool to the system"
    print "modifypool    change the allocation algorithm for a pool"
    print "destroypool   destroy a pool"
    print "listpools     list all the pools"
    print "createvol     add volume to a storage server"
    print "deletevol     delete volume on a storage server"
    print "listvol       list volume on a storage server"
    print "createlun     create LUN on a storage server"
    print "listlun       list LUN on a storage server"
    print "destroylun    destroy LUN on a storage server"
    print "assoclun      assoc LUN on a storage server"
    print "disassoclun   disassoc LUN on a storage server"
    print
    print "\"cloudvoladm COMMAND --help\" for more information on a specific command"
    print
    print "Global Options:"
    print "--cloudStackMgtSvrIP the IP address of CloudStack Management Server"
    print 
    print "Config file is ~/.cloudvoladmrc, Config options including: "
    print "cloudStackMgtSvrIP=Cloudstack Management Server Address, which can be overriden by --cloudStackMgtSvrIP. If neither is provided, localhost is used."

usage="Volume Manager CLI: add a new volume to a storage pool"
addvolParser= OptionParser(usage)
addvolParser.add_option("-i", metavar="server ip", dest="server_ip", help="The IP address of the storage server")
addvolParser.add_option("-u", metavar="username", dest="username", help="username to access the storage server with")
addvolParser.add_option("-w", metavar="password", dest="password", help="the password to access the storage server with")
addvolParser.add_option("-p", dest="pool_name", help="the name of the pool to allocate from") 
addvolParser.add_option("-a", dest="aggregate_name", help="the name of aggregate") 
addvolParser.add_option("-v", dest="vol_name", help="the name of volume") 
addvolParser.add_option("-s", dest="size", help="size in GB eg.1") 
optionalGroup = OptionGroup(addvolParser, "Optional")
optionalGroup.add_option("-r", dest="percentage", help="Percentage used for snapshot reserve") 
optionalGroup.add_option("-S", dest="snapshots", help="Snapshot schedule in <weeks> <days> <hours>@<which-hours> <minutes>@<which-minutes> e.g. \"2 4 5@1,4 6@2,5\"") 
addvolParser.add_option_group(optionalGroup)

usage="Volume Manager CLI: remove a volume from a pool"
delvolParser= OptionParser(usage)
delvolParser.add_option("-i", metavar="server ip", dest="server_ip", help="The IP address of the storage server")
delvolParser.add_option("-a", dest="aggregate_name", help="The name of aggregate") 
delvolParser.add_option("-v", dest="vol_name", help="The name of volume") 

usage="Volume Manager CLI: list all volumes known to exist in a pool"
listvolParser= OptionParser(usage)
listvolParser.add_option("-p", dest="pool_name", help="The name of the pool to list volumes from") 

usage="Volume Manager CLI: create a LUN on a pool"
createlunParser = OptionParser(usage)
createlunParser.add_option("-p", dest="pool_name", help="The name of the pool to add the volume to") 
createlunParser.add_option("-s", dest="size", help="The size in GB e.g. 100") 

usage="Volume Manager CLI: list LUN on a pool"
listlunParser = OptionParser(usage)
listlunParser.add_option("-p", dest="pool_name", help="The pool name") 

usage="Volume Manager CLI: destroy a LUN "
destroylunParser = OptionParser(usage)
destroylunParser.add_option("-l", dest="lun_name", help="The LUN name") 

usage="Volume Manager CLI: Add a new pool to the system"
createPoolParser = OptionParser(usage)
createPoolParser.add_option("-p", dest="pool_name", help="The pool name") 
createPoolParser.add_option("-A", dest="algorithm", help="roundrobin or leastfull") 


usage="Volume Manager CLI: change the allocation algorithm for a pool"
modifyPoolParser = OptionParser(usage)
modifyPoolParser.add_option("-p", dest="pool_name", help="The pool name") 
modifyPoolParser.add_option("-A", dest="algorithm", help="roundrobin or leastfull") 

usage="Volume Manager CLI: destroy a pool"
destroyPoolParser = OptionParser(usage)
destroyPoolParser.add_option("-p", dest="pool_name", help="The pool name") 

usage="Volume Manager CLI: list pools"
listPoolParser = OptionParser(usage)

usage="Volume Manager CLI: associate a LUN with a guest that uses the stated IQN as client"
assocLunParser = OptionParser(usage)
assocLunParser.add_option("-g", dest="guest_iqn", help="the guest IQN. By default, it reads from /etc/iscsi/initiatorname.iscsi") 
assocLunParser.add_option("-l", dest="lun_name", help="The LUN name") 

usage="Volume Manager CLI: disassociate a LUN with a guest that uses the stated IQN as client"
disassocLunParser = OptionParser(usage)
disassocLunParser.add_option("-g", dest="guest_iqn", help="the guest IQN. By default, it reads from /etc/iscsi/initiatorname.iscsi") 
disassocLunParser.add_option("-l", dest="lun_name", help="The LUN name") 

cmdParsers = {cmds[0]:addvolParser, cmds[1]:delvolParser, cmds[2]:listvolParser,  cmds[3]:createlunParser, cmds[4]:listlunParser, 
          cmds[5]:destroylunParser, cmds[6]:assocLunParser, cmds[7]:disassocLunParser, cmds[8]:createPoolParser, cmds[9]:modifyPoolParser, cmds[10]:destroyPoolParser, cmds[11]:listPoolParser}


def validate_parameter(input, signature):
    (options, args) =  signature.parse_args([])
    inputDict = input.__dict__
    sigDict = options.__dict__
    for k,v in sigDict.iteritems():
        inputValue = inputDict[k]
        if inputValue == None:
            print "Volume Manager CLI: missing operand "
            print
            signature.parse_args(["--help"])

def help_callback(option, opt, value, parser):
    argv = sys.argv[1:]
    try:
        argv.remove(opt)
    except:
        argv.remove("--h")

    if len(argv) == 0:
        cmd_help()
        return
    (options, args) = parser.parse_args(argv)
    for cmd in cmds:
        if cmd == args[0]:
            cmdParsers[cmd].parse_args(["--help"])      

def Help():
    usage = "usage: %prog cmd[createpool|listpools|modifypool|destroypool|createvol|deletevol|listvol|createlun|listlun|destroylun|assoclun|disassoclun] arg1 arg2 [--help, -h]"
    parser = OptionParser(usage=usage, add_help_option=False)   
    parser.add_option("-h", "--help", action="callback", callback=help_callback);
    parser.add_option("-i", metavar="server ip", dest="server_ip", help="The IP address of the storage server")
    parser.add_option("--cloudstackSvr", dest="cloudstackSvr", help="cloudStack Server IP") 
    parser.add_option("-u", metavar="username", dest="username", help="username to access the storage server with")
    parser.add_option("-w", metavar="password", dest="password", help="the password to access the storage server with")
    parser.add_option("-p", dest="pool_name", help="the name of the pool to allocate from") 
    parser.add_option("-v", dest="vol_name", help="the name of volume") 
    parser.add_option("-A", dest="algorithm", help="roundrobin or leastfull") 
    parser.add_option("-a", dest="aggregate_name", help="The name of aggregate") 
    parser.add_option("-o", dest="options", help="requested option string for the NFS export or attach") 
    parser.add_option("-S", dest="snapshots", help="Snapshot schedule e.g.2 4 5@1,4 6@2,5") 
    parser.add_option("-r", dest="percentage", help="Percentage used for snapshot reservation") 
    parser.add_option("-s", dest="size", help="size in GB eg.1") 
    parser.add_option("-t", dest="target_iqn", help="the target IQN") 
    parser.add_option("-g", dest="guest_iqn", help="the guest IQN") 
    parser.add_option("-l", dest="lun_name", help="the LUN name") 
    
    return parser

def httpErrorHandler(code, msg):
    try:
        errtext = xml.dom.minidom.parseString(msg) 
        if errtext.getElementsByTagName("errortext") is not None:
            err = getText(errtext.getElementsByTagName("errortext")[0].childNodes).strip()
            print err
    except:
        print "Internal Error %s"%msg
    
def getText(nodelist):
    rc = []
    for node in nodelist:
        if node.nodeType == node.TEXT_NODE: rc.append(node.data)
    return ''.join(rc)

def createvol(options):
    args = []
    if options.pool_name == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])
    if options.aggregate_name == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])
    if options.vol_name == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])
    
    if options.snapshots != None:
        args += ['--snapshotpolicy=' + options.snapshots]
        
    if options.size == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])
        
    if options.percentage != None:
        args += ['--snapshotreservation=' + options.percentage]

    if NetAppServerIP == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])

    if NetAppUserName == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])
    
    if NetAppPassword == None:
        print "Volume Manager CLI: missing operand "
        print
        addvolParser.parse_args(["--help"])

    '''
    snapshot = options.snapshots
    tokens = snapshot.split(" ")
    print tokens
    pos = 0;
    for token in tokens:
        if pos == 0:
            #week
            try:
                week = int(token)           
                if week < 0:
                    raise
            except:
                print "Pls input correct week"
                sys.exit(1)
        elif pos == 1:
            try:
                day = int(token)
                if day < 0:
                    raise
            except:
                print "Pls input correct day"
                sys.exit(1)
        
        elif pos == 2:
            try:
                hours = token.split("@")
                if int(hours[0]) < 0:
                    raise
                hourlists = hours[1].split(",")
                for hour in hourlists:
                    if int(hour) < 0 or int(hour) > 24:
                        raise
            except:
                print "Pls input correct hour"
                sys.exit(1)
        elif pos == 3:
            try:
                minutes = token.split("@")
                if int(minutes[0]) < 0:
                    raise
                
                minuteslist = minutes[1].split(",")
                for minute in minuteslist:
                    if int(minute) < 0 or int(minute) > 60:
                        raise
            except:
                print "Pls input correct hour"
                sys.exit(1)
                
    '''
    

    try:
        output = cloudtool.main(['cloud-tool', 'createVolumeOnFiler', '--ipaddress=' + NetAppServerIP ,  '--aggregatename=' + options.aggregate_name,
                            '--poolname=' + options.pool_name, '--volumename=' + options.vol_name,
                            '--size=' + options.size,                  
                            '--username=' + NetAppUserName, '--password=' + NetAppPassword, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"] + args)
        print "Successfully added volume"
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing createvol cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing createvol cmd failed: %s" % (err.reason)
        sys.exit(1)


def deletevol(options):
    validate_parameter(options, delvolParser)

    try:
        output = cloudtool.main(['cloud-tool', 'destroyVolumeOnFiler', '--ipaddress=' + NetAppServerIP,  '--aggregatename=' + options.aggregate_name,
                             '--volumename=' + options.vol_name, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully deleted volume"
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing deletevol cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing deletevol cmd failed: %s" % (err.reason)
        sys.exit(1)
        
def listvol(options):
    validate_parameter(options, listvolParser)
    
    try:
        output = cloudtool.main(['cloud-tool', 'listVolumesOnFiler', '--poolname=' + options.pool_name, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"]).strip("\n")

        xmlResult = xml.dom.minidom.parseString(output) 
        print "%-10s %-20s %-20s %-40s %-20s %-30s "%('Id', 'Address', 'Aggregate', 'Volume', 'Size(GB)', 'snapshotPolicy', )
        for volume in xmlResult.getElementsByTagName("volume"):
            aggregatename = getText(volume.getElementsByTagName('aggregatename')[0].childNodes).strip()
            id = getText(volume.getElementsByTagName('id')[0].childNodes).strip()
            volumeName = getText(volume.getElementsByTagName('volumename')[0].childNodes).strip()
            snapshotPolicy = getText(volume.getElementsByTagName('snapshotpolicy')[0].childNodes).strip()
            ipaddress = getText(volume.getElementsByTagName('ipaddress')[0].childNodes).strip()
            volSize = getText(volume.getElementsByTagName('size')[0].childNodes).strip()
            print "%-10s %-20s %-20s %-40s %-20s %-30s "%(id, ipaddress, aggregatename, volumeName, volSize, snapshotPolicy)
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing listvol cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing listvol cmd failed: %s" % (err.reason)
        sys.exit(1)


def createlun(options):
    validate_parameter(options, createlunParser)

    try:
        output = cloudtool.main(['cloud-tool', 'createLunOnFiler', '--name=' + options.pool_name,
                                              '--size=' + options.size, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])

        xmlResult = xml.dom.minidom.parseString(output.strip("\n"))
        path = getText(xmlResult.getElementsByTagName("path")[0].childNodes).strip()
        iqn = getText(xmlResult.getElementsByTagName("iqn")[0].childNodes).strip()
        ipAddr = getText(xmlResult.getElementsByTagName('ipaddress')[0].childNodes).strip()
        print "%-30s %-30s %-50s "%('LUN Name', 'Address', 'Target IQN')
        print "%-30s %-30s %-50s "%(path, ipAddr, iqn)
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing createlun cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing createlun cmd failed: %s" % (err.reason)
        sys.exit(1)

def listlun(options):
    validate_parameter(options, listlunParser)

    args = ["--poolname=" + options.pool_name, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"]
    try:
        output = cloudtool.main(['cloud-tool', 'listLunsOnFiler'] + args).strip("\n")
        xmlResult = xml.dom.minidom.parseString(output)
        
        print "%-10s %-10s %-50s %-30s "%('LUN Id', 'Volume Id', 'Target IQN', 'LUN Name')
        for volume in xmlResult.getElementsByTagName("lun"):
            uuid = getText(volume.getElementsByTagName('id')[0].childNodes).strip()
            path = getText(volume.getElementsByTagName('name')[0].childNodes).strip()
            targetiqn = getText(volume.getElementsByTagName('iqn')[0].childNodes).strip()
            volumeId = getText(volume.getElementsByTagName('volumeid')[0].childNodes).strip()
            print "%-10s %-10s %-50s %-30s "%(uuid, volumeId, targetiqn, path)
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing listlun cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing listlun cmd failed: %s" % (err.reason)
        sys.exit(1)

def destroylun(options):
    validate_parameter(options, destroylunParser)

    try:
        output = cloudtool.main(['cloud-tool', 'destroyLunOnFiler', '--path=' + options.lun_name,
                                              "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully destroyed LUN"
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing destroylun cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing destroylun failed: %s" % (err.reason)
        sys.exit(1)

def assoclun(options):
    validate_parameter(options, assocLunParser)

    try:
        output = cloudtool.main(['cloud-tool', 'associateLun', '--name=' + options.lun_name,
                                              '--iqn=' + options.guest_iqn, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        xmlResult = xml.dom.minidom.parseString(output.strip("\n"))
        lunid = getText(xmlResult.getElementsByTagName("id")[0].childNodes).strip()
        iqn = getText(xmlResult.getElementsByTagName("targetiqn")[0].childNodes).strip()
        ipAddr = getText(xmlResult.getElementsByTagName('ipaddress')[0].childNodes).strip()
        print "%-30s %-30s %-50s "%('LUN Id', 'Address', 'Target IQN')
        print "%-30s %-30s %-50s" % (lunid, ipAddr, iqn)
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing assoclun cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing assoclun failed: %s" % (err.reason)
        sys.exit(1)
        
def disassoclun(options):
    validate_parameter(options, disassocLunParser)

    try:
        output = cloudtool.main(['cloud-tool', 'dissociateLun', '--path=' + options.lun_name,
                                              '--iqn=' + options.guest_iqn, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully dissociated LUN"
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing disassoclun cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing disassoclun failed: %s" % (err.reason)
        sys.exit(1)

def createpool(options):
    validate_parameter(options, createPoolParser)

    if not (options.algorithm == "roundrobin" or options.algorithm == "leastfull"):
        print "Only roundrobin or leastfull algorithm is supported"
        sys.exit(1)
    try:
        output = cloudtool.main(['cloud-tool', 'createPool', '--name=' + options.pool_name,
                                              '--algorithm=' + options.algorithm, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully created pool"
    except urllib2.HTTPError, err:
        code = err.code
        print "executing createpool cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, err.read())
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing createpool failed: %s" % (err.reason)
        sys.exit(1)

def listpools(options):
    try:
        output = cloudtool.main(['cloud-tool', 'listPools',
                                 "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        output = output.strip("\n")
        xmlResult = xml.dom.minidom.parseString(output) 
        print "%-10s %-40s %-10s" %('Id', 'Pool Name', 'Algorithm')
        for volume in xmlResult.getElementsByTagName("pool"):
            id = getText(volume.getElementsByTagName('id')[0].childNodes).strip()
            poolname = getText(volume.getElementsByTagName('name')[0].childNodes).strip()
            alg = getText(volume.getElementsByTagName('algorithm')[0].childNodes).strip()
            print "%-10s %-40s %-10s"%(id, poolname, alg)
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing listpools cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing listpools failed, due to: %s" % (err.reason)
        sys.exit(1)

def modifypool(options):
    validate_parameter(options, modifyPoolParser)
    
    try:
        output = cloudtool.main(['cloud-tool', 'modifyPool', '--poolname=' + options.pool_name,
                                              '--algorithm=' + options.algorithm, "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully modified pool"
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing modifypool cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing modifypool failed, due to: %s" % (err.reason)
        sys.exit(1)

def destroypool(options):
    validate_parameter(options, destroyPoolParser)

    try:
        output = cloudtool.main(['cloud-tool', 'deletePool', '--poolname=' + options.pool_name,
                                         "--server=" + CloudStackSvrIP + ":" + str(CloudStackSvrPort), "--stripxml=false"])
        print "Successfully destroyed pool: " + options.pool_name
    except urllib2.HTTPError, err:
        code = err.code
        msg = err.read()
        print "executing destroypool cmd failed, http returning error code: %s" % (code)
        httpErrorHandler(code, msg)
        sys.exit(1)
    except urllib2.URLError, err:
        print "executing destroypool failed, due to: %s" % (err.reason)
        sys.exit(1)

def loadCfgFile():
    options = dict()
    try:
        cfgFile = open(os.environ['HOME'] + "/.cloudvoladmrc")
        for line in cfgFile:
            option = line.split("=")
            if option[0] == "cloudStackMgtSvrIP":
                options["cloudStackMgtSvrIP"] = option[1].strip("\n")

    except:
        return None

    return options
        
def getGuestIQN():
    try:
        initialFile = open("/etc/iscsi/initiatorname.iscsi")    
        for line in initialFile:
            iqn = line.split("=")
            if iqn[0] == "InitiatorName":
                return iqn[1].strip("\n")
    except:
        return None
    return None

if __name__ == '__main__':
    parser = Help()
    (options, args) = parser.parse_args()
    
    globalCfg = loadCfgFile()

    NetAppServerIP= options.server_ip

    NetAppUserName = options.username
    
    NetAppPassword = options.password
    
    CloudStackSvrIP = options.cloudstackSvr
    if CloudStackSvrIP == None:
        if globalCfg != None and "cloudStackMgtSvrIP" in globalCfg:
            CloudStackSvrIP = globalCfg["cloudStackMgtSvrIP"]
        if CloudStackSvrIP == None:
            CloudStackSvrIP = "127.0.0.1"

    if options.guest_iqn == None:
        GuestIQN = getGuestIQN()    
        options.__dict__["guest_iqn"] = GuestIQN

    if len(args) == 0:
        sys.exit(1)
    cmd = args[0]
    if cmd == "createvol":
        createvol(options)
    elif cmd == "deletevol":
        deletevol(options)
    elif cmd == "listvol":
        listvol(options)
    elif cmd == "createlun":
        createlun(options)
    elif cmd == "listlun":
        listlun(options)
    elif cmd == "destroylun":
        destroylun(options)
    elif cmd == "assoclun":
        assoclun(options)
    elif cmd == "disassoclun":
        disassoclun(options)
    elif cmd == "createpool":
        createpool(options)
    elif cmd == "modifypool":
        modifypool(options)
    elif cmd == "destroypool":
        destroypool(options)
    elif cmd == "listpools":
        listpools(options)
    else:
        print "Unrecoginzied command"   
        cmd_help()
        sys.exit(1)