Mercurial पर एक पीछे की ओर विलय का समर्थन




merge dvcs (5)

आप पीड़ा से मरने के बिना ध्रुवीकृत शाखाओं पर विलय के प्रभाव को कैसे उलटते हैं?

यह समस्या महीनों से मुझे परेशान कर रही है और मैंने अंत में छोड़ दिया है।

आपके पास 2 नामांकित शाखाओं के साथ 1 रिपोजिटरी है। ए और बी

ए में होने वाले परिवर्तन अनिवार्य रूप से बी पर होते हैं।

बी पर सीधे होने वाले परिवर्तन कभी भी ए पर नहीं होंगे।

ऐसी कॉन्फ़िगरेशन में, "ए" में "बी" विलय करने से भंडार में एक गंभीर समस्या उत्पन्न होती है, क्योंकि बी में सभी परिवर्तन ए में दिखाई देते हैं जैसे कि वे ए में बनाए गए थे।

इस स्थिति से ठीक होने का एकमात्र "सामान्य" तरीका विलय का "समर्थन" होता है, यानी:

 hg up -r A 
 hg backout -r BadMergeRev --parent BadMergerevBeforeOnA 

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

इसके अलावा अब तक एक काम करने योग्य व्यवहार्य समाधान नहीं रहा है, "इसे अपनी बात करने दें, और फिर सभी समस्याओं को ठीक करें" और ईमानदार होने के लिए थोड़ा फ्यूबर है।

समस्या को स्पष्ट करने वाली एक छवि यहां दी गई है:

[मूल छवि खो गया]

फ़ाइलें सी और ई (या सी और ई में परिवर्तन) केवल शाखा बी पर दिखाई देनी चाहिए, न कि शाखा ए पर। संशोधन ए 9 यहां (शाखा ए, revno 9) समस्या की शुरुआत है।

संशोधन ए 10 और ए 11 "बैकआउट मर्ज" और "बैकआउट मर्ज करें" चरण हैं।

और संशोधन बी 12 मर्क्यूरियल है, गलती से बार-बार एक बदलाव छोड़ रहा है जिसका इरादा नहीं छोड़ा जाना था।

इस दुविधा ने बहुत निराशा और नीले धुएं का कारण बना दिया है और मैं इसे खत्म करना चाहता हूं।

ध्यान दें

रिवर्स विलय को या तो हुक या पॉलिसी के साथ होने से रोकने का प्रयास करने का स्पष्ट उत्तर हो सकता है, मुझे यह पता चला है कि यह ऊपर उठने की क्षमता अधिक है और यह संभावना है कि प्रतिकूल प्रतिक्रियाओं के साथ भी, आपको अभी भी अवश्य होना चाहिए मान लीजिए कि अनिवार्य रूप से, ऐसा होगा ताकि आप इसे हल कर सकें।

समझाने के लिए

मॉडल में मैंने अलग-अलग फाइलों का उपयोग किया है। ये समस्या को सरल बनाते हैं। ये केवल मनमानी परिवर्तनों का प्रतिनिधित्व करते हैं जो एक अलग रेखा हो सकती हैं।

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

इतिहास पुनर्लेखन चाल पर:

इन सभी रेट्रो-सक्रिय समाधानों के साथ समस्या निम्नानुसार है:

  1. हमारे पास 9 000 काम हैं।
  2. ताजा क्लोनिंग में आधे घंटे लगते हैं
  3. यदि कहीं भी भंडार के एक बुरे क्लोन मौजूद हैं, तो मूल भंडार के संपर्क में वापस आने की संभावना है, और इसे फिर से टक्कर लगी है।
  4. हर किसी ने पहले से ही इस भंडार को क्लोन कर दिया है, और अब चल रहे कामों के साथ कई दिन बीत चुके हैं।
  5. ऐसा एक क्लोन, एक लाइव साइट होता है, इसलिए "उस को पोंछना और खरोंच से शुरू करना" = "बड़ा गैर"

(मैं मानता हूं, उपरोक्त में से कई थोड़ा सा दास हैं, लेकिन वे मेरे नियंत्रण से बाहर हैं)।

एकमात्र समाधान जो व्यवहार्य हैं वे हैं जो मानते हैं कि लोग सब कुछ गलत कर सकते हैं और करेंगे , और इस गलतता को पूर्ववत करने का एक तरीका है।

https://code.i-harness.com


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

एक सरल ऑपरेशन करते समय मैंने इस पृष्ठ का संदर्भ दिया:

http://strongdynamic.blogspot.com/2007/08/expunging-problem-file-from-mercurial.html


ठीक है, टूटी हुई भंडार (एचजी init) से एक अलग निर्देशिका में एक नया खाली भंडार बनाकर शुरू करें। अब, नए भंडार में अंतिम ज्ञात अच्छे संस्करण को खींचें और शामिल करें; सुनिश्चित करें कि आप खराब विलय नहीं खींचते हैं और इससे पहले सबकुछ खींचते हैं। पुराने भंडार में, ए के अंतिम ज्ञात अच्छे संस्करण में अपडेट करें, और ऐसा करें:

hg graft r1 r2 r3

जहां r1-3 बॉट किए गए विलय के बाद किए गए परिवर्तन होते हैं। आप इस बिंदु पर संघर्ष प्राप्त कर सकते हैं; उन्हें ठीक करें।

यह ए के अंतिम ज्ञात अच्छे संस्करण के खिलाफ नए बदलाव पैदा करना चाहिए। नए भंडार में उन नए परिवर्तनों को खींचें। बस दोबारा जांचने के लिए कि आपने कुछ भी याद नहीं किया है, पुराने भंडार के खिलाफ आने वाले एचजी करें। यदि आप बॉट किए गए विलय और आर 1-3 के अलावा कुछ भी देखते हैं, तो इसे खींचें।

पुरानी भंडार दूर फेंको। हो गया। विलय नए भंडार में नहीं है और आपको इतिहास को फिर से लिखना नहीं था।


तो आप बी से कुछ में कुछ बदलावों को मर्ज करना चाहते हैं? आपके जैसे परिवर्तनों का बैक अप लेना वास्तव में एक बुरा विचार है जैसा कि आप पहले से ही पीड़ित हैं।

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


फर्नोड पर #mercurial पर कुछ सहायक लोगों के साथ बहुत चर्चा के बाद, एमपीएम ने एक आंशिक समाधान प्रदान किया है जो मेरे परीक्षण मामले के लिए काम करता है (मैंने परिदृश्य को दोहराने की कोशिश कर रहे नकली भंडार उत्पन्न किए हैं)

हालांकि, मेरे वास्तविक भंडार पर, कारणों से मैं काफी समझ में नहीं आता, यह अभी भी सही से कम है।

इस समस्या को हल करने के वर्तमान प्रस्तावित तरीके का चित्र यहां दिया गया है:

[मूल छवि खो गया]

अब इसे ठीक करने में कोई समस्या नहीं है, लेकिन मुझे अभी भी diffs की तुलना करना है (यानी: बी 46: बी 11 बनाम बी 46: बी 8, ए 43: ए 10 बनाम ए 43: ए 9) और हाथ कुछ बदलावों को संपादित करें।

इस सवाल को बंद नहीं करना / उत्तर देना जब तक कि मुझे गारंटीकृत तरीका न मिल जाए जो किसी भी भंडार पर काम करता है।

जरूरी

इस सामान को आजमाने वाले किसी भी व्यक्ति को अपने भंडार को क्लोन करना चाहिए और इसके साथ पहले एक सैंडबॉक्स की तरह खेलना चाहिए। जैसा कि आपको किसी मर्ज प्रक्रिया के साथ करना चाहिए, क्योंकि अगर यह गलत हो जाता है तो आप इसे फेंक सकते हैं और फिर से शुरू कर सकते हैं।


मुझे लगता है कि मुझे एक समाधान मिला जो खराब विलय को स्थायी रूप से ठीक करता है, और जिसके लिए आपको किसी भी diffs को मैन्युअल रूप से जांचने की आवश्यकता नहीं होती है। चाल इतिहास में वापस जाना है और खराब विलय के समानांतर काम करता है।

तो हमारे पास एक ही उत्पाद के प्रति बनाए गए संस्करण के अलग शाखाओं के साथ भंडार है। प्रश्न में उत्पन्न स्थिति की तरह, पहले संस्करण की शाखा (यानी उस संस्करण में बगफिक्स) पर किए गए सभी परिवर्तनों को अंततः बाद के संस्करणों की शाखाओं में विलय कर दिया जाना चाहिए।

तो विशेष रूप से, यदि BRANCH_V8 पर कुछ चेक किया गया है, तो इसे BRANCH_V9 में विलय किया जाना चाहिए।

अब डेवलपर्स में से एक निम्नलिखित गलती करता है: वह BRANCH_V9 से BRANCH_V8 में सभी परिवर्तनों को विलय करता है (यानी गलत दिशा में विलय)। इसके अलावा, उस बुरे विलय के बाद वह अपनी गलती को नोटिस करने से पहले कुछ अतिरिक्त काम करता है।

तो स्थिति नीचे ग्राफिकल लॉग में दिखाया गया है।

o  BRANCH_V8 - 13 - important commit right after the bad merge
|
o    BRANCH_V8 - 12 - wrong merge from BRANCH_V9
|\
| o  BRANCH_V8 - 11 - adding comment on BRANCH_V8 (ie. last known good state)
| |
o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
| |

हम इस गलती को निम्नानुसार ठीक कर सकते हैं:

  1. BRANCH_V8 की अंतिम अच्छी स्थिति में अपनी स्थानीय निर्देशिका अपडेट करें: hg update 11
  2. उस अंतिम अच्छी स्थिति का नया बच्चा बनाएं:
    1. कुछ फ़ाइल $EDITOR some/file.txt बदलें (यह आवश्यक है क्योंकि Mercurial खाली काम करने की अनुमति नहीं देता है)
    2. इन परिवर्तनों को hg commit -m "generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9"
      स्थिति अब निम्नानुसार दिखती है:
      o  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
      |
      | o  BRANCH_V8 - 13 - important commit right after the bad merge
      | |
      | o  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
      |/|
      o |  BRANCH_V8 - 11 - adding comment on BRANCH_V8
      | |
      | o  BRANCH_V9 - 10 - last commit on BRANCH_V9
      
  3. नए उत्पन्न सिर को उस संशोधन के साथ मर्ज करें जिसमें खराब विलय हुआ, और काम करने से पहले सभी परिवर्तनों को फेंक दें। बस दो सिर मर्ज न करें, क्योंकि आप विलय के बाद भी महत्वपूर्ण प्रतिबद्धता खो देंगे!

    1. विलय करें: hg merge 12 (किसी भी विवाद को अनदेखा करें)
    2. सभी परिवर्तनों को फेंक दें: hg revert -a --no-backup -r 14
    3. परिवर्तनों को प्रतिबद्ध करें: hg commit -m "throwing away wrong merge from BRANCH_V9" अब ऐसा लगता है:
      o    BRANCH_V8 - 15 - throwing away wrong merge from BRANCH_V9
      |\
      | o  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
      | |
      +---o  BRANCH_V8 - 13 - important commit right after the bad merge
      | |
      o |  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
      |\|
      | o  BRANCH_V8 - 11 - adding comment on BRANCH_V8
      | |
      o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
      | |
      

    अर्थात। BRANCH_V8 पर दो सिर हैं: एक जिसमें खराब विलय का फिक्स शामिल है, और दूसरा ब्रैंच_वी 8 पर बाएं ओवर महत्वपूर्ण प्रतिबद्धता है जो मर्ज के ठीक बाद हुआ।

  4. BRANCH_V8 पर दो सिर मर्ज करें:
    1. विलय: hg merge
    2. प्रतिबद्ध: hg commit -m "merged two heads used to revert from bad merge"

BRANCH_V8 पर अंत में स्थिति अब ठीक हो गई है, और ऐसा लगता है:

o    BRANCH_V8 - 16 - merged two heads used to revert from bad merge
|\
| o    BRANCH_V8 - 15 - throwing away wrong merge from BRANCH_V9
| |\
| | o  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
| | |
o | |  BRANCH_V8 - 13 - important commit right after the bad merge
|/ /
o |  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
|\|
| o  BRANCH_V8 - 11 - adding comment on BRANCH_V8
| |
o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
| |

अब BRANCH_V8 की स्थिति सही है। शेष समस्या केवल यह है कि BRANCH_V8 से BRANCH_V9 तक अगला विलय गलत होगा, क्योंकि यह खराब विलय के लिए 'ठीक' में विलय करेगा, जिसे हम BRANCH_V9 पर नहीं चाहते हैं। यहां की चाल अलग-अलग परिवर्तनों में BRANCH_V8 से BRANCH_V9 में विलय करना है:

  • पहले मर्ज करें, BRANCH_V8 से BRANCH_V9 तक, खराब विलय से पहले BRANCH_V8 पर सही परिवर्तन।
  • मर्ज गलती और इसके फिक्स में दूसरा विलय, और, कुछ भी जांचने की आवश्यकता के बिना, सभी परिवर्तनों को फेंक दें
  • BRANCH_V8 से शेष परिवर्तनों में तीसरा विलय करें।

विस्तार से:

  1. अपनी कार्य निर्देशिका को BRANCH_V9 पर स्विच करें: hg update BRANCH_V9
  2. BRANCH_V8 की अंतिम अच्छी स्थिति में विलय करें (यानि। जो विवाद आपने खराब विलय को ठीक करने के लिए उत्पन्न किया है)। यह विलय किसी भी नियमित विलय की तरह एक विलय है, यानी। संघर्ष सामान्य रूप से हल किया जाना चाहिए, और कुछ भी फेंकने की जरूरत नहीं है।
    1. विलय: hg merge 14
    2. प्रतिबद्ध: hg commit -m "Merging in last good state of BRANCH_V8" स्थिति अब है:
      @    BRANCH_V9 - 17 - Merging in last good state of BRANCH_V8
      |\
      | | o    BRANCH_V8 - 16 - merged two heads used to revert from bad merge
      | | |\
      | +---o  BRANCH_V8 - 15 - throwing away wrong merge from BRANCH_V9
      | | | |
      | o | |  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
      | | | |
      | | o |  BRANCH_V8 - 13 - important commit right after the bad merge
      | | |/
      +---o  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
      | |/
      | o  BRANCH_V8 - 11 - adding comment on BRANCH_V8
      | |
      o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
      | |
      
  3. BRANCH_V8 + पर इसके विलय में खराब विलय में विलय करें, और सभी परिवर्तनों को फेंक दें:
    1. विलय: hg merge 15
    2. सभी परिवर्तनों को वापस लाएं: hg revert -a --no-backup -r 17
    3. मर्ज करें: hg commit -m "Merging in bad merge from BRANCH_V8 and its fix and throwing it all away" वर्तमान स्थिति:
      @    BRANCH_V9 - 18 - Merging in bad merge from BRANCH_V8 and its fix and throwing it all away
      |\
      | o    BRANCH_V9 - 17 - Merging in last good state of BRANCH_V8
      | |\
      +-----o  BRANCH_V8 - 16 - merged two heads used to revert from bad merge
      | | | |
      o---+ |  BRANCH_V8 - 15 - throwing away wrong merge from BRANCH_V9
      | | | |
      | | o |  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
      | | | |
      +-----o  BRANCH_V8 - 13 - important commit right after the bad merge
      | | |
      o---+  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
      |/ /
      | o  BRANCH_V8 - 11 - adding comment on BRANCH_V8
      | |
      o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
      | |
      
  4. BRANCH_V8 से बाएं ओवर में परिवर्तनों में विलय करें:
    1. विलय करें: hg merge BRANCH_V8
    2. प्रतिबद्ध: hg commit -m "merging changes from BRANCH_V8"

अंत में स्थिति इस तरह दिखती है:

@    BRANCH_V9 - 19 - merging changes from BRANCH_V8
|\
| o    BRANCH_V9 - 18 - Merging in bad merge from BRANCH_V8 and its fix and throwing it all away
| |\
| | o    BRANCH_V9 - 17 - Merging in last good state of BRANCH_V8
| | |\
o | | |  BRANCH_V8 - 16 - merged two heads used to revert from bad merge
|\| | |
| o---+  BRANCH_V8 - 15 - throwing away wrong merge from BRANCH_V9
| | | |
| | | o  BRANCH_V8 - 14 - generating commit on BRANCH_V8 to rectify wrong merge from BRANCH_V9
| | | |
o | | |  BRANCH_V8 - 13 - important commit right after the bad merge
|/ / /
o---+  BRANCH_V8 - 12 - wrong merge from BRANCH_V9
|/ /
| o  BRANCH_V8 - 11 - adding comment on BRANCH_V8
| |
o |  BRANCH_V9 - 10 - last commit on BRANCH_V9
| |

इन सभी चरणों के बाद, जिसमें आपको मैन्युअल रूप से किसी भी प्रकार की जांच की आवश्यकता नहीं है, BRANCH_V8 और BRANCH_V9 सही हैं, और भविष्य में BRANCH_V8 से BRANCH_V9 में विलय विलय भी सही होगा।





branch