flex.py #19

#!/usr/bin/env python

import os
import pwd
import sys

from P4 import P4, P4Exception

sys.path.append("/usr/local/lib/netapp-manageability-sdk-5.3.1/lib/python/NetApp")
from NaServer import *



if sys.version_info[0] >= 3:
    from configparser import ConfigParser
else:
    from ConfigParser import ConfigParser


# ---------------------------------------------------------------------------
# Singleton class (of sorts) for loading configuration
# ---------------------------------------------------------------------------
class Config:
    def __init__(self, file):
        self.config = ConfigParser()
        try:
            self.config.read(file)
        except:
            print("Could not read config file: %s" % file)
            sys.exit(2)
            
    def get(self, key):
        parts = key.split(".")
        try:
            value = self.config.get(parts[0], parts[1])
        except:
            print("Could not access config: %s" % key)
            sys.exit(2)
        return value

dir = os.path.dirname(os.path.realpath(__file__))
config = Config(dir + "/flex.cfg")
FLEX_SNAP = config.get("p4.snap")
FLEX_CLONE = config.get("p4.clone")
# ---------------------------------------------------------------------------



# ---------------------------------------------------------------------------
# NetApp Server connection as 'admin' user
# ---------------------------------------------------------------------------
class NaFlex:
    def __init__(self):
        self.server = config.get("NaServer.server")
        self.port = config.get("NaServer.port")
        self.user = config.get("NaServer.admin_user")
        self.passwd = config.get("NaServer.admin_passwd")
        self.vserver = config.get("NaServer.vserver")
        self.transport = config.get("NaServer.transport")
        self.style = config.get("NaServer.style")
        self.server_type = config.get("NaServer.server_type")
        self.aggr = config.get("NaServer.aggr")
        self.mount = config.get("NaServer.mount_base")

    # Sets the filer properties for connection
    # @returns the NaServer connection
    def get(self):
        s = NaServer(self.server, 1 , 15)
        s.set_server_type(self.server_type)
        resp = s.set_style(self.style)
        if (resp and resp.results_errno() != 0) :
            r = resp.results_reason()
            print ("Failed to set authentication style " + r + "\n")
            sys.exit (2)

        s.set_admin_user(self.user, self.passwd)
        resp = s.set_transport_type(self.transport)
        if (resp and resp.results_errno() != 0) :
            r = resp.results_reason()
            print ("Unable to set HTTP transport " + r + "\n")
            sys.exit (2)
            
        s.set_vserver(self.vserver)
        s.set_port(self.port)
	return s

    # Creates the volume based on name and size
    def create(self, name, size):
	api = NaElement("volume-create")
        api.child_add_string("containing-aggr-name", self.aggr)
        api.child_add_string("size", size)
        api.child_add_string("volume", name)
        #api.child_add_string("junction-active", "true")
        jpath = "/" + name
        api.child_add_string("junction-path", jpath)

        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

    # Takes a snapshot of specified volume
    def snapshot(self, volname, snapname):
	api = NaElement("snapshot-create")
        api.child_add_string("volume", volname)
        api.child_add_string("snapshot", snapname)

        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())
        
    # Creates a volume clone based on the snapshot of parent volume
    def clone(self, cvolname, psnapname, pvolname):
        api = NaElement("volume-clone-create")
        api.child_add_string("junction-active", "true")
        jpath = "/" + cvolname
        api.child_add_string("junction-path", jpath)
        api.child_add_string("parent-snapshot", psnapname)
        api.child_add_string("parent-volume", pvolname)
        api.child_add_string("volume", cvolname)
        
        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

    # Deletes the volume by unmounting, offlining and then deleting volume from vserver
    def delete(self, volname):

        # Check to make sure volume passed in is not vserver root or node volume
        # Root and node volumes are required to keep info on state of vserver and node
        api = NaElement("volume-get-iter")

        # Build the input values for the api query call
        xi1 = NaElement("query")
        api.child_add(xi1)
        xi2 = NaElement("volume-attributes")
        xi1.child_add(xi2)
        xi3 = NaElement("volume-id-attributes")
        xi2.child_add(xi3)
        xi3.child_add_string("name", volname)

        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

        vlist = xo.child_get("attributes-list")
        vsattrs = None
        if (vlist != None):
            vol = vlist.child_get("volume-attributes")
            vsattrs = vol.child_get("volume-state-attributes")

        if (vsattrs != None):
            isvroot = vsattrs.child_get_string("is-vserver-root")
            isnroot = vsattrs.child_get_string("is-node-root")
            if ((isvroot == "true") or (isnroot == "true")):
                raise NAException("Not authorized to delete vserver root-volume %s. Go directly to the NetApp Filer to conduct this operation" % (volname))

        # Unmount 
        api = NaElement("volume-unmount")
        api.child_add_string("force", "false")
        api.child_add_string("volume-name", volname)
        
        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

        # Offline
        api = NaElement("volume-offline")
        api.child_add_string("name", volname)
        
        xo = self.get().invoke_elem(api)
        if ((xo.results_status() == "failed") and (xo.results_errno() != "13042")):
            raise NAException(xo.sprintf())

        # Delete
        api = NaElement("volume-destroy")
        api.child_add_string("name", volname)

        xo = self.get().invoke_elem(api)
        if (xo.results_status() == "failed"):
            raise NAException(xo.sprintf())
    
    # Prints out the list of volumes 
    def vlist (self):
        list = []
        
        # Get First Set of mrecs (100) records
        mrecs = "100"
        api = NaElement("volume-get-iter")
        api.child_add_string("max-records", mrecs)
        xo = self.get().invoke_elem(api)

        if(xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

        # Set up to get next set of records
        tag = xo.child_get_string("next-tag")
  
        # Add vollist results to list and then Get Following set of records
        # Break from loop when the vollist is None or next-tag is None
        while True:
            vollist = xo.child_get("attributes-list")

            if (vollist == None): 
                break
            
            for vol in vollist.children_get():
                volattrs = vol.child_get("volume-id-attributes")
                volpname = ""
                
                volstateattrs = vol.child_get("volume-state-attributes")
                if (volstateattrs != None):
                    state = volstateattrs.child_get_string("state") 
                    isroot = volstateattrs.child_get_string("is-vserver-root")
                    
                volcattrs = vol.child_get("volume-clone-attributes")
                if (volcattrs != None): 
                    volpattrs = volcattrs.child_get("volume-clone-parent-attributes")
                    if (volpattrs != None):
                        volpname = volpattrs.child_get_string("name")

                # Only print out volume if volume is online, not a clone, and not vserver root volume
                if (state == "online") and (volpname == "") and (isroot != "true"):
                    list.append(volattrs);

            api = NaElement("volume-get-iter")
            api.child_add_string("max-records", mrecs)
            api.child_add_string("tag", tag)
            xo = self.get().invoke_elem(api)
            if(xo.results_status() == "failed"):
                raise NAException(xo.sprintf())

            # Get next tag which indicates if there are more records
            tag = xo.child_get_string("next-tag")
            if (tag == None):
                break
            
        return list

    # Print out list of snapshots based on volume name
    def slist(self, vname):

        # Get First Set of records
        api = NaElement("snapshot-list-info")
        api.child_add_string("volume", vname)

        xo = self.get().invoke_elem(api)

        if (xo.results_errno() != 0) :
            raise NAException(xo.sprintf())

        # # get snapshot list
        snapshotlist = xo.child_get("snapshots")
        print("\n")

        if ((snapshotlist != None) and (snapshotlist != "")) :
            # iterate through snapshot list
            snapshots = snapshotlist.children_get()
            for ss in snapshots:
                sname = ss.child_get_string("name")
                print("snapshot:%s" % (sname))
        else:
            print("No snapshots for volume " + vname)

    # Print out volume name and their snapshots
    def slistall(self):
        # Get first set of records defined by mrecs
        mrecs = "100"
        api = NaElement("snapshot-get-iter")
        api.child_add_string("max-records", mrecs)
        xo = self.get().invoke_elem(api)

        if(xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

        # Set up tag to get next set of records
        tag = xo.child_get_string("next-tag")
        
        # Need to go thru this loop at least once before checking for next tag
        # Break out of loop if snaplist is None or next-tag is None
        while True:
            # Get list of snapshot-info attributes
            snaplist = dict()
            snaplist = xo.child_get("attributes-list")

            if (snaplist == None):
                break

            # Go thru list and print out volume and snapshot name
            for snap in snaplist.children_get(): 
                print("snapshot: %s:%s" % (snap.child_get_string("volume"), snap.child_get_string("name")))
                
            # Get next set of records
            api = NaElement("snapshot-get-iter")
            api.child_add_string("max-records", mrecs)
            api.child_add_string("tag", tag)
            xo = self.get().invoke_elem(api)
            if(xo.results_status() == "failed"):
                raise NAException(xo.sprintf())

           # Tag indicates if there are more records
            tag = xo.child_get_string("next-tag")

            # Break out of loop.  Tag of None indicates no more records
            if (tag == None):
                break

    ## Prints out list of clones with their corresponding parent volume and parent snapshot
    def clist(self):
        # Get first set number of records defined by mrecs
        mrecs = "100"
        api = NaElement("volume-clone-get-iter")
        api.child_add_string("max-records", mrecs)
        xo = self.get().invoke_elem(api)

        if(xo.results_status() == "failed"):
            raise NAException(xo.sprintf())

        # Set up to get next set of records
        tag = xo.child_get_string("next-tag")
        print("\n")
        
        # Need to go thru this loop at least once before checking for next tag
        while True:
            # Get list of snapshot-info attributes
            clonelist = dict()
            clonelist = xo.child_get("attributes-list")

            if (clonelist == None):
                break

            for clone in clonelist.children_get(): 
                print("clone: %s:%s:%s" % (clone.child_get_string("parent-volume"), clone.child_get_string("parent-snapshot"), clone.child_get_string("volume")))
                
            # Get next set of records
            api = NaElement("volume-clone-get-iter")
            api.child_add_string("max-records", mrecs)
            api.child_add_string("tag", tag)
            xo = self.get().invoke_elem(api)
            if(xo.results_status() == "failed"):
                raise NAException(xo.sprintf())

           # Tag indicates if there are more records
            tag = xo.child_get_string("next-tag")

            # Break if no more records
            if (tag == None):
                break


class NAException:
    def __init__(self, e):
        self.error = e
# ---------------------------------------------------------------------------



# ---------------------------------------------------------------------------
# Perforce connection as 'flex' user
# ---------------------------------------------------------------------------
class P4Flex:
    def __init__(self):
        self.port = config.get("p4.port")
        self.user = config.get("p4.user")
        self.passwd = config.get("p4.passwd")
        
    def getP4(self):
        p4 = P4()
        p4.user = self.user
        p4.port = self.port
        p4.connect()
        p4.password = self.passwd
        p4.run_login()
        return p4
# ---------------------------------------------------------------------------
   
       

# ---------------------------------------------------------------------------
# Parse the Broker's request and provide access to the user's environment
# ---------------------------------------------------------------------------
class Broker:
    def __init__(self):
        self.args = {}
        # Comment out stdin and uncomment block below for debug.
        lines = sys.stdin.readlines()
        # lines = []
        # with open("in.txt") as f:
        #    lines = f.readlines()

        for line in lines:
            parts = line.split(": ")
            self.args[parts[0]] = parts[1].rstrip()  
    
    def getP4(self):
        p4 = P4()
        p4.user = self.args['user']
        p4.port = self.args['clientPort']
        p4.client = self.args['workspace']
        p4.connect()
        return p4
            
    def getUser(self):
        return self.args['user']
    
    def getClient(self):
        return self.args['workspace']
    
    def getCommand(self):
        if 'Arg0' in self.args:
            return self.args['Arg0']
        else:
            return None
    
    def getOptions(self):
        c = 1
        opts = []
        while True:
            key = 'Arg' + str(c)
            c += 1
            if key in self.args:
                opts.append(self.args[key])
            else:
                break
               
        join = "" 
        list = []
        for opt in opts:
            if join:
                opt = join + opt
                join = ""
            if opt.startswith('-') and len(opt) == 2:
                join = opt
            else:
                list.append(opt)
        if join:
            list.append(opt)
        return list
# ---------------------------------------------------------------------------

     

# ---------------------------------------------------------------------------
# Handle Broker request and invoke the registered 'flex' command
# ---------------------------------------------------------------------------
class Flex:
    def __init__(self):
    
        # Process Broker arguments
        self.call = Broker()
        self.command = self.call.getCommand()
        self.args = self.call.args
        self.opts = self.call.getOptions()
   
        # Build table for function pointers     
        self.cmdFn = {
            'volume': self.volume,
            'volumes': self.volumes,
            'snapshot': self.snapshot,
            'snapshots': self.snapshots,
            'clone': self.clone,
            'clones': self.clones,
            'test': self.test,
            'help': self.help

            };
            
        # Call command
        if self.command in self.cmdFn:
            self.cmdFn[self.command]()
        else:
            self.usage()     
    
    
    def volume(self):
        # Get options (set defaults) 
        vname = ""
        size = "1G"
        for o in self.opts:
            if o.startswith('-d'):
                del_name = o[2:]
                self.vol_del(del_name)
                return
            if o.startswith('-s'):
                size = o[2:]
            else:
                vname = o
            
        if not vname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex volume name provided")
            return
        
        if not self.permission():
            print("action: REJECT")
            print("message: \"%s\"" % "You don't have permission for this operation.")
            return
        
        # NetApp connection
        netapp = NaFlex()
        
        # Create NetApp volume
        try:  
            netapp.create(vname, size)
            print("action: RESPOND")
            print("message: \"Created flex volume %s\"" % vname) 
                  
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)
              
    def volumes(self):
        # NetApp connection
        netapp = NaFlex()

        # List the volumes
        try:  
            list = ""
            vols = netapp.vlist()
            for v in vols:
                list += "volume "
                list += v.child_get_string("name") + " "
                list += v.child_get_string("name-ordinal") + " "
                list += v.child_get_string("owning-vserver-name") + " "
                list += "'" + v.child_get_string("comment")[:50] + "'"
                list += "\n"
                
            print("action: RESPOND")                  
            print("message: \"%s\"" % list)
            
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)

 
    # Builds a new FLEX_SNAP workspace to create the snapshot
    def snapshot(self):
        # Get options (set defaults)
        vname = ""
        sname = ""
        from_client_name = self.call.getClient()
        for o in self.opts:
            if o.startswith('-V'):
                vname = o[2:]
            if o.startswith('-c'):
                from_client_name = o[2:]
            else:
                sname = o
                
        if not vname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex volume name provided")
            return
        
        if not sname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex clone name provided")
            return
        
        if ':' in sname:
            print("action: REJECT")
            print("message: \"%s\"" % "Flex clone name must not use ':'")
            return     
        
        if not self.permission():
            print("action: REJECT")
            print("message: \"%s\"" % "You don't have permission for this operation.")
            return        
        
        # NetApp/Perforce connection as Flex
        netapp = NaFlex()
        p4 = P4Flex().getP4()
        
        # Create NetApp snapshot
        try:
            netapp.snapshot(vname, sname)
        
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)
              
        # Create Perforce workspace for snapshot
        try:  
            from_client = p4.fetch_client(from_client_name)
            root = from_client['Root']
            
            # Clone client workspace
            flex_client_name = FLEX_SNAP + vname + ':' + sname
            p4.client = flex_client_name
            flex_client = p4.fetch_client("-t", from_client_name, flex_client_name)
            
            # Mirror the same root
            flex_client['Root'] = root
            flex_client['Host'] = ""
            p4.save_client(flex_client)
            
            # Populate have list
            p4.run_sync("-k", "//" + flex_client_name + "/...@" + from_client_name)
            
            print("action: RESPOND")
            print("message: \"Created flex snapshot %s\"" % sname)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()

   
    def permission(self):
        try:
            # Perforce connection as Caller
            p4 = self.call.getP4()
            for p in p4.run_protects():
                if (p['perm'] == 'admin') or (p['perm'] == 'super'):
                    return True    
            return False
        
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()              


    def snapshots(self):
        try:  
            # Perforce connection as Caller
            p4 = self.call.getP4()
            snapshots = p4.run_clients("-e", FLEX_SNAP + "*")
            list = ""
            for v in snapshots:
                name = v['client'][len(FLEX_SNAP):]
                list += "snapshot " + name + " root " + v['Root'] + "\n"
            
            print("action: RESPOND")
            print("message: \"%s\"" % list)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()
   
   
    # Clones a new FLEX_CLONE workspace from the parent flexSnap_
    def clone(self):
        # Get options 
        vname = ""
        sname = ""
        cname = ""
        for o in self.opts:
            if o.startswith('-d'):
                del_name = o[2:]
                self.clone_del(del_name)
                return
            if o.startswith('-V'):
                vname = o[2:]
            if o.startswith('-P'):
                sname = o[2:]
            else:
                cname = o
        
        if not vname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex volume name provided")
            return
        
        if not sname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex snapshot name provided")
            return
        
        if not cname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex clone name provided")
            return
        
        if ':' in cname:
            print("action: REJECT")
            print("message: \"%s\"" % "Flex clone name must not use ':'")
            return  
        
        # NetApp/Perforce connection as Caller
        netapp = NaFlex()
        p4 = self.call.getP4()
        
        # Create NetApp clone from snapshot
        try:
            netapp.clone(cname, sname, vname)
        
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)
              
        try:  
            # Verify parent client exists
            parent_client_name = FLEX_SNAP + vname + ":" + sname
            list = p4.run_clients("-e", parent_client_name)
            if len(list) != 1:
                print("action: REJECT")
                print("message: \"Flex parent %s does not exist.\"" % parent_client_name)
                return
                            
            # Clone client workspace
            clone_client_name = FLEX_CLONE + cname
            p4.client = clone_client_name
            clone_client = p4.fetch_client("-t", parent_client_name, clone_client_name)
            p4.save_client(clone_client)
            
            # Set file ownership
            user = self.call.getUser()
            path = netapp.mount + "/" + cname
            self.chown(user, path)
                   
            # Populate have list
            p4.run_sync("-k", "//" + clone_client_name + "/...@" + parent_client_name)
            
            print("action: RESPOND")
            print("message: \"Created flex clone client %s\"" % clone_client_name)
        
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()

    
    def chown(self, user, path):
        uid = pwd.getpwnam(user).pw_uid
        gid = pwd.getpwnam(user).pw_gid
        
        # chown all files under the clone's mount point
        for root, dirs, files in os.walk(path):  
            for dir in dirs:  
                os.chown(os.path.join(root, dir), uid, gid)
            for file in files:
                os.chown(os.path.join(root, file), uid, gid)
        
        
    def clones(self):
        # Get options
        all = False 
        for o in self.opts:
            if o == "-a":
                all = True
        
        try:  
            # Perforce connection as Caller
            p4 = self.call.getP4()
            clones = []
            if all:
                clones = p4.run_clients("-e", FLEX_CLONE + "*")
            else:
                user = self.call.getUser()
                clones = p4.run_clients("-e", FLEX_CLONE + "*", "-u", user)
            
            list = ""
            for c in clones:
                name = c['client'][len(FLEX_CLONE):]
                list += "Clone " + name + " root " + c['Root'] + "\n"
            
            print("action: RESPOND")
            print("message: \"%s\"" % list)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()
            
            
    def clone_del(self, cname):               
        if not cname:
            print("action: REJECT")
            print("message: \"%s\"" % "No Flex clone name provided")
            return
        
        # NetApp/Perforce connection as Caller
        netapp = NaFlex()
        p4 = self.call.getP4()
        
        # Delete NetApp clone
        try:
            netapp.delete(cname)
        
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)
              
        # Delete Perforce workspace
        try:  
            client_name = FLEX_CLONE + cname
            p4.run_client("-d", client_name)
            
            print("action: RESPOND")
            print("message: \"Deleted Flex clone %s\"" % cname)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()
            
            
    def vol_del(self, vname):               
        if not vname:
            print("action: REJECT")
            print("message: \"%s\"" % "No flex volume name provided")
            return
        
        # NetApp/Perforce connection as Caller
        netapp = NaFlex()
        p4 = self.call.getP4()
        
        # Delete NetApp clone
        try:
            netapp.delete(vname)
        
        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)
            return
              
        # Delete Perforce workspaces
        try:
            clones = p4.run_clients("-e", FLEX_SNAP + vname + "*")
            
            list = ""
            for c in clones:
                client_name = c['client']
                p4.run_client("-d", client_name)
                list += "   deleted client: %s\n" % client_name
            
            print("action: RESPOND")
            message = "Deleted Flex volume %s\n" % vname
            message += list
            print("message: \"%s\"" % message)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()
    
    
    def help(self):
        help = (
            "(FlexClone)\n\n"
            "    flex -- Perforce FlexClone operations\n\n"
            "    p4 flex volume -s size[M, G] name\n"
            "    p4 flex volume -d name\n"
            "    p4 flex volumes \n\n"
            "    p4 flex snapshot -V volume [-c client] name\n"
            "    p4 flex snapshots \n\n"
            "    p4 flex clone -V volume -P parent name\n"
            "    p4 flex clone -d name\n"
            "    p4 flex clones [-P parent]\n"
            "        \n"
            "        'p4 flex volume' will create a new volume.\n"
            "        \n"
            "        'p4 flex volumes' will display a list of all volumes.\n"
            "        \n"
            "        'p4 flex snapshot' will create a new snapshot.\n"
            "        \n"
            "        'p4 flex snapshots' will display a list of all flex snapshots.\n"
            "        \n"
            "        'p4 flex clone' will create a new flex clone. The '-d' flag will\n"
            "        delete the flex clone and ascociated client.\n"
            "        \n"
            "        'p4 flex clones' will display a list of all flex clones owned by that\n"
            "        user. The '-a' flag will list all flex clones globally.\n"
        )
        print("action: RESPOND")
        print("message: \"%s\"" % help)
        
    def test(self):
        # Get a session connection to filer
        netapp = NaFlex()
        # Get options
        o = self.opts

        # Error if no arguments
        if not o:
            print("Need arguments")
            sys.exit (1)

        a = o[0]

        try: 
            # delete test
            if a.startswith('-d'):
                vname = a[2:]
                if (vname == ""):
                    print("Need to specify volume name")
                else:
                    netapp.delete(vname)                
            # create volume test
            elif a.startswith('-t'):
                vname = a[2:]
                if (vname == ""):
                    print("Need to specify volume name")
                else:
                    netapp.create(vname, "1G")
            # snapshot test
            elif a.startswith('-s'):
                if ((len(o) < 2)):
                    print("Need to specify a volume name and snapshot name")
                vname = a[2:]
                sname = o[1]
                if (vname == ""):
                    print("Need to specify volume name")
                else:
                    netapp.snapshot(vname, sname)
            # clone test
            elif a.startswith('-n'):
                if (len(o) < 3):
                    print("Need to specify a clone name, snapshot name, and volume name")
                cname = a[2:]
                sname = o[1]
                vname = o[2]
                netapp.clone(cname, sname, vname)
            # prints list of volumes
            elif a.startswith('-l'):
                netapp.vlist()
            # prints list of snapshots for specific volume specified
            elif a.startswith('-S'):
                vname = a[2:]
                if (vname == ""):
                    print("Need to specify volume name")
                else:
                    netapp.slist(vname)
            # prints all snapshots 
            elif a.startswith('-a'):
                netapp.slistall()
            # prints all the clones
            elif a.startswith('-c'):
                netapp.clist()
            else:
                print ("Error in test usage")

        except NAException as e:
            print("action: RESPOND")
            error = '\nNetApp Error: ' + e.error
            print("message: \"%s\"" % error)

        finally:
            sys.exit(0)

    def usage(self):
        usage = (
            "Usage: flex { volume(s) | snapshot(s) | clone(s) }\n"
            "Missing/wrong number of arguments."
        )
        print("action: RESPOND")
        print("message: \"%s\"" % usage)
# ---------------------------------------------------------------------------



# ---------------------------------------------------------------------------
# MAIN
# ---------------------------------------------------------------------------
if __name__ == '__main__':
    flex = Flex()