Quelle méthode Python suggéreriez-vous pour vérifier les enregistrements de la base de données whois ?
https://stackoverflow.com/questions/50394
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'essaie de mettre en place un service Web qui nécessite en fait de vérifier les bases de données whois.Ce que je fais en ce moment est moche et j'aimerais l'éviter autant que possible :J'appelle la commande gwhois et j'analyse sa sortie.Laid.
J'ai fait quelques recherches pour essayer de trouver un moyen pythonique d'effectuer cette tâche.En général, je n'ai presque rien - cet ancien lien de liste de discussion a un moyen de vérifier si le domaine existe.Ce n'est pas du tout ce que je cherchais...Mais c’était quand même la meilleure réponse que Google m’a donnée – tout le reste n’est qu’un tas de questions sans réponse.
L'un d'entre vous a-t-il réussi à mettre en place une méthode ?J'apprécierais beaucoup quelques conseils, ou devrais-je simplement le faire de manière open source, m'asseoir et coder quelque chose par moi-même ?:)
La solution
Il n'y a rien de mal à utiliser un utilitaire de ligne de commande pour faire ce que vous voulez.Si vous enveloppez joliment le service, vous pouvez implémenter les éléments internes comme vous le souhaitez !Par exemple:
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
Maintenant, que vous développiez ou non le vôtre en utilisant urllib, que vous utilisiez un utilitaire de ligne de commande (comme vous le faites) ou que vous importiez une bibliothèque tierce et l'utilisiez (comme tu dis), cette interface reste la même.
Cette approche n'est généralement pas considérée comme laide du tout -- Parfois, les utilitaires de commande font ce que vous voulez et vous devriez pouvoir les exploiter..Si la vitesse finit par être un goulot d'étranglement, votre abstraction rend le processus de passage à une implémentation Python native transparent pour votre code client.
La praticité bat la pureté - c'est ce qui est Pythonic.:)
Autres conseils
Regarde ça:http://code.google.com/p/pywhois/
pywhois - Module Python pour récupérer les informations WHOIS des domaines
But:- Créer un simple module Python importable qui produira des données WHOIS analysées pour un domaine donné.- Capable d'extraire des données pour tous les TLD populaires (com, org, net, ...) - interrogez un serveur Whois directement au lieu de passer par un service Web intermédiaire comme beaucoup d'autres.- Fonctionne avec Python 2.4+ et aucune dépendance externe
Exemple:
>>> 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
...
J'ai trouvé cette question lors de ma propre recherche d'une bibliothèque whois python.
Je ne sais pas que je suis d'accord avec la réponse de Cdleary que l'utilisation d'une bibliothèque qui enveloppe une commande est toujours la meilleure façon de procéder - mais je peux voir ses raisons pour lesquelles il a dit cela.
Pro:cmd-line whois gère tout le travail acharné (appels de socket, analyse, etc.)
Escroquer:non portable ;Le module peut ne pas fonctionner en fonction de la commande whois sous-jacente.Plus lent, depuis l'exécution d'une commande et très probablement un shell en plus de la commande whois.Affecté sinon UNIX (Windows), différents UNIX, Unix plus âgés ou commandes WHOIS plus anciennes
Je recherche un module whois capable de gérer les recherches IP whois et je ne suis pas intéressé à coder mon propre client whois.
Voici les modules que j'ai (légèrement) essayés et plus d'informations à ce sujet :
pywhoisapi :
- Maison: http://code.google.com/p/pywhoisapi/
- Conception:Client REST accédant au service ARIN whois REST
- Avantages:Capable de gérer les recherches d'adresses IP
- Les inconvénients:Capable d'extraire des informations des serveurs whois d'autres RIR ?
BulkWhois
- Maison: http://pypi.python.org/pypi/BulkWhois/0.2.1
- Conception:client telnet accédant à l'interface de requête whois telnet à partir de RIR (?)
- Avantages:Capable de gérer les recherches d'adresses IP
- Les inconvénients:Capable d'extraire des informations des serveurs whois d'autres RIR ?
pywhois :
- Maison: http://code.google.com/p/pywhois/
- Conception:Client REST accédant aux services whois RRID
- Avantages:Accède à de nombreux RRID ;a une branche python 3.x
- Les inconvénients:ne semble pas gérer les recherches d'adresses IP
python-whois :
- Maison: http://code.google.com/p/python-whois/
- Conception:encapsule la commande "whois"
- Les inconvénients:ne semble pas gérer les recherches d'adresses IP
whoisclient - fork de python-whois
- Maison: http://gitorious.org/python-whois
- Conception:encapsule la commande "whois"
- Dépend de:IPy.py
- Les inconvénients:ne semble pas gérer les recherches d'adresses IP
Mise à jour:J'ai fini par utiliser pywhoisapi pour les recherches IP inversées que je faisais
Voici le client whois ré-implémenté en Python :http://code.activestate.com/recipes/577364-whois-client/
Je ne sais pas si gwhois fait quelque chose de spécial avec la sortie du serveur ;cependant, vous pouvez simplement vous connecter au serveur whois sur le port whois (43), envoyer votre requête, lire toutes les données de la réponse et les analyser.Pour vous faciliter un peu la vie, vous pouvez utiliser la classe telnetlib.Telnet (même si le protocole whois est beaucoup plus simple que le protocole telnet) au lieu de simples sockets.
Les parties délicates :
- à quel serveur whois demanderez-vous ?RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO etc. LACNIC pourraient être une solution de repli utile, car ils ont tendance à répondre avec des données utiles aux requêtes en dehors de leur domaine.
- quelles sont les options et arguments exacts pour chaque serveur whois ?certains offrent de l'aide, d'autres non.En général, les noms de domaine simples fonctionnent sans aucune option particulière.
Une autre façon de procéder est d'utiliser urllib2 module pour analyser le service whois d'une autre page (de nombreux sites comme celui-ci existent).Mais cela semble être encore plus un hack que ce que vous faites actuellement, et vous donnerait une dépendance à l'égard du site whois que vous avez choisi, ce qui est mauvais.
Je déteste le dire, mais à moins que vous souhaitiez réimplémenter whois dans votre programme (ce qui reviendrait à réinventer la roue), en exécutant whois sur le système d'exploitation et analyser la sortie (c'est-à-dire ce que vous faites maintenant) semble être la bonne façon de le faire.
Analyser une autre page Web ne serait pas aussi mauvais (en supposant que leur code HTML ne serait pas très mauvais), mais cela me lierait en fait à eux - s'ils sont en panne, je suis en panne :)
En fait, j'ai trouvé un vieux projet sur sourceforge : rwhois.py.Ce qui me fait un peu peur, c'est que leur dernière mise à jour date de 2003.Mais cela peut sembler être un bon point de départ pour commencer à réimplémenter ce que je fais actuellement...Eh bien, je me suis senti obligé de poster le lien vers ce projet de toute façon, juste pour référence ultérieure.
import socket
socket.gethostbyname_ex('url.com')
s'il renvoie une erreur gaier, vous savez qu'il n'est enregistré auprès d'aucun DNS
voici une solution prête à l'emploi qui fonctionne pour moi ;écrit pour Python 3.1 (lors du rétroportage vers Py2.x, faites particulièrement attention aux distinctions octets/texte Unicode).votre point d'accès unique est la méthode DRWHO.whois(), qui attend qu'un nom de domaine soit transmis ;il tentera ensuite de résoudre le nom en utilisant le fournisseur configuré comme DRWHO.whois_providers[ '*' ] (une solution plus complète pourrait différencier les fournisseurs selon le domaine de premier niveau). DRWHO.whois() renverra un dictionnaire avec une seule entrée text, qui contient le texte de réponse renvoyé par le serveur WHOIS.Encore une fois, une solution plus complète essaierait alors d'analyser le texte (ce qui doit être fait séparément pour chaque fournisseur, car il n'existe pas de format standard) et de renvoyer un format plus structuré (par exemple, définir un indicateur available qui précise si le domaine semble disponible ou non).amusez-vous!
##########################################################################
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' ] )
