def monitor_direct(self) -> None:
# Check if node is accessible
self._logger.debug('Checking if %s is alive', self._node)
self._data_wrapper.ping_node(self._node.ws_url)
self._node.set_as_up(self.channels, self.logger)
# Get system_health
system_health = self.data_wrapper.get_system_health(self._node.ws_url)
# Get finalized block header
finalized_head = self.data_wrapper.get_finalized_head(self.node.ws_url)
finalized_block_header = self.data_wrapper.get_header(
self.node.ws_url, finalized_head)
# Set is-syncing
is_syncing = system_health['isSyncing']
self._logger.debug('%s is syncing: %s', self._node, is_syncing)
self._node.set_is_syncing(is_syncing, self.channels, self.logger)
# Set number of peers
no_of_peers = system_health['peers']
self._logger.debug('%s no. of peers: %s', self._node, no_of_peers)
self._node.set_no_of_peers(no_of_peers, self.channels, self.logger)
# Update finalized block
finalized_block_height = parse_int_from_string(
str(finalized_block_header['number']))
self._logger.debug('%s finalized_block_height: %s', self._node,
finalized_block_height)
self._node.update_finalized_block_height(finalized_block_height,
self.logger, self.channels)
# Set API as up
self.data_wrapper.set_api_as_up(self.monitor_name, self.channels)
def monitor(self) -> None:
# Get new data.
new_referendum_count = parse_int_from_string(
str(
self._data_wrapper.get_referendum_count(
self.data_source.ws_url)))
new_council_prop_count = parse_int_from_string(
str(
self._data_wrapper.get_council_proposal_count(
self.data_source.ws_url)))
new_public_prop_count = parse_int_from_string(
str(
self._data_wrapper.get_public_proposal_count(
self.data_source.ws_url)))
session_validators = self._data_wrapper.get_session_validators(
self.data_source.ws_url)
new_validator_set_size = len(session_validators)
# Check for referendums
self._logger.debug('%s referendum_count: %s', self.blockchain,
new_referendum_count)
self._check_for_new_referendums(new_referendum_count)
# Set council prop count
self._logger.debug('%s council_prop_count: %s', self.blockchain,
new_council_prop_count)
self.blockchain.set_council_prop_count(new_council_prop_count,
self.channels, self.logger)
# Set public prop count
self._logger.debug('%s public_prop_count: %s', self.blockchain,
new_public_prop_count)
self.blockchain.set_public_prop_count(new_public_prop_count,
self.channels, self.logger)
# Set validator set size
self._logger.debug('%s validator_set_size: %s', self.blockchain,
new_validator_set_size)
self.blockchain.set_validator_set_size(new_validator_set_size,
self.channels, self.logger)
# Set API as up and declare the used node as connected with the API
self.data_wrapper.set_api_as_up(self.monitor_name, self.channels)
self.last_data_source_used.connect_with_api(self.channels, self.logger)
self.logger.info('%s status: %s', self._monitor_name, self.status())
def set_referendum_count(self, new_referendum_count: int,
channels: ChannelSet, logger: logging.Logger,
referendum_info: PolkadotWrapperType = None) \
-> None:
logger.debug('%s set_referendum_count: referendum_count(currently)=%s, '
'channels=%s', self, self.referendum_count, channels)
# If referendum is new and still ongoing, alert the operator.
if self._referendum_count not in [None, new_referendum_count] \
and referendum_info is not None:
if 'Ongoing' in referendum_info:
end_block = parse_int_from_string(str(
referendum_info['Ongoing']['end']
))
channels.alert_info(NewReferendumAlert(
self.referendum_count, end_block)
)
self._referendum_count = new_referendum_count
def monitor_direct(self) -> None:
# Check if node is accessible
self._logger.debug('Checking if %s is alive', self._node)
self._data_wrapper.ping_node(self._node.api_url, self._node.name)
self._node.set_as_up(self.channels, self.logger)
# Get isSyncing Status
is_syncing = not self.data_wrapper.get_is_syncing(
self._node.api_url, self._node.name)
self._logger.debug('%s is syncing: %s', self._node, is_syncing)
self._node.set_is_syncing(is_syncing, self.channels, self.logger)
# Set number of peers
no_of_peers = self.data_wrapper.get_prometheus_gauge(
self._node.api_url, self._node.name, "tendermint_p2p_peers")
self._logger.debug('%s no. of peers: %s', self._node, no_of_peers)
self._node.set_no_of_peers(int(float(no_of_peers)), self.channels,
self.logger)
# Update finalized block height
finalized_block_header = self.data_wrapper.get_block_header(
self._node.api_url, self._node.name)
# Update finalized block
finalized_block_height = parse_int_from_string(
str(finalized_block_header['height']))
self._logger.debug('%s finalized_block_height: %s', self._node,
finalized_block_height)
self._node.update_finalized_block_height(finalized_block_height,
self.logger, self.channels)
# Set API as up, and declare that node was connected to the API
self.data_wrapper.set_api_as_up(self.monitor_name, self.channels)
self.node.connect_with_api(self.channels, self.logger)
def _monitor_indirect_validator(self) -> None:
session_validators = self.data_wrapper.get_session_validators(
self.data_source_indirect.ws_url)
stakers_json = self.data_wrapper.get_stakers(
self.data_source_indirect.ws_url, self._node.stash_account_address)
council_members = self.data_wrapper.get_council_members(
self.data_source_indirect.ws_url)
elected_validators = self.data_wrapper.get_current_elected(
self.data_source_indirect.ws_url)
new_session_index = self.data_wrapper.get_current_index(
self.data_source_indirect.ws_url)
new_number_of_blocks_authored = self.data_wrapper. \
get_authored_blocks(self.data_source_indirect.ws_url,
new_session_index,
self.node.stash_account_address)
disabled_validators = self.data_wrapper.get_disabled_validators(
self.data_source_indirect.ws_url)
# Set active
is_active = self._node.stash_account_address in session_validators
self._logger.debug('%s active: %s', self._node, is_active)
self.node.set_active(is_active, self.channels, self.logger)
# Set auth_index
if self._node.is_active:
new_auth_index = session_validators.index(
self.node.stash_account_address)
self._logger.debug('%s auth_index: %s', self._node, new_auth_index)
self._node.set_auth_index(new_auth_index, self.logger)
# Set disabled
is_disabled = self.node.auth_index in disabled_validators
self._logger.debug('%s disabled: %s', self._node, is_disabled)
self.node.set_disabled(is_disabled, new_session_index, self.channels,
self.logger)
# Set elected
is_elected = self._node.stash_account_address in elected_validators
self._logger.debug('%s elected: %s', self._node, is_elected)
self.node.set_elected(is_elected, self.channels, self.logger)
# Set bonded_balance
bonded_balance = parse_int_from_string(str(stakers_json['total']))
self._logger.debug('%s bonded_balance: %s', self._node, bonded_balance)
self._node.set_bonded_balance(bonded_balance, self.channels,
self.logger)
# Set council_member
is_council_member = self._node.stash_account_address in council_members
self._logger.debug('%s is council member: %s', self._node,
is_council_member)
self.node.set_council_member(is_council_member, self.channels,
self.logger)
# Set session index
self._check_for_new_session(new_session_index)
# Set number of blocks authored
self._logger.debug('%s number_of_blocks_authored: %s', self._node,
new_number_of_blocks_authored)
self._node.set_no_of_blocks_authored(self.channels, self.logger,
new_number_of_blocks_authored,
self._session_index)
if not self._archive_alerts_disabled:
self._monitor_archive_state()
def test_parse_int_from_str_returns_as_expected_when_given_hex_val_non_0(
self) -> None:
self.assertEqual(15, parse_int_from_string("0xF"))
def test_parse_int_from_str_returns_as_expected_when_given_val_0(
self) -> None:
self.assertEqual(0, parse_int_from_string("0"))
def _monitor_indirect_validator(self) -> None:
# Get dictionary of validators at current block height
session_validators = self.data_wrapper.get_session_validators(
self.data_source_indirect.api_url, self.data_source_indirect.name)
# Attempt to return validator from list of session_validators
validator_data = list(
filter(
lambda validator: validator['id'] == self._node.
node_public_key, session_validators))
is_active = False if len(validator_data) == 0 else True
self._logger.debug('%s active: %s', self._node, is_active)
self.node.set_active(is_active, self.channels, self.logger)
voting_power = 0 if is_active == False \
else validator_data[0]['voting_power']
self._logger.debug('%s voting power: %s', self.node, voting_power)
self.node.set_voting_power(int(voting_power), self.channels,
self.logger)
# Get node status and from that the last height to be checked
latestblock = self.data_wrapper.get_consensus_block(
self.data_source_indirect.api_url, self.data_source_indirect.name)
# The Precommits(Signatures) are of the block before
last_height_to_check = int(latestblock['height'])
# If the chain has not started, return as there are no blocks to get
if last_height_to_check == 0:
return
# If this is the first height being checked, ignore previous heights
if self._last_height_checked == NONE:
self._last_height_checked = last_height_to_check - 1
# Consider any height that is after the previous last height
height = self._last_height_checked
if last_height_to_check - self._last_height_checked > \
self._node_monitor_max_catch_up_blocks:
height = last_height_to_check - \
self._node_monitor_max_catch_up_blocks
self._check_block(height)
self._check_events(height, None)
self._last_height_checked = height
elif height <= last_height_to_check:
self._check_block(height)
self._check_events(height, None)
self._last_height_checked = height
if last_height_to_check - self._last_height_checked > 2:
self._monitor_is_catching_up = True
else:
self._monitor_is_catching_up = False
# Retrieve the bonding balance and set it
staking_account = self.data_wrapper.get_staking_account(
self.data_source_indirect.api_url, self.data_source_indirect.name,
self._node.staking_address)
bonded_balance = parse_int_from_string(
str(staking_account['escrow']['active']['balance']))
self._logger.debug('%s bonded_balance: %s', self._node, bonded_balance)
self._node.set_bonded_balance(bonded_balance, self.channels,
self.logger)
debonding_balance = parse_int_from_string(
str(staking_account['escrow']['debonding']['balance']))
self._logger.debug('%s debonding_balance: %s', self._node,
debonding_balance)
self._node.set_debonding_balance(debonding_balance, self.channels,
self.logger)
# Staking Delegations for self Entity ID
staking_delegations = self.data_wrapper.get_staking_delegations(
self.data_source_indirect.api_url, self.data_source_indirect.name,
self._node.staking_address)
shares = 0
for i, j in enumerate(staking_delegations):
shares += int(staking_delegations[j]['shares'])
# Set shares balance
self._logger.debug('%s shares balance: %s', self._node, shares)
self._node.set_shares_balance(shares, self.channels, self.logger)
if not self._archive_alerts_disabled:
self._monitor_archive_state()
self._last_height_checked += 1
