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)