def _ReadPythonModuleConfiguration(self, config_parser):
"""Reads the Python module configuration.
Args:
config_parser (ConfigParser): configuration file parser.
Raises:
ConfigurationError: if the Python module year of creation cannot
be converted to a base 10 integer value.
"""
self.python_module_authors = self._GetOptionalConfigValue(
config_parser,
'python_module',
'authors',
default_value=self.project_authors)
self.python_module_name = 'py{0:s}'.format(self.library_name_suffix)
self.python_module_year_of_creation = self._GetOptionalConfigValue(
config_parser, 'python_module', 'year_of_creation')
if not self.python_module_year_of_creation:
self.python_module_year_of_creation = self.project_year_of_creation
else:
try:
self.python_module_year_of_creation = int(
self.python_module_year_of_creation, 10)
except ValueError:
raise errors.ConfigurationError(
'Invalid Python module year of creation: {0!s}'.format(
self.python_module_year_of_creation))
def _ReadProjectConfiguration(self, config_parser):
"""Reads the project configuration.
Args:
config_parser (ConfigParser): configuration file parser.
Raises:
ConfigurationError: if the project year of creation cannot
be converted to a base 10 integer value.
"""
self.project_name = self._GetConfigValue(
config_parser, 'project', 'name')
self.project_data_format = self._GetOptionalConfigValue(
config_parser, 'project', 'data_format', default_value='')
project_description = ''
if self.project_data_format:
project_description = (
'{0:s} is a library to access the {1:s} format.'.format(
self.project_name, self.project_data_format))
self.project_description = self._GetOptionalConfigValue(
config_parser, 'project', 'description',
default_value=project_description)
project_authors = ['Joachim Metz <*****@*****.**>']
self.project_authors = self._GetOptionalConfigValue(
config_parser, 'project', 'authors', default_value=project_authors)
self.project_documentation_url = self._GetOptionalConfigValue(
config_parser, 'project', 'documentation_url')
project_downloads_url = 'https://github.com/libyal/{0:s}/releases'.format(
self.project_name)
self.project_downloads_url = self._GetOptionalConfigValue(
config_parser, 'project', 'downloads_url',
default_value=project_downloads_url)
project_git_url = 'https://github.com/libyal/{0:s}.git'.format(
self.project_name)
self.project_git_url = self._GetOptionalConfigValue(
config_parser, 'project', 'git_url', default_value=project_git_url)
self.project_status = self._GetConfigValue(
config_parser, 'project', 'status')
self.project_year_of_creation = self._GetConfigValue(
config_parser, 'project', 'year_of_creation')
try:
self.project_year_of_creation = int(self.project_year_of_creation, 10)
except ValueError:
raise errors.ConfigurationError(
'Invalid project year of creation: {0!s}'.format(
self.project_year_of_creation))
features = self._GetOptionalConfigValue(
config_parser, u'project', u'features', default_value=[])
self.supports_debug_output = 'debug_output' in features
def __init__(self, *args, **kwargs):
self.queue = kwargs.pop('queue')
self.number_requests = 0
try:
self.schema = json.loads(
open(settings.SCHEMA['NOTIFICATION']).read())
except (KeyError, IOError, ValueError):
raise errors.ConfigurationError('invalid json schema document')
resource.Resource.__init__(self, *args, **kwargs)
def __init__(self,
minConnections=3,
maxConnections=5,
reconnect=True,
keepAliveQuery=storagecontroller.KEEPALIVE_QUERY,
keepAliveInterval=storagecontroller.KEEPALIVE_INTERVAL):
self.minConnections = minConnections
self.maxConnections = maxConnections
self.reconnect = reconnect
self.keepAliveQuery = keepAliveQuery
self.keepAliveInterval = keepAliveInterval
# validate config
if self.minConnections < 1:
raise errors.ConfigurationError('minConnections must be >= 1')
if self.maxConnections > 100:
raise errors.ConfigurationError('maxConnections must be <= 100')
if self.keepAliveInterval < storagecontroller.MIN_KEEPALIVE_INTERVAL:
raise errors.ConfigurationError(
'maxConnections is specified in seconds. '
'It must be >= %s' % storagecontroller.MIN_KEEPALIVE_INTERVAL)
def __getitem__(self, key):
if key in self.overrides:
val = self.overrides[key]
elif key in self.obsconfigs:
val = self.obsconfigs[key]
elif key in self.defaults:
val = self.defaults[key]
else:
raise errors.ConfigurationError("The configuration '%s' "
"cannot be found!" % key)
return val
def __init__(self, pwd_path):
try:
content = open(pwd_path, 'r').read()
except IOError:
raise errors.ConfigurationError(
'%s is missing. Please read workdir/README.' %
os.path.basename(pwd_path))
lines = [l.strip() for l in content.splitlines()]
lines = [l for l in lines if l and not l.startswith('#')]
self.creds = {}
for l in lines:
items = l.split(':', 1)
self.creds[items[0].strip()] = items[1].strip()
def __getitem__(self, key):
if key in self.overrides:
#utils.print_debug("Config '%s' found in Overrides" % key, 'config', stepsback=3)
val = self.overrides[key]
elif key in self.obsconfigs:
#utils.print_debug("Config '%s' found in Observation configs" % key, 'config', stepsback=3)
val = self.obsconfigs[key]
elif key in self.defaults:
#utils.print_debug("Config '%s' found in Default" % key, 'config', stepsback=3)
val = self.defaults[key]
else:
raise errors.ConfigurationError("The configuration '%s' "
"cannot be found!" % key)
return val
def connect_apns(self):
for pem_file in [settings.APNS['cert'], settings.APNS['key']]:
if not validate_pem_file(pem_file):
raise errors.ConfigurationError(
'APNS PEM file is not valid: {}'.format(pem_file))
params = {
'cert': settings.APNS['cert'],
'key': settings.APNS['key'],
'release': settings.APNS['dist'],
}
if 'proxy' in settings.APNS and settings.APNS['proxy']:
params.update({'proxy': settings.APNS['proxy']})
logger.debug('connecting to apns service')
self.apns_obj = apns_service.APNS(**params)
def __init__(self,
name=None,
readServers=None,
writeServers=None,
user=None,
password=None,
port=3306,
sharePool=False,
ConnectionPool=None):
self._readPool = None
self._writePool = None
self.name = name
self.port = port
self.sharePool = sharePool
self.readServers = readServers
self.writeServers = writeServers
self.user = user
self.password = password
if ConnectionPool is not None:
self.ConnectionPool = ConnectionPoolConfig(**ConnectionPool)
else:
self.ConnectionPool = ConnectionPoolConfig()
# validate config
if self.name is None:
raise errors.ConfigurationError('DB.name is None or missing')
if self.readServers is None or not self.readServers:
raise errors.ConfigurationError(
'DB.readServers is None or empty list or missing')
if self.writeServers is None or not self.writeServers:
raise errors.ConfigurationError(
'DB.writeServers is None or empty list or missing')
if self.user is None:
raise errors.ConfigurationError('DB.user is None or missing')
if self.password is None:
raise errors.ConfigurationError('DB.password is None or missing')
def __init__(self, project_file_path, project_save_path=None):
vs.setDefaultBackendDevice(0)
self.calibration_string = None
self.resolution = SETTINGS.resolution
self.delay_adjusts = {}
#listing the audio sources will update the delays
self.list_audio_sources()
self.project_file_path = project_file_path
self.project_save_path = project_save_path if project_save_path else project_file_path
self.reset(False)
self.audio_pipe = None
if SETTINGS.enable_ev_compensation and SETTINGS.enable_metadata_processing:
raise errors.ConfigurationError(
'Conflict: both exposure algorithm and metadata processing are enabled'
)
def _ReadInfoToolConfiguration(self, config_parser):
"""Reads the info tool configuration.
Args:
config_parser (ConfigParser): configuration file parser.
Raises:
ConfigurationError: if the info tool source type is not supported.
"""
self.info_tool_source_description = self._GetOptionalConfigValue(
config_parser, 'info_tool', 'source_description')
self.info_tool_source_type = self._GetOptionalConfigValue(
config_parser, 'info_tool', 'source_type')
if (self.info_tool_source_type and self.info_tool_source_type
not in ('file', 'image', 'volume')):
raise errors.ConfigurationError(
'unsupported info tool source type: {0:s}'.format(
self.info_tool_source_type))
def _ReadMountToolConfiguration(self, config_parser):
"""Reads the mount tool configuration.
Args:
config_parser (ConfigParser): configuration file parser.
Raises:
ConfigurationError: if the mount tool source type is not supported.
"""
features = self._GetOptionalConfigValue(config_parser,
'mount_tool',
'features',
default_value=[])
if features:
self.mount_tool_has_keys_option = 'keys' in features
self.mount_tool_has_password_option = 'password' in features
self.mount_tool_additional_arguments = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'additional_arguments')
self.mount_tool_mounted_description = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'mounted_description')
self.mount_tool_source = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source')
self.mount_tool_source_description = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_description')
# If the long source description is not set it will default to
# source description.
self.mount_tool_source_description_long = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_description_long')
self.mount_tool_source_type = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_type')
if (self.mount_tool_source_type and self.mount_tool_source_type
not in ('file', 'image', 'volume')):
raise errors.ConfigurationError(
'unsupported mount tool source type: {0:s}'.format(
self.mount_tool_source_type))
def notify(self, *args, **kwargs):
msg = kwargs.pop('msg')
expiry_time = msg.pop('expiry_time', None)
if expiry_time:
try:
expiry = datetime.datetime.strptime(expiry_time,
'%Y-%m-%d %H:%M:%S')
except ValueError:
raise errors.DataValidationError(
'expiry time is not in a valid format')
if expiry < datetime.datetime.now():
logger.info('notification message is expired. dropped.')
return
srv_type = msg.pop('type', '')
if srv_type.lower() == 'fcm':
self.handle_fcm(*args, **msg)
elif srv_type.lower() == 'apns':
self.handle_apns(*args, **msg)
else:
raise errors.ConfigurationError(
'invalid notification service type: {}'.format(srv_type))
# -*- coding: utf-8 -*-
from item import Item # So that wikidata.Item can be used.
from configReader import Config
from api import API
import errors
config = Config('config.py')
if not config["api"]:
raise errors.ConfigurationError(
"An API url needs to be defined in config.py")
api = API(config)
def _resolve_database(self, database_name=None):
db = database_name or self.default_database
if db is None:
raise pbx_errors.ConfigurationError('Missing default database')
return db
def __init__(self, serverConfig, dbConfig, userData, profileData,
matchData, profileLogic):
self.serverConfig = serverConfig
self.dbConfig = dbConfig
self.userData = userData
self.profileData = profileData
self.matchData = matchData
self.profileLogic = profileLogic
self.cipherKey = ('27501fd04e6b82c831024dac5c6305221974deb9388a2190'
'1d576cbbe2f377ef23d75486010f37819afe6c321a0146d2'
'1544ec365bf7289a')
self.serverIP_lan = None
self.serverIP_wan = None
self.startDatetime = datetime.now()
reactor.callLater(0, self.setIP)
# initialize interface to listen on
self.interface = self.serverConfig.get('ListenOn', '')
# initialize MaxUsers, set to default if missing from config
self.serverConfig.MaxUsers = self.serverConfig.get('MaxUsers', 1000)
self.lobbies = []
for i, item in enumerate(serverConfig.Lobbies):
try:
name = item['name']
except TypeError:
name = str(item)
except KeyError:
raise errors.ConfigurationError(
'Structured lobby definitions must '
'include "name" attribute')
try:
lobbyType = item['type']
except TypeError:
lobbyType = 'open'
except KeyError:
lobbyType = 'open'
try:
showMatches = item['showMatches']
except TypeError:
showMatches = True
except KeyError:
showMatches = True
try:
checkRosterHash = bool(int(item['checkRosterHash']))
except:
checkRosterHash = True
aLobby = lobby.Lobby(name, 100)
aLobby.showMatches = showMatches
aLobby.checkRosterHash = checkRosterHash
aLobby.typeStr = str(lobbyType)
if lobbyType == 'noStats':
aLobby.typeCode = 0x20
elif lobbyType == 'open':
aLobby.typeCode = 0x5f
elif isinstance(lobbyType, list):
# restricted lobby
divMap = {'A': 0, '3B': 1, '3A': 2, '2': 3, '1': 4}
typeCode = 0
for divName in lobbyType:
try:
typeCode += 2**divMap[divName]
except KeyError:
raise errors.ConfigurationError(
'Invalid lobby type definition. '
'Unrecognized division: "%s" ' % divName)
aLobby.typeCode = typeCode
else:
aLobby.typeCode = 0x5f # default: open
self.lobbies.append(aLobby)
# auto-IP detector site
try:
self.ipDetectUri = self.serverConfig.IpDetectUri
except AttributeError:
self.ipDetectUri = 'http://mapote.com/cgi-bin/ip.py'
# rating/points calculator
self.ratingMath = rating.RatingMath(0.44, 0.56)
# initialize online-list
self.onlineUsers = dict()
# initialize latest-info dict
self._latestUserInfo = dict()
# read banned-list, if available
bannedYaml = self.serverConfig.BannedList
if not bannedYaml.startswith('/'):
fsroot = os.environ.get('FSROOT', '.')
bannedYaml = fsroot + '/' + bannedYaml
if os.path.exists(bannedYaml):
self.bannedList = YamlConfig(bannedYaml)
else:
self.bannedList = YamlConfig(None, newYamlFile=bannedYaml)
log.msg('NOTICE: banned-list file absent.')
try:
self.bannedList.Banned
except AttributeError:
self.bannedList.Banned = []
# make banned-list structure for quick checks
self.makeFastBannedList()
# set up periodical rank-compute
reactor.callLater(5, self.computeRanks)
# set up periodical date updates
now = datetime.now()
today = datetime(now.year, now.month, now.day)
td = today + timedelta(days=1) - now
reactor.callLater(0, self.systemDayChange)
def _read_lines(filepath, what):
try:
return open(filepath).readlines()
except IOError:
raise errors.ConfigurationError('Put the %s in %s' % (what, filepath))
def _ReadMountToolConfiguration(self, config_parser):
"""Reads the mount tool configuration.
Args:
config_parser (ConfigParser): configuration file parser.
Raises:
ConfigurationError: if the mount tool features or source type is not
supported.
"""
self._mount_tool_features = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'features', default_value=[])
if ('offset' in self._mount_tool_features
and 'parent' in self._mount_tool_features):
raise errors.ConfigurationError(
'unsupported mount tool features - offset and parent cannot be '
'combined.')
self.mount_tool_additional_arguments = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'additional_arguments')
self.mount_tool_base_type = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'base_type')
self.mount_tool_file_entry_access_time_type = (
self._GetOptionalConfigValue(config_parser, 'mount_tool',
'file_entry_access_time_type'))
if (self.mount_tool_file_entry_access_time_type
and self.mount_tool_file_entry_access_time_type
not in ('filetime', 'hfs_time', 'nano_posix_time')):
raise errors.ConfigurationError(
'unsupported mount tool file entry access time type: {0:s}'.
format(self.mount_tool_file_entry_access_time_type))
self.mount_tool_file_entry_access_time_value = (
self._GetOptionalConfigValue(config_parser,
'mount_tool',
'file_entry_access_time_value',
default_value='access_time'))
self.mount_tool_file_entry_creation_time_type = (
self._GetOptionalConfigValue(config_parser, 'mount_tool',
'file_entry_creation_time_type'))
if (self.mount_tool_file_entry_creation_time_type
and self.mount_tool_file_entry_creation_time_type
not in ('filetime', 'hfs_time', 'nano_posix_time')):
raise errors.ConfigurationError(
'unsupported mount tool file entry creation time type: {0:s}'.
format(self.mount_tool_file_entry_creation_time_type))
self.mount_tool_file_entry_creation_time_value = (
self._GetOptionalConfigValue(config_parser,
'mount_tool',
'file_entry_creation_time_value',
default_value='creation_time'))
self.mount_tool_file_entry_inode_change_time_type = (
self._GetOptionalConfigValue(config_parser, 'mount_tool',
'file_entry_inode_change_time_type'))
if (self.mount_tool_file_entry_inode_change_time_type
and self.mount_tool_file_entry_inode_change_time_type
not in ('filetime', 'hfs_time', 'nano_posix_time')):
raise errors.ConfigurationError(
('unsupported mount tool file entry inode change time type: '
'{0:s}').format(
self.mount_tool_file_entry_inode_change_time_type))
self.mount_tool_file_entry_inode_change_time_value = (
self._GetOptionalConfigValue(config_parser,
'mount_tool',
'file_entry_inode_change_time_value',
default_value='inode_change_time'))
self.mount_tool_file_entry_modification_time_type = (
self._GetOptionalConfigValue(config_parser, 'mount_tool',
'file_entry_modification_time_type'))
if (self.mount_tool_file_entry_modification_time_type
and self.mount_tool_file_entry_modification_time_type
not in ('filetime', 'hfs_time', 'nano_posix_time')):
raise errors.ConfigurationError(
('unsupported mount tool file entry modification time type: '
'{0:s}').format(
self.mount_tool_file_entry_modification_time_type))
self.mount_tool_file_entry_modification_time_value = (
self._GetOptionalConfigValue(config_parser,
'mount_tool',
'file_entry_modification_time_value',
default_value='modification_time'))
self.mount_tool_file_entry_type = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'file_entry_type')
self.mount_tool_file_entry_type_size_value = self._GetOptionalConfigValue(
config_parser,
'mount_tool',
'file_entry_type_size_value',
default_value='size')
self.mount_tool_file_system_type = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'file_system_type')
self.mount_tool_mounted_description = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'mounted_description')
self.mount_tool_path_prefix = self._GetOptionalConfigValue(
config_parser,
'mount_tool',
'path_prefix',
default_value=self.library_name_suffix)
self.mount_tool_source = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source')
self.mount_tool_source_description = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_description')
# If the long source description is not set it will default to
# source description.
self.mount_tool_source_description_long = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_description_long')
self.mount_tool_source_type = self._GetOptionalConfigValue(
config_parser, 'mount_tool', 'source_type')
if self.mount_tool_source_type and self.mount_tool_source_type not in (
'container', 'file', 'image', 'volume'):
raise errors.ConfigurationError(
'unsupported mount tool source type: {0:s}'.format(
self.mount_tool_source_type))
