पायथन

Question

में एकाधिक पिंग स्क्रिप्ट मुझे पाइथन और नेटवर्किंग पर दस्तावेज़ों को सीखने में कोई आसान आसान नहीं है। इस उदाहरण में, मैं बस एक आसान स्क्रिप्ट बनाने की कोशिश कर रहा हूं जिसे मैं कई दूरस्थ मशीनों को पिंग कर सकता हूं।

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

ऐसे ही एक साधारण स्क्रिप्ट मशीनों ठीक पिंग होगा, लेकिन मैं रिटर्न 'सक्रिय' 'कोई जवाब नहीं' कौन सा मुझे लगता है कि मैं समय मॉड्यूल को देखने के लिए होगा बनाता है स्क्रिप्ट प्राप्त करना चाहते हैं साथ ही, मुझे लगता है कि time.sleep(5) और उसके बाद, एक ब्रेक स्टेटमेंट होगा। जो मुझे लगता है कि अंदर थोड़ी देर लूप होना चाहिए। मैं 100% निश्चित नहीं हूं, मैं पूरी तरह गलत दिशा में जा रहा हूं:/अगर कोई मुझे कुछ दस्तावेज की दिशा में मदद या इंगित कर सकता है जो बहुत अच्छा होगा।

Answer 1

यह स्क्रिप्ट: यदि आप subprocess.PIPE साथ limbo की जगह और Popen वस्तु पर communicate() का उपयोग

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 

आप आउटपुट को कैप्चर कर सकते हैं::

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" 

इस उत्पादन की तरह कुछ का उत्पादन करेगा

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

इस तरह आप कमांड का रिटर्न वैल्यू प्राप्त करते हैं और टेक्स्ट कैप्चर कर सकते हैं।

अंतर्निहित प्रक्रिया निर्माण और इस मॉड्यूल है popen वर्ग द्वारा नियंत्रित में प्रबंधन: manual इस के बाद एक उपप्रक्रिया संचालित करने के लिए यदि आप लचीलेपन की जरूरत है पसंदीदा तरीका है। यह बहुत लचीलापन प्रदान करता है ताकि डेवलपर्स सुविधा कार्यों द्वारा कवर न किए गए कम आम मामलों को संभालने में सक्षम हैं।

Answer 2

subprocess.call आज़माएं। यह उस प्रोग्राम के रिटर्न वैल्यू को बचाता है जिसका इस्तेमाल किया गया था।

मेरे पिंग मैनुअल के मुताबिक, यह सफलता पर 0 लौटाता है, 2 जब पिंग्स भेजे जाते थे लेकिन कोई जवाब नहीं मिला और कोई अन्य मान किसी त्रुटि को इंगित करता है।

# 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!" 

Answer 3

एक ही बार में आप subprocess.Popen() इस्तेमाल कर सकते हैं कई मेजबान पिंग करने के लिए:

#!/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 

आप इस्तेमाल कर सकते हैं आप एक रूट के रूप में दिखाया जा सकता है एक pure Python ping script या 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")) 

Answer 4

तुम इतने धन्यवाद इसके लिए बहुत कुछ। मैंने विंडोज़ के साथ काम करने के लिए इसे संशोधित किया है। मैंने भी कम टाइमआउट डाला है, इसलिए आईपी का कोई रिटर्न नहीं होगा और प्रत्येक 5 सेकंड तक इंतजार नहीं करेगा। यह होचल स्रोत कोड से है।

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" 

बस अपनी योजना के लिए आईपी = और मेजबान के लिए xrange बदलें।

Answer 5

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") 

Answer 6

मैं एक नौसिखिया हूं और कई मेजबानों को पिंग करने के लिए एक स्क्रिप्ट लिखी है। एकाधिक होस्ट पिंग करने के लिए आप ipaddress मॉड्यूल का उपयोग कर सकते हैं।

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") 

Answer 7

import subprocess,os,threading,time 
from queue import Queue 
lock=threading.Lock() 
_start=time.time() 
def check(n): 
    with open(os.devnull, "wb") as limbo: 
       ip="192.168.21.{0}".format(n) 
       result=subprocess.Popen(["ping", "-n", "1", "-w", "300", ip],stdout=limbo, stderr=limbo).wait() 
       with lock:      
        if not result: 
         print (ip, "active")      
        else: 
         pass       

def threader(): 
    while True: 
     worker=q.get() 
     check(worker) 
     q.task_done() 
q=Queue() 

for x in range(255): 
    t=threading.Thread(target=threader) 
    t.daemon=True 
    t.start() 
for worker in range(1,255): 
    q.put(worker) 
q.join() 
print("Process completed in: ",time.time()-_start) 

मुझे लगता है कि यह बेहतर हो जाएगा।

Answer 8

पायथन वास्तव में वास्तव में मीठा method है जो 'नेटवर्क में उपयोग करने योग्य होस्टों पर एक पुनरावर्तक लौटाएगा'।

उदाहरण के लिए (सभी IP से अधिक झूठी दोहराता का कड़ाई से स्थापित करने):

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]) 

प्रतीक्षा अंतराल (-i0.1) स्वचालन के लिए महत्वपूर्ण हो सकता है, यहां तक ​​कि एक एक सेकंड टाइमआउट (-t1) ले जा सकते हैं हमेशा के लिए खत्म हो गया एक .0/24

संपादित: तो, क्रम ICMP (पिंग) अनुरोधों को ट्रैक करने में, हम कुछ इस तरह कर सकते हैं:

#!/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") 

कौन सा की तरह कुछ वापस आ जाएगी:

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

अर्थात ICMP का जवाब आईपी एक पूरे के ऊपर लेकर के सभी/23-- बहुत अच्छा!