def __createApiClient(self): try: ''' Step1 : Create a CS Connection Object ''' mgmt_details = self.__mgmtDetails self.__csConnection = CSConnection(mgmt_details, self.__asyncTimeOut, self.__logger) ''' Step2 : Create API Client with earlier created connection object ''' self.__apiClient = CloudStackAPIClient(self.__csConnection) ''' Step3: If API Key is not provided as part of Management Details, then verify and register ''' if mgmt_details.apiKey is None: list_user = listUsers.listUsersCmd() list_user.account = "admin" list_user_res = self.__apiClient.listUsers(list_user) if list_user_res is None or\ (validateList(list_user_res)[0] != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED user_id = list_user_res[0].id api_key = list_user_res[0].apikey security_key = list_user_res[0].secretkey if api_key is None: ret = self.__getKeys(user_id) if ret != FAILED: mgmt_details.apiKey = ret[0] mgmt_details.securityKey = ret[1] else: self.__logger.error("__createApiClient: API Client " "Creation Failed while " "Registering User") return FAILED else: mgmt_details.port = 8080 mgmt_details.apiKey = api_key mgmt_details.securityKey = security_key ''' Now Create the Connection objects and Api Client using new details ''' self.__csConnection = CSConnection(mgmt_details, self.__asyncTimeOut, self.__logger) self.__apiClient = CloudStackAPIClient(self.__csConnection) return SUCCESS except Exception as e: self.__logger.exception(" Exception Occurred Under " "__createApiClient: %s" % GetDetailExceptionInfo(e)) return FAILED
def __createApiClient(self): try: ''' Step1 : Create a CS Connection Object ''' self.__csConnection = CSConnection(self.__mgmtDetails, self.__asyncTimeOut, self.__logger) ''' Step2 : Create API Client with earlier created connection object ''' self.__apiClient = CloudStackAPIClient(self.__csConnection) ''' Step3: If API Key is not provided as part of Management Details, then verify and register ''' if self.__mgmtDetails.apiKey is None: list_user = listUsers.listUsersCmd() list_user.account = "admin" list_user_res = self.__apiClient.listUsers(list_user) if list_user_res is None or\ (validateList(list_user_res)[0] != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED user_id = list_user_res[0].id api_key = list_user_res[0].apikey security_key = list_user_res[0].secretkey if api_key is None: ret = self.__getKeys(user_id) if ret != FAILED: self.__mgmtDetails.port = 8080 self.__mgmtDetails.apiKey = ret[0] self.__mgmtDetails.securityKey = ret[1] else: self.__logger.error("__createApiClient: API Client " "Creation Failed while " "Registering User") return FAILED else: self.__mgmtDetails.port = 8080 self.__mgmtDetails.apiKey = api_key self.__mgmtDetails.securityKey = security_key ''' Now Create the Connection objects and Api Client using new details ''' self.__csConnection = CSConnection(self.__mgmtDetails, self.__asyncTimeOut, self.__logger) self.__apiClient = CloudStackAPIClient(self.__csConnection) return SUCCESS except Exception as e: self.__logger.exception(" Exception Occurred Under " "__createApiClient: %s" % GetDetailExceptionInfo(e)) return FAILED
def __init__(self, l, options): self.options = options self.log = l utils = CSUtils() conn = utils.getConnection() self.apiclient = CloudStackAPIClient(conn) self.get_zone() self.vms = [] self.networks = [] self.vpcs = [] self.isolated = []
def __createUserApiClient(self, UserName, DomainName, acctType=0): ''' @Name : ___createUserApiClient @Desc : Creates a User API Client with given UserName\DomainName Parameters @Input: UserName: Username to be created in cloudstack DomainName: Domain under which the above account be created accType: Type of Account EX: Root,Non Root etc @Output: Return the API client for the user ''' try: if not self.isAdminContext(): return self.__apiClient mgmt_details = self.__mgmtDetails listDomain = listDomains.listDomainsCmd() listDomain.listall = True listDomain.name = DomainName try: domains = self.__apiClient.listDomains(listDomain) domId = domains[0].id except: cdomain = createDomain.createDomainCmd() cdomain.name = DomainName domain = self.__apiClient.createDomain(cdomain) domId = domain.id cmd = listAccounts.listAccountsCmd() cmd.name = UserName cmd.domainid = domId cmd.listall = True try: accounts = self.__apiClient.listAccounts(cmd) acctId = accounts[0].id except: createAcctCmd = createAccount.createAccountCmd() createAcctCmd.accounttype = acctType createAcctCmd.domainid = domId createAcctCmd.email = "test-" + random_gen()\ + "@cloudstack.org" createAcctCmd.firstname = UserName createAcctCmd.lastname = UserName createAcctCmd.password = '******' createAcctCmd.username = UserName acct = self.__apiClient.createAccount(createAcctCmd) acctId = acct.id listuser = listUsers.listUsersCmd() listuser.username = UserName listuser.domainid = domId listuser.listall = True listuserRes = self.__apiClient.listUsers(listuser) userId = listuserRes[0].id getuser_keys = getUserKeys.getUserKeysCmd() getuser_keys.id = listuserRes[0].id getuser_keys_res = self.__apiClient.getUserKeys(getuser_keys) if getuser_keys_res is None or\ (validateList(getuser_keys_res) != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") apiKey = getuser_keys_res.apikey securityKey = getuser_keys_res.secretkey if apiKey is None: ret = self.__getKeys(userId) if ret != FAILED: mgmt_details.apiKey = ret[0] mgmt_details.securityKey = ret[1] else: self.__logger.error("__createUserApiClient: " "User API Client Creation." " While Registering User Failed") return FAILED else: mgmt_details.port = 8080 mgmt_details.apiKey = apiKey mgmt_details.securityKey = securityKey newUserConnection =\ CSConnection(mgmt_details, self.__csConnection.asyncTimeout, self.__csConnection.logger) self.__userApiClient = CloudStackAPIClient(newUserConnection) self.__userApiClient.connection = newUserConnection self.__userApiClient.hypervisor = self.__hypervisor return self.__userApiClient except Exception as e: self.__logger.exception("Exception Occurred " "Under getUserApiClient : %s" % GetDetailExceptionInfo(e)) return FAILED
class CSTestClient(object): ''' @Desc : CloudStackTestClient is encapsulated entity for creating and getting various clients viz., apiclient, user api client, dbconnection, test Data parsed information etc @Input : mgmt_details : Management Server Details dbsvr_details: Database Server details of Management \ Server. Retrieved from configuration file. async_timeout : Timeout for Async queries default_worker_threads : Number of worker threads logger : provides logging facilities for this library zone : The zone on which test suites using this test client will run ''' def __init__(self, mgmt_details, dbsvr_details, async_timeout=3600, logger=None, test_data_filepath=None, zone=None, hypervisor_type=None): self.__mgmtDetails = mgmt_details self.__dbSvrDetails = dbsvr_details self.__csConnection = None self.__dbConnection = None self.__testClient = None self.__asyncTimeOut = async_timeout self.__logger = logger self.__apiClient = None self.__userApiClient = None self.__asyncJobMgr = None self.__id = None self.__hypervisor = hypervisor_type self.__testDataFilePath = test_data_filepath self.__parsedTestDataConfig = None self.__zone = zone self.__setHypervisorInfo() @property def identifier(self): return self.__id @identifier.setter def identifier(self, id): self.__id = id def getParsedTestDataConfig(self): ''' @Name : getParsedTestDataConfig @Desc : Provides the TestData Config needed for Tests are to Run @Output : Returns the Parsed Test Data Dictionary ''' return copy.deepcopy(self.__parsedTestDataConfig) def getZoneForTests(self): ''' @Name : getZoneForTests @Desc : Provides the Zone against which Tests are to run If zone name provided to marvin plugin is none it will get it from Test Data Config File Even, if it is not available, return None @Output : Returns the Zone Name ''' return self.__zone def getHypervisorInfo(self): ''' @Name : getHypervisorInfo @Desc : Provides the hypervisor Information to test users @Output : Return Hypervisor Information ''' return self.__hypervisor def __setHypervisorInfo(self): ''' @Name : __setHypervisorInfo @Desc: Set the HyperVisor details; default to XenServer ''' try: if not self.__hypervisor: self.__hypervisor = XEN_SERVER return SUCCESS except Exception as e: print("\n Exception Occurred Under __setHypervisorInfo " \ "%s" % GetDetailExceptionInfo(e)) return FAILED def __createApiClient(self): try: ''' Step1 : Create a CS Connection Object ''' mgmt_details = self.__mgmtDetails self.__csConnection = CSConnection(mgmt_details, self.__asyncTimeOut, self.__logger) ''' Step2 : Create API Client with earlier created connection object ''' self.__apiClient = CloudStackAPIClient(self.__csConnection) ''' Step3: If API Key is not provided as part of Management Details, then verify and register ''' if mgmt_details.apiKey is None: list_user = listUsers.listUsersCmd() list_user.account = "admin" list_user_res = self.__apiClient.listUsers(list_user) if list_user_res is None or\ (validateList(list_user_res)[0] != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED getuser_keys = getUserKeys.getUserKeysCmd() getuser_keys.id = list_user_res[0].id getuser_keys_res = self.__apiClient.getUserKeys(getuser_keys) if getuser_keys_res is None : self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED api_key = getuser_keys_res.apikey security_key = getuser_keys_res.secretkey user_id = list_user_res[0].id if api_key is None: ret = self.__getKeys(user_id) if ret != FAILED: mgmt_details.apiKey = ret[0] mgmt_details.securityKey = ret[1] else: self.__logger.error("__createApiClient: API Client " "Creation Failed while " "Registering User") return FAILED else: mgmt_details.port = 8080 mgmt_details.apiKey = api_key mgmt_details.securityKey = security_key ''' Now Create the Connection objects and Api Client using new details ''' self.__csConnection = CSConnection(mgmt_details, self.__asyncTimeOut, self.__logger) self.__apiClient = CloudStackAPIClient(self.__csConnection) return SUCCESS except Exception as e: self.__logger.exception(" Exception Occurred Under " "__createApiClient: %s" % GetDetailExceptionInfo(e)) return FAILED def __createDbConnection(self): ''' @Name : ___createDbConnection @Desc : Creates the CloudStack DB Connection ''' host = "localhost" if self.__dbSvrDetails.dbSvr is None \ else self.__dbSvrDetails.dbSvr port = 3306 if self.__dbSvrDetails.port is None \ else self.__dbSvrDetails.port user = "******" if self.__dbSvrDetails.user is None \ else self.__dbSvrDetails.user passwd = 'cloud' if self.__dbSvrDetails.passwd is None \ else self.__dbSvrDetails.passwd db = 'cloud' if self.__dbSvrDetails.db is None \ else self.__dbSvrDetails.db self.__dbConnection = DbConnection(host, port, user, passwd, db) def __getKeys(self, userid): ''' @Name : ___getKeys @Desc : Retrieves the API and Secret Key for the provided Userid @Input: userid: Userid to register @Output: FAILED or tuple with apikey and secretkey ''' try: register_user = registerUserKeys.registerUserKeysCmd() register_user.id = userid register_user_res = \ self.__apiClient.registerUserKeys(register_user) if not register_user_res: return FAILED getuser_keys = getUserKeys.getUserKeysCmd() getuser_keys.id = userid getuser_keys_res = self.__apiClient.getUserKeys(getuser_keys) if getuser_keys_res is None : self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED api_key = getuser_keys_res.apikey security_key = getuser_keys_res.secretkey return (api_key, security_key) except Exception as e: self.__logger.exception("Exception Occurred Under __geKeys : " "%s" % GetDetailExceptionInfo(e)) return FAILED def createTestClient(self): ''' @Name : createTestClient @Desc : Creates the Test Client. The test Client is used by test suites Here we create ParsedTestData Config. Creates a DB Connection. Creates an API Client @Output : FAILED In case of an issue\Failure SUCCESS in case of Success of this function ''' try: ''' 1. Create Config Object Provides the Configuration Object to test suites through getConfigParser. The purpose of this config object is to parse the default config and provide dictionary of the config so users can use that configuration. Users can later call getConfig on this object and it will return the default parsed config dictionary from default configuration file. They can overwrite it with providing their own configuration file as well. ''' ''' 1. Check Config,Zone,Hypervisor Information ''' self.__configObj = ConfigManager(self.__testDataFilePath) if not self.__configObj or not self.__hypervisor: self.__logger.error("createTestClient : " "Either Hypervisor is None or " "Not able to create " "ConfigManager Object") return FAILED self.__parsedTestDataConfig = self.__configObj.getConfig() self.__logger.debug("Parsing Test data successful") ''' 2. Create DB Connection ''' self.__createDbConnection() ''' 3. Creates API Client ''' ret = self.__createApiClient() if ret == FAILED: self.__logger.\ error("==== Test Client Creation Failed ====") else: self.__logger.\ debug("==== Test Client Creation Successful ====") return ret except Exception as e: self.__logger.exception("Exception Occurred " "Under createTestClient " ": %s" % GetDetailExceptionInfo(e)) return FAILED def isAdminContext(self): """ @Name : isAdminContext @Desc:A user is a regular user if he fails to listDomains; if he is a domain-admin, he can list only domains that are non-ROOT; if he is an admin, he can list the ROOT domain successfully """ try: listdom = listDomains.listDomainsCmd() listdom.name = 'ROOT' listdomres = self.__apiClient.listDomains(listdom) if listdomres != FAILED: rootdom = listdomres[0].name if rootdom == 'ROOT': return ADMIN else: return DOMAIN_ADMIN return USER except: return USER def __createUserApiClient(self, UserName, DomainName, acctType=0): ''' @Name : ___createUserApiClient @Desc : Creates a User API Client with given UserName\DomainName Parameters @Input: UserName: Username to be created in cloudstack DomainName: Domain under which the above account be created accType: Type of Account EX: Root,Non Root etc @Output: Return the API client for the user ''' try: if not self.isAdminContext(): return self.__apiClient mgmt_details = self.__mgmtDetails listDomain = listDomains.listDomainsCmd() listDomain.listall = True listDomain.name = DomainName try: domains = self.__apiClient.listDomains(listDomain) domId = domains[0].id except: cdomain = createDomain.createDomainCmd() cdomain.name = DomainName domain = self.__apiClient.createDomain(cdomain) domId = domain.id cmd = listAccounts.listAccountsCmd() cmd.name = UserName cmd.domainid = domId cmd.listall = True try: accounts = self.__apiClient.listAccounts(cmd) acctId = accounts[0].id except: createAcctCmd = createAccount.createAccountCmd() createAcctCmd.accounttype = acctType createAcctCmd.domainid = domId createAcctCmd.email = "test-" + random_gen()\ + "@cloudstack.org" createAcctCmd.firstname = UserName createAcctCmd.lastname = UserName createAcctCmd.password = '******' createAcctCmd.username = UserName acct = self.__apiClient.createAccount(createAcctCmd) acctId = acct.id listuser = listUsers.listUsersCmd() listuser.username = UserName listuser.domainid = domId listuser.listall = True listuserRes = self.__apiClient.listUsers(listuser) userId = listuserRes[0].id getuser_keys = getUserKeys.getUserKeysCmd() getuser_keys.id = listuserRes[0].id getuser_keys_res = self.__apiClient.getUserKeys(getuser_keys) if getuser_keys_res is None or\ (validateList(getuser_keys_res) != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") apiKey = getuser_keys_res.apikey securityKey = getuser_keys_res.secretkey if apiKey is None: ret = self.__getKeys(userId) if ret != FAILED: mgmt_details.apiKey = ret[0] mgmt_details.securityKey = ret[1] else: self.__logger.error("__createUserApiClient: " "User API Client Creation." " While Registering User Failed") return FAILED else: mgmt_details.port = 8080 mgmt_details.apiKey = apiKey mgmt_details.securityKey = securityKey newUserConnection =\ CSConnection(mgmt_details, self.__csConnection.asyncTimeout, self.__csConnection.logger) self.__userApiClient = CloudStackAPIClient(newUserConnection) self.__userApiClient.connection = newUserConnection self.__userApiClient.hypervisor = self.__hypervisor return self.__userApiClient except Exception as e: self.__logger.exception("Exception Occurred " "Under getUserApiClient : %s" % GetDetailExceptionInfo(e)) return FAILED def close(self): if self.__csConnection is not None: self.__csConnection.close() def getDbConnection(self): ''' @Name : getDbConnection @Desc : Retrieves the DB Connection Handle ''' return self.__dbConnection def getConfigParser(self): ''' @Name : getConfigParser @Desc : Provides the ConfigManager Interface to TestClients ''' return self.__configObj def getApiClient(self): if self.__apiClient: self.__apiClient.id = self.identifier return self.__apiClient return None def getUserApiClient(self, UserName=None, DomainName=None, type=0): """ @Name : getUserApiClient @Desc : Provides the User API Client to test Users 0 - user ; 1 - admin;2 - domain admin @OutPut : FAILED In case of an issue else User API Client """ if UserName is None or DomainName is None: return FAILED return self.__createUserApiClient(UserName, DomainName, type) def submitCmdsAndWait(self, cmds, workers=1, apiclient=None): ''' @Desc : FixME, httplib has issue if more than one thread submitted ''' if not apiclient: apiclient = self.__apiClient if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(apiclient, self.__dbConnection) return self.__asyncJobMgr.submitCmdsAndWait(cmds, workers) def submitJob(self, job, ntimes=1, nums_threads=10, interval=1): ''' @Desc : submit one job and execute the same job ntimes, with nums_threads of threads ''' if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(self.__apiClient, self.__dbConnection) self.__asyncJobMgr.submitJobExecuteNtimes(job, ntimes, nums_threads, interval) def submitJobs(self, jobs, nums_threads=10, interval=1): ''' @Desc :submit n jobs, execute them with nums_threads of threads ''' if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(self.__apiClient, self.__dbConnection) self.__asyncJobMgr.submitJobs(jobs, nums_threads, interval)
from marvin.configGenerator import ConfigManager from marvin.lib.utils import (random_gen, validateList) from CSUtils import * config = { 'management_server' : 'localhost', 'hypervisor_type' : 'XenServer', 'primarystorage' : 'mccdxpl2_primary' } utils = CSUtils() conn = utils.getConnection() apiclient = CloudStackAPIClient(conn) configuration = { 'cpu.overprovisioning.factor' : 10, 'mem.overprovisioning.factor' : 10, 'storage.overprovisioning.factor' : 4, 'expunge.delay' : 120, 'expunge.interval' : 60, 'network.gc.interval' : 60, 'network.gc.wait' : 120 } listconfig = listConfigurations.listConfigurationsCmd() try: resp = apiclient.listConfigurations(listconfig) for item in resp:
class CSTestClient(object): ''' @Desc : CloudStackTestClient is encapsulated entity for creating and getting various clients viz., apiclient, user api client, dbconnection, test Data parsed information etc @Input : mgmt_details : Management Server Details dbsvr_details: Database Server details of Management \ Server. Retrieved from configuration file. async_timeout : Timeout for Async queries default_worker_threads : Number of worker threads logger : provides logging facilities for this library zone : The zone on which test suites using this test client will run ''' def __init__(self, mgmt_details, dbsvr_details, async_timeout=3600, logger=None, test_data_filepath=None, zone=None, hypervisor_type=None): self.__mgmtDetails = mgmt_details self.__dbSvrDetails = dbsvr_details self.__csConnection = None self.__dbConnection = None self.__testClient = None self.__asyncTimeOut = async_timeout self.__logger = logger self.__apiClient = None self.__userApiClient = None self.__asyncJobMgr = None self.__id = None self.__hypervisor = hypervisor_type self.__testDataFilePath = test_data_filepath self.__parsedTestDataConfig = None self.__zone = zone self.__setHypervisorInfo() @property def identifier(self): return self.__id @identifier.setter def identifier(self, id): self.__id = id def getParsedTestDataConfig(self): ''' @Name : getParsedTestDataConfig @Desc : Provides the TestData Config needed for Tests are to Run @Output : Returns the Parsed Test Data Dictionary ''' return self.__parsedTestDataConfig def getZoneForTests(self): ''' @Name : getZoneForTests @Desc : Provides the Zone against which Tests are to run If zone name provided to marvin plugin is none it will get it from Test Data Config File Even, if it is not available, return None @Output : Returns the Zone Name ''' return self.__zone def getHypervisorInfo(self): ''' @Name : getHypervisorInfo @Desc : Provides the hypervisor Information to test users @Output : Return Hypervisor Information ''' return self.__hypervisor def __setHypervisorInfo(self): ''' @Name : __setHypervisorInfo @Desc: Set the HyperVisor details; default to XenServer ''' try: if not self.__hypervisor: self.__hypervisor = XEN_SERVER return SUCCESS except Exception as e: print "\n Exception Occurred Under __setHypervisorInfo " \ "%s" % GetDetailExceptionInfo(e) return FAILED def __createApiClient(self): try: ''' Step1 : Create a CS Connection Object ''' self.__csConnection = CSConnection(self.__mgmtDetails, self.__asyncTimeOut, self.__logger) ''' Step2 : Create API Client with earlier created connection object ''' self.__apiClient = CloudStackAPIClient(self.__csConnection) ''' Step3: If API Key is not provided as part of Management Details, then verify and register ''' if self.__mgmtDetails.apiKey is None: list_user = listUsers.listUsersCmd() list_user.account = "admin" list_user_res = self.__apiClient.listUsers(list_user) if list_user_res is None or\ (validateList(list_user_res)[0] != PASS): self.__logger.error("__createApiClient: API " "Client Creation Failed") return FAILED user_id = list_user_res[0].id api_key = list_user_res[0].apikey security_key = list_user_res[0].secretkey if api_key is None: ret = self.__getKeys(user_id) if ret != FAILED: self.__mgmtDetails.port = 8080 self.__mgmtDetails.apiKey = ret[0] self.__mgmtDetails.securityKey = ret[1] else: self.__logger.error("__createApiClient: API Client " "Creation Failed while " "Registering User") return FAILED else: self.__mgmtDetails.port = 8080 self.__mgmtDetails.apiKey = api_key self.__mgmtDetails.securityKey = security_key ''' Now Create the Connection objects and Api Client using new details ''' self.__csConnection = CSConnection(self.__mgmtDetails, self.__asyncTimeOut, self.__logger) self.__apiClient = CloudStackAPIClient(self.__csConnection) return SUCCESS except Exception as e: self.__logger.exception(" Exception Occurred Under " "__createApiClient: %s" % GetDetailExceptionInfo(e)) return FAILED def __createDbConnection(self): ''' @Name : ___createDbConnection @Desc : Creates the CloudStack DB Connection ''' host = "localhost" if self.__dbSvrDetails.dbSvr is None \ else self.__dbSvrDetails.dbSvr port = 3306 if self.__dbSvrDetails.port is None \ else self.__dbSvrDetails.port user = "******" if self.__dbSvrDetails.user is None \ else self.__dbSvrDetails.user passwd = 'cloud' if self.__dbSvrDetails.passd is None \ else self.__dbSvrDetails.passd db = 'cloud' if self.__dbSvrDetails.db is None \ else self.__dbSvrDetails.db self.__dbConnection = DbConnection(host, port, user, passwd, db) def __getKeys(self, userid): ''' @Name : ___getKeys @Desc : Retrieves the API and Secret Key for the provided Userid @Input: userid: Userid to register @Output: FAILED or tuple with apikey and secretkey ''' try: register_user = registerUserKeys.registerUserKeysCmd() register_user.id = userid register_user_res = \ self.__apiClient.registerUserKeys(register_user) if not register_user_res: return FAILED return (register_user_res.apikey, register_user_res.secretkey) except Exception as e: self.__logger.exception("Exception Occurred Under __geKeys : " "%s" % GetDetailExceptionInfo(e)) return FAILED def createTestClient(self): ''' @Name : createTestClient @Desc : Creates the Test Client. The test Client is used by test suites Here we create ParsedTestData Config. Creates a DB Connection. Creates an API Client @Output : FAILED In case of an issue\Failure SUCCESS in case of Success of this function ''' try: ''' 1. Create Config Object Provides the Configuration Object to test suites through getConfigParser. The purpose of this config object is to parse the default config and provide dictionary of the config so users can use that configuration. Users can later call getConfig on this object and it will return the default parsed config dictionary from default configuration file. They can overwrite it with providing their own configuration file as well. ''' ''' 1. Check Config,Zone,Hypervisor Information ''' self.__configObj = ConfigManager(self.__testDataFilePath) if not self.__configObj or not self.__hypervisor: self.__logger.error("createTestClient : " "Either Hypervisor is None or " "Not able to create " "ConfigManager Object") return FAILED self.__parsedTestDataConfig = self.__configObj.getConfig() self.__logger.debug("Parsing Test data successful") ''' 2. Create DB Connection ''' self.__createDbConnection() ''' 3. Creates API Client ''' ret = self.__createApiClient() if ret == FAILED: self.__logger.\ error("==== Test Client Creation Failed ====") else: self.__logger.\ debug("==== Test Client Creation Successful ====") return ret except Exception as e: self.__logger.exception("Exception Occurred " "Under createTestClient " ": %s" % GetDetailExceptionInfo(e)) return FAILED def isAdminContext(self): """ @Name : isAdminContext @Desc:A user is a regular user if he fails to listDomains; if he is a domain-admin, he can list only domains that are non-ROOT; if he is an admin, he can list the ROOT domain successfully """ try: listdom = listDomains.listDomainsCmd() listdom.name = 'ROOT' listdomres = self.__apiClient.listDomains(listdom) if listdomres != FAILED: rootdom = listdomres[0].name if rootdom == 'ROOT': return ADMIN else: return DOMAIN_ADMIN return USER except: return USER def __createUserApiClient(self, UserName, DomainName, acctType=0): ''' @Name : ___createUserApiClient @Desc : Creates a User API Client with given UserName\DomainName Parameters @Input: UserName: Username to be created in cloudstack DomainName: Domain under which the above account be created accType: Type of Account EX: Root,Non Root etc @Output: Return the API client for the user ''' try: if not self.isAdminContext(): return self.__apiClient listDomain = listDomains.listDomainsCmd() listDomain.listall = True listDomain.name = DomainName try: domains = self.__apiClient.listDomains(listDomain) domId = domains[0].id except: cdomain = createDomain.createDomainCmd() cdomain.name = DomainName domain = self.__apiClient.createDomain(cdomain) domId = domain.id cmd = listAccounts.listAccountsCmd() cmd.name = UserName cmd.domainid = domId try: accounts = self.__apiClient.listAccounts(cmd) acctId = accounts[0].id except: createAcctCmd = createAccount.createAccountCmd() createAcctCmd.accounttype = acctType createAcctCmd.domainid = domId createAcctCmd.email = "test-" + random_gen()\ + "@cloudstack.org" createAcctCmd.firstname = UserName createAcctCmd.lastname = UserName createAcctCmd.password = '******' createAcctCmd.username = UserName acct = self.__apiClient.createAccount(createAcctCmd) acctId = acct.id listuser = listUsers.listUsersCmd() listuser.username = UserName listuserRes = self.__apiClient.listUsers(listuser) userId = listuserRes[0].id apiKey = listuserRes[0].apikey securityKey = listuserRes[0].secretkey if apiKey is None: ret = self.__getKeys(userId) if ret != FAILED: mgtDetails = self.__mgmtDetails mgtDetails.apiKey = ret[0] mgtDetails.securityKey = ret[1] else: self.__logger.error("__createUserApiClient: " "User API Client Creation." " While Registering User Failed") return FAILED else: mgtDetails = self.__mgmtDetails mgtDetails.apiKey = apiKey mgtDetails.securityKey = securityKey newUserConnection =\ CSConnection(mgtDetails, self.__csConnection.asyncTimeout, self.__csConnection.logger) self.__userApiClient = CloudStackAPIClient(newUserConnection) self.__userApiClient.connection = newUserConnection self.__userApiClient.hypervisor = self.__hypervisor return self.__userApiClient except Exception as e: self.__logger.exception("Exception Occurred " "Under getUserApiClient : %s" % GetDetailExceptionInfo(e)) return FAILED def close(self): if self.__csConnection is not None: self.__csConnection.close() def getDbConnection(self): ''' @Name : getDbConnection @Desc : Retrieves the DB Connection Handle ''' return self.__dbConnection def getConfigParser(self): ''' @Name : getConfigParser @Desc : Provides the ConfigManager Interface to TestClients ''' return self.__configObj def getApiClient(self): if self.__apiClient: self.__apiClient.id = self.identifier return self.__apiClient return None def getUserApiClient(self, UserName=None, DomainName=None, type=0): """ @Name : getUserApiClient @Desc : Provides the User API Client to test Users 0 - user ; 1 - admin;2 - domain admin @OutPut : FAILED In case of an issue else User API Client """ if UserName is None or DomainName is None: return FAILED return self.__createUserApiClient(UserName, DomainName, type) def submitCmdsAndWait(self, cmds, workers=1): ''' @Desc : FixME, httplib has issue if more than one thread submitted ''' if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(self.__apiClient, self.__dbConnection) return self.__asyncJobMgr.submitCmdsAndWait(cmds, workers) def submitJob(self, job, ntimes=1, nums_threads=10, interval=1): ''' @Desc : submit one job and execute the same job ntimes, with nums_threads of threads ''' if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(self.__apiClient, self.__dbConnection) self.__asyncJobMgr.submitJobExecuteNtimes(job, ntimes, nums_threads, interval) def submitJobs(self, jobs, nums_threads=10, interval=1): ''' @Desc :submit n jobs, execute them with nums_threads of threads ''' if self.__asyncJobMgr is None: self.__asyncJobMgr = asyncJobMgr(self.__apiClient, self.__dbConnection) self.__asyncJobMgr.submitJobs(jobs, nums_threads, interval)
from marvin.cloudstackException import GetDetailExceptionInfo from marvin.cloudstackConnection import CSConnection from marvin.configGenerator import ConfigManager from marvin.lib.utils import (random_gen, validateList) from CSUtils import * config = { 'management_server': 'localhost', 'hypervisor_type': 'XenServer', 'primarystorage': '192.168.56.5' } utils = CSUtils() conn = utils.getConnection() apiclient = CloudStackAPIClient(conn) configuration = { 'cpu.overprovisioning.factor': 10, 'mem.overprovisioning.factor': 10, 'storage.overprovisioning.factor': 4, 'expunge.delay': 120, 'expunge.interval': 60, 'network.gc.interval': 60, 'network.gc.wait': 120 } listconfig = listConfigurations.listConfigurationsCmd() try: resp = apiclient.listConfigurations(listconfig) for item in resp:
class RedVPCRouter(): templateName = "tiny Linux" hypervisor = "XenServer" serviceOffering = "tinyOffering" def __init__(self, l, options): self.options = options self.log = l utils = CSUtils() conn = utils.getConnection() self.apiclient = CloudStackAPIClient(conn) self.get_zone() self.vms = [] self.networks = [] self.vpcs = [] self.isolated = [] def add_comm(self, comm): self.comm = comm def get_zone(self): self.log.ptest("Getting Zone info") cmd = listZones.listZonesCmd() ret = self.apiclient.listZones(cmd) if ret is None: self.log.extra("No zones") self.log.failure() for zone in ret: self.zone = zone self.log.success() def list_routers(self, rid='', is_vpc=IS_VPC): self.log.ptest("Finding routers") cmd = listRouters.listRoutersCmd() ret = self.apiclient.listRouters(cmd) rtrs = [] if ret is None: self.log.extra("No routers found it has gone really wrong") self.log.failure() for router in ret: if is_vpc: if router.vpcid == rid: rtrs.append(router) else: if router.networkdomain == rid: rtrs.append(router) self.log.success() return rtrs def set_vpc_offerings(self, name): self.log.ptest("Getting VPC service offering") cmd = listVPCOfferings.listVPCOfferingsCmd() ret = self.apiclient.listVPCOfferings(cmd) self.vpc_off = None for off in ret: if off.displaytext == name: self.vpc_off = off if self.vpc_off is None: self.log.extra("No VPC offering found with name %s" % name) self.log.failure() self.log.success() def list_network_offerings(self, name): cmd = listNetworkOfferings.listNetworkOfferingsCmd() ret = self.apiclient.listNetworkOfferings(cmd) for off in ret: if off.name == name: return off return None def set_isolated_offerings(self, name): self.log.ptest("Getting Isolated service offering") cmd = listNetworkOfferings.listNetworkOfferingsCmd() ret = self.apiclient.listNetworkOfferings(cmd) self.isolated_off = None for off in ret: if off.name == name: self.isolated_off = off if self.isolated_off is None: self.log.extra("No Isolated offering found with name %s" % name) self.log.failure() self.log.success() def list_templates(self, name): cmd = listTemplates.listTemplatesCmd() cmd.templatefilter = "all" cmd.name = name cmd.listAll = True cmd.zone = self.zone.id return self.apiclient.listTemplates(cmd) def list_instances(self): cmd = listVirtualMachines.listVirtualMachinesCmd() return self.apiclient.listVirtualMachines(cmd) def instance_exists(self, name): vms = self.list_instances() if vms is None: return False for vm in vms: if vm.name == name: return vm.id return False def getServiceOffering(self, name): cmd = listServiceOfferings.listServiceOfferingsCmd() ret = self.apiclient.listServiceOfferings(cmd) for t in ret: if t.name.startswith(name): return t.id return False def list_vpc(self): cmd = listVPCs.listVPCsCmd() ret = self.apiclient.listVPCs(cmd) return ret def vpc_exists(self, name): vpcs = self.list_vpc() if vpcs is None: return False for vpc in vpcs: if vpc.name == name: return vpc return False def get_network(self, name): nets = self.list_networks() if nets is None: return None for net in nets: if net.name == name: return net return None def list_networks(self): cmd = listNetworks.listNetworksCmd() ret = self.apiclient.listNetworks(cmd) if ret is None: return None return ret def list_ips(self, net): self.ips = [] cmd = listPublicIpAddresses.listPublicIpAddressesCmd() cmd.listAll = True ret = self.apiclient.listPublicIpAddresses(cmd) self.log.ptest("Getting public ips for network %s" % net) for ip in ret: if hasattr(ip, "associatednetworkname") and ip.associatednetworkname == net: self.ips.append(ip) if len(self.ips) > 0: self.log.success() else: self.log.extra("No public IP") self.log.failure() def get_acl(self, traffictype, action): cmd = listNetworkACLs.listNetworkACLsCmd() ret = self.apiclient.listNetworkACLs(cmd) if ret is None: self.log.extra("No Network ACLS found") self.log.failure() for acl in ret: if acl.traffictype == traffictype and acl.action == action: return acl def create_network(self, vpc, name, gateway, netmask): self.log.ptest("Creating network %s (%s)" % (name, gateway)) vid = self.vpc_exists(vpc).id netname = "%s-%s" % (vpc, name) if not vid: self.log.extra("No vpc called %s" % vpc) self.log.failure(True) n = self.get_network(netname) if n is not None: self.log.extra("Network %s already exists" % netname) self.networks.append(n.id) self.log.success() return n cmd = createNetwork.createNetworkCmd() cmd.zoneid = self.zone.id cmd.name = netname cmd.displaytext = netname cmd.gateway = gateway cmd.netmask = netmask cmd.vpcid = vid cmd.aclid = self.get_acl("Egress", "Allow").aclid cmd.networkofferingid = self.list_network_offerings("DefaultIsolatedNetworkOfferingForVpcNetworks").id ret = self.apiclient.createNetwork(cmd) self.networks.append(ret.id) time.sleep(20) self.log.success() return ret def create_isolated_network(self, name, gw, mask): self.log.ptest("Creating Isolated Network %s (%s/%s)" % (name, gw, mask)) cmd = listNetworks.listNetworksCmd() networks = self.apiclient.listNetworks(cmd) if networks is not None: for net in networks: if net.name == name: self.networks.append(net.id) self.log.extra("Exists") self.log.success() return cmd = createNetwork.createNetworkCmd() cmd.zoneid = self.zone.id cmd.name = name cmd.displaytext = name cmd.networkofferingid = self.isolated_off.id cmd.gateway = gw cmd.netmask = mask cmd.networkdomain = "%s.local" % name ret = self.apiclient.createNetwork(cmd) self.networks.append(ret.id) self.log.success() return ret.id def create_vpc(self, name, cidr): self.log.ptest("Creating Redundant VPC %s (%s)" % (name, cidr)) vpc = self.vpc_exists(name) if vpc: self.log.extra("Already exists") self.log.success() self.vpcs.append(vpc.id) return vpc.id cmd = createVPC.createVPCCmd() cmd.name = name cmd.displaytext = name cmd.vpcofferingid = self.vpc_off.id cmd.zoneid = self.zone.id cmd.cidr = cidr # cmd.account = account # cmd.domainid = domainid # cmd.networkDomain = networkDomain ret = self.apiclient.createVPC(cmd) self.vpcs.append(ret.id) self.log.success() return ret.id def list_acls(self, name): cmd = listNetworkACLLists.listNetworkACLListsCmd() ret = self.apiclient.listNetworkACLLists(cmd) for acl in ret: if acl.name == name: return acl return None def create_acl_list(self, name, vid): self.log.ptest("Creating acl list %s" % name) acl = self.list_acls(name) if acl is None: cmd = createNetworkACLList.createNetworkACLListCmd() cmd.vpcid = vid cmd.name = name cmd.description = name acl = self.apiclient.createNetworkACLList(cmd) self.log.success() else: self.log.extra("exists") self.log.skipped() return acl def add_acl_rule(self, number, acl, port, direction): self.log.ptest("Adding %s rule for port %s" % (direction, port)) cmd = listNetworkACLs.listNetworkACLsCmd() cmd.aclid = acl.id ret = self.apiclient.listNetworkACLs(cmd) if ret is not None: for rule in ret: if rule.number == number: self.log.extra("Exists") self.log.skipped() return cmd = createNetworkACL.createNetworkACLCmd() cmd.aclid = acl.id cmd.startport = port cmd.endport = port cmd.cidrlist = '' cmd.number = number cmd.traffictype = direction cmd.protocol = 'tcp' self.apiclient.createNetworkACL(cmd) self.log.success() def replace_acl(self, acl, net): self.log.ptest("Setting acl on %s to %s" % (net.name, acl.name)) cmd = replaceNetworkACLList.replaceNetworkACLListCmd() cmd.networkid = net.id cmd.aclid = acl.id self.apiclient.replaceNetworkACLList(cmd) self.log.success() def create_instance(self, name, network): self.log.ptest("Creating virtual machine %s in %s" % (name, network)) v = self.instance_exists(name) if v: self.vms.append(v) self.log.extra("Already exists") self.log.success() return cmd = deployVirtualMachine.deployVirtualMachineCmd() cmd.name = name cmd.displayname = name cmd.zoneid = self.zone.id so = self.getServiceOffering(self.serviceOffering) if so is False: self.log.extra("Cannot find service Offering %s]" % self.serviceOffering) self.log.failure() cmd.serviceofferingid = so temp = self.list_templates(self.templateName) if temp is None: self.log.extra("Cannot find template %s" % self.templateName) self.log.failure() neto = self.get_network(network) if neto is None: self.log.extra("Cannot find network %s" % network) self.log.failure() cmd.networkids.append(neto.id) cmd.templateid = temp[0].id cmd.hypervisor = self.hypervisor ret = self.apiclient.deployVirtualMachine(cmd) self.vms.append(ret.id) time.sleep(20) self.log.success() def instances_in_network(self, name): instances = [] self.log.ptest("Getting virtual machines in %s" % name) for inst in self.list_instances(): for nic in inst.nic: if nic.networkname.startswith(name): instances.append(inst) self.log.extra("[Found %s]" % len(instances)) self.log.success() return instances def destroy_instance(self, id): if self.options.no_destroy: return self.log.ptest("Destroy virtual machine %s" % (id)) cmd = destroyVirtualMachine.destroyVirtualMachineCmd() cmd.id = id cmd.expunge = True self.apiclient.destroyVirtualMachine(cmd) time.sleep(20) self.log.success() def destroy_network(self, id): if self.options.no_destroy: return self.log.ptest("Destroy network %s" % (id)) cmd = deleteNetwork.deleteNetworkCmd() cmd.id = id cmd.expunge = True self.apiclient.deleteNetwork(cmd) time.sleep(20) self.log.success() def destroy_vpc(self, id): if self.options.no_destroy: return self.log.ptest("Detroying VPC %s" % id) cmd = deleteVPC.deleteVPCCmd() cmd.id = id ret = self.apiclient.deleteVPC(cmd) time.sleep(20) self.log.success() def destroy_all_vpcs(self): for id in self.vpcs: self.destroy_vpc(id) def destroy_all(self): for id in self.vms: self.destroy_instance(id) for id in self.networks: self.destroy_network(id) self.vms = [] self.networks = [] def list_firewall_rules(self, index, sport, eport): cmd = listFirewallRules.listFirewallRulesCmd() ret = self.apiclient.listFirewallRules(cmd) if ret is None: return ret for rule in ret: if rule.startport == str(sport) and rule.endport == str(eport) and self.ips[index].id == rule.ipaddressid: return rule return None def delete_firewall_rule(self, index, sport, eport): self.log.ptest("Deleting Firewall rule %s %s %s" % (self.ips[index].ipaddress, sport, eport)) self.comm.update_firewall(self.ips[index].ipaddress, sport, eport, False) rule = self.list_firewall_rules(index, sport, eport) if rule is None: self.log.extra("Not There") self.log.success() return cmd = deleteFirewallRule.deleteFirewallRuleCmd() cmd.id = rule.id self.apiclient.deleteFirewallRule(cmd) self.log.success() def add_firewall_rule(self, index, sport, eport): self.log.ptest("Adding Firewall rule %s %s %s" % (self.ips[index].ipaddress, sport, eport)) self.comm.update_firewall(self.ips[index].ipaddress, sport, eport, True) if self.list_firewall_rules(index, sport, eport) is not None: self.log.extra("Exists") self.log.success() return cmd = createFirewallRule.createFirewallRuleCmd() cmd.cidrlist = "0.0.0.0/0" cmd.protocol = "tcp" cmd.startport = sport cmd.endport = eport cmd.ipaddressid = self.ips[index].id self.apiclient.createFirewallRule(cmd) self.log.success() def enable_offering(self, off): self.log.ptest("Enabling network offering %s" % off.name) if off.state == "Enabled": self.log.extra("Already Enabled") self.log.success() return cmd = updateNetworkOffering.updateNetworkOfferingCmd() cmd.id = off.id cmd.state = "Enabled" self.apiclient.updateNetworkOffering(cmd) self.log.success() def add_redundant_service_offering(self, name="isored1"): self.log.ptest("Adding redundant isolated network offering (%s)" % name) off = self.list_network_offerings(name) if off is not None: self.log.extra("Exists") self.log.success() self.enable_offering(off) return off cmd = createNetworkOffering.createNetworkOfferingCmd() cmd.name = name cmd.displaytext = name cmd.ispersistent = "true" cmd.guestiptype = "Isolated" cmd.supportedservices = "Vpn,Dhcp,Dns,Firewall,Lb,SourceNat,StaticNat,PortForwarding" cmd.servicecapabilitylist = [] cmd.servicecapabilitylist.append({ "service": "SourceNat", "capabilitytype": "RedundantRouter", "capabilityvalue": "true" }) cmd.servicecapabilitylist.append({ "service": "SourceNat", "capabilitytype": "SupportedSourceNatTypes", "capabilityvalue": "peraccount" }) cmd.servicecapabilitylist.append({ "service": "lb", "capabilitytype": "SupportedLbIsolation", "capabilityvalue": "dedicated" }) cmd.serviceproviderlist = [] cmd.serviceproviderlist.append({"service": "Vpn", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "Dhcp", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "Dns", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "Firewall", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "Lb", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "SourceNat", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "StaticNat", "provider": "VirtualRouter"}) cmd.serviceproviderlist.append({"service": "PortForwarding", "provider": "VirtualRouter"}) cmd.traffictype = "GUEST" off = self.apiclient.createNetworkOffering(cmd) self.log.success() self.enable_offering(off) return off
from marvin.cloudstackAPI import * from marvin.cloudstackAPI.cloudstackAPIClient import CloudStackAPIClient from marvin.cloudstackException import CloudstackAPIException from marvin.cloudstackException import GetDetailExceptionInfo from marvin.cloudstackConnection import CSConnection from marvin.configGenerator import ConfigManager from marvin.lib.utils import (random_gen, validateList) from CSUtils import * import json import time import sys utils = CSUtils() conn = utils.getConnection() apiclient = CloudStackAPIClient(conn) # Query Zone lz = listZones.listZonesCmd() lz.available = True resp = apiclient.listZones(lz) zone = resp[0] # Create Network lno = listNetworkOfferings.listNetworkOfferingsCmd() lno.name="DefaultIsolatedNetworkOfferingWithSourceNatService" resp = apiclient.listNetworkOfferings(lno) offering = resp[0] cn = createNetwork.createNetworkCmd()
from marvin.cloudstackAPI import * from marvin.cloudstackAPI.cloudstackAPIClient import CloudStackAPIClient from marvin.cloudstackException import CloudstackAPIException from marvin.cloudstackException import GetDetailExceptionInfo from marvin.cloudstackConnection import CSConnection from marvin.configGenerator import ConfigManager from marvin.lib.utils import (random_gen, validateList) from CSUtils import * import json import time import sys utils = CSUtils() conn = utils.getConnection() apiclient = CloudStackAPIClient(conn) listsvm = listSystemVms.listSystemVmsCmd() count = 40 while count > 0: # Sleep 15 seconds time.sleep(15) count = count - 1 ssvm = None # Check if we have an ssvm print "Looking for systemvm of type secondarystoragevm" try: resp = apiclient.listSystemVms(listsvm) if resp == None or len(resp) == 0: