Überprüfen der Netzwerkverbindung

Ich möchte sehen, ob ich auf eine Online-API zugreifen kann, aber dafür muss ich über einen Internetzugang verfügen.

Wie kann ich feststellen, ob mit Python eine Verbindung verfügbar und aktiv ist?

Vielleicht könnten Sie so etwas gebrauchen:

import urllib2

def internet_on():
    try:
        urllib2.urlopen('http://216.58.192.142', timeout=1)
        return True
    except urllib2.URLError as err: 
        return False

Derzeit ist 216.58.192.142 eine der IP-Adressen für google.com. Wechseln Sie http://216.58.192.142zu einer beliebigen Site, von der erwartet werden kann, dass sie schnell reagiert .

Diese feste IP wird nicht für immer auf google.com abgebildet. Dieser Code ist also nicht robust - er muss ständig gewartet werden, damit er funktioniert.

Der Grund, warum der obige Code eine feste IP-Adresse anstelle eines vollqualifizierten Domänennamens (FQDN) verwendet, liegt darin, dass ein FQDN eine DNS-Suche erfordern würde. Wenn der Computer keine funktionierende Internetverbindung hat, blockiert die DNS-Suche selbst den Anruf möglicherweise urllib_request.urlopenlänger als eine Sekunde. Vielen Dank an @rzetterberg für diesen Hinweis.

Wenn die oben angegebene feste IP-Adresse nicht funktioniert, können Sie eine aktuelle IP-Adresse für google.com (unter Unix) finden, indem Sie ausführen

% dig google.com  +trace 
...
google.com.     300 IN  A   216.58.192.142

Wenn wir eine Verbindung zu einem Internet-Server herstellen können, haben wir tatsächlich Konnektivität. Für den schnellsten und zuverlässigsten Ansatz sollten jedoch alle Lösungen mindestens die folgenden Anforderungen erfüllen:

• Vermeiden Sie die DNS-Auflösung (wir benötigen eine IP, die bekannt ist und garantiert die meiste Zeit verfügbar ist).
• Vermeiden Sie Verbindungen auf Anwendungsebene (Verbindung zu einem HTTP / FTP / IMAP-Dienst)
• Vermeiden Sie Aufrufe externer Dienstprogramme von Python oder einer anderen Sprache Ihrer Wahl (wir müssen eine sprachunabhängige Lösung entwickeln, die nicht auf Lösungen von Drittanbietern basiert).

Um dies zu erreichen, könnte ein Ansatz darin bestehen, zu überprüfen, ob einer der öffentlichen DNS-Server von Google erreichbar ist. Die IPv4-Adressen für diese Server sind 8.8.8.8und 8.8.4.4. Wir können versuchen, eine Verbindung zu einem von ihnen herzustellen.

Eine kurze Nmap des Hosts 8.8.8.8ergab das folgende Ergebnis:

$ sudo nmap 8.8.8.8

Starting Nmap 6.40 ( http://nmap.org ) at 2015-10-14 10:17 IST
Nmap scan report for google-public-dns-a.google.com (8.8.8.8)
Host is up (0.0048s latency).
Not shown: 999 filtered ports
PORT   STATE SERVICE
53/tcp open  domain

Nmap done: 1 IP address (1 host up) scanned in 23.81 seconds

Wie wir sehen können, 53/tcpist offen und nicht gefiltert. Wenn Sie kein Root-Benutzer sind, denken Sie daran, sudodas -PnArgument für Nmap zu verwenden, um gestaltete Testpakete zu senden und festzustellen, ob ein Host aktiv ist.

Bevor wir es mit Python versuchen, testen wir die Konnektivität mit einem externen Tool, Netcat:

$ nc 8.8.8.8 53 -zv
Connection to 8.8.8.8 53 port [tcp/domain] succeeded!

Netcat bestätigt , dass wir erreichen können 8.8.8.8über 53/tcp. Jetzt können wir eine Socket-Verbindung zu 8.8.8.8:53/tcpin Python einrichten , um die Verbindung zu überprüfen:

import socket

def internet(host="8.8.8.8", port=53, timeout=3):
    """
    Host: 8.8.8.8 (google-public-dns-a.google.com)
    OpenPort: 53/tcp
    Service: domain (DNS/TCP)
    """
    try:
        socket.setdefaulttimeout(timeout)
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
        return True
    except socket.error as ex:
        print(ex)
        return False

internet()

Ein anderer Ansatz könnte darin bestehen, einen manuell erstellten DNS-Test an einen dieser Server zu senden und auf eine Antwort zu warten. Ich gehe jedoch davon aus, dass es sich im Vergleich zu Paketverlusten, Fehlern bei der DNS-Auflösung usw. als langsamer erweisen könnte. Bitte kommentieren Sie, wenn Sie etwas anderes denken.

UPDATE 1: Dank des Kommentars von @ theamk ist das Zeitlimit jetzt ein Argument und 3swird standardmäßig initialisiert .

UPDATE 2: Ich habe schnelle Tests durchgeführt, um die schnellste und allgemeinste Implementierung aller gültigen Antworten auf diese Frage zu ermitteln. Hier ist die Zusammenfassung:

$ ls *.py | sort -n | xargs -I % sh -c 'echo %; ./timeit.sh %; echo'
defos.py
True
00:00:00:00.487

iamaziz.py
True
00:00:00:00.335

ivelin.py
True
00:00:00:00.105

jaredb.py
True
00:00:00:00.533

kevinc.py
True
00:00:00:00.295

unutbu.py
True
00:00:00:00.546

7h3rAm.py
True
00:00:00:00.032

Und noch einmal:

$ ls *.py | sort -n | xargs -I % sh -c 'echo %; ./timeit.sh %; echo'
defos.py
True
00:00:00:00.450

iamaziz.py
True
00:00:00:00.358

ivelin.py
True
00:00:00:00.099

jaredb.py
True
00:00:00:00.585

kevinc.py
True
00:00:00:00.492

unutbu.py
True
00:00:00:00.485

7h3rAm.py
True
00:00:00:00.035

TrueIn der obigen Ausgabe bedeutet dies, dass alle diese Implementierungen der jeweiligen Autoren die Konnektivität zum Internet korrekt identifizieren. Die Zeit wird mit einer Auflösung von Millisekunden angezeigt.

UPDATE 3: Nach der Änderung der Ausnahmebehandlung erneut getestet:

defos.py
True
00:00:00:00.410

iamaziz.py
True
00:00:00:00.240

ivelin.py
True
00:00:00:00.109

jaredb.py
True
00:00:00:00.520

kevinc.py
True
00:00:00:00.317

unutbu.py
True
00:00:00:00.436

7h3rAm.py
True
00:00:00:00.030

Es ist schneller, nur eine HEAD-Anfrage zu stellen, damit kein HTML-Code abgerufen wird.
Ich bin mir auch sicher, dass Google es auf diese Weise besser mögen würde :)

try:
    import httplib
except:
    import http.client as httplib

def have_internet():
    conn = httplib.HTTPConnection("www.google.com", timeout=5)
    try:
        conn.request("HEAD", "/")
        conn.close()
        return True
    except:
        conn.close()
        return False

Als Alternative zu den Antworten von ubutnu / Kevin C verwende ich das requestsPaket wie folgt :

import requests

def connected_to_internet(url='http://www.google.com/', timeout=5):
    try:
        _ = requests.get(url, timeout=timeout)
        return True
    except requests.ConnectionError:
        print("No internet connection available.")
    return False

Bonus: Dies kann auf diese Funktion erweitert werden, die eine Website pingt.

def web_site_online(url='http://www.google.com/', timeout=5):
    try:
        req = requests.get(url, timeout=timeout)
        # HTTP errors are not raised by default, this statement does that
        req.raise_for_status()
        return True
    except requests.HTTPError as e:
        print("Checking internet connection failed, status code {0}.".format(
        e.response.status_code))
    except requests.ConnectionError:
        print("No internet connection available.")
    return False

Nur um zu aktualisieren, was unutbu für neuen Code in Python 3.2 gesagt hat

def check_connectivity(reference):
    try:
        urllib.request.urlopen(reference, timeout=1)
        return True
    except urllib.request.URLError:
        return False

Und um nur zu beachten, die Eingabe hier (Referenz) ist die URL, die Sie überprüfen möchten: Ich schlage vor, etwas zu wählen, das sich schnell mit Ihrem Wohnort verbindet - dh ich lebe in Südkorea, daher würde ich wahrscheinlich auf http: / verweisen. /www.naver.com .

Sie können einfach versuchen, Daten herunterzuladen, und wenn die Verbindung fehlschlägt, wissen Sie, dass etwas mit der Verbindung nicht in Ordnung ist.

Grundsätzlich können Sie nicht überprüfen, ob der Computer mit dem Internet verbunden ist. Es kann viele Gründe für einen Fehler geben, z. B. falsche DNS-Konfiguration, Firewalls, NAT. Selbst wenn Sie einige Tests durchführen, können Sie nicht garantieren, dass Sie eine Verbindung mit Ihrer API haben, bis Sie es versuchen.

import urllib

def connected(host='http://google.com'):
    try:
        urllib.urlopen(host)
        return True
    except:
        return False

# test
print( 'connected' if connected() else 'no internet!' )

Verwenden Sie für Python 3 urllib.request.urlopen(host)

Versuchen Sie die Operation, die Sie trotzdem versucht haben. Wenn es fehlschlägt, sollte Python eine Ausnahme auslösen, um Sie zu informieren.

Wenn Sie zuerst eine triviale Operation versuchen, um eine Verbindung zu erkennen, wird eine Race-Bedingung eingeführt. Was ist, wenn die Internetverbindung beim Testen gültig ist, aber ausfällt, bevor Sie die eigentliche Arbeit erledigen müssen?

Dies funktioniert möglicherweise nicht, wenn der lokale Host von 127.0.0.1 Try geändert wurde

import socket
ipaddress=socket.gethostbyname(socket.gethostname())
if ipaddress=="127.0.0.1":
    print("You are not connected to the internet!")
else:
    print("You are connected to the internet with the IP address of "+ ipaddress )

Sofern nicht bearbeitet, lautet die IP-Adresse Ihres Computers 127.0.0.1, wenn keine Verbindung zum Internet besteht. Dieser Code erhält im Grunde die IP-Adresse und fragt dann, ob es sich um die IP-Adresse des lokalen Hosts handelt. hoffentlich hilft das

Hier ist meine Version

import requests

try:
    if requests.get('https://google.com').ok:
        print("You're Online")
except:
    print("You're Offline")

Eine moderne tragbare Lösung mit requests:

import requests

def internet():
    """Detect an internet connection."""

    connection = None
    try:
        r = requests.get("https://google.com")
        r.raise_for_status()
        print("Internet connection detected.")
        connection = True
    except:
        print("Internet connection not detected.")
        connection = False
    finally:
        return connection

Oder eine Version, die eine Ausnahme auslöst:

import requests
from requests.exceptions import ConnectionError

def internet():
    """Detect an internet connection."""

    try:
        r = requests.get("https://google.com")
        r.raise_for_status()
        print("Internet connection detected.")
    except ConnectionError as e:
        print("Internet connection not detected.")
        raise e

Der beste Weg, dies zu tun, besteht darin, eine IP-Adresse zu überprüfen, die Python immer angibt, wenn die Website nicht gefunden werden kann. In diesem Fall ist dies mein Code:

import socket

print("website connection checker")
while True:
    website = input("please input website: ")
    print("")
    print(socket.gethostbyname(website))
    if socket.gethostbyname(website) == "92.242.140.2":
        print("Website could be experiencing an issue/Doesn't exist")
    else:
        socket.gethostbyname(website)
        print("Website is operational!")
        print("")

Mein Favorit, wenn Skripte in einem Cluster ausgeführt werden oder nicht

import subprocess

def online(timeout):
    try:
        return subprocess.run(
            ['wget', '-q', '--spider', 'google.com'],
            timeout=timeout
        ).returncode == 0
    except subprocess.TimeoutExpired:
        return False

Dies läuft leise und lädt nichts herunter, sondern überprüft, ob die angegebene Remote-Datei im Web vorhanden ist

Unter unutbu Antwort als Ausgangspunkt, und in der Vergangenheit durch eine „statische“ IP - Adresse verbrannt wurde, Ändern, ich eine einfache Klasse gemacht habe , dass die Kontrollen einmal einen DNS - Lookup verwenden (dh unter Verwendung der URL " https: // www .google.com ") und speichert dann die IP-Adresse des antwortenden Servers zur Verwendung bei nachfolgenden Überprüfungen. Auf diese Weise ist die IP-Adresse immer auf dem neuesten Stand (vorausgesetzt, die Klasse wird mindestens alle paar Jahre neu initialisiert). Ich gebe gawry auch Anerkennung für diese Antwort , die mir zeigte, wie ich die IP-Adresse des Servers erhalte (nach jeder Umleitung usw.). Bitte ignorieren Sie die offensichtliche Hackigkeit dieser Lösung. Ich werde hier ein minimales Arbeitsbeispiel anführen. :) :)

Folgendes habe ich:

import socket

try:
    from urllib2 import urlopen, URLError
    from urlparse import urlparse
except ImportError:  # Python 3
    from urllib.parse import urlparse
    from urllib.request import urlopen, URLError

class InternetChecker(object):
    conn_url = 'https://www.google.com/'

    def __init__(self):
        pass

    def test_internet(self):
        try:
            data = urlopen(self.conn_url, timeout=5)
        except URLError:
            return False

        try:
            host = data.fp._sock.fp._sock.getpeername()
        except AttributeError:  # Python 3
            host = data.fp.raw._sock.getpeername()

        # Ensure conn_url is an IPv4 address otherwise future queries will fail
        self.conn_url = 'http://' + (host[0] if len(host) == 2 else
                                     socket.gethostbyname(urlparse(data.geturl()).hostname))

        return True

# Usage example
checker = InternetChecker()
checker.test_internet()

Ich nehme an, wir könnten die Antwort von Six irgendwie vereinfachen, ein wichtiges Thema, da Neuankömmlinge in hochtechnischen Angelegenheiten verloren gehen.

Hier werde ich endlich warten, bis meine Verbindung (3G, langsam) einmal täglich für meine PV-Überwachung hergestellt ist.

Funktioniert unter Pyth3 mit Raspbian 3.4.2

from urllib.request import urlopen
from time import sleep
urltotest=http://www.lsdx.eu             # my own web page
nboftrials=0
answer='NO'
while answer=='NO' and nboftrials<10:
    try:
        urlopen(urltotest)
        answer='YES'
    except:
        essai='NO'
        nboftrials+=1
        sleep(30)       

Maximaler Lauf: 5 Minuten, wenn erreicht, werde ich es in einer Stunde versuchen, aber es ist ein weiteres Stück Skript!

Nehmen Sie die Antwort von Ivelin und fügen Sie eine zusätzliche Überprüfung hinzu, da mein Router seine IP-Adresse 192.168.0.1 liefert und einen Kopf zurückgibt, wenn er bei der Abfrage von google.com keine Internetverbindung hat.

import socket

def haveInternet():
    try:
        # first check if we get the correct IP-Address or just the router's IP-Address
        info = socket.getaddrinfo("www.google.com", None)[0]
        ipAddr = info[4][0]
        if ipAddr == "192.168.0.1" :
            return False
    except:
        return False

    conn = httplib.HTTPConnection("www.google.com", timeout=5)
    try:
        conn.request("HEAD", "/")
        conn.close()
        return True
    except:
        conn.close()
        return False

Dies funktioniert bei mir in Python3.6

import urllib
from urllib.request import urlopen


def is_internet():
    """
    Query internet using python
    :return:
    """
    try:
        urlopen('https://www.google.com', timeout=1)
        return True
    except urllib.error.URLError as Error:
        print(Error)
        return False


if is_internet():
    print("Internet is active")
else:
    print("Internet disconnected")

Ich habe ein paar zu Joels Code hinzugefügt.

    import socket,time
    mem1 = 0
    while True:
        try:
                host = socket.gethostbyname("www.google.com") #Change to personal choice of site
                s = socket.create_connection((host, 80), 2)
                s.close()
                mem2 = 1
                if (mem2 == mem1):
                    pass #Add commands to be executed on every check
                else:
                    mem1 = mem2
                    print ("Internet is working") #Will be executed on state change

        except Exception as e:
                mem2 = 0
                if (mem2 == mem1):
                    pass
                else:
                    mem1 = mem2
                    print ("Internet is down")
        time.sleep(10) #timeInterval for checking

Für meine Projekte verwende ich ein Skript, das so geändert wurde , dass es den öffentlichen DNS-Server von Google 8.8.8.8 anpingt. Verwenden eines Timeouts von 1 Sekunde und Kernpythonbibliotheken ohne externe Abhängigkeiten:

import struct
import socket
import select


def send_one_ping(to='8.8.8.8'):
   ping_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp'))
   checksum = 49410
   header = struct.pack('!BBHHH', 8, 0, checksum, 0x123, 1)
   data = b'BCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwx'
   header = struct.pack(
      '!BBHHH', 8, 0, checksum, 0x123, 1
   )
   packet = header + data
   ping_socket.sendto(packet, (to, 1))
   inputready, _, _ = select.select([ping_socket], [], [], 1.0)
   if inputready == []:
      raise Exception('No internet') ## or return False
   _, address = ping_socket.recvfrom(2048)
   print(address) ## or return True


send_one_ping()

Der Select - Timeout - Wert ist 1, kann aber eine Gleitkommazahl der Wahl sein , leichter als die 1 Sekunde in diesem Beispiel zu versagen.

Importieren Sie Anfragen und probieren Sie diesen einfachen Python-Code aus.

def check_internet():
url = 'http://www.google.com/'
timeout = 5
try:
    _ = requests.get(url, timeout=timeout)
    return True
except requests.ConnectionError:
return False