निर्माण को विफल करने वाले स्वचालित रूप से पुनरावृत्ति होती है

Question

मेरा एक सहयोगी ने मुझसे कहा कि वह, पूर्ववत करता है कि निर्माण में विफल रहा है के लिए हमारी सीआई सर्वर बनाने में सोच तो है HEADमें masterहमेशा होता है स्थिर (कम से कम निर्माण गुजर के रूप में)।

क्या यह सबसे अच्छा अभ्यास है या यह masterतब तक और अधिक समस्याग्रस्त हो सकता है जब तक कि डेवलपर इसे ठीक न कर दे?

मेरी सोच यह है कि कमिट करने से कमिटमेंट और रीड को ठीक करने का काम और अधिक जटिल हो जाएगा (डेवलपर को रिवर्ट को वापस करना होगा और फिर फिक्स को कमिट करना होगा, जो कि अव्यवस्थित भी हो जाएगा git log) और हमें बस कमिट छोड़ना चाहिए और फिर कमिट करना चाहिए ठीक कर। यद्यपि मुझे masterस्थिर होने में कुछ फायदे दिखाई देते हैं , लेकिन असफल होने के इस परिणाम से मुझे यकीन नहीं होता है।

संपादित करें: कोई फर्क नहीं पड़ता कि यह masterया किसी अन्य विकास शाखा है, लेकिन सवाल एक ही रहता है: क्या सीआई सिस्टम को एक प्रतिबद्ध वापस करना चाहिए जो निर्माण में विफल रहा है?

एक और (lenghty) संपादित करें: ठीक है, हम gitएक अजीब तरीके से उपयोग कर रहे हैं । हम मानते हैं कि शाखाओं की अवधारणा वास्तविक सीआई के खिलाफ जाती है, क्योंकि एक शाखा के लिए प्रतिबद्ध आपको अन्य डेवलपर्स और उनके परिवर्तनों से अलग करता है, और समय जोड़ता है जब आपको अपनी शाखा को फिर से स्थापित करना होगा और संभावित संघर्षों से निपटना होगा। अगर हर कोई masterइस टकराव के लिए कम से कम हो जाता है और हर प्रतिबद्ध सभी परीक्षणों को पारित करता है।

बेशक, यह आपको केवल स्थिर पुश करने के लिए मजबूर करता है (या आप बिल्ड को तोड़ते हैं) और पीछे की संगतता को न तोड़ने के लिए अधिक सावधानी से प्रोग्राम करते हैं या नई सुविधाओं को पेश करते समय फीचर-टॉगलिंग करते हैं।

इस या उस तरह से सीआई करते समय ट्रेडऑफ होते हैं, लेकिन यह प्रश्न के दायरे से बाहर है (इसके लिए संबंधित प्रश्न देखें )। यदि आप पसंद करते हैं, तो मैं इस सवाल का जवाब दे सकता हूं: डेवलपर्स की एक छोटी टीम एक सुविधा शाखा में एक साथ काम करती है। यदि एक डेवलपर कुछ ऐसा करता है जो उस शाखा के लिए निर्माण को तोड़ता है, तो क्या सीआई सिस्टम को कमिटमेंट वापस करना चाहिए या नहीं?

Comments

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

— थोरस्टेन म्यूलर

@ थोरस्टेनमुलर अच्छी तरह से कल्पना करता है कि यह एक विकास शाखा में है जो सभी डेवलपर्स उपयोग करते हैं। क्या CI सिस्टम को फिर से शुरू होना चाहिए जो बिल्ड में विफल हो?

— कार्लोस कैंपड्रोस

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

— विल्बर्ट

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

— दीवॉर्डे

... क्यों नहीं इसे इतना असफल बनाता है कि मास्टर के साथ शुरू करने के लिए स्वीकार नहीं किया जाता है?

— user253751

Answer 1

मैं निम्नलिखित कारणों से ऐसा करने के खिलाफ हूँ:

• जब भी आप अपनी ओर से कोड बदलने के लिए एक स्वचालित टूल सेट करते हैं , तो जोखिम होता है कि यह गलत हो जाएगा, या यह स्थिति उत्पन्न होगी कि आपको उस परिवर्तन को रोकने के लिए इसकी आवश्यकता है (जैसे, Google मॉक का नवीनतम संस्करण इसमें एक बग था, इसलिए यह आपका कोड विफल नहीं है) और आपको इसे फिर से संगठित करने में समय बर्बाद करना होगा। इसके अलावा, हमेशा एक मामूली जोखिम होता है कि बिल्ड आपके सिस्टम में बग के कारण विफल हो जाएगा, बजाय आपके कोड में बग के। मेरे लिए, सीआई विश्वास हासिल करने के बारे में है कि मेरा कोड सही है; यह मेरे लिए चिंता का एक और स्रोत बन जाएगा।

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

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

Comments

इसके अलावा, केवल सफल बिल्ड को एक "बिल्ड ड्रॉप" के निर्माण को ट्रिगर करना चाहिए जिसे तैनात किया जा सकता है। यदि कोई बिल्ड विफल हो जाता है, तो कोई परिनियोजित बिल्ड ड्रॉप नहीं होना चाहिए, इसलिए कोई जोखिम नहीं होना चाहिए कि कोई ग्राहकों को खराब कोड प्रकाशित करेगा।

— मार्क फ्रीडमैन

निश्चित रूप से एक और विकल्प है जिसका उपयोग किया जाता है और इससे बेहतर है जो मुझे लगता है और भारी उपयोग में है (हम इसे ट्विटर पर उपयोग करते हैं)। मास्टर पर विफल नहीं बनाता है और मूर्खतापूर्ण गलतियों को अभी भी ठीक करना आसान है। नीचे मेरा पूरा जवाब देखें।

— डीन हिलर

Answer 2

पहले शर्तों पर सहमत होते हैं।

मैं व्यक्तिगत रूप से दो अलग-अलग परिदृश्यों को अलग करने के लिए कंटीन्यूअस बिल्ड और कंटीन्यूअस इंटीग्रेशन का उपयोग करता हूं:

• सतत निर्माण: एक उपकरण जो समय-समय पर जांचता है कि अगर अंतिम निर्माण के बाद से रिपॉजिटरी बदल गई, और निर्माण / परीक्षण किया तो यह किया।
• निरंतर एकीकरण: एक उपकरण जो पुल अनुरोधों को लेता है और उन्हें दृश्यमान बनाने से पहले नवीनतम प्रमुख के खिलाफ मान्य करता है ।

उत्तरार्द्ध, सतत एकीकरण, का अर्थ है कि यह जो भंडार बचाता है वह हमेशा हरा होता है ¹ : यह सख्ती से बेहतर है।

आपका प्रश्न केवल कंटीन्यूअस बिल्ड के लिए वास्तव में समझ में आता है, इसलिए मैं उत्तर दूंगा कि यह आपका सेटअप है।

¹ : पर्यावरणीय कारण भी एक बिल्ड को खराब कर सकते हैं, उदाहरण के लिए एक कठिन-कोडित वर्ष (2015) के साथ एक परीक्षण 2016 की जनवरी में विफल होना शुरू हो सकता है, एक डिस्क पूरी हो सकती है, ... और निश्चित रूप से अस्थिर की प्लेग है परीक्षण। मैं यहाँ उन मुद्दों की उपेक्षा कर रहा हूँ; वरना हम कभी नहीं मिलेंगे।

---

यदि आपके पास एक कंटीन्यूअस बिल्ड सेटअप है, तो आप वास्तव में उन कमिट्स को रिवर्सल कर सकते हैं जो बिल्ड को तोड़ सकते हैं, हालांकि कई सूक्ष्मताएं हैं।

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

ध्यान दें कि इस प्रणाली के साथ, एक अस्थिर परीक्षण या सहकर्मी अक्सर बकवास करने के मामले में, कई अच्छे काम उलट जाएंगे। आपके सहकर्मी तब आपसे घृणा करेंगे।

---

उम्मीद है कि मेरी डरावनी कहानी ने टूटी हुई रिपॉजिटरी की अनुमति देने के मुद्दों को उजागर किया है और अब आप एक उचित कंटीन्यूअस इंटीग्रेशन पाइपलाइन को लागू करेंगे, जहां पीआर को रिपॉजिटरी में सीधे धक्का नहीं दिया जाता है, बल्कि काम की कतार में विलय के लिए कतारबद्ध किया जाता है, और एक समय में एकीकृत किया जाता है ( या रोल-अप द्वारा):

• स्थानीय स्तर पर भंडार का प्रमुख
• पुल अनुरोध लागू करें
• निर्माण और परीक्षण
• सफलता के मामले में, रिपॉजिटरी को धक्का दें, अन्यथा विफल होने के रूप में चिह्नित करें
• अगले अनुरोधों पर जाएं

दोनों का प्रयास करने के बाद, यह सख्ती से बेहतर है।

Comments

यह वास्तव में सही जवाब है - सही समाधान यह है कि बुरे बदलावों को मास्टर शाखा तक पहुंचने से रोका जाए, न कि उन्हें जमीन पर उतारने के लिए और फिर उन्हें वापस लुढ़कने से निपटने के लिए।

— डैनियल प्रीडेन

मुझे लगता है कि यहां समस्या यह है कि प्रश्नकर्ता का मानना ​​है कि "आपको अन्य डेवलपर्स से अलग-थलग करने की लागत और उनके परिवर्तन" लाभों से आगे निकलते हैं। बताई गई लागतें गैर-तुच्छ खतरे में वृद्धि का खतरा हैं जो अब दो लोगों को अलग कर देती हैं। आईएमओ टूटे हुए कोड से अलग होने का लाभ स्पष्ट है। प्रश्नकर्ता एक "आशावादी" रणनीति लेना चाहता है, जहां टूटी हुई कोड को masterखींचने के लिए संक्षिप्त रूप से उपलब्ध है , और परीक्षण विफल होने के बाद इस स्थिति को ठीक करें। बाकी सभी लोग आपको सलाह देते हुए "निराशावादी" रणनीति अपनाते हैं और केवल पासिंग कोड को खींचने के लिए उपलब्ध कराते हैं।

— स्टीव जेसप

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

— स्टीव जेसप

सही समाधान यह है कि बुरे बदलावों को किसी भी शाखा तक पहुँचने से रोका जाए। असफल किए गए कामों को कभी सार्वजनिक नहीं किया जाना चाहिए।

— माइल्स रूट

Answer 3

क्या यह सबसे अच्छा अभ्यास है या यह केवल मास्टर को टूटने से अधिक समस्याग्रस्त हो सकता है जब तक कि डेवलपर इसे ठीक नहीं करता है?

यह समस्याग्रस्त है। एक व्यक्ति "मास्टर हेड टूट गया है, मैं शीर्ष परिवर्तन को वापस कर दूंगा" सीआई सिस्टम के समान करने से पूरी तरह से अलग है।

यहाँ कुछ नुकसान हैं:

• स्वचालित उलट प्रक्रिया में त्रुटियां रिपॉजिटरी को खराब कर देंगी;

• यह एक एकल बदलाव (सबसे ऊपरी) को खराब कर देता है (जो अवास्तविक है)

• समस्या को ठीक करने के लिए रखरखाव के लिए और अधिक काम करना होगा, केवल जांच और प्रतिबद्ध होने से (उन्हें रिवर्स इतिहास को भी देखना होगा)

हम मानते हैं कि शाखाओं की अवधारणा वास्तविक सीआई के खिलाफ जाती है, क्योंकि एक शाखा के लिए प्रतिबद्ध आपको अन्य डेवलपर्स और उनके परिवर्तनों से अलग करता है, और समय जोड़ता है जब आपको अपनी शाखा को फिर से स्थापित करना होगा और संभावित संघर्षों से निपटना होगा।

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

सुविधा शाखाओं में आप अन्य डेवलपर्स से अलग होना चाहते हैं । यह आपको इसकी अनुमति देता है:

• खोजपूर्ण कोडिंग निष्पादित करें

• कोड बेस के साथ प्रयोग करें

• आंशिक पॉइंट्स (प्रभावी ढंग से काम न करने वाला कोड) करने के लिए बैकअप पॉइंट्स सेट करने के लिए (यदि आप स्क्रू अप करते हैं), तो अधिक अर्थपूर्ण परिवर्तन इतिहास (कमिट मैसेज के माध्यम से) बनाने के लिए, और अपने काम का बैकअप लेने के लिए और पूरी तरह से किसी और चीज़ में स्विच करने के लिए (में) आपको "git कमिट && git चेकआउट" लिखने में लगने वाला समय)

• निम्न-प्राथमिकता वाले कार्य करें जो एक लंबा समय लेते हैं (जैसे कि आप एक रीफैक्टरिंग करना चाहते हैं जो डेटा लेयर के सभी 80 वर्गों को बदल देता है: आप प्रति दिन दो बदलते हैं, जब तक कि आप उन सभी को एक कोड संकलन नहीं बदलते (लेकिन आप ऐसा कर सकते हैं) बिना किसी को प्रभावित किए जब तक आप एक भी कमिट नहीं कर सकते)।

यदि एक डेवलपर कुछ ऐसा करता है जो उस शाखा के लिए निर्माण को तोड़ता है, तो क्या सीआई सिस्टम को कमिटमेंट वापस करना चाहिए या नहीं?

यह नहीं करना चाहिए आपकी सीआई शाखा पर स्थिर कोड कमिट करना एक स्वचालित प्रणाली की नहीं बल्कि कमिट की जिम्मेदारी है।

Answer 4

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

इसका एक समान वातावरण @ ब्रायन-वैंडेनबर्ग द्वारा वर्णित है

अपनी शाखा को अच्छे आकार में रखने के अलावा, आप एक कोड समीक्षा चरण भी जोड़ते हैं जो आपके सॉफ़्टवेयर के बारे में कोड की गुणवत्ता और ज्ञान साझा करने में सुधार करता है।

[१] जेनकिन्स https://jenkins-ci.org/

[२] गेरिट https://www.gerritcodereview.com/

Answer 5

CI को रेपो के प्रतिबद्ध इतिहास में कभी बदलाव नहीं करना चाहिए।

अगर वे परीक्षण और सत्यापित नहीं किए गए हैं, तो यहां सही समाधान मास्टर शाखा में शामिल किए जाने के लिए कोई कमिट नहीं है।

क्या आप सुविधा शाखाओं पर काम करते हैं, उन पर CI स्वचालित रूप से चलता है, और यदि बिल्ड विफल हो जाते हैं, तो उन्हें मास्टर में मर्ज न करें।

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

Comments

यह किसी भी तरह से सवाल का जवाब नहीं देता है। यदि किसी सुविधा शाखा में बिल्ड विफल हो जाता है, तो क्या सीआई को प्रतिबद्ध वापस करना चाहिए?

— कार्लोस कैंपड्रोस

क्या होगा यदि बिल्ड सुविधा शाखा पर सफल होता है, लेकिन मर्ज के बाद विफल हो जाता है ?

— मथिउ एम।

@MatthieuM। मर्ज एक कमिट है, क्या CI कदम है कि मर्ज बिल्ड को वापस करना चाहिए?

— कार्लोस कैंपड्रोस

@ CarlosCampderrós: ​​मेरे पास व्यक्तिगत रूप से कभी भी ऐसा सेटअप नहीं होगा जो कमिट करने का प्रयास करता है; बहुत अधिक जटिल।

— मथिउ एम।

मैंने टिप्पणियों को संबोधित किया।

— डेन्थ

Answer 6

हम अपने बिल्ड सर्वर के लिए जेनकिंस का उपयोग करते हैं और कमिट को आगे बढ़ाने के लिए गेटकीपर मॉडल का उपयोग करते हैं - जहां जेनकिंस और कमिट ट्रिगर्स का एक संयोजन (यह सुनिश्चित करें कि सहकर्मी समीक्षकों ने अपना काम किया है) गेटकीपर है।

कमांड को परोक्ष रूप से जेनकिन्स के माध्यम से एक कर्ल के माध्यम से धकेल दिया जाता है , जहां यह मास्टर रेपो को क्लोन करता है फिर मर्ज करने के लिए कमिट (एस) में खींचता है और सभी आवश्यक बिल्ड (लिनक्स / सोलारिस के लिए) करता है। यदि सभी पूर्ण हो जाते हैं, तो कमिट को धक्का दिया जाता है।

यह बहुत से बचने के लिए अगर सभी समस्याओं पर चर्चा नहीं की है:

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

यह हमें अन्य आवश्यकताओं जैसे यूनिट परीक्षणों को सफलतापूर्वक पूरा करने के लिए सीधे लागू करने की अनुमति देता है।

Comments

पुन: डाउनवोट, क्या आप इस बात पर टिप्पणी करेंगे कि आपने मेरे उत्तर के बारे में क्या पसंद नहीं किया?

— ब्रायन वंडेनबर्ग

Answer 7

कितनी बार आपने उस स्वचालित ईमेल को यह कहते हुए प्राप्त किया है कि आपकी अंतिम प्रतिबद्धता ने निर्माण को तोड़ दिया है? यह कितनी बार गलत है? लेकिन अब आपको यह देखने के लिए चेक करना होगा कि क्या यह वास्तव में आप थे, या कोई और जिसने उसी समय के आसपास कोई और काम किया हो। या शायद यह कुछ पर्यावरणीय था।

यदि सिस्टम सुनिश्चित करने के लिए नहीं जानता है, तो मैं निश्चित रूप से इसे स्वचालित नहीं करना चाहता हूं।

Answer 8

पूछा गया प्रश्न त्रुटिपूर्ण है। मैं हालांकि इस बयान का सम्मान करता हूं

"हम मानते हैं कि शाखाओं की अवधारणा वास्तविक सीआई के खिलाफ जाती है, क्योंकि एक शाखा के लिए प्रतिबद्ध आपको अन्य डेवलपर्स और उनके परिवर्तनों से अलग करता है"

हालांकि आपको ये कदम उठाने चाहिए

• यदि आपको पसंद है (तो यह ठीक है और सभी से परिवर्तन खींचते रहें) तो मास्टर से काम करें, लेकिन स्थानीय स्तर पर मास्टर करने के लिए प्रतिबद्ध न हों
• बस इससे पहले कि आप मास्टर में अपने बदलाव करने जा रहे हों, submit_XXXXXX के साथ एक शाखा बनाएँ
• अपने स्वचालित बिल्ड को सभी submit_XXX शाखाओं का निर्माण करें
• विकल्प 1: निर्माण को तोड़ता है, या टूटता है ... परिवर्तन को अस्वीकार कर दिया गया है और यह कभी भी मास्टर पर नहीं उतरता है
• विकल्प 2: निर्माण कार्य, जेनकिंस मास्टर को धक्का देता है और इसे अपडेट करता है

फिर, हम जो कुछ भी करते हैं वह हर किसी को वास्तविक रूप से मास्टर करने से रोकता है। यह बहुत अच्छा काम करता है .... कोई टूट कभी नहीं बनाता है और न ही गुरु से पुनर्मिलन करता है।

बाद में, डीन