Hva Python måten vil du foreslå å sjekke whois databasen poster?

stemmer
8

Jeg prøver å få en webservice oppe og går som faktisk krever å sjekke whois-databaser. Hva jeg gjør akkurat nå er stygg og jeg ønsker å unngå det så mye som jeg kan: Jeg kaller gwhois kommando og analysere sin produksjon. Stygg.

Jeg gjorde noen søk for å prøve å finne en Pytonske måte å gjøre denne oppgaven. Vanligvis jeg fikk ganske mye ingenting - denne gamle diskusjonen liste linken har en måte å sjekke om domenet eksisterer. Ganske ikke det jeg var ute etter ... Men likevel, det var best anwser Google ga meg - alt annet er bare en haug med unanwsered spørsmål.

Noen av dere har klart å få noen metode oppe og går? Jeg vil veldig pris på noen tips, eller skal jeg bare gjøre det på den opensource-veien, sitte ned og kode noe av meg selv? :)

Publisert på 08/09/2008 klokken 18:43
kilden bruker
På andre språk...                            


9 svar

stemmer
8

Se på dette: http://code.google.com/p/pywhois/

pywhois - Python-modul for å hente WHOIS informasjon om domener

Mål: - Lag en enkel import Python-modul som skal produsere analysert WHOIS data for et gitt domene. - Kunne trekke ut data for alle de populære toppdomener (com, org, net, ...) - Query en WHOIS-server direkte i stedet for å gå gjennom et mellomliggende web-tjeneste som mange andre gjør. - Fungerer med Python 2.4+ og ingen eksterne avhengig

Eksempel:

>>> 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
...
Svarte 02/11/2010 kl. 13:53
kilden bruker

stemmer
6

Fant dette spørsmålet i prosessen med min egen søken etter en python whois bibliotek.

Vet ikke at jeg er enig med cdleary svar at bruk av et bibliotek som brytes en kommando er alltid den beste veien å gå - men jeg kan se sine grunner hvorfor han sa dette.

Pro: cmd-line whois håndterer alt det harde arbeidet (socket samtaler, analyse, etc)

Con: ikke bærbar; modul kan ikke fungere, avhengig av underliggende whois kommandoen. Tregere, siden kjører en kommando, og mest sannsynlig skall i tillegg til whois kommandoen. Påvirkes hvis ikke UNIX (Windows), forskjellige UNIX, eldre UNIX, eller eldre whois kommandoen

Jeg leter etter et whois-modul som kan håndtere whois IP-oppslag, og jeg er ikke interessert i koding min egen whois klient.

Her er de modulene som jeg (lett) prøvd ut og mer informasjon om det:

pywhoisapi:

  • Hjem: http://code.google.com/p/pywhoisapi/
  • Design: REST klient tilgang ARIN whois REST tjeneste
  • Pros: stand til å håndtere IP-adresse oppslag
  • Cons: stand til å trekke informasjon fra whois servere av andre RIR?

BulkWhois

  • Hjem: http://pypi.python.org/pypi/BulkWhois/0.2.1
  • Design: telnet klient tilgang whois telnet spørring grensesnitt fra RIR (?)
  • Pros: stand til å håndtere IP-adresse oppslag
  • Cons: stand til å trekke informasjon fra whois servere av andre RIR?

pywhois:

  • Hjem: http://code.google.com/p/pywhois/
  • Design: REST klient tilgang RRID whois tjenester
  • Pros: Accessses mange RRIDs; har python 3.x grenen
  • Cons: ser ikke ut til å håndtere IP-adresse oppslag

python-whois:

whoisclient - gaffel av python-whois

Oppdatering: Jeg endte opp med å bruke pywhoisapi for omvendt IP-oppslag som jeg gjorde

Svarte 05/07/2012 kl. 12:03
kilden bruker

stemmer
5

Det er ingenting galt med å bruke en kommandolinje verktøyet til å gjøre hva du vil. Hvis du putter en hyggelig wrapper rundt tjenesten, kan du implementere de innvendige slik du vil! For eksempel:

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

Nå, om du rulle din egen hjelp urllib, sjal rundt et kommandolinjeverktøy (som du gjør), eller importere en tredjepart bibliotek og bruke det (som du sier ), forblir dette grensesnittet det samme.

Denne tilnærmingen er vanligvis ikke regnes stygg i det hele tatt - noen ganger kommandoen utilities gjøre hva du vil, og du bør være i stand til å utnytte dem . Hvis hastigheten ender opp som en flaskehals, gjør abstraksjon prosessen med å bytte til en innfødt Python implementering transparent for klienten kode.

Praktisk slår renhet - det er det som er Pytonske. :)

Svarte 10/09/2008 kl. 21:44
kilden bruker

stemmer
4

Her er whois klient re-implementert i Python: http://code.activestate.com/recipes/577364-whois-client/

Svarte 31/03/2011 kl. 00:37
kilden bruker

stemmer
1

Jeg vet ikke om gwhois gjør noe spesielt med serveren utgang; men du kan tydelig koble til whois server på port whois (43), sende søket, kan du lese alle data i svaret og analysere dem. For å gjøre livet litt enklere, kan du bruke telnetlib.Telnet klasse (selv om whois-protokollen er mye enklere enn telnet-protokollen) i stedet for vanlig stikkontakter.

De vanskelige deler:

  • som whois server vil du spørre? RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, Verio etc LACNIC kan være et nyttig fallback, siden de har en tendens til å svare med nyttige data på forespørsler utenfor deres domene.
  • hva er de eksakte alternativer og argumenter for hver whois server? noen tilbyr hjelp, andre ikke. Generelt, vanlig domenenavn fungere uten spesielle alternativer.
Svarte 16/09/2008 kl. 00:23
kilden bruker

stemmer
0

her er en klar til bruk løsning som fungerer for meg; skrevet for Python 3.1 (når backporting å Py2.x, ta spesielt vare på byte / Unicode tekst utmerkelser). din enkelt tilgangspunkt er metoden DRWHO.whois(), som forventer et domenenavn være bestått; det vil da prøve å løse navnet med leverandøren konfigurert som DRWHO.whois_providers[ '*' ](en mer komplett løsning kunne skille leverandører i henhold til toppnivådomenet). DRWHO.whois()vil returnere en ordliste med en enkelt oppføring text, som inneholder svaret teksten sendt tilbake av WHOIS-server. Igjen, en mer komplett løsning vil da forsøke å analysere teksten (som må gjøres separat for hver leverandør, så det er ingen standard format) og returnere en mer strukturert format (for eksempel sette et flagg availablesom angir hvorvidt domene utseende tilgjengelig). ha det gøy!

##########################################################################
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' ] )
Svarte 09/03/2010 kl. 16:17
kilden bruker

stemmer
0
import socket
socket.gethostbyname_ex('url.com')

Hvis den gir en gaierror du vet vet det er ikke registrert med noen DNS

Svarte 09/03/2010 kl. 10:07
kilden bruker

stemmer
0

Parsing en annen nettside woulnd't være like ille (forutsatt at deres html woulnd't være svært dårlig), men det ville faktisk binde meg til dem - hvis de er nede, jeg er ned :)

Faktisk fant jeg noen gamle prosjektet på sourceforge: rwhois.py . Hva skremmer meg litt er at deres siste oppdatering er fra 2003. Men det kan virke som et godt sted å begynne reimplementation av det jeg gjør akkurat nå ... Vel, jeg følte obligued å poste linken til dette prosjektet likevel, bare for ytterligere referanse.

Svarte 08/09/2008 kl. 19:00
kilden bruker

stemmer
0

En annen måte å gjøre det på er å bruke urllib2modulen til å analysere en annen side whois tjeneste (mange nettsteder som det finnes). Men det virker som enda mer av en hack at det du gjør nå, og vil gi deg en avhengighet på hva whois stedet du velger, noe som er dårlig.

Jeg hater å si det, men med mindre du ønsker å re-implementere whoisi programmet (som ville bli re-oppfinne hjulet), kjører whoispå OS og analyse av produksjonen (dvs. hva du gjør nå) virker som den riktige måten å gjør det.

Svarte 08/09/2008 kl. 18:53
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more