Jaka część twojego projektu powinna podlegać kontroli kodu źródłowego?

Inny programista rozpoczął pracę nad nowym projektem Drupal, a sysadmin zasugerował, że powinni oni jedynie poddać podkatalogowi site / default kontroli źródła, ponieważ „sprawi, że aktualizacje będą łatwe do skryptu”. Pomijając to nieco wątpliwe twierdzenie, rodzi się kolejne pytanie - jakie pliki powinny być pod kontrolą źródła? I czy istnieje sytuacja, w której należy wykluczyć część dużych plików?

Moim zdaniem całe drzewo dla projektu powinno być pod kontrolą, i byłoby to prawdą w przypadku projektu Drupal, szyn lub cokolwiek innego. Wydaje się to oczywiste - potrzebujesz wersji dla swojego frameworka tak samo, jak dla każdego pisanego niestandardowego kodu.

Powiedziałbym, że chciałbym uzyskać inne opinie na ten temat. Czy istnieją argumenty przemawiające za tym, by nie mieć wszystkiego pod kontrolą?

Powiedziałbym, że minimum, jakie powinna zawierać kontrola źródła, to wszystkie pliki niezbędne do odtworzenia działającej wersji projektu. Obejmuje to nawet pliki DDL do konfigurowania i modyfikowania dowolnego schematu bazy danych oraz we właściwej kolejności. Minus, oczywiście, narzędzia niezbędne do zbudowania i wykonania projektu, a także wszystko, co można automatycznie uzyskać / wygenerować z innych plików w kontroli źródła (takich jak pliki JavaDoc generowane z plików Java w kontroli źródła).

Najlepiej oddać wszystko pod słońce pod kontrolę źródła.

• Kod

• Biblioteki

• Zasoby

• Kompiluj / wdrażaj skrypty

• Skrypty do tworzenia i aktualizacji baz danych

• Pewna dokumentacja

• Pliki konfiguracyjne właściwe dla środowiska

Jedyną rzeczą, której nie należy poddawać kontroli źródła, są artefakty budowania dla twojego projektu.

Powiedziałabym to;

• każdy plik potrzebny do wykonania kompilacji przechodzi do kontroli wersji
• żaden plik (który może być) wygenerowany przez kompilację nie

Zwykle umieszczałbym duże pliki binarne, takie jak pakiety instalacyjne narzędzi, gdzieś poza pniem, ale nadal powinny być pod kontrolą wersji.

I nie zapomnij również umieścić całego kodu bazy danych w Kontroli źródła! Obejmuje to oryginalne skrypty tworzenia, skrypty do modyfikowania tabel (które są oznaczone tym, która wersja oprogramowania ich używa, aby można było odtworzyć dowolną wersję bazy danych dla dowolnej wersji aplikacji) oraz skrypty wypełniające dowolne tabele wyszukiwania.

Ciężko zdobyte doświadczenie nauczyło mnie, że prawie wszystko należy do kontroli źródła. (Moje komentarze tutaj są pokolorowane przez półtorej dekady rozwijającej się dla systemów osadzonych / telekomunikacyjnych na zastrzeżonym sprzęcie z zastrzeżonymi, a czasem trudnymi do znalezienia narzędziami.)

Niektóre odpowiedzi tutaj brzmią: „nie poddawaj plików binarnych kontroli źródła”. To jest źle. Gdy pracujesz nad produktem z dużą ilością kodu innej firmy i wieloma bibliotekami binarnymi od dostawców, sprawdzasz biblioteki binarne . Ponieważ jeśli tego nie zrobisz, w pewnym momencie zamierzasz dokonać aktualizacji i napotkasz problemy: kompilacja ulega awarii, ponieważ maszyna kompilacji nie ma najnowszej wersji; ktoś daje nowemu facetowi stare płyty CD do zainstalowania; wiki projektu ma nieaktualne instrukcje dotyczące tego, którą wersję zainstalować; itd. Co gorsza, jeśli musisz ściśle współpracować z dostawcą, aby rozwiązać konkretny problem, a on wysyła ci pięć zestawów bibliotek w ciągu tygodnia, musiszbyć w stanie śledzić, który zestaw plików binarnych wykazał, które zachowanie. System kontroli źródła jest narzędziem, które rozwiązuje dokładnie ten problem.

Niektóre odpowiedzi tutaj mówią „nie poddawaj łańcucha narzędzi kontroli źródła”. Nie powiem, że to źle, ale najlepiej jest umieścić łańcuch narzędzi w kontroli źródła, chyba że masz do tego solidny system zarządzania konfiguracją (CM) . Ponownie rozważ problem aktualizacji, jak wspomniano powyżej. Co gorsza, pracowałem nad projektem, w którym cztery osobne smaki łańcucha narzędziowego unosiły się, gdy zostałem zatrudniony - wszystkie z nich były w użyciu ! Jedną z pierwszych rzeczy, które zrobiłem (po tym, jak udało mi się uruchomić kompilację do działania), było poddanie łańcucha narzędzi kontroli źródła. (Idea solidnego systemu CM była poza nadzieją).

A co się stanie, gdy różne projekty wymagają różnych łańcuchów narzędzi? Przykład: po kilku latach jeden z projektów otrzymał aktualizację od dostawcy i wszystkie Makefile się zepsuły. Okazuje się, że polegali na nowszej wersji GNU make. Więc wszyscy zaktualizowaliśmy. Ups, wszystkie pliki Makefiles z innego projektu się zepsuły. Lekcja: zatwierdź obie wersje GNU make i uruchom wersję dostarczoną z kasą projektu.

Lub, jeśli pracujesz w miejscu, w którym wszystko inne wymyka się spod kontroli, masz rozmowy takie jak: „Hej, nowy facet zaczyna dzisiaj, gdzie jest płyta CD dla kompilatora?” „Dunno, nie widziałem ich od czasu odejścia Jacka, był strażnikiem płyt CD”. „Uhh, czy to nie było zanim przeprowadziliśmy się z 2. piętra?” „Może są w pudełku czy coś”. A ponieważ narzędzia mają trzy lata, nie ma nadziei na otrzymanie tej starej płyty CD od dostawcy.

Wszystkie skrypty kompilacji podlegają kontroli źródła. Wszystko! Aż do zmiennych środowiskowych. Maszyna kompilacji powinna być w stanie uruchomić kompilację dowolnego projektu, wykonując pojedynczy skrypt w katalogu głównym projektu. ( ./buildjest rozsądnym standardem; ./configure; makejest prawie tak samo dobry). Skrypt powinien skonfigurować środowisko zgodnie z wymaganiami, a następnie uruchomić dowolne narzędzie budujące produkt (marka, mrówka itp.).

Jeśli uważasz, że to za dużo pracy, to nie. To faktycznie oszczędza mnóstwo pracy. Pliki zatwierdzasz raz na początku, a następnie przy każdej aktualizacji. Żaden samotny wilk nie może zaktualizować własnej maszyny i zatwierdzić zestawu kodu źródłowego, który zależy od najnowszej wersji jakiegoś narzędzia, co psuje kompilację wszystkim innym. Zatrudniając nowych programistów, możesz im powiedzieć, aby sprawdzili projekt i uruchomili go ./build. Gdy wersja 1.8 ma dużo dostrajania wydajności, a ty poprawiasz kod, flagi kompilatora i zmienne środowiskowe, chcesz się upewnić, że nowe flagi kompilatora nie zostaną przypadkowo zastosowane do kompilacji łatek w wersji 1.7, ponieważ naprawdę potrzebują kodu zmiany, które się z nimi wiążą lub widzisz owłosione warunki wyścigowe.

A co najlepsze , pewnego dnia uratuje ci tyłek: wyobraź sobie, że wysyłasz wersję 3.0.2 produktu w poniedziałek. Brawo, świętuj. We wtorek rano klient VIP dzwoni na infolinię wsparcia, narzekając na ten nadkrytyczny, pilny błąd w wersji 2.2.6, który został wysłany 18 miesięcy temu. Nadal musisz umownie go wspierać, a oni odmawiają aktualizacji, dopóki nie upewnisz się, że błąd został naprawiony w nowym kodzie i są wystarczająco duże, abyś mógł tańczyć. Istnieją dwa równoległe wszechświaty:

• We wszechświecie, w którym nie masz bibliotek, łańcucha narzędzi i budowania skryptów w kontroli źródła, a nie masz solidnego systemu CM ... Możesz sprawdzić odpowiednią wersję kodu, ale daje to próbujesz budować różnego rodzaju błędy. Zobaczmy, czy zaktualizowaliśmy narzędzia w maju? Nie, to były biblioteki. Ok, wróć do starych bibliotek - poczekaj, czy były dwie aktualizacje? Ach tak, to wygląda trochę lepiej. Ale teraz ta dziwna awaria linkera wygląda znajomo. Och, to dlatego, że stare biblioteki nie działały z nowym łańcuchem narzędzi, dlatego musieliśmy zaktualizować, prawda? (Oszczędzę ci cierpienia z resztą wysiłku. Zajmuje to dwa tygodnie i na końcu nikt nie jest szczęśliwy, nie ty, nie zarząd, nie klient.)

• We wszechświecie, w którym wszystko jest pod kontrolą źródła, sprawdzasz znacznik 2.2.6, masz gotową wersję do debugowania za około godzinę, spędzasz dzień lub dwa, odtwarzając „błąd VIP”, wyśledź przyczynę, napraw ją bieżące wydanie i przekonaj klienta do aktualizacji. Stresujące, ale nie tak złe jak ten inny wszechświat, w którym twoja linia włosów jest o 3 cm wyższa.

Powiedziawszy to, możesz posunąć się za daleko:

• Powinieneś mieć standardową instalację systemu operacyjnego, której „złotą kopię”. Udokumentuj to, prawdopodobnie w pliku README, który jest pod kontrolą źródła, aby przyszłe generacje wiedziały, że wersja 2.2.6 i wcześniejsze zbudowały tylko na RHEL 5.3 i 2.3.0, a później tylko na Ubuntu 11.04. Jeśli łatwiej ci zarządzać łańcuchem narzędzi w ten sposób, skorzystaj z niego, po prostu upewnij się, że jest to niezawodny system.
• Dokumentacja projektu jest uciążliwa w utrzymaniu w systemie kontroli źródła. Dokumenty projektu zawsze wyprzedzają sam kod i nierzadko pracujemy nad dokumentacją dla następnej wersji podczas pracy nad kodem dla bieżącej wersji. Zwłaszcza jeśli wszystkie dokumenty projektu są dokumentami binarnymi, których nie można różnicować ani scalać.
• Jeśli masz system kontrolujący wersje wszystkich elementów używanych w kompilacji, użyj go ! Upewnij się, że synchronizacja w całym zespole jest łatwa, aby wszyscy (w tym maszyna do budowania) korzystali z tego samego zestawu narzędzi. (Mam na myśli systemy takie jak pbuilder Debiana i odpowiedzialne korzystanie z virtualenv Pythona.)

Jedyne rzeczy, których nie poddaję kontroli źródła, to pliki, które można łatwo zregenerować lub są one specyficzne dla programistów. Oznacza to pliki wykonywalne i pliki binarne składające się z kodu źródłowego, dokumentacji generowanej z plików do odczytu / analizy pod kontrolą źródła oraz plików specyficznych dla IDE. Cała reszta przechodzi do kontroli wersji i jest odpowiednio zarządzana.

Przykładem użycia kontroli źródła jest: Co jeśli wszystkie nasze maszyny programistów i wszystkie nasze maszyny wdrożeniowe zostały uderzone przez meteoryt? Chcesz, aby odzyskiwanie było jak najbliżej realizacji transakcji i zbudowania, jak to możliwe. (Jeśli to zbyt głupie, możesz przejść do „zatrudnić nowego programistę”).

Innymi słowy, wszystko oprócz systemu operacyjnego, aplikacji i narzędzi powinno znajdować się w VCS, aw systemach wbudowanych, w których może istnieć zależność od konkretnej wersji binarnej narzędzia, widziałem też narzędzia przechowywane w VCS!

Niekompletna kontrola źródła jest jednym z najczęstszych zagrożeń, jakie widzę podczas konsultacji - istnieje wiele rodzajów tarcia związanych z pozyskaniem nowego programisty lub konfiguracją nowej maszyny. Wraz z koncepcjami ciągłej integracji i ciągłego dostarczania powinieneś mieć poczucie „ciągłego rozwoju” - czy osoba z branży IT może skonfigurować nową maszynę do programowania lub wdrażania zasadniczo automatycznie, aby deweloper mógł spojrzeć na kod przed jego zakończeniem ich pierwsza filiżanka kawy?

Wszystko, co przyczynia się do projektu i dla którego chcesz śledzić zmiany.

Wyjątki mogą obejmować duże binarne obiekty blob, takie jak obrazy, jeśli używasz scm, który nie obsługuje bardzo dobrze danych binarnych.

Drupal używa git, więc użyję terminologii git. Używałbym subrepos dla każdego modułu, aby móc pobrać aktualizacje modułu z oficjalnych repozytoriów drupala, jednocześnie zachowując strukturę poszczególnych wdrożeń. W ten sposób zyskujesz korzyści ze skryptowalności, nie tracąc korzyści z posiadania wszystkiego pod kontrolą źródła.

Wszystko powinno być pod kontrolą źródła, z wyjątkiem:

• Pliki konfiguracyjne, jeśli zawierają opcje konfiguracji różne dla każdego programisty i / lub każdego środowiska (programowanie, testowanie, produkcja)
• Pliki pamięci podręcznej, jeśli korzystasz z buforowania systemu plików
• Pliki dziennika, jeśli logujesz się do plików tekstowych
• Wszystko, co lubi pliki pamięci podręcznej i pliki dziennika, jest generowaną treścią
• (Bardzo) Duże pliki binarne, których zmiana jest mało prawdopodobna (niektóre systemy kontroli wersji ich nie lubią, ale jeśli używasz hg lub git, nie mają nic przeciwko)

Pomyśl o tym w ten sposób: każdy nowy członek zespołu powinien mieć możliwość pobrania kopii roboczej projektu (bez elementów konfiguracji).

I nie zapomnij poddać zmian schematu bazy danych (proste zrzuty SQL każdej zmiany schematu) również kontroli wersji. Możesz dołączyć dokumentację użytkownika i interfejsu API, jeśli ma to sens dla projektu.

@maple_shaft podnosi ważną kwestię w mojej pierwszej wypowiedzi dotyczącej plików konfiguracyjnych środowiska w komentarzach. Chciałbym wyjaśnić, że moją odpowiedzią jest specyfika pytania, które dotyczy Drupala lub ogólnych projektów CMS. W takich scenariuszach zazwyczaj masz lokalną i produkcyjną bazę danych, a jedną z opcji konfiguracji środowiska są poświadczenia tych baz danych (i podobne poświadczenia). Wskazane jest, aby NIE były one pod kontrolą źródła, ponieważ spowodowałoby to szereg problemów związanych z bezpieczeństwem.

Jednak w bardziej typowym przepływie pracy programistycznej zgadzam się z maple_shaft, że opcje konfiguracji środowiska powinny być pod kontrolą źródła, aby umożliwić jednoetapowe budowanie i wdrażanie dowolnego środowiska.

Wszystko Twój zautomatyzowane build robi generuje czy nie pójść w kontroli źródła. Wszystko, co nie wymaga modyfikacji podczas kompilacji , podlega kontroli źródła. To takie proste.

Na przykład następujące elementy nie podlegają kontroli źródła:

• wygenerowany kod
• wygenerowane pliki binarne
• wszystko stworzone przez twoją kompilację
• wszystko, co zostało stworzone w czasie wykonywania przez Twoją usługę, proces, aplikację internetową

Co wchodzi w kontrolę źródła:

• wszystko, co tworzy człowiek
• wszystko, co jest tworzone przez inną osobę lub grupę (np. biblioteka wewnętrzna innej firmy, w której rozproszona jest kontrola źródła lub pliki binarne projektu typu open source).
• skrypty i inne źródła, które tworzą takie rzeczy, jak baza danych (tj. jak odtworzyłbyś bazę danych, jeśli wszystkie bazy danych mają status AWOL).

Te praktyczne zasady opierają się na założeniu, że wszystko, co jest pod kontrolą źródła, może zostać zmodyfikowane przez człowieka i może zająć komuś cenny czas na zrozumienie, dlaczego tak jest.

Wszystko, co musisz pracować i które możesz zmienić, musi być w taki czy inny sposób wersjonowane. Ale rzadko jest potrzeba, aby śledzić to dwa niezależne systemy.

Wszystko, co zostało wygenerowane w niezawodny sposób, zwykle może być dołączone do wersji źródłowej - dlatego nie musi być śledzone niezależnie: wygenerowane źródło, pliki binarne, które nie są przekazywane z systemu do innego itp.

Twórz dzienniki i inne rzeczy, o które prawdopodobnie nikogo nie obchodzi (ale nigdy nie wiesz na pewno), najlepiej najlepiej śledzić przez tego, kto je generuje: jenkins itp.

Twórz produkty przekazywane z jednego systemu do drugiego, które trzeba śledzić, ale repozytorium maven to dobry sposób na zrobienie tego - nie potrzebujesz poziomu kontroli zapewnianego przez kontrolę źródła. Produkty dostarczane są często w tej samej kategorii.

Cokolwiek pozostaje (i na tym etapie powinno być niewiele więcej niż pliki źródłowe i konfiguracja serwera kompilacji), przechodzi pod kontrolę źródła.

Moja odpowiedź jest dość prosta: nie binaria. W konsekwencji prawie wszystko inne.

(Zdecydowanie nie kopie zapasowe bazy danych, migracje schematów lub dane użytkownika.)

Kontrola źródła to mechanizm śledzenia zmian. Użyj go, jeśli chcesz wiedzieć, kto i co zmienił.

Kontrola źródła nie jest darmowa. Zwiększa złożoność przepływu pracy i wymaga szkolenia dla nowych kolegów. Zważyć korzyści względem kosztów.

Na przykład kontrolowanie baz danych może być trudne. Kiedyś mieliśmy system, w którym trzeba było ręcznie zapisywać definicje w pliku tekstowym, a następnie dodawać je do kontroli źródła. Zajęło to dużo czasu i było zawodne. Ponieważ było to niewiarygodne, nie można było użyć go do skonfigurowania nowej bazy danych lub sprawdzenia, o której godzinie dokonano zmiany. Ale utrzymywaliśmy to przez lata, marnując niezliczone godziny, ponieważ nasz kierownik uważał, że „wszystko powinno być pod kontrolą źródła”.

Kontrola źródła nie jest magią. Wypróbuj, ale porzuć go, jeśli nie doda wystarczającej wartości, aby zrównoważyć koszt.

Rzeczy, których nie poddałbym kontroli źródła:

• Tajne klucze i hasła
• SDK, mimo że jest to ten sam katalog i jeśli zrobię łatkę do SDK, to powinien zrobić z niego inny projekt, ponieważ byłby on dla frameworka zamiast dla aplikacji
• Biblioteki innych firm, takie jak. Resztki z migracji, kopie zapasowe, skompilowany kod, kod na innej licencji (być może)

Więc nie robię hg addremovena przykład od czasu tworzenia nowego klonu co jakiś czas, gdy aktualizowany jest zestaw SDK. To również sprawia, że ​​wykonuję pełną kopię zapasową za każdym razem, gdy aktualizuje się SDk i sprawdzam, czy nowa wersja sklonowana z repozytorium działa prawidłowo.

Gorąco polecam ci następującą książkę, która dotyczy twoich obaw:

Ciągła dostawa: niezawodne wydania oprogramowania poprzez automatyzację kompilacji, testowania i wdrażania . W szczególności rozdział 2 dotyczy elementów, które należy umieścić w kontroli źródła, co, jak powiedzieli całkiem sporo osób, jest praktycznie wszystkim, z wyjątkiem głównie generowanej zawartości w wyniku kompilacji.

Nie zgadzam się z jedną częścią zaakceptowanej odpowiedzi udzielonej przez @FrustratedWithFormsDesigner mniej, ponieważ opowiada się on za niewprowadzaniem kontroli wersji narzędzi niezbędnych do zbudowania projektu. Gdzieś w kontroli źródła (obok budowanego kodu) powinny znajdować się skrypty budowania projektu i skrypty uruchamiane tylko z wiersza poleceń. Jeśli przez narzędzia, które ma na myśli, IDE i edytorów, nie powinno się wymagać od nich budowania projektu. Są one dobre dla aktywnego / szybkiego programowania dla programistów, a konfiguracja tego typu środowiska może być również skryptowana lub pobrana z innej sekcji SCM lub z pewnego rodzaju binarnego serwera zarządzania, a konfiguracja takich IDE powinna być jak najbardziej zautomatyzowana.

Nie zgadzam się również z tym, co stwierdza @Yannis Rizos na temat umieszczania konfiguracji dla środowisk w kontroli źródła. Powodem jest to, że powinieneś być w stanie zrekonstruować dowolne środowisko, używając tylko skryptów i nie jest możliwe do zarządzania bez posiadania ustawień konfiguracji w kontroli źródła. Nie ma również historii ewolucji konfiguracji dla różnych środowisk bez umieszczenia tych informacji w kontroli źródła. Teraz ustawienia środowiska produkcyjnego mogą być poufne lub firmy mogą nie chcieć umieszczać ich w kontroli wersji, więc drugą opcją jest nadal umieszczanie ich w kontroli wersji, aby miały historię i dać temu repozytorium ograniczony dostęp.

Zachowaj cały kod pod kontrolą wersji oraz wszystkie konfiguracje i dane użytkownika. Aby być specyficznym dla drupala, musisz wszystko kontrolować kontrolę wersji oprócz plików i ustawień. Php