Ne'iyi bir şekilde Mercurial paylaşılan bağımlılıkları ile projeler yapmayı?

Şu anda, eski bir sürüm kontrol sistemi taşıma ve mercurial için benim grup projesi taşınıyorum. Taşınıyorum kodu tür bir örnek olarak, 25 proje Visual Studio çözüm, tüm ortak kodu kullanan birkaç ayrı uygulama alanları içeren var. Taşma, bulduğum en yakın soru Yığını üzerinden bana bakıyordu sadece sürüm kontrol bahsetti ama this one,. Biraz daha fazla tavsiye, Mercurial, bu bağımlılıkları yönetmek için kullanarak özel uygulama teknikleri üzerine arıyorum.

Bağımlılıklar basitleştirilmiş bir görünümü aşağıdaki gibidir. (Bu resimde ve örnek içindir; gerçek bağımlılıkları önemli ölçüde daha karmaşık ama doğada benzer.)

                     Common Lib 1
                    /      |      \
                ----       |       -----   
               /           |        \   \
            App 1    Common Lib 2    \ App 2
                       /   |   \      \
                -------    |    ------ |
               /           |          \|
             App 3       App 4      App 5

Ortak Lib modülleri kod paylaşılacak - bu tüm uygulamaları aynı anda - derleme ikisi arasında kullanılan bir DLL veya başka bir kütüphane ve çalışma zamanı. Uygulamalar yoksa birbirinden bağımsız olarak çalıştırmak mümkün olacak.

Mercurial benim depoları kurma ile birkaç hedefim var:

Önemli uygulama veya bileşen grubu, her biri kendi depo ver.
Her depo kendi kendine yeten olun.
Proje öz toplamı içeriyordu.
Kolay tüm kod temeli aynı anda inşa etmek için yapmak. (sonunda, tüm bu programlar ve kütüphaneler tek bir yükleyici.)
Basit tutun.

Bir diğer nokta bir server bu projelerin her biri için ayrı havuzları var nereye kurdunuz.

Bu projeleri dışarı atarak birkaç şekilde görüyorum.

1. Bir "" depoyu içeren her şey. Kabuk oluşturmak

Bu (örneğin,. url tabanlı subrepos kullanmak istiyorsunuz hgsub,*. *4 gibi bir şey yaparım) Düzenlendiği, aşağıdaki gibi görünecektir:

 --------------------------- 
| Main Repository           |
| |  ---------------------  |
|  -| Build               | |
| |  ---------------------  |
| |  ---------------------  |
|  -| Common Lib 1        | |
| |  ---------------------  |
| |  ---------------------  |
|  -| Common Lib 2        | |
| |  ---------------------  |
| |  ---------------------  |
|  -| App 1               | |
| |  ---------------------  |
| |  ---------------------  |
|  -| App 2               | |
| |  ---------------------  |
| |  ---------------------  |
|  -| App 3               | |
| |  ---------------------  |
| |  ---------------------  |
|  -| App 4               | |
| |  ---------------------  |
| |  ---------------------  |
|  -| App 5               | |
|    ---------------------  |
 ---------------------------

Kabuk depodaki her ana klasör subrepo, her bir proje alanı için bir içerir. Bağımlılıklar yüklü olmalıdır: Örneğin, App beri 4 ihtiyacı Lib Ortak 2, ortak kütüphane sadece başvuru için göreli yolları kullanır.

Bu yaklaşımın artıları:

Her kütüphane kez ve yalnızca bir kez aşağı çekti.
Mercurial var subreos kütüphane aynı sürümünü bu subrepo tek bir sürümünü proje var olduğundan tüm proje boyunca otomatik olarak kullanılır sağlayacaktır.
Kolay, her kaynak bulmak kolay değil.

Bu yaklaşımın eksileri:

Bir Uygulama üzerinde bağımsız olarak çalışamıyorum. Eğer ortak kütüphanelere değişmesi lazım 2 ve Uygulaması üzerinde çalışıyorum eğer örneğin, diğer uygulamalar tüm bu değişiklikleri hemen kabul etmek zorunda kalacaksınız.
Eğer kendisi tarafından Uygulama repo çekersem, eğer bunu kurmak istiyorum diğer bağımlı repo elle ne gerektirir (veya bilmek) bir yolunu bulmam lazım.
Bağımlılıklar güçlü bir şekilde ayrılmış değil - kolay tüm özelliklerini elde etmek için bu yana yeni bir özellik herhangi bir yerde eklemek için cazip olabilir.

2. Bağımlı subrepos tamamen alır.

Bu yaklaşımda, her uygulama kendi depo (önceki gibi) ama bu sefer de subrepositories içerir: kendi kaynak ve her bağımlı depo için. Genel bir depo daha sonra bu proje depoların her içerir ve tüm çözüm yapmayı bilir. Bu aşağıdaki gibi görünecektir:

 ----------------------------------------------------------------------- 
| Main Repository                                                       |
|  --------------------   --------------------   --------------------   |
| | Build              | | Common Lib 1       | | Common Lib 2       |  |
|  --------------------  | |  --------------  | | |  --------------  |  |
|                        |  -| Lib 1 Source | | |  -| Common Lib 1 | |  |
|                        |    --------------  | | |  --------------  |  |
|                        |                    | | |  --------------  |  |
|                        |                    | |  -| Lib 2 Source | |  |
|                        |                    | |    --------------  |  |
|                         --------------------   --------------------   |
|  --------------------   --------------------   ---------------------  |
| | App 1              | | App 2              | |  App 3              | |
| | |  --------------  | | |  --------------  | |  |  --------------  | |
| |  -| Common Lib 1 | | |  -| Common Lib 1 | | |   -| Common Lib 2 | | |
| | |  --------------  | | |  --------------  | |  |  --------------  | |
| | |  --------------  | | |  --------------  | |  |  --------------  | |
| |  -| App 1 Source | | |  -| App 2 Source | | |   -| App 3 Source | | |
| |    --------------  | |    --------------  | |     --------------  | |
|  --------------------   --------------------   ---------------------  |
|  --------------------   --------------------                          |
| | App 4              | | App 5              |                         |
| | |  --------------  | | |  --------------  |                         |
| |  -| Common Lib 2 | | |  -| Common Lib 1 | |                         |
| | |  --------------  | | |  --------------  |                         |
| | |  --------------  | | |  --------------  |                         |
| |  -| App 4 Source | | |  -| Common Lib 2 | |                         |
| |    --------------  | | |  --------------  |                         |
|  --------------------    |  --------------  |                         |
|                        |  -| App 5 Source | |                         |
|                        |    --------------  |                         |
|                         --------------------                          |
 -----------------------------------------------------------------------

Artıları:

Her uygulama kendisi tarafından, birbirinden bağımsız olarak inşa edilebilir.
Kitaplıkları bağımlı sürümleri başına uygulaması, genel yerine izlenebilir. Proje, yeni bir bağımlılık eklemek için bir subrepo ekleme açık bir hareket alır.

Eksileri:

Son inşa yaparken, her uygulama paylaşılan bir kütüphane farklı bir sürümünü kullanıyor olabilir. (belki araçları yazmak için sync ortak lib subrepos. Eww.)
Eğer tüm kaynak sağlamak istiyorsam, paylaşılan kitaplıkları birden çok kez aşağı çekerek bitirmek istiyorum. 1, koparmak isterdim Ortak Lib sekiz durumda (!) kere.

3. Bağımlılıkları hiç subrepos olarak vardır - onları inşa parçası olarak getirmezler.

Bu yaklaşım, ortak kütüphaneler sadece yapı parçası olarak çekilecek dışında 1, yaklaşım gibi görünüyor. Her uygulaması gereken ne bilmiyorum, ve ortak bir konumda koyun.

Artıları:

Her uygulama kendisi tarafından inşa edebilir.
Ortak kütüphaneler sadece bir kez çekilmiş olması gerekir.

Eksileri:

Kütüphaneler şu anda her uygulama tarafından kullanılan sürümleri takip etmek zorunda kalırız. Bu subrepo özellikleri çoğaltır.
Daha fazla şeyler inşa komut girmek anlamına gelen bu destek için bir altyapı inşa etmek zorundayız. Ugh.

4. Başka ne var?

İdare başka bir yolu var mı? Daha iyi bir yolu? Yolu denedi ve başarılı oldu, ne yollar denedim ama nefret etmiş ne var? Ama emin olmak için ne zaman başvuru bağımsızlık eksikliği 1, beni gerçekten rahatsız ediyor şu anda doğru eğilmiş değilim. Bir şekilde işlemek için komut dosyaları (seçenek 3 gibi) yazmak zorunda kalmadan kod çekme ve bağımlılık bakım kabus masif yinelenen olmadan yöntem 2 güzel ayrılık olsun, var mı?

CEVAP

17 Mayıs 2011, Salı

Bağımlılıkları yönetimi proje organizasyonu, gözlerim için önemli bir yönüdür. Harika detayları, farklı çözümler, subrepos özelliği Mercurial dayalı gösterdiğiniz ve verdiğiniz eksileri/artıları katılıyorum.

SCMs bağımlılıkları yönetimi için uygun değil bence. Bunun için özel bir araç (bu çözümünüz°3 n) olması tercih ederim.

Benim şimdiki proje Java. Apache Ant ve ben ilk bağımlılıkları yönetim aracı olarak Apache Ivy set ile inşa edilmiştir. Sonunda, Kur paylaşılan bir dizinde, bazı Ivy yapılandırma dosyaları oluşuyordu, ve bir XML projenin her bir modül bağımlılıklarını Listeleme dosyası. Ivy her modül iki yeni eylemler ekledim Karınca hedefleri tarafından çağrılan olabilir : "bağımlılıklar" ve "" dağıtmak. inşa eseri gidermek Dağıtım paylaşılan dizin buid (obje adı) sonucu ekler. Bağımlılıklar çözünürlük demek geçişli modül bağımlılıkları çözümleniyor ve çözülmüş eserler kopyalama "lib" modülünün kaynaklarında.

Ivy Java bağımlılıkları yönetmek için özel olduğundan bu çözüm C bir proje için geçerlidir : eserler herhangi bir şey olabilir. C , eserler bir modül tarafından üretilen olacaktır :

o yüzden zamanında bir dll
başlık derleme zamanında dosyaları.

Bu mükemmel bir çözüm: Sarmaşık değil kolay kurulum, hala söylemek zorunda inşa script ne bağımlılıkları ve yok doğrudan erişim için kaynakların bağımlılıklar için hata ayıklama amaçlı. Ama bağımsız SCM depoları ile sona erecek.

Projemizde, biz o yapı ve bağımlılıkları yönetimini önemser Apache Maven, form Karınca Ivy geçti. Eserler paylaşılan bir klasör yerine Apache Archiva bir görev. Bu büyük bir gelişmedir, ama iyi Java projeleri için sadece çalışacak.

Bunu Paylaş: