def ping(target):
# https://pypi.org/project/pingparsing/
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = target
transmitter.count = num_of_ping
output = json.dumps(ping_parser.parse(transmitter.ping()).as_dict(),
indent=4)
'''
"destination": "8.8.8.8",
"packet_transmit": 10,
"packet_receive": 10,
"packet_loss_count": 0,
"packet_loss_rate": 0.0,
"rtt_min": 15.132,
"rtt_avg": 19.378,
"rtt_max": 27.466,
"rtt_mdev": 3.695,
"packet_duplicate_count": 0,
"packet_duplicate_rate": 0.0
'''
rtt_min = json.loads(output)['rtt_min']
rtt_avg = json.loads(output)['rtt_avg']
rtt_max = json.loads(output)['rtt_max']
packet_loss = json.loads(output)['packet_loss_rate']
return (rtt_min, rtt_avg, rtt_max, packet_loss)
def pingparse(ip):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = ip
transmitter.count = 5
result = transmitter.ping()
return ping_parser.parse(result).as_dict()
def parse_ping(logger, dest_or_file, interface):
data = dest_or_file.split(",")
transmitter = pingparsing.PingTransmitter()
if len(data) > 0:
transmitter.destination_host = data[0]
else:
transmitter.destination_host = "localhost"
transmitter.interface = interface
if len(data) > 1:
transmitter.tos = data[1]
else:
transmitter.tos = 0
if len(data) > 2:
transmitter.packet_size = data[2]
else:
transmitter.packet_size = 56
if len(data) > 3:
transmitter.count = data[3]
else:
transmitter.count = 3
result = transmitter.ping()
ping_result_text = result.stdout
if result.returncode != 0:
logger.error(result.stderr)
ping_parser = pingparsing.PingParsing()
ping_parser.parse(ping_result_text)
return (dest_or_file, ping_parser.as_dict())
def ping(host: str) -> pingparsing.PingStats:
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 2
transmitter.timeout = 2000
return ping_parser.parse(transmitter.ping())
def run():
global old_value_sent, old_value_recv
while flag:
new_value_sent = psutil.net_io_counters().bytes_sent
new_value_recv = psutil.net_io_counters().bytes_recv
row = ""
transmitter = pingparsing.PingTransmitter()
transmitter.destination = "emea2cps.adobeconnect.com"
transmitter.count = 4
result = transmitter.ping()
strings = result.stdout.split("\r\n")
if old_value_sent and old_value_recv:
up = round(send_stat(new_value_sent - old_value_sent), 4)
dw = round(recv_stat(new_value_recv - old_value_recv), 4)
row = str(datetime.datetime.now()) + ", upload: " + str(
up) + " Mbit" + ", download: " + str(
dw) + " Mbit" + ", ping: " + strings[12].split(
",")[2] + " Packet Loss:" + strings[10] + "\n"
fileRow = (
str(datetime.datetime.now()) + "," + str(up) + "," +
str(dw) + "," +
strings[12].split(",")[2].split("= ")[1].split("ms")[0] +
"," + strings[10].split("(")[1].split("%")[0] + "\n")
file2write.write(fileRow)
if not flag:
file2write.close()
break
old_value_sent = new_value_sent
old_value_recv = new_value_recv
variable.set(str(row))
def parse_ping(logger, dest_or_file, interface, count, deadline, is_parse_icmp_reply):
if os.path.isfile(dest_or_file):
with open(dest_or_file) as f:
ping_result_text = f.read()
else:
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = dest_or_file
transmitter.interface = interface
transmitter.count = count
transmitter.deadline = deadline
transmitter.is_quiet = not is_parse_icmp_reply
try:
result = transmitter.ping()
except CommandError as e:
logger.error(e)
sys.exit(e.errno)
ping_result_text = result.stdout
if result.returncode != 0:
logger.error(result.stderr)
ping_parser = pingparsing.PingParsing()
stats = ping_parser.parse(ping_result_text)
output = stats.as_dict()
if is_parse_icmp_reply:
output["icmp_reply"] = stats.icmp_reply_list
return (dest_or_file, output)
def srv_stats(item, rf_id, user_id, user_pass):
#print(item)
#print(threading.current_thread())
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = item
transmitter.count = 1
result = transmitter.ping()
if ping_parser.parse(result).as_dict()['rtt_avg'] is None:
ping = -1
else:
ping = ping_parser.parse(result).as_dict()['rtt_avg']
server_ping.labels(serverip=item).set(ping)
total_url = "https://%s%sSystems/%s" % (item, red_fish_url, rf_id)
session = requests.Session()
session.mount('https://', HTTPAdapter(max_retries=connection_retry))
try:
data = session.get(total_url, auth=(user_id, user_pass), verify=False, timeout=connection_timeout)
except requests.exceptions.RequestException as ex:
print(ex)
finally:
stdout = json.loads(data.text)
print(stdout)
data_dict = {'Manufacturer': str(stdout['Manufacturer']),
'Status': str(stdout['Status']['Health']),
'Model': str(stdout['Model']),
'PowerState': str(stdout['PowerState']),
'hostName': str(stdout['HostName']),
'SerialNumber': str(stdout['SerialNumber'])}
if 'SKU' in stdout:
data_dict['SKU'] = str(stdout['SKU']) #service tag
server_general.labels(serverip=item).info(data_dict)
def startPing():
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = ping_addr
print(getTime() + "\tStarting ping test #" + str(i) +
" with destination: " + transmitter.destination)
#transmitter.count = 10
transmitter.deadline = duration
result = transmitter.ping()
json.dumps(ping_parser.parse(result).as_dict(), indent=4)
destination = ping_parser.destination
transmitted_pkt = ping_parser.packet_transmit
received_pkts = ping_parser.packet_receive
lost_pkts = ping_parser.packet_loss_count
pkt_loss_rate = ping_parser.packet_loss_rate
rtt_min = ping_parser.rtt_min
rtt_avg = ping_parser.rtt_avg
rtt_max = ping_parser.rtt_max
rtt_mdev = ping_parser.rtt_mdev
pkt_duplicate = ping_parser.packet_duplicate_count
pkt_duplicate_rate = ping_parser.packet_duplicate_rate
#store results in DB.
sql = (
"INSERT INTO ping_results (test_id, attack_frame_rate, destination, transmitted_pkt, received_pkts, lost_pkts, pkt_loss_rate, rtt_min, rtt_avg, rtt_max, rtt_mdev, pkt_duplicate, pkt_duplicate_rate, duration, exp_start_time) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
)
values = (test_id, attack_frame_rate, destination, transmitted_pkt,
received_pkts, lost_pkts, pkt_loss_rate, rtt_min, rtt_avg,
rtt_max, rtt_mdev, pkt_duplicate, pkt_duplicate_rate,
duration, exp_start_time)
executeQuery(sql, values)
print("end of ping\t" + getTime())
def from_ping(target, count=10):
"""
Collects latency data based on `ping`.
:param target: destination host to ping
:param count: number of pings to perform (default is 10)
:return: latency data
"""
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = target
transmitter.count = count
parser = pingparsing.PingParsing()
try:
raw_result = parser.parse(transmitter.ping())
result = raw_result.as_dict()
return Latency(
target=target,
loss=result['packet_loss_rate'],
average=result['rtt_avg'],
minimum=result['rtt_min'],
maximum=result['rtt_max']
)
except (KeyboardInterrupt, SystemExit):
raise
except:
return None
def find_server_nearest(self):
hosts = [
"18.231.0.104", ##San Paulo
"18.203.250.214", ##Ireland
"13.125.116.112", ##Seoul
"52.66.248.28"
] ##Mumbai
# hosts = ["www.google.com", ##San Paulo
# "www.facebook.com", ##Ireland
# "www.bing.com", ##Seoul
# "www.baidu.com"] ##Mumbai
rtt = 10000
index = 0
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
for i in range(len(hosts)):
print(i)
transmitter.destination_host = hosts[i]
transmitter.count = 10
result = transmitter.ping()
t = ping_parser.parse(result).as_dict()["rtt_avg"]
print(t)
if t < rtt:
rtt = t
index = i
print(hosts[index])
print(rtt)
return index
def get_ping_time(host):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 10
result = transmitter.ping()
result = ping_parser.parse(result).as_dict()
return result['rtt_avg']
def get_ping_result(self, host, count=5):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = host
transmitter.count = count
result = transmitter.ping()
parse_result = ping_parser.parse(result).as_dict()
return parse_result
def icmp_ping(ip_to_ping, count, id_try):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = ip_to_ping
transmitter.count = count
result = transmitter.ping()
stats = json.loads(
json.dumps(ping_parser.parse(result).as_dict(), indent=4))
return stats
def ping_bench(dict, host):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 6
result = transmitter.ping()
stats = ping_parser.parse(result)
stats.icmp_replies
dict['ping'] = stats.icmp_replies
def get_ping_stats(destination = "localhost"):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = destination
transmitter.count = 3
result = transmitter.ping()
a = json.dumps(ping_parser.parse(result).as_dict(), indent=4)
result = json.loads(a)
return result
def check_ping(host):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 10
result = json.loads(json.dumps(ping_parser.parse(transmitter.ping()).as_dict(), indent=4))
ping["packet_receive"] += result["packet_receive"]
ping["packet_loss_count"] += result["packet_loss_count"]
return (result["packet_receive"], result["packet_loss_count"])
def ping_host(host: str):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 10
transmitter.timeout = TIMEOUT
result = transmitter.ping()
rtt_avg = ping_parser.parse(result).as_dict()["rtt_avg"]
return host, rtt_avg
def main():
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = "google.com"
transmitter.count = 10
result = transmitter.ping()
print(json.dumps(ping_parser.parse(result).as_dict(), indent=4))
return result.returncode
def _ping(self, host, count):
parsing = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = count
result = transmitter.ping()
if result.returncode == 0:
return parsing.parse(result).as_dict()
else:
return None
def startPing(ip):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.count = 1
transmitter.destination_host = ip
ping_res = transmitter.ping()
if ping_res.returncode == 0:
return ping_parser.parse(ping_res).as_dict()
else:
return None
def ping_node(ip_addr):
ping_parser = pp.PingParsing()
transmitter = pp.PingTransmitter()
transmitter.destination = ip_addr
transmitter.count = 10
result = transmitter.ping()
try:
return ping_parser.parse(result.stdout).as_dict()
except:
print(result)
return None
def ping(dest):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = dest
transmitter.count = 1
result = ping_parser.parse(transmitter.ping()).as_dict()
if 'rtt_avg' in result:
return result['rtt_avg']
return None
def ping_scan(host):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = host
transmitter.count = 5
try:
result = transmitter.ping()
output = json.loads(json.dumps(ping_parser.parse(result).as_dict()))
return output["rtt_max"] * 0.001
except:
pass
def ping():
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination_host = "google.com"
transmitter.count = 1
result = transmitter.ping()
json.dumps(ping_parser.parse(result).as_dict(), indent=4)
global tripTime
global packetLoss
tripTime = ping_parser.rtt_avg
packetLoss = ping_parser.packet_loss
print(str(tripTime) + " ms")
print(str(packetLoss) + "%" + " Packet Loss ")
def ping(self, dest_ip):
'''
This function takes a destination ip, pings
to that ip and returns a list containing minimum, average and maximum round
trip time.
'''
ping_parser = pingparsing.PingParsing() # creating an object
transmitter = pingparsing.PingTransmitter() # create transmitter
transmitter.destination = dest_ip # set ip for the destination
transmitter.count = 2 # set number of packets to send
result = transmitter.ping() # get result and saving it in a variable
x = ping_parser.parse(result).as_dict() # converting the result into a dictionary format
return [x['rtt_min'],x['rtt_avg'],x['rtt_max']]
def pinga(self, destination):
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = destination
transmitter.count = self.count
transmitter.deadline = self.deadline
transmitter.timeout = self.timeout
try:
result = transmitter.ping()
resultasdict = json.loads(
(json.dumps(ping_parser.parse(result).as_dict(), indent=4)))
return (resultasdict)
except Exception as e:
logging.error('Error en ping: {}'.format(e))
return False
def gather_data():
results = []
with open('data/nodes.json', 'r') as f: #opening file with IPs
nodes = json.load(f) #loads json
for node in nodes:
ping_parser = pingparsing.PingParsing() #parsing ping
transmitter = pingparsing.PingTransmitter() #parsing ping
transmitter.destination = node["IP"] #pinging the ip object from the json file
transmitter.count = 1 #amount of times pinging
result = transmitter.ping()
parsed = ping_parser.parse(result).as_dict()
parsed['ip'] = node["IP"]
parsed['game'] = node["GAME"]
results.append(parsed)
return results
def ping():
global counter, outputs
print("run #{}".format(counter))
counter += 1
transmitter = pingparsing.PingTransmitter()
transmitter.destination = "10.0.0.20"
transmitter.count = 1000
transmitter.timestamp = True
transmitter.ping_option = '-f'
out = transmitter.ping()
print(out.stdout)
outputs.append(out.stdout)
return out
def icmp_ping(ip_to_ping, count):
"""
:description: Function to perform icmp ping through pingparsing library.
:param ip_to_ping: [str] IP to ping.
:param count: [str] Number of times that ping should be performed.
:return: [list] list with max, min, avg and mdv statistics.
"""
ping_parser = pingparsing.PingParsing()
transmitter = pingparsing.PingTransmitter()
transmitter.destination = ip_to_ping
transmitter.count = count
result = transmitter.ping()
stats = json.loads(
json.dumps(ping_parser.parse(result).as_dict(), indent=4))
return stats
def ping_control(number):
transmitter = pingparsing.PingTransmitter()
transmitter.destination = "10.0.0.20"
#transmitter.count = 50
transmitter.timestamp = True
transmitter.ping_option = "-i 0.020" #-i 0.010"
transmitter.deadline = 1
outputs = []
for i in range(0, number):
print("Control Second {}".format(i))
result = transmitter.ping()
outputs.append(result)
for i in range(0, number):
with open("control_results/{}.txt".format(i), mode='w+') as f:
f.write(outputs[i].stdout)
