पायथन में एक साइट पिंग?

Question 1

मैं पायथन के साथ एक वेबसाइट या आईपी पते को कैसे पिंग करूं?

Question 2

मैथ्यू डिक्सन काउल और जेन्स डायमर द्वारा इस शुद्ध अजगर पिंग को देखें । इसके अलावा, याद रखें कि पायथन को रूट को लिनक्स में ICMP (यानी पिंग) सॉकेट की आवश्यकता होती है।

import ping, socket
try:
    ping.verbose_ping('www.google.com', count=3)
    delay = ping.Ping('www.wikipedia.org', timeout=2000).do()
except socket.error, e:
    print "Ping Error:", e

स्रोत कोड खुद को पढ़ने के लिए आसान है, प्रेरणा verbose_pingके Ping.doलिए के कार्यान्वयन को देखें ।

Question 3

आप क्या हासिल करना चाहते हैं इसके आधार पर, आप शायद सिस्टम पिंग कमांड को कॉल करना सबसे आसान है।

सबप्रोसेस मॉड्यूल का उपयोग करना ऐसा करने का सबसे अच्छा तरीका है, हालाँकि आपको याद रखना होगा कि पिंग कमांड अलग-अलग ऑपरेटिंग सिस्टम पर अलग है!

import subprocess

host = "www.google.com"

ping = subprocess.Popen(
    ["ping", "-c", "4", host],
    stdout = subprocess.PIPE,
    stderr = subprocess.PIPE
)

out, error = ping.communicate()
print out

आपको शेल-एस्केप पात्रों के बारे में चिंता करने की आवश्यकता नहीं है। उदाहरण के लिए..

host = "google.com; `echo test`

.. इको कमांड निष्पादित नहीं करेंगे ।

अब, वास्तव में पिंग परिणाम प्राप्त करने के लिए, आप outचर को पार्स कर सकते हैं । उदाहरण आउटपुट:

round-trip min/avg/max/stddev = 248.139/249.474/250.530/0.896 ms

उदाहरण रेगेक्स:

import re
matcher = re.compile("round-trip min/avg/max/stddev = (\d+.\d+)/(\d+.\d+)/(\d+.\d+)/(\d+.\d+)")
print matcher.search(out).groups()

# ('248.139', '249.474', '250.530', '0.896')

फिर से, याद रखें कि ऑपरेटिंग सिस्टम (और यहां तक कि संस्करण ping) के आधार पर आउटपुट अलग-अलग होगा । यह आदर्श नहीं है, लेकिन यह कई स्थितियों में ठीक काम करेगा (जहां आप जानते हैं कि मशीनों को स्क्रिप्ट चालू होगी)

Question 4

आपको पायथन के साथ नोहा गिफ्ट की प्रस्तुति क्रिएटिंग एजाइल कमांडलाइन टूल्स मिल सकती है । इसमें वह सबप्रोसेस, क्यू और थ्रेडिंग को जोड़ता है ताकि समाधान विकसित किया जा सके जो मेजबानों को समतल करने और प्रक्रिया को गति देने में सक्षम हो। कमांड लाइन पार्सिंग और कुछ अन्य विशेषताओं को जोड़ने से पहले नीचे एक मूल संस्करण दिया गया है। इस संस्करण का कोड और अन्य यहां पाया जा सकता है

#!/usr/bin/env python2.5
from threading import Thread
import subprocess
from Queue import Queue

num_threads = 4
queue = Queue()
ips = ["10.0.1.1", "10.0.1.3", "10.0.1.11", "10.0.1.51"]
#wraps system ping command
def pinger(i, q):
    """Pings subnet"""
    while True:
        ip = q.get()
        print "Thread %s: Pinging %s" % (i, ip)
        ret = subprocess.call("ping -c 1 %s" % ip,
            shell=True,
            stdout=open('/dev/null', 'w'),
            stderr=subprocess.STDOUT)
        if ret == 0:
            print "%s: is alive" % ip
        else:
            print "%s: did not respond" % ip
        q.task_done()
#Spawn thread pool
for i in range(num_threads):

    worker = Thread(target=pinger, args=(i, queue))
    worker.setDaemon(True)
    worker.start()
#Place work in queue
for ip in ips:
    queue.put(ip)
#Wait until worker threads are done to exit    
queue.join()

वह भी लेखक हैं: यूनिक्स और लिनक्स सिस्टम प्रशासन के लिए पायथन

http://ecx.images-amazon.com/images/I/515qmR%2B4sjL._SL500_AA240_.jpg

Question 5

यह कहना कठिन है कि आपका प्रश्न क्या है, लेकिन कुछ विकल्प हैं।

यदि आप आईसीएमपी पिंग प्रोटोकॉल का उपयोग करके शाब्दिक रूप से अनुरोध को निष्पादित करने का मतलब रखते हैं, तो आप आईसीएमपी पुस्तकालय प्राप्त कर सकते हैं और सीधे पिंग अनुरोध को निष्पादित कर सकते हैं। Google "पायथन ICMP" इस icmplib जैसी चीजों को खोजने के लिए । आप scapy को भी देखना चाह सकते हैं ।

यह उपयोग करने की तुलना में बहुत तेज होगा os.system("ping " + ip )।

यदि आप उदारतापूर्वक "पिंग" बॉक्स से मतलब रखते हैं, तो यह देखने के लिए कि आप पोर्ट 7 पर इको प्रोटोकॉल का उपयोग कर सकते हैं।

इको के लिए, आप आईपी पते और पोर्ट को खोलने के लिए सॉकेट लाइब्रेरी का उपयोग करते हैं । 7. आप उस पोर्ट पर कुछ लिखते हैं, एक गाड़ी वापसी ( "\r\n") भेजते हैं और फिर उत्तर पढ़ते हैं।

यदि आप एक वेब साइट को "पिंग" करने का मतलब देखते हैं कि साइट चल रही है, तो आपको पोर्ट 80 पर http प्रोटोकॉल का उपयोग करना होगा।

वेब सर्वर की ठीक से जाँच करने के लिए , आप एक विशिष्ट URL खोलने के लिए urllib2 का उपयोग करते हैं । (/index.html हमेशा लोकप्रिय है) और प्रतिक्रिया पढ़ें।

अभी भी "ट्रेसरआउट" और "उंगली" सहित "पिंग" के अधिक संभावित अर्थ हैं।

Question 6

मैंने एक प्रेरणा के रूप में इस तरह से कुछ किया:

import urllib
import threading
import time

def pinger_urllib(host):
  """
  helper function timing the retrival of index.html 
  TODO: should there be a 1MB bogus file?
  """
  t1 = time.time()
  urllib.urlopen(host + '/index.html').read()
  return (time.time() - t1) * 1000.0


def task(m):
  """
  the actual task
  """
  delay = float(pinger_urllib(m))
  print '%-30s %5.0f [ms]' % (m, delay)

# parallelization
tasks = []
URLs = ['google.com', 'wikipedia.org']
for m in URLs:
  t = threading.Thread(target=task, args=(m,))
  t.start()
  tasks.append(t)

# synchronization point
for t in tasks:
  t.join()

Question 7

यहाँ एक छोटा सा स्निपेट का उपयोग किया गया है subprocess। check_callविधि या तो सफलता के लिए 0 देता है, या एक अपवाद को जन्म देती है। इस तरह, मुझे पिंग के आउटपुट को पार्स नहीं करना है। मैं shlexकमांड लाइन के तर्कों को विभाजित करने के लिए उपयोग कर रहा हूं ।

  import subprocess
  import shlex

  command_line = "ping -c 1 www.google.comsldjkflksj"
  args = shlex.split(command_line)
  try:
      subprocess.check_call(args,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
      print "Website is there."
  except subprocess.CalledProcessError:
      print "Couldn't get a ping."

Question 8

फ़ाइल का नाम पढ़ें, फ़ाइल में प्रति पंक्ति एक यूआरएल शामिल है, जैसे:

http://www.poolsaboveground.com/apache/hadoop/core/
http://mirrors.sonic.net/apache/hadoop/core/

कमांड का उपयोग करें:

python url.py urls.txt

परिणाम प्राप्त करें:

Round Trip Time: 253 ms - mirrors.sonic.net
Round Trip Time: 245 ms - www.globalish.com
Round Trip Time: 327 ms - www.poolsaboveground.com

स्रोत कोड (url.py):

import re
import sys
import urlparse
from subprocess import Popen, PIPE
from threading import Thread


class Pinger(object):
    def __init__(self, hosts):
        for host in hosts:
            hostname = urlparse.urlparse(host).hostname
            if hostname:
                pa = PingAgent(hostname)
                pa.start()
            else:
                continue

class PingAgent(Thread):
    def __init__(self, host):
        Thread.__init__(self)        
        self.host = host

    def run(self):
        p = Popen('ping -n 1 ' + self.host, stdout=PIPE)
        m = re.search('Average = (.*)ms', p.stdout.read())
        if m: print 'Round Trip Time: %s ms -' % m.group(1), self.host
        else: print 'Error: Invalid Response -', self.host


if __name__ == '__main__':
    with open(sys.argv[1]) as f:
        content = f.readlines() 
    Pinger(content)

Question 9

import subprocess as s
ip=raw_input("Enter the IP/Domain name:")
if(s.call(["ping",ip])==0):
    print "your IP is alive"
else:
    print "Check ur IP"

Question 10

यदि आप वास्तव में पाइथन में कुछ चाहते हैं, जिसके साथ आप खेल सकते हैं, तो स्केपी पर एक नज़र डालें:

from scapy.all import *
request = IP(dst="www.google.com")/ICMP()
answer = sr1(request)

कुछ फंकी सबप्रोसेस कॉल की तुलना में यह मेरी राय में बहुत बेहतर (और पूरी तरह से क्रॉस-प्लेटफॉर्म) है। साथ ही आपको उत्तर के बारे में अधिक जानकारी हो सकती है (अनुक्रम आईडी .....) जैसा आप चाहते हैं, जैसा कि आपके पास पैकेट है।

Question 11

सबसे सरल उत्तर है:

import os
os.system("ping google.com")

Question 12

आप उल्लेखित स्क्रिप्ट का एक अद्यतन संस्करण पा सकते हैं जो यहां विंडोज और लिनक्स दोनों पर काम करता है

Question 13

मैं एक पुस्तकालय विकसित करता हूं जो मुझे लगता है कि आपकी मदद कर सकता है। इसे icmplib कहा जाता है (उसी नाम के किसी भी अन्य कोड से संबंधित है जो इंटरनेट पर पाया जा सकता है) और पायथन में ICMP प्रोटोकॉल का शुद्ध कार्यान्वयन है।

यह पूरी तरह से ऑब्जेक्ट ओरिएंटेड है और इसमें सरल कार्य हैं जैसे कि क्लासिक पिंग, मल्टीपिंग और ट्रेसरआउट, साथ ही निम्न स्तर की कक्षाएं और उन लोगों के लिए सॉकेट जो आईसीएमपी प्रोटोकॉल के आधार पर एप्लिकेशन विकसित करना चाहते हैं।

यहाँ कुछ अन्य मुख्य बातें हैं:

बिना रूट विशेषाधिकार के चलाया जा सकता है।
आप ICMP पैकेट और ट्रैफ़िक क्लास (QoS) के पेलोड जैसे कई मापदंडों को अनुकूलित कर सकते हैं।
क्रॉस-प्लेटफॉर्म: लिनक्स, मैकओएस और विंडोज पर परीक्षण किया गया।
उपप्रकार के साथ किए गए कॉल के विपरीत फास्ट और कुछ सीपीयू / रैम संसाधनों की आवश्यकता है।
लाइटवेट और किसी भी अतिरिक्त निर्भरता पर निर्भर नहीं करता है।

इसे स्थापित करने के लिए (अजगर 3.6+ आवश्यक):

pip3 install icmplib

यहाँ पिंग फ़ंक्शन का एक सरल उदाहरण है:

host = ping('1.1.1.1', count=4, interval=1, timeout=2, privileged=True)

if host.is_alive:
    print(f'{host.address} is alive! avg_rtt={host.avg_rtt} ms')
else:
    print(f'{host.address} is dead')

यदि आप रूट विशेषाधिकार के बिना लाइब्रेरी का उपयोग करना चाहते हैं, तो "विशेषाधिकार प्राप्त" पैरामीटर को गलत पर सेट करें।

आप परियोजना पृष्ठ पर पूर्ण प्रलेखन पा सकते हैं: https://github.com/ValentinBELYN/icmplib

आशा है कि आप इस पुस्तकालय को उपयोगी पाएंगे।

Question 14

मेजबानों की सूची को पिंग करने के लिए सिस्टम पिंग कमांड का उपयोग करना:

import re
from subprocess import Popen, PIPE
from threading import Thread


class Pinger(object):
    def __init__(self, hosts):
        for host in hosts:
            pa = PingAgent(host)
            pa.start()

class PingAgent(Thread):
    def __init__(self, host):
        Thread.__init__(self)        
        self.host = host

    def run(self):
        p = Popen('ping -n 1 ' + self.host, stdout=PIPE)
        m = re.search('Average = (.*)ms', p.stdout.read())
        if m: print 'Round Trip Time: %s ms -' % m.group(1), self.host
        else: print 'Error: Invalid Response -', self.host


if __name__ == '__main__':
    hosts = [
        'www.pylot.org',
        'www.goldb.org',
        'www.google.com',
        'www.yahoo.com',
        'www.techcrunch.com',
        'www.this_one_wont_work.com'
       ]
    Pinger(hosts)

Question 15

सबप्रोसेस पिंग कमांड का उपयोग करके पिंग को डीकोड करना क्योंकि प्रतिक्रिया द्विआधारी है:

import subprocess
ping_response = subprocess.Popen(["ping", "-a", "google.com"], stdout=subprocess.PIPE).stdout.read()
result = ping_response.decode('utf-8')
print(result)

Question 16

आप साइट के आईपी पाने के लिए सॉकेट की कोशिश कर सकते हैं और आईपी के लिए icmp पिंग करने के लिए स्क्रैप का उपयोग कर सकते हैं।

import gevent
from gevent import monkey
# monkey.patch_all() should be executed before any library that will
# standard library
monkey.patch_all()

import socket
from scapy.all import IP, ICMP, sr1


def ping_site(fqdn):
    ip = socket.gethostbyaddr(fqdn)[-1][0]
    print(fqdn, ip, '\n')
    icmp = IP(dst=ip)/ICMP()
    resp = sr1(icmp, timeout=10)
    if resp:
        return (fqdn, False)
    else:
        return (fqdn, True)


sites = ['www.google.com', 'www.baidu.com', 'www.bing.com']
jobs = [gevent.spawn(ping_site, fqdn) for fqdn in sites]
gevent.joinall(jobs)
print([job.value for job in jobs])

Question 17

इसका उपयोग अजगर 2.7 पर परीक्षण किया गया है और यह ठीक काम करता है यदि मिलीसेकंड में पिंग का समय वापस आता है तो सफलता मिलती है और असफलता लौटती है।

import platform,subproccess,re
def Ping(hostname,timeout):
    if platform.system() == "Windows":
        command="ping "+hostname+" -n 1 -w "+str(timeout*1000)
    else:
        command="ping -i "+str(timeout)+" -c 1 " + hostname
    proccess = subprocess.Popen(command, stdout=subprocess.PIPE)
    matches=re.match('.*time=([0-9]+)ms.*', proccess.stdout.read(),re.DOTALL)
    if matches:
        return matches.group(1)
    else: 
        return False