Gần đây tôi đã rẽ nhánh một dự án và áp dụng một số bản sửa lỗi. Sau đó tôi đã tạo một yêu cầu kéo được chấp nhận.

Một vài ngày sau, một sự thay đổi khác được thực hiện bởi một người đóng góp khác. Vì vậy, ngã ba của tôi không chứa sự thay đổi đó.

Làm thế nào tôi có thể có được sự thay đổi đó vào ngã ba của tôi? Tôi có cần xóa và tạo lại ngã ba của mình khi tôi có thêm các thay đổi để đóng góp không? Hoặc có một nút cập nhật?

Trong bản sao cục bộ của kho lưu trữ rẽ nhánh của bạn, bạn có thể thêm kho lưu trữ GitHub ban đầu dưới dạng "từ xa". ("Từ xa" giống như biệt danh cho các URL của kho lưu trữ - originlà một ví dụ.) Sau đó, bạn có thể tìm nạp tất cả các nhánh từ kho lưu trữ ngược dòng đó và khởi động lại công việc của bạn để tiếp tục làm việc trên phiên bản ngược dòng. Về mặt các lệnh có thể trông giống như:

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

Nếu bạn không muốn viết lại lịch sử của nhánh chính của mình, (ví dụ vì người khác có thể đã nhân bản nó) thì bạn nên thay thế lệnh cuối cùng bằng git merge upstream/master. Tuy nhiên, để thực hiện các yêu cầu kéo tiếp theo càng sạch càng tốt, có lẽ tốt hơn là nên phản ứng lại.

Nếu bạn đã từ chối chi nhánh của mình lên, upstream/masterbạn có thể cần phải đẩy để đẩy nó đến kho lưu trữ rẽ nhánh của riêng bạn trên GitHub. Bạn sẽ làm điều đó với:

git push -f origin master

Bạn chỉ cần sử dụng -flần đầu tiên sau khi bạn đã khởi động lại.

Bắt đầu từ tháng 5 năm 2014, có thể cập nhật một ngã ba trực tiếp từ GitHub. Điều này vẫn hoạt động kể từ tháng 9 năm 2017, NHƯNG nó sẽ dẫn đến một lịch sử cam kết bẩn.

1. Mở ngã ba của bạn trên GitHub.
2. Bấm vào Pull Requests.
3. Bấm vào New Pull Request. Theo mặc định, GitHub sẽ so sánh bản gốc với bản ngã ba của bạn và không nên có bất cứ điều gì để so sánh nếu bạn không thực hiện bất kỳ thay đổi nào.
4. Nhấp vào switching the basenếu bạn thấy liên kết đó. Nếu không, hãy đặt thủ công base forkthả xuống ngã ba của bạn và head forkngược dòng. Bây giờ GitHub sẽ so sánh ngã ba của bạn với bản gốc và bạn sẽ thấy tất cả các thay đổi mới nhất.
5. Create pull requestvà gán tên dự đoán cho yêu cầu kéo của bạn (ví dụ Update from original:).
6. Cuộn xuống Merge pull request, nhưng không nhấp vào bất cứ điều gì.

Bây giờ bạn có ba tùy chọn, nhưng mỗi tùy chọn sẽ dẫn đến một lịch sử cam kết không sạch sẽ.

1. Mặc định sẽ tạo ra một cam kết hợp nhất xấu xí.
2. Nếu bạn nhấp vào menu thả xuống và chọn "Squash and merge", tất cả các cam kết can thiệp sẽ được nén thành một. Đây thường là điều bạn không muốn.
3. Nếu bạn nhấp Rebase and merge, tất cả các cam kết sẽ được thực hiện "với" bạn, các PR gốc sẽ liên kết với PR của bạn và GitHub sẽ hiển thị This branch is X commits ahead, Y commits behind <original fork>.

Vì vậy, có, bạn có thể giữ cho repo của mình được cập nhật với dòng ngược của nó bằng giao diện người dùng web GitHub, nhưng làm như vậy sẽ làm xáo trộn lịch sử cam kết của bạn. Thay vào đó, hãy bám vào dòng lệnh - thật dễ dàng.

Đây là tài liệu chính thức của GitHub về Đồng bộ hóa một ngã ba :

Đồng bộ hóa một ngã ba

Cài đặt

Trước khi bạn có thể đồng bộ hóa, bạn cần thêm một điều khiển từ xa trỏ đến kho lưu trữ ngược dòng. Bạn có thể đã làm điều này khi bạn rẽ nhánh ban đầu.

Mẹo: Đồng bộ hóa ngã ba của bạn chỉ cập nhật bản sao lưu trữ cục bộ của bạn; nó không cập nhật kho lưu trữ của bạn trên GitHub.

$ git remote -v
# List the current remotes
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)

Đồng bộ hóa

Có hai bước cần thiết để đồng bộ hóa kho lưu trữ của bạn với ngược dòng: đầu tiên bạn phải tìm nạp từ xa, sau đó bạn phải hợp nhất nhánh mong muốn vào nhánh cục bộ của mình.

Lấy

Tìm nạp từ kho lưu trữ từ xa sẽ mang lại các nhánh và các cam kết tương ứng của chúng. Chúng được lưu trữ trong kho lưu trữ cục bộ của bạn dưới các nhánh đặc biệt.

$ git fetch upstream
# Grab the upstream remote's branches
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master

Bây giờ chúng ta có nhánh chính của thượng nguồn được lưu trữ trong một nhánh cục bộ, ngược dòng / chính

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Sáp nhập

Bây giờ chúng tôi đã tìm nạp kho lưu trữ ngược dòng, chúng tôi muốn hợp nhất các thay đổi của nó vào chi nhánh địa phương của chúng tôi. Điều này sẽ mang chi nhánh đó đồng bộ với thượng nguồn, mà không làm mất các thay đổi cục bộ của chúng tôi.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md

Nếu chi nhánh địa phương của bạn không có bất kỳ cam kết duy nhất nào, thay vào đó, git sẽ thực hiện "chuyển tiếp nhanh":

$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Mẹo: Nếu bạn muốn cập nhật kho lưu trữ của mình trên GitHub, hãy làm theo các hướng dẫn tại đây

Rất nhiều câu trả lời cuối cùng di chuyển ngã ba của bạn một cam kết trước kho lưu trữ mẹ. Câu trả lời này tóm tắt các bước được tìm thấy ở đây sẽ di chuyển ngã ba của bạn đến cùng một cam kết với cha mẹ .

1. Thay đổi thư mục vào kho lưu trữ cục bộ của bạn.

   • Chuyển sang nhánh chính nếu bạn không git checkout master

2. Thêm cha mẹ như một kho lưu trữ từ xa, git remote add upstream <repo-location>

3. Vấn đề git fetch upstream

4. Vấn đề git rebase upstream/master

   • Ở giai đoạn này, bạn kiểm tra cam kết những gì sẽ được hợp nhất bằng cách gõ git status

5. Vấn đề git push origin master

Để biết thêm thông tin về các lệnh này, hãy tham khảo bước 3 .

Nếu, giống như tôi, bạn không bao giờ cam kết trực tiếp bất cứ điều gì để thành thạo , điều mà bạn thực sự nên làm, bạn có thể làm như sau.

Từ bản sao cục bộ của ngã ba của bạn, tạo điều khiển từ xa ngược dòng của bạn. Bạn chỉ cần làm điều đó một lần:

git remote add upstream https://github.com/whoever/whatever.git

Sau đó, bất cứ khi nào bạn muốn bắt kịp với nhánh chính của kho lưu trữ ngược dòng, bạn cần phải:

git checkout master
git pull upstream master

Giả sử bạn không bao giờ cam kết bất cứ điều gì về bản thân, bạn nên hoàn thành nó. Bây giờ bạn có thể đẩy chủ địa phương của mình đến ngã ba GitHub từ xa. Bạn cũng có thể khởi động lại chi nhánh phát triển của mình trên chủ địa phương hiện tại.

Qua thiết lập ngược dòng ban đầu và kiểm tra tổng thể, tất cả những gì bạn cần làm là chạy lệnh sau để đồng bộ hóa chủ của bạn với ngược dòng: git kéo ngược dòng chính .

Lời nói đầu: Ngã ba của bạn là "nguồn gốc" và kho lưu trữ mà bạn rẽ nhánh là "thượng nguồn".

Giả sử rằng bạn đã nhân bản ngã ba của bạn vào máy tính của bạn bằng một lệnh như thế này:

git clone git@github.com:your_name/project_name.git
cd project_name

Nếu điều đó được đưa ra thì bạn cần tiếp tục theo thứ tự này:

1. Thêm "ngược dòng" vào kho lưu trữ nhân bản của bạn ("nguồn gốc"):

   git remote add upstream git@github.com:original_author/project_name.git
   

2. Lấy các cam kết (và các nhánh) từ "thượng nguồn":

   git fetch upstream
   

3. Chuyển sang nhánh "chính" của ngã ba của bạn ("nguồn gốc"):

   git checkout master
   

4. Bỏ bớt những thay đổi của nhánh "chính" của bạn:

   git stash
   

5. Hợp nhất các thay đổi từ nhánh "chính" của "thượng nguồn" thành nhánh "chính" của "gốc" của bạn:

   git merge upstream/master
   

6. Giải quyết xung đột hợp nhất nếu có và cam kết hợp nhất của bạn

   git commit -am "Merged from upstream"
   

7. Đẩy các thay đổi vào ngã ba của bạn

   git push
   

8. Nhận lại các thay đổi được đặt của bạn (nếu có)

   git stash pop
   

9. Bạn đã hoàn tất! Xin chúc mừng!

GitHub cũng cung cấp hướng dẫn cho chủ đề này: Đồng bộ hóa một ngã ba

Kể từ tháng 11 năm 2013, đã có một yêu cầu tính năng không chính thức được mở với GitHub để yêu cầu họ thêm một phương thức rất đơn giản và trực quan để giữ cho một ngã ba cục bộ đồng bộ với ngược dòng:

https://github.com/isaacs/github/issues/121

Lưu ý: Vì yêu cầu tính năng không chính thức, bạn cũng nên liên hệ support@github.comđể thêm hỗ trợ cho một tính năng như thế này sẽ được triển khai. Yêu cầu tính năng không chính thức ở trên có thể được sử dụng làm bằng chứng về số tiền lãi trong việc này đang được thực hiện.

Kể từ ngày trả lời này, GitHub không ( hoặc tôi sẽ nói không còn nữa? ) Tính năng này trong giao diện web. Tuy nhiên, bạn có thể yêu cầu support@github.comthêm phiếu bầu của mình cho điều đó.

Trong khi đó, người dùng GitHub bardiharborow đã tạo ra một công cụ để làm việc này: https://upriver.github.io/

Nguồn ở đây: https://github.com/upriver/upriver.github.io

Nếu bạn đang sử dụng GitHub cho Windows hoặc Mac thì bây giờ họ có tính năng một lần nhấp để cập nhật các nhánh:

1. Chọn kho lưu trữ trong UI.
2. Nhấp vào nút "Cập nhật từ người dùng / chi nhánh" trên cùng.

Trên thực tế, có thể tạo một nhánh trong nhánh của bạn từ bất kỳ cam kết ngược dòng nào trong trình duyệt:

• Mở https://github.com/<repo>/commits/<hash>, trong đó repo là ngã ba của bạn và hàm băm là hàm băm đầy đủ của cam kết mà bạn có thể tìm thấy trong giao diện web ngược dòng. Ví dụ: tôi có thể mở https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , chỉ đến linux masterthời điểm viết.
• Nhấp vào nút "Cây: ....".
• Nhập tên của chi nhánh mới và nhấn Enter

Sau đó, bạn có thể tìm nạp chi nhánh đó đến bản sao cục bộ của mình và bạn sẽ không phải đẩy tất cả dữ liệu đó trở lại GitHub khi bạn đẩy các chỉnh sửa lên trên cam kết đó. Hoặc sử dụng giao diện web để thay đổi một cái gì đó trong nhánh đó.

Cách thức hoạt động (đó là một phỏng đoán, tôi không biết chính xác GitHub làm như thế nào): forks chia sẻ lưu trữ đối tượng và sử dụng không gian tên để phân tách các tham chiếu của người dùng. Vì vậy, bạn có thể truy cập tất cả các cam kết thông qua ngã ba của mình, ngay cả khi chúng không tồn tại vào thời điểm rèn.

Thực hiện theo các bước dưới đây. Tôi đã thử chúng và nó đã giúp tôi.

Thanh toán cho chi nhánh của bạn

Cú pháp: git nhánh yourDevelopmentBranch
Ví dụ: git checkout master

Kéo nhánh kho lưu trữ nguồn để lấy mã mới nhất

Cú pháp: git pull https://github.com/tastejs/awclaw-app-ideas master
Ví dụ: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Tôi cập nhật repos ngã ba của mình với một dòng này:

git pull https://github.com/forkuser/forkedrepo.git branch

Sử dụng điều này nếu bạn không muốn thêm một điểm cuối từ xa khác vào dự án của mình, như các giải pháp khác được đăng ở đây.

Để bổ sung cho câu trả lời này, tôi đã tìm cách cập nhật tất cả các nhánh từ xa của repo nhân bản ( nguồn gốc ) từ thượng nguồn các nhánh trong một lần. Đây là cách tôi đã làm nó.

Điều này giả định rằng bạn đã cấu hình một điều khiển từ xa ngược dòng vào kho lưu trữ nguồn (nơi gốc được rẽ nhánh từ đó) và đã đồng bộ hóa nó vớigit fetch upstream .

Sau đó chạy:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

Phần đầu tiên của lệnh này liệt kê tất cả các đầu trong repo từ xa ngược dòng và loại bỏ SHA-1 theo saurefs/heads/ tiền tố tên nhánh.

Sau đó, đối với mỗi nhánh này, nó sẽ đẩy bản sao cục bộ của nhánh theo dõi từ xa ngược dòng ( refs/remotes/upstream/<branch>về phía cục bộ) trực tiếp đến nhánh từ xa về nguồn gốc (refs/heads/<branch> ở phía xa).

Bất kỳ lệnh đồng bộ nhánh nào trong số này có thể không thành công vì một trong hai lý do: hoặc nhánh ngược dòng đã được viết lại hoặc bạn đã đẩy các cam kết trên nhánh đó đến ngã ba của mình. Trong trường hợp đầu tiên khi bạn không cam kết bất cứ điều gì với nhánh trên ngã ba của mình, bạn có thể đẩy mạnh (Thêm công tắc -f ; tức là git push -ftrong lệnh trên). Trong trường hợp khác, điều này là bình thường vì nhánh rẽ nhánh của bạn đã chuyển hướng và bạn không thể mong đợi lệnh đồng bộ hóa hoạt động cho đến khi các cam kết của bạn được hợp nhất trở lại ngược dòng .

Các "Kéo" ứng dụng là một giải pháp tự động set-up-and-quên. Nó sẽ đồng bộ nhánh mặc định của ngã ba của bạn với kho lưu trữ ngược dòng.

Truy cập URL, nhấp vào nút "Cài đặt" màu xanh lục và chọn kho lưu trữ nơi bạn muốn bật đồng bộ hóa tự động.

Chi nhánh được cập nhật một lần mỗi giờ trực tiếp trên GitHub, trên máy cục bộ của bạn, bạn cần kéo chi nhánh chính để đảm bảo rằng bản sao cục bộ của bạn được đồng bộ hóa.

Android Studio hiện đã học cách làm việc với kho lưu trữ ngã ba GitHub (bạn thậm chí không phải thêm kho lưu trữ từ xa "ngược dòng" bằng lệnh console).

Mở menu VCS → Git

Và chú ý đến hai mục menu bật lên cuối cùng:

• Rebase ngã ba GitHub của tôi

• Tạo yêu cầu kéo

Thử chúng đi. Tôi sử dụng cái đầu tiên để đồng bộ hóa kho lưu trữ cục bộ của tôi. Dù sao, các nhánh từ kho lưu trữ từ xa gốc ("ngược dòng") sẽ có thể truy cập được trong Android Studio sau khi bạn nhấp vào "Rebase my GitHub fork" và bạn sẽ có thể hoạt động dễ dàng với chúng.

(Tôi sử dụng Android Studio 3.0 với các plugin "Tích hợp Git" và "GitHub".)

Khi bạn đã sao chép kho lưu trữ rẽ nhánh của mình, hãy chuyển đến đường dẫn thư mục nơi bản sao của bạn cư trú và một vài dòng trong Git Bash Terminal của bạn.

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

Và ở đó bạn tốt để đi. Tất cả các thay đổi được cập nhật trong kho lưu trữ chính sẽ được đẩy vào kho lưu trữ ngã ba của bạn.

Lệnh "tìm nạp" là không thể thiếu để luôn cập nhật trong một dự án: chỉ khi thực hiện "git fetch", bạn mới được thông báo về những thay đổi mà đồng nghiệp của bạn đã đẩy đến máy chủ từ xa.

Bạn vẫn có thể truy cập vào đây để truy vấn thêm

Nếu bạn đặt ngược dòng của bạn. Kiểm tra với git remote -v, sau đó điều này sẽ đủ.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

Điều đó phụ thuộc vào kích thước của kho lưu trữ của bạn và cách bạn rẽ nhánh nó.

Nếu đó là một kho lưu trữ lớn, bạn có thể muốn quản lý nó theo một cách đặc biệt (ví dụ: lịch sử thả). Về cơ bản, bạn có thể nhận được sự khác biệt giữa các phiên bản hiện tại và ngược dòng, cam kết chúng và sau đó chọn lại anh đào để làm chủ.

Hãy thử đọc cái này . Nó mô tả cách xử lý các kho Git lớn và cách ngược dòng chúng với những thay đổi mới nhất.

Tôi muốn thêm vào câu trả lời của @ krlmlr .

Ban đầu, kho lưu trữ rẽ nhánh có một nhánh có tên : master. Nếu bạn đang làm việc trên một tính năng mới hoặc một bản sửa lỗi, bạn thường sẽ tạo một chi nhánh mớifeature và thực hiện các thay đổi.

Nếu bạn muốn kho lưu trữ được đồng bộ hóa với kho lưu trữ gốc, bạn có thể thiết lập tệp cấu hình ( pull.yml) cho ứng dụng Kéo ( trong nhánh tính năng ), như sau:

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

Điều này giữ cho masterchi nhánh của repo ngã ba được cập nhật với repo cha. Nó giữ cho featurenhánh của repo rẽ nhánh được cập nhật thông qua masternhánh của repo rẽ nhánh bằng cách hợp nhất. Điều này giả định rằng featurenhánh là nhánh mặc định chứa tệp cấu hình.

Ở đây có hai mergemethodstrò chơi, một là hardresetgiúp buộc thay đổi đồng bộ hóa trong masternhánh của repo rẽ nhánh với repo gốc và phương thức khác là merge. Phương pháp này được sử dụng để hợp nhất các thay đổi do bạn thực hiện trong featurechi nhánh và các thay đổi được thực hiện do đồng bộ hóa lực lượng trongmaster chi nhánh. Trong trường hợp xung đột hợp nhất, ứng dụng kéo sẽ cho phép bạn chọn hướng hành động tiếp theo trong yêu cầu kéo.

Bạn có thể đọc về cấu hình cơ bản và nâng cao và khác nhau mergemethods ở đây .

Tôi hiện đang sử dụng cấu hình này trong repo rẽ nhánh của mình ở đây để đảm bảo cải tiến được yêu cầu ở đây vẫn được cập nhật.

Có hai điều chính trong việc giữ cho một kho lưu trữ rẽ nhánh luôn cập nhật cho tốt.

1. Tạo các nhánh từ chủ ngã ba và thay đổi ở đó .

Vì vậy, khi Yêu cầu kéo của bạn được chấp nhận thì bạn có thể xóa chi nhánh một cách an toàn vì mã đóng góp của bạn sẽ tồn tại trong tổng thể của kho lưu trữ rẽ nhánh của bạn khi bạn cập nhật nó với dòng ngược. Bằng cách này, chủ của bạn sẽ luôn trong tình trạng sạch sẽ để tạo một nhánh mới để thực hiện một thay đổi khác.

2. Tạo một công việc được lên lịch để chủ ngã ba tự động cập nhật .

Điều này có thể được thực hiện với cron . Đây là mã ví dụ nếu bạn làm điều đó trong linux.

$ crontab -e

đặt mã này vào crontab fileđể thực hiện công việc hàng giờ.

0 * * * * sh ~/cron.sh

sau đó tạo cron.shtệp script và tương tác git với ssh-agent và / hoặc mong đợi như bên dưới

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="git@github.com:<username>/$REPOSITORY.git"   
UPSTREAM=git@github.com:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

Kiểm tra kho lưu trữ của bạn. Thỉnh thoảng nó sẽ luôn hiển thị thông báo này:

Chi nhánh này thậm chí với <upstream>: chủ .

Sử dụng các lệnh này (trong trường hợp may mắn)

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v