Стратегія Git для невеликих розробників [закрита]

У нас є веб-додаток, який ми оновлюємо та випускаємо майже щодня. Ми використовуємо git як наш VCS, і наша нинішня стратегія розгалуження дуже проста і зламана: у нас є головна гілка і ми перевіряємо зміни, які ми «відчуваємо добре» в ній. Це працює, але лише до тих пір, поки ми не переконаємося в переломній зміні.

Хто-небудь має улюблену стратегію для git-філій для невеликих команд, яка відповідає таким вимогам:

1. Добре працює для команд від 2 до 3 розробників
2. Легкий і не надто великий процес
3. Дозволяє розробникам легко ізолювати роботу над виправленнями помилок та більшими можливостями
4. Дозволяє нам зберігати стабільну гілку (для тих моментів, коли нам доведеться працювати на наших виробничих серверах)

В ідеалі я хотів би побачити ваш покроковий процес для розробника, який працює над новою помилкою

Ви можете скористатися робочим процесом, який Скотт Чакон описує в Pro Git . У цьому робочому процесі у вас є дві гілки, які завжди існують, опановуються та розвиваються .

master представляє найбільш стабільну версію вашого проекту, і ви лише коли-небудь розгортаєтеся для виробництва з цієї галузі.

розробка містить зміни, які тривають і можуть не обов'язково бути готовими до виробництва.

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

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

Крок за кроком ваш робочий процес у цій моделі може виглядати приблизно так:

1. Вам потрібно виправити помилку.
2. Створіть гілку, яку називають myfix, яка заснована на гілці розробки .
3. Працюйте над помилкою у цій тематичній галузі, поки вона не буде усунена.
4. Об’єднайте міфікс у розробку . Виконати тести.
5. Ви виявите свої скрутні конфлікти з іншим темою філії hisfix , що ваші колеги об'єднані в розробку , поки ви працюєте над виправленням.
6. Зробіть більше змін у гілці myfix, щоб вирішити ці конфлікти.
7. Об’єднайте міфікс у розробці та запустіть тести ще раз.
8. Все працює добре. Злиття розвиваються в майстер .
9. Будь-який час впроваджуйте у виробництво від майстра , адже ви знаєте, що це стабільно.

Щоб отримати детальнішу інформацію про цей робочий процес, перегляньте розділ « Розгалуження робочих потоків» у Pro Git.

Після того, як увійшов як початківець, намагався знайти пряму стратегію, щоб навчити інших дияволів, які ніколи не використовували управління джерелами. Це той, який підходить http://nvie.com/posts/a-successful-git-branching-model/ Я спробував використовувати стандартний робочий процес GIT, який знаходиться на сторінках man, але це мене трохи збентежило та мою аудиторію повністю.

За останні 6 місяців мені довелося виправляти конфлікти лише двічі. Я додав кроки, щоб завжди перевіряти після злиття, а також "витягувати і зливати" або "тягнути - повторно", дуже багато (один раз вранці та вдень), розробляючи функції. Ми також використовували github.com як центральне місце для виведення останнього коду.

(Зробив мій коментар вище, це власна відповідь, як я і повинен був спочатку.)

Від Скотта Чакона з Гітбуба:

Як ми це робимо так, що таке GitHub Flow?

• Все, що знаходиться у головній галузі, є розгорнутим
• Щоб працювати над чимось новим, створіть описово названу гілку від master (тобто: new-oauth2-scopes)
• Приєднайтесь до цієї гілки на місцевому рівні та регулярно переносьте свою роботу до однойменної гілки на сервері
• Коли вам потрібен зворотній зв'язок або допомога, або ви вважаєте, що відділення готове до об'єднання, відкрийте запит на виклик
• Після того, як хтось інший перевірив та вийшов із функції, ви можете об'єднати її в головний
• Після того, як це об'єднано і висунуто на "майстер", ви можете і потрібно негайно розгортатись

Детальну інформацію див. У всій статті: http://scottchacon.com/2011/08/31/github-flow.html

Зауважте, що "запити на потяг" - це винахід Github, і це щось, що виведено на їхньому веб-сайті, а не самому Git: https://help.github.com/articles/using-pull-requests/

Використовуйте masterгілку як свою галузь розвитку та створіть гілки випуску для виконання виправлень помилок.

Будь-які нові функції працюватимуть masterпід час вікна розробки (або безпосередньо, або як тематичні гілки із запитами на тягу, до вас - не відображаються у графіці). Після того, як всі заплановані функції будуть реалізовані, введіть функцію заморожування та проведіть тестування. Коли ви щасливі, позначте версію masterякv1.0 .

З часом ваші користувачі знайдуть помилки, v1.0тому вам захочеться створити гілку з цього тегу (наприклад, назвати його після випуску 1.0) та виправити ці помилки у гілці. Коли у вас виправлено достатню кількість помилок, ви вважаєте, що це вимагає нової версії, тоді позначайте її як v1.0.1і об'єднуйте назад у master.

Тим часом на masterгілці може відбуватися нове вікно розробки, яке згодом буде позначено як v1.1.

Промийте і повторіть.

Звідси випливає логіка нумерації семантичних версій .

 ---------(v1.0)--------------------------------(v1.1)-----------------------------> master
             \                                     \  
              ---(v1.0.1)---(v1.0.2)---> 1.0        ---(v1.1.1)---(v1.1.2)---> 1.1

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

Але у DVCS (як у "Децентралізованій" VCS) у вас також є випуск публікації , із гілками, які зберігаються локально у ваших сховищах, та гілках, на які ви натискаєте або витягуєте.

У цьому контексті почніть з визначення одночасних зусиль з розробки та визначтесь із процесом публікації (push / pull). Наприклад (і це не єдиний спосіб):

• prod - це публічна гілка, доступна лише для читання, з кодом у виробництві. Кожен міг витягнути з нього, щоб:
  • відновити його поточну розробку поверх нього (для локального тестування або для інтеграції на локальному розробнику repo виправлення, зроблене в продуктовому репо на гілці prod)
  • відділення, щоб робити нові функції (з відомого стабільного коду)
  • гілка, щоб запустити наступну гілку випуску (ту, яка має бути у виробництві),
    ніхто не повинен натискати безпосередньо, щоб продати (отже, лише для читання)
• release - це гілка консолідації читання-запису, де відповідні комірки вибираються вишневими, щоб бути частиною наступного випуску.
  Кожен може натиснути на випуск, щоб оновити наступний випуск.
  Кожен може вийти із зазначеного випуску, щоб оновити свій / локальний процес консолідації.
• featureX - це приватна гілка читання-запису (оскільки вона не потребує натискання на центральну програму репо) і може бути натиснута / перетягнута між репо-версіями. Він представляє середньо- та довгострокові зусилля, відмінні від щоденних розробників
• master представляє поточний dev і переміщується / тягнеться між rev rev.

Існують й інші процеси управління випусками, про що свідчить це питання СУ .

Читайте Git Workflow ReinH для Agile команд тут: http://reinh.com/blog/2009/03/02/a-git-workflow-for-agile-teams.html

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

Примітка: ця стратегія навряд чи є специфічною для git, але git робить її реалізацією досить простою.