Plate-forme de verrouillage de fichier indépendant?

Question

Je suis en cours d'exécution d'un travail scientifique intensif très informatiquement qui crache sur les résultats chaque maintenant et puis. Le travail est fondamentalement juste simuler la même chose tout un tas de fois, il est donc divisé entre plusieurs ordinateurs, qui utilisent différents systèmes d'exploitation. Je voudrais diriger la sortie de tous ces cas, le même fichier, puisque tous les ordinateurs peuvent voir le même système de fichiers via NFS / Samba. Voici les contraintes:

1. doit permettre concomitantes sûr y ajouter ses. Doit bloquer si une autre instance sur un autre ordinateur est actuellement au Annexer des fichiers.
2. performance ne pas count. E / S pour chaque instance est seulement quelques octets par minute.
3. La simplicité ne compte. Le point entier de cette (en plus de la curiosité pure) est si je peux cesser d'avoir tous les cas écrire dans un fichier différent et fusionnant manuellement ces fichiers ensemble.
4. ne doit pas dépendre des détails du système de fichiers. Doit travailler avec un système de fichiers inconnu sur un montage NFS ou Samba.

La langue que je utilise est D, dans le cas qui compte. Je l'ai regardé, il n'y a rien dans la norme lib qui semble faire. Les deux D-spécifiques et générales, les réponses de langue agnostique sont tout à fait acceptables et appréciés.

Answer 1

-Root Vous faites face à des problèmes avec la mise en cache côté client et des données périmées. J'ai écrit un module de verrouillage indépendant OS pour fonctionner sur NFS avant. L'idée simple de créer un fichier .lock [datafile] ne fonctionne pas sur NFS. L'idée de base de travailler autour d'elle est de créer un fichier de verrouillage [datafile] .lock qui, si présent signifie fichier n'est pas verrouillé et un processus qui veut acquérir un verrou renomme le fichier à un nom différent, comme [datafile] .lock. [ nom d'hôte]. [pid]. Le changement de nom est une opération assez atomique qui fonctionne assez bien sur NFS pour garantir l'exclusivité de la serrure. Le reste est essentiellement un groupe de fail safe, des boucles, la vérification des erreurs et de récupération en cas de verrouillage du processus meurt avant de libérer le verrou et renommer le fichier de verrouillage de retour à [fichier de données] .lock

Answer 2

La solution classique consiste à utiliser un fichier de verrouillage, ou plus exactement un répertoire de verrouillage. Sur tous les systèmes d'exploitation commune la création d'un répertoire est une opération atomique si la routine est:

• essayer de créer un répertoire de verrouillage avec un nom fixe dans un emplacement fixe
• si l'Echec de création, attendez une seconde ou et essayez à nouveau - répéter jusqu'à ce que le succès
• écrire vos données dans le fichier de données réelles
• supprimer le répertoire de verrouillage

Cela a été utilisé par des applications telles que CVS depuis de nombreuses années dans de nombreuses plates-formes. Le seul problème se produit dans les rares cas où votre application se bloque lors de l'écriture et avant de retirer le verrou.

Answer 3

Pourquoi ne pas simplement construire un simple serveur qui se trouve entre le fichier et les autres ordinateurs?

Alors si vous avez toujours voulu changer le format de données, vous ne devez modifier le serveur, et non tous les clients.

À mon avis la construction d'un serveur serait beaucoup plus facile que d'essayer d'utiliser un système de fichiers réseau.

Answer 4

Fichier de verrouillage avec une touche

Comme d'autres réponses ont mentionné, la méthode la plus simple est de créer un fichier de verrouillage dans le même répertoire que le fichier de données.

Puisque vous voulez être en mesure d'accéder au même fichier sur plusieurs PC la meilleure solution que je peux penser est juste inclure l'identifiant de la machine en train d'écrire dans le fichier de données.

Ainsi, la séquence d'écriture dans le fichier de données serait:

1. Vérifiez s'il y a un fichier présent de verrouillage

2. S'il y a un fichier de verrouillage, voir si je suis celui de posséder en vérifiant que son contenu a mon identifiant.
   Si tel est le cas, il suffit d'écrire dans le fichier de données puis supprimez le fichier de verrouillage.
   Si ce n'est pas le cas, attendez une seconde ou une petite longueur de temps aléatoire et essayez à nouveau le cycle.

3. S'il n'y a pas de fichier de verrouillage, créez un avec mon identifiant et essayer le cycle à nouveau pour éviter la condition de course (re-vérifier que le fichier de verrouillage est vraiment le mien).

En plus de l'identifiant, j'enregistrerait un horodatage dans le fichier de verrouillage et vérifier si elle est plus qu'une valeur de délai donné.
Si l'horodatage est trop vieux, alors supposer que le fichier de verrouillage est obsolète et juste le supprimer car il Mea l'un des PC écrit au fichier de données peut être écrasé ou sa connexion a été perdue.

Une autre solution

Si vous êtes en contrôle le format du fichier de données, pourrait être de réserver une structure au début du fichier pour enregistrer s'il est verrouillé ou non.
Si vous réservez juste un octet à cet effet, vous pouvez supposer, par exemple, que signifierait le 00 fichier de données ne sont pas verrouillés, et que d'autres valeurs représenterait l'identifiant de la machine en train d'écrire à elle.

Problèmes avec NFS

OK, j'ajoute quelques choses parce que Jiri Klouda a à juste titre que utilise NFS mise en cache côté client qui se traduira dans le fichier de verrouillage réel étant dans un état indéterminé.

Quelques façons de résoudre ce problème:

• monter le répertoire NFS avec le ou noac sync options. Ceci est facile, mais ne garantit pas totalement la cohérence des données entre le client et le serveur bien donc il peut encore y avoir des problèmes, bien que dans votre cas, il peut être OK.

• Ouvrez le fichier de verrouillage ou d'un fichier de données à l'aide du O_DIRECT, les attributs O_SYNC ou O_DSYNC. Ce système est censé désactiver le cache complètement.
  Cela permettra de diminuer les performances, mais assurera la cohérence.

• peut pouvoir utiliser pour verrouiller le flock() fichier de données, mais sa mise en œuvre est inégale et vous devez vérifier si votre système d'exploitation particulier utilise effectivement le service de verrouillage NFS. Il ne peut rien faire du tout autrement.
  Si le fichier de données est verrouillé, puis une autre ouverture client pour l'écriture échouera.
  Ah oui, et il ne semble pas fonctionner sur les partages SMB, il est probablement préférable d'oublier à ce sujet.

• Ne pas utiliser NFS et il suffit d'utiliser Samba à la place: il y a un

  Je ne sais pas D, mais je chose en utilisant un fichier mutex pour faire le Jobe pourrait fonctionner. Voici quelques pseudo-code peut vous être utile:

  do {
    // Try to create a new file to use as mutex.
    // If it's already created, it will throw some kind of error.
    mutex = create_file_for_writing('lock_file');
  } while (mutex == null);
  
  // Open your log file and write results
  log_file = open_file_for_reading('the_log_file');
  write(log_file, data);
  close_file(log_file);
  
  close_file(mutex);
  // Free mutex and allow other processes to create the same file.
  delete_file(mutex); 
  

  Alors, tous les processus vont essayer de créer le fichier mutex, mais seulement celui qui gagne sera en mesure de continuer. Une fois que vous écrivez votre sortie, fermer et supprimer le mutex pour que d'autres processus peuvent faire la même chose.

Answer 5

Answer 6

Answer 7

Je ne sais pas D, mais je chose en utilisant un fichier mutex pour faire le Jobe pourrait fonctionner. Voici quelques pseudo-code peut vous être utile:

do {
  // Try to create a new file to use as mutex.
  // If it's already created, it will throw some kind of error.
  mutex = create_file_for_writing('lock_file');
} while (mutex == null);

// Open your log file and write results
log_file = open_file_for_reading('the_log_file');
write(log_file, data);
close_file(log_file);

close_file(mutex);
// Free mutex and allow other processes to create the same file.
delete_file(mutex); 

Alors, tous les processus vont essayer de créer le fichier mutex, mais seulement celui qui gagne sera en mesure de continuer. Une fois que vous écrivez votre sortie, fermer et supprimer le mutex pour que d'autres processus peuvent faire la même chose.

Answer 8

Answer 9

Answer 10