def _initialise_github_alerter() -> GithubAlerter:
alerter_display_name = GITHUB_ALERTER_NAME
github_alerter_logger = _initialise_alerter_logger(alerter_display_name,
GithubAlerter.__name__)
# Try initialising an alerter until successful
while True:
try:
rabbitmq = RabbitMQApi(logger=github_alerter_logger.getChild(
RabbitMQApi.__name__),
host=RABBIT_IP)
github_alerter = GithubAlerter(alerter_display_name,
github_alerter_logger, rabbitmq,
ALERTER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(alerter_display_name),
github_alerter_logger)
break
except Exception as e:
msg = get_initialisation_error_message(alerter_display_name, e)
log_and_print(msg, github_alerter_logger)
# sleep 10 seconds before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return github_alerter
def _initialise_system_alerter(system_alerts_config: SystemAlertsConfig,
chain: str) -> SystemAlerter:
# Alerter display name based on system
alerter_display_name = SYSTEM_ALERTER_NAME_TEMPLATE.format(chain)
system_alerter_logger = _initialise_alerter_logger(alerter_display_name,
SystemAlerter.__name__)
# Try initialising an alerter until successful
while True:
try:
rabbitmq = RabbitMQApi(logger=system_alerter_logger.getChild(
RabbitMQApi.__name__),
host=RABBIT_IP)
system_alerter = SystemAlerter(alerter_display_name,
system_alerts_config,
system_alerter_logger, rabbitmq,
ALERTER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(alerter_display_name),
system_alerter_logger)
break
except Exception as e:
msg = get_initialisation_error_message(alerter_display_name, e)
log_and_print(msg, system_alerter_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return system_alerter
def _initialise_monitor(monitor_type: Type[T], monitor_display_name: str,
monitoring_period: int,
config: Union[SystemConfig, RepoConfig]) -> T:
monitor_logger = _initialise_monitor_logger(monitor_display_name,
monitor_type.__name__)
# Try initialising the monitor until successful
while True:
try:
rabbitmq = RabbitMQApi(logger=monitor_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
monitor = monitor_type(monitor_display_name, config,
monitor_logger, monitoring_period, rabbitmq)
log_and_print(
"Successfully initialised {}".format(monitor_display_name),
monitor_logger)
break
except Exception as e:
msg = get_initialisation_error_message(monitor_display_name, e)
log_and_print(msg, monitor_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return monitor
def _initialise_data_transformer(data_transformer_type: Type[T],
data_transformer_display_name: str) -> T:
transformer_logger = _initialise_transformer_logger(
data_transformer_display_name, data_transformer_type.__name__)
redis = _initialise_transformer_redis(data_transformer_display_name,
transformer_logger)
# Try initialising the transformer until successful
while True:
try:
rabbitmq = RabbitMQApi(logger=transformer_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
data_transformer = data_transformer_type(
data_transformer_display_name, transformer_logger, redis,
rabbitmq, env.DATA_TRANSFORMER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(
data_transformer_display_name), transformer_logger)
break
except Exception as e:
msg = get_initialisation_error_message(
data_transformer_display_name, e)
log_and_print(msg, transformer_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return data_transformer
def _initialise_component_redis(component_display_name: str,
component_logger: logging.Logger) -> RedisApi:
# Try initialising the Redis API until successful. This had to be done
# separately to avoid instances when Redis creation failed and we
# attempt to use it.
while True:
try:
redis_db = env.REDIS_DB
redis_port = env.REDIS_PORT
redis_host = env.REDIS_IP
unique_alerter_identifier = env.UNIQUE_ALERTER_IDENTIFIER
redis = RedisApi(logger=component_logger.getChild(
RedisApi.__name__),
db=redis_db,
host=redis_host,
port=redis_port,
namespace=unique_alerter_identifier)
break
except Exception as e:
msg = get_initialisation_error_message(component_display_name, e)
log_and_print(msg, component_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return redis
def _initialise_system_monitors_manager() -> SystemMonitorsManager:
manager_display_name = SYSTEM_MONITORS_MANAGER_NAME
system_monitors_manager_logger = _initialise_logger(
manager_display_name, SystemMonitorsManager.__name__,
env.MANAGERS_LOG_FILE_TEMPLATE)
# Attempt to initialise the system monitors manager
while True:
try:
rabbit_ip = env.RABBIT_IP
rabbitmq = RabbitMQApi(
logger=system_monitors_manager_logger.getChild(
RabbitMQApi.__name__),
host=rabbit_ip)
system_monitors_manager = SystemMonitorsManager(
system_monitors_manager_logger, manager_display_name, rabbitmq)
break
except Exception as e:
log_and_print(
get_initialisation_error_message(manager_display_name, e),
system_monitors_manager_logger)
log_and_print(get_reattempting_message(manager_display_name),
system_monitors_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return system_monitors_manager
def _initialise_data_store_manager() -> StoreManager:
manager_display_name = DATA_STORE_MANAGER_NAME
data_store_manager_logger = _initialise_logger(
manager_display_name, StoreManager.__name__,
env.MANAGERS_LOG_FILE_TEMPLATE)
# Attempt to initialise the data store manager
while True:
try:
rabbitmq = RabbitMQApi(logger=data_store_manager_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
data_store_manager = StoreManager(data_store_manager_logger,
manager_display_name, rabbitmq)
break
except Exception as e:
log_and_print(
get_initialisation_error_message(manager_display_name, e),
data_store_manager_logger)
log_and_print(get_reattempting_message(manager_display_name),
data_store_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return data_store_manager
def _initialise_logger(component_display_name: str, component_module_name: str,
log_file_template: str) -> logging.Logger:
# Try initialising the logger until successful. This had to be done
# separately to avoid instances when the logger creation failed and we
# attempt to use it.
while True:
try:
new_logger = create_logger(
log_file_template.format(component_display_name),
component_module_name,
env.LOGGING_LEVEL,
rotating=True)
break
except Exception as e:
# Use a dummy logger in this case because we cannot create the
# manager's logger.
dummy_logger = logging.getLogger('DUMMY_LOGGER')
log_and_print(
get_initialisation_error_message(component_display_name, e),
dummy_logger)
log_and_print(get_reattempting_message(component_display_name),
dummy_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return new_logger
def _initialise_github_alerter_manager() -> GithubAlerterManager:
manager_display_name = GITHUB_ALERTER_MANAGER_NAME
github_alerter_manager_logger = _initialise_logger(
manager_display_name, GithubAlerterManager.__name__,
env.MANAGERS_LOG_FILE_TEMPLATE)
# Attempt to initialise the system alerters manager
while True:
try:
rabbitmq = RabbitMQApi(
logger=github_alerter_manager_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
github_alerter_manager = GithubAlerterManager(
github_alerter_manager_logger, manager_display_name, rabbitmq)
break
except Exception as e:
log_and_print(
get_initialisation_error_message(manager_display_name, e),
github_alerter_manager_logger)
log_and_print(get_reattempting_message(manager_display_name),
github_alerter_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return github_alerter_manager
def _initialise_channels_manager() -> ChannelsManager:
manager_display_name = CHANNELS_MANAGER_NAME
channels_manager_logger = _initialise_logger(
manager_display_name, ChannelsManager.__name__,
env.MANAGERS_LOG_FILE_TEMPLATE)
# Attempt to initialise the data transformers manager
while True:
try:
rabbitmq = RabbitMQApi(logger=channels_manager_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
channels_manager = ChannelsManager(channels_manager_logger,
manager_display_name, rabbitmq)
break
except Exception as e:
log_and_print(
get_initialisation_error_message(manager_display_name, e),
channels_manager_logger)
log_and_print(get_reattempting_message(manager_display_name),
channels_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return channels_manager
def _initialise_log_alerts_handler(channel_id: str,
channel_name: str) -> LogAlertsHandler:
# Handler display name based on channel name
handler_display_name = LOG_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, LogAlertsHandler.__name__)
alerts_logger = _initialise_alerts_logger()
# Try initialising handler until successful
while True:
try:
log_channel = LogChannel(
channel_name, channel_id,
handler_logger.getChild(LogChannel.__name__), alerts_logger)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
log_alerts_handler = LogAlertsHandler(handler_display_name,
handler_logger, rabbitmq,
log_channel)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return log_alerts_handler
def _initialise_telegram_commands_handler(
bot_token: str, bot_chat_id: str, channel_id: str, channel_name: str,
associated_chains: Dict) -> TelegramCommandsHandler:
# Handler display name based on channel name
handler_display_name = TELEGRAM_COMMANDS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, TelegramCommandsHandler.__name__)
# Try initialising handler until successful
while True:
try:
telegram_bot = TelegramBotApi(bot_token, bot_chat_id)
telegram_channel = TelegramChannel(
channel_name, channel_id,
handler_logger.getChild(TelegramChannel.__name__),
telegram_bot)
cmd_handlers_logger = handler_logger.getChild(
TelegramCommandHandlers.__name__)
cmd_handlers_rabbitmq = RabbitMQApi(
logger=cmd_handlers_logger.getChild(RabbitMQApi.__name__),
host=env.RABBIT_IP)
cmd_handlers_redis = RedisApi(
logger=cmd_handlers_logger.getChild(RedisApi.__name__),
host=env.REDIS_IP,
db=env.REDIS_DB,
port=env.REDIS_PORT,
namespace=env.UNIQUE_ALERTER_IDENTIFIER)
cmd_handlers_mongo = MongoApi(logger=cmd_handlers_logger.getChild(
MongoApi.__name__),
host=env.DB_IP,
db_name=env.DB_NAME,
port=env.DB_PORT)
cmd_handlers = TelegramCommandHandlers(
TELEGRAM_COMMAND_HANDLERS_NAME, cmd_handlers_logger,
associated_chains, telegram_channel, cmd_handlers_rabbitmq,
cmd_handlers_redis, cmd_handlers_mongo)
handler_rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
telegram_commands_handler = TelegramCommandsHandler(
handler_display_name, handler_logger, handler_rabbitmq,
telegram_channel, cmd_handlers)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return telegram_commands_handler
def _initialise_alert_router() -> Tuple[AlertRouter, logging.Logger]:
display_name = ALERT_ROUTER_NAME
# Try initialising the logger until successful. This had to be done
# separately to avoid instances when the logger creation failed and we
# attempt to use it.
while True:
try:
alert_router_logger = create_logger(env.ALERT_ROUTER_LOG_FILE,
AlertRouter.__name__,
env.LOGGING_LEVEL,
rotating=True)
break
except Exception as e:
# Use a dummy logger in this case because we cannot create the
# manager's logger.
dummy_logger = logging.getLogger('DUMMY_LOGGER')
log_and_print(get_initialisation_error_message(display_name, e),
dummy_logger)
log_and_print(get_reattempting_message(display_name), dummy_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
rabbit_ip = env.RABBIT_IP
redis_ip = env.REDIS_IP
redis_db = env.REDIS_DB
redis_port = env.REDIS_PORT
unique_alerter_identifier = env.UNIQUE_ALERTER_IDENTIFIER
while True:
try:
alert_router = AlertRouter(display_name, alert_router_logger,
rabbit_ip, redis_ip, redis_db,
redis_port, unique_alerter_identifier,
env.ENABLE_CONSOLE_ALERTS,
env.ENABLE_LOG_ALERTS)
return alert_router, alert_router_logger
except Exception as e:
log_and_print(get_initialisation_error_message(display_name, e),
alert_router_logger)
log_and_print(get_reattempting_message(display_name),
alert_router_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
def _initialise_alerts_logger() -> logging.Logger:
# Try initialising the logger until successful. This had to be done
# separately to avoid instances when the logger creation failed and we
# attempt to use it.
while True:
try:
alerts_logger = create_logger(env.ALERTS_LOG_FILE, 'Alerts',
env.LOGGING_LEVEL, True)
break
except Exception as e:
msg = get_initialisation_error_message('Alerts Log File', e)
# Use a dummy logger in this case because we cannot create the
# logger.
log_and_print(msg, logging.getLogger('DUMMY_LOGGER'))
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return alerts_logger
def _initialise_email_alerts_handler(smtp: str,
email_from: str,
emails_to: List[str],
channel_id: str,
channel_name: str,
username: Optional[str],
password: Optional[str],
port: int = 0) -> EmailAlertsHandler:
# Handler display name based on channel name
handler_display_name = EMAIL_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, EmailAlertsHandler.__name__)
# Try initialising handler until successful
while True:
try:
email_api = EmailApi(smtp, email_from, username, password, port)
email_channel = EmailChannel(
channel_name, channel_id,
handler_logger.getChild(EmailChannel.__name__), emails_to,
email_api)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
email_alerts_handler = EmailAlertsHandler(
handler_display_name, handler_logger, rabbitmq, email_channel,
env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return email_alerts_handler
def _initialise_store_logger(
store_display_name: str, store_module_name: str) -> logging.Logger:
# Try initialising the logger until successful. This had to be done
# separately to avoid instances when the logger creation failed and we
# attempt to use it.
while True:
try:
store_logger = create_logger(
env.DATA_STORE_LOG_FILE_TEMPLATE.format(store_display_name),
store_module_name, env.LOGGING_LEVEL, rotating=True)
break
except Exception as e:
msg = get_initialisation_error_message(store_display_name, e)
# Use a dummy logger in this case because we cannot create the
# transformer's logger.
log_and_print(msg, logging.getLogger('DUMMY_LOGGER'))
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return store_logger
def _initialise_store(store_type: Type[T], store_display_name: str) -> T:
store_logger = _initialise_store_logger(store_display_name,
store_type.__name__)
# Try initialising the store until successful
while True:
try:
rabbitmq = RabbitMQApi(
logger=store_logger.getChild(RabbitMQApi.__name__),
host=env.RABBIT_IP)
store = store_type(store_display_name, store_logger, rabbitmq)
log_and_print("Successfully initialised {}".format(
store_display_name), store_logger)
break
except Exception as e:
msg = get_initialisation_error_message(store_display_name, e)
log_and_print(msg, store_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return store
def _initialise_transformer_redis(
transformer_name: str, transformer_logger: logging.Logger) -> RedisApi:
# Try initialising the Redis API until successful. This had to be done
# separately to avoid instances when Redis creation failed and we
# attempt to use it.
while True:
try:
redis = RedisApi(logger=transformer_logger.getChild(
RedisApi.__name__),
db=env.REDIS_DB,
host=env.REDIS_IP,
port=env.REDIS_PORT,
namespace=env.UNIQUE_ALERTER_IDENTIFIER)
break
except Exception as e:
msg = get_initialisation_error_message(transformer_name, e)
log_and_print(msg, transformer_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return redis
def _initialise_health_checker_manager() -> HealthCheckerManager:
manager_display_name = HEALTH_CHECKER_MANAGER_NAME
health_checker_manager_logger = _initialise_logger(
manager_display_name, HealthCheckerManager.__name__,
env.MANAGERS_LOG_FILE_TEMPLATE)
# Attempt to initialise the health checker manager
while True:
try:
health_checker_manager = HealthCheckerManager(
health_checker_manager_logger, manager_display_name)
break
except Exception as e:
msg = get_initialisation_error_message(manager_display_name, e)
log_and_print(msg, health_checker_manager_logger)
log_and_print(get_reattempting_message(manager_display_name),
health_checker_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return health_checker_manager
def _initialise_heartbeat_handler() -> HeartbeatHandler:
component_display_name = HEARTBEAT_HANDLER_NAME
logger = _initialise_health_checker_logger(component_display_name,
HeartbeatHandler.__name__)
redis = _initialise_component_redis(component_display_name, logger)
# Try initialising the heartbeat handler until successful
while True:
try:
heartbeat_handler = HeartbeatHandler(logger, redis,
component_display_name)
log_and_print(
"Successfully initialised {}".format(component_display_name),
logger)
break
except Exception as e:
msg = get_initialisation_error_message(component_display_name, e)
log_and_print(msg, logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return heartbeat_handler
def _initialise_ping_publisher() -> PingPublisher:
component_display_name = PING_PUBLISHER_NAME
logger = _initialise_health_checker_logger(component_display_name,
PingPublisher.__name__)
redis = _initialise_component_redis(component_display_name, logger)
# Try initialising the ping publisher until successful
while True:
try:
ping_publisher = PingPublisher(30, logger, redis,
component_display_name)
log_and_print(
"Successfully initialised {}".format(component_display_name),
logger)
break
except Exception as e:
msg = get_initialisation_error_message(component_display_name, e)
log_and_print(msg, logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return ping_publisher
def _initialise_config_manager() -> Tuple[ConfigsManager, logging.Logger]:
display_name = CONFIGS_MANAGER_NAME
config_manager_logger = _initialise_logger(display_name,
ConfigsManager.__name__,
env.CONFIG_MANAGER_LOG_FILE)
rabbit_ip = env.RABBIT_IP
while True:
try:
config_manager = ConfigsManager(display_name,
config_manager_logger, '../config',
rabbit_ip)
return config_manager, config_manager_logger
except Exception as e:
# This is already logged, we need to try again. This exception
# should not happen, but if it does the program can't fully start
# up
log_and_print(get_initialisation_error_message(display_name, e),
config_manager_logger)
log_and_print(get_reattempting_message(display_name),
config_manager_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
def _initialise_telegram_alerts_handler(
bot_token: str, bot_chat_id: str, channel_id: str,
channel_name: str) -> TelegramAlertsHandler:
# Handler display name based on channel name
handler_display_name = TELEGRAM_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, TelegramAlertsHandler.__name__)
# Try initialising handler until successful
while True:
try:
telegram_bot = TelegramBotApi(bot_token, bot_chat_id)
telegram_channel = TelegramChannel(
channel_name, channel_id,
handler_logger.getChild(TelegramChannel.__name__),
telegram_bot)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
telegram_alerts_handler = TelegramAlertsHandler(
handler_display_name, handler_logger, rabbitmq,
telegram_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return telegram_alerts_handler
def _initialise_opsgenie_alerts_handler(
api_key: str, eu_host: bool, channel_id: str,
channel_name: str) -> OpsgenieAlertsHandler:
# Handler display name based on channel name
handler_display_name = OPSGENIE_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, OpsgenieAlertsHandler.__name__)
# Try initialising handler until successful
while True:
try:
opsgenie_api = OpsgenieApi(api_key, eu_host)
opsgenie_channel = OpsgenieChannel(
channel_name, channel_id,
handler_logger.getChild(OpsgenieChannel.__name__),
opsgenie_api)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
opsgenie_alerts_handler = OpsgenieAlertsHandler(
handler_display_name, handler_logger, rabbitmq,
opsgenie_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return opsgenie_alerts_handler
def _initialise_pagerduty_alerts_handler(
integration_key: str, channel_id: str,
channel_name: str) -> PagerDutyAlertsHandler:
# Handler display name based on channel name
handler_display_name = PAGERDUTY_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, PagerDutyAlertsHandler.__name__)
# Try initialising handler until successful
while True:
try:
pagerduty_api = PagerDutyApi(integration_key)
pagerduty_channel = PagerDutyChannel(
channel_name, channel_id,
handler_logger.getChild(PagerDutyChannel.__name__),
pagerduty_api)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
pagerduty_alerts_handler = PagerDutyAlertsHandler(
handler_display_name, handler_logger, rabbitmq,
pagerduty_channel, env.CHANNELS_MANAGER_PUBLISHING_QUEUE_SIZE)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return pagerduty_alerts_handler
def _initialise_twilio_alerts_handler(
account_sid: str, auth_token: str, channel_id: str, channel_name: str,
call_from: str, call_to: List[str], twiml: str, twiml_is_url: bool) \
-> TwilioAlertsHandler:
# Handler display name based on channel name
handler_display_name = TWILIO_ALERTS_HANDLER_NAME_TEMPLATE.format(
channel_name)
handler_logger = _initialise_channel_handler_logger(
handler_display_name, TwilioAlertsHandler.__name__)
# Try initialising handler until successful
while True:
try:
twilio_api = TwilioApi(account_sid, auth_token)
twilio_channel = TwilioChannel(
channel_name, channel_id,
handler_logger.getChild(TwilioChannel.__name__), twilio_api)
rabbitmq = RabbitMQApi(logger=handler_logger.getChild(
RabbitMQApi.__name__),
host=env.RABBIT_IP)
twilio_alerts_handler = TwilioAlertsHandler(
handler_display_name, handler_logger, rabbitmq, twilio_channel,
call_from, call_to, twiml, twiml_is_url)
log_and_print(
"Successfully initialised {}".format(handler_display_name),
handler_logger)
break
except Exception as e:
msg = get_initialisation_error_message(handler_display_name, e)
log_and_print(msg, handler_logger)
# sleep before trying again
time.sleep(RE_INITIALISE_SLEEPING_PERIOD)
return twilio_alerts_handler
