จะใช้ github, branch และรีลีสอัตโนมัติสำหรับการจัดการเวอร์ชั่นได้อย่างไร? [ปิด]

ฉันเข้าใจแนวคิดพื้นฐานของ Git / Github ส่วนใหญ่แล้วในตอนนี้อย่างไรก็ตามฉันยังคงมีปัญหาในการเข้าใจภาพรวมที่ใหญ่ขึ้น

นี่คือบางสิ่งที่ฉันสามารถทำให้ทำงานได้จนถึงตอนนี้:

• ผลักดันมุ่งมั่น
• ทำงานกับสาขา
• รวม Github กับ Travis CI ซึ่งเป็นระบบการรวมอย่างต่อเนื่อง
• Via Travis CI สร้างโดยอัตโนมัติทุกคอมมิทถึงมาสเตอร์และวางจำหน่ายเป็น ZIP บน Github ภายใต้รีลีส

อย่างไรก็ตามฉันเพิ่งทำงานกับโปรเจ็กต์เวอร์ชันอัลฟ่า / เบต้าเท่านั้นดังนั้นฉันจึงไม่เคยเห็นเวอร์ชันที่เผยแพร่ในทางปฏิบัติเลย

ดังนั้นฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการกำหนดรุ่นการบำรุงรักษารุ่นแยกต่างหากการแก้ไขด่วนรุ่น ฯลฯ

ฉันจะมั่นใจได้อย่างไรว่าสิ่งต่าง ๆ ต่อไปนี้เกิดขึ้น:

• มีเวอร์ชันของโครงการต่าง ๆ ของฉันเช่นเวอร์ชัน 1.1.0 และ 2.0.0
• มีความสามารถในการผลักดันโปรแกรมแก้ไขด่วนในรุ่นเรียงลำดับของกระแทกกับรุ่น 1.1.1 หรือ 2.0.1 เป็นต้น
• สร้างระบบการรวมอย่างต่อเนื่องสร้างรุ่นนั้นโดยอัตโนมัติเมื่อกระทำและหากสำเร็จให้เผยแพร่รุ่นสำหรับรุ่นนั้นโดยเฉพาะ

ฉันสงสัยระหว่างตัวเลือกต่อไปนี้:

• ฉันจำเป็นต้องใช้แท็กสำหรับทุกเวอร์ชันหรือไม่ ถ้าเป็นเช่นนั้นระบบการรวมอย่างต่อเนื่องจะสร้างการเผยแพร่โดยอัตโนมัติได้อย่างไร
• ฉันควรสร้างสาขาสำหรับทุกรุ่นหรือไม่ ถ้าเป็นเช่นนั้นจะไม่สร้างสาขาทั้งหมด (เช่นสาขา 1.1 และสาขา 2.0 โปรแกรมแก้ไขด่วนจะไปยังสาขานั้น ๆ )
• ฉันจะระบุหมายเลขรุ่นได้อย่างไร มันโอเคที่จะมีไฟล์กำหนดค่าที่ระบุหมายเลขเวอร์ชั่นหรือมีวิธีที่ชาญฉลาดกว่านี้ไหม? ในกรณีนี้มันจะเป็นโครงการ Java ถ้าเรื่องนั้นสำคัญ

คุณควรดูที่คอมไพล์ไหล มันเป็นรูปแบบการแตกแขนงที่ยอดเยี่ยม

สรุปการไหลของ Git

การแตกแขนง

ลำต้นหลักที่อยู่รอบ ๆ ตลอดไปคือdevelopและmaster. masterถือรุ่นล่าสุดของคุณและdevelopถือสำเนาการพัฒนา "มั่นคง" ล่าสุดของคุณ

ผู้สนับสนุนสร้างfeatureสาขา (นำหน้าด้วยfeature/แบบแผน) จากdevelop :

$ git checkout -b feature/my-feature develop

และhotfixสาขา (นำหน้าด้วยhotfix/การประชุม) จากmaster:

# hotfix the latest version of master
$ git checkout -b hotfix/hotfix-version-number master

# or hotfix from a specific version
$ git checkout -b hotfix/hotfix-version-number <starting-tag-name>

กิ่งไม้เหล่านี้เป็น "แบบใช้ครั้งเดียว" ซึ่งหมายความว่าพวกมันมีอายุการใช้งานสั้นก่อนที่พวกมันจะรวมกลับไปที่ลำต้นหลัก มีไว้เพื่อหุ้มฟังก์ชั่นชิ้นเล็ก ๆ

สาขาการตกแต่ง

เมื่อผู้มีส่วนร่วมทำกับfeatureสาขาพวกเขารวมมันกลับเข้าไปในdevelop:

$ git checkout develop
$ git merge --no-ff feature/my-feature
$ git branch -d feature/my-feature

เมื่อพวกเขาทำกับhotfixสาขาพวกเขารวมมันกลับเข้าไปในทั้งสองmasterและdevelopดำเนินการแก้ไขด่วน:

$ git checkout master
$ git merge --no-ff hotfix/hotfix-version-number
$ git checkout develop
$ git merge --no-ff hotfix/hotfix-version-number
$ git branch -d hotfix/hotfix-version-number

นี่คือด้านการรวมอย่างต่อเนื่อง

ข่าว

เมื่อคุณพร้อมที่จะเริ่มต้นการบรรจุหีบห่อคุณสร้างreleaseสาขาจากสาขา "เสถียร" ของคุณdevelop(เช่นเดียวกับการสร้างfeatureสาขา) จากนั้นคุณชนหมายเลขรุ่นในแท็ก (อธิบายไว้ด้านล่าง)

การใช้releaseสาขาแยกช่วยให้คุณสามารถพัฒนาฟีเจอร์ใหม่ต่อไปdevelopในขณะที่คุณแก้ไขข้อบกพร่องและเพิ่มสัมผัสการตกแต่งให้กับreleaseสาขา

เมื่อคุณพร้อมที่จะเสร็จสิ้นการปล่อยคุณรวมreleaseสาขาในทั้งสองmasterและdevelop(เช่นเดียวกับhotfix) เพื่อให้การเปลี่ยนแปลงทั้งหมดของคุณดำเนินต่อไป

แท็ก

เมื่อคุณสร้างreleaseสาขาหรือhotfixสาขาคุณจะชนหมายเลขเวอร์ชันอย่างเหมาะสมในแท็ก ด้วย vanilla git ที่มีลักษณะเช่นนี้:

$ git tag -a <tag-name> -m <tag-description>

จากนั้นคุณจะต้องผลักดันแท็ก (แยกต่างหาก) ไปยังที่เก็บระยะไกลของคุณ:

$ git push --tags

มันมักจะดีที่สุดที่จะใช้เวอร์ชันความหมายmajor.minor.hotfixซึ่งในรุ่นของคุณจะนำรูปแบบ การกระแทกที่สำคัญจะย้อนกลับเข้ากันไม่ได้ในขณะที่การกระแทกเล็กน้อยและการแก้ไขด่วนจะไม่เข้ากันได้ย้อนหลัง (ยกเว้นว่าคุณอยู่ในรุ่นเบต้า0.x.x)

การผสม

ดังที่คุณเห็นด้านบน git-flow สนับสนุนให้คุณรวมสาขาด้วยคำสั่งต่อไปนี้:

$ git merge --no-ff <branch-name>

--no-ffตัวเลือกที่ช่วยให้คุณรักษาประวัติศาสตร์ของสาขาของคุณโดยไม่ต้องออกพวงของสาขาโกหกรอบในปัจจุบันกระทำของพื้นที่เก็บข้อมูล (ดังนั้นไม่ต้องกังวลคุณจะไม่ได้มีสาขาทุกรุ่น)

คุณยังได้รับการสนับสนุนที่จะดึงออกมาด้วย

$ git pull --rebase

ดังนั้นคุณจะไม่เพิ่มการรวมที่ไร้ประโยชน์จำนวนมาก

.gitconfigคุณสามารถกำหนดค่าคอมไพล์จะทำทั้งสองสิ่งเหล่านี้โดยเริ่มต้นในของคุณ ฉันจะให้คุณดูอย่างนั้น;)

กำลังดูรุ่น

เมื่อใครบางคนกำลังมองหา codebase ของคุณพวกเขาสามารถเช็คเอาต์แท็กด้วยชื่อ:

# checkout in detached HEAD to browse
$ git checkout <tag-name>

# OR checkout and create a new local branch (as you might for a hotfix)
$ git checkout -b <new-branch-name> <tag-name>

หรือหากมีใครบางคนกำลังเรียกดูบน GitHub นอกจากนี้ยังมีแท็บ "แท็ก" ในเมนูแบบเลื่อนลง "สาขา"

ใช้ส่วนขยาย git-flow (แนะนำ)

วิธีที่ฉันโปรดปรานในการใช้โมเดลนี้คือส่วนขยาย git flowสำหรับ git

( แก้ไข:หลุยส์ได้แนะนำส้อม AVHซึ่งทำงานได้ดีขึ้นgit describeและอาจใช้งานได้มากขึ้นในขณะนี้ขอบคุณ Louis

ส่วนขยายจะทำให้ส่วนที่ยุ่งทั้งหมดโดยอัตโนมัติ (เช่นการใช้merge --no-ffและการลบสาขาหลังจากการรวม) เพื่อให้คุณสามารถดำเนินชีวิตต่อไปได้

ตัวอย่างเช่นด้วยส่วนขยายคุณสามารถสร้างสาขาคุณลักษณะดังนี้:

$ git flow feature start my-feature-name

และทำมันให้จบ

$ git flow feature finish my-feature-name

คำสั่งสำหรับโปรแกรมแก้ไขด่วนและการเปิดตัวจะคล้ายกันแม้ว่าพวกเขาจะใช้หมายเลขรุ่นแทนชื่อสาขาเช่น:

# Create hotfix number 14 for this minor version.
$ git flow hotfix start 2.4.14

# Create the next release
$ git flow release start 2.5.0

จากนั้น Git flow จะสร้างแท็กเวอร์ชันสำหรับคุณและขอเตือนให้คุณชนเวอร์ชันในไฟล์กำหนดค่าหรือไฟล์ Manifest (ซึ่งคุณสามารถทำได้กับตัวจัดการงานอย่าง Grunt)

หวังว่าจะช่วย :) ฉันไม่แน่ใจว่าคุณจะรวมทุกอย่างเข้ากับการตั้งค่า Travis CI ของคุณได้อย่างไร แต่ฉันคิดว่า githooks จะพาคุณไปที่นั่น

ฉันจำเป็นต้องใช้แท็กสำหรับทุกรุ่นหรือไม่

ไม่คุณไม่จำเป็นต้องใช้แท็กเลย หากคุณต้องการติดแท็กทุกรุ่นที่ไม่เป็นไรหรือถ้าคุณต้องการติดแท็กทุกครั้งที่ระบบ CI ของคุณสร้างขึ้นคุณก็สามารถทำได้เช่นกัน แท็กเป็นเพียงการให้ชื่อที่เป็นมิตรกับผู้ใช้แก่ผู้ใช้เพื่อให้คุณสามารถดึงมันขึ้นมาและดูในภายหลัง

ฉันควรสร้างสาขาสำหรับทุกรุ่นหรือไม่

แน่นอน! การแบรนช์มีราคาถูก / ฟรีใน Git ดังนั้นฉันจึงใช้ประโยชน์จากทุกโอกาสที่ได้รับ คุณสามารถผสานและลบสาขาได้อย่างรวดเร็วเช่นกัน หากคุณรู้สึกว่าคุณมีสาขาหลายสาขาคุณสามารถตัดมันทิ้งในภายหลังด้วยการผสานแบบเลือกสรร มีรูปแบบการแยกย่อยของ Git ที่พร้อมใช้งานเช่นกันหากคุณต้องการใช้รูปแบบที่พยายามและเป็นจริง

ฉันจะระบุหมายเลขรุ่นได้อย่างไร

แท็กมักจะเป็นวิธีที่คุณระบุหมายเลขเวอร์ชันเนื่องจากเกี่ยวข้องกับ git หากคุณกำลังพูดถึงวิธีการสร้างโครงการหรือวิธีที่ดีที่สุดในการทำเช่นนั้นคุณจะต้องทำการขุดบ้างเนื่องจากเป็นคำถามที่อิงตามความเห็นอย่างเป็นธรรม บางโปรเจ็กต์ยังคงอยู่ในเบต้าตลอดไปบางโปรเจ็กต์จะเพิ่มเวอร์ชันเต็มจำนวนเหมือนกำลังจะหมดสไตล์ (มองโครเมี่ยมของคุณ)

ฉันจำเป็นต้องใช้แท็กสำหรับทุกเวอร์ชันหรือไม่

หากตาม "version" คุณหมายถึงชุดของไฟล์ที่ประกอบขึ้นเป็นรีลีสหรือตัวเลือกรีลีสฉันขอแนะนำให้ติดแท็กทุกเวอร์ชัน หากคุณต้องการอ้างถึงเวอร์ชั่น 1.2.7 ตามท้องถนนคุณต้องการล่าแฮชคอมมิชชันหรือเพียงแค่ใช้หมายเลขเวอร์ชั่น?

นอกจากนี้หากคุณใช้git describeในการบันทึกข้อมูลการสร้างที่ไหนสักแห่ง (เช่นฉัน) แล้วการใช้แท็กช่วยให้มันให้ผลลัพธ์ที่ดีกว่ามาก

ถ้าเป็นเช่นนั้นระบบการรวมอย่างต่อเนื่องจะสร้างการเผยแพร่โดยอัตโนมัติได้อย่างไร

ระบบการรวมอย่างต่อเนื่องสามารถสร้างการเผยแพร่โดยไม่คำนึงถึงวิธีการที่คุณใช้แท็ก คุณสามารถบอกได้ว่ามันจะสร้างการปล่อยบนพื้นฐานของแฮชคอมมิท แท็กทำให้ชีวิตของคุณง่ายขึ้น

ฉันควรสร้างสาขาสำหรับทุกรุ่นหรือไม่ ถ้าเป็นเช่นนั้นจะไม่สร้างสาขาทั้งหมด (เช่นสาขา 1.1 และสาขา 2.0 โปรแกรมแก้ไขด่วนจะไปยังสาขานั้น ๆ )

ฉันไม่เห็นว่าการแตกแขนงเป็นสิ่งที่ "ต่อรุ่น" ฉันมีโปรเจ็กต์สองสามรุ่นที่เวอร์ชันทั้งหมดของฉันมุ่งมั่นที่masterสาขา ฉันไม่ต้องการอะไรที่ซับซ้อนมากกว่านี้ในตอนนี้เพราะไม่มีโครงการใดอยู่ในช่วงที่มีเสถียรภาพและไม่จำเป็นต้องสนับสนุนเวอร์ชันเก่าในระยะยาว แต่สมมุติว่าฉันปล่อย 1.0, 1.1, 1.2 จากนั้นฉันก็ปล่อย 2.0 และฉันยังต้องสนับสนุน 1.0 ซีรีส์ด้วยการแก้ไขความปลอดภัย ฯลฯ จากนั้นแน่นอนฉันมีสาขาที่จะวางการบำรุงรักษาสำหรับซีรี่ย์ 1.x .

ฉันจะระบุหมายเลขรุ่นได้อย่างไร มันโอเคที่จะมีไฟล์กำหนดค่าที่ระบุหมายเลขเวอร์ชั่นหรือมีวิธีที่ชาญฉลาดกว่านี้ไหม? ในกรณีนี้มันจะเป็นโครงการ Java ถ้าเรื่องนั้นสำคัญ

การมีแหล่งที่มาเดียวสำหรับหมายเลขเวอร์ชันของคุณเช่นไฟล์กำหนดค่าเป็นวิธีที่ดีที่สุดเนื่องจากป้องกันข้อผิดพลาดของไขมันนิ้วที่อาจเกิดขึ้นได้หากคุณต้องอัปเดตตัวเลขในหลาย ๆ ที่ ฉันกำลังพูดจาก ... อืม ... ประสบการณ์ที่น่าอาย คุณปล่อย 1.3 เพื่อค้นหาว่าซอฟต์แวร์ยังรายงานว่าเป็นรุ่น 1.2 เท่านั้น อ๊ะ!

ในอีกคำตอบ mxdubois แนะนำ gitflow ให้คุณ ถ้าคุณตัดสินใจที่จะใช้ gitflow ผมอยากแนะนำให้ใช้รุ่น AVH เวอร์ชันดั้งเดิมจะไม่ได้รับการดูแลรักษาอีกต่อไป ข้อแตกต่างที่น่าสังเกตประการหนึ่งคือรุ่น AVH ทำการผสานการปล่อยที่อนุญาตให้git describeทำงานได้อย่างชาญฉลาด รุ่นเดิมดำเนินการผสานในทางที่เป็นทริปgit describe

กำลังสแกนรายการของคุณฉันเห็นเวอร์ชันเป็นจุดสนใจของคุณดังนั้น ...

วิธีหนึ่งในการบำรุงรักษาเวอร์ชันคือมีสาขาและการรวม (หรือการรีบูต)

ดังนั้นคุณมี:

master

จากนั้นคุณสร้างสาขา

v1

จากนั้นคุณเพิ่มการเปลี่ยนแปลงเพิ่มเติมให้กับ

master(diff1)

จากนั้นคุณสร้างสาขา

v3

จากนั้นคุณเพิ่มการเปลี่ยนแปลงเพิ่มเติมให้กับ

master(diff2)

ขณะนี้:

หากต้องการอัปเดตเวอร์ชัน 2 คุณต้องดำเนินการ

git checkout v2
git merge master  # for the changes you want to bring into version 2
# rebasing is also an option
# resolve any merge conflicts
# Done.

เพื่ออัปเดตเวอร์ชัน 3

git checkout v3
git merge master

ด้านบนสำหรับการอัปเดตขายส่ง

อาจเป็นไปได้ว่าคุณจะต้องการเลือกการเปลี่ยนแปลงเฉพาะที่มี

git cherry-pick

เพิ่มเติมเกี่ยวกับการเก็บเชอร์รี่ที่http://git-scm.com/docs/git-cherry-pick