fcntl.flock - cómo implementar un tiempo de espera?

Question

estoy usando Python 2.7

Quiero crear una función de envoltura alrededor de fcntl.flock() que el tiempo de espera después de un intervalo de tiempo establecido:

wrapper_function(timeout): 

He intentado llamar en otro hilo y el uso de hilo .join (tiempo de espera), pero parece que fcntl.flock() sigue bloqueando:

def GetLock(self, timeout): 
    """Returns true if lock is aquired, false if lock is already in use""" 
    self.__lock_file = open('proc_lock', 'w') 

    def GetLockOrTimeOut(): 
     print 'ProcessLock: Acquiring Lock'    
     fcntl.flock(self.__lock_file.fileno(), fcntl.LOCK_EX) 
     print 'ProcessLock: Lock Acquired' 

    thread = threading.Thread(target=GetLockOrTimeOut) 
    thread.start() 
    thread.join(timeout) 

    if thread.isAlive(): 
     print 'GetLock timed out' 
     return False 
    else: 
     return True 

he mirado en soluciones para la terminación de hilos, la solución más popular parece ser sub-clasificar a threading.Thread y añadiendo una característica para aumentar una excepción en el hilo. Sin embargo, me encontré con un link que dice que este método no funcionará con llamadas nativas, y estoy seguro de que fcntl.flock() llama a una función nativa. Sugerencias?

Contexto: Estoy usando un bloqueo de archivos para crear una aplicación de instancia única, pero no quiero que una segunda instancia de la aplicación se quede ahí y cuelgue hasta que termine la primera instancia.

Answer 1

tiempos de espera para las llamadas al sistema están hechas con señales. La mayoría de las llamadas al sistema de bloqueo regresan con EINTR cuando ocurre una señal, por lo que puede usar alarm para implementar los tiempos de espera.

Aquí hay un administrador de contexto que funciona con la mayoría de las llamadas al sistema, haciendo que IOError se levante de una llamada al sistema de bloqueo si lleva demasiado tiempo.

import signal, errno 
from contextlib import contextmanager 
import fcntl 

@contextmanager 
def timeout(seconds): 
    def timeout_handler(signum, frame): 
     pass 

    original_handler = signal.signal(signal.SIGALRM, timeout_handler) 

    try: 
     signal.alarm(seconds) 
     yield 
    finally: 
     signal.alarm(0) 
     signal.signal(signal.SIGALRM, original_handler) 

with timeout(1): 
    f = open("test.lck", "w") 
    try: 
     fcntl.flock(f.fileno(), fcntl.LOCK_EX) 
    except IOError, e: 
     if e.errno != errno.EINTR: 
      raise e 
     print "Lock timed out" 

Answer 2

Estoy seguro de que hay varias formas, pero ¿qué tal si utilizas un bloqueo sin bloqueo? Después de algunos n intentos, renunciar y salir?

Para utilizar el bloqueo de no bloqueo, incluir la bandera fcntl.LOCK_NB, como en:

fcntl.flock(self.__lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) 

Answer 3

Soy un fan de los bombardeos a cabo a acudir aquí, ya tratar de hacer un bloqueo de bloqueo con un tiempo de espera requiere cambios en el estado global, que hace que sea más difícil de razonar acerca de su programa, sobre todo si se trata de roscar .

Se puede bifurcar fuera un subproceso y poner en marcha la alarma que el anterior, o usted podría exec http://man7.org/linux/man-pages/man1/flock.1.html

import subprocess 
def flock_with_timeout(fd, timeout, shared=True): 
    rc = subprocess.call(['flock', '--shared' if shared else '--exclusive', '--timeout', str(timeout), str(fd)]) 
    if rc != 0: 
     raise Exception('Failed to take lock') 

Si usted tiene una nueva versión bastante de rebaño puede utilizar -E para especificar un código de salida diferente para el comando de lo contrario tendría éxito, pero no pudo tomar el bloqueo después de un tiempo de espera, por lo que puede saber si el comando falló por alguna otra razón en su lugar.