débit croissant dans un script python

Question

Je traitement une liste de milliers de noms de domaine à partir d'un DNSBL par creuser, en créant un fichier CSV d'URL et les adresses IP. C'est un processus très long qui peut prendre plusieurs heures. DNSBL de mon serveur met à jour toutes les quinze minutes. Est-il possible d'augmenter le débit de mon script Python pour suivre les mises à jour du serveur?

Modifier: le script, comme l'a demandé.

import re 
import subprocess as sp 

text = open("domainslist", 'r') 
text = text.read() 
text = re.split("\n+", text) 

file = open('final.csv', 'w') 

for element in text: 
     try: 
      ip = sp.Popen(["dig", "+short", url], stdout = sp.PIPE) 
      ip = re.split("\n+", ip.stdout.read()) 
      file.write(url + "," + ip[0] + "\n") 
     except: 
      pass 

Answer 1

Eh bien, c'est probablement la résolution de nom qui vous prend si longtemps. Si vous comptez cela (c'est-à-dire, si d'une manière ou d'une autre vous revenez très rapidement), Python devrait être capable de gérer facilement des milliers d'entrées.

Cela dit, vous devriez essayer une approche filetée. Cela résoudrait (théoriquement) plusieurs adresses en même temps, plutôt que séquentiellement. Vous pourriez tout aussi bien continuer à utiliser creuser pour cela, et il devrait être trivial de modifier mon code exemple ci-dessous, mais, pour rendre les choses intéressantes (et je l'espère plus pythonique), nous allons utiliser un module existant pour que: dnspython

alors, installez-le avec:

sudo pip install -f http://www.dnspython.org/kits/1.8.0/ dnspython 

Et essayez quelque chose comme ce qui suit:

import threading 
from dns import resolver 

class Resolver(threading.Thread): 
    def __init__(self, address, result_dict): 
     threading.Thread.__init__(self) 
     self.address = address 
     self.result_dict = result_dict 

    def run(self): 
     try: 
      result = resolver.query(self.address)[0].to_text() 
      self.result_dict[self.address] = result 
     except resolver.NXDOMAIN: 
      pass 


def main(): 
    infile = open("domainlist", "r") 
    intext = infile.readlines() 
    threads = [] 
    results = {} 
    for address in [address.strip() for address in intext if address.strip()]: 
     resolver_thread = Resolver(address, results) 
     threads.append(resolver_thread) 
     resolver_thread.start() 

    for thread in threads: 
     thread.join() 

    outfile = open('final.csv', 'w') 
    outfile.write("\n".join("%s,%s" % (address, ip) for address, ip in results.iteritems())) 
    outfile.close() 

if __name__ == '__main__': 
    main() 

Si cela se révèle commencer trop de threads en même temps, vous pourriez essayer de le faire par lots ou en utilisant une file d'attente (voir http://www.ibm.com/developerworks/aix/library/au-threadingpython/ pour un exemple)

Answer 2

La grande majorité du temps ici est passé dans les appels externes à , afin d'améliorer cette vitesse, vous devez multithread. Cela vous permettra d'exécuter plusieurs appels à en même temps. Voir par exemple: Python Subprocess.Popen from a thread. Ou, vous pouvez utiliser Twisted (http://twistedmatrix.com/trac/).

EDIT: Vous avez raison, une grande partie de ce n'était pas nécessaire.

Answer 3

J'envisagerais d'utiliser une bibliothèque pure-Python pour faire les requêtes DNS, plutôt que de déléguer à , car l'appel d'un autre processus peut prendre beaucoup de temps. (Bien sûr, chercher quoi que ce soit sur internet est aussi relativement long, alors ce que gilesc a dit sur le multithreading s'applique toujours) Une recherche Google pour python dns vous donnera quelques options pour commencer.

Answer 4

Afin de maintenir le rythme des mises à jour du serveur, il faut prendre moins de 15 minutes pour exécuter. Votre script prend-il 15 minutes pour s'exécuter? Si cela ne prend pas 15 minutes, vous avez terminé!

J'enquête sur la mise en cache et diffs de séries précédentes afin d'augmenter les performances.