it-swarm.com.de

Mehrere Ping-Skripts in Python

Ich kann keine einfach zu erlernende Dokumentation zu Python und Networking finden. In diesem Fall versuche ich nur, ein einfaches Skript zu erstellen, mit dem ich eine Reihe von Remote-Computern anpingen kann.

for ping in range(1,10):
   ip="127.0.0."+str(ping)
   os.system("ping -c 3 %s" % ip)

Ein einfaches Skript wie dieses wird die Maschinen gut pingen, aber ich möchte, dass das Skript "aktiv" "keine Antwort" zurückgibt. Das lässt mich denken, dass ich auch das Zeitmodul nachschlagen muss, denke ich, time.sleep(5) und danach würde es eine break-aussage geben. Was mich zu dem Gedanken bringt, dass es eine Weile-Schleife geben sollte. Ich bin nicht zu 100% sicher, ich könnte völlig in die falsche Richtung gehen:/wenn mir jemand helfen könnte oder mich in Richtung Dokumentation zeigt, wäre das großartig.

18
kuiper

Versuchen Sie subprocess.call. Es speichert den Rückgabewert des verwendeten Programms.

Gemäß meinem Ping-Handbuch gibt es 0 bei Erfolg zurück, 2, wenn Pings gesendet wurden, aber keine Antwort empfangen wurde und jeder andere Wert einen Fehler anzeigt.

# typo error in import
import subprocess

for ping in range(1,10):
    address = "127.0.0." + str(ping)
    res = subprocess.call(['ping', '-c', '3', address])
    if res == 0:
        print "ping to", address, "OK"
    Elif res == 2:
        print "no response from", address
    else:
        print "ping to", address, "failed!"
25
Roland Smith

Dieses Skript:

import subprocess
import os
with open(os.devnull, "wb") as limbo:
        for n in xrange(1, 10):
                ip="192.168.0.{0}".format(n)
                result=subprocess.Popen(["ping", "-c", "1", "-n", "-W", "2", ip],
                        stdout=limbo, stderr=limbo).wait()
                if result:
                        print ip, "inactive"
                else:
                        print ip, "active"

erzeugt etwas wie diese Ausgabe:

192.168.0.1 active
192.168.0.2 active
192.168.0.3 inactive
192.168.0.4 inactive
192.168.0.5 inactive
192.168.0.6 inactive
192.168.0.7 active
192.168.0.8 inactive
192.168.0.9 inactive

Sie können die Ausgabe erfassen, wenn Sie limbo durch subprocess.PIPE ersetzen und communicate() für das Popen-Objekt verwenden:

p=Popen( ... )
output=p.communicate()
result=p.wait()

Auf diese Weise erhalten Sie den Rückgabewert des Befehls und können den Text erfassen. Befolgen Sie das manual dies ist der bevorzugte Weg, um einen Unterprozess zu betreiben, wenn Sie Flexibilität benötigen:

Die zugrunde liegende Prozesserstellung und -verwaltung in diesem Modul ist wird von der Popen-Klasse behandelt. Es bietet viel Flexibilität, so dass Entwickler sind in der Lage, die weniger häufig vorkommenden Fälle zu behandeln, die nicht von .__ abgedeckt werden. Komfortfunktionen.

9
hochl

Vielen Dank dafür. Ich habe es geändert, um mit Windows zu arbeiten. Ich habe auch ein niedriges Timeout gesetzt, also werden die IPs, die keine Rückkehr haben, nicht warten und jeweils 5 Sekunden warten. Dies ist aus dem Quellcode von hochl.

import subprocess
import os
with open(os.devnull, "wb") as limbo:
        for n in xrange(200, 240):
                ip="10.2.7.{0}".format(n)
                result=subprocess.Popen(["ping", "-n", "1", "-w", "200", ip],
                        stdout=limbo, stderr=limbo).wait()
                if result:
                        print ip, "inactive"
                else:
                        print ip, "active"

Ändern Sie einfach das ip = für Ihr Schema und den Xrange für die Hosts.

5
Robert N

Ich bin ein Anfänger und habe ein Skript geschrieben, mit dem Sie mehrere Hosts pingen können. 

import ipaddress
from subprocess import Popen, PIPE

net4 = ipaddress.ip_network('192.168.2.0/24')
for x in net4.hosts():
    x = str(x)
    hostup = Popen(["ping", "-c1", x], stdout=PIPE)
    output = hostup.communicate()[0]
    val1 = hostup.returncode
 if val1 == 0:
    print(x, "is pinging")
 else:
    print(x, "is not responding")
3
Sumit

Um mehrere Hosts gleichzeitig zu pingen, können Sie subprocess.Popen() verwenden:

#!/usr/bin/env python3
import os
import time
from subprocess import Popen, DEVNULL

p = {} # ip -> process
for n in range(1, 100): # start ping processes
    ip = "127.0.0.%d" % n
    p[ip] = Popen(['ping', '-n', '-w5', '-c3', ip], stdout=DEVNULL)
    #NOTE: you could set stderr=subprocess.STDOUT to ignore stderr also

while p:
    for ip, proc in p.items():
        if proc.poll() is not None: # ping finished
            del p[ip] # remove from the process list
            if proc.returncode == 0:
                print('%s active' % ip)
            Elif proc.returncode == 1:
                print('%s no response' % ip)
            else:
                print('%s error' % ip)
            break

Wenn Sie als Root laufen können, können Sie ein pure Python-Ping-Skript verwenden oder scapy :

from scapy.all import sr, ICMP, IP, L3RawSocket, conf

conf.L3socket = L3RawSocket # for loopback interface
ans, unans = sr(IP(dst="127.0.0.1-99")/ICMP(), verbose=0) # make requests
ans.summary(lambda (s,r): r.sprintf("%IP.src% is alive"))
2
jfs
import subprocess
import os
'''
servers.txt contains ip address in following format
192.168.1.1
192.168.1.2
'''
    with open('servers.txt', 'r') as f:
        for ip in f:
            result=subprocess.Popen(["ping", "-c", "1", "-n", "-W", "2",    ip],stdout=f, stderr=f).wait()
            if result:
                print(ip, "inactive")
            else:
                print(ip, "active")
1
Razi Ahmed

Python hat tatsächlich ein wirklich süßes method , das einen Iterator über die verwendbaren Hosts im Netzwerk zurückgibt. (Wenn Strikt auf Falsch gesetzt wird, werden alle IPs durchlaufen.)

Zum Beispiel:

import subprocess
import ipaddress

subnet = ipaddress.ip_network('192.168.1.0/24', strict=False)
for i in subnet.hosts():
    i = str(i)
    subprocess.call(["ping", "-c1", "-n", "-i0.1", "-W1", i])

Das Warteintervall (-i0.1) kann für Automatisierungen wichtig sein, selbst ein Timeout von einer Sekunde (-t1) kann über einen Wert von 0,0/24 ewig dauern

EDIT: Um ICMP-Anforderungen (Ping-Anfragen) zu verfolgen, können wir beispielsweise Folgendes tun:

#!/usr/bin/env python

import subprocess
import ipaddress

alive = []
subnet = ipaddress.ip_network('192.168.1.0/23', strict=False)
for i in subnet.hosts():
    i = str(i)
    retval = subprocess.call(["ping", "-c1", "-n", "-i0.1", "-W1", i])
    if retval == 0:
        alive.append(i)
for ip in alive:
    print(ip + " is alive") 

Was wird so etwas zurückgeben:

192.168.0.1 is alive
192.168.0.2 is alive
192.168.1.1 is alive
192.168.1.246 is alive

alle IPs, die auf ICMP reagieren, erstrecken sich über eine ganze/23 - Ziemlich cool!

0
andylukem