Verrouiller un fichier en Python

J'ai besoin de verrouiller un fichier pour l'écrire en Python. Il sera accessible à partir de plusieurs processus Python à la fois. J'ai trouvé des solutions en ligne, mais la plupart échouent à mes fins car elles sont souvent uniquement basées sur Unix ou Windows.

D'accord, j'ai donc fini par utiliser le code que j'ai écrit ici, sur mon site, le ^{lien est mort, voir sur archive.org} ( également disponible sur GitHub ). Je peux l'utiliser de la manière suivante:

from filelock import FileLock

with FileLock("myfile.txt.lock"):
    print("Lock acquired.")
    with open("myfile.txt"):
        # work with the file as it is now locked

Il existe un module de verrouillage de fichiers multiplateforme ici: Portalocker

Bien que, comme le dit Kevin, écrire dans un fichier à partir de plusieurs processus à la fois est quelque chose que vous voulez éviter dans la mesure du possible.

Si vous parvenez à intégrer votre problème dans une base de données, vous pouvez utiliser SQLite. Il prend en charge l'accès simultané et gère son propre verrouillage.

Les autres solutions citent de nombreuses bases de code externes. Si vous préférez le faire vous-même, voici un code pour une solution multiplateforme qui utilise les outils de verrouillage de fichiers respectifs sur les systèmes Linux / DOS.

try:
    # Posix based file locking (Linux, Ubuntu, MacOS, etc.)
    import fcntl, os
    def lock_file(f):
        fcntl.lockf(f, fcntl.LOCK_EX)
    def unlock_file(f):
        fcntl.lockf(f, fcntl.LOCK_UN)
except ModuleNotFoundError:
    # Windows file locking
    import msvcrt, os
    def file_size(f):
        return os.path.getsize( os.path.realpath(f.name) )
    def lock_file(f):
        msvcrt.locking(f.fileno(), msvcrt.LK_RLCK, file_size(f))
    def unlock_file(f):
        msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, file_size(f))


# Class for ensuring that all file operations are atomic, treat
# initialization like a standard call to 'open' that happens to be atomic.
# This file opener *must* be used in a "with" block.
class AtomicOpen:
    # Open the file with arguments provided by user. Then acquire
    # a lock on that file object (WARNING: Advisory locking).
    def __init__(self, path, *args, **kwargs):
        # Open the file and acquire a lock on the file before operating
        self.file = open(path,*args, **kwargs)
        # Lock the opened file
        lock_file(self.file)

    # Return the opened file object (knowing a lock has been obtained).
    def __enter__(self, *args, **kwargs): return self.file

    # Unlock the file and close the file object.
    def __exit__(self, exc_type=None, exc_value=None, traceback=None):        
        # Flush to make sure all buffered contents are written to file.
        self.file.flush()
        os.fsync(self.file.fileno())
        # Release the lock on the file.
        unlock_file(self.file)
        self.file.close()
        # Handle exceptions that may have come up during execution, by
        # default any exceptions are raised to the user.
        if (exc_type != None): return False
        else:                  return True        

Maintenant, AtomicOpenpeut être utilisé dans un withbloc où l'on utiliserait normalement une openinstruction.

AVERTISSEMENT: si l'exécution sous Windows et Python se bloque avant l' appel de exit , je ne suis pas sûr du comportement de verrouillage.

AVERTISSEMENT: Le verrouillage fourni ici est indicatif et non absolu. Tous les processus potentiellement concurrents doivent utiliser la classe "AtomicOpen".

Je préfère lockfile - Verrouillage de fichiers indépendant de la plate-forme

J'ai cherché plusieurs solutions pour ce faire et mon choix a été oslo.

C'est puissant et relativement bien documenté. Il est basé sur des attaches.

Autres solutions:

• Portalocker : nécessite pywin32, qui est une installation exe, donc pas possible via pip
• fixations : mal documentées
• lockfile : obsolète
• flufl.lock : verrouillage de fichier sécurisé NFS pour les systèmes POSIX.
• simpleflock : Dernière mise à jour 07/2013
• zc.lockfile : Dernière mise à jour 2016-06 (à partir de 2017-03)
• lock_file : Dernière mise à jour en 2007-10

Le verrouillage est spécifique à la plate-forme et à l'appareil, mais en général, vous avez quelques options:

1. Utilisez flock () ou équivalent (si votre système d'exploitation le prend en charge). Il s'agit d'un verrouillage consultatif, sauf si vous vérifiez le verrou, il est ignoré.
2. Utilisez une méthodologie de verrouillage-copie-déplacement-déverrouillage, dans laquelle vous copiez le fichier, écrivez les nouvelles données, puis déplacez-les (déplacer, pas copier - déplacer est une opération atomique sous Linux - vérifiez votre système d'exploitation), et vous vérifiez le existence du fichier de verrouillage.
3. Utilisez un répertoire comme "verrou". Ceci est nécessaire si vous écrivez sur NFS, car NFS ne prend pas en charge flock ().
4. Il y a aussi la possibilité d'utiliser la mémoire partagée entre les processus, mais je n'ai jamais essayé cela; c'est très spécifique au système d'exploitation.

Pour toutes ces méthodes, vous devrez utiliser une technique de verrouillage rotatif (nouvelle tentative après échec) pour acquérir et tester le verrou. Cela laisse une petite fenêtre pour une mauvaise synchronisation, mais elle est généralement suffisamment petite pour ne pas être un problème majeur.

Si vous recherchez une solution multiplateforme, vous feriez mieux de vous connecter à un autre système via un autre mécanisme (la meilleure chose à faire est la technique NFS ci-dessus).

Notez que sqlite est soumis aux mêmes contraintes sur NFS que les fichiers normaux, vous ne pouvez donc pas écrire dans une base de données sqlite sur un partage réseau et obtenir une synchronisation gratuitement.

La coordination de l'accès à un seul fichier au niveau du système d'exploitation comporte toutes sortes de problèmes que vous ne voulez probablement pas résoudre.

Votre meilleur pari est d'avoir un processus séparé qui coordonne l'accès en lecture / écriture à ce fichier.

Le verrouillage d'un fichier est généralement une opération spécifique à la plate-forme, vous devrez peut-être prévoir la possibilité de s'exécuter sur différents systèmes d'exploitation. Par exemple:

import os

def my_lock(f):
    if os.name == "posix":
        # Unix or OS X specific locking here
    elif os.name == "nt":
        # Windows specific locking here
    else:
        print "Unknown operating system, lock unavailable"

J'ai travaillé sur une situation comme celle-ci où j'exécute plusieurs copies du même programme à partir du même répertoire / dossier et des erreurs de journalisation. Mon approche était d'écrire un "fichier de verrouillage" sur le disque avant d'ouvrir le fichier journal. Le programme vérifie la présence du "fichier de verrouillage" avant de continuer, et attend son tour si le "fichier de verrouillage" existe.

Voici le code:

def errlogger(error):

    while True:
        if not exists('errloglock'):
            lock = open('errloglock', 'w')
            if exists('errorlog'): log = open('errorlog', 'a')
            else: log = open('errorlog', 'w')
            log.write(str(datetime.utcnow())[0:-7] + ' ' + error + '\n')
            log.close()
            remove('errloglock')
            return
        else:
            check = stat('errloglock')
            if time() - check.st_ctime > 0.01: remove('errloglock')
            print('waiting my turn')

EDIT --- Après avoir réfléchi à certains des commentaires sur les verrous périmés ci-dessus, j'ai modifié le code pour ajouter une vérification de l'exactitude du "fichier de verrouillage". Le chronométrage de plusieurs milliers d'itérations de cette fonction sur mon système a donné une moyenne de 0,002066 ... secondes juste avant:

lock = open('errloglock', 'w')

à juste après:

remove('errloglock')

J'ai donc pensé que je commencerais avec 5 fois ce montant pour indiquer l'obsolescence et surveiller la situation pour les problèmes.

De plus, en travaillant avec le timing, j'ai réalisé que j'avais un peu de code qui n'était pas vraiment nécessaire:

lock.close()

que j'avais immédiatement après la déclaration ouverte, je l'ai donc supprimée dans cette modification.

Pour ajouter à la réponse d'Evan Fossmark , voici un exemple d'utilisation de filelock :

from filelock import FileLock

lockfile = r"c:\scr.txt"
lock = FileLock(lockfile + ".lock")
with lock:
    file = open(path, "w")
    file.write("123")
    file.close()

Tout code dans le with lock:bloc est thread-safe, ce qui signifie qu'il sera terminé avant qu'un autre processus ait accès au fichier.

Le scénario est comme ça: l'utilisateur demande un fichier pour faire quelque chose. Ensuite, si l'utilisateur envoie à nouveau la même requête, il informe l'utilisateur que la seconde requête n'est pas effectuée tant que la première requête n'est pas terminée. C'est pourquoi, j'utilise un mécanisme de verrouillage pour gérer ce problème.

Voici mon code de travail:

from lockfile import LockFile
lock = LockFile(lock_file_path)
status = ""
if not lock.is_locked():
    lock.acquire()
    status = lock.path + ' is locked.'
    print status
else:
    status = lock.path + " is already locked."
    print status

return status

J'ai trouvé une implémentation simple et efficace (!) De grizzled-python.

L'utilisation simple os.open (..., O_EXCL) + os.close () ne fonctionnait pas sous Windows.

Vous pouvez trouver pylocker très utile. Il peut être utilisé pour verrouiller un fichier ou pour verrouiller les mécanismes en général et est accessible à partir de plusieurs processus Python à la fois.

Si vous souhaitez simplement verrouiller un fichier, voici comment cela fonctionne:

import uuid
from pylocker import Locker

#  create a unique lock pass. This can be any string.
lpass = str(uuid.uuid1())

# create locker instance.
FL = Locker(filePath='myfile.txt', lockPass=lpass, mode='w')

# aquire the lock
with FL as r:
    # get the result
    acquired, code, fd  = r

    # check if aquired.
    if fd is not None:
        print fd
        fd.write("I have succesfuly aquired the lock !")

# no need to release anything or to close the file descriptor, 
# with statement takes care of that. let's print fd and verify that.
print fd