Гибкое ветвление против статического (Git против Clearcase / Accurev)

https://stackoverflow.com/questions/763099

11-09-2019
|

Вопрос

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

Но в других системах, таких как Clearcase или Accurev, вы можете указать, как ветви заполняются какой - то механизм наследования:Я имею в виду, что с Clearcase, используя config_spec, вы можете сказать “получите все файлы, измененные в ветке / main /issue001, а затем продолжите с файлами в / main или с этой конкретной базовой линией”.

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

Разве вы не скучаете по этому при использовании Git?Можете ли вы перечислить сценарии, в которых это наследование это обязательно?

Спасибо

Обновить Пожалуйста, прочтите ответ VonC ниже, чтобы действительно сфокусировать мой вопрос.Как только мы согласимся, что "линейное хранилище" и SCM на основе DAG обладают разными возможностями, мой вопрос заключается: каковы сценарии реальной жизни (особенно для компаний, выходящих за рамки OSS), где linear может делать то, что невозможно для DAG?Стоят ли они того?

Решение

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

ClearCase использует хранение линейной версии:каждая версия элемента (файла или каталога) связана прямым линейный связь с предыдущей версией того же элемента.
Git использует ДАГ - Направленный Ациклический граф:каждая "версия" файла фактически является частью глобального набора изменений в дереве, которое само по себе является частью фиксации.Предыдущая версия этого должна быть найдена в предыдущем коммите, доступном через один направленный путь ациклического графа.

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

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

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

Чтобы применить в Git некоторые другие версии, вы должны либо:

объедините в свою ветку какой-нибудь другой коммит (например, в git pull", упомянутом ответ stsquad's) или
перебазируйте свою ветку (как Грег упоминает)

Но поскольку Git - это SCM на основе DAG, это всегда приведет к новой фиксации.

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

В чисто централизованном VCS вы можете определить свое рабочее пространство (в ClearCase ваш "вид", либо моментальный снимок, либо динамический) с любыми правилами, которые вы хотите.

неизвестно-google добавляет в комментарии (и в своем вопросе выше):

Итак, как только мы увидим, что две модели могут достигать разных результатов (линейный vs DAG), мой вопрос таков:каковы сценарии реальной жизни (особенно для компаний, выходящих за рамки OSS), где linear может делать то, что невозможно для DAG?Стоят ли они того?

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

Рассмотрим эту "спецификацию конфигурации" (т.е."спецификация конфигурации" для правил выбора с помощью ClearCase):

element /aPath/... aLabel3 -mkbranch myNewBranch
element /aPath/... aLabel2 -mkbranch myNewBranch

Он выбирает все файлы, помеченные 'aLabel2" (и ответвляющиеся оттуда), за исключением тех, которые помечены "aLabel3' - и ответвляться оттуда - (потому что это правило предшествует тому , в котором упоминается 'aLabel2').

Стоит ли оно того?

Нет.

На самом деле, UCM-версия ClearCase ("Унифицированное Управление конфигурацией"методология, включенная в продукт ClearCase и представляющая все "лучшие практики", выведенные из базового использования ClearCase), не позволяет этого по причинам упрощенность.Набор файлов называется "компонентом", и если вы хотите выполнить ветвление для заданной метки (известной как "базовая линия"), это будет переведено следующим образом: спецификация конфигурации:

element /aPath/... .../myNewBranch
element /aPath/... aLabel3 -mkbranch myNewBranch
element /aPath/... /main/0 -mkbranch myNewBranch

Вы должны выбрать один отправная точка (здесь, 'aLabel3') и идите оттуда.Если вы хотите также получить файлы из 'aLabel2', вы произведете слияние из всех 'aLabel2'файлы к тем, что в 'myNewBranch'.

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

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

Общая цель состоит в том, чтобы рассуждать в "когерентный Операции контроля версий, применяемые к когерентный компонент"."Согласованный" набор файлов - это набор файлов в четко определенном согласованном состоянии:

если помечено, ВСЕ его файлы помечены
если разветвленный, ВСЕ его файлы будут отходить от такой же уникальный отправная точка

Это легко сделать в системе DAG;это может быть сложнее в линейной системе (особенно с "Базовым ClearCase", где "спецификация конфигурации" может быть сложной), но это обеспечивается методологией UCM того же самого линейного инструмента.

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

Это позволяет вам покинуть сферу VCS (Система контроля версий) и войди в царство SCM (Управление конфигурацией программного обеспечения), который в основном связан с "воспроизводимость".И это (функции SCM) может быть достигнуто с помощью VCS на основе linear или DAG.

Другие советы

Похоже, то, что вы ищете, может быть git rebase.Перебазирование ветви концептуально отсоединяет ее от исходной точки ветвления и повторно подключает в какой-либо другой точке.(На самом деле перебазирование осуществляется путем последовательного применения каждого патча ветви к новой точке ветвления, создавая новый набор патчей.) В вашем примере вы можете переназначить ветвь на текущую вершину верхней ветви, которая, по сути, "унаследует" все изменения, внесенные в другую ветвь.

Я не совсем понимаю, о чем вы просите, но это звучит как git семантика отслеживания - это то, что вы хотите.Когда вы переходите из am origin вы можете сделать что-то вроде:

git -t -b источник моей ветви/мастер

И тогда будущее "извлечения"S будет автоматически объединять происхождения/мастер в рабочая ветвь.Затем вы можете использовать "git cherry -v origin / master", чтобы увидеть в чем разница.Вы можете использовать "git rebase" перед публикацией ваших изменений чтобы очистить историю, но вы не должны использовать rebase один раз ваша история общедоступна (т.Е.другие люди следуют этой ветке).

Что касается схемы наследования, используемой accurev:Пользователи GIT, вероятно, "поймут" все это целиком, когда взглянут на git-поток (см . также: http://github.com/nvie/gitflow и http://jeffkreeftmeijer.com/2010/why-arent-you-using-git-flow/)

Эта модель ветвления GIT более или менее выполняет (вручную / с помощью инструмента git-flow) то, что accurev делает из коробки автоматически и с великий Поддержка графического интерфейса.

Итак это кажется GIT может делать то же, что и accurev.Поскольку я никогда на самом деле не использовал git / git-flow изо дня в день, я не могу точно сказать, как это работает, но это выглядит многообещающе.(Минус надлежащая поддержка графического интерфейса:-)

Я постараюсь ответить на ваш вопрос.(Я должен сказать здесь, что я не использовал GIT, только читал об этом, поэтому, если что-то, о чем я упоминаю ниже, неверно, пожалуйста, поправьте меня)

"Можете ли вы перечислить сценарии, в которых это наследование является обязательным?"

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

Единственный сценарий, который я вижу, это удобно иметь в этом "наследство" поведение и используйте возможности спецификации конфигурации, когда вы хотите, чтобы ваш набор изменений "изолированный" сопоставлен задаче (devtask, CR, SR или тому, что определяет цель / область действия вашего набора изменений)

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

Будучи пуристом, вынужденным фиксировать / объединять / перебазировать только для того, чтобы иметь "определенную отправную точку", я думаю, это было бы 'загрязнять' ваша ветка, и вы получите свои изменения + другие изменения в вашей ветке / наборе изменений.

Когда / Где эта изоляция полезна?Приведенные ниже пункты могут иметь смысл только в контексте компаний, использующих CMM и некоторые сертификаты ISO, и могут не представлять интереса для других компаний или OSS

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

В крупных проектах с несколькими командами и более чем 500 разработчиками, активно работающими одновременно над одним и тем же базовым кодом (где графические деревья версий отдельных элементов выглядят как запутанная паутина с несколькими линиями загрузки, по одной для каждого крупного заказчика или по одной для каждой технологии), большие спецификации конфигурации с использованием композиции нескольких степеней глубины позволили такому количеству людей беспрепятственно адаптировать один и тот же продукт / систему (базовый код) для разных целей.Используя эту спецификацию конфигурации, вы динамически предоставляли каждой команде или подразделению другое представление о том, что им нужно и от чего им нужно отходить (каскадируя в нескольких случаях) без необходимости создания промежуточных ветвей интеграции или постоянного объединения и перебазирования всех битов, с которых вам нужно начать.Код из одной и той же задачи / назначения представлял собой ветвление разных меток, но имел смысл.(Вы можете утверждать здесь, что "известная базовая линия" является принципом SCM, но простые метки, предусмотренные в письменном плане SCM, выполнили свою работу) Должно быть возможно решить это с помощью GIT (я думаю, нединамическим способом), но мне действительно трудно представить себе без этого поведение "наследования".Я предполагаю, что пункт, упомянутый VonC "если он разветвлен, все его файлы будут разветвляться от одной и той же уникальной начальной точки", был нарушен здесь, но помимо того, что это было хорошо задокументировано в SCMP, я помню, что были веские деловые причины сделать это таким образом.

Да, создание этих конфигурационных спецификаций, о которых я упоминал выше, не было бесплатным, вначале там было 4-5 хорошо оплачиваемых людей, стоящих за SCM, но позже они были сокращены с помощью автоматизированных скриптов, которые спрашивали вас, что вы хотите с точки зрения ярлыков / ветвей / функций, и напишут CS для вас.

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

Итак, отсюда можно сделать один вывод: только если ваш проект достаточно большой / сложный (и вы можете позволить себе SC-менеджеров на протяжении всего срока реализации проекта :)) тогда вы только начнете думать, нужно ли вам поведение "наследования" или действительно универсальный инструмент, в противном случае вы перейдете непосредственно к бесплатному инструменту, который уже позаботится о согласованности вашего SCM ...но в инструменте SCM могут быть и другие факторы, которые могут заставить вас придерживаться того или иного ...читайте дальше..

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

Я должен добавить здесь, что мы используем "старый добрый CC", а не UCM.Полностью согласен с VonC в отношении хорошая методология позволяет "направить" гибкость в сторону более согласованной конфигурации.Хорошо то, что CC довольно гибкий, и вы можете найти (не без некоторых усилий) хороший способ сделать все согласованным, в то время как в других SCM вы могли бы получить это бесплатно.Но, например, здесь (и в других местах, где я работал с CC) для проектов на C / C ++ мы не можем позволить себе цену отсутствия подмигивающий функция (повторное использование производных объектов), которая сокращает время компиляции в несколько X раз.Можно утверждать, что наличие лучшего дизайна, более развязанного кода и оптимизации Make-файлов может уменьшить необходимость компиляции всего этого, но бывают случаи, когда вам нужно компилировать всего зверя много раз в день, а совместное использование DO экономит кучу времени / денег.Там, где я сейчас нахожусь, мы стараемся использовать как можно больше бесплатных инструментов, и я думаю, мы избавимся от CC, если сможем найти более дешевый или бесплатный инструмент, который реализует подмигивающий особенность.

Я закончу тем, о чем упомянул Пол , разные инструменты лучше других подходят для разных целей но я добавлю, что вы можете избежать некоторых ограничений инструмента, используя согласованный процесс и не подвергая критике воспроизводимость, ключевые моменты SCM В конце концов, я предполагаю, что ответ на это того стоит? зависит от вашей "проблемы", используемого SDLC, ваших процессов SCM и наличия какой-либо дополнительной функции (например, winkin), которая может быть полезна в вашей среде.

мои 2 цента

Помимо теории, вот своего рода очевидный практический подход к этому, с моей точки зрения, использующий AccuRev в коммерческой производственной среде в течение ряда лет:Модель наследования работает очень хорошо до тех пор, пока дочерние потоки не слишком сильно разошлись с предками, которые все еще находятся в разработке.Это выходит из строя, когда наследуемые потоки слишком отличаются.

Наследование (более поздние версии как дочерние по отношению к более ранним) позволяет изменениям в потоках-предках быть активными в дочерних потоках, при этом никто ничего не делает (если только не требуется слияние, и в этом случае оно проявляется как глубокое перекрытие, что хорошо видеть).

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

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

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

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

Вы заметили, что вы также можете проверять определенные версии файлов с помощью GIT?

Просто используй это:

git checkout [< tree-ish >] [--] < paths >

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

Следующая последовательность проверяет главную ветвь, возвращает Makefile на две ревизии назад, удаляет hello.c по ошибке, и получает его обратно из индекса:

$ git checkout master             
$ git checkout master~2 Makefile             
$ rm -f hello.c            
$ git checkout hello.c

ClearCase, без мультисайта, представляет собой единый репозиторий, но Git распространяется.ClearCase фиксирует на уровне файла, но Git фиксирует на уровне репозитория.(Это последнее отличие означает, что первоначальный вопрос основан на недоразумении, как указывалось в других сообщениях здесь.)

Если это те различия, о которых мы говорим, то я думаю, что "линейный" и "DAG" - это запутанный способ отличить эти SCM-системы.В ClearCase все версии файла называются "деревом" версий файла, но на самом деле это ориентированный ациклический граф!Реальное отличие от Git заключается в том, что базы данных ClearCase существуют для каждого файла.Поэтому я думаю, что ошибочно называть ClearCase не-DAG, а Git - DAG.

(Кстати, ClearCase версифицирует свои каталоги аналогично своим файлам - но это уже другая история.)

Я не уверен, спрашиваете ли вы о чем-нибудь, но вы демонстрируете, что потоки Accurev - это другие инструменты, чем ветви Git (или SVN).(Я не знаю Clearcase.)

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

С помощью Git вы можете разделить исследовательское кодирование в локальных репозиториях или в ветвях функций, что не очень хорошо поддерживается Accurev.

Разные инструменты хороши для разных целей;полезно спросить, чем хорош каждый из них для.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow