Как интеграция контроля ошибок/контроля версий работает с типичными рабочими процессами git?

Ответ 1

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

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

Другими полезными функциями было бы графическое представление того, как ветки создаются и объединяются, подобно тому, как выглядит gitk. Я не знаю ни одного трекера ошибок, который делает такую ​​визуализацию.

ИЗМЕНИТЬ Кори Трейгер. Я копирую/вставляю @Squelch ответ здесь (я также сохранил @Squelch):

Благодаря распределенному характеру git по отношению к централизованной природе SVN, вполне возможно, что каждый пользователь или копия репозитория имеет разные ветки. У exisitnig trackers обычно есть локальная копия репозитория, которая используется как центральная ссылка ( "доброжелательный диктатор" ), которая может рассматриваться как рабочая копия для всех пользователей.

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

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

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

Короче говоря, трекер обычно видит, какие изменения внесены в ветки, к которым он в настоящее время имеет доступ. С помощью крючка эти изменения видны сразу, включая создание новой ветки. Он не увидит или не отслеживает изменения, внесенные в репозитории пользователей (в автономном режиме), пока они не нажмут эти изменения.

КОНЕЦ @Squelch

Ответ 2

Великий вопрос.
Чтобы ответить на этот вопрос, вам нужно посмотреть, какие из этих инструментов (BugTracker.NET, что вы знаете хорошо, очевидно;) и Git, сделанный изначально для Linux в 2005 году) на самом деле пытается решить.

• BugTracker.NET: веб-трекер, для ошибки (или почти любой другой "элемент", который вы хотите отслеживать, поскольку вы можете определить свои настраиваемые поля, статус и рабочий процесс).
• Git: по своей сути, это интегратор патчей, сделанный для подачи большого количества патчей от большого количества людей (не всех из них известных или с определенными ролями) большому количеству файлов. Быстро.

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

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

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

Если вы посмотрите презентацию Linus Git в Google, около 18'35, вы попадете в проход, где вы поймете, что используете Git означает, что не все пользователи идентифицированы и привязаны к роли.

Вот несколько быстрых цитат/точек, которые иллюстрируют этот факт:

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

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

Что "рабочий процесс доброжелательного диктатора" означает, что вы работаете с "сетью доверия": избранная группа людей. Опять же, не все разработчики сразу видны.

• Из той же презентации вы также понимаете, что "весь репозиторий" может быть частью жизненного цикла кода (в отличие от интеграции веток "," тестирования "," освобождения "или" ярлыков ", release1.0 ',...):

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

Это укрепит предыдущий момент: если вы контролируете только одно репо, вы можете использовать только монетизацию от ограниченного числа людей.
И это добавляет поворот:
Хотя вы не можете контролировать все репозиции там, вам может не потребоваться отслеживать только одно репо: если отслеживание ошибок перекрывает несколько этапов (а именно "contrinous integration", "функциональное тестирование", "проверка пользователя", "предварительная подготовка",...), каждый из которых потенциально имеет свое собственное дерево, и каждый из них является потенциальным источником для заполнения отчета об ошибке.
В этом отношении поддержка "Git от Redmine" (Редакция 2840) по-прежнему производится с учетом "централизованного репо", где вы используете ветвь для моделирования жизненного цикла разработки (где вы выполняете задачи вокруг и вокруг разработки, вместо того, чтобы делать фактические "усилия по разработке", что и должно быть веткой).

Где все, что вас покидает?

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

• или переопределить управление жизненным циклом ошибок, чтобы принять во внимание:

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

Короче говоря, это не тривиальная задача.

Проблемы остаются:

• Git рабочий процесс публикации, который является inter-repo (push/pull), а также intra-repo (merge/rebase): какие из них вы хотите отслеживать?
• Git частное ветвление: не вся история кода будет видна и не должна отслеживаться. Следует отслеживать только публичные ветки (которые вытягиваются/выталкиваются, но также модифицируются в пределах своего собственного репо путем слияния или переучета).
• Git пользователи: согласно их месту в "сети доверия", они имеют разные роли, которые трекер должен отражать.

Ответ 3

Чтобы ответить на вопрос MichaelM, Redmine имеет хорошую интеграцию Git. Он следует за сообщениями фиксации для ключевых слов, таких как ссылки. исправления и т.д. и номер трекера формы № 1234.

Правда, поддержка ветки еще не существует, но она вступила в trunk около месяца назад и предназначена для версии 0,9. Redmine в настоящее время поддерживается в SVN, но есть также зеркало на Github

Ссылка на соединительную линию Redmine указывает на выход трекера для репозиториев Git с различиями в том, как перемещаются ветки.

$ git log

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

Edit: Из-за распределенной природы Git против централизованного характера SVN, вполне возможно, что каждый пользователь или копия репозитория имеет разные ветки. У exisitnig trackers обычно есть локальная копия репозитория, которая используется в качестве центральной ссылки ( "доброжелательный диктатор" ), которая может рассматриваться как рабочая копия для всех пользователей.

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

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

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

Короче говоря, трекер обычно видит, какие изменения внесены в ветки, к которым он в настоящее время имеет доступ. С помощью крючка эти изменения видны сразу, включая создание новой ветки. Он не увидит или не отслеживает изменения, внесенные в репозитории пользователей (в автономном режиме), пока они не нажмут эти изменения.

Ответ 4

Там также интеграция с открытым исходным кодом с Fogbugz, на GitHub, конечно.

Ответ 5

Посмотрите, как Launchpad делает это: отслеживание состояния ошибки в разных местах.

Ниже я приведу Mark Shuttleworth:

Истинно распределенное отслеживание ошибок (где список ошибок следует за кодом везде) является очень захватывающим и может быть долгосрочным решением. В промежуточный, вы можете обратиться к нему, просто отслеживая состояние ошибка в нескольких разных местах. Canonical финансирует работу над Bugzilla, Trac и другие трекеры ошибок, чтобы облегчить общение с их программно, чтобы мы могли постоянно обновлять разработчиков Ubuntu автоматически.

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

https://bugs.launchpad.net/moblin-applets/+bug/209870
https://bugs.launchpad.net/ubuntu/+source/nfs-utils/+bug/214041
https://bugs.launchpad.net/ubuntu/+source/tuxmath/+bug/220319
https://bugs.launchpad.net/ubuntu/+source/linux-source-2.6.22/+bug/123920
https://bugs.launchpad.net/ubuntu/+source/warsow/+bug/131582

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

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

Ответ 6

Redmine уже интегрируется с Git и открывает его. Возможно, вы можете взглянуть на их интеграцию идей.

Ответ 7

Возможно, я немного наивен, но будет ли отслеживание ошибок действительно отличным в git чем в svn? Репозиторий, используемый системой, будет в основном иметь ту же структуру (ветки и теги), что и в подрывной деятельности, правильно?

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