Come impedire che un blocco di codice venga interrotto da KeyboardInterrupt in Python?

Question

Sto scrivendo un programma che memorizza nella cache alcuni risultati tramite il modulo pickle. Quello che succede in questo momento è che se ho colpito ctrl-c quando l'operazione dump si sta verificando, dump viene interrotto e il file risultante è corrotto (cioè solo parzialmente scritto, quindi non può essere di nuovo load ed.

C'è un modo per rendere dump, o, in generale, un blocco di codice, uninterruptable mia soluzione attuale simile a questa:?

try: 
    file = open(path, 'w') 
    dump(obj, file) 
    file.close() 
except KeyboardInterrupt: 
    file.close() 
    file.open(path,'w') 
    dump(obj, file) 
    file.close() 
    raise 

sembra stupido per riavviare l'operazione se si è interrotto, quindi sono alla ricerca di un modo per posticipare l'interrupt Come posso fare?

Answer 1

Inserisci la funzione in una discussione e attendi che il thread termini.

I thread Python non possono essere interrotti se non con uno speciale C api.

import time 
from threading import Thread 

def noInterrupt(): 
    for i in xrange(4): 
     print i 
     time.sleep(1) 

a = Thread(target=noInterrupt) 
a.start() 
a.join() 
print "done" 


0 
1 
2 
3 
Traceback (most recent call last): 
    File "C:\Users\Admin\Desktop\test.py", line 11, in <module> 
    a.join() 
    File "C:\Python26\lib\threading.py", line 634, in join 
    self.__block.wait() 
    File "C:\Python26\lib\threading.py", line 237, in wait 
    waiter.acquire() 
KeyboardInterrupt 

Vedere come l'interruzione è stata posticipata fino al termine del thread?

Qui è adattato a vostro uso:

import time 
from threading import Thread 

def noInterrupt(path, obj): 
    try: 
     file = open(path, 'w') 
     dump(obj, file) 
    finally: 
     file.close() 

a = Thread(target=noInterrupt, args=(path,obj)) 
a.start() 
a.join() 

Answer 2

Utilizza il modulo signal per disabilitare SIGINT per tutta la durata del processo:

s = signal.signal(signal.SIGINT, signal.SIG_IGN) 
do_important_stuff() 
signal.signal(signal.SIGINT, s) 

Answer 3

A mio parere utilizzando thread per questo è un peso inutile . È possibile assicurarsi che il file sia salvato correttamente semplicemente farlo in un ciclo fino a quando una scrittura di successo è stato fatto:

def saveToFile(obj, filename): 
    file = open(filename, 'w') 
    cPickle.dump(obj, file) 
    file.close() 
    return True 

done = False 
while not done: 
    try: 
     done = saveToFile(obj, 'file') 
    except KeyboardInterrupt: 
     print 'retry' 
     continue 

Answer 4

Quello che segue è un gestore di contesto che attribuisce un gestore di segnale per SIGINT. Se viene chiamato il gestore di segnale del gestore di contesto, il segnale viene ritardato passando solo il segnale al gestore originale quando si chiude il gestore di contesto.

import signal 
import logging 

class DelayedKeyboardInterrupt(object): 
    def __enter__(self): 
     self.signal_received = False 
     self.old_handler = signal.signal(signal.SIGINT, self.handler) 

    def handler(self, sig, frame): 
     self.signal_received = (sig, frame) 
     logging.debug('SIGINT received. Delaying KeyboardInterrupt.') 

    def __exit__(self, type, value, traceback): 
     signal.signal(signal.SIGINT, self.old_handler) 
     if self.signal_received: 
      self.old_handler(*self.signal_received) 

with DelayedKeyboardInterrupt(): 
    # stuff here will not be interrupted by SIGINT 
    critical_code()