Лучшая стратегия ветвления при непрерывной интеграции?

Ответ 1

Ответ зависит от размера вашей команды и качества вашего исходного элемента управления и возможности правильного сложения сложных наборов изменений. Например, в полнофункциональном управлении источником, например, слиянием CVS или SVN, может быть сложно, и вам может быть лучше с первой моделью, тогда как при использовании более сложной системы, такой как IBM ClearCase, и с большим размером команды вы можете быть лучше со вторым модель или комбинация двух.

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

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

В то же время у вас есть в истории набор веток, где вы можете предоставить backports, поддержку и исправления для ваших клиентов, которые по какой-либо причине остаются на предыдущих версиях вашего продукта или даже самой последней выпущенной версии. Как и в случае с багажником, вы не настраиваете непрерывную интеграцию на ветвях выпуска, они тщательно интегрируются при передаче всех регрессионных тестов и другого контроля качества выпуска.

Если по какой-то причине две функции зависят друг от друга и необходимы изменения, сделанные друг для друга, вы можете подумать либо о том, чтобы либо развиваться как в одной ветки функции, либо требовать, чтобы функции регулярно сливали стабильные части кода в магистраль, а затем обновить изменения с туловища, чтобы обменять код между ветвями. Или, если вам нужно изолировать эти две функции от других, вы можете создать общую ветку, от которой вы введете эти ветки функций и которые вы можете использовать для обмена кодом между функциями.

Вышеупомянутая модель не имеет особого смысла в командах до 50 разработчиков и системы управления версиями без редких веток и надлежащей возможности слияния, таких как CVS или SVN, что просто сделает всю эту модель кошмаром для настройки, управления и интеграции.

Ответ 2

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

• Я помню Марка Шаттлворта, предложившего модель о том, чтобы сохранить основную ветку в чистом виде, выходя за рамки обычного CI. Я опубликовал об этом здесь.
• Поскольку я знаком с Cruise Control, я также написал о ветвях задач и CI здесь. Это шаг за шагом учебник, объясняющий, как это сделать с помощью Пластиковый SCM.
• Наконец, я нашел некоторые темы о CI (и, возможно, о разветвлении) в книге Дюваля на CI очень интересной.

Надеюсь, вы найдете интересные ссылки.

Ответ 3

Я лично считаю его более чистым, чтобы иметь стабильный багажник и выполнять ветвление. Таким образом, тестеры и т.д. Могут оставаться на одной "версии" и обновляться со ствола, чтобы протестировать любую функцию, которая завершена.

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

В качестве дополнительного бонуса существует некоторый уровень интеграции, который приходит автоматически.

Ответ 4

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

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

Так что для меня использование обоих механизмов - очень хорошая стратегия.

Интересная ссылка из Книга SVN.

Ответ 5

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

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

ИЗМЕНИТЬ

Я читал эту книгу в CI, и авторы предлагают предположить, что разветвление по версии является их предпочтительной стратегией разветвления. Я должен согласиться. Ветвление по признакам не имеет смысла для меня при использовании CI.

Я попытаюсь объяснить, почему я так думаю. Скажем, у трех разработчиков есть ветка для работы над функцией. Для завершения каждой функции потребуется несколько дней или недель. Чтобы обеспечить постоянную интеграцию команды, они должны совершать основные действия по крайней мере один раз в день. Как только они начинают это делать, они теряют выгоду от создания ветки функций. Их изменения больше не отделены от всех других изменений разработчика. В этом случае, зачем вообще создавать ветки функций?

Использование ветвления по версии требует гораздо меньшего объединения ветвей (всегда хорошо), гарантирует, что все изменения будут интегрированы как ASAP и (если все сделано правильно) гарантирует, что ваша база кода всегда готова к выпуску. Нижняя сторона к разветвлению по выпуску состоит в том, что вы должны быть значительно более осторожны с изменениями. Например. Большой рефакторинг должен выполняться постепенно, и если вы уже интегрировали новую функцию, которую вы не хотите в следующем выпуске, тогда она должна быть скрыта с помощью механизм переключения функций.

ДРУГОЕ ИЗОБРАЖЕНИЕ

Существует более одного мнения по этому вопросу. Вот сообщение в блоге, которое представляет собой ветвь с функциями с CI

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

Ответ 6

Недавно я использовал эту модель при использовании git. Хотя ваш вопрос отмечен как "svn", вы все равно сможете его использовать.

Непрерывная интеграция может в какой-то степени произойти в ветки "разработки" (или как бы вы это называете) в этой модели, хотя наличие длинных функциональных ветвей для будущих выпусков не сделало бы это настолько жестким, чтобы рассматривать каждое изменение, происходящее с код где-то. Остается вопрос, хотите ли вы этого. Мартин Фаулер делает.

Ответ 7

Пока вы понимаете принципы, вы всегда можете заново изобрести лучшие практики. Если вы не понимаете принципов, лучшие практики позволят вам до того, как развалиться из-за некоторых противоречивых внешних требований.

Для лучшего ввода в модель Mainline прочтите следующее: https://web.archive.org/web/20120304070315/http://oreilly.com/catalog/practicalperforce/chapter/ch07.pdf

Прочтите ссылку. После того, как вы получили основы, прочитайте следующую статью почтенного Хенрика Книберга. Это поможет вам связать модель Mainline с непрерывной интеграцией.

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

Ответ 8

Непрерывная интеграция не должна быть каким-либо фактором в определении вашей стратегии ветвления. Ваш подход к ветвям должен быть выбран на основе вашей команды, разрабатываемой системы и доступных вам инструментов.

Сказав, что...

• нет причин, по которым CI не может использоваться в обоих описанных вами подходах.
• эти подходы работают довольно хорошо в комбинации
• ни одна из двух не работает "лучше", чем другая
• CI делает общий смысл с неустойчивой магистралью

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

Ответ 9

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

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

Окончательный "гвоздь в гроб" из чистых стратегий SC пришел, когда мы решили, что у нас должен быть 1. стабильный багажник и 2. Производство должно содержать ST, UAT и регрессионные тесты BINARIES (а не только источник - думаю, CC).

Это заставляет нас разработать стратегию, которая является гибридом между стратегиями SC и ОС на основе релиза.

Итак, у нас есть багажник. В каждом спринте мы разветвляем ветвь спринта (для непередвижных людей - спринт - это всего лишь временная работа по разработке с переменным выходом, основанным на сложности). Из ветки спринта мы создаем ветки признаков, и в них начинается параллельная разработка. Когда функции завершены и протестированы системой, и мы получаем намерение их развернуть, они объединяются в ветвь спринта - некоторые могут плавать через несколько спринтов, как правило, более сложные. Как только спринт близок к его концу, а функции завершены... мы "переименуем" ветвь спринта в "регрессию" (это позволяет CruiseControl подбирать его без какой-либо переконфигурации), а затем тестирование на регрессию/интеграцию начинается с cc-built EAR. Когда все это будет сделано, оно начнет работать.

Короче говоря, для разработки, системного тестирования и UAT-функций используются специализированные ветки. Ветвь спринта (на самом деле ветвь освобождения) используется для выборочного объединения функций по требованию и интеграции-теста.

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

Ответ 10

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

Когда и что делать, обычно зависит от размера команды и размера разрабатываемых функций. Я не думаю, что есть золотое правило. Удостоверьтесь, что вы используете стратегию, в которой вы можете получить обратную связь раньше/часто, и которая включает в себя качество, связанное с самого начала функций. Бит качества означает, что по мере того, как вы разрабатываете автоматизацию, когда вы разрабатываете команду, если вы отправляетесь на большой набор функций, создаваемых командой, вы также должны иметь качество, связанное с командой.

ps Откуда вы взяли эти ссылки? - не чувствует, что эти графики представляют все опции

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

Ответ 11

Я думаю, что инструменты, которые вы используете, являются большим фактором здесь.

• Если вы используете подрывную деятельность, придерживаетесь опции 1 и освобождаетесь от ветвей.
• Если вы используете GIT, опция 2 будет хорошо работать для вас.