În Python, există o modalitate de a ping un server prin intermediul ICMP și întoarce TRUE dacă serverul răspunde, sau FALSE dacă nu există nici un răspuns?
Dacă tu nu't nevoie pentru a sprijini Windows, aici's foarte concis mod de a face asta:
import os
hostname = "google.com" #example
response = os.system("ping -c 1 " + hostname)
#and then check the response...
if response == 0:
print hostname, 'is up!'
else:
print hostname, 'is down!'
Acest lucru functioneaza pentru ping returnează o valoare diferită de zero în cazul în care conexiunea eșuează. (Valoarea returnată de fapt diferă în funcție de eroare de rețea.) Ai putea schimba, de asemenea, ping timeout (în secunde), folosind '-t' opțiune. Notă, acest lucru va text de ieșire la consolă.
Această funcție funcționează în orice sistem de OPERARE (Unix, Linux, macOS și Windows) Python 2 și 3 Python
MODIFICĂRI:
De @radato os.sistemul a fost înlocuit cu
subproces.sun. De [@Boris](https://stackoverflow.com/users/3064538/) documentația recomandă utilizarea [
subproces.run()`]3 dacă're folosind Python 3.5+.
import platform # For getting the operating system name
import subprocess # For executing a shell command
def ping(host):
"""
Returns True if host (str) responds to a ping request.
Remember that a host may not respond to a ping (ICMP) request even if the host name is valid.
"""
# Option for the number of packets as a function of
param = '-n' if platform.system().lower()=='windows' else '-c'
# Building the command. Ex: "ping -c 1 google.com"
command = ['ping', param, '1', host]
return subprocess.call(command) == 0
Rețineți că, în conformitate cu @ikrase pe Windows această funcție va returna "True" dacă ai o Destination Host Unreachable
eroare.
Explicație
Comanda "ping", atât pentru Windows și sistemele Unix-like.
Opțiunea -n
(Windows) sau "- c " (Unix) controlează numărul de pachete care în acest exemplu a fost setat la 1.
platforma.sistemul()
a se întoarce platforma numele. Ex. 'Darwin' pe macOS. [
subproces.apel()][2] execută un apel de sistem. Ex.
subproces.apel(['e','-l'])`.
Acolo este un modul numit pyping, care poate face acest lucru. Acesta poate fi instalat cu pip
pip install pyping
Este destul de simplu de utilizat, cu toate acestea, atunci când se utilizează acest modul, aveți nevoie de acces root, datorită faptului că este crafting pachete brute sub capota.
import pyping
r = pyping.ping('google.com')
if r.ret_code == 0:
print("Success")
else:
print("Failed with {}".format(r.ret_code))
Pentru că îmi place să-mi Python program universal pe versiunea 2.7 și 3.x și pe platforma Linux, Mac OS și Windows, am avut de a modifica exemplele existente.
# shebang does not work over all platforms
# ping.py 2016-02-25 Rudolf
# subprocess.call() is preferred to os.system()
# works under Python 2.7 and 3.4
# works under Linux, Mac OS, Windows
def ping(host):
"""
Returns True if host responds to a ping request
"""
import subprocess, platform
# Ping parameters as function of OS
ping_str = "-n 1" if platform.system().lower()=="windows" else "-c 1"
args = "ping " + " " + ping_str + " " + host
need_sh = False if platform.system().lower()=="windows" else True
# Ping
return subprocess.call(args, shell=need_sh) == 0
# test call
print(ping("192.168.17.142"))
#!/usr/bin/python3
import subprocess as sp
def ipcheck():
status,result = sp.getstatusoutput("ping -c1 -w2 " + str(pop))
if status == 0:
print("System " + str(pop) + " is UP !")
else:
print("System " + str(pop) + " is DOWN !")
pop = input("Enter the ip address: ")
ipcheck()
După ce se uită în jur, am ajuns sa-mi scriu propria ping modul, care este proiectat pentru a monitoriza un număr mare de adrese, este asincron și nu't de a folosi o mulțime de resurse de sistem. Puteți găsi aici: https://github.com/romana/multi-ping/ It's Apache licență, astfel încât să puteți utiliza în proiectul dumneavoastră în orice fel tu de cuviință.
Principalele motive pentru punerea în aplicare propriile mele sunt restricții de alte abordări:
Pentru python3 acolo's un foarte simplu și convenabil modul python ping3: (pip instala ping3)
.
from ping3 import ping, verbose_ping
ping('example.com') # Returns delay in seconds.
>>> 0.215697261510079666
Acest modul permite personalizarea unor parametri la fel de bine.
Am rezolvat cu:
def ping(self, host):
res = False
ping_param = "-n 1" if system_name().lower() == "windows" else "-c 1"
resultado = os.popen("ping " + ping_param + " " + host).read()
if "TTL=" in resultado:
res = True
return res
"TTL" este o modalitate de a ști dacă ping este corect. Saludos
Programatic ICMP ping este complicată din cauza privilegii ridicate necesare pentru a trimite prime pachetele ICMP, și de asteptare "ping" binar este urât. Pentru monitorizare server, puteți obține același rezultat folosind o tehnica numita TCP ping:
# pip3 install tcping
>>> from tcping import Ping
# Ping(host, port, timeout)
>>> ping = Ping('212.69.63.54', 22, 60)
>>> ping.ping(3)
Connected to 212.69.63.54[:22]: seq=1 time=23.71 ms
Connected to 212.69.63.54[:22]: seq=2 time=24.38 ms
Connected to 212.69.63.54[:22]: seq=3 time=24.00 ms
Pe plan intern, acest lucru pur și simplu stabilește o conexiune TCP cu serverul țintă și scade imediat, măsurând timpul scurs. Acest lucru special, punerea în aplicare este un pic limitat în care nu't se ocupe porturile inchise, dar pentru propriile servere, merge destul de bine.
Mea reducere folosind idei din răspunsuri în acest post, dar numai folosind cele mai noi recomandat subproces module și python3:
import subprocess
import platform
operating_sys = platform.system()
nas = '192.168.0.10'
def ping(ip):
# ping_command = ['ping', ip, '-n', '1'] instead of ping_command = ['ping', ip, '-n 1'] for Windows
ping_command = ['ping', ip, '-n', '1'] if operating_sys == 'Windows' else ['ping', ip, '-c 1']
shell_needed = True if operating_sys == 'Windows' else False
ping_output = subprocess.run(ping_command,shell=shell_needed,stdout=subprocess.PIPE)
success = ping_output.returncode
return True if success == 0 else False
out = ping(nas)
print(out)
Versiunea mea de ping funcția:
def ping(host_or_ip, pachete=1, timeout=1000): ''' Apeluri de sistem "ping" comandă, returnează True dacă ping reușește. Parametru obligatoriu: host_or_ip (str, adresa de gazdă la ping) Parametri opționali: pachete (int, numărul de încercări), interval (int, ms astept raspuns) Nu arată nici o ieșire, fie ca fereastră pop-up sau în linie de comandă. Python 3.5+, Windows și Linux compatibil (Mac nu a fost testat, ar trebui să funcționeze) '''
if platform.system().lower() == 'windows':
command = ['ping', '-n', str(packets), '-w', str(timeout), host_or_ip]
# run parameters: capture output, discard error messages, do not show window
result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=0x08000000)
# 0x0800000 is a windows-only Popen flag to specify that a new process will not create a window.
# On Python 3.7+, you can use a subprocess constant:
# result = subprocess.run(command, capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
# On windows 7+, ping returns 0 (ok) when host is not reachable; to be sure host is responding,
# we search the text "TTL=" on the command output. If it's there, the ping really had a response.
return result.returncode == 0 and b'TTL=' in result.stdout
else:
command = ['ping', '-c', str(packets), '-w', str(timeout), host_or_ip]
# run parameters: discard output and error messages
result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
return result.returncode == 0
`` Simțiți-vă liber să-l folosească ca o vei face.
Acest script funcționează pe Windows, și ar trebui să funcționeze pe alte sisteme de operare : Aceasta funcționează pe Windows, Debian, și macosx, nevoie de un test pe solaris.
import os
import platform
def isUp(hostname):
giveFeedback = False
if platform.system() == "Windows":
response = os.system("ping "+hostname+" -n 1")
else:
response = os.system("ping -c 1 " + hostname)
isUpBool = False
if response == 0:
if giveFeedback:
print hostname, 'is up!'
isUpBool = True
else:
if giveFeedback:
print hostname, 'is down!'
return isUpBool
print(isUp("example.com")) #Example domain
print(isUp("localhost")) #Your computer
print(isUp("invalid.example.com")) #Unresolvable hostname: https://tools.ietf.org/html/rfc6761
print(isUp("192.168.1.1")) #Pings local router
print(isUp("192.168.1.135")) #Pings a local computer - will differ for your network
Am ajuns să găsesc această întrebare cu privire la un scenariu similar. Am încercat pyping dar exemplul dat de Naveen n't lucra pentru mine în Windows sub Python 2.7.
Un exemplu care a lucrat pentru mine este:
import pyping
response = pyping.send('Your IP')
if response['ret_code'] == 0:
print("reachable")
else:
print("unreachable")
Folosind Multi-ping (pip instala multiPing
) am făcut acest lucru simplu cod (pur și simplu copiați și inserați dacă va!):
from multiping import MultiPing
def ping(host,n = 0):
if(n>0):
avg = 0
for i in range (n):
avg += ping(host)
avg = avg/n
# Create a MultiPing object to test hosts / addresses
mp = MultiPing([host])
# Send the pings to those addresses
mp.send()
# With a 1 second timout, wait for responses (may return sooner if all
# results are received).
responses, no_responses = mp.receive(1)
for addr, rtt in responses.items():
RTT = rtt
if no_responses:
# Sending pings once more, but just to those addresses that have not
# responded, yet.
mp.send()
responses, no_responses = mp.receive(1)
RTT = -1
return RTT
Utilizare:
#Getting the latency average (in seconds) of host '192.168.0.123' using 10 samples
ping('192.168.0.123',10)
Dacă doriți o singură probă, cea de-a doua parametru "10
" poate fi ignorat!
Sper că vă ajută!
Aici's o soluție folosind Python's subproces
module și "ping" CLI instrument furnizat de fond al sistemului de OPERARE. Testat pe Windows și Linux. Suport pentru stabilirea unei rețele de expirare. Nu't nevoie de privilegii de root (cel puțin pe Windows și Linux).
import platform
import subprocess
def ping(host, network_timeout=3):
"""Send a ping packet to the specified host, using the system "ping" command."""
args = [
'ping'
]
platform_os = platform.system().lower()
if platform_os == 'windows':
args.extend(['-n', '1'])
args.extend(['-w', str(network_timeout * 1000)])
elif platform_os in ('linux', 'darwin'):
args.extend(['-c', '1'])
args.extend(['-W', str(network_timeout)])
else:
raise NotImplemented('Unsupported OS: {}'.format(platform_os))
args.append(host)
try:
if platform_os == 'windows':
output = subprocess.run(args, check=True, universal_newlines=True).stdout
if output and 'TTL' not in output:
return False
else:
subprocess.run(args, check=True)
return True
except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
return False
Am avut cerință similară așa că am pus în aplicare așa cum se arată mai jos. Acesta este testat pe Windows pe 64 de biți și Linux.
import subprocess
def systemCommand(Command):
Output = ""
Error = ""
try:
Output = subprocess.check_output(Command,stderr = subprocess.STDOUT,shell='True')
except subprocess.CalledProcessError as e:
#Invalid command raises this exception
Error = e.output
if Output:
Stdout = Output.split("\n")
else:
Stdout = []
if Error:
Stderr = Error.split("\n")
else:
Stderr = []
return (Stdout,Stderr)
#in main
Host = "ip to ping"
NoOfPackets = 2
Timeout = 5000 #in milliseconds
#Command for windows
Command = 'ping -n {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
#Command for linux
#Command = 'ping -c {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
Stdout,Stderr = systemCommand(Command)
if Stdout:
print("Host [{}] is reachable.".format(Host))
else:
print("Host [{}] is unreachable.".format(Host))
Atunci când IP-ul nu este accesibil subproces.check_output() ridică o excepție. În plus verificarea se poate face prin extragerea de informații din linia de ieșire 'Packets: Sent = 2, a Primit = 2, Lost = 0 (0% loss)'.
Pare destul de simplu, dar mi se potrivește. Am păstrat obtinerea "icmp deschide socket operation not permitted" sau altfel de solutii s-ar închide dacă serverul a fost off-line. Dacă, cu toate acestea, ceea ce vreau să știu este că serverul este în viață și se execută pe un server web de pe acel server, apoi se răsuci va face treaba. Dacă aveți ssh și certificate, ssh și o simplă comandă va fi suficient. Aici este codul:
from easyprocess import EasyProcess # as root: pip install EasyProcess
def ping(ip):
ping="ssh %s date;exit"%(ip) # test ssh alive or
ping="curl -IL %s"%(ip) # test if http alive
response=len(EasyProcess(ping).call(timeout=2).stdout)
return response #integer 0 if no response in 2 seconds