Verrouillage de fichiers binarys à l’aide du système de contrôle de version git

Depuis un an et demi, je garde un œil sur la communauté git dans l’espoir de faire la transition avec SVN. L’incapacité à verrouiller des fichiers binarys est un problème particulier. Au cours de l’année écasting, je n’ai pas encore vu d’évolution sur cette question. Je comprends que le locking des fichiers va à l’encontre des principes fondamentaux du contrôle de source dissortingbué, mais je ne vois pas comment une entreprise de développement web peut profiter de git pour suivre le code source et les changements de fichiers d’image quand il y a le risque de conflits de fichiers binarys.

Pour obtenir les effets du locking, un référentiel “central” doit être identifié. Quelle que soit la nature dissortingbuée de git, la plupart des entresockets disposeront d’un référentiel “central” pour un projet logiciel. Nous devrions être en mesure de marquer un fichier comme nécessitant un verrou du référentiel git en vigueur à une adresse spécifiée. Peut-être cela est-il difficile car git suit le contenu des fichiers et non les fichiers?

L’un d’entre vous a-t-il de l’expérience dans le traitement des fichiers git et binarys qui devraient être verrouillés avant la modification?

NOTE: Il semble que le nouveau projet de contrôle de version dissortingbué open source de Source Gear, Veracity, ait pour objective de bloquer.

Git LFS 2.0 a ajouté un support pour le locking des fichiers.

Avec Git LFS 2.0.0, vous pouvez désormais verrouiller les fichiers sur lesquels vous travaillez activement, empêchant ainsi les autres utilisateurs d’accéder au serveur Git LFS jusqu’à ce que vous les déverrouilliez à nouveau.

Cela évitera les conflits de fusion ainsi que le travail perdu sur les fichiers non fusionnables au niveau du système de fichiers. Bien qu’il puisse sembler contredire la dissortingbution et de la nature parallèle de Git, le locking de fichier est une partie importante de nombreux stream de travail, en particulier de développement de logiciels pour les grandes équipes qui travaillent avec des actifs binarys.

Subversion a des verrous, et ils ne sont pas seulement des conseils. Ils peuvent être appliqués en utilisant l’atsortingbut svn:needs-lock (mais peuvent aussi être délibérément cassés si nécessaire). C’est la bonne solution pour gérer les fichiers non fusionnables. La société pour laquelle je travaille est à peu près tout dans Subversion et utilise svn:needs-lock pour tous les fichiers non fusionnables.

Je ne suis pas d’accord avec “les serrures ne sont qu’une méthode de communication”. Ils sont une méthode beaucoup plus efficace que les notifications push telles que le téléphone ou l’e-mail. Les verrous de subversion sont auto-documentés (qui a le verrou). D’autre part, si vous devez communiquer par d’autres canaux de notification push traditionnels, tels que le courrier électronique, à qui envoyez-vous la notification? Vous ne savez pas à l’avance qui peut vouloir modifier le fichier, en particulier sur les projets open-source, sauf si vous avez une liste complète de votre équipe de développement. Ces méthodes de communication traditionnelles ne sont donc pas aussi efficaces.

Un serveur de locking central, contrairement aux principes du DVCS, est la seule méthode possible pour les fichiers non-fusibles. Tant que le DVCS n’a pas de fonction de locking central, je pense que la société pour laquelle je travaille doit continuer à utiliser Subversion.

La meilleure solution serait de créer un outil de fusion pour tous vos formats de fichiers binarys, mais il s’agit d’un objective à long terme et permanent qui ne sera jamais «fini».

Voici une lecture intéressante sur le sujet.

Je suis d’accord que le locking des fichiers binarys est une fonctionnalité nécessaire pour certains environnements. J’ai juste réfléchi à la façon de mettre en œuvre cela, bien que:

  • Avoir un moyen de marquer un fichier comme “needs-lock” (comme la propriété “svn: needs-lock”).
  • À la caisse, git marque un fichier en lecture seule.
  • Une nouvelle commande git-lock contactera un serveur de locking central quelque part pour demander la permission de verrouiller.
  • Si le serveur de locking accorde une autorisation, marquez le fichier en lecture-écriture.
  • git-add informe le serveur de locking du contenu du hachage du fichier verrouillé.
  • Le serveur de locking surveille l’apparition de ce hachage dans un commit sur le référentiel maître.
  • Lorsque le hachage apparaît, relâchez le verrou.

C’est une idée très approximative et il y a des trous potentiels partout. Cela va aussi à l’encontre de l’esprit de git, mais cela peut certainement être utile dans certains contextes.

Dans une organisation particulière, ce genre de chose pourrait peut-être être construit en utilisant une combinaison appropriée d’encapsuleurs de script et de hooks de validation.

En réponse à l’inquiétude de Mario concernant les changements intervenant à plusieurs endroits dans les binarys. Ainsi, le scénario est qu’Alice et Bob apportent tous les deux des modifications à la même ressource binary en même temps. Ils ont chacun leur propre repo local, cloné à partir d’une télécommande centrale.

C’est en effet un problème potentiel. Ainsi, Alice termine en premier et passe à la twig centrale alice/update . Normalement, lorsque cela se produit, Alice ferait une annonce selon laquelle elle devrait être révisée. Bob voit ça et le révise. Il peut soit (1) incorporer ces modifications lui-même dans sa version (en partant d’ alice/update et en y apportant ses modifications) ou (2) publier ses propres modifications sur bob/update . Encore une fois, il fait une annonce.

Maintenant, si Alice pousse à master place, Bob a un dilemme quand il tire master et essaie de se fondre dans sa twig locale. Ses conflits avec ceux d’Alice. Mais encore une fois, la même procédure peut s’appliquer, uniquement sur différentes twigs. Et même si Bob ignore tous les avertissements et commet sur Alice, il est toujours possible de sortir l’engagement d’Alice pour régler les problèmes. Cela devient simplement un problème de communication.

Puisque (AFAIK) les verrous de Subversion ne sont que des conseils, un courrier électronique ou un message instantané pourrait servir le même objective. Mais même si vous ne le faites pas, Git vous permet de le réparer.

Non, il n’y a pas de mécanisme de locking en soi. Mais un mécanisme de locking tend à se substituer à une bonne communication. Je crois que c’est pourquoi les développeurs de Git n’ont pas ajouté de mécanisme de locking.

Nous venons tout juste de commencer à utiliser Git (Subversion utilisé précédemment) et j’ai trouvé un changement dans le workflow qui pourrait vous aider à résoudre votre problème, sans avoir besoin de verrou. Il tire parti de la conception de git et de la facilité des twigs.

Fondamentalement, cela revient à pousser vers une twig non maître, à faire une révision de cette twig, puis à fusionner dans la twig principale (ou sur la twig cible).

La façon dont git est “destiné” à être utilisé, chaque développeur publie son propre référentiel public, dont il demande aux autres de tirer. J’ai trouvé que les utilisateurs de Subversion ont des problèmes avec ça. Ainsi, au lieu de cela, nous poussons à twigr des arborescences dans le référentiel central, chaque utilisateur ayant son propre arborescence. Par exemple, une hiérarchie comme celle-ci pourrait fonctionner:

 users/a/feature1 users/a/feature2 users/b/feature3 teams/d/featurey 

N’hésitez pas à utiliser votre propre structure. Note Je montre également les twigs du sujet, un autre idiome commun de git.

Puis dans un repo local pour l’utilisateur a:

 feature1 feature2 

Et pour le faire parvenir au serveur central (origine):

 git push origin feature1:users/a/feature1 

(cela peut probablement être simplifié avec des changements de configuration)

Quoi qu’il en soit, une fois que feature1 est passé en revue, quiconque est responsable (dans notre cas, c’est le développeur de la fonctionnalité, vous pourriez avoir un seul utilisateur responsable des fusions à maîsortingser), fait ce qui suit:

 git checkout master git pull git merge users/name/feature1 git push 

L’extrait effectue une extraction (en tirant tous les nouveaux changements principaux et la twig de fonctionnalités) et le maître des mises à jour dans le référentiel central. Si l’utilisateur a fait son travail et suivi le maître correctement, la fusion ne devrait pas poser de problème.

Tout cela signifie que, même si un utilisateur ou une équipe distante apporte une modification à une ressource binary, celle-ci est examinée avant d’être incorporée dans la twig principale. Et il y a une délimitation claire (basée sur le processus) quant au moment où quelque chose entre dans la twig principale.

Vous pouvez également appliquer par programmation des aspects de ceci en utilisant des hooks git, mais là encore, je n’ai pas encore travaillé avec eux, donc je ne peux pas en parler.

Lorsque j’utilisais Subversion, je définissais religieusement la propriété svn:needs-lock sur tous les fichiers texte binarys et même difficiles à éditer. Je n’ai jamais réellement vécu de conflit.

Maintenant, à Git, je ne m’inquiète pas de telles choses. Rappelez-vous: les verrous dans Subversion ne sont pas des verrous obligatoires, ils ne sont que des outils de communication. Et devinez quoi: je n’ai pas besoin de Subversion pour communiquer, je peux me débrouiller très bien avec le courrier électronique, le téléphone et la messagerie instantanée.

Une autre chose que j’ai faite est de remplacer de nombreux formats binarys par des formats de texte brut. J’utilise reStructuredText ou LaΤ Ε Χ au lieu de Word, CSV au lieu d’Excel, ASCII-Art au lieu de Visio, YAML au lieu de bases de données, SVG au lieu de OO Draw, abc au lieu de MIDI, etc.

Il est utile d’examiner votre stream de travail actuel pour voir si le locking des images est vraiment nécessaire. Il est relativement inhabituel pour deux personnes de modifier une image de manière indépendante, et un peu de communication peut être très utile.

J’ai discuté de cette question sur les groupes de discussion git et j’ai conclu qu’il n’existait à l’heure actuelle aucune méthode convenue de locking centralisé des fichiers pour git.

TortoiseGit prend en charge le stream de travail git complet pour les documents Office déléguant diff à Office lui-même. Il fonctionne également en déléguant aux formats OpenOffice for OpenDocument.

Je ne m’attendrais pas à ce que le locking des fichiers en fasse une fonctionnalité dans git. Quels types de fichiers binarys vous intéressent principalement? Êtes-vous réellement intéressé par le locking des fichiers, ou simplement par la prévention des conflits provoqués par l’impossibilité de les fusionner?

Je me souviens de quelqu’un qui parle (ou même implémente) la prise en charge de la fusion de documents OpenOffice dans git.

Qu’en est-il des fichiers CAD? Si les fichiers ne sont pas verrouillés, pour être conservés en lecture seule, la plupart des programmes CAD les ouvrent simplement en changeant des bits arbitraires, considérés comme un nouveau fichier par n’importe quel vcs. Donc, à mon avis, le locking est un moyen idéal pour communiquer votre intention de modifier certains fichiers particalur. De plus, cela empêche certains logiciels d’avoir un access en écriture en premier lieu. Cela permet de mettre à jour les fichiers locaux sans avoir à fermer le logiciel ou au moins tous les fichiers.

Il suffit de mettre un fichier texte dans cc avec le fichier que vous souhaitez verrouiller et de le faire rejeter par le hook de mise à jour.

Il se peut que réorganiser un projet aide à éviter les verrous, mais:

  • Les équipes sont également organisées selon d’autres priorités (localisation, clients, …)
  • Les outils sont également sélectionnés par d’autres cibles (compatibilité, prix, facilité d’utilisation par la plupart des employés)
  • Certains outils (et donc les fichiers binarys) ne peuvent pas être évités, car il n’y a tout simplement pas de remplaçant capable de faire le même travail, correspondant aux besoins de l’entreprise pour le même prix.

Pour demander, toute une entreprise pourrait réorganiser son stream de travail et remplacer tous ses outils qui produisent des binarys, seulement pour pouvoir travailler avec git, en raison du manque de verrous, cela semble assez inefficace.

Les verrous ne rentrent pas dans la philosophie de git (qui n’a jamais été faite pour les binarys), mais il existe des situations non négligeables, où les verrous sont le moyen le plus efficace de résoudre un tel problème.

Ce n’est pas une solution mais plutôt un commentaire sur la nécessité de mécanismes de locking. Il existe certains outils utilisés dans certains champs qui utilisent uniquement des formats binarys critiques à l’échelle de la mission et les «outils mieux adaptés / différents» ne sont tout simplement pas une option. Il n’y a pas d’autres outils viables. Ceux que je connais ne seraient vraiment pas des candidats à la fusion, même si vous stockiez les mêmes informations dans un format ASCII. Une objection que j’ai entendue est que vous voulez pouvoir travailler hors ligne. L’outil particulier auquel je pense ne fonctionne pas vraiment en mode hors connexion, car il faut extraire des licences, donc si j’ai des données sur un ordinateur portable, ce n’est pas comme si je pouvais utiliser l’outil dans un train. Cela dit, ce que git fournit si ma connexion est lente, je peux obtenir des licences et aussi retirer des modifications, mais j’ai une copie locale rapide pour examiner différentes versions. C’est une bonne chose que le DVCS vous offre même dans ce cas.

Un sharepoint vue est que git n’est tout simplement pas l’outil à utiliser, mais il est agréable pour tous les fichiers texte qui sont également gérés avec lui et il est ennuyeux d’avoir besoin d’outils de contrôle de version différents pour différents fichiers.

L’approche du type de conseil-locking-via-mail pue vraiment. J’ai vu cela et j’ai été fatigué d’un flot ininterrompu d’e-mails de “je le modifie” “j’ai terminé l’édition” et j’ai vu les changements perdus à cause de cela. Le cas particulier auquel je pense était celui où une collection de fichiers ascii plus petits aurait été beaucoup plus agréable, mais c’est une réserve.

Je ne suggère pas d’utiliser git chez moi pour le même problème. Nous utilisons EA pour toutes nos conceptions et Microsoft Word pour la documentation, nous ne soaps pas à l’avance qui peut éditer un fichier particulier, le locking exclusif est notre seule option.

git fonctionnera très bien dans un environnement hors équipe où chaque développeur est seul responsable d’un morceau de code ou de fichier, car dans ce cas, la communication sur les verrous n’est pas nécessaire.

Si votre organisation requirejs un environnement d’équipe (généralement pour supprimer les développeurs de la sécurité des tâches), utilisez svn, git n’est pas pour vous. Svn fournit à la fois le contrôle des sources et la communication entre développeurs sur les verrous.

Git ne fournit aucune commande pour verrouiller des fichiers, mais j’ai trouvé un moyen de réaliser cette fonction en utilisant les hooks git. Un serveur auxiliaire est nécessaire pour stocker les informations de locking. Nous pouvons utiliser un hook pré-commit pour vérifier si l’un des fichiers validés est verrouillé. Et si quelqu’un verrouille un fichier, un programme devrait indiquer au serveur auxiliaire les informations du casier et du fichier verrouillé.