ping_node.py

import socket
import time
import concurrent.futures
from tqdm import tqdm

# Configuration parameters
PEERS_FILE = "peers_list.txt"
TOP_N_PEERS = 10
SUCCESSFUL_PEERS_LOG_FILE = "successful_peers_log.txt"
FULL_PEERS_LOG_FILE = "full_peers_log.txt"
SORTED_PEERS_FILE = "sorted_peers.txt"
FINAL_PEERS_FILE = "final_peers_for_validators.txt"

NUM_PINGS = 3
MAX_WORKERS = 50
LOG_INTERVAL = 10

def ping_peer(peer, num_pings=NUM_PINGS):
 id_ip_port = peer.strip()
 try:
 if "@" not in id_ip_port:
 return None, f"Invalid format (missing '@'): {id_ip_port}"

 ip_port = id_ip_port.split("@")[1]
 if ":" not in ip_port:
 return None, f"Invalid format (missing ':'): {id_ip_port}"

 ip, port = ip_port.split(":")
 port = int(port)
 except (IndexError, ValueError):
 return None, f"Invalid format: {id_ip_port}"

 response_times = []
 for _ in range(num_pings):
 try:
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.settimeout(1) # Timeout 1 second
 start_time_ping = time.time()
 result = sock.connect_ex((ip, port))
 end_time_ping = time.time()
 sock.close()

 response_time = (end_time_ping - start_time_ping) * 1000
 if result == 0:
 response_times.append(response_time)
 else:
 response_times.append(None)
 except socket.error:
 response_times.append(None)

 valid_response_times = [t for t in response_times if t is not None]
 avg_response_time = sum(valid_response_times) / len(valid_response_times) if valid_response_times else None

 if avg_response_time is not None:
 return id_ip_port, f"{avg_response_time:.0f}ms - {id_ip_port}"
 else:
 return None, f"Failed - {id_ip_port}"

def main():
 # Initialize the log files
 open(SUCCESSFUL_PEERS_LOG_FILE, "w").close()
 open(FULL_PEERS_LOG_FILE, "w").close()

 valid_peers = []
 invalid_peers = []

 # Normalize and process the peer list from file
 with open(PEERS_FILE, "r") as file:
 raw_peers = file.read()

 # Replace newlines with commas and split by commas to handle multiple formats
 normalized_peers = raw_peers.replace("\n", ",").replace(", ", ",").split(",")

 for peer in normalized_peers:
 peer = peer.strip()
 if peer and "@" in peer and ":" in peer.split("@")[1]:
 valid_peers.append(peer)
 else:
 invalid_peers.append(peer)

 if invalid_peers:
 print("The following peers have invalid formats and will be skipped:")
 for invalid in invalid_peers:
 print(f" - {invalid}")

 with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
 futures = [executor.submit(ping_peer, peer) for peer in valid_peers]
 results = []
 for idx, future in tqdm(enumerate(concurrent.futures.as_completed(futures)), total=len(futures)):
 try:
 result = future.result()
 results.append(result)
 if idx % LOG_INTERVAL == 0 and result[0] is not None:
 print(f"{result[0]}: Connected successfully, average response time: {result[1].split()[0]}")
 except Exception as e:
 print(f"Error processing a peer: {e}")

 with open(SUCCESSFUL_PEERS_LOG_FILE, "w") as log_file:
 for result in results:
 if result[0] is not None:
 log_file.write(result[0] + ",")

 with open(FULL_PEERS_LOG_FILE, "w") as full_log_file:
 for result in results:
 full_log_file.write(result[1] + "\n")
 print(f"Debug: Writing to log: {result[1]}") # Debug line

 # Process and sort ping data
 with open(FULL_PEERS_LOG_FILE, 'r') as file:
 lines = file.readlines()

 ping_data = []
 for line in lines:
 parts = line.strip().split(' - ', 1) # Split on first occurrence of ' - '
 if len(parts) == 2:
 ping, node = parts
 if ping == "Failed":
 ping_data.append((float('inf'), node)) # Use 'inf' to treat failed nodes as last
 elif "ms" in ping:
 try:
 ping_ms = int(ping.replace('ms', '').strip())
 ping_data.append((ping_ms, node))
 except ValueError:
 ping_data.append((float('inf'), node))
 else:
 print(f"Skipping malformed line: {line.strip()}")

 # Sort the data
 sorted_ping_data = sorted(ping_data, key=lambda x: x[0])

 # Filter the top N nodes
 top_n_nodes = sorted_ping_data[:TOP_N_PEERS]
 nodes_below_100 = [(ping, node) for ping, node in sorted_ping_data if ping < 100]
 nodes_below_200 = [(ping, node) for ping, node in sorted_ping_data if ping < 200]

 count_below_100 = len(nodes_below_100)
 count_below_200 = len(nodes_below_200)
 count_above_200 = sum(1 for ping, _ in sorted_ping_data if ping >= 200)
 count_failed = sum(1 for ping, _ in ping_data if ping == float('inf'))
 total_nodes = len(ping_data)

 # Write sorted data to the log file
 with open(SORTED_PEERS_FILE, 'w') as file:
 file.write(f"Top {TOP_N_PEERS} nodes with the lowest ping:\n")
 for ping, node in top_n_nodes:
 file.write(f"{ping}ms - {node}\n")

 file.write(f"\nNodes with ping below 100ms: {count_below_100}/{total_nodes} ({count_below_100/total_nodes*100:.2f}%)\n")
 for ping, node in nodes_below_100:
 file.write(f"{ping}ms - {node}\n")

 file.write(f"\nNodes with ping below 200ms: {count_below_200}/{total_nodes} ({count_below_200/total_nodes*100:.2f}%)\n")
 for ping, node in nodes_below_200:
 file.write(f"{ping}ms - {node}\n")

 file.write(f"\nNodes with ping above 200ms: {count_above_200}/{total_nodes} ({count_above_200/total_nodes*100:.2f}%)\n")

 file.write(f"\nFailed nodes: {count_failed}/{total_nodes} ({count_failed/total_nodes*100:.2f}%)\n")

 with open(FINAL_PEERS_FILE, 'w') as file:
 file.write(','.join(node for _, node in top_n_nodes))

 print(f"Top {TOP_N_PEERS} nodes with the lowest ping: {len(top_n_nodes)}/{total_nodes} ({len(top_n_nodes)/total_nodes*100:.2f}%)")
 print(f"Nodes with ping below 100ms: {count_below_100}/{total_nodes} ({count_below_100/total_nodes*100:.2f}%)")
 print(f"Nodes with ping below 200ms: {count_below_200}/{total_nodes} ({count_below_200/total_nodes*100:.2f}%)")
 print(f"Nodes with ping above 200ms: {count_above_200}/{total_nodes} ({count_above_200/total_nodes*100:.2f}%)")
 print(f"Failed nodes: {count_failed}/{total_nodes} ({count_failed/total_nodes*100:.2f}%)")

if __name__ == "__main__":
 main()