Структура Mercurial Repository з великою вагою корпоративних комісій, управління конфігурацією та вимоги до тесту


16

Я ще один користувач Subversion, який бореться за перевиховання себе в Тао розподіленого контролю версій.

Під час використання Subversion я був великим шанувальником підходу, що стосується незначних проектів, і, з більшістю моїх колишніх роботодавців, ми би структурували наші відділення сховищ; теги та ствол:

branches-+
         +-personal-+
         |          +-alice-+
         |          |       +-shinyNewFeature
         |          |       +-AUTOMATED-+
         |          |                   +-shinyNewFeature
         |          +-bob-+
         |                +-AUTOMATED-+
         |                            +-bespokeCustomerProject
         +-project-+
                   +-shinyNewFeature
                   +-fixStinkyBug
tags-+
     +-m20110401_releaseCandidate_0_1
     +-m20110505_release_0_1
     +-m20110602_milestone
trunk

В межах самого власного дерева-джерела ми використали б (щось на зразок) таку структуру:

  (src)-+
        +-developmentAutomation-+
        |                       +-testAutomation
        |                       +-deploymentAutomation
        |                       +-docGeneration
        |                       +-staticAnalysis
        |                       +-systemTest
        |                       +-performanceMeasurement
        |                       +-configurationManagement
        |                       +-utilities
        +-libraries-+
        |           +-log-+
        |           |     +-build
        |           |     +-doc
        |           |     +-test
        |           +-statistics-+
        |           |            +-build
        |           |            +-doc
        |           |            +-test
        |           +-charting-+
        |           |          +-build
        |           |          +-doc
        |           |          +-test
        |           +-distributedComputing-+
        |           |                      +-build
        |           |                      +-doc
        |           |                      +-test
        |           +-widgets-+
        |                     +-build
        |                     +-doc
        |                     +-test
        +-productLines-+
        |              +-flagshipProduct-+
        |              |                 +-coolFeature
        |              |                 +-anotherCoolFeature
        |              |                 +-build
        |              |                 +-doc
        |              |                 +-test
        |              +-coolNewProduct
        +-project-+
                  +-bigImportantCustomer-+
                  |                      +-bespokeProjectOne
                  |                      +-bespokeProjectTwo
                  +-anotherImportantCustomer-+
                                             +-anotherBespokeProject

Ідея полягала в (і досі є) використати структуру сховища, щоб сприяти структуруванню зв'язку між інженерною командою; частина бізнесу, що стоїть перед клієнтами, та різні інші зацікавлені сторони та експерти в галузі.

На доцільність: вихідні документи, які розміщуються в одному з каталогів "проекту", використовуються (і заробляють гроші) лише один раз. Документи, що знаходяться в одному з каталогів "productLines", заробляють гроші стільки ж разів, скільки продається продукт з цього конкретного рядка. Документи, що знаходяться в одному з каталогів "бібліотек", заробляють гроші стільки разів, скільки продаються будь-які продукти, які ними користуються.

Це робить поняття амортизації витрат явним і допомагає розбудувати підтримку повторного використання вихідних документів у бізнесі.

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

Важливо, що продукти, над якими я працюю, зазвичай займають ВЕЛИКИЙ час, щоб виконати тести вимірювання та характеристики продуктивності; від 20 до 200 годин; генерування десь від декількох ГБ до декількох ТБ оброблюваних результатів тесту / проміжних даних (які потрібно зберігати та прив’язувати до певної конфігурації системи, щоб покращити продуктивність з часом). Це питання робить управління конфігурацією важливим фактором, а також пред'являє певну вимогу до централізації, оскільки, як правило, обчислювальні ресурси, необхідні для виконання тестів на вимірювання та характеристики продуктивності, обмежені; (невелике скупчення 64-128 ядер).

Як одна фінальна примітка; система безперервної інтеграції знає, що їй потрібно викликати збірку; статичний аналіз; тест на дим і тестовий запуск блоку кожного разу, коли змінюється ствол, кожен раз, коли будь-яка гілка "тегів" змінюється, і кожен раз, коли будь-яка гілка "АВТОМАТИЧНА" гілка. Таким чином, окремі розробники можуть використовувати систему CI зі своїми персональними відділеннями, важливою здатністю, IMHO.

Тепер ось моє запитання: як я можу повторити все вищезазначене (і покращити його, якщо це можливо) за допомогою Mercurial.

--edit:

Моя теперішня думка полягає у використанні центрального сховища Subversion, для визначення загальної структури, але дозволити використання hg як клієнта, щоб розробники могли мати репост доступний на місцевому рівні.


1
Ого. Гарною відповіддю на це буде дуже довгий нарис, я думаю.
Ед Джеймс

Я думаю, що ключовим питанням є те, як і де відбувається злиття коду, оскільки це, ймовірно, визначить шлях найменшого опору. Отже, як зливається код?
Wyatt Barnett

Зазвичай злиття може відбуватися з особистої гілки в гілку проекту або функції, а потім у магістраль. Я ніколи не стикався з великими труднощами з злиттями (ми використовували TortoiseSVN на Win32), хоча ми ніколи не працювали занадто довго (максимум одна ітерація) без інтеграції назад у багажник. Ми, як правило, велику частину нашої роботи в будь-якому випадку хотіли зробити, хоча метою було спрощення управління людиною, а не робочий процес розвитку. (Один розробник, багато незалежно працюючих розробників, тому, маючи все в багажнику, було легше на Dev-Lead відстежувати, що відбувається.)
William Payne

Одним із ключових моментів була велика залежність від тестування, керованого системою ІС, особливо на рівні тесту на систему. Це мало допомогти створити впевненість у тому, що різні розробники не заважають один одному, а також сприяти менталітету багато-маленьких ітерацій. (Крім того, обчислювальний важкий підйом, необхідний для виконання системних тестів, означав, що для обчислювальних ресурсів було менше суперечок, якщо люди працювали переважно на магістралі).
Вільям Пейн

Відповіді:


10

Відповідь Спойєка відмінна, але є кілька речей, які, я думаю, варто було б додати, які є занадто великими для коментарів.

Галузева організація

За допомогою Mercurial ви можете радісно проігнорувати всю свою першу організаційну таблицю. Як говорить Спок, у кожному сховищі є власний набір тегів, гілок (названих та анонімних) і їх можна організувати відповідно до потреб бізнесу.

Якщо вам bespokeProjectTwoпотрібна спеціальна версія chartingбібліотеки, ви можете відділити charting, додати нові засоби та використовувати її bespokeProjectTwo. Нові засоби (та їх помилки) не будуть використовуватися іншими проектами, які б посилалися на стандартну chartingбібліотеку. Якщо в основній chartingбібліотеці були виправлені помилки, ви можете об'єднати ці зміни у гілку. Якщо інші проекти також потребували цих засобів, ви можете або отримати ці проекти для використання спеціальної гілки, або об'єднати гілку в основну лінію та закрити гілку.

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

Організація довідників

Немає причини, чому ви не можете зберегти ваш вихідний каталог точно так, як це стосується Mercurial. Єдина відмінність полягає в тому, що якщо в Subversion ви маєте єдине монолітне (src)сховище, з Mercurial вам краще розділити на сховища, які логічно згруповані. З вашої структури дерев-джерел я, мабуть, витягнув би кожне з наступних як окремі сховища:

src-+
      +-(developmentAutomation)
      +-libraries-+
      |           +-(log)
      |           +-(statistics)
      |           +-(charting)
      |           +-(distributedComputing)
      |           +-(widgets)
      +-productLines-+
      |              +-(flagshipProduct)
      |              +-(coolNewProduct)
      +-project-+
                +-bigImportantCustomer-+
                |                      +-(bespokeProjectOne)
                |                      +-(bespokeProjectTwo)
                +-anotherImportantCustomer-+
                                           +-(anotherBespokeProject)

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

Робочий процес

Альтернативою запропонованому Спойком робочим процесом (розробник витягує з блаженного репо, працює на місцевому рівні, видає запит на витяг, і нарешті інтегратор витягує ці зміни та об'єднує їх) - використовувати систему постійної інтеграції в якості посередника.

Як і раніше, розробник витягує з благословенного репо і працює на місцевому рівні, але коли це закінчиться, вони знову витягуються з благословенного репо і зливаються перед тим, як натиснути на неповторне репо. Будь-які зміни, які не стосуються неповторного репо, потім переглядаються (вручну або автоматично) і переміщуються до благословенного репо, лише якщо вони затверджені.

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

Як запропоновано в книзі про вбивство, для автоматизації цієї процедури можна використовувати гачки :

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

Інші питання

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


Знову ще одна відмінна та інформативна відповідь. Дякую.
Вільям Пейн

RE: Галузева організація. Я погоджуюся, що першу організаційну схему можна з радістю ігнорувати. У будь-якому випадку він не особливо добре повідомляє робочий процес, і тому не надає реальної корисності, крім посилення конвенції. Однак я хотів би замінити це тим, що сильно передає (простий, наскільки це можливо) робочий процес, і заохочує часті домагання. Можливо, назвати головну галузь "ствол / розвиток" "щоденною" це зробить?
Вільям Пейн

RE: Організація каталогів. Я використовував організацію каталогів джерел як підсвідоме засіб зв'язку; нав'язування неявної структури організації коду (і через це для бізнесу в цілому). Я починаю розуміти, що Mercurial, як правило, використовується дуже гнучко; але я дуже хочу обмежити частину цієї гнучкості, щоб нав'язати структуру таким чином, як люди думають про бізнес, нав'язуючи структуру на шляху організації своїх документів на своїх робочих станціях та наших мережевих сховищах. (Більше корпоративних комунальних послуг, ніж технічних.)
Вільям Пейн

RE: Робочий процес. Я думаю, що найпростішим робочим процесом було б витягнути з "щоденного" сховища, працювати над ним локально, потім (часто) відштовхуватися до "щоденного" сховища, починаючи статичний аналіз, тести диму та регресійні тести через систему CI. Я радий, що головне репо буде "зламане", доки я знаю про нього, і поки воно швидко виправиться. Насправді, я розглядаю можливість зробити зобов’язання "щоденного" репо єдиним способом компілювати та створювати, щоб заохочувати часті вчинення та гарне покриття тесту. (Набагато важливіше, ніж здатність працювати ізольовано, ІМХО).
Вільям Пейн

@WilliamPayne - Дякую Хоча Mercurial є гнучким, з відповідними сховищами, гілками та гачками ви можете будувати будь-які обмеження, що вам потрібно, на рівні організації чи сховища. Особисто я б почав просто з організаційного контролю та декількох гачків ІС, і в майбутньому розширюю ці елементи контролю, коли їхня потреба стане очевидною. Також, розумне використання субрепост може, наприклад, спонукати людей перевіряти речі локально в тій же структурі, що і на сервері, наприклад, маючи productLinesабо bigImportantCustomerяк супер-репост.
Марк Бут

9

Гаразд, намагаюся відповісти на це просто.

Що потрібно знати

Перше, що вам потрібно знати: Mercurial поширюється на керування версіями і має деякі властивості, про які слід знати, перелічені нижче.

  • Джерело надходить з одного сховища, де це сховище може бути клоновано. Усі клоновані сховища можуть обмінюватися кодом між собою за допомогою синхронізації (за допомогою команд "pull and push", яким доступ може бути обмежений).
  • Кожен користувач, який має копію коду, має клон сховища. Якщо вони хочуть розгалужуватися, вони можуть це зробити у своєму місцевому клоні. Це означає, що вам не потрібно впорядковувати, як повинен користуватися кожен користувач. Вони можуть це зробити самі.
  • Теги створюються в меркуріальній формі комітом (що таке саме, як жорсткі теги в git). Це означає, що вам не потрібен каталог всередині вашої структури сховища для тегів.
  • Звичайна модель, з якою люди працюють у DVCS (яка використовується в github та bitbucket), - це робити це напів централізовано.

    Кожен користувач має загальнодоступний сховище (у якійсь частці або на захищеному сервері) та приватне сховище (на власних робочих станціях). Вони обидва клони «блаженного» сховища інтегратора. Щоразу, коли вони вважають, що готові опублікувати свій код, вони можуть перенести зміни до свого загальнодоступного сховища. Потім інтегратор може вибирати, яких користувачів перетягувати код у "благословенне" сховище.

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

Налаштування сховищ за проектом

Тож звичайна установка полягає в тому, що для кожного проекту є наступне:

  • Загальнодоступне сховище лише для читання, за яке відповідає інтегратор. Це "благословенно".

    Тобто всі користувачі можуть витягувати / витягувати вміст, але не мають доступу до нього.

  • Кожен користувач може мати власний публічний клон сховища.

    Найпростіше налаштувати, як розмістити на загальному диску (хоча ви можете розглянути можливість розміщення хостингу, такого як бітбукет). Інтегратор отримує запити на виклики від користувачів і намагається витягнути новий код з цих сховищ. Коли злиття виконуються без замикання, він поміщається в сховище лише для читання. Якщо ні, то від користувачів пропонується виправити конфлікти злиття, що виникають шляхом оновлення та об'єднання для себе локально.

  • Кожен користувач може мати власні приватні клони сховища.

    Доброю практикою є витяг з їх громадського клону, але не має значення, чи вони витягують їх з громадськості чи інтегратора. Усі коміти є унікальними для ідентифікації, тому об’єднання комітетів, які ви забули отримати у загальнодоступному, виправити порівняно легко (натискаючи зміни від приватного до загальнодоступного, воно автоматично отримує і зміни інтегратора).

Організація вихідного коду

Щодо того, як влаштувати джерело проекту - це те, що потрібно продумати. Якщо артефакт потрібно контролювати джерелом, тоді поставте його в управління джерелами. Особисто мені не подобається ідея перевіряти артефакти, які створені за допомогою збірки чи часу виконання (через високий ризик конфлікту об'єднати такі артефакти), як бінарні файли або файли журналів.

Ви також можете перевірити конфігурацію, якщо вони полегшують розробникам можливість рухатися і не псують конфігурацію для випусків або поточного / виробничого середовища (наприклад, налаштування додатків / веб-сервера). Це призводить до того, що якщо конфігурація, яку ви серйозно заважаєте розробникам почати роботу протягом п'яти хвилин після того, як вони перевірили код, його потрібно буде відновити. Інші вимоги полягають у тому, що розробникам має бути важко зіпсувати реліз або середовище живого / виробничого середовища.

Ви згадуєте, що у вас є дані тесту, які потрібно прив’язати до якоїсь версії коду. Тепер це трохи складніше, оскільки системи DVCS, такі як Mercurial та Git, мають тенденцію до повільного, коли ви перевіряєте дані, які є ВЕЛИЧЕЗНІ. На мій досвід, це стає нестерпним після 5 ГБ бінарних файлів (ваш пробіг може відрізнятися, тому ви повинні перевірити, як це працює для вас). Однак я б рекомендував розмістити згенеровані дані у власне сховище та мати тест-систему належним чином тегувати їх під час перевірки (та / або створення текстових файлів для тих же цілей метаданих).

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


+1 за дуже приємну відповідь з кількома дуже корисними пунктами. У відповідь на перший розділ вашої відповіді я не зрозумів значення кожного користувача, який має власне публічне сховище. Можливо, мені потрібно більше подумати про те, як можна було б організувати однорангові робочі процеси.
Вільям Пейн

У відповідь на другий розділ вашої відповіді, вся суть (на мій погляд) створення єдиного сховища для всієї організації полягає у створенні спільного ментального образу для того, як структурується робота, і полегшити пошук компонентів, які можуть підлягати повторному використанню. (Дуже сильно Собор, а не базар, але це середовище, в якому я працюю). Мені б дуже хотілося знати, як досягти однакового сенсу структурованої організації (системи подачі заявок) з DCVS.
Вільям Пейн

У відповідь на третій розділ вашої відповіді: Я щиро погоджуюся, що система управління джерелами призначена для вихідних документів, а отримані артефакти не належать до неї. Я також погоджуюся, що зберігати великі бінарні файли будь-якого опису в VCS недоцільно. Однак я вважаю, що ви можете зберігати великі бінарні файли в узгодженому мережевому розташуванні з визначеним іменем та посилатись на них у межах VCS. Наприклад, середовище (и) збирання можуть зберігатися як названі образи диска VM та посилатися на них із різних сценаріїв збірки. (наприклад: побудувати мене на build_env_A). Те ж саме стосується тестових даних.
Вільям Пейн

Раніше я використовував ієрархію каталогів на мережевому диску, де імена каталогів походять від ревізійного номера підривної програми + хеш місця розташування гілок, щоб прив’язати проміжні файли та результати тестування до певних версій. Це означає, що ми маємо можливість відстеження без необхідності зберігання похідних файлів у контролі версій.
Вільям Пейн
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.