flex.py #9

#!/usr/bin/env python

import sys
import os
from P4 import P4, P4Exception

import sys
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")


    def get(self):
        s = NaServer(self.server, 1 , 30)
        s.set_server_type("FILER")
        s.set_transport_type("HTTPS")
        s.set_port(self.port)
        s.set_style("LOGIN")
        s.set_admin_user(self.user, self.passwd)
        s.set_vserver(self.vserver)
	return s

    def create(self, name, size):
	api = NaElement("volume-create")
        api.child_add_string("containing-aggr-name","p4")
        api.child_add_string("size", size)
        api.child_add_string("volume", name)

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

        if (xo.results_status() == "failed") :
            print ("Error:\n")
            print (xo.sprintf())
            sys.exit(1)

## ---------------------------------------------------------------------------



## ---------------------------------------------------------------------------
## 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 = {
            '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()     
    
    # Builds a new FLEX_SNAP workspace to create the snapshot
    def snapshot(self):
        # Get options (set defaults) 
        flex = ""
        from_client_name = self.call.getClient()
        for o in self.opts:
            if o.startswith('-c'):
                from_client_name = o[2:]
            else:
                flex = o
        if not flex:
            print("action: REJECT")
            print("message: \"%s\"" % "No Flex clone name provided")
            return
        
        if not self.permission():
            print("action: REJECT")
            print("message: \"%s\"" % "You don't have permission for this operation.")
            return        
        
        try:  
            # Perforce connection as Flex
            p4 = P4Flex().getP4()
            from_client = p4.fetch_client(from_client_name)
            root = from_client['Root']
            
            # Clone client workspace
            flex_client_name = FLEX_SNAP + flex
            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)
            
            # Create parent snapshot
            netapp = NaFlex()
            netapp.create(flex, "1G")
                        
            print("action: RESPOND")
            print("message: \"%s\"" % netapp)
            
        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 
        clone = ""
        parent_name = ""
        for o in self.opts:
            if o.startswith('-d'):
                del_name = o[2:]
                self.clone_del(del_name)
                return
            if o.startswith('-P'):
                parent_name = o[2:]
            else:
                clone = o
               
        if not clone:
            print("action: REJECT")
            print("message: \"%s\"" % "No Flex clone name provided")
            return
         
        if not parent_name:
            print("action: REJECT")
            print("message: \"%s\"" % "No Flex parent name provided")
            return
        
        try:  
            # Perforce connection as Caller
            p4 = self.call.getP4()
            
            # Verify parent client exists
            parent_client_name = FLEX_SNAP + parent_name
            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 + clone
            p4.client = clone_client_name
            clone_client = p4.fetch_client("-t", parent_client_name, clone_client_name)
            p4.save_client(clone_client)
            
            # Create flex clone
            netapp = ("vol clone create -vserver perforce -flexclone %s -snapshot %s\n"
                      "vol mount -vserver perforce -snapshot %s\n" 
                      % (clone, parent_name, parent_name))
            
            # Populate have list
            p4.run_sync("-k", "//" + clone_client_name + "/...@" + parent_client_name)
            
            print("action: RESPOND")
            print("message: \"%s\"" % netapp)
            
        except P4Exception:
            print("action: RESPOND")
            error = '\n'.join(p4.errors)
            error += '\n'.join(p4.warnings)
            print("message: \"%s\"" % error)
            
        finally:
            p4.disconnect()
            
        print("action: RESPOND")
        print("message: \"%s\"" % self.args)     
    
    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, clone):               
        if not clone:
            print("action: REJECT")
            print("message: \"%s\"" % "No Flex clone name provided")
            return
        
        try:  
            # Perforce connection as Caller
            p4 = self.call.getP4()
            client_name = FLEX_CLONE + clone
            p4.run_client("-d", client_name)
            
            print("action: RESPOND")
            print("message: \"Deleted Flex clone %s\"" % clone)
            
        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 snapshot [-c client] name\n"
            "    p4 flex snapshots \n"
            "    p4 flex clone -P parent name\n"
            "    p4 flex clone -d name\n"
            "    p4 flex clones [-P parent]\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):
        # Create parent snapshot
        netapp = NaFlex()
        netapp.create("del2", "1G")
        print("action: RESPOND")
        print("message: \"test done\"")

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



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