def get_periodic_alive_reminder_channel_set(
channel_name: str,
logger_general: logging.Logger,
redis: Optional[RedisApi],
alerts_log_file: str,
mongo: Optional[MongoApi],
internal_conf: InternalConfig = InternalConf,
user_conf: UserConfig = UserConf) -> ChannelSet:
# Initialise list of channels with default channels
channels = [
_get_console_channel(channel_name, logger_general),
_get_log_channel(alerts_log_file, channel_name, logger_general,
internal_conf)
]
# Initialise backup channel sets with default channels
backup_channels_for_telegram = ChannelSet(channels)
backup_channels_for_mongo = ChannelSet(channels)
# Add telegram alerts to channel set if they are enabled from config file
if user_conf.telegram_alerts_enabled and \
user_conf.par_telegram_enabled:
telegram_channel = _get_telegram_channel(channel_name, logger_general,
redis,
backup_channels_for_telegram,
user_conf)
channels.append(telegram_channel)
else:
telegram_channel = None
# Add email alerts to channel set if they are enabled from config file
if user_conf.email_alerts_enabled and \
user_conf.par_email_enabled:
email_channel = _get_email_channel(channel_name, logger_general, redis,
user_conf)
channels.append(email_channel)
else:
email_channel = None
# Add mongo alerts to channel set if they are enabled from config file
if user_conf.mongo_enabled:
mongo_channel = _get_mongo_channel(channel_name, logger_general, redis,
mongo, backup_channels_for_mongo)
channels.append(mongo_channel)
else:
# noinspection PyUnusedLocal
mongo_channel = None
# Set up email channel as backup channel for telegram, mongo
if email_channel is not None:
backup_channels_for_telegram.add_channel(email_channel)
backup_channels_for_mongo.add_channel(email_channel)
# Set up telegram channel as backup channel for mongo
if telegram_channel is not None:
backup_channels_for_mongo.add_channel(telegram_channel)
return ChannelSet(channels)
def setUp(self) -> None:
self.alerter_name = 'testalerter'
self.logger = logging.getLogger('dummy')
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.par = PeriodicAliveReminder(timedelta(), self.channel_set, None)
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testmonitor'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel])
self.repo_name = 'dummy/repository/'
self.releases_page = 'dummy.releases.page'
self.redis_prefix = TestInternalConf.redis_github_releases_key_prefix
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.redis = RedisApi(self.logger, self.db, self.host,
self.port, self.password)
self.redis.delete_all_unsafe()
try:
self.redis.ping_unsafe()
except RedisConnectionError:
self.fail('Redis is not online.')
self.monitor = GitHubMonitor(self.monitor_name, self.channel_set,
self.logger, self.redis, self.repo_name,
self.releases_page, self.redis_prefix)
self.monitor._internal_conf = TestInternalConf
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testblockchainmonitor'
self.blockchain_name = 'testblockchain'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.redis = RedisApi(self.logger, self.db, self.host, self.port,
self.password)
self.redis.delete_all_unsafe()
try:
self.redis.ping_unsafe()
except RedisConnectionError:
self.fail('Redis is not online.')
self.data_sources = []
self.blockchain = Blockchain(self.blockchain_name, self.redis)
self.polkadot_api_endpoint = 'api_endpoint'
self.monitor = BlockchainMonitor(self.monitor_name, self.blockchain,
self.channel_set, self.logger,
self.redis, self.data_sources,
self.polkadot_api_endpoint,
TestInternalConf)
self.redis_alive_key_timeout = \
TestInternalConf.redis_blockchain_monitor_alive_key_timeout
self.alive_key_timeout = \
TestInternalConf.redis_blockchain_monitor_alive_key_timeout
def setUp(self) -> None:
self.blockchain_name = 'testblockchain'
self.redis_prefix = self.blockchain_name
self.logger = logging.getLogger('dummy')
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel])
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.redis = RedisApi(self.logger, self.db, self.host, self.port,
self.password)
self.redis.delete_all_unsafe()
try:
self.redis.ping_unsafe()
except RedisConnectionError:
self.fail('Redis is not online.')
self.blockchain = Blockchain(self.blockchain_name, self.redis)
self.dummy_referendum_count = 10
self.dummy_council_prop_count = 10
self.dummy_public_prop_count = 10
self.dummy_validator_set_size = 120
def setUp(self) -> None:
self.blockchain_name = 'testblockchain'
self.logger = logging.getLogger('dummy')
self.blockchain = Blockchain(name=self.blockchain_name, redis=None)
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.dummy_referendum_count, self.dummy_public_prop_count, \
self.dummy_council_prop_count = 10, 10, 10
self.dummy_validator_set_size = 120
self.dummy_referendum_info_ongoing = {
'Ongoing': {
'proposalHash': '0x345jtg8ergfg8df89h9we9t9sd9g9gsd9g9sdfg',
'end': 124143848,
'threshold': 'Supermajorityapproval',
'delay': 11549,
'tally': {
'ayes': '4544545 KSM',
'nayes': '3454 KSM',
'turnout': '4545454454 KSM'
}
}
}
self.dummy_referendum_info_finished = {
'Finished': {
'approved': False,
'end': 124143848
}
}
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testnodemonitor'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.redis = RedisApi(self.logger, self.db, self.host, self.port,
self.password)
self.redis.delete_all_unsafe()
try:
self.redis.ping_unsafe()
except RedisConnectionError:
self.fail('Redis is not online.')
self.node_monitor_max_catch_up_blocks = \
TestInternalConf.node_monitor_max_catch_up_blocks
self.node = None
self.archive_alerts_disabled = False
self.data_sources = []
self.monitor = NodeMonitor(self.monitor_name, self.channel_set,
self.logger,
self.node_monitor_max_catch_up_blocks,
self.redis, self.node,
self.archive_alerts_disabled,
self.data_sources, TestInternalConf)
self.dummy_last_height_checked = 1000
self.redis_alive_key_timeout = \
TestInternalConf.redis_node_monitor_alive_key_timeout
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.wrapper = PolkadotApiWrapper(self.logger, self.api_endpoint)
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.params = {'websocket': self.ws_url}
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testblockchainmonitor'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.redis = None
self.data_sources = []
self.polkadot_api_endpoint = 'api_endpoint'
self.dummy_ws_url_1 = "11.22.33.11:9944"
self.dummy_ws_url_2 = "11.22.33.12:9944"
self.dummy_ws_url_3 = "11.22.33.13:9944"
self.dummy_ws_url_4 = "11.22.33.14:9944"
self.dummy_node_name_1 = "testnode1"
self.dummy_node_name_2 = "testnode2"
self.dummy_node_name_3 = "testnode3"
self.dummy_node_name_4 = "testnode4"
self.dummy_chain_name = "testchain"
self.validator_stash_account_address = "DFJGDF8G898fdghb98dg9wetg9we00w"
self.dummy_full_node_1 = Node(name=self.dummy_node_name_1,
ws_url=self.dummy_ws_url_1,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
stash_account_address='',
chain=self.dummy_chain_name, redis=None,
is_archive_node=True,
internal_conf=TestInternalConf)
self.dummy_full_node_2 = Node(name=self.dummy_node_name_2,
ws_url=self.dummy_ws_url_2,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
stash_account_address='',
chain=self.dummy_chain_name, redis=None,
is_archive_node=True,
internal_conf=TestInternalConf)
self.dummy_full_node_3 = Node(name=self.dummy_node_name_3,
ws_url=self.dummy_ws_url_3,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
stash_account_address='',
chain=self.dummy_chain_name, redis=None,
is_archive_node=True,
internal_conf=TestInternalConf)
self.dummy_validator_node_1 = Node(
name=self.dummy_node_name_4, ws_url=self.dummy_ws_url_4,
node_type=NodeType.VALIDATOR_FULL_NODE,
stash_account_address=self.validator_stash_account_address,
chain=self.dummy_chain_name, redis=None, is_archive_node=False,
internal_conf=TestInternalConf)
self.dummy_blockchain = Blockchain(self.dummy_chain_name, None)
self.monitor = BlockchainMonitor(self.monitor_name,
self.dummy_blockchain,
self.channel_set, self.logger,
self.redis, self.data_sources,
self.polkadot_api_endpoint,
TestInternalConf)
self.dummy_referendum_count = 10
self.dummy_public_prop_count = 10
self.dummy_council_prop_count = 10
self.dummy_validator_set_size = 120
def setUp(self) -> None:
self.alerter_name = 'testalerter'
self.logger = logging.getLogger('dummy')
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel])
self.mute_key = TestInternalConf.redis_periodic_alive_reminder_mute_key
self.par = PeriodicAliveReminder(timedelta(), self.channel_set,
self.mute_key, None)
def setUp(self) -> None:
self.alerter_name = 'testalerter'
self.logger = logging.getLogger('dummy')
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel],
TestInternalConfSomeAlertsDisabled)
self.dummy_alert = Alert(AlertCode.TestAlert, 'dummy')
self.severities_map_bkp = \
TestInternalConfSomeAlertsDisabled.severities_enabled_map.copy()
self.alerts_map_bkp = \
TestInternalConfSomeAlertsDisabled.alerts_enabled_map.copy()
def setUp(self) -> None:
self.blockchain_name = 'testblockchain'
self.logger = logging.getLogger('dummy')
self.blockchain = Blockchain(name=self.blockchain_name, redis=None)
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel])
self.dummy_referendum_count, self.dummy_public_prop_count, \
self.dummy_council_prop_count = 10, 10, 10
self.dummy_validator_set_size = 120
self.dummy_referendum_info = {'end': '8568'}
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.node_name = 'dummy_node'
self.wrapper = OasisApiWrapper(self.logger)
self.max_time = 15
self.max_time_less = self.max_time - 10
self.max_time_more = self.max_time + 2
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.params = {'name': self.node_name}
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testmonitor'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.repo_name = 'dummy/repository/'
self.releases_page = 'dummy.releases.page'
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.monitor = GitHubMonitor(self.monitor_name, self.channel_set,
self.logger, None, self.repo_name,
self.releases_page)
self.monitor._internal_conf = TestInternalConf
def setUp(self) -> None:
self.alerter_name = 'testalerter'
self.logger = logging.getLogger('dummy')
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.db = TestInternalConf.redis_test_database
self.host = TestUserConf.redis_host
self.port = TestUserConf.redis_port
self.password = TestUserConf.redis_password
self.redis = RedisApi(self.logger, self.db, self.host, self.port,
self.password)
self.redis.delete_all_unsafe()
try:
self.redis.ping_unsafe()
except RedisConnectionError:
self.fail('Redis is not online.')
self.par = PeriodicAliveReminder(timedelta(), self.channel_set,
self.redis)
def setUp(self) -> None:
self.logger = logging.getLogger('dummy')
self.monitor_name = 'testnodemonitor'
self.counter_channel = CounterChannel(self.logger)
self.channel_set = ChannelSet([self.counter_channel], TestInternalConf)
self.node_monitor_max_catch_up_blocks = \
TestInternalConf.node_monitor_max_catch_up_blocks
self.redis = None
self.archive_alerts_disabled = False
self.data_sources = []
self.chain = 'testchain'
self.full_node_name = 'testfullnode'
self.full_node_api_url = '123.123.123.11:9944'
self.full_node_consensus_key = "ANDSAdisadjasdaANDAsa"
self.full_node_tendermint_key = "ASFLNAFIISDANNSDAKKS2313AA"
self.full_node_entity_public_key = "a98dabsfkjabfkjabsf9j"
self.full_node_staking_address = "asdsasdsdsaasdsdaswwad"
self.full_node = Node(
self.full_node_name, self.full_node_api_url, None,
NodeType.NON_VALIDATOR_FULL_NODE, '', self.chain, None, True,
self.full_node_consensus_key, self.full_node_tendermint_key,
self.full_node_staking_address, self.full_node_entity_public_key,
TestInternalConf)
self.full_node_monitor = NodeMonitor(
self.monitor_name, self.channel_set, self.logger,
self.node_monitor_max_catch_up_blocks, self.redis, self.full_node,
self.archive_alerts_disabled, self.data_sources, TestInternalConf)
self.validator_name = 'testvalidator'
self.validator_api_url = '13.13.14.11:9944'
self.validator_consensus_key = "KASDB01923udlakd19sad"
self.validator_tendermint_key = "ALSFNF9)901jjelakNALKNDLKA"
self.validator_node_public_key = "DFJGDF8G898fdghb98dg9wetg9we00w"
self.validator_node_entity_public_key = "s12adsdghas9as0sa9dhnaskdlan"
self.validator_node_staking_address = "jujuujsmjmsjmaklzsdjsdnanz"
self.validator = Node(
self.validator_name, self.validator_api_url, None,
NodeType.VALIDATOR_FULL_NODE, self.validator_node_public_key,
self.chain, None, True, self.validator_consensus_key,
self.validator_tendermint_key, self.validator_node_staking_address,
self.validator_node_entity_public_key, TestInternalConf)
self.validator_monitor = NodeMonitor(
self.monitor_name, self.channel_set, self.logger,
self.node_monitor_max_catch_up_blocks, self.redis, self.validator,
self.archive_alerts_disabled, self.data_sources, TestInternalConf)
self.dummy_last_height_checked = 1000
self.dummy_bonded_balance = scale_to_giga(5)
self.dummy_debonding_balance = scale_to_giga(5)
self.dummy_shares_balance = scale_to_giga(5)
self.dummy_height_to_check = 1000
self.dummy_no_of_peers = 100
self.dummy_is_missing_blocks = False
self.dummy_active = True
self.dummy_finalized_block_height = 34535
self.dummy_api_url_1 = "11.22.33.11:9944"
self.dummy_api_url_2 = "11.22.33.12:9944"
self.dummy_api_url_3 = "11.22.33.13:9944"
self.dummy_api_url_4 = "11.22.33.14:9944"
self.dummy_api_url_5 = "11.22.33.15:9944"
self.dummy_node_name_1 = "testnode1"
self.dummy_node_name_2 = "testnode2"
self.dummy_node_name_3 = "testnode3"
self.dummy_node_name_4 = "testnode4"
self.dummy_node_name_5 = "testnode5"
self.dummy_validator_node_name_2 = "testvalidatornode2"
self.dummy_validator_node_name_3 = "testvalidatornode3"
self.dummy_node_consensus_key_1 = "consensus_key_1"
self.dummy_node_consensus_key_2 = "consensus_key_2"
self.dummy_node_consensus_key_3 = "consensus_key_3"
self.dummy_node_tendermint_key_1 = "consensus_key_1"
self.dummy_node_tendermint_key_2 = "consensus_key_2"
self.dummy_node_tendermint_key_3 = "consensus_key_3"
self.dummy_node_entity_public_key_1 = "entity_key_1"
self.dummy_node_entity_public_key_2 = "entity_key_2"
self.dummy_node_entity_public_key_3 = "entity_key_3"
self.dummy_node_staking_address_1 = "staking-key_1"
self.dummy_node_staking_address_2 = "staking_key_2"
self.dummy_node_staking_address_3 = "staking_key_3"
self.dummy_full_node_1 = Node(
name=self.dummy_node_name_1,
api_url=self.dummy_api_url_1,
prometheus_endpoint=None,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
node_public_key='',
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key='',
tendermint_address_key='',
staking_address='',
entity_public_key='',
internal_conf=TestInternalConf)
self.dummy_full_node_2 = Node(
name=self.dummy_node_name_2,
api_url=self.dummy_api_url_2,
prometheus_endpoint=None,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
node_public_key='',
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key='',
tendermint_address_key='',
staking_address='',
entity_public_key='',
internal_conf=TestInternalConf)
self.dummy_full_node_3 = Node(
name=self.dummy_node_name_3,
api_url=self.dummy_api_url_3,
prometheus_endpoint=None,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
node_public_key='',
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key='',
tendermint_address_key='',
staking_address='',
entity_public_key='',
internal_conf=TestInternalConf)
self.dummy_full_node_4 = Node(
name=self.dummy_node_name_5,
api_url=self.dummy_api_url_5,
prometheus_endpoint=None,
node_type=NodeType.NON_VALIDATOR_FULL_NODE,
node_public_key='',
chain=self.chain,
redis=None,
is_archive_node=False,
consensus_public_key='',
tendermint_address_key='',
staking_address='',
entity_public_key='',
internal_conf=TestInternalConf)
self.dummy_take_event_owner = {
"escrow": {
"take": {
"owner": self.dummy_node_entity_public_key_1,
"tokens": "2000000000"
}
}
}
self.dummy_validator_node_1 = Node(
name=self.dummy_node_name_4,
api_url=self.dummy_api_url_4,
prometheus_endpoint=None,
node_type=NodeType.VALIDATOR_FULL_NODE,
node_public_key=self.validator_node_public_key,
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key=self.dummy_node_consensus_key_1,
tendermint_address_key=self.dummy_node_tendermint_key_1,
staking_address=self.dummy_node_staking_address_1,
entity_public_key=self.dummy_node_entity_public_key_1,
internal_conf=TestInternalConf)
self.dummy_validator_node_2 = Node(
name=self.dummy_validator_node_name_2,
api_url=self.dummy_api_url_4,
prometheus_endpoint=None,
node_type=NodeType.VALIDATOR_FULL_NODE,
node_public_key=self.validator_node_public_key,
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key=self.dummy_node_consensus_key_2,
tendermint_address_key=self.dummy_node_tendermint_key_2,
staking_address=self.dummy_node_staking_address_2,
entity_public_key=self.dummy_node_entity_public_key_2,
internal_conf=TestInternalConf)
self.dummy_validator_node_3 = Node(
name=self.dummy_validator_node_name_3,
api_url=self.dummy_api_url_4,
prometheus_endpoint=None,
node_type=NodeType.VALIDATOR_FULL_NODE,
node_public_key=self.validator_node_public_key,
chain=self.chain,
redis=None,
is_archive_node=True,
consensus_public_key=self.dummy_node_consensus_key_3,
tendermint_address_key=self.dummy_node_tendermint_key_3,
staking_address=self.dummy_node_staking_address_3,
entity_public_key=self.dummy_node_entity_public_key_3,
internal_conf=TestInternalConf)
