Welcher Teil Ihres Projekts sollte sich in der Quellcodeverwaltung befinden?

Ein Mitentwickler hat begonnen, an einem neuen Drupal-Projekt zu arbeiten, und der Systemadministrator hat vorgeschlagen, nur das Unterverzeichnis sites / default in die Quellcodeverwaltung aufzunehmen, da hierdurch "Aktualisierungen einfach über Skripts ausführbar werden". Abgesehen von dieser etwas zweifelhaften Behauptung wirft sie eine andere Frage auf: Welche Dateien sollten der Quellcodeverwaltung unterliegen? Und gibt es eine Situation, in der ein großer Teil der Dateien ausgeschlossen werden sollte?

Meiner Meinung nach sollte der gesamte Baum für das Projekt unter Kontrolle sein, und dies würde für ein Drupal-Projekt, Rails oder irgendetwas anderes gelten. Dies scheint ein Kinderspiel zu sein - Sie benötigen eindeutig eine Versionierung für Ihr Framework ebenso wie für jeden benutzerdefinierten Code, den Sie schreiben.

Trotzdem würde ich gerne andere Meinungen dazu einholen. Gibt es Argumente dafür, nicht alles unter Kontrolle zu haben?

Ich würde sagen, dass die Quellcodeverwaltung mindestens alle Dateien enthalten sollte, die zum Neuerstellen einer ausgeführten Version des Projekts erforderlich sind. Dies umfasst sogar DDL-Dateien zum Einrichten und Ändern von Datenbankschemata, und zwar auch in der richtigen Reihenfolge. Abgesehen von den Tools, die zum Erstellen und Ausführen des Projekts erforderlich sind, und allem, was automatisch aus anderen Dateien in der Quellcodeverwaltung abgeleitet / generiert werden kann (z. B. JavaDoc-Dateien, die aus den Java-Dateien in der Quellcodeverwaltung generiert wurden).

Es ist am besten, fast alles unter der Sonne in die Quellcodeverwaltung zu bringen.

• Code

• Bibliotheken

• Ressourcen

• Erstellen / Bereitstellen von Skripten

• Skripte zur Datenbankerstellung und -aktualisierung

• Bestimmte Dokumentation

• Umgebungsspezifische Konfigurationsdateien

Das einzige, was nicht in die Quellcodeverwaltung aufgenommen werden sollte, sind Build-Artefakte für Ihr Projekt.

Ich würde sagen, dass;

• Jede Datei, die zur Ausführung des Builds benötigt wird, wird in die Versionskontrolle aufgenommen
• Jede Datei, die vom Build generiert werden kann, funktioniert nicht

Ich würde dazu neigen, große Binärdateien wie Tool-Installationspakete außerhalb des Trunks zu platzieren, aber sie sollten immer noch unter Versionskontrolle stehen.

Und vergessen Sie nicht, auch den gesamten Datenbankcode in die Quellcodeverwaltung zu stellen! Dies umfasst die ursprünglichen Erstellungsskripten, die Skripten zum Ändern von Tabellen (die durch die von der Software verwendete Version gekennzeichnet sind, sodass Sie jede Version der Datenbank für jede Version der Anwendungen neu erstellen können) und Skripten zum Auffüllen von Nachschlagetabellen.

Schwer gewonnene Erfahrungen haben mich gelehrt, dass fast alles in die Quellcodeverwaltung gehört. (Meine Kommentare hier sind von anderthalb Jahrzehnten Farbe, die für eingebettete / Telekommunikationssysteme auf proprietärer Hardware mit proprietären und manchmal schwer zu findenden Tools entwickelt wurden.)

Einige der Antworten hier lauten "Versetzen Sie keine Binärdateien in die Quellcodeverwaltung". Das ist falsch. Wenn Sie an einem Produkt mit viel Code von Drittanbietern und vielen Binärbibliotheken von Anbietern arbeiten, checken Sie die Binärbibliotheken ein . Andernfalls tritt irgendwann ein Upgrade auf und es treten Probleme auf: Der Build bricht ab, da die Build-Maschine nicht über die neueste Version verfügt. jemand gibt dem Neuen die alten CDs, von denen er sie installieren kann; Das Projekt-Wiki enthält veraltete Anweisungen bezüglich der zu installierenden Version. usw. Schlimmer noch, wenn Sie eng mit dem Anbieter zusammenarbeiten müssen, um ein bestimmtes Problem zu lösen, und dieser Ihnen fünf Bibliotheksgruppen in einer Woche zusendet, müssen Sie dies tunin der Lage sein, zu verfolgen, welche Binärdateien welches Verhalten aufwiesen. Das Quellcodeverwaltungssystem ist ein Tool, das genau dieses Problem löst.

Einige der Antworten hier lauten "Versetzen Sie die Toolchain nicht in die Quellcodeverwaltung". Ich sage nicht, dass es falsch ist, aber es ist am besten, die Toolchain in die Quellcodeverwaltung zu versetzen , es sei denn, Sie verfügen über ein solides Konfigurationsverwaltungssystem . Betrachten Sie erneut das oben erwähnte Upgrade-Problem. Schlimmer noch, ich arbeitete an einem Projekt, bei dem vier verschiedene Varianten der Toolchain im Umlauf waren, als ich eingestellt wurde - alle im aktiven Einsatz ! Eines der ersten Dinge, die ich tat (nachdem ich es geschafft hatte, einen Build zum Laufen zu bringen), war die Versionskontrolle der Toolchain. (Die Idee eines soliden CM-Systems war hoffnungslos.)

Und was passiert, wenn unterschiedliche Projekte unterschiedliche Toolchains erfordern? Ein typisches Beispiel: Nach ein paar Jahren erhielt eines der Projekte ein Upgrade von einem Anbieter und alle Makefiles gingen kaputt. Es stellte sich heraus, dass sie sich auf eine neuere Version von GNU make stützten. Also haben wir alle aufgerüstet. Hoppla, die Makefiles eines anderen Projekts sind alle kaputt gegangen. Lektion: Übernehmen Sie beide Versionen von GNU make und führen Sie die Version aus, die mit Ihrer Projektprüfung geliefert wird.

Oder wenn Sie an einem Ort arbeiten, an dem alles andere außer Kontrolle gerät, führen Sie Gespräche wie: "Hey, der neue Typ fängt heute an, wo ist die CD für den Compiler?" "Keine Ahnung, ich habe sie seit Jacks Rücktritt nicht mehr gesehen, er war der Hüter der CDs." "Äh, war das nicht bevor wir aus dem 2. Stock aufgestiegen sind?" "Vielleicht sind sie in einer Kiste oder so." Und da die Werkzeuge drei Jahre alt sind, gibt es keine Hoffnung, diese alte CD vom Anbieter zu bekommen.

Alle Ihre Build-Skripte gehören in die Quellcodeverwaltung. Alles! Bis hinunter zu Umgebungsvariablen. Ihr Build-Computer sollte in der Lage sein, einen Build eines beliebigen Projekts auszuführen, indem Sie ein einzelnes Skript im Stammverzeichnis des Projekts ausführen. ( ./buildist ein vernünftiger Standard; ./configure; makeist fast genauso gut.) Das Skript sollte die Umgebung nach Bedarf einrichten und dann das Tool starten, mit dem das Produkt erstellt wird (make, ant usw.).

Wenn Sie denken, es ist zu viel Arbeit, ist es nicht. Das spart tatsächlich eine Menge Arbeit. Sie übergeben die Dateien einmal zu Beginn und dann bei jedem Upgrade. Kein einzelner Wolf kann seine eigene Maschine upgraden und eine Menge Quellcode schreiben, der von der neuesten Version eines Tools abhängt, wodurch der Build für alle anderen gebrochen wird. Wenn Sie neue Entwickler einstellen, können Sie diese anweisen, das Projekt zu überprüfen und auszuführen ./build. Wenn in Version 1.8 viele Leistungsoptimierungen vorgenommen wurden und Sie Code, Compiler-Flags und Umgebungsvariablen optimieren, möchten Sie sicherstellen, dass die neuen Compiler-Flags nicht versehentlich auf Patchbuilds der Version 1.7 angewendet werden, da sie den Code wirklich benötigen Änderungen, die mit ihnen einhergehen, oder Sie sehen einige haarige Rennbedingungen.

Und das Beste ist , dass es eines Tages Ihren Hintern rettet: Stellen Sie sich vor, Sie versenden die Version 3.0.2 Ihres Produkts an einem Montag. Hurra, feier. Am Dienstagmorgen ruft ein VIP-Kunde die Support-Hotline an und beschwert sich über diesen überkritischen, dringenden Fehler in Version 2.2.6, den Sie vor 18 Monaten verschickt haben. Und vertraglich müssen Sie es immer noch unterstützen, und sie lehnen ein Upgrade ab, bis Sie mit Sicherheit bestätigen können, dass der Fehler im neuen Code behoben ist, und sie sind groß genug, um Sie zum Tanzen zu bringen. Es gibt zwei parallele Universen:

• In einem Universum, in dem es keine Bibliotheken, Toolchain und Build-Skripte in der Quellcodeverwaltung gibt und in dem Sie kein solides CM-System haben ... Sie können die richtige Version des Codes überprüfen, aber es gibt sie Sie alle Arten von Fehlern, wenn Sie versuchen, zu bauen. Mal sehen, haben wir die Tools im Mai aktualisiert? Nein, das waren die Bibliotheken. Ok, gehe zurück zu den alten Bibliotheken - warte, gab es zwei Upgrades? Ah ja, das sieht ein bisschen besser aus. Aber jetzt kommt mir dieser seltsame Linker-Absturz bekannt vor. Oh, das liegt daran, dass die alten Bibliotheken nicht mit der neuen Toolchain zusammengearbeitet haben. Deshalb mussten wir ein Upgrade durchführen, oder? (Ich erspare Ihnen die Qual des restlichen Aufwands. Es dauert zwei Wochen, und am Ende ist niemand glücklich, nicht Sie, nicht das Management, nicht der Kunde.)

• In dem Universum, in dem sich alles in der Quellcodeverwaltung befindet, checken Sie das 2.2.6-Tag aus, haben ein Debug-Build in etwa einer Stunde fertig, verbringen einen oder zwei Tage damit, den "VIP-Bug" neu zu erstellen, die Ursache aufzuspüren und zu beheben die aktuelle Version, und überzeugen Sie den Kunden, zu aktualisieren. Stressig, aber nicht annähernd so schlimm wie das andere Universum, in dem Ihr Haaransatz 3 cm höher ist.

Wenn das gesagt ist, können Sie es zu weit bringen:

• Sie sollten ein Standard-Betriebssystem installieren, von dem Sie eine "goldene Kopie" haben. Dokumentieren Sie es, wahrscheinlich in einer README-Datei, die sich in der Quellcodeverwaltung befindet, damit zukünftige Generationen wissen, dass Version 2.2.6 und früher nur auf RHEL 5.3 und 2.3.0 und später nur auf Ubuntu 11.04 basiert. Wenn es für Sie einfacher ist, die Toolchain auf diese Weise zu verwalten, wählen Sie es aus und vergewissern Sie sich, dass es sich um ein zuverlässiges System handelt.
• Die Pflege der Projektdokumentation in einem Versionsverwaltungssystem ist umständlich. Projektdokumente sind immer dem Code selbst voraus und es ist nicht ungewöhnlich, an der Dokumentation für die nächste Version zu arbeiten, während Sie an Code für die aktuelle Version arbeiten. Insbesondere, wenn alle Ihre Projektdokumente Binärdokumente sind, die Sie nicht unterscheiden oder zusammenführen können.
• Wenn Sie ein System haben, das die Versionen aller im Build verwendeten Komponenten steuert, verwenden Sie es ! Stellen Sie einfach sicher, dass die Synchronisierung im gesamten Team einfach ist, sodass alle (einschließlich der Build-Maschine) von denselben Tools profitieren. (Ich denke an Systeme wie Debians Pbuilder und den verantwortungsvollen Umgang mit Pythons Virtualenv.)

Die einzigen Dinge, die ich nicht der Quellcodeverwaltung unterstelle, sind Dateien, die Sie einfach neu generieren können oder die für den jeweiligen Entwickler spezifisch sind. Dies bedeutet ausführbare Dateien und Binärdateien, die aus Ihrem Quellcode, Dokumentation, die aus dem Lesen / Parsen von Dateien unter Versionskontrolle generiert wird, und IDE-spezifischen Dateien bestehen. Alles andere geht in die Versionskontrolle und wird entsprechend verwaltet.

Der Anwendungsfall für die Quellcodeverwaltung lautet: Was wäre, wenn alle unsere Entwicklercomputer und alle unsere Bereitstellungscomputer von einem Meteoriten getroffen würden? Sie möchten, dass die Wiederherstellung so nah wie möglich an der Kasse und beim Erstellen erfolgt. (Wenn das zu dumm ist, können Sie "einen neuen Entwickler einstellen".)

Mit anderen Worten, alles andere als Betriebssysteme, Apps und Tools sollte sich in VCS befinden. In eingebetteten Systemen, in denen eine Abhängigkeit von einer bestimmten Tool-Binärversion bestehen kann, wurden die Tools auch in VCS beibehalten.

Eine unvollständige Quellcodeverwaltung ist eines der häufigsten Risiken, die ich bei der Beratung sehe - es gibt jede Menge Reibungspunkte, wenn man einen neuen Entwickler einstellt oder eine neue Maschine einrichtet. Neben den Konzepten Continuous Integration und Continuous Delivery sollten Sie ein Gespür für "Continuous Development" haben - kann eine IT-Person eine neue Entwicklungs- oder Bereitstellungsmaschine im Wesentlichen automatisch einrichten, sodass der Entwickler den Code überprüfen kann, bevor er fertig ist ihre erste Tasse Kaffee?

Alles, was zum Projekt beiträgt und für das Sie Änderungen nachverfolgen möchten.

Ausnahmen können große binäre Blobs wie Bilder sein, wenn Sie einen SCM verwenden, der mit binären Daten nicht sehr gut umgehen kann.

Drupal verwendet Git, daher verwende ich die Terminologie von Git. Ich würde Subrepos für jedes Modul verwenden, um Modulaktualisierungen aus den offiziellen Repos von Drupal abzurufen und dabei die Struktur der einzelnen Bereitstellungen beizubehalten. Auf diese Weise erhalten Sie die Vorteile der Skriptfähigkeit, ohne die Vorteile der Quellcodeverwaltung zu verlieren.

Alles sollte unter Quellcodeverwaltung stehen, außer:

• Konfigurationsdateien, wenn sie Konfigurationsoptionen enthalten, die für jeden Entwickler und / oder jede Umgebung unterschiedlich sind (Entwicklung, Test, Produktion)
• Cache-Dateien, wenn Sie das Dateisystem-Caching verwenden
• Protokolldateien, wenn Sie in Textdateien protokollieren
• Alles, was Cache-Dateien und Protokolldateien mag, ist generierter Inhalt
• (Sehr) große Binärdateien, die sich wahrscheinlich nicht ändern (einige Versionskontrollsysteme mögen sie nicht, aber wenn Sie hg oder git verwenden, stört es sie nicht sehr)

Stellen Sie sich das so vor: Jedes neue Mitglied des Teams sollte in der Lage sein, eine Arbeitskopie des Projekts (abzüglich der Konfigurationselemente) auszuchecken.

Und vergessen Sie nicht, Datenbankschemaänderungen (einfache SQL-Dumps jeder Schemaänderung) ebenfalls der Versionskontrolle zu unterwerfen. Sie können Benutzer- und API-Dokumentation hinzufügen, wenn dies für das Projekt sinnvoll ist.

@maple_shaft wirft ein wichtiges Problem mit meiner ersten Aussage zu Umgebungskonfigurationsdateien in den Kommentaren auf. Ich möchte klarstellen, dass ich auf die Besonderheiten der Frage antworte, die sich auf Drupal- oder generische CMS-Projekte bezieht. In solchen Szenarien verfügen Sie normalerweise über eine lokale und eine Produktionsdatenbank, und eine Umgebungskonfigurationsoption sind die Anmeldeinformationen für diese Datenbanken (und ähnliche Anmeldeinformationen). Es ist ratsam, dass diese NICHT der Quellcodeverwaltung unterliegen, da dies mehrere Sicherheitsbedenken aufwirft.

In einem eher typischen Entwicklungsworkflow stimme ich jedoch maple_shaft zu, dass die Konfigurationsoptionen für die Umgebung der Quellcodeverwaltung unterliegen sollten, damit jede Umgebung in einem Schritt erstellt und bereitgestellt werden kann.

Alles, was Ihr automatisierter Build generiert, geht nicht in die Quellcodeverwaltung. Alles, was während des Builds nicht geändert werden muss , wird in die Quellcodeverwaltung übernommen. So einfach ist das.

Folgendes gehört beispielsweise nicht zur Quellcodeverwaltung:

• generierter Code
• generierte Binärdateien
• Alles, was von Ihrem Build erstellt wurde
• Alles, was zur Laufzeit von Ihrem Dienst, Ihrem Prozess oder Ihrer Webanwendung erstellt wurde

Was geht in der Quellcodeverwaltung:

• alles, was ein Mensch schafft
• Alles, was von einer anderen Person oder Gruppe erstellt wurde (z. B. eine interne Bibliothek eines Drittanbieters, in der die Quellcodeverwaltung verteilt ist, oder die Binärdateien eines Open-Source-Projekts).
• Skripte und andere Quellen, die Dinge wie eine Datenbank erstellen (dh wie würden Sie die Datenbank neu erstellen, wenn alle DBAs AWOL werden).

Diese Regeln-of-Daumen auf der Vorstellung ausgesagt , dass alles , was in der Quellcodeverwaltung ist könnte durch einen Menschen verändert werden und könnte jemand wertvolle Zeit in Anspruch nehmen zu verstehen , warum es da ist.

Alles, was Sie arbeiten müssen und ändern können, muss auf die eine oder andere Weise versioniert werden. Es ist jedoch selten erforderlich, dass zwei unabhängige Systeme den Überblick behalten.

Alles, was auf zuverlässige Weise generiert wurde, kann normalerweise an eine Quellversion angehängt werden - daher muss es nicht unabhängig nachverfolgt werden: generierte Quellen, Binärdateien, die nicht von einem System zu einem anderen übertragen werden usw.

Das Erstellen von Protokollen und anderen Dingen, die wahrscheinlich niemanden interessieren (aber Sie wissen es nie genau), wird in der Regel am besten von demjenigen verfolgt, der sie erstellt: Jenkins usw.

Build-Produkte, die von einem System an ein anderes übergeben werden, müssen nachverfolgt werden. Ein Maven-Repo ist jedoch eine gute Möglichkeit, dies zu tun. Sie benötigen nicht die Kontrolle, die eine Quellcodeverwaltung bietet. Die zu erbringenden Leistungen fallen häufig in dieselbe Kategorie.

Was übrig bleibt (und zu diesem Zeitpunkt sollte es kaum mehr als Quelldateien und Build-Server-Konfiguration geben), wird in die Quellcodeverwaltung übernommen.

Meine Antwort ist ziemlich einfach: keine Binärdateien. Implizit fast alles andere.

(Auf keinen Fall jedoch Datenbank-Backups oder Schema-Migrationen oder Benutzerdaten.)

Die Quellcodeverwaltung ist ein Mechanismus zur Änderungsverfolgung. Verwenden Sie diese Option, wenn Sie wissen möchten, wer was wann geändert hat.

Die Quellcodeverwaltung ist nicht kostenlos. Dies erhöht die Komplexität Ihres Workflows und erfordert Schulungen für neue Kollegen. Wägen Sie die Vorteile gegen die Kosten ab.

Beispielsweise kann es schwierig sein, Datenbanken zu steuern. Früher hatten wir ein System, in dem Sie Definitionen manuell in einer Textdatei speichern und diese dann zur Quellcodeverwaltung hinzufügen mussten. Dies nahm viel Zeit in Anspruch und war unzuverlässig. Da es unzuverlässig war, konnten Sie es nicht verwenden, um eine neue Datenbank einzurichten oder um zu überprüfen, wann eine Änderung vorgenommen wurde. Aber wir haben es jahrelang aufbewahrt und unzählige Stunden verschwendet, weil unser Manager dachte, "alle Dinge sollten in der Quellcodeverwaltung sein".

Quellcodeverwaltung ist keine Zauberei. Probieren Sie es aus, aber geben Sie es auf, wenn der Wert nicht ausreicht, um die Kosten auszugleichen.

Sachen die ich nicht in die Quellcodeverwaltung stecken würde:

• Geheime Schlüssel und Passwörter
• Das SDK, obwohl es sich um dasselbe Verzeichnis handelt und wenn ich ein Patch für das SDK mache, sollte es ein anderes Projekt sein, da es pro Framework und nicht pro App ist
• Bibliotheken von Drittanbietern wie. Reste von Migration, Backups, kompiliertem Code, Code unter anderer Lizenz (vielleicht)

So mache ich hg addremovezum Beispiel keine, da gelegentlich ein neuer Klon erstellt wird, wenn das SDK aktualisiert wird. Dadurch mache ich jedes Mal ein vollständiges Backup, wenn das SDk aktualisiert wird, und überprüfe, ob eine neue Version, die aus dem Repository geklont wurde, in Ordnung ist.

Ich kann Ihnen das folgende Buch wärmstens empfehlen, das sich mit Ihren Anliegen befasst:

Kontinuierliche Bereitstellung: Zuverlässige Softwareversionen durch Build-, Test- und Bereitstellungsautomatisierung . Kapitel 2 befasst sich insbesondere mit Elementen, die in die Quellcodeverwaltung aufgenommen werden sollen. Wie einige Leute bereits sagten, handelt es sich praktisch ausschließlich um generierte Inhalte, die als Ergebnis eines Builds erstellt wurden.

Ich bin nicht mit einem Teil der akzeptierten Antwort von @FrustratedWithFormsDesigner einverstanden, da er befürwortet, die für die Erstellung des Projekts erforderlichen Tools nicht in die Versionskontrolle einzubeziehen . Irgendwo in der Quellcodeverwaltung (neben dem zu erstellenden Code) sollten sich die Erstellungsskripten zum Erstellen des Projekts und Erstellungsskripten befinden, die nur über eine Befehlszeile ausgeführt werden. Wenn er mit Tools meint, IDEs und Editoren, sollten sie nicht verpflichtet sein, das Projekt überhaupt zu erstellen. Diese eignen sich für eine aktive / schnelle Entwicklung für Entwickler, und das Einrichten dieser Art von Umgebung kann auch als Skript ausgeführt oder aus einem anderen Abschnitt von SCM oder von einem binären Verwaltungsserver heruntergeladen werden. Das Einrichten solcher IDEs sollte so automatisiert wie möglich sein.

Ich bin auch anderer Meinung als @Yannis Rizos bezüglich der Platzierung von Konfigurationen für Umgebungen in der Quellcodeverwaltung. Der Grund dafür ist, dass Sie in der Lage sein sollten, jede Umgebung nach Belieben mit nur Skripten zu rekonstruieren. Ohne Konfigurationseinstellungen in der Quellcodeverwaltung ist dies nicht verwaltbar. Es gibt auch keinen Verlauf darüber, wie sich Konfigurationen für verschiedene Umgebungen entwickelt haben, ohne diese Informationen in die Quellcodeverwaltung zu übernehmen. Möglicherweise sind die Einstellungen der Produktionsumgebung vertraulich, oder Unternehmen möchten diese Einstellungen möglicherweise nicht in der Versionskontrolle platzieren. Eine zweite Option besteht darin, sie weiterhin in der Versionskontrolle zu platzieren, damit sie einen Verlauf haben und diesem Repository eingeschränkten Zugriff gewähren.

Behalten Sie den gesamten Code in der Versionskontrolle und lassen Sie alle Konfigurationen und Benutzerdaten aus. Um spezifisch für Drupal zu sein, müssen Sie alles außer files und settings.php in die Versionskontrolle einbinden