गिट में, एक दर्जन पुस्तकालयों के लिए संस्करण कैसे करना है, सभी समानांतर में काम करते थे


11

हम परियोजनाएं कर रहे हैं, लेकिन हम परियोजनाओं के बीच बहुत सारे कोड का पुन: उपयोग करते हैं और बहुत सारे पुस्तकालय हैं जिनमें हमारा सामान्य कोड है। जैसा कि हम नई परियोजनाओं को लागू करते हैं, हम सामान्य कोड को बाहर करने और पुस्तकालयों में डालने के लिए और अधिक तरीके ढूंढते हैं। पुस्तकालय एक-दूसरे पर निर्भर करते हैं, और परियोजनाएँ पुस्तकालयों पर निर्भर करती हैं। प्रत्येक परियोजना, और उस परियोजना में उपयोग किए जाने वाले सभी पुस्तकालय, उन सभी पुस्तकालयों के समान संस्करण का उपयोग करने की आवश्यकता होती है, जिनका वे उल्लेख कर रहे हैं। यदि हम एक सॉफ्टवेयर जारी करते हैं तो हमें बग को ठीक करना होगा और हो सकता है कि कई वर्षों तक, कभी-कभी दशकों तक नई सुविधाएँ जोड़ें। हमारे पास लगभग एक दर्जन पुस्तकालय हैं, परिवर्तन अक्सर दो से अधिक में कटौती करते हैं, और कई टीमें समानांतर में कई परियोजनाओं पर काम करती हैं, जिससे इन सभी पुस्तकालयों में समवर्ती परिवर्तन होते हैं।

हमने हाल ही में प्रत्येक पुस्तकालय और प्रत्येक परियोजना के लिए git और repositories स्थापित किया है। हम एक सामान्य भंडार के रूप में उपयोग करते हैं, फीचर शाखाओं पर नया सामान बनाते हैं, फिर पुल अनुरोध करते हैं और समीक्षा के बाद ही उन्हें मर्ज करते हैं।

परियोजनाओं में हमें जिन मुद्दों से निपटना पड़ता है, उनमें से कई हमें कई पुस्तकालयों और परियोजना के विशिष्ट कोड में परिवर्तन करने की आवश्यकता होती है। इनमें अक्सर पुस्तकालय इंटरफेस के परिवर्तन शामिल होते हैं, जिनमें से कुछ असंगत होते हैं। (यदि आपको लगता है कि यह गड़बड़ लगता है: हम हार्डवेयर के साथ इंटरफेस करते हैं, और जेनेरिक इंटरफेस के पीछे विशिष्ट हार्डवेयर छिपाते हैं। लगभग हर बार जब हम कुछ अन्य वेंडर के हार्डवेयर को एकीकृत करते हैं, तो हम उन मामलों में भाग लेते हैं जो हमारे वर्तमान इंटरफेस का अनुमान नहीं था, और इसलिए उन्हें परिष्कृत करना होगा।) उदाहरण के लिए, एक परियोजना की कल्पना P1लाइब्रेरी का उपयोग कर L1, L2और L3L1उपयोग भी करता है L2और L3, और L2उपयोग भी करता है L3। निर्भरता ग्राफ इस तरह दिखता है:

   <-------L1<--+
P1 <----+  ^    |
   <-+  |  |    |
     |  +--L2   |
     |     ^    |
     |     |    |
     +-----L3---+

अब इस परियोजना के लिए एक विशेषता की कल्पना करें P1और इसमें L3किस परिवर्तन की आवश्यकता है L3। अब परियोजनाओं P2और P3मिश्रण में जोड़ें , जो इन पुस्तकालयों को भी संदर्भित करता है। हम उन सभी को नए इंटरफ़ेस में बदलने, सभी परीक्षण चलाने और नए सॉफ़्टवेयर को तैनात करने का जोखिम नहीं उठा सकते। तो विकल्प क्या है?

  1. में नया इंटरफ़ेस लागू करें L3
  2. के लिए एक पुल अनुरोध L3करें और समीक्षा के लिए प्रतीक्षा करें
  3. परिवर्तन को मर्ज करें
  4. की एक नई रिलीज़ बनाएँ L3
  5. इस सुविधा को नई रिलीज़ के P1संदर्भ में बनाकर काम करना शुरू करें L3, फिर P1फ़ीचर की सुविधा शाखा पर लागू करें
  6. एक पुल अनुरोध करें, इसकी समीक्षा करें और विलय कर दें

(मैंने अभी देखा कि मैं स्विच करना भूल गया L1और L2नई रिलीज़ के लिए। और मुझे यह भी नहीं पता है कि मुझे यह कहाँ रहना है, क्योंकि इसे समानांतर में करने की आवश्यकता होगी P1...)

यह एक थकाऊ, त्रुटि-प्रवण, और इस सुविधा को लागू करने के लिए बहुत लंबी प्रक्रिया है, इसके लिए स्वतंत्र समीक्षा की आवश्यकता होती है (जिसकी समीक्षा करना बहुत कठिन है), बिल्कुल भी पैमाने पर नहीं है, और हमें व्यापार से बाहर करने की संभावना है क्योंकि हम इस प्रक्रिया में इतना घिर जाना कि हमें कभी कुछ नहीं करना है।

लेकिन हम बहुत अधिक उपरि के बिना नई परियोजनाओं में नई सुविधाओं को लागू करने की अनुमति देने वाली प्रक्रिया बनाने के लिए ब्रांचिंग और टैगिंग को कैसे नियोजित करते हैं?


1
आपके टूलिंग को बदलने से आपके द्वारा बहुत अधिक की जाने वाली प्रक्रियाओं को प्रभावित नहीं होना चाहिए। तो, आप कैसे स्विच करने से पहले इस समस्या से निपट रहे थे?
बार्ट वैन इनगेन शेनौ

क्या यह संभव है कि किसी मौजूदा को तोड़े बिना इंटरफ़ेस पर एक नई विधि को जोड़ा जाए जब बहुत सारे पुस्तकालय इस पर निर्भर होते हैं? आम तौर पर यह सबसे अच्छा विचार नहीं है, लेकिन कम से कम यह आपको नई सुविधा को लागू करने के साथ "चालू" करने देता है और जब भी कोई खाली पल होता है तो आप पुरानी पद्धति को ठीक से चित्रित कर सकते हैं। या फिर ये इंटरफेस "समानांतर इंटरफेस" के लिए बहुत अधिक स्टेटफुल हैं जैसे कि काम करने के लिए?
Ixrec

1
@Ixrec: मुझे बताया गया कि "यह काम करने का तरीका नहीं है"। प्रत्येक व्यक्ति अलग-अलग परियोजनाओं के लिए अलग-अलग रिपॉजिटरी का उपयोग करता है, इसलिए यह निर्णय लिया गया कि हम भी ऐसा करते हैं।
sbi

2
मैं तर्क दूंगा कि वे अलग-अलग परियोजनाएं नहीं हैं, अगर उन्हें अक्सर मिलकर बदलना पड़ता है। "प्रोजेक्ट्स" के बीच की सीमाओं में हमेशा किसी न किसी प्रकार की लंबी अवधि की पश्चगामी संगतता की गारंटी होनी चाहिए।
Ixrec

1
@Ixrec: अधिक हार्डवेयर का एकीकरण कोड को अधिक प्लेटफ़ॉर्म पर पोर्ट करने के समान है: जितना अधिक आपने यह किया है, उतना कम आपको किसी अन्य हार्डवेयर / प्लेटफ़ॉर्म के लिए बदलने की आवश्यकता है। इसलिए लंबे समय में, कोड स्थिर हो जाएगा। हालाँकि, अभी हमें एक ऐसी प्रक्रिया खोजने की आवश्यकता होगी जो हमें बाजार में लंबे समय तक रहने की अनुमति दे सके।
sbi

जवाबों:


5

यहाँ स्पष्ट बाहर डालने की तरह है, लेकिन शायद यह उल्लेख के लायक है।

आमतौर पर, git repos प्रति lib / प्रोजेक्ट के अनुरूप होते हैं क्योंकि वे स्वतंत्र होते हैं। आप अपनी परियोजना को अद्यतन करते हैं, और बाकी की परवाह नहीं करते हैं। इसके आधार पर अन्य परियोजनाएं, जब भी वे फिट दिखेंगी, बस अपने काम को अद्यतन करेंगी।

हालाँकि, आपका मामला सहसंबंधित घटकों पर अत्यधिक निर्भर करता है, जिससे कि एक विशेषता आमतौर पर उनमें से कई को प्रभावित करती है। और पूरे को बंडल के रूप में पैक किया जाना है। चूंकि एक सुविधा / परिवर्तन / बग को लागू करने के लिए अक्सर कई अलग-अलग पुस्तकालयों / परियोजनाओं को एक साथ अनुकूलित करने की आवश्यकता होती है, शायद यह उन सभी को एक ही रेपो में डालने के लिए समझ में आता है।

इसके लिए मजबूत फायदे / कमियां हैं।

लाभ:

  • ट्रेसबिलिटी: ब्रांच इस प्रोजेक्ट / बग से संबंधित हर प्रोजेक्ट / लिब में सब कुछ बदल कर दिखाता है।
  • बंडलिंग: बस एक टैग चुनें, और आपको सभी स्रोत सही मिलेंगे।

कमियां:

  • विलय: ... यह कभी-कभी एक ही परियोजना के साथ पहले से ही कठिन है। साझा शाखाओं पर काम करने वाली विभिन्न टीमों के साथ, प्रभाव के लिए तैयार होने के लिए तैयार रहें।
  • खतरनाक "उफ़" कारक: यदि कोई कर्मचारी कुछ गलती करके रिपॉजिटरी को गड़बड़ करता है, तो यह सभी परियोजनाओं और टीमों को प्रभावित कर सकता है ।

यह जानना आपके ऊपर है कि क्या कीमत लाभ के लायक है।

संपादित करें:

यह इस तरह काम करेगा:

  • फ़ीचर X को लागू किया जाना चाहिए
  • शाखा बनाएँ feature_x
  • सभी डेवलपर्स इस शाखा में काम करते हैं और इस पर काम करते हैं, शायद अपनी परियोजना / परिवाद से संबंधित समर्पित निर्देशिकाओं में
  • एक बार जब यह खत्म हो जाए, तो इसकी समीक्षा करें, इसका परीक्षण करें, इसे पैकेज करें, जो भी हो
  • इसे मास्टर में वापस मर्ज करें ... और इस बीच से यह कठिन हिस्सा हो सकता है feature_yऔर feature_zइसमें भी जोड़ा जा सकता है। यह एक "क्रॉस-टीम" मर्ज हो जाता है। यही कारण है कि यह एक गंभीर खामी है।

सिर्फ रिकॉर्ड के लिए: मुझे लगता है कि यह ज्यादातर मामलों में एक बुरा विचार है और इसे सावधानी से किया जाना चाहिए क्योंकि मर्ज की खामी आमतौर पर निर्भरता प्रबंधन / उचित सुविधा ट्रैकिंग के माध्यम से आपको प्राप्त होने की तुलना में अधिक होती है।


धन्यवाद, हम वास्तव में इस समय देख रहे हैं। इस के प्रकाश में मुझे समझ में नहीं आ रहा है कि हम कैसे गिट के साथ शाखा करेंगे। एसवीएन में, ब्रांचिंग का मतलब एक सबट्री (रिपॉजिटरी में) को कहीं और (रिपॉजिटरी में) कॉपी करना है। इसके साथ, आपके रेपो में किसी भी सबट्री की शाखाएं बनाना आसान है, इसलिए यदि आपके पास वहाँ कई परियोजनाएं हैं, तो आप उनमें से प्रत्येक को अलग-अलग शाखा कर सकते हैं। क्या गिट में ऐसा कुछ है, या हम हमेशा केवल एक पूरे रेपो को ही सक्षम कर पाएंगे?
sbi

@ एसबीआई: आप पूरे रेपो को शाखा देंगे। आप विभिन्न शाखाओं में उपप्रकार के साथ काम नहीं कर सकते हैं, जो आपके मामले में बिंदु को हराने का काम करेगा। हालांकि यह कुछ भी "कॉपी" नहीं करेगा, यह केवल उस शाखा के परिवर्तनों को ट्रैक करेगा जिस पर आप काम कर रहे हैं।
डेगनलीज

तो इसके लिए किसी को लाइब्रेरी के लिए एक सुविधा शाखा बनाने की आवश्यकता होती है, जो विलय या रीबासिंग करते समय अन्य सभी को भी मर्ज कर दे। यह एक वास्तविक दोष है। (बीटीडब्ल्यू, एसवीएन भी केवल आलसी प्रतियां ही करता है।)
एसबीआई

@ एसबीआई: संपादित देखें
dagnelies

1
खैर, वर्तमान में हम में से अधिकांश आरामदायक नहीं हैं। :-/क्या अधिक है, यहां तक ​​कि जो लोग हैं (और जो चाल के लिए धक्का दिया), पता नहीं कैसे हमारी विकास प्रक्रिया को फिट के साथ फिट किया जाए। आह। यह कुछ कठिन महीने होने जा रहे हैं, मुझे डर है, जब तक कि चीजें चिकनी नहीं होने लगती हैं। वैसे भी धन्यवाद, तुम्हारा अब तक का सबसे अधिक / केवल सहायक उत्तर है।
sbi

4

आप जिस समाधान की तलाश कर रहे हैं वह गिट सबमॉड्यूल के साथ समन्वय में एक निर्भरता प्रबंधन उपकरण है

उपकरण जैसे:

  • Maven
  • चींटी
  • संगीतकार

आप किसी प्रोजेक्ट की निर्भरता को परिभाषित करने के लिए उन उपकरणों का उपयोग कर सकते हैं।

आपको कम से कम संस्करण > 2.xx के लिए एक सबमॉड्यूल की आवश्यकता हो सकती है या ऐसे संस्करणों की एक श्रृंखला को निरूपित कर सकते हैं जो संगत = 2.2 हैं। * या किसी विशेष संस्करण से कम <2.2.3।

जब भी आप किसी एक पैकेज का नया संस्करण जारी करते हैं तो आप उसे संस्करण संख्या के साथ टैग कर सकते हैं, इस तरह आप कोड के उस विशिष्ट संस्करण को अन्य सभी परियोजनाओं में खींच सकते हैं।


लेकिन निर्भरता प्रबंधन हमारी समस्या नहीं है, यह हल है। वर्तमान में हम नियमित रूप से कई पुस्तकालयों में बदलाव करते हैं और स्थिर परियोजना रिलीज़ को बनाए रखते हुए नए संस्करण बनाने के ओवरहेड को कम करने की आवश्यकता है। आपका उत्तर इस बात का समाधान नहीं देता है।
sbi

@sbi यह नए संस्करण बनाने और स्थिर परियोजना रिलीज को बनाए रखने के ओवरहेड का प्रबंधन करेगा। चूँकि आप प्रोजेक्ट x संस्करण 2.1.1 पर निर्भर करते हुए प्रोजेक्ट x पर निर्भर कर सकते हैं, आप प्रोजेक्ट y के नए संस्करण बना सकते हैं जो प्रोजेक्ट x को प्रभावित नहीं करेंगे।
पैट्रिक

फिर से, निर्भरता की घोषणा करना हमारी समस्या नहीं है। यह हम पहले से ही कर सकते हैं। समस्या यह है कि एक कुशल तरीके से कई परियोजनाओं / पुस्तकालयों में परिवर्तन को कैसे प्रबंधित किया जाए। आपका उत्तर यह समझाने में विफल रहता है।
sbi

@ एसएसबी: तो वास्तव में आपका मुद्दा क्या है? आप अपने परिवर्तन करते हैं, संस्करण को टक्कर देते हैं, जहां निर्भरता की आवश्यकता होती है, और वॉइला को अपडेट करते हैं। आपने अपनी प्रारंभिक पोस्ट में जो बताया वह विशिष्ट मावेन और सह है। सामान। प्रत्येक वितरण स्पष्ट रूप से परिभाषित संस्करण लिबास पर आधारित है। यह अधिक स्पष्ट कैसे हो सकता है?
डेगनेलिस

@ हरनौद: तीन या अधिक परतों के माध्यम से इस तरह की प्रक्रिया के लिए टर्नअराउंड समय (वर्तमान में आम है) के काटने से परिवर्तन होता है। मुझे लगा कि मेरे प्रश्न का वर्णन किया गया है।
sbi

0

submodules

आपको एक टिप्पणी में सुझाए गए अनुसार सबमोडुल्स को प्रस्तुत करने का प्रयास करना चाहिए ।

जब प्रोजेक्ट P1तीन सबमॉडल्स को संदर्भित करता है L1, L2और L3, यह वास्तव में सभी तीन रिपॉजिटरी में विशेष रूप से कमिट्स के लिए एक संदर्भ संग्रहीत करता है: वे उस प्रोजेक्ट के लिए प्रत्येक लाइब्रेरी के वर्किंग संस्करण हैं ।

इसलिए कई परियोजनाएँ कई सबमॉड्यूल्स के साथ काम कर P1सकती हैं : लाइब्रेरी के पुराने संस्करण को संदर्भित कर सकती हैं L1जबकि प्रोजेक्ट P2नए संस्करण का उपयोग करता है।

जब आप नया संस्करण देते हैं तो क्या होता है L3?

  • में नया इंटरफ़ेस लागू करें L3
  • प्रतिबद्ध, परीक्षण , पुल अनुरोध करें, समीक्षा करें, मर्ज करें, ... (आप इससे बच नहीं सकते)
  • सुनिश्चित करने के L2साथ काम करता है L3, प्रतिबद्ध, ...
  • L1नए के साथ काम सुनिश्चित करता है L2, ...
  • P1सभी पुस्तकालयों के नए संस्करणों के साथ काम करना सुनिश्चित करें :
    • अंदर P1की स्थानीय कार्य प्रतिलिपि L1, L2और L3, उन परिवर्तनों को प्राप्त करें जिनकी आप रुचि रखते हैं।
    • git add L1 L2 L3मॉड्यूल के लिए नए संदर्भ के लिए , परिवर्तन करें
    • पुल के लिए अनुरोध P1, परीक्षण, समीक्षा, पुल अनुरोध, मर्ज ...

क्रियाविधि

यह एक थकाऊ, त्रुटि-प्रवण, और इस सुविधा को लागू करने के लिए बहुत लंबी प्रक्रिया है, इसके लिए स्वतंत्र समीक्षा की आवश्यकता होती है (जिसकी समीक्षा करना बहुत कठिन है), बिल्कुल भी पैमाने पर नहीं है, और हमें व्यापार से बाहर करने की संभावना है क्योंकि हम प्रक्रिया में इतना घिर जाना कि हमें कभी कुछ नहीं करना है।

हां, इसके लिए स्वतंत्र समीक्षाओं की आवश्यकता है , क्योंकि आप बदलते हैं:

  • पुस्तकालय
  • पुस्तकालय जो इस पर निर्भर करते हैं
  • परियोजनाएँ जो कई पुस्तकालयों पर निर्भर करती हैं

क्या आपको व्यापार से बाहर रखा जाएगा क्योंकि आप बकवास करते हैं? (शायद नहीं, वास्तव में)। यदि हाँ, तो आपको परीक्षण करने और परिवर्तनों की समीक्षा करने की आवश्यकता है।

उपयुक्त गिट टूल्स (यहां तक ​​कि gitk) के साथ, आप आसानी से देख सकते हैं कि प्रत्येक परियोजना में पुस्तकालयों के कौन से संस्करण उपयोग करते हैं, और आप अपनी आवश्यकताओं के अनुसार उन्हें स्वतंत्र रूप से अपडेट कर सकते हैं। सबमॉड्यूल्स आपकी स्थिति के लिए एकदम सही हैं और आपकी प्रक्रिया को धीमा नहीं करेगा।

हो सकता है कि आप इस प्रक्रिया का हिस्सा स्वचालित करने का एक तरीका पा सकते हैं , लेकिन ऊपर दिए गए अधिकांश चरणों में मानव दिमाग की आवश्यकता होती है। समय काटने का सबसे प्रभावी तरीका यह सुनिश्चित करना होगा कि आपके पुस्तकालयों और परियोजनाओं को विकसित करना आसान है। यदि आपका कोडबेस नई आवश्यकताओं को इनायत से संभाल सकता है, तो कोड समीक्षा सरल हो जाएगी और आपका कम समय लेगी।

(संपादित करें) एक और चीज़ जो आपको संबंधित कोड समीक्षाओं को समूह बनाने में मदद कर सकती है। आप सभी परिवर्तन करते हैं और तब तक प्रतीक्षा करते हैं जब तक कि आप उन परिवर्तनों को उन सभी पुस्तकालयों और परियोजनाओं के लिए प्रचारित न कर दें, जो पुल अनुरोधों (या इससे पहले कि आप उनकी देखभाल करते हैं) का उपयोग करने से पहले उनका उपयोग करें। आप पूरी निर्भरता श्रृंखला के लिए एक बड़ी समीक्षा कर रहे हैं। यदि प्रत्येक स्थानीय परिवर्तन छोटा है तो शायद यह आपको समय बचाने में मदद कर सकता है।


आप वर्णन करते हैं कि निर्भरता की समस्या को कैसे हल किया जाए (जो, जैसा कि मैंने पहले कहा है, हमने हल कर लिया है) और हमारे पास जो समस्या है, उसे नकार दें। तुम भी क्यों परेशान करते हो? (एफडब्ल्यूआईडब्ल्यू, हम सॉफ्टवेयर लिखते हैं जो बिजली संयंत्रों को चलाता है। स्वच्छ, सुरक्षित, और अच्छी तरह से समीक्षा की गई कोड एक प्रमुख विशेषता है।)
sbi

@ एसबी क्या सबमॉड्यूल हैं यदि ब्रांचिंग और टैगिंग का विशेष मामला नहीं है? आपको लगता है कि सबमॉड्यूल निर्भरता प्रबंधन के बारे में हैं, क्योंकि वे भी निर्भरता का ट्रैक रखते हैं। लेकिन निश्चित रूप से, यदि आप चाहते हैं, तो मुझे कोई आपत्ति नहीं है, कृपया टैग्स के साथ सबमॉड्यूल को फिर से मजबूत करें। मैं आपकी समस्या को नहीं समझता: यदि समीक्षा की गई कोड एक प्रमुख विशेषता है, तो आपके समीक्षाओं के लिए कुछ समय का बजट होना चाहिए। आप नीचे नहीं हैं, आप आप पर लगाए गए बाधाओं के साथ जितनी जल्दी हो सके चले जाते हैं।
coredump

समीक्षा हमारे लिए बहुत महत्वपूर्ण हैं। यही कारण है कि हम एक मुद्दे (और इसकी समीक्षाओं) के बारे में चिंतित हैं, जो कई रिपॉजिटरी में कई परिवर्तनों के लिए कई समीक्षाओं में विभाजित हो रहे हैं। इसके अलावा हम एक मुद्दे पर हमें मौत के लिए प्रशासित करने के लिए नहीं चाहते हैं कि हम समय लिखने और समीक्षा कोड खर्च करना चाहते हैं। रे सबमॉड्यूल्स: अब तक, केवल एक चीज जो मैंने उनके बारे में सुना है वह है "परेशान मत करो, यह रास्ता नहीं है"। ठीक है, यह देखते हुए कि हमारी आवश्यकताएं इतनी अनोखी हैं, शायद हमें इस निर्णय पर फिर से विचार करना चाहिए ...
sbi

0

तो जो मैं समझता हूं कि आप पी 1 के लिए हैं आप एल 3 इंटरफेस बदलना चाहते हैं, लेकिन आप अन्य पी 2 और पी 3 चाहते हैं जो तुरंत बदलने के लिए एल 3 इंटरफेस पर निर्भर हैं। यह पिछड़े अनुकूलता का एक विशिष्ट मामला है। इस संरक्षित पिछड़े संगतता पर एक अच्छा लेख है

इसे हल करने के कई तरीके हैं:

  • आपको हर बार नए इंटरफेस बनाने होंगे जो पुराने इंटरफेस को बढ़ा सकते हैं।

या

  • यदि आप कुछ समय के बाद पुराने इंटरफ़ेस को रिटायर करना चाहते हैं, तो आपके पास इंटरफेस के कई संस्करण हो सकते हैं और एक बार सभी आश्रित परियोजनाएं आपके पुराने इंटरफेस को हटा देती हैं।

1
नहीं, बैकवर्ड संगतता रिलीज शाखाओं के माध्यम से सुनिश्चित की जाती है और हमारी समस्या नहीं है। समस्या यह है कि हम वर्तमान में तेजी से बदलते हुए कोडबेस पर बैठते हैं, जो गीला अब पुस्तकालयों में अलग होना चाहते हैं, इस तथ्य के बावजूद कि इंटरफेस अभी भी उस चरण में हैं जहां वे अक्सर बदलते हैं। मुझे पता है कि एसवीएन में ऐसे जानवरों का प्रबंधन कैसे किया जाता है, लेकिन यह नहीं पता कि प्रशासन में डूबे बिना कैसे किया जाए।
sbi

0

अगर मुझे आपकी समस्या सही लग रही है:

  • आपके 4 इंटर-संबंधित मॉड्यूल हैं, पी 1 और एल 1 से एल 3
  • आपको P1 में परिवर्तन करने की आवश्यकता है जो अंततः L1 से L3 को प्रभावित करेगा
  • यदि आपको सभी 4 को एक साथ बदलना है तो यह एक प्रक्रिया विफलता के रूप में गिना जाता है
  • यह एक प्रक्रिया विफलता के रूप में गिना जाता है यदि आपको उन सभी को 1 से 1 बदलना है।
  • यह एक प्रक्रिया विफलता के रूप में गिना जाता है यदि आपको अग्रिम में उन चनों की पहचान करनी है जिनमें परिवर्तन किए जाने हैं।

तो लक्ष्य यह है कि आप P1 और L1 को एक बार में कर सकते हैं, और फिर एक महीने बाद L2 और L3 को दूसरे में कर सकते हैं।

जावा दुनिया में, यह तुच्छ है, और शायद काम करने का डिफ़ॉल्ट तरीका:

  • सब कुछ एक रिपॉजिटरी में चला जाता है जिसमें ब्रांचिंग का कोई प्रासंगिक उपयोग नहीं होता है
  • मॉड्यूल संकलित + संस्करण संख्याओं के आधार पर मावेन द्वारा एक साथ जुड़े हुए हैं, इस तथ्य से नहीं कि सभी एक ही निर्देशिका ट्री में हैं।

तो आपके पास L3 के लिए आपकी स्थानीय डिस्क पर कोड हो सकता है जो संकलन नहीं करेगा यदि यह आपकी डिस्क पर अन्य निर्देशिका में P1 की प्रतिलिपि के खिलाफ संकलन कर रहा था; सौभाग्य से यह ऐसा नहीं कर रहा है। जावा सीधे तौर पर ऐसा कर सकता है क्योंकि संकलित जार फाइलों के खिलाफ कहानियों को संकलित / लिंक करना, स्रोत कोड नहीं।

मुझे C / C ++ दुनिया के लिए इस समस्या के लिए पहले से व्यापक रूप से उपयोग किए गए समाधान के बारे में पता नहीं है, और मुझे लगता है कि आप शायद ही भाषाओं को स्विच करना चाहते हों। लेकिन कुछ को आसानी से हैक किया जा सकता है साथ ही साथ मेक फाइल्स भी करें जो बराबर काम करती हैं:

  • एम्बेडेड संस्करण संख्या के साथ ज्ञात निर्देशिकाओं के लिए स्थापित लाइब्रेरी + हेडर
  • उचित संस्करण संख्याओं के लिए निर्देशिका में प्रति संकलक पथ बदले

आप मावेन में सी / सी ++ समर्थन का उपयोग भी कर सकते हैं , हालांकि यदि आपने किया तो अधिकांश सी डेवलपर्स आपको अजीब लगेंगे ...


"यह एक प्रक्रिया विफलता के रूप में गिना जाता है यदि आपको सभी 4 को एक साथ बदलना है" । वास्तव में यह नहीं होगा। वास्तव में, यह वही है जो हमने एसवीएन का उपयोग करके किया था।
sbi

जिस स्थिति में मुझे लगता है कि सभी परियोजनाओं को केवल भंडार में रखने से कोई समस्या नहीं है।
सोरू

अब हम पुस्तकालयों को केवल दो रिपॉजिटरी में डालने का मूल्यांकन कर रहे हैं। यह अभी भी एक से अधिक है, लेकिन "हर परियोजना के लिए एक" से बहुत कम है, और पुस्तकालयों को बहुत अच्छी तरह से दो समूहों में विभाजित किया जा सकता है। आपके सहयोग के लिए धन्यवाद!
sbi

पुनश्च: "मुझे लगता है कि आप शायद ही भाषाओं को स्विच करना चाहते हैं।" यह एम्बेडेड सामान है। :)
sbi

-1

एक सरल उपाय है: संपूर्ण रिपॉजिटरी में कट रिलीज शाखाएं, सभी फिक्सेस को सक्रिय रूप से शिप किए गए रिलीज में मर्ज करें (यह स्पष्ट है-केस में आसान होना चाहिए)।

सभी विकल्प समय के साथ और परियोजना के विकास के साथ एक भयानक गड़बड़ पैदा करेंगे।


क्या आप कृपया विस्तार से बता सकते हैं? मुझे यकीन नहीं है कि आप क्या सुझाव दे रहे हैं।
sbi

स्पष्ट स्थिति में आप एक शाखा-बिंदु को आधार शाखा और टाइमस्टैम्प के रूप में परिभाषित करते हैं। आपके पास पदानुक्रम है: आधार शाखा -> रिलीज़-डेवलपमेंट-शाखा -> निजी-विकास शाखा। सभी विकास निजी शाखाओं पर किया जाता है और फिर पदानुक्रम में विलय कर दिया जाता है। ग्राहक रिलीज़ शाखाएँ रिलीज़-डेवलपमेंट-ब्रांच से अलग हो जाती हैं। मैं git से परिचित नहीं हूं लेकिन मुक्त स्रोत नियंत्रण प्रणालियों के बीच मामले को साफ करने के लिए यह निकटतम बात लगती है।
zzz777

मेरे प्रश्न का सावधानीपूर्वक पढ़ा जाना चाहिए कि आपको दिखाया गया है कि हमें रिपॉजिटरी के बीच परिवर्तनों के प्रसार में शामिल ओवरहेड की समस्या है। इसका आपके जवाब से कोई लेना-देना नहीं है।
sbi

@sbi मुझे खेद है कि मैंने आपके प्रश्न को गलत समझा। और मुझे डर है कि आप जल्दी या बाद में एक भयानक गड़बड़ का सामना करेंगे।
zzz777
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.