Struktur Repositori Mercurial dengan komunikasi perusahaan kelas berat, manajemen konfigurasi & persyaratan pengujian

Saya adalah pengguna Subversion lain yang berjuang untuk mendidik kembali diri saya sendiri dalam Tao tentang kontrol versi terdistribusi.

Ketika menggunakan Subversion, saya adalah penggemar berat pendekatan proyek-kecil, dan, dengan sebagian besar mantan majikan saya, kami akan menyusun cabang repositori kami; tag & trunk sebagai berikut:

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

Di dalam pohon sumber itu sendiri, kami akan menggunakan (seperti) struktur berikut:

  (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

Idenya adalah (dan masih) menggunakan struktur repositori untuk membantu struktur komunikasi antara tim teknik; bagian bisnis yang menghadap pelanggan dan berbagai pemangku kepentingan lainnya & pakar domain.

Intinya: Sumber dokumen yang duduk di salah satu direktori "proyek" biasakan (dan dapatkan uang) hanya sekali. Dokumen yang berada di salah satu direktori "productLines" menghasilkan uang sebanyak produk yang dijual. Dokumen yang berada di salah satu direktori "perpustakaan" menghasilkan uang sebanyak produk mana pun yang menggunakannya dijual.

Itu membuat gagasan amortisasi biaya eksplisit, dan membantu membangun dukungan untuk penggunaan kembali dokumen sumber di seluruh bisnis.

Ini juga berarti bahwa ada struktur umum di mana alat otomasi bangunan kami dapat beroperasi. (Skrip build kami menjalankan hierarki sumber mencari folder "build" di mana mereka menemukan file konfigurasi yang menentukan bagaimana setiap komponen akan dibangun; proses serupa terjadi untuk pembuatan dan pengujian dokumentasi).

Secara signifikan, produk tempat saya bekerja biasanya membutuhkan waktu yang lama untuk menjalankan tes pengukuran & karakterisasi kinerja; dari 20 hingga 200 jam; menghasilkan suatu tempat antara beberapa GB hingga beberapa TB hasil uji yang diproses / data antara (yang harus disimpan dan diikat ke konfigurasi sistem tertentu sehingga peningkatan kinerja dari waktu ke waktu dapat diukur). Masalah ini membuat manajemen konfigurasi menjadi pertimbangan penting, dan juga memaksakan beberapa persyaratan untuk sentralisasi, karena biasanya sumber daya komputasi yang diperlukan untuk menjalankan pengukuran kinerja dan tes karakterisasi terbatas; (sekelompok kecil 64-128 core).

Sebagai satu catatan akhir; sistem integrasi berkelanjutan tahu bahwa ia perlu memicu pembangunan; analisis statis; uji asap & uji unit dijalankan setiap kali trunk dimodifikasi, setiap kali "tag" cabang diubah, dan setiap kali cabang "OTOMATIS" dimodifikasi. Dengan cara ini, pengembang individu dapat menggunakan sistem CI dengan cabang pribadi mereka, kemampuan penting, IMHO.

Sekarang, inilah pertanyaan saya: Bagaimana saya bisa meniru semua hal di atas (dan memperbaikinya, jika mungkin), dengan Mercurial.

--edit:

Cara berpikir saya saat ini adalah menggunakan Repositori Subversion pusat, untuk menentukan struktur keseluruhan, tetapi untuk memungkinkan penggunaan hg sebagai klien sehingga pengembang dapat memiliki repo tersedia secara lokal.

Jawaban Spoike sangat bagus, tetapi ada beberapa hal yang menurut saya layak untuk ditambahkan yang terlalu besar untuk dikomentari.

Organisasi cabang

Dengan Mercurial Anda dapat dengan senang hati mengabaikan seluruh bagan organisasi pertama Anda. Seperti yang dikatakan Spoke, setiap repositori memiliki set tag, cabang (nama dan anonim) sendiri dan dapat diatur sesuai dengan kebutuhan bisnis.

Jika bespokeProjectTwomemerlukan versi khusus chartingperpustakaan, maka Anda akan bercabang charting, menambahkan fasilitas baru dan menggunakannya bespokeProjectTwo. Fasilitas baru (dan bug mereka) tidak akan digunakan oleh proyek lain yang akan merujuk chartingperpustakaan standar . Jika chartingpustaka utama memiliki bug yang diperbaiki, Anda bisa menggabungkan perubahan itu ke cabang. Jika proyek lain juga membutuhkan fasilitas ini, Anda bisa mendapatkan proyek tersebut untuk menggunakan cabang khusus , atau menggabungkan cabang ke dalam jalur utama dan menutup cabang.

Juga, tidak ada yang menghentikan Anda memiliki kebijakan untuk struktur nama cabang untuk menyediakan fasilitas spesifik seperti cabang OTOMASI Anda.

Organisasi direktori

Tidak ada alasan mengapa Anda tidak dapat menyimpan direktori sumber Anda persis seperti Mercurial. Satu-satunya perbedaan adalah bahwa sedangkan dengan Subversion Anda memiliki (src)repositori monolitik tunggal , dengan Mercurial Anda lebih baik membelah menjadi repositori yang secara logis dikelompokkan. Dari struktur pohon sumber Anda, saya mungkin akan mengekstrak masing-masing berikut ini sebagai repositori individu:

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

Ini memungkinkan setiap produk atau proyek yang dipesan lebih dahulu untuk menggunakan kombinasi perpustakaan, pada revisi apa pun. Lihatlah sub-repositori lincah untuk mengetahui cara mudah mengelola perpustakaan mana yang digunakan untuk versi produk atau proyek apa pun.

Alur kerja

Alternatif untuk alur kerja Spoike yang disarankan (pengembang menarik dari repo yang diberkati, bekerja secara lokal, mengeluarkan permintaan tarik dan akhirnya integrator menarik perubahan itu & menggabungkannya) akan menggunakan sistem integrasi berkelanjutan sebagai perantara.

Seperti sebelumnya, pengembang menarik dari repo yang diberkati dan bekerja secara lokal, tetapi ketika selesai, mereka menarik dari repo yang diberkati lagi dan menggabungkan diri sebelum mendorong ke repo yang tidak diberkati. Setiap perubahan pada repo yang tidak diberkati kemudian ditinjau (baik secara manual atau otomatis) dan dipindahkan ke repo yang diberkati hanya jika disetujui.

Ini berarti bahwa integrator hanya menerima atau menolak perubahan, tidak melakukan penggabungan. ^{Dalam pengalaman saya, hampir selalu lebih baik bagi pengembang yang menulis kode untuk melakukan penggabungan daripada bagi orang lain untuk melakukannya.}

Seperti yang disarankan dalam buku lincah, kait dapat digunakan untuk mengotomatisasi prosedur ini:

Ketika seseorang mendorong set perubahan ke server yang menarik semua orang, server akan menguji set perubahan sebelum menerima itu sebagai permanen, dan menolaknya jika gagal melewati rangkaian uji. Jika orang hanya menarik perubahan dari server pemfilteran ini, itu akan berfungsi untuk memastikan bahwa semua perubahan yang ditarik orang telah diperiksa secara otomatis.

Masalah lain

Masalah dataset uji besar juga dapat diselesaikan dengan menempatkan data uji ke dalam sub-repositori mercurial . Ini akan mencegah repositori kode membengkak dengan data uji, sambil tetap menjaga data uji di bawah kontrol revisi.

Oke, mencoba menjawab ini dengan sederhana.

Apa yang perlu Anda ketahui

Hal pertama yang perlu Anda ketahui: Mercurial adalah kontrol versi terdistribusi dan memiliki beberapa properti yang harus Anda ketahui tercantum di bawah ini.

• Sumber berasal dari satu repositori, tempat repositori itu dapat dikloning. Semua repositori yang dikloning dapat berbagi kode satu sama lain melalui sinkronisasi (dengan perintah tarik dan tekan, yang dapat dibatasi akses).
• Setiap pengguna yang memiliki salinan kode, memiliki tiruan dari repositori. Jika mereka ingin bercabang, mereka dapat melakukannya di klon lokal mereka. Itu berarti Anda tidak perlu mengatur bagaimana setiap pengguna harus bercabang. Mereka dapat melakukan ini untuk diri mereka sendiri.
• Tag dibuat dalam mercurial oleh komit (yang sama dengan tag keras di git). Ini berarti Anda tidak perlu direktori di dalam struktur repositori Anda untuk tag.

• Model yang biasa digunakan orang dalam DVCS (yang digunakan di github dan bitbucket) adalah melakukannya secara semi-terpusat.

  Setiap pengguna memiliki repositori publik (dalam beberapa bagian atau pada server yang aman) dan repositori pribadi (di workstation mereka sendiri). Keduanya adalah klon dari repositori integrator "diberkati". Setiap kali mereka merasa siap untuk mempublikasikan kode mereka, mereka dapat mendorong perubahan dari ke repositori publik mereka. Integrator kemudian dapat memilih pengguna mana yang akan menarik kode ke dalam repositori "diberkati".

  Jika integrator tidak dapat menggabungkan beberapa kode pengguna dengan mudah, maka perubahan ditolak dan terserah kepada pengguna tertentu untuk memperbarui repositori mereka dan memperbaiki sendiri gabungan tersebut. Biasanya tidak terlalu sulit jika Anda sering menggabungkan (karena lebih sedikit kode yang perlu digabung) dan biasanya pengguna tersebut harus tahu apa yang salah dengan merger.

Pengaturan repositori per proyek

Jadi pengaturan yang biasa adalah bahwa untuk setiap proyek ada yang berikut:

• Repositori baca-saja publik yang menjadi tanggung jawab integrator. Itu "diberkati".

  Yaitu semua pengguna dapat menarik / mengambil konten tetapi tidak memiliki akses untuk mendorongnya.

• Setiap pengguna dapat memiliki klon publik sendiri dari repositori.

  Pengaturan termudah yang dimasukkan ke drive share (meskipun Anda mungkin mempertimbangkan hosting seperti bitbucket). Integrator menerima permintaan tarik dari pengguna dan mencoba menarik kode baru dari repositori ini. Ketika penggabungan dilakukan tanpa hambatan, dimasukkan ke dalam repositori read-only. Jika tidak, maka pengguna diminta untuk memperbaiki konflik gabungan yang muncul dengan memperbarui dan menggabungkannya untuk diri mereka sendiri secara lokal.

• Setiap pengguna dapat memiliki klon pribadi dari repositori mereka sendiri.

  Praktik yang baik adalah menarik dari klon publik mereka, tetapi tidak masalah jika mereka menarik dari publik mereka atau integrator. Semua komit dapat diidentifikasi secara unik sehingga menggabungkan komit yang Anda lupa untuk ambil di publik yang relatif mudah untuk diperbaiki (dengan mendorong perubahan dari privat ke publik, secara otomatis mendapat perubahan integrator juga).

Organisasi kode sumber

Seperti cara mengatur sumber proyek itu sendiri adalah sesuatu yang perlu Anda pikirkan. Jika suatu artefak perlu dikendalikan sumbernya maka taruh dalam kendali sumber. Secara pribadi saya tidak suka ide memeriksa artefak yang dibuat oleh build atau runtime (karena risiko tinggi konflik penggabungan pada jenis artefak ini) seperti biner atau file log.

Anda juga dapat memeriksa konfigurasi, selama memungkinkan pengembang untuk melanjutkan dan tidak mengacaukan konfigurasi untuk rilis atau lingkungan live / produksi (seperti pengaturan aplikasi / server web). Ini mengarah pada anggapan bahwa jika konfigurasi yang Anda lakukan secara serius menghambat pengembang untuk memulai dalam waktu lima menit setelah mereka memeriksa kode, maka itu perlu dilakukan refactored. Persyaratan lain adalah harus sangat sulit bagi pengembang untuk mengacaukan rilis atau lingkungan live / produksi.

Anda menyebutkan bahwa Anda memiliki data uji yang perlu dikaitkan dengan beberapa versi kode. Sekarang ini sedikit rumit karena sistem-DVCS seperti Mercurial dan Git memiliki kecenderungan untuk menjadi lambat ketika Anda memeriksa data yang BESAR. Dalam pengalaman saya itu menjadi sangat tak tertahankan setelah 5 GB file biner (jarak tempuh Anda mungkin berbeda, jadi Anda harus menguji cara kerjanya untuk Anda). Namun saya akan merekomendasikan agar Anda memasukkan data yang dihasilkan ke dalam repositori itu sendiri dan meminta sistem pengujian Anda untuk menandainya dengan benar saat memeriksanya (dan / atau membuat file teks untuk tujuan data meta yang sama).

Saya harap ini semua masuk akal. Berikan komentar di bawah jika saya melewatkan beberapa detail atau jika ada sesuatu yang perlu dijelaskan lebih lanjut dan saya akan mencoba mengedit.