Welche Python-Methode würden Sie vorschlagen, um Whois-Datenbankeinträge zu überprüfen?
https://stackoverflow.com/questions/50394
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich versuche, einen Webservice zum Laufen zu bringen, der tatsächlich die Überprüfung von Whois-Datenbanken erfordert.Was ich gerade mache, ist hässlich und ich möchte es so weit wie möglich vermeiden:Ich rufe den Befehl gwhois auf und analysiere seine Ausgabe.Hässlich.
Ich habe eine Suche durchgeführt, um eine pythonische Möglichkeit zu finden, diese Aufgabe zu erledigen.Generell habe ich so gut wie nichts bekommen - dieser alte Link zur Diskussionsliste verfügt über eine Möglichkeit zu überprüfen, ob eine Domäne vorhanden ist.Ganz und gar nicht das, was ich gesucht habe...Trotzdem war es die beste Antwort, die Google mir gegeben hat – alles andere sind nur ein Haufen unbeantworteter Fragen.
Ist es jemandem von euch gelungen, eine Methode zum Laufen zu bringen?Ich würde mich sehr über ein paar Tipps freuen, oder sollte ich es einfach auf Open-Source-Art machen, mich hinsetzen und selbst etwas programmieren?:) :)
Lösung
Es ist nichts Falsches daran, ein Befehlszeilenprogramm zu verwenden, um das zu tun, was Sie wollen.Wenn Sie den Dienst schön umhüllen, können Sie die Interna nach Ihren Wünschen implementieren!Zum Beispiel:
class Whois(object):
_whois_by_query_cache = {}
def __init__(self, query):
"""Initializes the instance variables to defaults. See :meth:`lookup`
for details on how to submit the query."""
self.query = query
self.domain = None
# ... other fields.
def lookup(self):
"""Submits the `whois` query and stores results internally."""
# ... implementation
Unabhängig davon, ob Sie Ihre eigene Bibliothek mithilfe von urllib rollen oder nicht, ein Befehlszeilenprogramm umschließen (wie Sie es tun) oder eine Bibliothek eines Drittanbieters importieren und diese verwenden (z. B du sagst), bleibt diese Schnittstelle gleich.
Dieser Ansatz wird im Allgemeinen überhaupt nicht als hässlich angesehen – Manchmal machen Befehlsdienstprogramme das, was Sie wollen, und Sie sollten in der Lage sein, sie zu nutzen.Wenn die Geschwindigkeit zum Engpass wird, macht Ihre Abstraktion den Wechsel zu einer nativen Python-Implementierung für Ihren Client-Code transparent.
Praktikabilität übertrifft Reinheit – das ist Pythonic.:) :)
Andere Tipps
Schau dir das an:http://code.google.com/p/pywhois/
pywhois – Python-Modul zum Abrufen von WHOIS-Informationen von Domains
Ziel:- Erstellen Sie ein einfaches importierbares Python-Modul, das analysierte WHOIS-Daten für eine bestimmte Domäne erzeugt.- In der Lage, Daten für alle beliebten TLDs (com, org, net, ...) zu extrahieren - Fragen Sie einen Whois -Server direkt ab, anstatt einen Zwischendienst wie viele andere zu durchlaufen.- Funktioniert mit Python 2.4+ und ohne externe Abhängigkeiten
Beispiel:
>>> import pywhois
>>> w = pywhois.whois('google.com')
>>> w.expiration_date
['14-sep-2011']
>>> w.emails
['contact-admin@google.com',
'dns-admin@google.com',
'dns-admin@google.com',
'dns-admin@google.com']
>>> print w
...
Ich habe diese Frage bei meiner eigenen Suche nach einer Python-Whois-Bibliothek gefunden.
Ich weiß nicht, dass ich der Antwort von CDleary zustimme, dass es immer der beste Weg ist, wenn eine Bibliothek mit einer Bibliothek einbezogen wird - aber ich kann seine Gründe sehen, warum er das gesagt hat.
Profi:cmd-line whois übernimmt die ganze harte Arbeit (Socket-Aufrufe, Parsing usw.)
Nachteil:nicht tragbar;Abhängig vom zugrunde liegenden Whois-Befehl funktioniert das Modul möglicherweise nicht.Langsamer, da zusätzlich zum Whois-Befehl ein Befehl und höchstwahrscheinlich eine Shell ausgeführt wird.Betroffen, wenn nicht Unix (Windows), unterschiedliche Unix, ältere Unix oder älterer WHOIS -Befehl
Ich suche nach einem Whois-Modul, das Whois-IP-Suchen verarbeiten kann, und bin nicht daran interessiert, meinen eigenen Whois-Client zu programmieren.
Hier sind die Module, die ich (leicht) ausprobiert habe, und weitere Informationen dazu:
pywhoisapi:
- Heim: http://code.google.com/p/pywhoisapi/
- Design:REST-Client, der auf den ARIN-whois-REST-Dienst zugreift
- Vorteile:Kann IP-Adresssuchen verarbeiten
- Nachteile:Können Informationen von Whois-Servern anderer RIRs abgerufen werden?
BulkWhois
- Heim: http://pypi.python.org/pypi/BulkWhois/0.2.1
- Design:Telnet-Client greift über RIR auf die Whois-Telnet-Abfrageschnittstelle zu (?)
- Vorteile:Kann IP-Adresssuchen verarbeiten
- Nachteile:Können Informationen von Whois-Servern anderer RIRs abgerufen werden?
pywhois:
- Heim: http://code.google.com/p/pywhois/
- Design:REST-Client, der auf RRID-Whois-Dienste zugreift
- Vorteile:Greift auf viele RRIDs zu;hat einen Python 3.x-Zweig
- Nachteile:scheint die Suche nach IP-Adressen nicht zu verarbeiten
Python-whois:
- Heim: http://code.google.com/p/python-whois/
- Design:Umschließt den „whois“-Befehl
- Nachteile:scheint die Suche nach IP-Adressen nicht zu verarbeiten
whoisclient – Fork von Python-whois
- Heim: http://gitorious.org/python-whois
- Design:Umschließt den „whois“-Befehl
- Kommt drauf an:IPy.py
- Nachteile:scheint die Suche nach IP-Adressen nicht zu verarbeiten
Aktualisieren:Am Ende habe ich pywhoisapi für die Reverse-IP-Suche verwendet, die ich durchgeführt habe
Hier ist der in Python neu implementierte Whois-Client:http://code.activestate.com/recipes/577364-whois-client/
Ich weiß nicht, ob gwhois etwas Besonderes mit der Serverausgabe macht;Sie können sich jedoch auch einfach über Port Whois (43) mit dem Whois-Server verbinden, Ihre Anfrage senden, alle Daten in der Antwort lesen und sie analysieren.Um das Leben ein wenig einfacher zu machen, könnten Sie anstelle einfacher Sockets die Klasse telnetlib.Telnet verwenden (auch wenn das Whois-Protokoll viel einfacher ist als das Telnet-Protokoll).
Die kniffligen Teile:
- Welchen Whois-Server werden Sie fragen?RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO usw. LACNIC könnten ein nützlicher Ersatz sein, da sie dazu neigen, mit nützlichen Daten auf Anfragen außerhalb ihrer Domäne zu antworten.
- Was sind die genauen Optionen und Argumente für jeden Whois-Server?Manche bieten Hilfe an, andere nicht.Im Allgemeinen funktionieren einfache Domainnamen ohne besondere Optionen.
Eine andere Möglichkeit, dies zu tun, ist die Verwendung urllib2 Modul zum Analysieren des Whois-Dienstes einer anderen Seite (es gibt viele Websites dieser Art).Aber das scheint ein noch größerer Hack zu sein als das, was Sie jetzt tun, und würde Ihnen eine Abhängigkeit von der von Ihnen gewählten Whois-Site verschaffen, was schlecht ist.
Ich hasse es, es zu sagen, aber es sei denn, Sie möchten es erneut implementieren whois in Ihrem Programm (was das Rad neu erfinden würde), läuft whois auf dem Betriebssystem und das Analysieren der Ausgabe (dh das, was Sie gerade tun) scheint der richtige Weg zu sein.
Das Parsen einer anderen Webseite wäre nicht so schlimm (vorausgesetzt, ihr HTML wäre nicht sehr schlecht), aber es würde mich tatsächlich an sie binden – wenn sie down sind, bin ich down :)
Eigentlich habe ich ein altes Projekt auf SourceForge gefunden: rwhois.py.Was mir etwas Angst macht, ist, dass ihr letztes Update aus dem Jahr 2003 stammt.Aber es scheint ein guter Ort zu sein, um mit der Neuimplementierung dessen zu beginnen, was ich gerade mache ...Nun, ich fühlte mich trotzdem verpflichtet, den Link zu diesem Projekt zu posten, nur als weitere Referenz.
import socket
socket.gethostbyname_ex('url.com')
Wenn ein Gaierror zurückgegeben wird, wissen Sie, dass es bei keinem DNS registriert ist
Hier ist eine gebrauchsfertige Lösung, die für mich funktioniert.geschrieben für Python 3.1 (achten Sie beim Backportieren auf Py2.x besonders auf die Unterscheidung zwischen Bytes und Unicode-Text).Ihr einziger Zugangspunkt ist die Methode DRWHO.whois(), das die Übergabe eines Domänennamens erwartet;Anschließend wird versucht, den Namen mithilfe des als konfigurierten Anbieters aufzulösen DRWHO.whois_providers[ '*' ] (Eine umfassendere Lösung könnte Anbieter nach der Top-Level-Domain differenzieren.) DRWHO.whois() gibt ein Wörterbuch mit einem einzelnen Eintrag zurück text, der den vom WHOIS-Server zurückgesendeten Antworttext enthält.Auch hier würde eine umfassendere Lösung versuchen, den Text zu analysieren (was für jeden Anbieter separat durchgeführt werden muss, da es kein Standardformat gibt) und ein strukturierteres Format zurückzugeben (z. B. ein Flag zu setzen). available Dies gibt an, ob die Domain verfügbar zu sein scheint oder nicht).viel Spaß!
##########################################################################
import asyncore as _sys_asyncore
from asyncore import loop as _sys_asyncore_loop
import socket as _sys_socket
##########################################################################
class _Whois_request( _sys_asyncore.dispatcher_with_send, object ):
# simple whois requester
# original code by Frederik Lundh
#-----------------------------------------------------------------------
whoisPort = 43
#-----------------------------------------------------------------------
def __init__(self, consumer, host, provider ):
_sys_asyncore.dispatcher_with_send.__init__(self)
self.consumer = consumer
self.query = host
self.create_socket( _sys_socket.AF_INET, _sys_socket.SOCK_STREAM )
self.connect( ( provider, self.whoisPort, ) )
#-----------------------------------------------------------------------
def handle_connect(self):
self.send( bytes( '%s\r\n' % ( self.query, ), 'utf-8' ) )
#-----------------------------------------------------------------------
def handle_expt(self):
self.close() # connection failed, shutdown
self.consumer.abort()
#-----------------------------------------------------------------------
def handle_read(self):
# get data from server
self.consumer.feed( self.recv( 2048 ) )
#-----------------------------------------------------------------------
def handle_close(self):
self.close()
self.consumer.close()
##########################################################################
class _Whois_consumer( object ):
# original code by Frederik Lundh
#-----------------------------------------------------------------------
def __init__( self, host, provider, result ):
self.texts_as_bytes = []
self.host = host
self.provider = provider
self.result = result
#-----------------------------------------------------------------------
def feed( self, text ):
self.texts_as_bytes.append( text.strip() )
#-----------------------------------------------------------------------
def abort(self):
del self.texts_as_bytes[:]
self.finalize()
#-----------------------------------------------------------------------
def close(self):
self.finalize()
#-----------------------------------------------------------------------
def finalize( self ):
# join bytestrings and decode them (witha a guessed encoding):
text_as_bytes = b'\n'.join( self.texts_as_bytes )
self.result[ 'text' ] = text_as_bytes.decode( 'utf-8' )
##########################################################################
class DRWHO:
#-----------------------------------------------------------------------
whois_providers = {
'~isa': 'DRWHO/whois-providers',
'*': 'whois.opensrs.net', }
#-----------------------------------------------------------------------
def whois( self, domain ):
R = {}
provider = self._get_whois_provider( '*' )
self._fetch_whois( provider, domain, R )
return R
#-----------------------------------------------------------------------
def _get_whois_provider( self, top_level_domain ):
providers = self.whois_providers
R = providers.get( top_level_domain, None )
if R is None:
R = providers[ '*' ]
return R
#-----------------------------------------------------------------------
def _fetch_whois( self, provider, domain, pod ):
#.....................................................................
consumer = _Whois_consumer( domain, provider, pod )
request = _Whois_request( consumer, domain, provider )
#.....................................................................
_sys_asyncore_loop() # loops until requests have been processed
#=========================================================================
DRWHO = DRWHO()
domain = 'example.com'
whois = DRWHO.whois( domain )
print( whois[ 'text' ] )
