Quale modo Python suggeriresti per controllare i record del database whois?
https://stackoverflow.com/questions/50394
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Sto cercando di mettere in funzione un servizio web che richieda effettivamente il controllo dei database whois.Quello che sto facendo in questo momento è brutto e vorrei evitarlo il più possibile:Chiamo il comando gwhois e ne analizzo l'output.Brutto.
Ho fatto qualche ricerca per provare a trovare un modo Python per svolgere questo compito.Generalmente non ho ottenuto praticamente nulla - questo vecchio collegamento all'elenco di discussione ha un modo per verificare se il dominio esiste.Non proprio quello che cercavo...Ma è stata comunque la risposta migliore che Google mi ha dato: tutto il resto è solo un mucchio di domande senza risposta.
Qualcuno di voi è riuscito a mettere in funzione qualche metodo?Apprezzerei molto alcuni suggerimenti, o dovrei semplicemente farlo in modo opensource, sedermi e codificare qualcosa da solo?:)
Soluzione
Non c'è niente di sbagliato nell'usare un'utilità da riga di comando per fare ciò che desideri.Se metti un bel involucro attorno al servizio, puoi implementare gli interni come preferisci!Per esempio:
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
Ora, indipendentemente dal fatto che tu ne crei o meno uno usando urllib, avvolgi un'utilità della riga di comando (come stai facendo) o importi una libreria di terze parti e usala (come stai dicendo), questa interfaccia rimane la stessa.
Questo approccio generalmente non è affatto considerato brutto -- a volte le utilità di comando fanno quello che vuoi e dovresti essere in grado di sfruttarle.Se la velocità finisce per rappresentare un collo di bottiglia, la tua astrazione rende trasparente al tuo codice client il processo di passaggio a un'implementazione Python nativa.
La praticità batte la purezza -- questo è Pythonic.:)
Altri suggerimenti
Guarda questo:http://code.google.com/p/pywhois/
pywhois - Modulo Python per il recupero delle informazioni WHOIS dei domini
Obiettivo:- Crea un semplice modulo Python importabile che produrrà dati WHOIS analizzati per un determinato dominio.- In grado di estrarre dati per tutti i popolari TLD (COM, Org, Net, ...) - Interroga un server Whois direttamente invece di passare attraverso un servizio Web intermedio come fanno molti altri.- Funziona con Python 2.4+ e senza dipendenze esterne
Esempio:
>>> 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
...
Ho trovato questa domanda durante la mia ricerca di una libreria whois Python.
Non so che sono d'accordo con la risposta di Cdleary secondo cui l'uso di una libreria che avvolge un comando è sempre il modo migliore per andare, ma posso vedere i suoi motivi per cui ha detto questo.
Pro:cmd-line whois gestisce tutto il duro lavoro (chiamate socket, analisi, ecc.)
Contro:non portatile;il modulo potrebbe non funzionare a seconda del comando whois sottostante.Più lento, poiché esegue un comando e molto probabilmente la shell oltre al comando whois.Interessati se non unix (Windows), diversi Unix, UNIX più vecchio o comando WHOIS più anziano
Sto cercando un modulo whois in grado di gestire le ricerche IP whois e non sono interessato a codificare il mio client whois.
Ecco i moduli che ho (leggermente) provato e maggiori informazioni a riguardo:
pywhoisapi:
- Casa: http://code.google.com/p/pywhoisapi/
- Progetto:Client REST che accede al servizio ARIN whois REST
- Professionisti:In grado di gestire le ricerche di indirizzi IP
- Contro:In grado di estrarre informazioni dai server whois di altri RIR?
BulkWhois
- Casa: http://pypi.python.org/pypi/BulkWhois/0.2.1
- Progetto:client telnet che accede all'interfaccia di query whois telnet da RIR(?)
- Professionisti:In grado di gestire le ricerche di indirizzi IP
- Contro:In grado di estrarre informazioni dai server whois di altri RIR?
pywhois:
- Casa: http://code.google.com/p/pywhois/
- Progetto:Client REST che accede ai servizi whois RRID
- Professionisti:Accede a molti RRID;ha il ramo Python 3.x
- Contro:non sembra gestire le ricerche di indirizzi IP
python-whois:
- Casa: http://code.google.com/p/python-whois/
- Progetto:avvolge il comando "whois".
- Contro:non sembra gestire le ricerche di indirizzi IP
whoisclient - fork di python-whois
- Casa: http://gitorious.org/python-whois
- Progetto:avvolge il comando "whois".
- Dipende da:IPy.py
- Contro:non sembra gestire le ricerche di indirizzi IP
Aggiornamento:Alla fine ho utilizzato pywhoisapi per le ricerche IP inverse che stavo facendo
Ecco il client whois reimplementato in Python:http://code.activestate.com/recipes/577364-whois-client/
Non so se gwhois faccia qualcosa di speciale con l'output del server;tuttavia, puoi semplicemente connetterti al server whois sulla porta whois (43), inviare la tua query, leggere tutti i dati nella risposta e analizzarli.Per rendere la vita un po' più semplice, potresti usare la classe telnetlib.Telnet (anche se il protocollo whois è molto più semplice del protocollo telnet) invece dei semplici socket.
Le parti difficili:
- quale server whois chiederai?RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO ecc. LACNIC potrebbero essere un utile fallback, poiché tendono a rispondere con dati utili a richieste al di fuori del loro dominio.
- quali sono le opzioni e gli argomenti esatti per ciascun server whois?alcuni offrono aiuto, altri no.In generale, i nomi di dominio semplici funzionano senza opzioni speciali.
Un altro modo per farlo è usare urllib2 modulo per analizzare il servizio whois di qualche altra pagina (esistono molti siti simili).Ma sembra ancora più un hack di quello che fai adesso, e ti darebbe una dipendenza da qualunque sito whois tu scelga, il che è negativo.
Odio dirlo, ma a meno che tu non voglia reimplementarlo whois nel tuo programma (che significherebbe reinventare la ruota), in esecuzione whois sul sistema operativo e analizzare l'output (ovvero quello che stai facendo ora) sembra il modo giusto per farlo.
Analizzare un'altra pagina web non sarebbe così male (supponendo che il loro html non sarebbe poi così male), ma in realtà mi legherebbe a loro - se sono inattivi, sono inattivo :)
In realtà ho trovato qualche vecchio progetto su sourceforge: rwhois.py.Ciò che mi spaventa un po' è che il loro ultimo aggiornamento è del 2003.Ma potrebbe sembrare un buon punto di partenza per reimplementare ciò che faccio adesso...Bene, mi sono sentito comunque obbligato a pubblicare il collegamento a questo progetto, solo per ulteriore riferimento.
import socket
socket.gethostbyname_ex('url.com')
se restituisce un gaierror sai che non è registrato con nessun DNS
ecco una soluzione pronta all'uso che funziona per me;scritto per Python 3.1 (quando si esegue il backport su Py2.x, prestare particolare attenzione alle distinzioni tra byte e testo Unicode).il tuo unico punto di accesso è il metodo DRWHO.whois(), che prevede il passaggio di un nome di dominio;proverà quindi a risolvere il nome utilizzando il provider configurato come DRWHO.whois_providers[ '*' ] (una soluzione più completa potrebbe differenziare i fornitori in base al dominio di primo livello). DRWHO.whois() restituirà un dizionario con una singola voce text, che contiene il testo di risposta inviato dal server WHOIS.Ancora una volta, una soluzione più completa proverebbe ad analizzare il testo (che deve essere eseguita separatamente per ciascun provider, poiché non esiste un formato standard) e restituire un formato più strutturato (ad esempio, impostare un flag available che specifica se il dominio sembra disponibile o meno).divertiti!
##########################################################################
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' ] )
