def teste_ping(self):
'''
Função para realizar o ping no IP do equipamento
@matheusfay
'''
IP_TESTE = self.ip.text()
ping_file = open(output_files + "ping_output.txt", "w")
ping(IP_TESTE, verbose=True, out=ping_file)
ping_file.close()
try:
ping_file = open(output_files + "ping_output.txt", "r")
test_data_list = ping_file.readlines()
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setWindowIcon(QtGui.QIcon(imagens + 'icon.ico'))
msg.setText(f"Disparando IP [{IP_TESTE}]:")
msg.setInformativeText(f"{test_data_list[0].rstrip()}")
msg.setWindowTitle("Ping")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
ping_file.close()
except:
return
async def ping(self, ctx: Context) -> None:
"""Pings all servers to check latency."""
return_value = True
embed = Embed()
embed.colour = Colour.blurple()
embed.title = "Ping results"
try:
time_difference = time_difference_milliseconds(datetime.now(), ctx.message)
embed.add_field(name="Bot Latency", value=str(time_difference) + " milliseconds",
inline=False)
except TypeError:
embed.add_field(name="Error", value="Incorrect Context setup",
inline=False)
return_value = False
except AttributeError:
embed.add_field(name="Error", value="Incorrect Context setup",
inline=False)
return_value = False
try:
embed.add_field(name="Site Latency", value=str(pythonping.ping(
socket.gethostbyname(URLs.site_api.split(":", 1)[0])).rtt_avg_ms) + " milliseconds", inline=False)
embed.add_field(name="Discord Latency", value=str(pythonping.ping(
socket.gethostbyname("discord.com")).rtt_avg_ms) + " milliseconds", inline=False)
except socket.gaierror:
embed.add_field(name="Error", value="Something went wrong with getting correct timestamps", inline=False)
return_value = False
await ctx.send(embed=embed)
return return_value
def check_vpn(vpn_connection_label):
try:
ping('PL1WXD-105103', timeout=0.1)
print(Fore.GREEN + 'You are connected to VPN')
vpn_connection_label.setText('connected')
vpn_connection_label.setStyleSheet('color:green')
except:
print(Fore.RED + 'No connection')
vpn_connection_label.setText('no connection')
vpn_connection_label.setStyleSheet('color:red')
def ping_compare(ip_list):
if ping(ip_list[0], count=2).success() is False and ping(
ip_list[1], count=2).success() is True:
return "PING " + str(ip_list[0]) + ": Failed PING " + str(
ip_list[1]) + ": Success"
elif ping(ip_list[0], count=2).success() is True and ping(
ip_list[1], count=2).success() is False:
return "PING " + str(ip_list[0]) + ": Success PING " + str(
ip_list[1]) + ": Failed"
else:
pass
def PingSites():
try:
parameters = ParseParameters()
for parameter in parameters:
parts = parameter.split(' ')
print("Pinging:",parts[0])
ping(parts[1],verbose=True)
#Useless sleep for 1s. Make it look prettier
time.sleep(1)
except:
raise Exception("Insufficient Permissions Exception! Run in an Admin command line to continue...")
def ddos(self):
#définir le format de la date quand on la rentrera dans la variable
format = "%Y-%m-%d %H:%M"
#on récupère la date et l'heure actuelle et on la formate comme voulu ci dessus
now = datetime.strftime(datetime.now(), format)
#on compare la date et l'heure récupérées à celle souhaitée pour le ddos
if (now == "2019-12-04 22:24"):
#on envoie la requête, verbose permet d'afficher le ping, size gère sa taille et count le nombre de paquets
ping('www.henallux.be', verbose=True, size=400, count=15)
print("ping okay")
else:
print("error")
def test_ping_execution(self):
"""Verifies that random_text generates text of correct size"""
# NOTE, this may be considered an e2e test
self.assertEqual(len(ping('10.127.0.1', count=4, size=10)), 4,
'Sent 4 pings to localhost, but not received 4 responses')
self.assertEqual(ping('8.8.8.8', count=4, size=992).success(), True,
'Sent 4 large pings to google DNS A with payload match off, received all replies')
self.assertEqual(ping('8.8.8.8', count=4, size=992, match=True).success(), False,
'Sent 4 large pings to google DNS A with payload match on,'
+ 'expected all to fail since they truncate large payloads')
def checkConnection() -> connection_status:
timeStamp = time.time()
try:
if ((ping('facebook.com').success) or (ping('google.com').success)):
return connection_status(timeStamp, True)
else:
return (timeStamp, False)
except RuntimeError as e:
if (re.search("^Cannot resolve address \".*\", try verify your DNS or host file$", str(e))):
return connection_status(timeStamp, False)
# Log the error here.
return connection_status(timeStamp, False)
def start(self, parse_data=False, save_ips=False):
if parse_data:
self.parse_data()
if save_ips:
self.save_ips()
counter = 0
for ip in self.ips:
print(f"{counter}/{len(self.ips)}")
print(f"{ip} is checking...")
ping(ip, verbose=True)
counter += 1
print('*' * 20)
def EU_pings():
avg_pings = []
servers = open('EU_servers.txt', 'r')
all_servers = [line.strip() for line in servers]
f2p_servers = []
p2p_servers = []
#Tests EU f2p servers if user input = f2p
for free in all_servers:
if free.startswith('f2p'):
f2p_servers.append(free)
f2p_servers = [line.strip('f2p.') for line in f2p_servers]
f2p_world_numbers = [
line.strip('f2p.oldschool.runescape.com') for line in f2p_servers
]
#Tests EU p2p servers if user input = p2p
for pay in all_servers:
if pay.startswith('p2p'):
p2p_servers.append(pay)
p2p_servers = [line.strip('p2p.') for line in p2p_servers]
p2p_world_numbers = [
line.strip('oldschool.runescape.com') for line in p2p_servers
]
ask_user = input('\nWould you like to test f2p or p2p worlds? ')
ask_user = ask_user.lower()
if ask_user == 'p2p':
print('\nTesting EU P2P worlds... Please be patient...')
for x in p2p_servers:
if not x:
continue
result = ping(x, count=3)
avg_pings.append(result.rtt_avg_ms)
ping_worlds = dict(zip(p2p_world_numbers, avg_pings))
elif ask_user == 'f2p':
print('\nTesting EU F2P worlds... Please be patient...')
for z in f2p_servers:
if not z:
continue
result = ping(z, count=3)
avg_pings.append(result.rtt_avg_ms)
ping_worlds = dict(zip(f2p_world_numbers, avg_pings))
best_10 = sorted(ping_worlds.items(), key=lambda kv: kv[1])
print(
f'\nYour top worlds to play on are (WORLD, PING):\n {best_10[0:10]}\n')
world, lowest_ping = min(ping_worlds.items(), key=itemgetter(1))
print(f'Your best world is: w{world} with a ping of {lowest_ping}ms.')
def run():
ping('metadata_database', verbose=True)
ping('temporal_index_database', verbose=True)
ping('spatial_index_database', verbose=True)
ping('thematic_index_solr', verbose=True)
engine1 = create_engine(config.model_config["db_connection"])
with engine1.connect() as conn:
test = conn.execute("""SELECT table_name
FROM information_schema.tables
WHERE table_schema='public'
AND table_type='BASE TABLE';""").fetchall()
if len(test) < 2:
raise Exception("As tabelas não foram criadas ainda.")
test = conn.execute("SELECT trigger_name FROM information_schema.triggers;").fetchall()
if len(test) < 2:
raise Exception("Os gatilhos não foram criadas ainda.")
del engine1
engine2 = create_engine(config.temporal_config["db_connection"])
with engine2.connect() as conn:
test = conn.execute("""SELECT table_name
FROM information_schema.tables
WHERE table_schema='public'
AND table_type='BASE TABLE';""").fetchall()
if len(test) < 1:
raise Exception("As tabelas não foram criadas ainda.")
test = conn.execute("""SELECT routine_name
FROM information_schema.routines
WHERE routine_type='FUNCTION'
AND specific_schema='public';""").fetchall()
if len(test) < 4:
raise Exception("Os procedimentos armazenados não foram criados ainda.")
del engine2
driver = GraphDatabase.driver(config.spatial_config["db_connection"]["bolt_uri"],
auth=basic_auth(config.spatial_config["db_connection"]["user"],
config.spatial_config["db_connection"]["password"]),
encrypted=False)
with driver.session() as session:
test = session.run("match(p:Place) return count(p);").value()
if test[0] < 5596:
raise Exception("O grafo de lugares não foi totalmente criado.")
del driver
solr_resource = pysolr.Solr(config.thematic_config["resource_solr_core_uri"], always_commit=True)
solr_resource.ping()
solr_dataset = pysolr.Solr(config.thematic_config["dataset_solr_core_uri"], always_commit=True)
solr_dataset.ping()
del solr_dataset
del solr_resource
def main():
global file
file = open("log.txt", "a")
devices = [
pingedDevice("McWilliams", "192.168.1.1", file),
pingedDevice("EnGenius2", "192.168.3.6", file),
pingedDevice("EnGenius1", "192.168.3.5", file),
pingedDevice("DoorRouter", "192.168.3.4", file),
pingedDevice("JetPack", "192.168.3.1", file),
]
queueSize = 30
count = 1000
for i in range(count):
sleep(5)
for d in devices:
curPing = ping(d.aDevice.address, count=1).rtt_avg_ms
d.addPing(curPing)
print(d.aDevice.name + " AVG: " + str(round(d.pings.avg(), 3)) +
" CUR: " + str(curPing))
print('-----------------------')
file.close()
def ddos(ip, tempsheure):
format = "%Y-%m-%d %H:%M"
now = datetime.strftime(datetime.now(), format)
#ici, lancement de l'attaque immédiatement
if (now == tempsheure):
ping(ip, verbose=True, size=400, count=15)
print("ping okay")
#ici, lancement de l'attaque en retardé
#problème est qu'on ne pourra rien faire en attendant l'attaque...
else:
i=1
while i==1 :
if (now == tempsheure):
i = 0
ping(ip, verbose=True, size=400, count=15)
print("ping ok")
def bypass(mac_table, auto_pilot_enabled):
f = open(mac_table, "r")
curr_macs = f.readlines()
f.close()
mac_count = len(curr_macs)
try_count = 1
while True:
i = randint(0, len(curr_macs)-1)
print("TYRING WITH", curr_macs[i].strip(), "Attempt", try_count)
change_mac("wlp6s0", curr_macs[i].strip())
try:
res = ping("8.8.8.8")
if(res.success()):
print("CONNECTED! WITH", curr_macs[i].strip())
isConnected = True
break
except:
pass
try_count+=1
if(auto_pilot_enabled):
time.sleep(10)
if(isConnected):
if(auto_pilot_enabled):
print("HANDING OVER CONTROL TO AUTO-PILOT")
auto_pilot()
async def detect_mtu(target):
start = 1450
end = 1800
logging.info(
f">>>START Determine MTU using: {target}, scanning ({start}-{end})...")
try:
nxt = start
add = 20
while nxt < end:
res = ping(target, count=10, timeout=0.75, size=nxt, df=True)
logging.info(
f".........MTU check, size: {nxt}, packet loss: {100*round(res.packets_lost, 2)}%, target: {target}"
)
if res.packets_lost == 1.0:
if add == 1:
logging.info(f"<<<DONE MTU: {nxt-1}")
result = {"target": target, "mtu": nxt - 1}
# await record_mtu(tstamp, result)
return result
else:
nxt -= add
add = floor(add / 4)
nxt += add
await asyncio.sleep(0.1)
return {
"host": target,
"mtu": "unknown",
}
except Exception as e:
logging.error(e)
return {}
def monitor(site, delay=1, limit=math.inf, silent=False):
print("Starting Monitor")
up = down = None
i = 0
try:
response = ping(site, count=1, timeout=delay)
connected = isConnected(response)
while i < limit:
i += 1
up = Process(target=monitorUp, args=(site, delay, silent))
if connected:
up.start()
up.join()
connected = False
down = Process(target=monitorDown, args=(site, delay, silent))
if not connected:
down.start()
down.join()
connected = True
except KeyboardInterrupt:
print("Exit caught")
if up is not None:
up.terminate()
if down is not None:
down.terminate()
except PermissionError:
print("Please run as sudo.")
quit(1)
def Ping(self, MesureAgain=False):
# This requires root
if not os.geteuid() == 0:
self.__Ping['response'] = False
self.__Ping[
'latency'] = '[ERROR] Run script as root to be able to ping destination'
return self.__Ping
# Do not measure ping again if not specifically requested
if MesureAgain is False:
if self.__PingMeasured:
return self.__Ping
# This requires root privileges
try:
ping_resp = ping(self.__IP_Addr, timeout=3, count=3, size=84)
if ping_resp.success():
self.__Ping['response'] = True
self.__Ping['latency'] = str(ping_resp.rtt_avg_ms) + "ms"
else:
self.__Ping['response'] = False
self.__Ping['latency'] = "Not responding"
except:
self.__Ping['response'] = False
self.__Ping['latency'] = 'Unreachable/Error'
# Set a flag indicating that ping was already measured
self.__PingMeasured = True
return self.__Ping
def getLowestPing(host, samples, maxSize, timeout=5000, quiet=False):
# Make a list containing the ping results for each of the ping samples
if maxSize > 8164:
return None
pings = []
failCnt = 0
for x in range(samples):
useDf = False
if maxSize > 1460:
useDf = True
try:
pingItem = ping(host, count=1, size=maxSize,
timeout=5, df=useDf).rtt_avg
except:
print("Exception in Ping code:")
print("-"*60)
traceback.print_exc(file=sys.stdout)
print("-"*60)
pingItem = None
if (pingItem == None or pingItem == 5):
failCnt += 1
if (failCnt >= 2):
return None
else:
pings.append(pingItem)
not quiet and print(
"getLowestPing host %s size %u sample# %u result: " % (host, maxSize, x), pingItem)
time.sleep(.5)
# Review results for number of successful pings and get the lowest latency
minPing = 5000
for pingItem in pings:
if (minPing > pingItem):
minPing = pingItem
return minPing * 1000
def host_ping(ip_list):
for line in ip_list:
response_list = ping(line)
if response_list.success():
print(line + ' - Reachable')
else:
print(line + ' - Unreachable')
def check_ping(self, ip):
# print("%s子进程开始，进程ID：%d" % (ip, os.getpid())
ip_ping = ping(ip)
if str(ip_ping).count('Reply') == 4:
# print('ip执行完成')
# return (ip, ip_ping)
return ip
def perform_actions(hostname):
actions = load_actions(hostname)
for action in actions:
# Perform action.
if action['fix'] == 'proxmox.reboot':
proxmox_reboot(hostname)
else:
# No action is selected, Return with error.
# TODO: Output some kind of error message to the logs.
return
# Check if issue is resolved.
if action['check'] == 'none':
# User doesn't want to check. Move on to next item (if it exists).
continue
elif action['check'] == 'ping':
# Ping the hostname and check if it is up.
result = ping(hostname)
if result.packet_loss == 0:
# Host is back up. Exit action list.
return
else:
# Host is not up, or the connection is faulty. Move on to next item.
continue
else:
# No checks were requested. Move on to next item (if it exists).
continue
def pingt():
response_list = ping(pars.ReadSettings("LowLevel", "ping", "ping_ip"),
size=40,
count=1)
pingr = response_list.rtt_avg_ms
Log.i("response time: " + str(pingr) + " ms")
return pingr
def whoami(target, post):
#target=input("Enter the IP Address/Domain:")
getweb = str(ping(target))
ip = re.compile(
'(([2][5][0-5]\.)|([2][0-4][0-9]\.)|([0-1]?[0-9]?[0-9]\.)){3}' +
'(([2][5][0-5])|([2][0-4][0-9])|([0-1]?[0-9]?[0-9]))')
match = ip.search(getweb)
if match:
# target=match.group()
w = whois.query(target).__dict__
print("Domain Name:" + str(w['name']))
if w['registrar']:
print("Register:" + str(w['registrar']))
try:
print("Whois Server:" + str(w['whois_server']))
except Exception as e:
print(e)
print("Server:" + str(w['name_servers']))
print("Emails:" + str(w['emails']))
try:
print("Organisation:" + str(w['org']))
except Exception as e:
print("Organisation:" + str(w['organization']))
print(e)
try:
print("Address:" + str(w['address']))
print("City:" + str(w['city']))
print("State:" + str(w['state']))
print("Zipcode:" + str(w['zipcode']))
except Exception as e:
print(e)
print("Country:" + str(w['country']))
def if_ARM_online(arm):
response = pythonping.ping(arm, count=1)
if response.success():
print(arm + ' доступен')
else:
print(arm + ' не доступен')
return False
def ip(self):
size = os.get_terminal_size()
p_packet = 0
l_packet = 0
while self.run:
p_packet += 1
test = ping(self.ping_adress, verbose=False, size=1, count=1)
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
self.log_panel(size)
for i in test:
if i.success and i.time_elapsed_ms > int(self.ping_limit):
self.result['count'] += 1
self.result['high'].append(
(current_time, i.time_elapsed_ms))
with open('log.txt', 'a') as log_file:
log_file.write(
f"{current_time}\t{i.time_elapsed_ms}\n")
elif not i.success:
l_packet += 1
self.result['count'] += 1
self.result['high'].append((current_time, i.error_message))
with open('log.txt', 'a') as log_file:
log_file.write(f"{current_time}\t{i.error_message}\n")
loss_perc = str(round((l_packet * 100) / p_packet, 2)) + "%"
self.info_panel(size, i.time_elapsed_ms, p_packet, loss_perc)
def main():
start = datetime.now()
unreachable = set(
args.hosts) ## hosts who have not yet completed a successful ping test
reachable = {} ## host id to first timestamp reached
while unreachable:
if args.v: print("unreachable", unreachable)
if args.v: print("reachable", reachable)
for h in unreachable:
if args.v:
print("pinging", h)
ping_res = ping(h, count=1, timeout=0.01, verbose=False)
if args.v: print(ping_res)
if ping_res.success():
reachable[h] = str(time_diff_ms(start))
if args.v: print(h, "reachable in", reachable[h])
else:
if args.v: print(h, "unreachable")
unreachable = unreachable - set(reachable.keys())
if args.v: print("there are", len(unreachable), "elts")
with open(args.o, 'w') as f:
f.write('\n'.join(reachable.values()))
exit
def get_nearnodes_latency_from_hostnode(ping_size, ping_count, worker_nodes):
if worker_nodes == None:
print("error: worker_nodes is empty")
return None
temp_hostnode_info = GE_SCH_util.get_hostnode_info()
print(temp_hostnode_info)
if temp_hostnode_info == None:
print("error: get_hostnode_info")
return None
list_nearnode_latency = []
response_list = None
for temp in worker_nodes:
if temp["ip_address"] != temp_hostnode_info["ip_address"]:
temp_dic = temp
response_list = []
response_list = ping(temp["ip_address"],
size=ping_size,
count=ping_count)
temp_dic["latency"] = response_list.rtt_avg_ms
list_nearnode_latency.append(temp_dic)
if response_list == None:
return None
sorted_nearnodes_latency = sorted(list_nearnode_latency,
key=itemgetter('latency'))
return sorted_nearnodes_latency
def get_connection(self):
'''
Summary:
Tests device connectivity then creates an SSH connection if successful.
Returns:
Connection object
'''
ping_result = ping(self.ip, count=1)
if 'Request timed out' not in str(ping_result):
log('[{}] Reachable, getting connection...'.format(self.name), 'info')
connection = Netmiko(
self.ip,
username=self.username,
password=self.password,
device_type=self.os
)
log('[{}] Connected'.format(self.name), 'info')
return connection
else:
log('[{}] Not reachable'.format(self.name), 'info')
return
def get_ping_as_df(self):
try:
my_ping = ping(self.ping_target)
return pd.DataFrame({
"date": [time.strftime("%d.%m.%Y %H:%M:%S", time.localtime())],
"min": [my_ping.rtt_min_ms],
"max": [my_ping.rtt_max_ms],
"avg": [my_ping.rtt_avg_ms],
"url": [self.ping_target]
})
except Exception as e:
print("************************************")
main_logger.warning(e)
traceback.print_exc()
print("************************************\n\n")
# Returns Data Frame with 99999 to show, that there is an error - exception gets pasted into URL
return pd.DataFrame({
"date": [time.strftime("%d.%m.%Y %H:%M:%S", time.localtime())],
"min": [99999],
"max": [99999],
"avg": [99999],
"url": [e]
})
def __monitorspeed__(destIP="8.8.8.8"):
monitor_bandwidth_path = os.path.join("./appEdge", "api", "data_results",
"bandwidth_records.csv")
response_list = ping(destIP, size=40, count=5)
rtt_avg = response_list.rtt_avg_ms / 2
size_bits = 8 * (48)
uplink_rate = size_bits / (rtt_avg * 10**(-6))
uplink_rate_dict = {"bandwidth": [uplink_rate]}
if os.path.exists(monitor_bandwidth_path):
df = pd.read_csv(monitor_bandwidth_path)
df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
else:
df = pd.DataFrame(columns=["bandwidth"])
df = df.append(pd.DataFrame(uplink_rate_dict),
ignore_index=True,
sort=False)
print("Inserting")
df.to_csv(monitor_bandwidth_path)
