diff options
Diffstat (limited to 'libs/globals')
-rw-r--r-- | libs/globals/atfglobals.py | 85 | ||||
-rw-r--r-- | libs/globals/logger.py | 211 | ||||
-rwxr-xr-x | libs/globals/manager.py | 64 | ||||
-rwxr-xr-x | libs/globals/testenv.py | 462 | ||||
-rw-r--r-- | libs/globals/testruninfo.py | 144 |
5 files changed, 966 insertions, 0 deletions
diff --git a/libs/globals/atfglobals.py b/libs/globals/atfglobals.py new file mode 100644 index 0000000..ff1faad --- /dev/null +++ b/libs/globals/atfglobals.py @@ -0,0 +1,85 @@ +"""atfglobals module contain AtfGlobal class and GlobalObj + +AtfGlobals class wrapps all global objects used in the framework +*) TestrunInfo +*) Logger +*) Testenv +*) ConnectionsManager + +GlobalObj is 'The Instance' of AtfGlobals which will be referred throughout +the framework utilities. +""" + +import testruninfo +import logger +import testenv +import manager + +class AtfGlobals: + + + def __init__(self): + self._testruninfo = None + self._logger = logger.Log() + self._env = None + self._connectionsmanager = manager.ConnectionsManager() + + def getTestrunInfoObj(self): + """Returns TestrunInfo Object + """ + return self._testruninfo + + def getLoggerObj(self): + """Returns Logger Object + """ + return self._logger + + def getTestenvObj(self): + """Returns Current TestEnvironment Object. + """ + return self._env + + def getConnectionsManagerObj(self): + """Returns ConnectionsManager Object + """ + return self._connectionsmanager + + def initTestrunInfoObj(self): + """Instantiation of TestrunInfo Object + """ + self._testruninfo = testruninfo.TestRunInfo() + + def initLoggerObj(self): + """Instantiation of Logger Object + """ + self._logger = logger.Log() + + def initTestenvObj(self): + """Instantiation of Testenv Object + """ + self._env = testenv.TestEnv() + + def initConnectionsManagerObj(self): + """Instantiation of ConnectionsManager Object + """ + self._connectionsmanager = manager.ConnectionsManager() + +GlobalObj = AtfGlobals() +__all__ = ['GlobalObj'] + + + + + + + + + + + + + + + + + diff --git a/libs/globals/logger.py b/libs/globals/logger.py new file mode 100644 index 0000000..9d11bd7 --- /dev/null +++ b/libs/globals/logger.py @@ -0,0 +1,211 @@ +""" + logger class contains variables and methods for Logging + the events during the test run. + + Variables: + SummaryLog: [filename, loglevel, format] + + DetailLog: [filename, loglevel, format] + + StdoutLog: [loglevel, format] + +""" +import logging + +class Log(): + + def __init__(self): + self._summarylog = {'format': + '%(asctime)s %(levelname)s : %(filename)s %(lineno)d - \ + \'%(message)s\''} + self._detaillog = {'format': + '%(asctime)s %(levelname)s : %(pathname)s %(funcName)s \ + %(lineno)d - \'%(message)s\''} + self._stdoutlog = {'logstatus':'false', 'format':'%(asctime)s \ + %(levelname)s : %(filename)s %(lineno)d - \'%(message)s\''} + self._loggers = [] + + + def getLogLevel(self, loglevel): + """ + Description: + Returns logging.(LogLevel) for loglevel + + Parameters: + loglevel: String specifying the loglevel + + Returns: + logging.(Loglevel) + """ + + LEVELS = {'DEBUG': logging.DEBUG, + 'INFO': logging.INFO, + 'WARNING': logging.WARNING, + 'ERROR': logging.ERROR, + 'CRITICAL': logging.CRITICAL, + 'debug': logging.DEBUG, + 'info': logging.INFO, + 'warning': logging.WARNING, + 'error': logging.ERROR, + 'critical': logging.CRITICAL} + return LEVELS.get(loglevel, logging.NOTSET) + + def setSummaryLog(self, filename='SummaryLog.out', loglevel='INFO'): + """ + Description: + Set Summary Log Name and Log Level + + Parameters: + filename: SummaryLog File Name + loglevel : Log level to be set for summary log + """ + + self._summarylog['filename'] = filename + self._summarylog['loglevel'] = self.getLogLevel(loglevel) + + def setDetailLog(self, filename='DetailLog.out', loglevel = 'DEBUG'): + """ + Description: + Set Detail Log Name and Log Level + + Parameters: + filename: DetailLog FIle name + loglevel: Log level to be set for detail log + """ + + self._detaillog['filename'] = filename + self._detaillog['loglevel'] = self.getLogLevel(loglevel) + + def setStdoutLog(self, do_log=True, loglevel='INFO'): + """ + Description: + Set Log Level for logging to STDOUT + + Parameters: + loglevel: Log level for logging to STDOUT + """ + self._stdoutlog['do_log'] = do_log + self._stdoutlog['loglevel'] = self.getLogLevel(loglevel) + + def createLogger(self, atfdir, logname='ATFLOG'): + """ + Description: + Create a Logger with LogName 'logname' + + Parameters: + logname: Name of the Logger + + Return: + Success: 0 (Successful creation of logger with name : 'logname') + Failure: 1 (Unable to create logger with name: logname) + """ + + # Create a Logger Object with name "logname". + # Set the log level to 'DEBUG' + logger = logging.getLogger(logname) + logger.setLevel(logging.DEBUG) + self.loggers.append({'logname': logname}) + + # Create Summary Log File Handler + # Set the Log Level + # Set the Log Record format for Summary Log + summarylog_abspath = atfdir + "/" + self._summarylog['filename'] + try: + summary_handler = logging.FileHandler(summarylog_abspath, mode='w') + + except IOError as (errno, errstr): + print "I/0 error({0}): {1}".format(errno, errstr) + return 1 + + else: + summary_formatter = logging.Formatter(self._summarylog['format']) + summary_handler.setFormatter(summary_formatter) + summary_handler.setLevel(self._summarylog['loglevel']) + logger.addHandler(summary_handler) + for log in self._loggers: + if log['logname'] == logname: + log['summary_handler'] = summary_handler + break + + # Create Stdout Log StreamHandler if log to stdout is defined + # Set the Log Level + # Set the Log Record format for STDOUT + if self._stdoutlog['do_log'] == 'true': + stdout_handler = logging.StreamHandler() + stdout_handler.setLevel(self._stdoutlog['loglevel']) + stdout_formatter = logging.Formatter(self._stdoutlog['format']) + stdout_handler.setFormatter(stdout_formatter) + logger.addHandler(stdout_handler) + for log in self._loggers: + if log['logname'] == logname: + log['stdout_handler'] = stdout_handler + break + return 0 + + def addDetaillogHandler(self, abspath, logname): + """ + Description: + Add a Detail Log FileHandler to Logger with logname 'logname' + + Parameters: + logname: Name of the Logger + + Returns: + Success: 0 + Failure: 1 + """ + + logger = logging.getLogger(logname) + + # Create Detail Log File Handler + # Set the Log Level + # Set the Log Record format for Detail Log + abspath = abspath + self._detaillog['filename'] + + try: + detail_handler = logging.FileHandler(abspath, mode='w') + + except IOError as (errno, errstr): + logger.error("IOError ({0}): {1}".format(errno, errstr)) + return 1 + + else: + detail_handler.setLevel(self._detaillog['loglevel']) + detail_formatter = logging.Formatter(self._detaillog['format']) + detail_handler.setFormatter(detail_formatter) + logger.addHandler(detail_handler) + + for log in self._loggers: + if log['logname'] == logname: + log['detail_handler'] = detail_handler + break + + logger.debug("Detail Log File Handler Successfully Added") + + return 0 + + def removeDetaillogHandler(self, logname): + """ + Description: + Remove Detail Log File Handler from Logger with + logname 'logname' + + Parameters: + logname: Name of the Logger + """ + + logger = logging.getLogger(logname) + Map = {} + for log in self._loggers: + Map = log + + if Map.has_key('detail_handler'): + detail_handler = log.pop('detail_handler') + logger.removeHandler(detail_handler) + logger.info("DetailLog Handler Removed for the Logger: " + + logname) + else: + logger.warning("DetailLog Handler Not Found for the Logger: " + + logname) + return + diff --git a/libs/globals/manager.py b/libs/globals/manager.py new file mode 100755 index 0000000..d73cf15 --- /dev/null +++ b/libs/globals/manager.py @@ -0,0 +1,64 @@ +""" manager module contains: + +*) ConnectionsManager Class +""" +class ConnectionsManager(): + """ + *) Manages Client SSH Connections in the current TestEnvironment + *) Manages Server SSH Connections in the current TestEnvironment + *) Manages allhosts SSH Connection in the current TestEnvironment + """ + def __init__(self): + + self._serverpool = {} + self._clientpool = {} + self._all = {} + + def addServer(self, key, server): + """ + Add a server to _serverpool + """ + + self._serverpool[key] = server + self._all[key] = server + return + + def addClient(self, key, client): + """ + Add a client to clientpool + """ + + self._clientpool[key] = client + self._all[key] = client + return + + def getServers(self): + """ + Return the server object + """ + + return self._serverpool + + def getClients(self): + """ + Return the client object + """ + + return self._clientpool + + def getConnection(self, key): + """ + """ + value = None + if self._all.has_key(key): + value = self._all[key] + return value + + def getConnections(self): + """ + """ + return self._all + + + + diff --git a/libs/globals/testenv.py b/libs/globals/testenv.py new file mode 100755 index 0000000..9aa8ec8 --- /dev/null +++ b/libs/globals/testenv.py @@ -0,0 +1,462 @@ +"""testenv module. + +TestEnv Class has attributes which holds information of the current +testenvironment. It includes information about Servers, Clients, Volume, +Bricks, MountPoints etc. +TestEnv Class provides methods to access the testenvironment info +""" + +from collections import namedtuple +import re + +class TestEnv(): + + def __init__(self): + self._exportdirs = {} + self._servers = {} + self._bricks = {} + self._volumes = {} + self._clients = {} + self._mountdevices = {} + self._mounts = {} + self._gluster_download_paths = [] + self._active_volume = None + + self._exportdir_tuple = namedtuple('ExportDir', + ['dir', 'fstype', 'device']) + + self._server_tuple = namedtuple('Server', + ['hostname', 'user', 'password', + 'glusterversion', 'installpath']) + + self._brick_tuple = namedtuple('Brick', + ['hostname', 'path']) + + self._volume_tuple = namedtuple('Volume', + ['volumename', 'volumetype', 'count', + 'transporttype', 'bricks']) + + self._client_tuple = namedtuple('Client', + ['hostname', 'user', 'password', + 'glusterversion', 'installpath']) + + self._mountdevice_tuple = namedtuple('MountDevice', + ['hostname', 'volumename']) + + self._mount_tuple = namedtuple('Mount', + ['client', 'dir', 'device', + 'type', 'logfile', 'options']) + + def addExportdir(self, key, dir_, **arguments): + """ + """ + fstype = device = None + if (arguments.has_key('fstype') and arguments['fstype']): + fstype = arguments['fstype'] + + if (arguments.has_key('device') and arguments['device']): + device = arguments['device'] + + exportdir_obj = self._exportdir_tuple(dir_, fstype, device) + self._exportdirs[key] = exportdir_obj + + def getExportdir(self, exportdirkey): + """ + """ + exportdir_obj = None + if self._exportdirs.has_key(exportdirkey): + exportdir_obj = self._exportdirs[exportdirkey] + + return exportdir_obj + + def getExportdirs(self): + """Returns self._exportdirs dictionary. + 'key' in dict is exportdirkey + 'value' is exportdir namedtuple object + """ + + return self._exportdirs + + def addServer(self, key, hostname, user, password, + glusterversion, **arguments): + """ + """ + installpath = None + if (arguments.has_key('installpath') and arguments['installpath']): + installpath = arguments['installpath'] + + server_obj = self._server_tuple(hostname, user, password, + glusterversion, installpath) + + self._servers[key] = server_obj + + def getServer(self, serverkey): + """ + """ + server_obj = None + if self._servers.has_key(serverkey): + server_obj = self._servers[serverkey] + + return server_obj + + def getServers(self): + """ + """ + servers = {} + + for serverkey in self._servers.keys(): + servers[serverkey] = self.getServer(serverkey) + + return servers + + def addClient(self, key, hostname, user, password, + glusterversion, **arguments): + """ + """ + installpath = None + if arguments.has_key('installpath') and arguments['installpath']: + installpath = arguments['installpath'] + + client_obj = self._client_tuple(hostname, user, password, + glusterversion, installpath) + self._clients[key] = client_obj + + def getClient(self, clientkey): + """ + """ + client_obj = None + if self._clients.has_key(clientkey): + client_obj = self._clients[clientkey] + + return client_obj + + def getClients(self): + """ + """ + clients = {} + + for clientkey in self._clients.keys(): + clients[clientkey] = self.getClient(clientkey) + + return clients + + def addBrick(self, key, hostname, path, **arguments): + """ + """ + brick_obj = self._brick_tuple(hostname, path) + self._bricks[key] = brick_obj + + def getBrick(self, brickkey): + """ + """ + return_brick_obj = None + newhostname = newpath = '' + + if self._bricks.has_key(brickkey): + brick_obj = self._bricks[brickkey] + else: + return return_brick_obj + + hostname_value = brick_obj.hostname + serverkey = re.split("\.", hostname_value, maxsplit=1)[0] + server_obj = self.getServer(serverkey) + if server_obj: + newhostname = server_obj.hostname + else: + return return_brick_obj + + path_value = brick_obj.path + if re.match("^\/", path_value): + path = path_value + else: + exportdir_obj = self.getExportdir(path_value) + if exportdir_obj: + newpath = exportdir_obj.dir + else: + brick_obj = None + return return_brick_obj + + return_brick_obj = brick_obj._replace(hostname=newhostname, + path=newpath) + + return return_brick_obj + + def getBricks(self): + """ + """ + return_bricks = {} + + for brickkey in self._bricks.keys(): + return_bricks[brickkey] = self.getBrick(brickkey) + + return return_bricks + + def getRawBrick(self, brickkey): + brick_obj = None + if self._bricks.has_key(brickkey): + brick_obj = self._bricks[brickkey] + return brick_obj + + def getBrickKeys(self): + """ + """ + brick_keys = [] + brick_keys.extend(self._bricks.keys()) + return brick_keys + + def addBricksToVolume(self, volumekey="ActiveVolume", *bricks): + """ + """ + volume_obj = None + if volumekey == "ActiveVolume": + volumekey = self._active_volume + + if not (volumekey and self._volumes.has_key(volumekey)): + return 1 + + volume_obj = self._volumes[volumekey] + + for brick in bricks: + volume_obj.bricks.append(brick) + + return 0 + + def replaceBrickInVolume(self, replace_brick, to_brick, + volumekey="ActiveVolume"): + """ + """ + volume_obj = None + replaced_status = False + if volumekey == "ActiveVolume": + volumekey = self._active_volume + + if not (volumekey and self._volumes.has_key(volumekey)): + return 1 + + volume_obj = self._volumes[volumekey] + for index, brick in enumerate(volume_obj.bricks): + if brick == replace_brick: + volume_obj.bricks[index] = to_brick + replaced_status = True + break + else: + continue + + if replaced_status: + return 0 + else: + return 1 + + def addVolume(self, key, volumename, volumetype, count, + transporttype, bricks): + """ + """ + brickskeylist = [x.strip() for x in bricks.split(",")] + volume_obj = self._volume_tuple(volumename, volumetype, + count, transporttype, brickskeylist) + self._volumes[key] = volume_obj + + def getVolume(self, volumekey): + """ + """ + return_volume_obj = None + + if not self._volumes.has_key(volumekey): + return return_volume_obj + + volume_obj = self._volumes[volumekey] + brickslist = [] + for brickkey in volume_obj.bricks: + brick_obj = self.getBrick(brickkey) + if not brick_obj: + return return_volume_obj + else: + brickslist.append(brick_obj) + + return_volume_obj = volume_obj._replace(bricks=brickslist) + + return return_volume_obj + + def getVolumes(self): + """ + """ + return_volumes = {} + for volumekey in self._volumes.keys(): + return_volumes[volumekey] = self.getVolume(volumekey) + + return return_volumes + + def addMountDevice(self, key, hostname, volumename): + """ + """ + mountdevice_obj = self._mountdevice_tuple(hostname, volumename) + self._mountdevices[key] = mountdevice_obj + + def getMountDevice(self, mountdevicekey): + """ + *) Check the hostname = IPAddress + *) Check hostname refers to any server + *) Check the volume is defined. + *) Substitute all values + """ + returndevice_obj = None + ip_pattern = re.compile('(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})\.(?:[\d]{1,3})') + + if not self._mountdevices.has_key(mountdevicekey): + return returndevice_obj + + else: + mountdevice_obj = self._mountdevices[mountdevicekey] + + hostname_value = mountdevice_obj.hostname + if ip_pattern.match(hostname_value): + newhostname = hostname_value + elif re.match('(([a-z]|[A-Z])+[0-9]+)\.hostname', hostname_value): + serverkey = re.split("\.", hostname_value, maxsplit=1)[0] + server_obj = self.getServer(serverkey) + if server_obj: + newhostname = server_obj.hostname + else: + return returndevice_obj + else: + newhostname = hostname_value + volumekey = re.split("\.", mountdevice_obj.volumename, maxsplit=1)[0] + volume_obj = self.getVolume(volumekey) + if volume_obj: + newvolumename = volume_obj.volumename + else: + return returndevice_obj + + + returndevice_obj = mountdevice_obj._replace(hostname=newhostname, + volumename=newvolumename) + return returndevice_obj + + def getMountDevices(self): + """ + """ + return_mount_devices = {} + + for mountdevicekey in self._mountdevices.keys(): + return_mount_devices[mountdevicekey] = self.getMountDevice(mountdevicekey) + + return return_mount_devices + + def addMount(self, key, client, dir_, device, **arguments): + """ + """ + logfile = options = None + type_ = "glusterfs" + + if (arguments.has_key("type") and arguments['type']): + type_ = arguments['type'] + + if (arguments.has_key("logfile") and arguments['logfile']): + logfile = arguments['logfile'] + + if (arguments.has_key("options") and arguments['options']): + options = arguments['options'] + + mount_obj = self._mount_tuple(client, dir_, device, + type_, logfile, options) + self._mounts[key] = mount_obj + + def getMount(self, mountkey): + """ + """ + return_mount_obj = None + if not self._mounts.has_key(mountkey): + return return_mount_obj + + mount_obj = self._mounts[mountkey] + devicekey = mount_obj.device + device_obj = self.getMountDevice(devicekey) + if not device_obj: + return return_mount_obj + else: + return_mount_obj = mount_obj._replace(device=device_obj) + + return return_mount_obj + + def getMounts(self): + """ + """ + return_mounts = {} + + for mountkey in self._mounts.keys(): + return_mounts[mountkey] = self.getMount(mountkey) + + return return_mounts + + def getMountsKeys(self): + """ + """ + mounts_keys = [] + mounts_keys.extend(self._mounts.keys()) + return mounts_keys + + def addDefaults(self, **arguments): + """ + """ + downloadpaths = [] + + if (arguments.has_key('downloadpath') and arguments['downloadpath']): + paths = arguments['downloadpath'] + downloadpaths = [x.strip() for x in paths.split(",")] + + self._gluster_download_paths = downloadpaths + + def setActiveVolume(self, volumekey): + """ + """ + if self._volumes.has_key(volumekey): + self._active_volume = volumekey + return 0 + else: + return 1 + + def getActiveVolume(self): + """ + """ + active_volume_key = self._active_volume + active_volume = self.getVolume(active_volume_key) + return active_volume + + def getGlusterDownloadPaths(self): + """ + """ + return self._gluster_download_paths + + def getHosts(self): + """ + """ + all_hosts = {} + all_hosts.update(self.getServers) + all_hosts.update(self.getClients) + return all_hosts + + def getHostsKeys(self): + """ + """ + hosts_keys = [] + hosts_keys.extend(self._servers.keys()) + hosts_keys.extend(self._clients.keys()) + return hosts_keys + + def getHost(self, hostkey): + """ + """ + host_obj = None + host_obj = self.getServer(hostkey) + if host_obj: + return host_obj + else: + host_obj = self.getClient(hostkey) + return host_obj + + + + + + + diff --git a/libs/globals/testruninfo.py b/libs/globals/testruninfo.py new file mode 100644 index 0000000..9b012e8 --- /dev/null +++ b/libs/globals/testruninfo.py @@ -0,0 +1,144 @@ +"""testruninfo module + +TestRunInfo Class contains variables and methods for storing and retrieving +information about current "TestRun". +""" +import re + +class TestRunInfo(): + def __init__(self): + self._testunits = [] + self._keywords = '' + self._glusterversion = '' + self._atfdir = '' + self._summaryloginfo = {} + self._detailloginfo = {} + self._stdoutloginfo = {} + + def addGlusterVersion(self, version): + """ + """ + self._glusterversion = version + + def getGlusterVersion(self): + """ + """ + return self._glusterversion + + def addSummaryLogInfo(self, filename, loglevel): + """ + """ + if not filename: + filename = "SummaryLog.out" + + if not loglevel: + loglevel = "info" + + self._summaryloginfo['filename'] = filename + self._summaryloginfo['loglevel'] = loglevel + + def getSummaryLogInfo(self): + """ + """ + return self._summaryloginfo + + def addDetailLogInfo(self, filename, loglevel): + """ + """ + if not filename: + filename = "DetailLog.out" + + if not loglevel: + loglevel = "info" + + self._detailloginfo['filename'] = filename + self._detailloginfo['loglevel'] = loglevel + + def getDetailLogInfo(self): + """ + """ + return self._detailloginfo + + def addStdoutLogInfo(self, do_log, loglevel): + """ + """ + true_pattern = re.compile('True|Yes', re.IGNORECASE) + false_pattern = re.compile('False|No', re.IGNORECASE) + + if not loglevel: + loglevel = "info" + + if true_pattern.match(do_log): + do_log = True + + elif false_pattern.match(do_log): + do_log = False + + else: + do_log = True + + self._stdoutloginfo['do_log'] = do_log + self._stdoutloginfo['loglevel'] = loglevel + + def getStdoutLogInfo(self): + """ + """ + return self._stdoutloginfo + + def addAtfDir(self, atfdir): + """ + """ + self._atfdir = atfdir + + def getAtfDir(self): + """ + """ + return self._atfdir + + def addTestUnits(self, testunit): + """ + Description: + Add a testunit to TestUnits List + + Parameter: + testunit: Name of the Testing Unit + + Returns: + """ + + self._testunits.append(testunit) + return + + def getTestUnits(self): + """ + Description: + Return TestUnits List + + Parameters: + + Returns: + Success: Testunit Name + Failure: '' + """ + + return self._testunits + + def addKeywords(self, keywords): + """ + Description: + Add Keywords to KeyWords List + + Parameters: + keyname: Keyword + + Returns: + """ + self._keywords = keywords + + def getKeywords(self): + """ + """ + return self._keywords + + + |