Найкраща стратегія розгалуження при постійній інтеграції?


100

Яку найкращу стратегію розгалуження слід використовувати, коли ви хочете робити безперервну інтеграцію?

  1. Випуск Розгалуження: розвивайтеся на магістралі, зберігайте гілку для кожного випуску.
  2. Розгалуження функцій: розробляйте кожну функцію в окрему гілку, зливайтеся лише один раз стабільно.

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


2
Побічна примітка: дехто може стверджувати, що навіть у міру застосування нових функцій все завжди має бути стабільним. З іншого боку, це може бути дещо ідеалістичним.
Кіт Пінсон

Відповіді:


21

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

  • Я пам’ятаю, як Марк Шаттлворт пропонував модель про збереження основної гілки первозданною, виходячи за рамки звичайних ІС. Я розмістив про це тут .
  • Оскільки я знайомий з круїзним контролем, я також веду блоги про галузі завдань та CI тут . Це покрокове підручник, що пояснює, як це зробити за допомогою Plastic SCM .
  • Нарешті, я знайшов деякі теми про КІ (і, можливо, про розгалуження) в книзі Дювальла про КІ також дуже цікавою .

Сподіваюся, ви знайдете посилання цікавими.


Ми додали підтримку Bamboo для того, щоб робити відділення за завданням codicesoftware.blogspot.com/2012/02/… , і, схоже, їх найновіша версія зробить це спочатку з кількома елементами управління версіями, включаючи dvcs.
пабло

20

Відповідь залежить від розміру вашої команди та якості вашого джерела управління та вміння правильно об'єднати складні набори змін. Наприклад, повне управління джерелами гілок, наприклад CVS або SVN, може бути важким, і вам може бути краще з першою моделлю, тоді як якщо ви використовуєте більш складну систему, як IBM ClearCase, і з більшим розміром команди, ви можете бути краще з другою модель або комбінація двох.

Я особисто розділив модель функціональної гілки, де кожна основна особливість розробляється на окремій гілці, із підгалузями завдань для кожної зміни, виконаної окремим розробником. По мірі стабілізації функцій вони об'єднуються в багажник, який ви зберігаєте достатньо стабільний і проходить усі регресійні тести в будь-який час. Коли ви підходите до кінця циклу випуску та з’єднуються всі гілки функцій, ви стабілізуєте і гілку гілки системи випуску, на якій ви робите лише виправлення помилок стабільності та необхідні опори, тоді як магістраль використовується для розробки наступного випуску, і ви знову відділення для нових функціональних гілок. І так далі.

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

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

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

Наведена вище модель не має особливого сенсу для команд, що не досягли 50 років, та системи управління джерелами без розріджених гілок та належної можливості злиття, таких як CVS або SVN, що просто зробило б цілу модель кошмаром для налаштування, управління та інтеграції.


5
Я не впевнений, чи погоджуюсь ви, що те, що ви описуєте, не має сенсу для команд до 50 розробників. Я бачу вигоду і для значно менших команд. +1
Aardvark

2
Звичайно, є переваги для команд будь-якого розміру. Питання полягає в тому, який розмір переваг команди перевищує витрати, пов'язані з важким процесом.
Іржі Клуда

Це схоже на модель GitFlow та / або GitHubFlow. Я не думаю, що ці моделі сприяють постійній інтеграції (CI). На мою думку, розвиток на основі магістралей - це суттєве вдосконалення цих моделей.
Яні

Ви можете бачити, що цей коментар насправді є попереднім початком випуску git flow. Не зовсім впевнений, що ви маєте на увазі під «кращим». Я підтримував команди 1, 5, 25, 150, 1000 та 20 000 розробників, які працювали над проектами, які були інтегровані певною мірою. Вимоги різняться, і "краще" дуже відносний термін. Чи потрібно вам коли-небудь підтримувати кодекс? Виправлення безпеки? Якщо ні, то ваше життя просте. SaaS - це прямий результат обмежень, накладених розробкою на основі магістралей. Функційні прапори так само складні, як і гілки зображень. За винятком випадків, коли ви дізнаєтесь від клієнтів лише тоді, коли перестановка їх порушується.
Jiri Klouda

9

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

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

Як додатковий бонус, існує певний рівень інтеграційного тестування, який надходить автоматично.


Крім того, ви все ще розгалужуєте та тегуєте для кожного головного випуску? Або просто тег?
KingNestor

1
Він добре працює з CI до тих пір, поки функції гілок об'єднані в магістраль з деякою дисципліною, щоб не мати зламаних складок. Я роблю гілку та теги для кожного випуску виробництва, який буде використовуватися лише для виправлення помилок. Це можна негайно об'єднати в стійкий багажник.
Аднан

@king Я б сказав, що, ймовірно, залежить від того, що ви називаєте основним випуском, але в будь-якому випадку ви можете теги і відключити пізніше, коли вам це потрібно (на основі тегу :))
eglasius

5

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

http://martinfowler.com/articles/continuousIntegration.html#EveryoneCommitsToTheMainlineEveryDay

EDIT

Я читав цю книгу про КІ, і автори припускають, що розгалуження шляхом випуску є їх бажаною стратегією розгалуження. Я повинен погодитися. Розгалуження за властивостями для мене не має сенсу при використанні CI.

Я спробую пояснити, чому я так думаю. Скажімо, що три розробники беруть гілку для роботи над функцією. Кожна функція займе кілька днів або тижнів. Щоб забезпечити постійну інтеграцію колективу, вони повинні брати участь у головній галузі принаймні один раз на день. Як тільки вони починають це робити, вони втрачають перевагу у створенні функції. Їх зміни вже не відокремлюються від усіх змін інших розробників. Зважаючи на це, чому взагалі турбуватися створювати функції гілок?

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

ІНШИЙ РЕДАКТ

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

http://jamesmckay.net/2011/07/why-does-martin-fowler-not-understand-feature-branches/


цікаво, більше не можу знайти цю публікацію
Jirong Hu

5

Гілки випуску дуже корисні і навіть абсолютно необхідні, якщо вам потрібно підтримувати кілька версій програми.

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

Тож для мене використання обох механізмів - це дуже гарна стратегія.

Цікава посилання з Книги СВН .


4

Нещодавно мені сподобалась ця модель при використанні git. Хоча ваше запитання позначено "svn", ви все одно зможете ним скористатися.

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


2

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

Сказавши, що ...

  • немає причин, чому CI не можна було використовувати в обох описаних вами підходах
  • ці підходи працюють досить добре в поєднанні
  • жоден з двох не працює «краще», ніж інші
  • CI має тотальний сенс при нестабільному магістралі

На все це відповіли в четвертому запитанні на сторінці, на якій ви взяли діаграми: http://blogs.collab.net/subversion/2007/11/branching-strat/


2

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

Для найкращого вступу до основної моделі читайте це: https://web.archive.org/web/20120304070315/http://oreilly.com/catalog/practicalperforce/chapter/ch07.pdf

Прочитайте посилання. Отримавши основи, прочитайте наступну статтю поважного Генріка Кніберга. Це допоможе вам зв’язати основну модель з постійною інтеграцією.

http://www.infoq.com/articles/agile-version-control


Глава O'Reilly більше не доступна
Jason S

1

Коли ми запустили свою команду, ми успадкували стратегію, що базується на випуску, від постачальника, який спочатку розробив систему, над якою ми збиралися завідувати. Він працював до того моменту, коли наші клієнти вимагали, щоб кілька розроблених функцій не були включені до випуску (fyi ~ 250k рядків коду, ~ 2500 файлів, Scrum з XP SDLC).

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

Остаточний "цвях у труні" чистих стратегій СК прийшов, коли ми вирішили, що у нас повинен бути 1. стабільний магістраль і 2. Виробництво повинно містити перевірені ST, UAT та регресію BINARIES (не лише джерело - думаю, CC.)

Це приводить нас до розробки стратегії, яка є гібридом між стратегіями на основі функцій та SC-версій.

Отже, у нас є багажник. Кожен спринт ми розгалужуємо гілку спринту (для негиблих людей - спринт - це лише затримані в часі зусилля з розробки із змінним результатом на основі складності.) З гілки спринту ми створюємо особливі гілки і паралельний розвиток починається в них. Після того, як функції будуть завершені та перевірені системою, і ми отримаємо намір розгорнути їх, вони об’єднуються у гілку спринту - деякі можуть плавати через декілька спринтів, як правило, більш складні. Після того, як спринт наближається до кінця і функції завершені ... ми "перейменовуємо" гілку спринту на "регресію" (це дозволяє CruiseControl забрати її без будь-якої реконфігурації), а потім розпочнеться тест регресії / інтеграції на вбудованому комп'ютері EAR. Коли це все зроблено, він йде у виробництво.

Коротше кажучи, для розробки, тестування системи та функціональності UAT використовуються галузеві функції. Гілка спринту (справді гілка випуску) використовується для вибіркового об'єднання функцій на вимогу та інтеграції-тесту.

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


Я не обов'язково згоден з висновками, але дякую за обговорення вашого процесу. Не існує рішення одного розміру.
РаулРубін

0

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

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

ps Де ви взяли ці посилання на підхід? - не відчуває, що ці графіки представляють усі варіанти

Оновлення 1: Розгортання того, чому я сказав, що це не золоте правило. В основному для відносно невеликих команд я вважав, що найкраще використовувати підхід, який є сумішшю. Функціональні гілки створюються, якщо це щось довге, і частина команди продовжить додавати менші функції.


У ньому є ще кілька. Але я відчуваю, що розгалуження функцій та розгалуження випусків - це 2 найпоширеніші.
KingNestor

0

Дейв Фарлі , автор програми " Постійна доставка" , назвав розробку на основі магістральних шляхів (TBD) як наріжний камінь безперервної інтеграції (CI) та безперервної доставки (CD). Він каже:

Будь-яка форма розгалуження антитетична постійній інтеграції.

Він також каже:

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

На основі магістральних розробок (TBD) - це практика інтегрувати зміни коду в магістраль (він же, головний, основний) принаймні один раз на день - бажано кілька разів на день. Постійна інтеграція (CI) є подібною практикою, за винятком того, що вона також включає перевірку змін коду за допомогою автоматизованих тестів. Найкраща стратегія розгалуження для цього - працювати безпосередньо над магістраллю та виконувати перегляд коду за допомогою програми « Пара-програмування» . Якщо з якихось причин ви не можете паритись, або ви просто дуже хочете розгалужуватися, переконайтеся, що ваші гілки короткочасні (менше ніж на день).

Я працюю над Trunk, "майстром" у своїх репортажах про GIT. Я зобов'язуюсь опанувати локально і, коли я підключуюся до мережі, негайно натискаю на свій центральний репо-майстер, де працює CI. Це воно!

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

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


Дейв Фарлі та Джез Хамбл просто помиляються у своїй позиції щодо розгалуження. Причиною цього є те, що воно кодує важливе припущення "вам ніколи не доведеться маніпулювати кодом на рівні функції, і якщо, тоді це нормально, щоб це було дорогою операцією", і вони базують свою оцінку на іншому припущенні "злиття занадто дороге з автоматизованим злиття майже неможливо в масштабі ". Якщо ці два припущення не відповідають дійсності, якщо ви живете в світі, де злиття дешеве, але вам потрібно маніпулювати кодом на рівні функцій заднього порту та виправлень безпеки, тоді їхні твердження руйнуються. Це рідкісний випадок тхо.
Jiri Klouda

Деяким компаніям також потрібно перенести функції вперед до майбутніх версій, після того, як ці функції потрапили в дорожні блоки та впроваджують реліз. Іноді є можливість залишити код, як у продуктах SaaS, але якщо код буде випущений клієнтам, він може не бути варіантом, оскільки його можуть аналізувати конкуренти. Стільки коду в ці дні не компілюється, і навіть якщо він є, визначення / функції прапорів у коді знаходяться на тому ж рівні складності, що і гілки.
Jiri Klouda

-3

Я думаю, що інструменти, які ви використовуєте, є тут великим фактором.

  • Якщо ви використовуєте підрив, дотримуйтесь варіант 1 і звільніть від гілок.
  • Якщо ви використовуєте GIT, варіант 2 буде добре працювати для вас.

2
Особливості розгалуження можна легко досягти за допомогою будь-якої SCM
hdost
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.