Git के साथ आप संख्यात्मक संस्करण योजना कैसे प्राप्त करते हैं?

Question

मेरा संगठन SVN से Git तक जाने पर विचार कर रहा है। चलती के खिलाफ एक तर्क इस प्रकार है:

हम संस्करण कैसे बनाते हैं?

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

संभव समाधान:

• हडसन से बिल्ड नंबर का उपयोग करना (समस्या: आपको हडसन को एक वास्तविक गिट संस्करण में सहसंबंधित करने के लिए जांचना होगा)
• मैन्युअल रूप से रात और स्थिर के लिए संस्करण को छोड़ना (समस्या: सीखने की अवस्था, मानव त्रुटि)

यदि किसी और व्यक्ति ने इसी तरह की समस्या का सामना किया है और इसे हल किया है, तो हम यह सुनना पसंद करेंगे कि कैसे।

Comments

क्या आप अपने हडसन ( जेनकिन्स नहीं ?) सर्वर को gitप्रत्येक सफल निर्माण के बाद स्वचालित रूप से एक टैग जोड़ सकते हैं ? इसका अतिरिक्त फायदा यह होगा कि यह वास्तव में स्पष्ट कर gitदेता है कि कौन से मुद्दों का निर्माण या परीक्षण विफल रहा है, क्योंकि वे बिना टैग किए रहेंगे।

— मार्क बूथ

देखें stackoverflow.com/questions/677436/…

— चार्ल्स बी

साइड नोट के रूप में, आप बिल्ड समय को ट्रैक करके टैग में बिल्ड काउंट जोड़ सकते हैं ।

— शाहबाज

यकीन नहीं अगर एक व्यवहार्य समाधान, लेकिन कैसे के बारे में git से निर्यात करने के लिए एक svn रेपो सही हर निर्माण से पहले? तो बस svn रेपो से निर्माण - अगर केंद्रीकृत है कि हम क्या चाहते हैं, बस इसके बजाय का उपयोग करें।

— जॉनी

Answer 1

संस्करण संख्याओं के साथ कमिट चिह्नित करने के लिए टैग का उपयोग करें :

git tag -a v2.5 -m 'Version 2.5'

पुश अपस्ट्रीम - यह डिफ़ॉल्ट रूप से नहीं किया जाता है:

git push --tags

फिर वर्णन कमांड का उपयोग करें :

git describe --tags --long

यह आपको प्रारूप की एक स्ट्रिंग देता है:

v2.5-0-gdeadbee
^    ^ ^^
|    | ||
|    | |'-- SHA of HEAD (first seven chars)
|    | '-- "g" is for git
|    '---- number of commits since last tag
|
'--------- last tag

Comments

सहमत - अगर आपको जरूरत है तो नाइट टैग नंबरिंग को स्वचालित करना आसान होना चाहिए, और स्थिर को बढ़ावा देना वैसे भी मैनुअल है।

— बेकार

छोटे सुधार: git describe --long --tags --dirty --always। 'डर्टी' आपको बताएगी कि क्या स्थानीय विवरण तब थे जब 'वर्णन' किया गया था (मतलब यह रेपो की स्थिति का पूरी तरह से वर्णन नहीं कर सकता है)। 'हमेशा' का मतलब है कि टैग न होने पर आपको कोई त्रुटि नहीं मिलेगी। यह कमिटेड हैश की तरह ही वापस आएगा। तो आप 76001f2-dirtyएक उदाहरण के रूप में प्राप्त कर सकते हैं । जाहिर है, 'गंदा' देखने का मतलब है कि किसी ने गड़बड़ कर दी।

— माइक वेलर

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

— void.pointer

@ void.pointer: निश्चित रूप से, यह संस्करण संख्या इस सवाल का जवाब देती है कि "यह रिलीज़ किस आधार पर हुई?" नहीं "यह किस रिलीज़ में प्रतिबद्ध होगी?" हालाँकि, आप टैग्स की अलग-अलग तरह से व्याख्या करने के लिए स्वतंत्र हैं। उदाहरण के लिए, यदि आप के HEADरूप में टैग करते हैं v2.5, तो आप बस व्याख्या कर सकते हैं कि 2.5 रिलीज चक्र की शुरुआत के रूप में , फिर टैग v2.5-releaseया जो भी आपको पसंद हो।

— जॉन प्यार्डी

एक और छोटा सुधार। यदि आप अन्य टैग भी चाहते हैं, लेकिन संशोधन पीढ़ी के लिए विशेष रूप से पैटर्न किए गए टैग का उपयोग करें, तो आप --matchइस तरह के विकल्प का उपयोग कर सकते हैं :git describe --long --tags --dirty --always --match 'v[0-9]\.[0-9]'

— अलेक्जेंडर अमेलकिन

Answer 2

यह मेरे लिए कुछ परियोजनाओं पर आया है। अब तक मैंने जो सबसे अच्छा समाधान निकाला है, वह इस तरह से एक संस्करण संख्या उत्पन्न करना है:

xy <कमिट्स की संख्या> .r <git-hash>

आमतौर पर, यह प्रमुख पुनरीक्षण संख्याओं को प्राप्त करने के लिए कुछ स्थिर फ़ाइल या टैग के संयोजन का उपयोग करके हमारे बिल्ड सिस्टम द्वारा उत्पन्न होता है, git rev-list HEAD | wc -l(जो उपयोग करने की तुलना में तेज था git log), और git rev-parse HEAD। तर्क इस प्रकार था:

1. हमें स्पष्ट रूप से उच्च-स्तरीय संस्करण बनाने की क्षमता की आवश्यकता थी (यानी)
2. जब समानांतर विकास हो रहा था, तो हमें उसी संस्करण संख्या को उत्पन्न करने की आवश्यकता थी।
3. हम आसानी से नीचे ट्रैक करना चाहते थे जहां से एक संस्करण आया था।
4. जब समानांतर रेखाओं को मिला दिया गया था, तो हम चाहते थे कि नया संस्करण किसी भी शाखा से अधिक हल करे।

नंबर 2 अधिकांश लोगों के लिए अदृश्य है, लेकिन वितरित स्रोत नियंत्रण के साथ वास्तव में महत्वपूर्ण है, और वास्तव में मुश्किल है। एसवीएन आपको एक ही संशोधन संख्या देता है। यह पता चलता है कि एक कमिट गणना जितनी करीब हो सकती है, उतनी ही जादुई रूप से # 4 को हल करने में भी है। शाखाओं की उपस्थिति में, यह अभी भी अद्वितीय नहीं है, जिस स्थिति में हम हैश जोड़ते हैं, जो बड़े करीने से # 3 को हल करता है।

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

यदि आप सोच रहे हैं, तो हमने हैश के सामने r को कुछ विचित्रता के कारण चुना है कि कैसे पायथन पैकेजिंग संस्करण संख्याओं में अक्षरों को संभालती है (यानी ae 0 से कम है, जो "1.3.10.a1234" < "1.3.10" <"1.3.10.1234")।

Comments

btw, आपने चिकन-अंडे की समस्या से निपटने के लिए git-hash निर्धारित करने से पहले कैसे जांच की? क्या आपने कुछ फॉर्म का इस्तेमाल किया है।

— kfmfe04

मैंने नहीं किया। जब तक पैकेज चेक-इन के बाद लंबा नहीं हो जाता, तब तक मैं हैश का उपयोग नहीं करता। विभिन्न भाषाओं में इसे इंजेक्ट करने के अलग-अलग तरीके हैं। पायथन के लिए, मैं './setup.py egg_info -b "का उपयोग करता हूं। $ {BUILD_VERSION}" sdist'। C और C ++ के लिए, मैं 'CFLAGS = -D "$ {BUILD_VERSION}" के साथ संकलन समय पर एक मैक्रो को परिभाषित करता हूं। गो के लिए, मैं 'go install -ldflags appmodule.BuildVV "-X। $ {BUILD_VERSION}" "के साथ लिंक समय पर एक प्रतीक को परिभाषित करता हूं।

— जेसन

यह सबसे अच्छा जवाब होना चाहिए।

— एल्विनबाद

बहुत अच्छा जवाब

— हेलिक्स

Answer 3

चेकइन के समय संग्रहीत निर्देशिका ट्री में सभी फाइलों के SHA1 हैश के संस्करण की पहचान की गई है। यह हैश पैरेंट चेकइन (एस) के हैश के साथ संग्रहीत किया जाता है ताकि पूरा इतिहास पढ़ा जा सके।

GIT-VERSION-GEN के माध्यम से 'git-description' का उपयोग करने की प्रक्रिया पर एक नज़र डालें और जब आप अपनी रिलीज़ को टैग करते हैं तो आप इसे अपनी बिल्ड प्रक्रिया से कैसे जोड़ सकते हैं।

यहाँ एक अच्छा ब्लॉग है जो आपको क्या चाहिए कैसे प्राप्त करने का एक उदाहरण देता है:

http://cd34.com/blog/programming/using-git-to-generate-an-automatic-version-number/

Answer 4

यह थोड़ा अधिक हो सकता है, लेकिन मैं आपको बता दूंगा कि हम इसे कैसे करते हैं।

हम इसके समान ही एक शाखा संरचना का उपयोग करते हैं ।

हडसन हमारी "विकसित" शाखाओं का निर्माण करता है और वेतन वृद्धि 0. से शुरू होने वाली संख्या का निर्माण करता है। निर्माण संख्या प्रत्येक परियोजना के लिए अद्वितीय है और संस्करण नियंत्रण में टैग की गई है। इसका कारण यह है कि आप बता सकते हैं कि कौन सी शाखा का विकास 42 से हुआ है, उदाहरण के लिए (प्रत्येक परियोजना में समानांतर में कई विकसित शाखाएं हो सकती हैं, क्योंकि प्रत्येक परियोजना में परियोजना के विभिन्न पहलुओं पर काम करने वाली कई टीमें हो सकती हैं)।

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

उदाहरण: 2.1.0 का निर्माण 1337

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

Answer 5

जॉन पेडी का सही विचार है। git flowइन शाखाओं के वास्तविक प्रबंधन को आसान बनाता है, साथ ही, और शाखा प्रबंधन को स्थानांतरित करने के लिए एक तर्क है git।

चलो एक बुनियादी ठहरनेवाला के साथ शुरू करते हैं git, क्योंकि आप svn-to- gitपरिप्रेक्ष्य से आ रहे हैं । gitनिम्नलिखित पर विचार करें :

master--...............-.....-..............-
        \             /     /              /
         ---develop---------............../
                            \            /
                             --feature---

ऊपर, आप शाखा masterको develop(द्वारा निरूपित \), और शाखा developको featureशाखा। हम उन शाखाओं को एक शाखा के साथ वापस ( /) द्वारा निरूपित ( ) द्वारा मर्ज करते हैं -। (यदि कोई प्रतिबद्ध नहीं है लेकिन मर्ज दाईं ओर है, तो .यह दिखाने के लिए संकेतक हैं कि अगला -अगला प्रतिबद्ध है)।

काफी आसान। अगर हमारी मुख्य रिलीज़ में कोई हॉटफ़िक्स है तो क्या होगा?

master--...............-.....-................-...........-.........-
        \             /     /                / \         /|        /
         \           /     /                /   -hotfix-- V       /
          ---develop---------............../..............-...----
                             \            / \             V   /
                              --feature---   --feature2...----

ऊपर, से developशाखा master। जिस बग की खोज की गई masterथी master, उसे ब्रांच करने, उसे ठीक करने और वापस मर्ज करने से तय किया गया था master। हम तो विलय कर masterमें develop, और उसके बाद developमेंfeature2 , जिसमें से नए कोड लुढ़का hotfixइन शाखाओं में।

जब आप feature2वापस मर्ज करते हैं develop, तो इसका इतिहास इसके developसाथ शामिल होता है hotfix। इसी तरह, developमें विलय कर दिया गया है feature2से नए कोड के साथ masterहै, तो विलय developवापस करने के लिए masterके रूप में यह आधारित है, बिना किसी अवरोध के क्या होगा पर कि में प्रतिबद्ध masterहै कि समय-जैसे आप से branched था पर masterउस बिंदु पर।

तो यहाँ ऐसा करने का एक और तरीका है।

master--..........-........-
        \        /\       /
         ---1.0--  --1.1-- 

आपका 1.0 विज्ञप्ति tagged- मिल 1.0.1, 1.0.2, 1.0.3, और इसके आगे।

अब यहाँ एक चाल है: आपको 1.0 में एक बग मिला और यह 1.1, 1.2, और 1.3 को प्रभावित करता है। आप क्या करते हैं?

आप अपने नवीनतम या जल्द से जल्द बनाए गए रिलीज को बंद कर देते हैं और इसे ठीक कर देते हैं। तो फिर आप अपने नए मर्ज hotfixमें शाखा 1.3में -और 1.2, 1.1, और 1.0। रखरखाव संस्करण शाखाओं में से प्रत्येक से शाखा मत करो; आपस में नहीं मिलाते 1.0में masterया मर्ज masterमें वापस 1.0। एक hotfixशाखा लें और इसे अपनी सभी संस्करण शाखाओं में मिला लें। यदि संघर्ष हैं, तो यह आपको बताएगा; परिवर्तन सही हैं ( git diffयह आपका मित्र है) सुनिश्चित करने के लिए अपने कोड की समीक्षा करें ।

अब उस विशिष्ट परिवर्तन को हर जगह लागू किया जाता है। वंशावली शाखा है, लेकिन यह ठीक है। यह हाहाकार नहीं है। 1.31.3.17 के रूप में सिर को टैग करें , इसे प्रत्येक सुविधा-प्रगति में विलय कर दें 1.3, और आगे बढ़ें।

git flowएक्सटेंशन आपके लिए इन रखरखाव, सुविधा और हॉटफ़िक्स शाखाओं का प्रबंधन करने में मदद करता है। एक बार जब आप वर्कफ़्लो को नीचे लाते हैं, तो यह तुच्छ है और स्रोत कोड प्रबंधन से बड़ी मात्रा में परेशानी लेता है।

मैंने इसे प्रोग्रामिंग टीमों पर किया है, लेकिन मैंने खुद एक प्रोग्रामर के रूप में गहराई से काम नहीं किया है, इसलिए मैं अभी भी अपने दिन-प्रतिदिन वर्कफ़्लो के आसपास अपना सिर प्राप्त कर रहा हूं।

Answer 6

"Git Attributes" की धारा 7.2 में "Git Attributes" में प्रो Git, विस्तार भाग में RCS- शैली कीवर्ड बनाने के लिए स्मज और क्लीन फिल्टर का उपयोग करने का एक अच्छा उदाहरण है। आप अपने नियमों के अनुसार कुछ संस्करण-स्ट्रिंग को कोड में प्रारूपित और गणना करने के लिए एक ही तकनीक का उपयोग कर सकते हैं । आप अभी भी एक घूर बिंदु के रूप में उपयोग कर सकते हैं , लेकिन आपके पास किसी भी अधिक उपयुक्त रूप में बदलने और v2.5-14-feebdaed से प्राप्त करने की संभावना है, उदाहरण के लिए, साफ 2.5.14git describe

Comments

-1 विज्ञापन होमिनम हमलों के लिए पूरी तरह से बिना रुके एक अच्छे उत्तर को बर्बाद करने के लिए।

— जोर्ग डब्ल्यू मित्तग

यह कहने के लिए कि आपके नीचे मतदान करने वाले लड़के कौन थे । यह आसानी से ऐसे लोग हो सकते हैं जो थोड़ी सी शिष्टता पसंद करते हैं ।

— मार्क बूथ

FYI करें, मैंने केवल उत्तर संपादित किया है।

— कीथ थॉम्पसन

git describeटैग नाम का उत्पादन तब तक किया --longजाता है जब तक कि पारित नहीं हो जाता है या अंतिम टैग के बाद से कमिट होते हैं, इसलिए यह पहले से ही पूरी तरह से साफ है। यदि आप चूक नहीं बदल रहे थे, तो यह आपको वही देता था जो आप चाहते थे।

— स्ट्रैकट