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 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 ping_from_ns(namespace):
namespace = util.process_namespace(namespace, allow_none=True)
dest = request.args.get("destination")
if app.simulate:
if dest == "1.1.1.1":
return jsonify(
{
"destination": "1.1.1.1",
"packet_duplicate_count": 0,
"packet_duplicate_rate": 0,
"packet_loss_count": 0,
"packet_loss_rate": 0,
"packet_receive": 4,
"packet_transmit": 4,
"rtt_avg": 5.472,
"rtt_max": 10.635,
"rtt_mdev": 3.171,
"rtt_min": 2.533,
}
)
else:
return jsonify({})
else:
ping_parser = pingparsing.PingParsing()
try:
result = util.run_in_ns(namespace, ["ping", "-c", "4", "-i", "0.2", dest])
return jsonify(ping_parser.parse(result).as_dict())
except subprocess.CalledProcessError as e:
LOGGER.exception("status: %s, out: %s, err: %s", e.returncode, e.stdout, e.stderr)
return jsonify({})
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 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 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 _ping_host(host, pkts=10):
ping = subprocess.Popen(['ping', '-c', str(pkts), '-i', '0.4', '-W',
'1', '-q', host], stdout=subprocess.PIPE)
ping_parser = pingparsing.PingParsing()
output = ping.stdout.read()
result = ping_parser.parse(output.decode().replace('pipe 8\n', ''))
return result.as_dict()
def main():
parser = pingparsing.PingParsing()
stats = parser.parse(
dedent(
"""\
PING google.com (74.125.24.100) 56(84) bytes of data.
[1524930937.003555] 64 bytes from 74.125.24.100: icmp_seq=1 ttl=39 time=148 ms
[1524930937.787175] 64 bytes from 74.125.24.100: icmp_seq=2 ttl=39 time=137 ms
[1524930938.787642] 64 bytes from 74.125.24.100: icmp_seq=3 ttl=39 time=137 ms
[1524930939.787653] 64 bytes from 74.125.24.100: icmp_seq=4 ttl=39 time=136 ms
[1524930940.788365] 64 bytes from 74.125.24.100: icmp_seq=5 ttl=39 time=136 ms
--- google.com ping statistics ---
5 packets transmitted, 5 received, 0% packet loss, time 4001ms
rtt min/avg/max/mdev = 136.537/139.174/148.006/4.425 ms
"""
)
)
print("[ping statistics]")
print(json.dumps(stats.as_dict(), indent=4))
print("\n[icmp reply]")
for icmp_reply in stats.icmp_reply_list:
print(icmp_reply)
return 0
def check_ping(ip_address):
# Get base ip address from full sensor path (e.g. rtsp://root:[email protected]/axis-media/media.amp)
try:
tmp1 = ip_address.split('@')
tmp2 = tmp1[1].split('/')
ip_address_base = tmp2[0]
except:
ip_address_base = ip_address
pass
ping_status = {'ping_status': False}
response = subprocess.run(['ping', '-c 1', '-w 1', ip_address_base],
stdout=subprocess.PIPE,
encoding='UTF-8')
# and then check the response...
if response.returncode == 0:
# Parse results
ping_parser = pingparsing.PingParsing()
ping_status = ping_parser.parse(response.stdout).as_dict()
ping_status.update({'ping_status': True})
return ping_status
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 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 main():
options = parse_option()
initialize_log_handler(options.log_level)
logger = logbook.Logger("pingparsing cli")
logger.level = options.log_level
pingparsing.set_log_level(options.log_level)
output = {}
if is_use_stdin():
from concurrent import futures
pingparsing.set_log_level(options.log_level)
max_workers = (multiprocessing.cpu_count() * 2
if options.max_workers is None else options.max_workers)
count, deadline = get_ping_param(options)
logger.debug("max-workers={}, count={}, deadline={}".format(
max_workers, count, deadline))
try:
with futures.ProcessPoolExecutor(max_workers) as executor:
future_list = []
for dest_or_file in options.destination_or_file:
logger.debug("start {}".format(dest_or_file))
future_list.append(
executor.submit(
parse_ping,
logger,
dest_or_file,
options.interface,
count,
deadline,
options.icmp_reply,
))
for future in futures.as_completed(future_list):
key, ping_data = future.result()
output[key] = ping_data
finally:
logger.debug("shutdown ProcessPoolExecutor")
executor.shutdown()
else:
ping_result_text = sys.stdin.read()
ping_parser = pingparsing.PingParsing()
stats = ping_parser.parse(ping_result_text)
output = stats.as_dict()
if options.icmp_reply:
output["icmp_reply"] = stats.icmp_reply_list
if options.indent <= 0:
result = json.dumps(output)
else:
result = json.dumps(output, indent=options.indent)
print_result(result)
return 0
def _ping_host(host, pkts=10):
ping = subprocess.Popen(
['ping', '-c',
str(pkts), '-i', '0.4', '-W', '1', '-q', host],
stdout=subprocess.PIPE)
ping_parser = pingparsing.PingParsing()
ping_parser.parse(ping.stdout.read())
return ping_parser.as_dict()
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_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 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 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 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 main():
options = parse_option()
ping_parser = pingparsing.PingParsing()
with open(options.file) as f:
ping_parser.parse(f.read())
examplecommon.print_ping_parser(ping_parser)
return 0
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 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 main():
parser = pingparsing.PingParsing()
parser.parse("""PING google.com (216.58.196.238) 56(84) bytes of data.
--- google.com ping statistics ---
60 packets transmitted, 60 received, 0% packet loss, time 59153ms
rtt min/avg/max/mdev = 61.425/99.731/212.597/27.566 ms
""")
print(json.dumps(parser.as_dict(), indent=4))
return 0
