Які моделі розгалуження Git працюють для вас?


378

В даний час наша компанія використовує просту модель розгалуження магістралі / випуску / виправлень і радить поради щодо того, які моделі розгалуження найкраще підходять для вашої компанії або процесу розвитку.

  1. Моделі робочих процесів / розгалуження

    Нижче наведено три основні описи цього, що я бачив, але вони частково суперечать один одному або не заходять досить далеко, щоб розібратися з подальшими проблемами, з якими ми стикалися (як описано нижче). Таким чином, наша команда поки що за замовчуванням не настільки великі рішення. Ви робите щось краще?

  2. Злиття та повторне звільнення (заплутане по відношенню до послідовної історії)

    Потрібно pull --rebaseабо чекати, коли з’єднатись з основною лінією, поки ваше завдання не буде закінчено? Особисто я схиляюся до злиття, оскільки це зберігає візуальну ілюстрацію того, на якій основі було розпочато і закінчено завдання, і я навіть віддаю перевагу merge --no-ffдля цієї мети. Однак він має й інші недоліки. Також багато хто не усвідомив корисну властивість злиття - те, що воно не є комутативним (об'єднання гілки теми в головний не означає злиття головного в тему гілки).

  3. Я шукаю природний робочий процес

    Іноді помилки трапляються, оскільки наші процедури не охоплюють конкретну ситуацію простими правилами. Наприклад, виправлення, необхідне для попередніх випусків, звичайно, має бути засноване на достатній низці, щоб можна було об'єднати вгору за всіма гілками (чи достатньо зрозумілим є використання цих термінів?). Однак трапляється, що виправлення перетворює його на майстра до того, як розробник зрозуміє, що його слід було розмістити далі за течією, і якщо це вже натиснуто (що ще гірше, об'єднане чи щось на його основі), то залишилася опція - вибирання вишні, з пов'язані з цим небезпеки. Які прості правила типу таких ви використовуєте?Також в це включено незграбність однієї тематичної гілки, обов'язково виключаючи інші галузі тем (припускаючи, що вони розгалужені із загальної базової лінії). Розробники не хочуть закінчити функцію, щоб почати ще одне відчуття, як код, який вони тільки що написали, вже не існує

  4. Як уникнути створення конфліктів злиття (через вишню)?

    Як виглядає вірний спосіб створити конфлікт злиття - це вишня між гілками, їх більше ніколи не можна об’єднати? Чи застосувати одне і те ж зобов’язання у зворотному порядку (як це зробити?) В будь-якій галузі, можливо, вирішити цю ситуацію? Це одна з причин, що я не наважуюся наполягати на значному об'єднанні робочого процесу.

  5. Як розкласти на актуальні гілки?

    Ми розуміємо, що було б чудово зібрати готову інтеграцію з тематичних галузей, але часто робота наших розробників не є чітко визначеною (іноді такою простою, як "розколювання"), і якщо якийсь код уже перейшов у "різне" тему, її не можна вивозити звідти знову, відповідно до вищезазначеного питання? Як ви працюєте з визначенням / затвердженням / закінченням / випуском галузей тем?

  6. Правильні процедури, такі як перегляд коду та його закінчення , звичайно, були б чудовими.

    Але ми просто не можемо тримати речі недостатньо розметаними для управління цим - будь-які пропозиції? інтеграційні галузі, ілюстрації?

Нижче наведено перелік пов’язаних питань:

Також перевірте, що пише Plastic SCM щодо розробки завдань , і якщо Plastic не є вашим вибором, вивчіть модель розгалуження nvie та його підтримуючі сценарії .


2
Ага, дякую, справді так є ... Я насправді прочитав більшість цього ... речі :-). Мені відоме щось - не погоджуватися на посереднє рішення, а продовжувати пошук ідеального. Часто це є помилкою, але в цьому випадку дуже багато під загрозою, і рішення, які є під рукою, є занадто безладним або поганим, що мені потрібно продовжувати шукати. Тому я вирішив перерахувати всі проблеми, які у мене є.
HiQ CJ

Пластиковий блог SCM кинув їхню думку на дискусію, це, принаймні, проникливо: codicesoftware.blogspot.com/2010/08/…
HiQ CJ

1
Ви повинні бути обережними при використанні "merge --no-ff", перевірте це на деякі застереження sandofsky.com/blog/git-workflow.html
Doppelganger

1
@Doppelganger Мені буде цікаво, як конкретно --no-ff нібито сприяє проблемі, описаній у посиланні, яке ви розміщуєте. Для мене описаною проблемою є збій бісектії з контрольною точкою, а також неспроможність git вини допомогти у цьому випадку - але я не бачу, як "--no-ff" щось змінює, на відміну від того, щоб не використовувати його. Автор скаржиться, що злиття з --no-ff не робить файл модифікованим - все ж без нього файл також не був би змінений, ви також бачили б лише старі комісії у своїй історії, правда?
кодування

Інша модель розгалуження: модель кактуса barro.github.io/2016/02/… , основна модель bitsnbites.eu/a-stable-mainline-branching-model-for-git . Ця модель розгалуження пропонує інший підхід, ніж gitflow.
Матьє Момаль

Відповіді:


90

Найбільш тривожна функція, яку нові розробники повинні розуміти на DVCS, - це процес публікації :

  • Ви можете імпортувати (отримати / витягнути) все необхідне віддалене репо
  • ви можете опублікувати (натиснути) на будь-яке (голое) репо, яке ви хочете

Відтак ви можете дотримуватися кількох правил, щоб полегшити свої запитання:

  • перезавантажте гілку лише у тому випадку, якщо вона не була натиснута (не натиснута з моменту останнього відновлення)
  • натискати лише на голий репо (обов'язковий з Git1.7)
  • дотримуйтесь порад Лінуса щодо перезавантаження та злиття

Зараз:

Моделі робочих процесів / розгалуження :

кожен робочий процес є для того, щоб підтримувати процес управління випуском , який підходить для кожного проекту.
Що я можу додати до робочого процесу, який ви згадуєте, це: кожен розробник не повинен створювати функціональну гілку, а лише "поточну гілку", оскільки правда полягає в тому, що розробник часто не знає, що саме буде виробляти його / її гілка: одна особливість, кілька (тому що вона виявилася занадто складною особливістю), жодна (тому що не готова вчасно до випуску), інша функція (тому що оригінальна "перетворилася"), ...

Тільки "інтегратор" повинен створити офіційні гілки функцій на "центральному" репо, які потім розробники можуть отримати заново / об'єднати ту частину своєї роботи, яка відповідає цій функції.

Злиття та перезавантаження (заплутане проти послідовної історії) :

Мені подобається моя відповідь, яку ви згадуєте (" Опис робочого процесу для використання git для внутрішньої роботи ")

Я шукаю природний робочий процес :

що стосується виправлень, це може допомогти пов’язати кожне виправлення з білетом відслідковування помилок, що допоможе розробнику запам'ятати, де (тобто, на якій гілці, тобто спеціалізованій гілці "для виправлень"), він / вона повинен здійснити такі зміни.
Тоді гачки можуть допомогти захистити центральний репо від протиштовхувань від неперевірених виправлень помилок або від гілок, з яких не слід натискати. (тут немає жодного конкретного рішення, все це потрібно адаптувати до вашого оточення)

Як уникнути створення конфліктів злиття (через вишню)?

Як заявив Якуб Нарубський у своїй відповіді , збирання вишні має бути зарезервоване для рідкісних ситуацій, коли це потрібно.
Якщо ваша установка передбачає багато збирання вишні (тобто "це не рідкість"), то щось вимкнено.

Чи застосував би ту саму комісію до відшкодування (як це зробити?)

git revert слід подбати про це, але це не ідеально.

Як розкласти на актуальні гілки?

До тих пір, поки галузь ще не просунута скрізь, розробник повинен реорганізувати свою історію комісій (як тільки він / вона нарешті побачить, що розвиток набуває більш чіткої та стабільної форми) у:

  • декілька гілок, якщо потрібно (одна за чіткою визначеною ознакою)
  • узгоджений набір комісій у межах однієї гілки (див. Обрізання Git Checkins )

Правильні процедури, такі як перегляд коду та його закінчення?

Інтеграційні гілки (у спеціалізованій інтеграції) repo можуть допомогти розробнику:

  • відновити його / її розвиток над тією гілкою віддаленої інтеграції (pull --rebase)
  • вирішувати локально
  • підштовхнути розвиток до цього репо
  • зверніться до інтегратора, що не призводить до безладу;)

@UncleCJ: як ви бачите, це не зовсім остаточна відповідь на ваше "остаточне запитання";)
VonC

Я розумію, і у мене є чудове відчуття іронії, це нормально ;-)
HiQ CJ

3
@UncleCJ вище за течією - це те, куди ви регулярно виходите, з мого посту, куди б не закінчувалися всі зобов'язання (версія версії або магістраль у SVN-мові). Нижче за течією - всі під ними. Відправка матеріалів за течією - це процес її об'єднання в репо-версію випуску (як linux-2.6), а вниз за потоком - це зміни, які виходять звідти, або з вашого сховища, як каже менеджер розробки такої функції для ваших міньйонів ... I середня команда.

2
@UncleCJ: "Я все ще вважаю складним обрізати ваші чеки, щоб досягти суворо послідовної історії": простіше з Git1.7 і його rebase --interactive --autosquashпереміщенням буде автоматично переходити все з того ж початку іншого повідомлення про фіксацію. Якщо в цих комісіях використовується номер квитка (наприклад), навіть якщо ті виправлення, пов’язані з цим квитком, не були зроблені послідовно в той час, автозаправка дозволяє швидко переупорядкувати ці комісії.
VonC

1
@UncleCJ: "суворо послідовна історія (це потрібно чи ні ?!)": не завжди потрібна, але це допомагає відслідковувати функціональні залежності ( stackoverflow.com/questions/881092/… ) та семантичні конфлікти ( stackoverflow.com/questions / 2514502 /… )
VonC

21

Я думаю, і я можу помилятися, що одне з речей, яке найбільше не зрозуміло щодо git, - це його поширений характер. Це робить дуже різним говорити про підрив у способах роботи, хоча ви можете імітувати поведінку SVN, якщо хочете. Проблема полягає в майже будь-якому робочому процесі, що є великим, але також оманливим.

Якщо я розумію розробку ядра (я зупинюся саме на цьому) правильно, у кожного є власне сховище git для розробки ядра. Існує одне сховище, linux-2.6.git, за яким доглядає Torvalds, яке виконує функції сховища релізів. Люди клонують звідси, якщо хочуть розпочати розробку функції проти гілки "звільнення".

Інші сховища роблять певну розробку. Ідея полягає в тому, щоб клонуватись з linux-2.6, розгалужувати стільки разів, скільки вам подобається, до тих пір, поки ви не отримаєте робочу "нову" функцію. Потім, коли це буде готово, ви можете зробити його доступним для того, хто вважається довіреним, хто витягне цю гілку з вашого сховища у своє та об'єднає її в основний потік. У ядрі Linux це відбувається на декількох рівнях (довірених лейтенантів), поки воно не досягне linux-2.6.git, після чого воно стає «ядром».

Тепер ось де це стає заплутаним. Імена філій взагалі не повинні бути узгодженими у сховищах. Тож я можу git pull origin master:vanilla-codeотримати філію від originгосподаря у філії мого сховища під назвою vanilla-code. За умови, що я знаю, що відбувається, це насправді не має значення - воно розподіляється в тому сенсі, що всі сховища є одноранговими, а не просто спільними для декількох комп'ютерів, таких як SVN.

Отже, маючи на увазі все це:

  1. Я думаю, що кожен програміст залежить від їх розгалуження. Все, що вам потрібно, - це центральне сховище для управління випусками тощо head. Випуски можуть бути тегами чи гілками, а виправлення, ймовірно, самі по собі гілки. Насправді, я б, мабуть, робив випуски як гілки, щоб ви могли продовжувати їх латати.
  2. Я б злився і не переобладнав. Якщо, наприклад, ви берете сховище, клонуєте його, відгалужуєте і робите девіз, то витягніть зі свого, originщо слід, у вашому сховищі, ймовірно, зробіть іншу гілку і об'єднайте останню masterв yourbranchту, щоб хтось інший міг витягнути ваші зміни якнайменше зусиль, можливо. На моєму досвіді, дуже рідко виникає потреба в реконструкції.
  3. Я думаю, що це випадок розуміння того, як працює Git і що він може зробити. Це потребує певного часу і багато хорошого спілкування - я по-справжньому почав розуміти, що відбувається, коли почав використовувати git з іншими розробниками і навіть зараз, деякі речі, в яких я не впевнений.
  4. Конфлікти злиття корисні. Я знаю, я знаю, ви хочете, щоб усе працювало, але факт полягає в зміні коду, і вам потрібно об'єднати результати в те, що працює. Конфлікти злиття насправді просто більше програмування. Я ніколи не знайшов легкого пояснення, що робити з ними, тому ось це: відзначте файли, у яких є конфлікти злиття, перейдіть і змініть їх на те, що вони мають бути, git add .а потім git commit.
  5. Однак це підходить. Як я вже говорив, кожен користувач репозиторію git має власну гру, а назви гілок не повинні бути однаковими . Якщо у вас був сховище сховища, наприклад, ви можете застосувати схему іменування, але це не потрібно для кожного розробника, лише у репо релізі.
  6. Це етап злиття. Ви зливаєтесь у гілки випуску тощо лише тоді, коли вважаєте код переглянутим / проходите тестування якості.

Я сподіваюся, що це допомагає. Я розумію, що VonC щойно розмістив дуже подібне пояснення ... Я не можу набрати досить швидко!

Відредагуйте кілька додаткових думок про те, як використовувати git в комерційних умовах, оскільки це здається актуальним для ОП з коментарів:

  • Репозиторій випусків, ми його назвемо product.git, доступний багатьом старшим програмістам / технічним особам, відповідальним за фактичне догляд за самим продуктом. Вони аналогічні ролі обслуговуючого персоналу в OSS.
  • Ці програмісти, ймовірно, також частково ведуть розробку нових версій, тому вони також можуть кодувати себе та підтримувати сховища varios. Вони можуть керувати сховищами для постановки дійсно нових функцій, а також можуть мати свої сховища.
  • Під ними розміщені програмісти, відповідальні за розробку окремих бітів. Наприклад, хтось може відповідати за роботу інтерфейсу користувача. Тому вони управляють сховищем UI.git.
  • Під ними розміщені власне програмісти, які розробляють функції як свою повну щоденну роботу.

То що ж відбувається? Що ж, усі витягують на початку кожного дня з "початкового" джерела, тобто репозиторію релізів (який, ймовірно, також містить найновіший матеріал із розробки попередніх днів). Усі роблять це безпосередньо. Це піде на гілку у їх сховищі, яку, ймовірно, називають "майстер" або, можливо, якщо ви мене називали "останньою". Потім програміст виконає певну роботу. Ця робота може бути те, в чому вони не впевнені, тому вони роблять гілку, виконують роботу. Якщо це не працює, вони можуть видалити гілку та повернутися назад. Якщо це станеться, їм доведеться об'єднатись в основну галузь, над якою зараз працюють. Ми будемо говорити , що це UI програміст , що працює на latest-uiтак що він git checkout latest-uiслідgit merge abc-ui-mywhizzynewfeature. Потім він каже своєму технічному керівництву (ведучому користувальницького інтерфейсу) ей, я виконав таке завдання, витягніть мене. Тож ведучий інтерфейсу робить git pull user-repo lastest-ui:lastest-ui-suchafeature-abc. Потім ведучий користувальницького інтерфейсу дивиться на цю гілку і каже, що насправді це дуже добре, я об'єднаю її ui-latest. Тоді він може сказати всім, хто знаходиться під ним, витягнути з нього на своїх ui-latestгілках або будь-яке ім’я, яке вони їм дали, і тому чорт розібрався в цій функції. Якщо команда задоволена, керівник інтерфейсу може попросити ведучий тестування вийти з нього і об'єднати зміни. Це поширюється на всіх (після зміни), хто тестує його, і надсилає звіти про помилки тощо. Нарешті, якщо функція проходить тестування тощо, один із найвищих технічних підручників може об'єднати її у поточну робочу копію програми, в який момент всі зміни потім поширюються назад вниз. І так далі.

Це не "традиційний" спосіб роботи, і він призначений для "однорангових", а не для "ієрархічних", як SVN / CVS. По суті, кожен має доступ на доступ, але лише локально. Саме доступ до сховища та сховища, яке ви позначаєте як репортаж випусків, дозволяє використовувати ієрархію.


Дякую за велику відповідь (і голоси), я прочитаю ще пару разів, щоб вилучити з неї корисну інформацію. Однак ми - це компанія, а не комітет з розробки ОС; Давайте подивимось, куди веде ця публікація, я відчуваю хороший імпульс, продовжуйте її надходити!
HiQ CJ

@ VonC Дякую @UncleCJ правда, але ви, я впевнений, мають менеджерів випусків тощо. Усі, хто має доступ до сховища, можуть робити це. Що стосується розвитку, чому б не дати розробникам свободу, в межах розуму, відганятися? Якщо у вас є якийсь протокол узгодження злиття, і ваш центральний сховище (і) буде названо так, як вам подобається, проблеми не виникає. Сказавши це, поширена схема іменування не є поганою ідеєю. Я схильний використовувати ініціали-версія-особливості-підгалузі для особистих гілок та версію для гілок.

@UncleCJ Я додав приклад того, як це може працювати в компанії. По суті, ролі OSS замінені на менеджерів, але ви розумієте. У порівнянні з SVN є додаткова перевага від того, що ваші розробники можуть працювати і в автономному режимі (їм потрібна лише сітка для витягування / натискання), і я думаю, що це полегшує тестування функцій, якщо ви добре їх реалізуєте.

Нічого собі, це насправді чудовий приклад, ми можемо почати використовувати щось подібне для випускного. Я не мав на увазі настільки, що оскільки ми не робимо ОСС, всі мають бути регульовані, ми насправді досить маленька і плоска команда, але ми повинні намагатися ефективно співпрацювати за жорстким графіком, а також навчатись як команда . Ось чому я тут задаю ці дурні питання, щоб пізніше допомогти іншій команді :-). Я також зрозумів від #git, що погано визначений базовий рівень у поєднанні з тиском для скорочення строків руху змушує нас подорожувати на ноги ... повернемося пізніше.
HiQ CJ

Це досить справедливо - я останнім часом був там, саме так я і взяв цей приклад, спробувавши його і не вдавшись багато ... а також адаптуючись до способів роботи деяких проектів OSS. Я здогадуюсь, що це справді великий Ґіґі - це не має значення, як ви відділення і де знаходяться ваші сховища ... Ви можете їх визначити будь-яким способом, який ви хочете, що було для мене справжнім шокером! Але це дозволяє робити якісь цікаві речі. У будь-якому випадку, удачі та веселощів!

9

Модель, яку я використав із хорошими результатами, полягає в наступному:

"Благословенне" репо всіх натискає і тягне в / з, в основному топологія клієнт-сервер.

Немає головної гілки, тому жоден розробник не може висунути будь-який код у "основну лінію".

Усі розробки відбуваються в тематичних галузях. Ми називали простори імен, щоб легко визначити, хто за це відповідає: jn / newFeature або jn / issue-1234

На дошці також існує картографічне відображення 1 на 1 між гілками та картами kanban / scrum.

Щоб випустити гілку, її висувають на благословенне репо, і канбан-карту переміщують до готової для огляду.

Тоді, якщо гілка буде прийнята рецензією, вона є кандидатом на звільнення.

Випуск відбувається, коли набір прийнятих гілок об'єднуються разом і позначаються номером версії.

Натискаючи новий тег на благословенне репо, з’являється нова можлива база для нових функцій.

Щоб уникнути конфліктів злиття, розробники просять оновити (об'єднати) свої невипущені гілки до останнього тегу випуску.


2

Особисто я намагаюся зберігати лише готовий до випуску код у головній галузі.

Коли я працюю над новою функцією або помилкою, я роблю це у відділенні. Я також проводжу блок-тест у галузі. Якщо все виходить добре, тільки тоді я зливаю / перезавантажую назад у головний.

Я також намагаюся використовувати загальні угоди про іменування гілок, такі як:

  • помилка / рекурсивний_лоп
  • помилка / sql_timeout
  • функція / new_layout
  • функція / посилений_пошук
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.