version control मैं मर्क्यूरियल में एक मर्ज वापस कैसे कर सकता हूं और बाद में उस शाखा के साथ फिर से जुड़ सकता हूं?




version-control mercurial (5)

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

हमारे रिपॉजिटरी सर्वर पर हमने एक नया रिपॉजिटरी बनाया, फिर हमने पुराने रिपॉजिटरी को मर्ज करने से ठीक पहले संशोधन तक क्लोन किया। फिर सर्वर पर नए क्लोन को धकेला और सभी के लिए नया लिंक भेजा। सौभाग्य से हम काफी छोटी विकास टीम हैं।

शायद समस्या को हल करने के लिए सबसे अधिक रास्ता नहीं है, लेकिन यह काम किया :)

मेरी दो शाखाएँ हैं, डिफ़ॉल्ट और शाखा 1। गलती से हमारी टीम के एक व्यक्ति ने शाखा 1 को डिफ़ॉल्ट रूप से विलय कर दिया। ब्रांच 1 की सामग्री अभी तक डिफ़ॉल्ट रूप से विलय करने के लिए तैयार नहीं है (इसमें बिल्ड और परिनियोजित वातावरण का एक प्रमुख कार्य शामिल है)।

हमने 'hg backout' के साथ एक प्रयोग किया, मर्ज का समर्थन करते हुए (यकीन है कि यह ऐसा करने का सही तरीका है)। फिर शाखा 1 से परिवर्तन डिफ़ॉल्ट रूप से हटा दिए जाते हैं, जो ठीक है - लेकिन हम शाखा 1 के साथ फिर से नहीं जुड़ सकते हैं।

हमें इस मुद्दे को कैसे हल करना चाहिए?


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

कोई और परिवर्तन नहीं, मर्ज साझा नहीं (कोई धक्का / खींचता नहीं)

प्रोग्रामर का विलय हो गया है, लेकिन कुछ और नहीं किया गया है, और न ही उन्होंने किसी के साथ, किसी भी तरह से परिवर्तनों को साझा किया है

इस मामले में, बस स्थानीय क्लोन को छोड़ दें, और एक सुरक्षित भंडार से एक ताजा क्लोन प्राप्त करें।

मर्ज के शीर्ष पर स्थानीय परिवर्तन, साझा नहीं किए गए

प्रोग्रामर विलय हो गया है, और उस मर्ज के आधार पर काम करना जारी रखा है। मर्ज का अनुसरण करने वाले परिवर्तनों को रखा जाना चाहिए, लेकिन मर्ज को स्वयं हटा दिया जाना चाहिए। परिवर्तन (मर्ज + निम्नलिखित परिवर्तन) किसी के साथ साझा नहीं किए गए हैं

इस मामले में मैं चार में से एक करूंगा:

  1. REBASE एक्सटेंशन का उपयोग करने का प्रयास करें, यह परिवर्तनों को एक स्थान से दूसरे स्थान पर ले जाएगा। यदि परिवर्तन कोड-परिवर्तनों पर आधारित होते हैं जो मर्ज के साथ पेश किए गए थे, तो मतभेदों को समेटने के लिए कुछ मैनुअल काम करना होगा।
  2. पैच-कतार में रखे जाने वाले परिवर्तनों को खींचने के लिए MQ एक्सटेंशन का उपयोग करने का प्रयास करें, फिर उन्हें एक अलग स्थान पर वापस धकेलें। हालाँकि, मर्ज के आधार पर परिवर्तनों के संदर्भ में REBASE एक्सटेंशन के रूप में यह समस्या होगी
  3. एक स्थान से दूसरे स्थान पर परिवर्तनों को "कॉपी" करने के लिए ट्रांसप्लंट एक्सटेंशन का उपयोग करने का प्रयास करें। फिर भी, पहले दो के समान ही समस्या है।
  4. कार्य को फिर से करें, संभवतया एक अलग उपकरण की मदद से जिन परिवर्तनों को मैं त्यागना चाहता हूं, उनमें किए गए बदलावों को सही स्थान पर फिर से कर लें।

मर्ज परिवर्तन से छुटकारा पाने के लिए + निम्नलिखित सभी परिवर्तनों के बाद, कुछ विकल्प हैं:

  1. MQ एक्सटेंशन में स्ट्रिप कमांड का उपयोग करें

    hg strip <hash of merge changeset>
    
  2. क्लोन और पुल, और उन परिवर्तनों के हैश निर्दिष्ट करें, जो मर्ज को शामिल नहीं करते हैं। संक्षेप में, क्षतिग्रस्त क्लोन से एक नए में खींचकर एक नया क्लोन बनाएं, और उस मर्ज में खींचने से बचें जो आप नहीं चाहते हैं।

    hg clone damaged -r <hash of first parent> .
    hg pull damaged -r <hash of second parent>
    

दूसरों को धक्का दिया, क्लोन पर नियंत्रण

प्रोग्रामर ने मास्टर रिपॉजिटरी में, या किसी और के लिए, या प्रोग्रामर रिपॉजिटरी से किसी को खींच लिया है। हालाँकि, आप (डेवलपर्स के समूह में) सभी रिपॉजिटरी पर नियंत्रण रखते हैं, जैसे कि, अधिक काम पूरा होने से पहले आप सभी से संपर्क कर सकते हैं और उनसे बात कर सकते हैं

इस मामले में, मैं देखूंगा कि क्या चरण 1 या 2 किया जा सकता है, लेकिन इसे बहुत सारे स्थानों पर करना पड़ सकता है, इसलिए इसमें बहुत सारे काम शामिल हो सकते हैं।

यदि किसी ने मर्ज परिवर्तन के आधार पर काम नहीं किया है, तो मैं चरण 1 या 2 का उपयोग सफाई करने के लिए करूंगा, फिर मास्टर रिपॉजिटरी को धक्का दूंगा, और सभी को मास्टर रिपॉजिटरी से एक ताजा क्लोन प्राप्त करने के लिए कहूंगा।

मर्ज को धक्का दिया गया, आपके पास क्लोन पर नियंत्रण नहीं है

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

मर्ज परिवर्तन को अनदेखा करें और दो शाखाओं में काम करें जैसे कि यह कभी नहीं हुआ। इससे झूलता हुआ सिर निकल जाएगा। आप बाद में, जब आप दो शाखाओं को मिला सकते हैं, तो इससे छुटकारा पाने के लिए इस सिर के लिए एक शून्य-मर्ज करें।

  M         <-- this is the one you want to disregard
 / \
*   *
|   |
*   *
|   |

बस दो शाखाओं में काम करना जारी रखें:

|   |
*   *
| M |       <-- this is the one you want to disregard
|/ \|
*   *
|   |
*   *
|   |

फिर बाद में आप दोनों को मिला देते हैं, असली मर्ज आप चाहते हैं:

  m
 / \
*   *
|   |
*   *
| M |       <-- this is the one you want to disregard
|/ \|
*   *
|   |
*   *
|   |

फिर आप लटकते हुए सिर से छुटकारा पाने के लिए एक शून्य-मर्ज कर सकते हैं। दुर्भाग्य से मैं नहीं जानता कि कैसे करना है कि TortoiseHg के अलावा। इसमें एक चेकबॉक्स है जहां मैं शाखाओं में से एक से परिवर्तनों को छोड़ सकता हूं।

TortoiseHg के साथ, मैं उस मर्ज को अपडेट करूँगा जिसे मैं रखना चाहता हूं (सबसे ऊपर, निचला मीटर), फिर नीचे दिए गए लटकते मर्ज हेड पर सेलेक्ट करें और राइट-क्लिक करें, और फिर "मर्ज टारगेट (अन्य) रिवीजन से सभी बदलावों को छोड़ें" की जांच करें :


हमने 'hg backout' के साथ एक प्रयोग किया, मर्ज का समर्थन करते हुए (यकीन है कि यह ऐसा करने का सही तरीका है)। फिर शाखा 1 से परिवर्तन डिफ़ॉल्ट रूप से हटा दिए जाते हैं, जो ठीक है - लेकिन हम शाखा 1 के साथ फिर से नहीं जुड़ सकते हैं।

मैं मर्ज रद्द करने के लिए बैकआउट का उपयोग करता हूं। आप फिर से नहीं जुड़ सकते हैं, लेकिन आप "बैकआउट बैकआउट मर्ज" करने में सक्षम हैं, अर्थात जब आप पुनर्मिलन करना चाहते हैं, तो आप "बैक आउट मर्ज बदलाव" ... पर 'एचजी बैकआउट' कर सकते हैं ... फिर से शाखा को मर्ज करें।

उदाहरण:

  7     M       remerge
  6   /   \
  5   *   |     hg backout 3 (backout backout)
  4   |   *     fix error 
  3   *   |     hg backout 2
  2   M   |     fail merge
    /     \
  1 *     *
    |     |

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


यह उत्तर मानता है कि आपने पहले ही धक्का दे दिया है

यह (कम से कम एक) अनसुलझे सिर के परिणामस्वरूप होगा, जो आप अभी भूल गए थे उसके आधार पर। अधिक निर्भर करता है कि किसने किस शाखा से धक्का दिया।

मैं एचजी से प्यार करता हूं और इसका इस्तेमाल पूरी तरह से करता हूं, लेकिन एक शाखा का उनका विचार किसी ऐसे व्यक्ति को जब किसी इतिहास के साथ जोड़ा जाता है (जानबूझकर) अपरिवर्तनीय रूप से बैटी ड्राइव कर सकता है।

मैं आमतौर पर एक शाखा मर्ज करने से पहले रेपो का बैकअप (स्थानीय रूप से) क्लोन करता हूं, बस इसी कारण से। मैं हमेशा खींचने से पहले जांच करता हूं।

एरिक रेमंड एक ऐसी चीज पर काम कर रहे हैं, जो कमोबेश DVCS अज्ञेयवादी है (उम्मीद है) उन स्थितियों में मदद कर सकती है, जो आपके द्वारा बताए गए उफ़ की तरह हैं, लेकिन मुझे नहीं लगता कि उसके पास एक या दो हफ़्ते के लिए पूरी तरह से लागू की गई HG सहायता है। फिर भी, यह देखने लायक हो सकता है।

लेकिन, केवल तभी उपयोगी है जब किसी ने 'ऊओपी' टिप नहीं खींची है।





dvcs