Git
Chapters ▾ 2nd Edition

2.5 Mga Pangunahing Kaalaman sa Git - Paggawa gamit ang mga Remote

Paggawa gamit ang mga Remote

Upang magawa ang pakikipagtutulungan sa anumang proyekto sa Git, kailangan mong malaman kung paano papangasiwaan ang iyong mga remote na repositoryo. Ang mga naka-remote na repositoryo ay mga bersyon ng iyong proyekto na naka-host sa Internet o sa saan mang lugar sa network. Maaari kang magkaroon iilan sa kanila, sa pangkalahatan bawat isa ay maaaring read-only o read/write para sayo. Ang pakikipagtulungan sa iba ay naglalakip sa pamamahala sa naka-remote na mga repositoryo na ito at pag-push at pag-pull ng datos sa patutunguhan at sa pinanggalingan nila kapag kailangan mong magbahagi ng trabaho. Ang pagpapangasiwa ng naka-remote na mga repositoryo ay naglakip nang kaalaman kung paano magdagdag ng naka-remote na mga repositoryo, mag-alis sa mga naka-remote na hindi na magagamit, mangangasiwa ng iba’t ibang mga sanga at tukuyin ang mga ito kung sinusubaybayan o hindi, at marami pang iba. Sa seksyon na ito, tatalakayin natin ang iilan sa mga kakayahan sa pagpapangasiwa ng naka-remote na repositoryo.

Example 2. Ang naka-remote na mga repositoryo ay maaaring nasa iyong lokal na makina.

Ito ay posible na ikaw ay nagtatrabaho sa isang “naka-remote” na repositoryo na iyan, at sa katunayan, nasa parehong host kung saan nandoon ka. Ang salitang “remote” ay hindi kinakailangan nagpapahiwatig na ang repositoryo ay nasa ibang lugar sa network o Internet, tanging ito ay nasa ibang lugar lang. Ang pagtrabaho sa isang naka-remote na repositoryo gaya nito ay magkakaroon pa rin sa lahat ng karaniwang pag-push, pag-pull at pag-fetch ng mga operasyon tulad ng sa ibang anumang nakaremote.

Pagpapakita ng iyong mga Remote

Upang makita kung aling remote na mga server ang iyong na-configure, maaari mong patakbuhin ang git remote na utos. Inilista nito ang mga alyas sa bawat remote na handle na iyong itinukoy. Kung na-clone mo ang iyong repositoryo, dapat mong makita ang origin — iyon ang naka-default na pangalan na ibinigay ng Git sa server na pinagmulan ng iyong naka-clone na repositoryo:

$ git clone https://github.com/schacon/ticgit
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
origin

Maaari mo ring ilagay ang -v, na nagpapakita sa iyo sa mga URL na iniimbak ng Git na alyas para magagamit kapag nagbabasa at nagsusulat sa remote na iyon:

$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)

Kung mayroon kang higit pa sa isang remote, ang utos ay naglilista sa kanilang lahat. Bilang halimbawa, ang isang repositoryo na may maramihang mga remote para sa pakikipagtulungan sa mga iilang mga taga-ambag ay maaaring maging tulad nito.

$ cd grit
$ git remote -v
bakkdoor  https://github.com/bakkdoor/grit (fetch)
bakkdoor  https://github.com/bakkdoor/grit (push)
cho45     https://github.com/cho45/grit (fetch)
cho45     https://github.com/cho45/grit (push)
defunkt   https://github.com/defunkt/grit (fetch)
defunkt   https://github.com/defunkt/grit (push)
koke      git://github.com/koke/grit.git (fetch)
koke      git://github.com/koke/grit.git (push)
origin    git@github.com:mojombo/grit.git (fetch)
origin    git@github.com:mojombo/grit.git (push)

Ang ibig sabihin nito ay maaari naming madaling i-pull ang mga kontribusyon mula sa sinumang mga gumagamit Maaari nating idagdag ang mga pahintulot na mag-push sa isa o higit pa sa mga ito, bagaman hindi natin ito masasabi dito.

Kung mapansin mo ang mga remote na ito ay gumagamit ng napakaraming mga protokol; tatalakayin pa natin ito nang malaliman sa Pagkuha ng Git sa isang Server.

Pagdagdag ng Remote na mga Repositoryo

Nabanggit at ibinigay na namin ang ilang mga pagpapakita kung paano ang git clone na utos ay sadyang nagdagdag ng origin na remote para sa iyo. Narito ang paraan kung papaano hayagang magdagdag ng isang bagong remote. Para makadagdag ng bagong remote na repositoryo ng Git bilang isang alyas para madali mong magamit, patakbuhin ang git remote add <shortname> <url>:

$ git remote
origin
$ git remote add pb https://github.com/paulboone/ticgit
$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)
pb	https://github.com/paulboone/ticgit (fetch)
pb	https://github.com/paulboone/ticgit (push)

Ngayon maaari mo nang gamitin ang string pb sa command line sa halip ng buong URL. Halimbawa, kung gusto mong kunin ang lahat ng impormasyon na mayroon si Pablo ngunit wala pa sa iyong repositoryo, maaari mong patakbuhin ang git fetch pb:

$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
From https://github.com/paulboone/ticgit
 * [new branch]      master     -> pb/master
 * [new branch]      ticgit     -> pb/ticgit

Ang master branch ni Pablo ay magagamit na ngayon sa lokal bilang pb/master — maaari mo itong i-merge sa isa sa iyong mga branch, o maaari mong suriin ang lokal na branch sa puntong iyon kung gusto mong siyasatin ito. (Ating tatalakayin kung ano ang mga branch at kung paano gamitin ang mga ito na mas detalyado sa Pag-branch ng Git.)

Pag-fetch at Pag-Pull mula sa iyong mga Remote

Tulad ng iyong nakikita, upang makakuha ng datos mula sa iyong remote na mga proyekto, maaari kang magtakbo:

$ git fetch <remote>

Ang utos ay napupunta sa remote na proyekto na iyon at nagkuha sa lahat ng datos mula sa remote na proyekto na iyon na wala ka pa. Pagkatapos mong gawin ito, mayroon ka ng mga reperensiya sa lahat ng mga branch mula sa remote na iyon, kung saan maaari mo itong i-merge o siyasatin sa anumang oras.

Kung mag-clone ka ng isang repositoryo, ang utos ay awtomatikong nagdagdag sa remote na repositoryo na iyon sa ilalim ng pangalan “origin”. Kaya, ang git fetch origin ay kumukuha ng anumang bagong trabaho na nai-push sa server na iyon mula nang na-clone (o huling kang nag-fetch) nito. Mahalaga itong tandaan na ang git fetch na utos ay nagda-download lang ng mga datos sa iyong lokal na repositoryo — ito ay hindi awtomatikong nag-merge sa anumang ginawa o binago mo na kasalukuyan mong ginawa. Kailangan mong i-merge ito ng mano-mano sa iyong trabaho kapag ikaw ay handa na.

Kung ang iyong kasalukuyang branch ay naka-set up upang subaybayan ang remote na branch (tingnan ang susunod na seksyon at Pag-branch ng Git para sa karagdagang impormasyon), maaari kang gumagamit ng git pull na utos upang awtomatikong mag-fetch at pagkatapos ay mag-merge sa remote na branch sa iyong kasalukuyang branch. Ito ay maaaring maging mas madali o maginhawang proseso para sa iyo; at bilang default, ang git clone na utos ay awtomakong nag-setup sa iyong lokal na branch upang subaybayan ang remote na master branch (o anumang default na branch na tinatawag) sa server na naka-clone ka. Ang pagpapatakbo ng git pull ay karaniwang kumukuha ng datos mula sa server na pinanggalingan ng iyong kopya ng repositoryo at awtomatikong nagsusubok na i-merge ito sa kasalukuyang tinatrabaho mo.

Pagtulak sa iyong mga Remote

Kapag mayroon kang proyekto na gusto mong ibahagi sa isang punto, kailangan mong i-push ito pataas. Ang utos para dito ay simple lang: git push <remote> <branch>. Kung gusto mo i-push ang iyong master branch sa iyong origin sa server (sa uulitin, ang pag-clone ay awtomatikong nag-setup mga pangalan na iyon para sa iyo), pagkatapos ay maaari mo nang patakbuhin ito para i-push ang anumang mga commit na nagawa mo papunta sa server:

$ git push origin master

Ang utos na ito ay gagana lang kung ikaw ay naka-clone mula sa isang server na kung saan meron kang pahintulot na magsulat at kung walang pang pansamantalang nag-push. Kung ikaw at sinumang nag-clone sa parehong oras at sila ay nag-push pataas at pagkatapos ikaw ay nag-push pataas, ang iyong pag-push ay hindi tatanggapin. Kailangan mo pang kunin ang kanilang trabaho at isama ito sa iyong nagawa bago ka pahintulotang mag-push. Tingnan ang Pag-branch ng Git para sa mga karagdagang detalye kung papaano mag-push sa remote na mga server.

Pagsusuri sa Remote

Kung gusto mong makakita pa ng maraming impormasyon tungkol sa partikular na remote, maaari mong gamitin ang git remote show <remote> na utos. Kung papatakbuhin mo ang utos na ito na may isang partikular na alyas, tulad ng origin, makakuha ka ng ganito:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/schacon/ticgit
  Push  URL: https://github.com/schacon/ticgit
  HEAD branch: master
  Remote branches:
    master                               tracked
    dev-branch                           tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Naglilista ito ng URL para sa remote na repositoryo pati na rin ang impormasyon sa pagsubabay ng branch. Nakakatulong ang utos na magsabi sa iyo na kung ikaw ay nasa master na branch at ikaw ay nagpapatakbo ng git pull, awtomatiko itong i-merge sa master na branch na nasa iyong remote pagkatapos nitong makuha ang lahat ng remote na mga reperensiya. Naglilista din ito sa lahat ng remote na mga reperensiya na nakuha nito pababa.

Iyan ay isang simpleng halimbawa na malamang ay matatagpuan mo. Kapag mas madalas ang paggamit mo sa Git, gayunman, maaari kang makakita ng mas maraming impormasyon mula sa git remote show:

$ git remote show origin
* remote origin
  URL: https://github.com/my-org/complex-project
  Fetch URL: https://github.com/my-org/complex-project
  Push  URL: https://github.com/my-org/complex-project
  HEAD branch: master
  Remote branches:
    master                           tracked
    dev-branch                       tracked
    markdown-strip                   tracked
    issue-43                         new (next fetch will store in remotes/origin)
    issue-45                         new (next fetch will store in remotes/origin)
    refs/remotes/origin/issue-11     stale (use 'git remote prune' to remove)
  Local branches configured for 'git pull':
    dev-branch merges with remote dev-branch
    master     merges with remote master
  Local refs configured for 'git push':
    dev-branch                     pushes to dev-branch                     (up to date)
    markdown-strip                 pushes to markdown-strip                 (up to date)
    master                         pushes to master                         (up to date)

Ang utos na ito ay nagpapakita kung aling branch ang awtomatikong na-push kapag pinatakbo mo ang git push habang nasa ibang branch ka. Ito rin ay nagpapakita sa iyo kung aling remote na mga branch ang nasa server na wala ka pa, kung aling mga remote na branch na meron ka pa na inalis mo na sa server, at maraming lokal na mga branch na awtomatikong mai-merge sa kanilang remote-tracking na branch kapag nagpatakbo ka ng git pull.

Pagpapalit ng pangalan at Pagtatangal ng mga Remote

Maaari kang magpatakbo ng git remote rename upang baguhin ang alyas ng isang remote. Halimbawa, kung ikaw ay gustong magbago ng pangalan ng pb sa paul, maaari mo itong gawin gamit ang git remote rename:

$ git remote rename pb paul
$ git remote
origin
paul

Ito ay mahalagang banggitin na ito ay nagbabago rin sa lahat ng iyong remote-tracking na mga pangalan ng branch. Ang dating ginamit na pb/master ay ngayon ay nasa paul/master na.

Kung gusto mong tanggalin ang remote para sa kahit anong rason — inilipat mo ang server o hindi na ginagamit ang isang partikular na mirror, o marahil ang isang umaambag ay hindi na mag-aambag muli — maaari mong gamitin ang git remote remove o git remote rm:

$ git remote remove paul
$ git remote
origin

Kapag natanggal mo na ang reperensiya sa isang remote sa ganitong paraan, lahat ng remote-tracking na mga branch at mga configuration setting na may kaugnayan sa remote ay tinanggal din.