blob: 620191f3a83d213af3b23920e29fc9fb498eb41b [file] [log] [blame] [edit]
"""
Wrapper around ConfigParser to manage testcases configuration.
@author rsalveti@linux.vnet.ibm.com (Ricardo Salveti de Araujo)
"""
from ConfigParser import ConfigParser
from StringIO import StringIO
from os import path
import types, re, string
from autotest_lib.client.common_lib import utils
__all__ = ['config_loader']
class config_loader:
"""
Base class of the configuration parser
"""
def __init__(self, cfg, tmpdir='/tmp', raise_errors=False):
"""
Instantiate ConfigParser and provide the file like object that we'll
use to read configuration data from.
@param cfg: Where we'll get configuration data. It can be either:
* A URL containing the file
* A valid file path inside the filesystem
* A string containing configuration data
@param tmpdir: Where we'll dump the temporary conf files.
@param raise_errors: Whether config value absences will raise
ValueError exceptions.
"""
# Base Parser
self.parser = ConfigParser()
# Raise errors when lacking values
self.raise_errors = raise_errors
# File is already a file like object
if hasattr(cfg, 'read'):
self.cfg = cfg
self.parser.readfp(self.cfg)
elif isinstance(cfg, types.StringTypes):
# Config file is a URL. Download it to a temp dir
if cfg.startswith('http') or cfg.startswith('ftp'):
self.cfg = path.join(tmpdir, path.basename(cfg))
utils.urlretrieve(cfg, self.cfg)
self.parser.read(self.cfg)
# Config is a valid filesystem path to a file.
elif path.exists(path.abspath(cfg)):
if path.isfile(cfg):
self.cfg = path.abspath(cfg)
self.parser.read(self.cfg)
else:
e_msg = 'Invalid config file path: %s' % cfg
raise IOError(e_msg)
# Config file is just a string, convert it to a python file like
# object using StringIO
else:
self.cfg = StringIO(cfg)
self.parser.readfp(self.cfg)
def get(self, section, option, default=None):
"""
Get the value of a option.
Section of the config file and the option name.
You can pass a default value if the option doesn't exist.
@param section: Configuration file section.
@param option: Option we're looking after.
@default: In case the option is not available and raise_errors is set
to False, return the default.
"""
if not self.parser.has_option(section, option):
if self.raise_errors:
raise ValueError('No value for option %s. Please check your '
'config file "%s".' % (option, self.cfg))
else:
return default
return self.parser.get(section, option)
def set(self, section, option, value):
"""
Set an option.
This change is not persistent unless saved with 'save()'.
"""
if not self.parser.has_section(section):
self.parser.add_section(section)
return self.parser.set(section, option, value)
def remove(self, section, option):
"""
Remove an option.
"""
if self.parser.has_section(section):
self.parser.remove_option(section, option)
def save(self):
"""
Save the configuration file with all modifications
"""
if not self.cfg:
return
fileobj = file(self.cfg, 'w')
try:
self.parser.write(fileobj)
finally:
fileobj.close()
def check(self, section):
"""
Check if the config file has valid values
"""
if not self.parser.has_section(section):
return False, "Section not found: %s"%(section)
options = self.parser.items(section)
for i in range(options.__len__()):
param = options[i][0]
aux = string.split(param, '.')
if aux.__len__ < 2:
return False, "Invalid parameter syntax at %s"%(param)
if not self.check_parameter(aux[0], options[i][1]):
return False, "Invalid value at %s"%(param)
return True, None
def check_parameter(self, param_type, parameter):
"""
Check if a option has a valid value
"""
if parameter == '' or parameter == None:
return False
elif param_type == "ip" and self.__isipaddress(parameter):
return True
elif param_type == "int" and self.__isint(parameter):
return True
elif param_type == "float" and self.__isfloat(parameter):
return True
elif param_type == "str" and self.__isstr(parameter):
return True
return False
def __isipaddress(self, parameter):
"""
Verify if the ip address is valid
@param ip String: IP Address
@return True if a valid IP Address or False
"""
octet1 = "([1-9][0-9]{,1}|1[0-9]{2}|2[0-4][0-9]|25[0-5])"
octet = "([0-9]{1,2}|1[0-9]{2}|2[0-4][0-9]|25[0-5])"
pattern = "^" + octet1 + "\.(" + octet + "\.){2}" + octet + "$"
if re.match(pattern, parameter) == None:
return False
else:
return True
def __isint(self, parameter):
try:
int(parameter)
except Exception, e_stack:
return False
return True
def __isfloat(self, parameter):
try:
float(parameter)
except Exception, e_stack:
return False
return True
def __isstr(self, parameter):
try:
str(parameter)
except Exception, e_stack:
return False
return True