forked from TrueCloudLab/frostfs-testlib
86 lines
3.9 KiB
Python
86 lines
3.9 KiB
Python
import re
|
|
|
|
from frostfs_testlib.storage.cluster import ClusterNode
|
|
from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetInfo, NodeNetmapInfo
|
|
|
|
|
|
class NetmapParser:
|
|
@staticmethod
|
|
def netinfo(output: str) -> NodeNetInfo:
|
|
regexes = {
|
|
"epoch": r"Epoch: (?P<epoch>\d+)",
|
|
"network_magic": r"Network magic: (?P<network_magic>.*$)",
|
|
"time_per_block": r"Time per block: (?P<time_per_block>\d+\w+)",
|
|
"container_fee": r"Container fee: (?P<container_fee>\d+)",
|
|
"epoch_duration": r"Epoch duration: (?P<epoch_duration>\d+)",
|
|
"inner_ring_candidate_fee": r"Inner Ring candidate fee: (?P<inner_ring_candidate_fee>\d+)",
|
|
"maximum_object_size": r"Maximum object size: (?P<maximum_object_size>\d+)",
|
|
"withdrawal_fee": r"Withdrawal fee: (?P<withdrawal_fee>\d+)",
|
|
"homomorphic_hashing_disabled": r"Homomorphic hashing disabled: (?P<homomorphic_hashing_disabled>true|false)",
|
|
"maintenance_mode_allowed": r"Maintenance mode allowed: (?P<maintenance_mode_allowed>true|false)",
|
|
"eigen_trust_alpha": r"EigenTrustAlpha: (?P<eigen_trust_alpha>\d+\w+$)",
|
|
"eigen_trust_iterations": r"EigenTrustIterations: (?P<eigen_trust_iterations>\d+)",
|
|
}
|
|
parse_result = {}
|
|
|
|
for key, regex in regexes.items():
|
|
search_result = re.search(regex, output, flags=re.MULTILINE)
|
|
if search_result == None:
|
|
parse_result[key] = None
|
|
continue
|
|
parse_result[key] = search_result[key].strip()
|
|
|
|
node_netinfo = NodeNetInfo(**parse_result)
|
|
|
|
return node_netinfo
|
|
|
|
@staticmethod
|
|
def snapshot_all_nodes(output: str) -> list[NodeNetmapInfo]:
|
|
"""The code will parse each line and return each node as dataclass."""
|
|
netmap_nodes = output.split("Node ")[1:]
|
|
dataclasses_netmap = []
|
|
result_netmap = {}
|
|
|
|
regexes = {
|
|
"node_id": r"\d+: (?P<node_id>\w+)",
|
|
"node_data_ips": r"(?P<node_data_ips>/ip4/.+?)$",
|
|
"node_status": r"(?P<node_status>ONLINE|OFFLINE)",
|
|
"cluster_name": r"ClusterName: (?P<cluster_name>\w+)",
|
|
"continent": r"Continent: (?P<continent>\w+)",
|
|
"country": r"Country: (?P<country>\w+)",
|
|
"country_code": r"CountryCode: (?P<country_code>\w+)",
|
|
"external_address": r"ExternalAddr: (?P<external_address>/ip[4].+?)$",
|
|
"location": r"Location: (?P<location>\w+.*)",
|
|
"node": r"Node: (?P<node>\d+\.\d+\.\d+\.\d+)",
|
|
"price": r"Price: (?P<price>\d+)",
|
|
"sub_div": r"SubDiv: (?P<sub_div>.*)",
|
|
"sub_div_code": r"SubDivCode: (?P<sub_div_code>\w+)",
|
|
"un_locode": r"UN-LOCODE: (?P<un_locode>\w+.*)",
|
|
"role": r"role: (?P<role>\w+)",
|
|
}
|
|
|
|
for node in netmap_nodes:
|
|
for key, regex in regexes.items():
|
|
search_result = re.search(regex, node, flags=re.MULTILINE)
|
|
if key == "node_data_ips":
|
|
result_netmap[key] = search_result[key].strip().split(" ")
|
|
continue
|
|
if key == "external_address":
|
|
result_netmap[key] = search_result[key].strip().split(",")
|
|
continue
|
|
if search_result == None:
|
|
result_netmap[key] = None
|
|
continue
|
|
result_netmap[key] = search_result[key].strip()
|
|
|
|
dataclasses_netmap.append(NodeNetmapInfo(**result_netmap))
|
|
|
|
return dataclasses_netmap
|
|
|
|
@staticmethod
|
|
def snapshot_one_node(output: str, cluster_node: ClusterNode) -> NodeNetmapInfo | None:
|
|
snapshot_nodes = NetmapParser.snapshot_all_nodes(output=output)
|
|
snapshot_node = [node for node in snapshot_nodes if node.node == cluster_node.host_ip]
|
|
if not snapshot_node:
|
|
return None
|
|
return snapshot_node[0]
|