TFS: Объединить лучшие практики

Ответ 1

• Слияние с Dev * → Интеграция и интеграция → Производство всегда должно быть "копировать" слияния. Это самый безопасный способ сохранить стабильность ваших нисходящих ветвей.
  • Сначала слейте в другом направлении (например, Integration → Dev2), чтобы получить последние изменения от целевой ветки.
  • Если есть конфликты, обрабатывайте разности в каждом отдельном случае. AcceptMerge (автоматический или ручной) обычно является желаемым результатом, но иногда вы захотите взять одну или другую ветку без изменений.
  • Используйте ветку источника (Dev # 2 в нашем случае), чтобы полностью включить, отреагировать и стабилизировать эти изменения.
  • Объединить в нужном направлении (например, Dev2 → Интеграция). Разрешите все конфликты как AcceptTheirs [aka "копия из источника" ].
  • Убедитесь, что в целевом ветке нет изменений между шагами 1-4. Если ветвь Dev принимает слияние рано и часто, как и должно быть, тогда не должно быть обременительно блокировать целевую ветвь во время этого многообещающего процесса. Если вы ожидаете "большого взрыва" слияния смерти по какой-либо причине, там приличная блокировка блокирует другие команды от параллельного выполнения одной и той же вещи, поэтому вам, возможно, придется повторять шаги 1-4 1-4, пока вы не будете готовы.
• "Догоняй" сливается, когда это возможно. То есть, объединить вещи в том же порядке, в котором они были проверены. Если изменения 10, 20 и 30 являются кандидатами для слияния с A → B, то любой из этих диапазонов слияния является "догоняющим": 10 ~ 10, 10 ~ 20, 10 ~ 30. Любой диапазон изменений, который пропускает # 10, известен как "выбор вишни". Как только вы начнете собирать вишню, вы столкнетесь с несколькими опасностями:
  • Вы не можете использовать слияние, копировать модель, описанную выше. Только для этого, Лаура Вингерд сказала бы, что вы прыгаете через бордюр.
  • Если какой-либо из файлов, затронутых вашим диапазоном, также был затронут ранее, вам нужно будет выполнить трехстороннее слияние содержимого, чтобы распространять только вишневые различия. Инструмент diff не идеален; вы добавляете ненулевой риск ввода большего количества кода, чем предполагалось, случайно переписывая изменения, внесенные в цель, вводя логические ошибки, когда две ветки расходятся и т.д.
  • Набор изменений, которые вы продвигаете в предположительно более стабильную ветвь, представляет собой конфигурацию, которая никогда не строилась или не тестировалась ранее. Вы можете догадаться о конечном состоянии целевой ветки. "Я объединяю все изменения, влияющие на модуль Foo, и я тестировал новую версию Foo в Dev, так что, как Foo будет вести себя в интеграции, не так ли?" Конечно... может быть... если вы можете отслеживать каждую зависимость в своей голове (включая все, что могло измениться в Integration, когда вы тестировали Dev). Но эти догадки никоим образом не известны или не подтверждены вашей цепочкой инструментов SCM.
  • В TFS конкретно, выбор вишни, в котором происходят изменения пространства имен, - это просто просить о сожжении. Если ваш диапазон версии и/или область пути исключает источник переименования, он будет заменен как ветка. Если вы исключите цель, она отложит удаление. Если ваша область пути не включает корень восстановления, вы получите загадочные ошибки. Если ваш диапазон охватывает промежуток времени между восстановлением и повторным удалением, вы получите файлы "phantom", отображаемые в целевом объекте, даже если вы не включите сам undelete. Если вы объедините Moves со всеми вашими путями и версиями, исправьте, но сделайте это не по порядку, вы можете получить другое целевое имя, чем имя источника, даже после того, как все изменения набора кандидатов исчерпаны. Я уверен, что есть больше способов, чтобы эта комбинация пошла не так, как сейчас не приходит в голову... просто поверьте мне.
• Всегда делайте Get на целевой ветке до слияния. Расширенная версия для максимальной безопасности: синхронизировать рабочую область, в которой вы будете сливаться с определенным номером набора изменений, который находится рядом с подсказкой или рядом с ним, а затем [догонять] слияние с тем же набором изменений. Это позволяет избежать нескольких возможных проблем:
  • Слияние с устаревшим кодом, приводящим к запутыванию трехсторонних различий, которые, как представляется, устраняют изменения, которые вы видите в подсказке. [вы в конечном итоге вернете их обратно на Checkin + Resolve, но нет причин идти через два рискованных различия, когда вы можете избежать обоих]
  • Необходимо дважды пройти процесс разрешения конфликтов: один раз на Merge, один раз на Checkin. Нет никакого способа избежать этого в общем случае, но в большинстве случаев # одновременных изменений, сделанных в то время, когда вы Merge + Resolve крошечные по сравнению С# изменениями, с которыми вы столкнулись в рабочей области, которая может быть дней или недель из дата.
• Не сливайте по метке (или рабочей области), если вы действительно не знаете, что делаете. Давайте рассмотрим функции, предлагаемые метками TFS, а затем проанализируем, почему каждый из них не подходит для безопасного и последовательного слияния.
  • Ярлыки могут представлять собой несколько точек во времени. Если метка представляет собой последовательный моментальный снимок VCS и всегда была предназначена как таковая, то она не имеет технического преимущества перед датой или набором изменений #. К сожалению, довольно сложно сказать, действительно ли ярлык со временем согласуется. Если нет, слияние по метке может привести к:
    • Неверный выбор вишни, если диапазон начинается с метки, указывающей на элемент @на время перед первым кандидатом.
    • Непреднамеренное исключение, если диапазон начинается с метки, указывающей на элемент @время перед концом диапазона
    • Непреднамеренное исключение, если диапазон заканчивается меткой, указывающей на элемент @за раз до начала диапазона
  • Этикетки versionpecs представляют собой определенный набор элементов. Они могут использоваться для преднамеренного исключения файлов и папок, которые в противном случае видел бы рекурсивный запрос. Эта функция также является плохим совпадением для операций слияния. (И снова, если вам не нужна эта способность, вы подвергаетесь следующему риску, не получая ничего от дат и наборов изменений.)
    • Элементы, отсутствующие в метке, будут просто проигнорированы, а не объединены как ожидающие удаления. В отличие от некоторых рассмотренных до сих пор краевых дел, это большая сделка, которая, скорее всего, произойдет в основных сценариях, но большинство людей пропустит. [В результате TFS 2010 добавляет поддержку удаленных элементов внутри меток.]
    • Неверный выбор вишни, если вы добавите элемент на метку, которая присутствовала некоторое время, но была исключена из предыдущих слияний из-за одного из вышеупомянутых побочных эффектов.
    • Преднамеренный сбор вишни. Все преимущество этой функции приносит Merge, чтобы сломать одно из наших рекомендаций, так что очевидно, что это не очень хорошая причина. Кроме того, он вызывает сбор вишни на уровне файлов, что еще более опасно, чем "обычная" сборка вишни по набору изменений.
  • Ярлыки имеют дружественные настраиваемые имена, владельцы и комментарии. Таким образом, мы имеем чистую разницу в использовании по сравнению с датами/наборами изменений; техническое преимущество не предоставляется. Но даже здесь это не так привлекательно, как кажется. TFS не делает много, чтобы на самом деле нарисовать метки в пользовательском интерфейсе, тогда как вы можете видеть комментарии к изменениям по всему месту. Запрос владельца выполняется быстро (на стороне сервера), но большинство других запросов выполняется медленно (на стороне клиента), если вы не знаете точное имя метки. Средства управления практически отсутствуют. Нет изменений или аудита, только временная метка. В целом, это вряд ли является основанием для отказа от поручительства, предоставляемого наборами изменений.
• Всегда объединяйте всю ветвь сразу. Слияние файлов или поддеревья иногда заманчиво, но в конечном итоге сводится к простому набору вишни под новым видом.
• Планируйте заранее. К сожалению, переобучение веток в TFS является болезненной темой. Иногда это тяжело, иногда это всего лишь несколько шагов, но это никогда не бывает очевидным; нет встроенной команды (до 2010 года). Вытягивание его в 2005/2008 году требует довольно глубокого знания вашей текущей структуры отрасли, желаемой структуры и способов злоупотребления побочными эффектами различных команд TF.
• Не создавайте ветки внутри ветвей. Например, иногда рекомендуется разветвление и слияние как способ поддерживать общие модули или двоичные файлы между слабо связанными проектами. Я не думаю, что это очень хороший совет для начала - гораздо лучше, чтобы ваша система сборки выполняла свою основную работу должным образом, а не заставляла вашу систему управления версиями делать то, что она не намеревалась сделать. Во всяком случае, эта тактика "совместного использования" ужасно конфликтует с самими проектами, живущими внутри более широкой иерархии веток для целей SCM. Если вы не слишком осторожны, TFS с радостью разрешит вам создавать произвольные отношения "во много раз" между элементами управления версиями. Удачи, сортируя это (я когда-то должен был сделать это для клиента, не очень.)
• Не создавать файлы с одинаковым относительным путем в двух ветвях независимо; используйте Merge, чтобы разветкить их, или вы будете часами преследовать конфликты пространства имен. (n/a в 2010 году)
• Не добавляйте лишние файлы поверх пути, в котором существуют другие элементы. Были ли старые элементы переименованы/перемещены или просто удалены, вы столкнетесь с интересными задачами в момент слияния; как минимум, для полноты размножения потребуется две проверки. (n/a в 2010 году, хотя опыт все еще несколько ухудшился, требуется только 1 проверка, содержимое элемента сохраняется, но история имен находится в этой ветки и всех ветвях по течению)
• Не используйте флаг /force, если вы не знаете, что делаете. Все/принудительные слияния - это, как правило, вишневые кирки, что приводит к очень похожим рискам (код теряется во время процесса Resolve и т.д. И т.д.).
• Не используйте флагов /unseless, если вы действительно не знаете, что делаете. Вы пропускаете удаления - подобно ярлыкам, за исключением того, что переименования всегда превращаются в ветки, а не просто в случаях неудач. Вы не получаете никакой дебетовой/кредитной защиты вообще. И самое страшное из всех, вы будете создавать новые отношения ветки. Иногда. (пользователю не сообщается о том, являются ли все целевые элементы новыми, старыми с новым отношением или старыми с существующими отношениями).
• Если возможно, избегайте/отбрасывайте (и, что то же самое, разрешения AcceptYours). Отбрасывание некоторых наборов изменений только для принятия последующих - это еще одно имя для выбора вишни:)
• Будьте осторожны с вашими разрешениями в целом. Каждый из них обладает уникальными эффектами нисходящего потока, кроме его влияния на слияние.
  • AcceptTheirs - это быстрый и мощный способ получить "копирование" слияния, как это указано в первом руководстве. Если вы используете его и в других сценариях, помните, что вы не просто указываете TFS, чтобы содержимое файла было одинаковым. Вы говорите, что эти два файла полностью синхронизированы с версией POV. Для этого любые предварительные изменения целевого файла, которые могли быть объединены в противоположном направлении, больше не будут считаться кандидатами после того, как вы проверите AcceptTheirs.
  • Обратите внимание, что AcceptMerge (автоматический или ручной), итоговое содержимое которого совпадает с исходным файлом, будет считаться сервером AcceptTheirs. В протоколе web-сервиса Checkin нет различий.
  • Использование AcceptYours при включении переименований может перекрутить ваш мозг. Вы быстро окажетесь в ситуации, когда "тот же" элемент имеет разные имена в разных ветвях. Предполагая, что у вас есть веская причина отказаться от изменений в первую очередь, это явление небезопасно по сути - на самом деле, вероятно, необходимо избегать либо перерывов, либо одноразовых настроек для ваших файлов. Это просто сбивает с толку людей и, скорее всего, нарушит любые сценарии автоматизации, которые у вас есть, что предполагает, что древовидные структуры согласованы с веткой на ветку.
  • AcceptMerge по умолчанию по умолчанию. Иногда это приводит к большему количеству конфликтов версий, чем кажется строго необходимым, но является самым безопасным выбором, когда требуется истинное слияние. (Например, шаг № 1 первичного руководства "слить, скопировать".) Пока вы следите за другими рекомендациями, количество слияний, требующих внимания со стороны руководства, должно падать - резко, если вы исходите из рабочий процесс, который сильно зависит от выбора вишни.
• Ошибки должны быть связаны с набором изменений, в котором исправление действительно было выполнено. Если позже вам нужно просверлить в нисходящие ветки, чтобы увидеть, когда, где (и, возможно, как) было распространено исправление, это чисто функция управления версиями. Не нужно загрязнять рабочий элемент дополнительным багажом, а тем более изменять способ, которым вы принципиально выполняете слияния. В 2005/2008 году вы можете перемещать историю слияния с помощью команды tf merges или стороннего интерфейса, такого как Attrice SideKicks. В 2010 году вы получаете отличные визуализации, встроенные в Visual Studio. Инструкции и скриншоты в MSDN.

Ответ 2

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

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

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

Итак, суммируя это, я не вижу причин, почему бы не объединиться с массами.