Linux troupeau, comment il “suffit” de verrouiller un fichier?

En Bash, je suis en train de faire une fonction getLock pour être utilisé avec différents noms de verrouillage.

function getLock
{
    getLock_FILE=""
    getLock_OP=""
    case "${getLock_OP}" in
        "LOCK_UN")
            flock -u "${getLock_FILE}"
            rm -fr "${getLock_FILE}"
            ;;
        "LOCK_EX")
            flock -x "${getLock_FILE}"
    esac
}

Mais troupeau dit flock: bad number: myfilelock

Comment puis-je verrouiller un fichier, et de le libérer quand je veux, sans avoir à exécuter une commande dans le troupeau?

C'est pour être utilisée comme ceci:

getLock myfilelock LOCK_EX
somecommands
........
getLock myfilelock LOCK_UN
  • Je ne te comprends pas. Je n'ai pas wan pas de verrouiller un fichier modifié, veulent juste pour obtenir un verrou sur elle afin qu'un autre processus en cours d'exécution en PHP qui verrouille le même fichier, qui attend d'être libéré.
  • Refonte de votre script à utiliser flock pour chaque instance qui doit être de verrouillage protégé. Sinon, il suffit de créer vos propres fichiers de verrouillage, c'est juste des fichiers normaux...
  • Donc flock fonctionne comme: processus 1 exécute les flock lockfile command_to_run, processus 2 exécute flock lockfile some_command. Maintenant, la deuxième aura lieu jusqu'à la première finitions. Simple que cela. Même pas besoin de soins sur le fichier de verrouillage lui-même, flock poignées automatiquement.
  • flock verrous de descripteurs de fichier, pas de fichiers. C'est important, car cela signifie que vous pas verrouiller un fichier que vous n'êtes pas tenue ouvert pour la durée de la serrure.
  • Pour info, le function mot-clé est gratuitement incompatible avec POSIX sh, et n'ajoute aucune valeur, que ce soit au cours de la POSIX syntaxe pour la déclaration des fonctions. Aussi, pourquoi utiliser des espaces de variables globales lorsque vous pouvez simplement utiliser habitants? Aussi, ne JAMAIS ne JAMAIS ne JAMAIS ne JAMAIS supprimer les fichiers de verrous créés avec flock (sauf si vous êtes complètement sûr que personne ne peut être en essayant d'attraper un verrou en même temps-ce redémarrage est sûr), ce qui crée des conditions de course. Laisser le déverrouillage des fichiers sur le disque pour s'assurer que, si les deux programmes d'essayer de saisir simultanément le même libéré de verrouillage, ils obtiennent le même inode.
  • Je pensais qu'il n'y avait pas de variables locales, vous devez utiliser le "déclarer" pour eux, à être locale? C'est pourquoi j'ai utilisé les espaces de noms. Et je ne devrais pas utiliser la fonction de mot-clé que vous dites? Juste le nom et les accolades?
  • declare va rendre les choses locale, si utilisé à l'intérieur d'une fonction, mais il y a aussi un local de mots clés disponibles.
  • correct, juste le nom et bretelles; la function mot-clé de votre code incompatible avec d'autres coquilles, mais (contrairement à beaucoup d'autres, plus utiles bashisms) n'ajoute aucune valeur en faire.

InformationsquelleAutor JorgeeFG | 2014-06-24
  1. 31

    De verrouiller le fichier:

    exec 3>filename # open a file handle; this part will always succeed
flock -x 3      # lock the file handle; this part will block

    Pour libérer le verrou:

    exec 3>&-       # close the file handle

    Vous pouvez également faire de la manière dont le troupeau de la page de manuel décrit:

    {
  flock -x 3
  ...other stuff here...
} 3>filename

    ...auquel cas le fichier est automatiquement fermé lorsque le bloc de sorties. (Un shell interne est exécuté peut également être utilisée ici, via l'aide de ( ) plutôt que { }, mais ce devrait être une décision délibérée -- en tant que sous-coquille ont une perte de performance, et de la portée de la variable modifications et autres changements d'état à eux-mêmes).

    Si vous utilisez une nouvelle assez de la version de bash, vous n'avez pas besoin de gérer un fichier descripteur de numéros à la main:

    # this requires a very new bash -- 4.2 or so.
exec {lock_fd}>filename
flock -x "$lock_fd"
exec $lock_fd>&-

    ...maintenant, pour votre fonction, nous allons avoir besoin de tableaux associatifs et automatique FD allocation (et, pour permettre le même fichier pour être verrouillé ou déverrouillé à partir de différents chemins, GNU readlink) -- si cela ne fonctionne pas avec les anciennes versions de bash:

    declare -A lock_fds=()                        # store FDs in an associative array
getLock() {
  local file=$(readlink -f "$1")              # declare locals; canonicalize name
  local op=$2
  case $op in
    LOCK_UN)
      [[ ${lock_fds[$file]} ]] || return      # if not locked, do nothing
      exec ${lock_fds[$file]}>&-              # close the FD, releasing the lock
      unset lock_fds[$file]                   # ...and clear the map entry.
      ;;
    LOCK_EX)
      [[ ${lock_fds[$file]} ]] && return      # if already locked, do nothing
      local new_lock_fd                       # don't leak this variable
      exec {new_lock_fd}>"$file"              # open the file...
      flock -x "$new_lock_fd"                 # ...lock the fd...
      lock_fds[$file]=$new_lock_fd            # ...and store the locked FD.
      ;;
  esac
}

    Si vous êtes sur une plate-forme GNU readlink est pas disponible, je vous suggère de remplacer le readlink -f appel avec realpath de sh-realpath par Michael Kropat (en ne comptant que sur largement-disponible readlink fonctionnalité, pas GNU extensions).

    InformationsquelleAutor Charles Duffy