Come gestire asyncore all'interno di una classe in python, senza bloccare nulla?

Question

Devo creare una classe in grado di ricevere e archiviare messaggi SMTP, ad esempio E-mail. Per fare ciò, sto usando asyncore secondo un esempio pubblicato here. Tuttavia, asyncore.loop() sta bloccando, quindi non posso fare nient'altro nel codice.

Quindi ho pensato di utilizzare i thread. Ecco un esempio di codice che mostra quello che ho in mente:

class MyServer(smtpd.SMTPServer): 
    # derive from the python server class 

    def process_message(..): 
     # overwrite a smtpd.SMTPServer method to be able to handle the received messages 
     ... 
     self.list_emails.append(this_email) 

    def get_number_received_emails(self): 
     """Return the current number of stored emails""" 
     return len(self.list_emails) 


    def start_receiving(self): 
     """Start the actual server to listen on port 25""" 

     self.thread = threading.Thread(target=asyncore.loop) 
     self.thread.start()  

    def stop(self): 
     """Stop listening now to port 25""" 
     # close the SMTPserver from itself 
     self.close() 
     self.thread.join() 

Spero che tu abbia la foto. La classe MyServer dovrebbe essere in grado di avviare e interrompere l'ascolto della porta 25 in modo non bloccante, in grado di essere interrogato per i messaggi durante l'ascolto (o meno). Il metodo start avvia il listener , che, quando si verifica una ricezione di un'e-mail, si aggiunge a un elenco interno. Simile, il metodo stop dovrebbe essere in grado di arrestare questo server, come suggerito here.

Nonostante il fatto che questo codice non funziona come mi aspetto di (asyncore sembra funzionare sempre, anche io chiamo il metodo di cui sopra stop. La error Alzo catched all'interno stop, ma non all'interno della funzione target contenente asyncore.loop()), Non sono sicuro che il mio approccio al problema sia sensato. Sono graditi suggerimenti per la correzione del codice di cui sopra o per la proposta di un'implementazione più solida (senza utilizzando software di terze parti).

Answer 1

La soluzione fornita potrebbe non essere la soluzione più sofisticata, ma funziona in modo ragionevole ed è stata testata.

Innanzitutto, la questione con asyncore.loop() è che blocca finché tutti asyncore canali sono chiusi, come utente Wessie sottolineato in un commento prima. Facendo riferimento allo smtp example menzionato in precedenza, risulta che smtpd.SMTPServer eredita da asyncore.dispatcher (come descritto nello smtpd documentation), che risponde alla domanda su quale canale deve essere chiuso.

Pertanto, la domanda iniziale può essere risolta con il seguente codice di esempio aggiornato:

class CustomSMTPServer(smtpd.SMTPServer): 
    # store the emails in any form inside the custom SMTP server 
    emails = [] 
    # overwrite the method that is used to process the received 
    # emails, putting them into self.emails for example 
    def process_message(self, peer, mailfrom, rcpttos, data): 
     # email processing 


class MyReceiver(object): 
    def start(self): 
     """Start the listening service""" 
     # here I create an instance of the SMTP server, derived from asyncore.dispatcher 
     self.smtp = CustomSMTPServer(('0.0.0.0', 25), None) 
     # and here I also start the asyncore loop, listening for SMTP connection, within a thread 
     # timeout parameter is important, otherwise code will block 30 seconds after the smtp channel has been closed 
     self.thread = threading.Thread(target=asyncore.loop,kwargs = {'timeout':1}) 
     self.thread.start()  

    def stop(self): 
     """Stop listening now to port 25""" 
     # close the SMTPserver to ensure no channels connect to asyncore 
     self.smtp.close() 
     # now it is save to wait for the thread to finish, i.e. for asyncore.loop() to exit 
     self.thread.join() 

    # now it finally it is possible to use an instance of this class to check for emails or whatever in a non-blocking way 
    def count(self): 
     """Return the number of emails received""" 
     return len(self.smtp.emails)   
    def get(self): 
     """Return all emails received so far""" 
     return self.smtp.emails 
    .... 

Così, alla fine, ho una e un metodo startstop per avviare e interrompere l'ascolto sulla porta 25 all'interno di un non -blocco dell'ambiente.

Answer 2

Si consiglia di utilizzare Twisted, invece. http://twistedmatrix.com/trac/browser/trunk/doc/mail/examples/emailserver.tac mostra come configurare un server SMTP con un hook personalizzabile alla consegna.

Answer 3

Venendo da altra domanda asyncore.loop doesn't terminate when there are no more connections

penso che tu sia un po 'più di pensare la filettatura. Utilizzando il codice dalla altra domanda, è possibile avviare un nuovo thread che gestisce la asyncore.loop dal seguente frammento di codice:

import threading 

loop_thread = threading.Thread(target=asyncore.loop, name="Asyncore Loop") 
# If you want to make the thread a daemon 
# loop_thread.daemon = True 
loop_thread.start() 

Questo verrà eseguito in un nuovo thread e andrà avanti fino a che tutti asyncore canali sono chiusi.