modules/fm-orchestrator
1
0
Fork 0
mirror of https://pagure.io/fm-orchestrator.git synced 2026-05-16 13:56:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: registering conf items is not required

Browse Source
This commit is contained in:
Filip Valder
2016-11-11 14:05:57 +01:00
parent e783e91889
commit b9382f8e9f
1 changed files with 228 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

606
module_build_service/config.py
View File

@@ -30,13 +30,174 @@ import six
from module_build_service import app from module_build_service import app
from module_build_service import logger from module_build_service import logger
DEFAULTS = [
{'name': 'system',
'type': str,
'default': '',
'desc': ''},
{'name': 'db',
'type': str,
'default': '',
'desc': ''},
{'name': 'polling_interval',
'type': int,
'default': 0,
'desc': ''},
{'name': 'pdc_url',
'type': str,
'default': '',
'desc': ''},
{'name': 'pdc_insecure',
'type': bool,
'default': False,
'desc': ''},
{'name': 'pdc_develop',
'type': bool,
'default': False,
'desc': ''},
{'name': 'koji_config',
'type': str,
'default': None,
'desc': ''},
{'name': 'koji_profile',
'type': str,
'default': None,
'desc': ''},
{'name': 'koji_arches',
'type': list,
'default': None,
'desc': ''},
{'name': 'koji_proxyuser',
'type': bool,
'default': None,
'desc': ''},
{'name': 'koji_build_priority',
'type': int,
'default': 10,
'desc': ''},
{'name': 'koji_repository_url',
'type': str,
'default': None,
'desc': ''},
{'name': 'rpms_default_repository',
'type': str,
'default': '',
'desc': ''},
{'name': 'rpms_allow_repository',
'type': bool,
'default': False,
'desc': ''},
{'name': 'rpms_default_cache',
'type': str,
'default': '',
'desc': ''},
{'name': 'rpms_allow_cache',
'type': bool,
'default': False,
'desc': ''},
{'name': 'ssl_certificate_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'ssl_certificate_key_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'ssl_ca_certificate_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'pkgdb_api_url',
'type': str,
'default': '',
'desc': ''},
{'name': 'fas_url',
'type': str,
'default': '',
'desc': ''},
{'name': 'fas_username',
'type': str,
'default': '',
'desc': ''},
{'name': 'fas_password',
'type': str,
'default': '',
'desc': ''},
{'name': 'require_packager',
'type': bool,
'default': True,
'desc': ''},
{'name': 'log_backend',
'type': str,
'default': '',
'desc': ''},
{'name': 'log_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'log_level',
'type': str,
'default': 0,
'desc': ''},
{'name': 'krb_keytab',
'type': None,
'default': None,
'desc': ''},
{'name': 'krb_principal',
'type': None,
'default': None,
'desc': ''},
{'name': 'krb_ccache',
'type': None,
'default': '/tmp/krb5cc_module_build_service',
'desc': ''},
{'name': 'messaging',
'type': str,
'default': '',
'desc': ''},
{'name': 'amq_recv_addresses',
'type': list,
'default': [],
'desc': ''},
{'name': 'amq_dest_address',
'type': str,
'default': '',
'desc': ''},
{'name': 'amq_cert_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'amq_private_key_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'amq_trusted_cert_file',
'type': str,
'default': '',
'desc': ''},
{'name': 'mock_config',
'type': str,
'default': 'fedora-25-x86_64',
'desc': ''},
{'name': 'mock_build_srpm_cmd',
'type': str,
'default': 'fedpkg --dist f25 srpm',
'desc': ''},
{'name': 'scmurls',
'type': list,
'default': [],
'desc': ''},
]
def from_app_config(): def from_app_config():
""" Create the configuration instance from the values in app.config """ Create the configuration instance from the values in app.config
""" """
conf = Config() conf = Config()
for key, value in app.config.items(): for key, value in app.config.items():
setattr(conf, key.lower(), value) # lower keys
key = key.lower()
conf.setitem(key, value)
return conf return conf
@@ -44,407 +205,96 @@ class Config(object):
"""Class representing the orchestrator configuration.""" """Class representing the orchestrator configuration."""
def __init__(self): def __init__(self):
"""Initialize the Config object.""" """Initialize the Config object with defaults."""
self._system = "" self._defaults = DEFAULTS
self._db = "" self._defaults_by_name = {conf_item['name']: conf_item
self._polling_interval = 0 for conf_item
self._pdc_url = "" in self._defaults}
self._pdc_insecure = False
self._pdc_develop = False
self._koji_config = None
self._koji_profile = None
self._koji_arches = None
self._koji_proxyuser = None
self._koji_build_priority = 10
self._koji_repository_url = None
self._rpms_default_repository = ""
self._rpms_allow_repository = False
self._rpms_default_cache = ""
self._rpms_allow_cache = False
self._ssl_certificate_file = ""
self._ssl_certificate_key_file = ""
self._ssl_ca_certificate_file = ""
self._pkgdb_api_url = ""
self._fas_url = ""
self._fas_username = ""
self._fas_password = ""
self._require_packager = True
self._log_backend = ""
self._log_file = ""
self._log_level = 0
self._krb_keytab = None
self._krb_principal = None
self._krb_ccache = "/tmp/krb5cc_module_build_service"
self._messaging = ""
self._amq_recv_addresses = []
self._amq_dest_address = ""
self._amq_cert_file = ""
self._amq_private_key_file = ""
self._amq_trusted_cert_file = ""
self._mock_config = "fedora-25-x86_64"
self._mock_build_srpm_cmd = "fedpkg --dist f25 srpm"
@property for conf_item in self._defaults:
def system(self): self.setitem(conf_item['name'], conf_item['default'])
"""The buildsystem to use."""
return self._system
@system.setter def setitem(self, key, value):
def system(self, s): if key == 'setitem' or key.startswith('_'):
raise Exception("Configuration item's name is not allowed: %s" % key)
# registered defaults
if key in self._defaults_by_name:
# customized check & set first
setifok_func = '_setifok_{}'.format(key)
if hasattr(self, setifok_func):
getattr(self, setifok_func)(value)
return
# type conversion
convert = self._defaults_by_name[key]['type']
if convert in [bool, int, list, str]:
setattr(self, key, convert(value))
# conversion is not required if type is None
elif convert is None:
setattr(self, key, value)
# unknown type/unsupported conversion
else:
raise Exception("Unsupported type %s for configuration item: %s" % (convert, key))
# passthrough for uncontrolled configuration items
else:
setattr(self, key, value)
return
def _setifok_system(self, s):
s = str(s) s = str(s)
if s not in ("koji", "copr", "mock"): if s not in ("koji", "copr", "mock"):
raise ValueError("Unsupported buildsystem: %s." % s) raise ValueError("Unsupported buildsystem: %s." % s)
self._system = s self.system = s
@property def _setifok_polling_interval(self, i):
def messaging(self):
"""The messaging system to use."""
return self._messaging
@messaging.setter
def messaging(self, s):
s = str(s)
if s not in ("fedmsg" , "amq"):
raise ValueError("Unsupported messaging system.")
self._messaging = s
@property
def amq_recv_addresses(self):
"""Apache MQ broker url to receive messages."""
return self._amq_recv_addresses
@amq_recv_addresses.setter
def amq_recv_addresses(self, l):
assert isinstance(l, list) or isinstance(l, tuple)
self._amq_recv_addresses = list(l)
@property
def amq_dest_address(self):
"""Apache MQ broker address to send messages"""
return self._amq_dest_address
@amq_dest_address.setter
def amq_dest_address(self, s):
self._amq_dest_address = str(s)
@property
def amq_cert_file(self):
"""Certificate for Apache MQ broker auth."""
return self._amq_cert_file
@amq_cert_file.setter
def amq_cert_file(self, s):
self._amq_cert_file = str(s)
@property
def amq_private_key_file(self):
"""Private key for Apache MQ broker auth."""
return self._amq_private_key_file
@amq_private_key_file.setter
def amq_private_key_file(self, s):
self._amq_private_key_file = str(s)
@property
def amq_trusted_cert_file(self):
"""Trusted certificate for ssl connection."""
return self._amq_trusted_cert_file
@amq_trusted_cert_file.setter
def amq_trusted_cert_file(self, s):
s = str(s)
self._amq_trusted_cert_file = s
@property
def db(self):
"""RDB URL."""
return self._db
@db.setter
def db(self, s):
self._db = str(s)
@property
def pdc_url(self):
"""PDC URL."""
return self._pdc_url
@pdc_url.setter
def pdc_url(self, s):
self._pdc_url = str(s)
@property
def pdc_insecure(self):
"""Allow insecure connection to PDC."""
return self._pdc_insecure
@pdc_insecure.setter
def pdc_insecure(self, b):
self._pdc_insecure = bool(b)
@property
def pdc_develop(self):
"""PDC Development mode, basically noauth."""
return self._pdc_develop
@pdc_develop.setter
def pdc_develop(self, b):
self._pdc_develop = bool(b)
@property
def polling_interval(self):
"""Polling interval, in seconds."""
return self._polling_interval
@polling_interval.setter
def polling_interval(self, i):
if not isinstance(i, int): if not isinstance(i, int):
raise TypeError("polling_interval needs to be an int") raise TypeError("polling_interval needs to be an int")
if i < 0: if i < 0:
raise ValueError("polling_interval must be >= 0") raise ValueError("polling_interval must be >= 0")
self._polling_interval = i self.polling_interval = i
@property def _setifok_rpms_default_repository(self, s):
def mock_config(self):
return self._mock_config
@mock_config.setter
def mock_config(self, s):
self._mock_config = str(s)
@property
def mock_build_srpm_cmd(self):
return self._mock_build_srpm_cmd
@mock_build_srpm_cmd.setter
def mock_build_srpm_cmd(self, s):
self._mock_build_srpm_cmd = str(s)
@property
def koji_config(self):
"""Koji URL."""
return self._koji_config
@koji_config.setter
def koji_config(self, s):
self._koji_config = str(s)
@property
def koji_profile(self):
"""Koji URL."""
return self._koji_profile
@koji_profile.setter
def koji_profile(self, s):
self._koji_profile = str(s)
@property
def koji_arches(self):
"""Koji architectures."""
return self._koji_arches
@koji_arches.setter
def koji_arches(self, s):
self._koji_arches = list(s)
@property
def koji_proxyuser(self):
"""Koji proxyuser flag."""
return self._koji_proxyuser
@koji_proxyuser.setter
def koji_proxyuser(self, s):
self._koji_proxyuser = bool(s)
@property
def koji_repository_url(self):
return self._koji_repository_url
@koji_repository_url.setter
def koji_repository_url(self, s):
self._koji_repository_url = str(s)
@property
def koji_build_priority(self):
return self._koji_build_priority
@koji_build_priority.setter
def koji_build_priority(self, i):
if not isinstance(i, int):
raise TypeError("koji_build_priority needs to be an int")
self._koji_build_priority = i
@property
def scmurls(self):
"""Allowed SCM URLs."""
return self._scmurls
@scmurls.setter
def scmurls(self, l):
if not isinstance(l, list):
raise TypeError("scmurls needs to be a list.")
self._scmurls = [str(x) for x in l]
@property
def rpms_default_repository(self):
return self._rpms_default_repository
@rpms_default_repository.setter
def rpms_default_repository(self, s):
rpm_repo = str(s) rpm_repo = str(s)
if rpm_repo[-1] != '/': if rpm_repo[-1] != '/':
rpm_repo = rpm_repo + '/' rpm_repo = rpm_repo + '/'
self._rpms_default_repository = rpm_repo self.rpms_default_repository = rpm_repo
@property def _setifok_rpms_default_cache(self, s):
def rpms_allow_repository(self):
return self._rpms_allow_repository
@rpms_allow_repository.setter
def rpms_allow_repository(self, b):
if not isinstance(b, bool):
raise TypeError("rpms_allow_repository must be a bool.")
self._rpms_allow_repository = b
@property
def rpms_default_cache(self):
return self._rpms_default_cache
@rpms_default_cache.setter
def rpms_default_cache(self, s):
rpm_cache = str(s) rpm_cache = str(s)
if rpm_cache[-1] != '/': if rpm_cache[-1] != '/':
rpm_cache = rpm_cache + '/' rpm_cache = rpm_cache + '/'
self._rpms_default_cache = rpm_cache self.rpms_default_cache = rpm_cache
@property def _setifok_log_backend(self, s):
def rpms_allow_cache(self): if s is None:
return self._rpms_allow_cache self.log_backend = "console"
elif s not in logger.supported_log_backends():
@rpms_allow_cache.setter
def rpms_allow_cache(self, b):
if not isinstance(b, bool):
raise TypeError("rpms_allow_cache must be a bool.")
self._rpms_allow_cache = b
@property
def ssl_certificate_file(self):
return self._ssl_certificate_file
@ssl_certificate_file.setter
def ssl_certificate_file(self, s):
self._ssl_certificate_file = str(s)
@property
def ssl_ca_certificate_file(self):
return self._ssl_ca_certificate_file
@ssl_ca_certificate_file.setter
def ssl_ca_certificate_file(self, s):
self._ssl_ca_certificate_file = str(s)
@property
def ssl_certificate_key_file(self):
return self._ssl_certificate_key_file
@ssl_certificate_key_file.setter
def ssl_certificate_key_file(self, s):
self._ssl_certificate_key_file = str(s)
@property
def pkgdb_api_url(self):
return self._pkgdb_api_url
@pkgdb_api_url.setter
def pkgdb_api_url(self, s):
self._pkgdb_api_url = str(s)
@property
def fas_url(self):
return self._fas_url
@fas_url.setter
def fas_url(self, s):
self._fas_url = str(s)
@property
def fas_username(self):
return self._fas_username
@fas_username.setter
def fas_username(self, s):
self._fas_username = str(s)
@property
def fas_password(self):
return self._fas_password
@fas_password.setter
def fas_password(self, s):
self._fas_password = str(s)
@property
def require_packager(self):
return self._require_packager
@require_packager.setter
def require_packager(self, s):
self._require_packager = bool(s)
@property
def log_backend(self):
return self._log_backend
@log_backend.setter
def log_backend(self, s):
if s == None:
self._log_backend = "console"
elif not s in logger.supported_log_backends():
raise ValueError("Unsupported log backend") raise ValueError("Unsupported log backend")
self.log_backend = str(s)
self._log_backend = str(s) def _setifok_log_file(self, s):
if s is None:
@property self.log_file = ""
def log_file(self):
return self._log_file
@log_file.setter
def log_file(self, s):
if s == None:
self._log_file = ""
else: else:
self._log_file = str(s) self.log_file = str(s)
@property def _setifok_log_level(self, s):
def log_level(self):
return self._log_level
@log_level.setter
def log_level(self, s):
level = str(s).lower() level = str(s).lower()
self._log_level = logger.str_to_log_level(level) self.log_level = logger.str_to_log_level(level)
@property def _setifok_messaging(self, s):
def krb_keytab(self): s = str(s)
return self._krb_keytab if s not in ("fedmsg", "amq"):
raise ValueError("Unsupported messaging system.")
self.messaging = s
@krb_keytab.setter def _setifok_amq_recv_addresses(self, l):
def krb_keytab(self, s): assert isinstance(l, list) or isinstance(l, tuple)
self._krb_keytab = s self.amq_recv_addresses = list(l)
@property def _setifok_scmurls(self, l):
def krb_principal(self): if not isinstance(l, list):
return self._krb_principal raise TypeError("scmurls needs to be a list.")
self.scmurls = [str(x) for x in l]
@krb_principal.setter
def krb_principal(self, s):
self._krb_principal = s
@property
def krb_ccache(self):
return self._krb_ccache
@krb_ccache.setter
def krb_ccache(self, s):
self._krb_ccache = s