def __init__(self, p_config, p_section_name, p_base_api_url=""):
self._config = p_config
self._logger = log_handling.get_logger(p_section_name)
# logger = log_handling.get_logger("requests.packages.urllib3.connectionpool")
logger = log_handling.get_logger("urllib3.connectionpool")
logger.setLevel(logging.WARNING)
self._api_base_url = p_base_api_url
def __init__(self,
p_app_name,
p_pid_file,
p_arguments,
p_dir_name,
p_languages=None):
super().__init__(pidfile=p_pid_file)
self._app_name = p_app_name
self._dir_name = p_dir_name
self._languages = p_languages
self._arguments = p_arguments
self._logger = log_handling.get_logger(self.__class__.__name__)
self._config = None
self._recurring_tasks = []
self._downtime = 0
self._locale_helper = None
self._latest_request = None
self._partial_basic_init_executed = False
self._full_basic_init_executed = False
self._active_signals = [signal.SIGTERM, signal.SIGINT]
self._done = False
if not tools.is_windows():
self._active_signals.append(signal.SIGHUP)
if self._languages is None:
self._languages = DEFAULT_LANGUAGES
self._langs = {}
# Only temporary until the app has been initialized completely!
self._app_config = BaseAppConfigModel()
def __init__(self, *args, **kwargs):
base_dir = dirname(inspect.getfile(self.__class__))
if PARAMETER_NAME_CONFIGURATION_FILE in kwargs:
filename = kwargs.get(PARAMETER_NAME_CONFIGURATION_FILE,
DEFAULT_CONFIG_FILENAME)
if filename is None:
filename = DEFAULT_CONFIG_FILENAME
self._config_filename = join(base_dir, filename)
del (kwargs[PARAMETER_NAME_CONFIGURATION_FILE])
else:
self._config_filename = join(base_dir, DEFAULT_CONFIG_FILENAME)
if PARAMETER_NAME_TEST_DATA_BASE_DIR in kwargs:
self._test_data_base_dir = join(
base_dir, kwargs.get(PARAMETER_NAME_TEST_DATA_BASE_DIR))
del (kwargs[PARAMETER_NAME_TEST_DATA_BASE_DIR])
else:
self._test_data_base_dir = join(base_dir,
DEFAULT_RESOURCE_REL_PATH)
super(BaseTestCase, self).__init__(*args, **kwargs)
log_handling.start_logging(p_use_filter=False)
self._config = self.configuration_factory()
self._logger = log_handling.get_logger(self.__class__.__name__)
def __init__(self,
p_username,
p_reference_time,
p_max_lookback_in_days,
p_min_activity_duration,
p_notification_name=None,
p_full_name=None):
self._logger = log_handling.get_logger(self.__class__.__name__)
self.username = p_username
self.notification_name = p_notification_name if p_notification_name is not None else self.username
self.full_name = p_full_name if p_full_name is not None else self.username
self.reference_time = p_reference_time
self.reference_date = p_reference_time.date()
self.max_lookback_in_days = p_max_lookback_in_days
self.min_activity_duration = p_min_activity_duration
self.active_processes = 0
self.last_inactivity_start_time = None
self.current_activity = None
self.previous_activity = None
self.accumulated_break_time = 0
self.has_downtime = False
self.day_statistics = [
DayStatistics() for _i in range(0, p_max_lookback_in_days + 1)
]
self.currently_active_host_processes = {}
def __init__(self, p_config):
self._config = p_config
self._logger = log_handling.get_logger(self.__class__.__name__)
self._process_infos = {}
def check_installation(p_arguments):
pid_file_directory = os.path.dirname(p_arguments.pid_file)
if p_arguments.log_dir is not None:
tools.test_mode(p_arguments.log_dir,
p_app_owner=p_arguments.app_owner,
p_is_directory=True,
p_executable=True,
p_writable=True,
p_other_access=False)
if p_arguments.daemonize:
tools.test_mode(pid_file_directory,
p_app_owner=p_arguments.app_owner,
p_is_directory=True,
p_executable=True,
p_writable=True)
for config_file in p_arguments.configurations:
tools.test_mode(config_file,
p_app_owner=p_arguments.app_owner,
p_other_access=False)
logger = log_handling.get_logger()
logger.info("Installation OK!")
def __init__(self, p_config, p_exclude_user_list=None):
self._logger = log_handling.get_logger(self.__class__.__name__)
self._config = p_config
self._exclude_user_list = p_exclude_user_list
if self._exclude_user_list is None:
self._exclude_user_list = []
def __init__(self):
self._sections = {}
self._logger = log_handling.get_logger(self.__class__.__name__)
self._section_handlers = []
self._optional_section_handler_definitions: dict[
str, OptionalSectionHandlerDefinition] = {}
self.config = configparser.ConfigParser(strict=False)
def __init__(self, p_config, p_rule_set_configs):
self._config = p_config
self._rule_set_configs = p_rule_set_configs
self._context_rule_handlers = {}
self._default_context_rule_handler_name = None
self._logger = log_handling.get_logger(self.__class__.__name__)
def __init__(self,
p_config,
p_debug_mode,
p_process_handlers,
p_persistence,
p_rule_handler,
p_notification_handlers,
p_master_connector,
p_rule_set_configs,
p_username_map=None):
if p_username_map is None:
p_username_map = {}
self._config = p_config
self._debug_mode = p_debug_mode
self._process_handlers = p_process_handlers
self._persistence = p_persistence
self._rule_handler = p_rule_handler
self._notification_handlers = p_notification_handlers
self._master_connector = p_master_connector
self._logger = log_handling.get_logger(self.__class__.__name__)
self._usernames_not_found = []
self._usernames = []
self._process_regex_map = None
self._uid_map = {}
self._username_map = p_username_map
self._logout_warnings = {}
if self._rule_handler is not None:
self.register_rule_context_handlers()
self.set_rule_set_configs(p_rule_set_configs=p_rule_set_configs)
fmt = "Watching usernames: %s" % ",".join(self._usernames)
self._logger.info(fmt)
self._event_queue = queue.Queue()
self._outgoing_events = []
self._could_not_send = False
self._client_infos = {}
self._rule_overrides = {}
if self._config.hostname is None:
self._host_name = socket.getfqdn()
else:
self._host_name = self._config.hostname
if not self._config.scan_active:
fmt = "Scanning for this host has been deactivated in configuration"
self._logger.warning(fmt)
self.init_labels_and_notifications()
def __init__(self, p_config, p_process_iterator_factory):
super().__init__(p_config=p_config)
# self._config = p_config
self._process_iterator_factory = p_process_iterator_factory
self._logger = log_handling.get_logger(self.__class__.__name__)
self._process_infos = {}
def check_configuration(self):
logger = log_handling.get_logger()
self.prepare_configuration(self.configuration_factory())
fmt = "%d configuration files are Ok!" % len(
self._arguments.configurations)
logger.info(fmt)
def delete_audio_file(p_audio_handler):
audio_file = p_audio_handler.get_audio_filename(p_text=TEXT, p_locale=None)
try:
os.unlink(audio_file)
except Exception as e:
logger = log_handling.get_logger()
fmt = "Cannot delete audio file {filename}: {exception}"
logger.warning(fmt.format(filename=audio_file, exception=str(e)))
def __init__(self, p_app, p_app_control, p_master_connector):
self._appcontrol = p_app_control
self._master_connector = p_master_connector
self._logger = log_handling.get_logger(self.__class__.__name__)
self._blueprint = flask.Blueprint(API_BLUEPRINT_NAME,
little_brother.__name__)
API_BLUEPRINT_ADAPTER.assign_view_handler_instance(
p_blueprint=self._blueprint, p_view_handler_instance=self)
API_BLUEPRINT_ADAPTER.check_view_methods()
p_app.register_blueprint(self._blueprint)
def __init__(self):
super().__init__(p_context_name=CALENDAR_CONTEXT_RULE_HANDLER_NAME)
self._logger = log_handling.get_logger(self.__class__.__name__)
self._vacation_data = None
self._federal_state_map = None
self._config = GermanVacationContextRuleHandlerConfig()
self._cache = {}
def __init__(self, p_config):
self._config = p_config
self._logger = log_handling.get_logger(self.__class__.__name__)
self._recent_texts = {}
if self._config.locale is None:
self._config.locale = locale.getdefaultlocale()[0]
self.init_engine()
def __init__(self, p_default_port=None, p_config=None):
if p_config is None:
p_config = PingerConfigModel()
self._config = p_config
self._default_port = p_default_port
self._logger = log_handling.get_logger(self.__class__.__name__)
try:
self.ping_result_regex = re.compile(self._config.ping_result_regex)
except Exception:
fmt = "Invalid regular expression '{regex}' in [{section}]ping_result_regex"
raise configuration.ConfigurationException(
fmt.format(regex=self._config.ping_result_regex,
section=SECTION_NAME))
def test_mode(p_filename, p_app_owner, p_executable=False, p_writable=False, p_is_directory=False, p_other_access=True):
logger = log_handling.get_logger()
p_filename = os.path.abspath(p_filename)
if p_is_directory:
if not os.path.isdir(p_filename):
raise exceptions.InstallationException("Directory '%s' not found!" % p_filename)
else:
if not os.path.isfile(p_filename):
raise exceptions.InstallationException("File '%s' not found!" % p_filename)
info = os.stat(p_filename)
if p_app_owner is not None:
if not is_windows():
import pwd
owner_name = pwd.getpwuid(info.st_uid).pw_name
if owner_name != p_app_owner:
raise exceptions.InstallationException(
"File/directory '%s' must be owned by '%s'!" % (p_filename, p_app_owner))
logger.info("File/directory '%s' is owned by '%s' -> OK" % (p_filename, p_app_owner))
if info.st_mode & stat.S_IRUSR == 0:
raise exceptions.InstallationException("File/directory '%s' must be readable by owner!" % p_filename)
logger.info("File/directory '%s' must be readable by owner -> OK" % p_filename)
if p_executable:
if info.st_mode & stat.S_IXUSR == 0:
raise exceptions.InstallationException("File/directory '%s' must be executable by owner!" % p_filename)
logger.info("File/directory '%s' must be executable by owner -> OK" % p_filename)
if p_writable:
if info.st_mode & stat.S_IWUSR == 0:
raise exceptions.InstallationException("File/directory '%s' must be writable by owner!" % p_filename)
logger.info("File/directory '%s' must be writable by owner -> OK" % p_filename)
if not p_other_access:
if info.st_mode & (stat.S_IRGRP | stat.S_IROTH | stat.S_IWGRP | stat.S_IWOTH | stat.S_IXGRP | stat.S_IXOTH) > 0:
raise exceptions.InstallationException(
"File/directory '%s' must not be accessible by group or others!" % p_filename)
logger.info("File/directory '%s' must not be accessible by group or others!" % p_filename)
def __init__(self, p_config, p_persistence):
super().__init__(p_config=p_config)
self._persistence = p_persistence
#self._session_context = persistence.SessionContext(p_persistence=self._persistence, p_register=True)
try:
self.ping_result_regex = re.compile(self._config.ping_result_regex)
except Exception:
fmt = "Invalid regular expression '{regex}' in [{section}]ping_result_regex"
raise configuration.ConfigurationException(
fmt.format(regex=self._config.ping_result_regex, section=SECTION_NAME))
self._logger = log_handling.get_logger(self.__class__.__name__)
self._process_infos = {}
self._device_infos = {}
def __init__(self, p_config, p_client_device_configs):
super()._init__(p_config=p_config)
self._client_device_configs = p_client_device_configs
try:
self.ping_result_regex = re.compile(self._config.ping_result_regex)
except Exception:
fmt = "Invalid regular expression '{regex}' in [{section}]ping_result_regex"
raise configuration.ConfigurationException(
fmt.format(regex=self._config.ping_result_regex,
section=SECTION_NAME))
self._logger = log_handling.get_logger(self.__class__.__name__)
self._process_infos = {}
self._device_infos = {}
self._process_info_candidates = {}
def __init__(self,
pidfile,
stdin=os.devnull,
stdout=os.devnull,
stderr=os.devnull,
home_dir='.',
umask=0o22,
verbose=1,
use_gevent=False,
use_eventlet=False):
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
self.pidfile = pidfile
self.home_dir = home_dir
self.verbose = verbose
self.umask = umask
self.daemon_alive = True
self.use_gevent = use_gevent
self.use_eventlet = use_eventlet
self._logger = log_handling.get_logger(self.__class__.__name__)
def __init__(self, p_section_prefix):
self._section_prefix = p_section_prefix
self._configuration = None
self._logger = log_handling.get_logger(self.__class__.__name__)
def __init__(self):
self._logger = log_handling.get_logger(self.__class__.__name__)
def main(p_app_name, p_app_class, p_argument_parser):
process_result = 0
logger = log_handling.get_logger()
arguments = p_argument_parser.parse_args()
try:
if arguments.daemonize and arguments.log_dir is None:
raise configuration.ConfigurationException(
"Option --daemonize requires option --logdir!")
default_log_file = '%s.log' % p_app_name
log_handling.start_logging(p_level=arguments.log_level,
p_log_dir=arguments.log_dir,
p_log_file=default_log_file,
p_use_filter=not arguments.no_log_filter)
logger = log_handling.get_logger()
for path in CONTRIB_LOG_PATHS:
msg = "Setting log filter for library {path}..."
logger.debug(msg.format(path=path))
log_handling.add_default_filter_to_logger_by_name(path)
if arguments.check_installation:
logger.info("Checking installation...")
check_installation(p_arguments=arguments)
else:
app = p_app_class(p_pid_file=arguments.pid_file,
p_arguments=arguments,
p_app_name=p_app_name)
if len(arguments.configurations) == 0:
logger.warning("No configuration files specified")
if arguments.kill:
logger.info("Killing active daemon process...")
app.stop()
elif arguments.check_configuration:
logger.info("Checking configuration files...")
app.check_configuration()
else:
app.load_configuration()
if not app.run_special_commands(p_arguments=arguments):
if arguments.daemonize:
logger.info("Starting daemon process...")
app.start()
else:
logger.info(
"Starting as a normal foreground process...")
app.run()
except configuration.ConfigurationException as e:
logger.error(str(e))
process_result = 3
except exceptions.InstallationException as e:
logger.error(str(e))
process_result = 2
except Exception as e:
tools.handle_fatal_exception(p_exception=e, p_logger=logger)
tools.log_stack_trace(p_logger=logger)
process_result = 1
fmt = 'Terminated with exit code %d' % process_result
logger.info(fmt)
return process_result
def __init__(self, p_config, p_reuse_session=True):
self._logger = log_handling.get_logger(self.__class__.__name__)
self._config = p_config
self._session_used = False
self._admin_session = None
self._create_table_session = None
self._admin_engine = None
self._create_table_engine = None
self._reuse_session = p_reuse_session
self._users = None
self._devices = None
self._users_session = None
self._devices_session = None
self._cache_entities = True
if self._config.database_user is not None:
tools.check_config_value(
p_config=self._config,
p_config_attribute_name="database_password")
if self._config.database_admin is not None and self._config.database_admin_password is not None:
url = urllib.parse.urlunsplit(
(self._config.database_driver, "%s:%s@%s:%d" %
(self._config.database_admin,
self._config.database_admin_password,
self._config.database_host, self._config.database_port), '',
None, None))
fmt = "Database URL for administrative access: '%s'" % tools.anonymize_url(
url)
self._logger.info(fmt)
if DATABASE_DRIVER_POSTGRESQL in self._config.database_driver:
isolation_level = 'AUTOCOMMIT'
else:
isolation_level = None
if isolation_level is not None:
self._create_table_engine = sqlalchemy.create_engine(
url, isolation_level=isolation_level)
else:
self._create_table_engine = sqlalchemy.create_engine(url)
self._admin_engine = sqlalchemy.create_engine(
url, pool_recycle=self._config.pool_recycle)
url = self.build_url()
fmt = "Database URL for normal access: '%s'" % tools.anonymize_url(url)
self._logger.info(fmt)
options = {'pool_recycle': self._config.pool_recycle}
if (DATABASE_DRIVER_POSTGRESQL in self._config.database_driver
or DATABASE_DRIVER_MYSQL in self._config.database_driver):
options['pool_size'] = self._config.pool_size
options['max_overflow'] = self._config.max_overflow
# if DATABASE_DRIVER_SQLITE in self._config.database_driver:
# options['check_same_thread'] = False
self._engine = sqlalchemy.create_engine(url, **options)
def setUpClass(cls):
logger = log_handling.get_logger("urllib3.connectionpool")
logger.setLevel(logging.WARNING)
def __init__(self, p_required_capabilities):
self._required_capabilities = p_required_capabilities
self._logger = log_handling.get_logger(self.__class__.__name__)
def __init__(self,
p_name,
p_config,
p_package_name,
p_user_handler=None,
p_login_view=None,
p_logged_out_endpoint=None):
self._login_manager = None
self._flask_stopper = None
self._auth_view_handler = None
self._server_started = False
self._user_handler = p_user_handler
self._csrf = None
self._name = p_name
self._config = p_config
self._login_view = p_login_view
if p_package_name is None:
raise configuration.ConfigurationException(
"HttpServer: p_package_name must not be None")
self._logger = log_handling.get_logger(self.__class__.__name__)
self._app = flask.Flask(p_package_name)
# see https://improveandrepeat.com/2020/10/python-friday-43-add-security-headers-to-your-flask-application/
# see https://secure.readthedocs.io/en/latest/frameworks.html#flask
self._app.after_request(set_secure_headers)
# see https://stackoverflow.com/questions/62992831/python-session-samesite-none-not-being-set
# see https://flask.palletsprojects.com/en/2.0.x/security/#security-cookie
self._app.config['SESSION_COOKIE_SAMESITE'] = "Strict"
self._flask_stopper = some_flask_helpers.FlaskStopper(
p_app=self._app, p_logger=self._logger)
self._app.config["APPLICATION_ROOT"] = self._config.base_url
if self._user_handler is not None:
tools.check_config_value(p_config=self._config,
p_config_attribute_name="app_secret")
self._auth_view_handler = auth_view_handler.AuthViewHandler(
p_user_handler=self._user_handler,
p_app=self._app,
p_logged_out_endpoint=p_logged_out_endpoint,
p_url_prefix=self._config.base_url,
p_login_view=p_login_view)
# Activate CSRF protection
self._app.config.update(SECRET_KEY=self._config.app_secret)
self._csrf = CSRFProtect()
self._csrf.init_app(self._app)
self._server_exception = None
# Install the actuator handler for the health check
self._actuator_view_handler = actuator.ActuatorViewHandler(
p_app=self._app, p_url_prefix=self._config.internal_base_url)
logger = log_handling.get_logger("werkzeug")
logger.setLevel(logging.WARNING)
logger = log_handling.get_logger("sqlalchemy.engine")
logger.setLevel(logging.WARNING)
def __init__(self, p_config, p_reuse_session=True):
self._logger = log_handling.get_logger(self.__class__.__name__)
self._config = p_config
self._session_used = False
self._admin_session = None
self._create_table_session = None
self._admin_engine = None
self._reuse_session = p_reuse_session
if self._config.database_user is not None:
tools.check_config_value(p_config=self._config, p_config_attribute_name="database_password")
if self._config.database_admin is not None and self._config.database_admin_password is not None:
url = urllib.parse.urlunsplit(
(
self._config.database_driver,
"%s:%s@%s:%d" % (
self._config.database_admin, self._config.database_admin_password,
self._config.database_host, self._config.database_port),
'',
None,
None
))
fmt = "Database URL for administrative access: '%s'" % tools.anonymize_url(url)
self._logger.info(fmt)
if DATABASE_DRIVER_POSTGRESQL in self._config.database_driver:
isolation_level = 'AUTOCOMMIT'
else:
isolation_level = None
if isolation_level is not None:
self._create_table_engine = sqlalchemy.create_engine(url, isolation_level=isolation_level)
else:
self._create_table_engine = sqlalchemy.create_engine(url)
self._admin_engine = sqlalchemy.create_engine(url, pool_recycle=self._config.pool_recycle)
if self._config.database_user is not None:
url = urllib.parse.urlunsplit(
(
self._config.database_driver,
"%s:%s@%s:%d" % (
self._config.database_user, self._config.database_password,
self._config.database_host, self._config.database_port),
self._config.database_name,
None,
None
))
else:
url = "{driver}://".format(driver=self._config.database_driver)
fmt = "Database URL for normal access: '%s'" % tools.anonymize_url(url)
self._logger.info(fmt)
self._engine = sqlalchemy.create_engine(url, pool_recycle=self._config.pool_recycle)
def main(p_main_module_dir):
global logger
exit_code = 0
try:
log_handling.start_logging()
logger = log_handling.get_logger(__name__)
parser = get_parser()
arguments = parser.parse_args()
main_setup_module = load_setup_module(p_dir=p_main_module_dir,
p_module_name="setup")
template_loader = jinja2.PackageLoader(python_base_app.__name__)
template_env = jinja2.Environment(loader=template_loader)
var = get_vars(p_setup_params=main_setup_module.extended_setup_params)
if arguments.execute_stage == STAGE_BUILD_PACKAGE:
if var["setup"]["build_debian_package"]:
generate_debian_control(p_main_setup_module=main_setup_module,
p_template_env=template_env)
generate_debian_postinst(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_pip3_script(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_make_debian_package(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_make_debian_package_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_PUBLISH_PACKAGE:
generate_publish_debian_package_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_publish_debian_package_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_PUBLISH_PYPI_PACKAGE:
generate_publish_pypi_package_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_publish_pypi_package_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_BUILD_DOCKER_IMAGES:
generate_build_docker_image_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_build_docker_image_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_INSTALL:
generate_install_debian_package_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_install_debian_package_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_INSTALL_PYPI_PACKAGE:
generate_install_pypi_package_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_install_pypi_package_script(
p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_TEST:
generate_test_app_script(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_pycoveragerc(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_test_app_script(p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_ANALYZE:
generate_analyze_app_script(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
execute_analyze_app_script(p_main_setup_module=main_setup_module)
elif arguments.execute_stage == STAGE_PREPARE:
generate_gitlab_ci_configuration(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_circle_ci_configuration(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_pip3_script(p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
generate_codacy_configuration(
p_main_setup_module=main_setup_module,
p_template_env=template_env)
generate_git_python_file(p_main_setup_module=main_setup_module,
p_template_env=template_env)
var = get_vars(
p_setup_params=main_setup_module.extended_setup_params)
if var["setup"]["generate_generic_install"]:
generate_generic_installation_script(
p_main_setup_module=main_setup_module,
p_template_env=template_env,
p_arguments=arguments)
else:
msg = "No stage selected -> nothing to do!"
logger.warn(msg)
except exceptions.ScriptExecutionError as e:
fmt = "Execution of script {script_name} failed with exit code {exit_code}"
logger.error(
fmt.format(script_name=e.script_name, exit_code=e.exit_code))
exit_code = 1
except KeyError as e:
fmt = "Exception of type {type}: {msg}"
logger.exception(fmt.format(type=type(e), msg=str(e)))
exit_code = 2
except Exception as e:
fmt = "General exception of type {type}: {msg}"
logger.exception(fmt.format(type=type(e), msg=str(e)))
exit_code = 2
fmt = "Exiting with code {exit_code}"
logger.info(fmt.format(exit_code=exit_code))
return exit_code
