本文共 7553 字,大约阅读时间需要 25 分钟。
目录
To collaborate in a distributed development process you’ll need to push code to remotely accessible repositories.
This is somewhat of a follow-up to the previous article setting up a new rails app with git.
It's good to know how this stuff works, but this is definitely the hard way. For no fuss git repository setup (especially if you want to collaborate with others) check out GitHub.
Set up the new bare repo on the server:
$ ssh myserver.comWelcome to myserver.com!$ mkdir /var/git/myapp.git && cd /var/git/myapp.git$ git --bare initInitialized empty Git repository in /var/git/myapp.git$ exitBye!
Add the remote repository to your existing local git repo and push:
$ cd ~/Sites/myapp$ git remote add origin ssh://myserver.com/var/git/myapp.git$ git push origin master
Set the local master branch to track the remote branch.
Read further for a step-by-step explanation of what’s going on.
Setting up a remote repository is fairly simple but somewhat confusing at first. Firstly, let’s check out what remote repositories are being tracked in our git repo:
$ cd ~/Sites/myapp$ git remote
None. Looking good. Now let’s list all the branches:
$ git branch -a* master
Just one branch, the master branch. Let’s have a look at .git/config
:
$ cat .git/config[core] repositoryformatversion = 0 filemode = true bare = false logallrefupdates = true
A pretty bare-minimum config file.
Before we can push our local master branch to a remote repository we need to create the remote repository. To do this we’ll ssh in and create it on the server:
$ ssh myserver.comWelcome to myserver.com!$ cd /var/git$ mkdir myapp.git$ cd myapp.git$ git --bare initInitialized empty Git repository in /var/git/myapp.git$ exitBye!
A short aside about what git means by bare: A default git repository assumes that you’ll be using it as your working directory, so git stores the actual bare repository files in a .git
directory alongside all the project files. Remote repositories don’t need copies of the files on the filesystem unlike working copies, all they need are the deltas and binary what-nots of the repository itself. This is what “bare” means to git. Just the repository itself.
Now that we’ve created the remote repository we’ll add it to our local repository as a remote server called “origin” using git remote add
, which is just a nicer way of updating our config file for us:
$ git remote add origin ssh://myserver.com/var/git/myapp.git
Let’s see what it added to the config file:
[core] repositoryformatversion = 0 filemode = true bare = false logallrefupdates = true[remote "origin"] url = ssh://myserver.com/var/git/myapp.git fetch = +refs/heads/*:refs/remotes/origin/*
We now have a remote repository “origin” that will fetch all of it’s refs/heads/*
branches and store them in our local repo in refs/remotes/origin/*
when a git fetch
is performed.
The time has come to push our local master branch to the origin’s master branch. We do that using the git push <target> <local>
command.
$ git push origin masterupdating 'refs/heads/master' from 0000000000000000000000000000000000000000 to b379203bc187c2926f44a71eca3f901321ea42c6 Also local refs/remotes/origin/masterGenerating pack...Done counting 1374 objects.Deltifying 1374 objects... 100% (1374/1374) doneWriting 1374 objects... 100% (1374/1374) doneTotal 1374 (delta 89), reused 0 (delta 0)refs/heads/master: 0000000000000000000000000000000000000000 -> b379203bc187c2926f44a71eca3f901321ea42c6
and that’s all, folks. Further pushes can be done by repeating the git push
command.
Now you can tell your co-conspirators to:
$ git clone ssh://myserver.com/var/git/myapp.git
and push and pull to your heart’s content.
You can specify the default remote repository for pushing and pulling using git-branch’s track option. You’d normally do this by specifying the --track
option when creating your local master branch, but as it already exists we’ll just update the config manually like so:
[branch "master"] remote = origin merge = refs/heads/master
Now you can simply git push
and git pull
.
If you want to set it up as a public repository be sure to check out the Git manual’s chapter on public git repositories.
git remote show
is used to inspect a remote repository. It goes and checks the remote repository to see what branches have been added and removed since the last git fetch
.
Doing a git remote show
at the moment only shows us the remote repo’s master branch which we pushed earlier:
$ git remote show origin* remote origin URL: ssh://myserver.com/var/git/myapp.git Tracked remote branches master
Let’s create a new local git repository and push to a new branch on the remote repository. We can then use git remote show
to see the new remote branch, git fetch
to mirror it into our local repo and git checkout --track -b
to create a local branch to do some work on it.
We’ll start by creating a new local repo and pushing some code to a new branch in the remote repository.
$ mkdir /tmp/other-git$ cd /tmp/other-git$ git initInitialized empty Git repository in /tmp/other-git$ git remote add origin ssh://myserver.com/var/git/myapp.git$ echo "Rails 2... woo" > afile$ git add afile$ git commit -m "Added afile" Created initial commit 0ac9a74: Added afile 1 files changed, 1 insertions(+), 0 deletions(-) create mode 100644 something$ git push origin master:rails-2updating 'refs/heads/rails-2' using 'refs/heads/master' from 0000000000000000000000000000000000000000 to 0ac9a7457f4b21c9e058d4c54d262584bf35e528 Also local refs/remotes/origin/rails-2Generating pack...Done counting 3 objects.Deltifying 3 objects... 100% (3/3) doneWriting 3 objects... 100% (3/3) doneTotal 3 (delta 0), reused 0 (delta 0)Unpacking 3 objects... 100% (3/3) donerefs/heads/rails-2: 0000000000000000000000000000000000000000 -> 0ac9a7457f4b21c9e058d4c54d262584bf35e528
Now let’s switch back to our old git repository and see if it detects the new branch on the remote repository:
$ git remote show origin* remote origin URL: ssh://myserver.com/var/git/myapp.git New remote branches (next fetch will store in remotes/origin) dev/rails-2 Tracked remote branches master
Let’s update our mirror of the remote repository by doing a git fetch
:
$ git fetch* refs/remotes/origin/master: storing branch 'dev/rails-2' of ssh://myserver.com/var/git/myapp.git commit: b379203$ git remote show origin* remote origin URL: ssh://myserver.com/var/git/myapp.git Tracked remote branches master dev/rails-2
We should now be able to see this in a our list of remote branches:
$ git branch -a* masterorigin/dev/rails-2origin/master
If we then wanted to do some work on this remote dev/rails-2
branch we create a new local tracking branch like so:
$ git checkout --track -b dev/rails-2 origin/dev/rails-2Branch dev/rails-2 set up to track remote branch refs/remotes/origin/dev/rails-2.Switched to a new branch "dev/rails-2"
To keep up-to-date and push new changesets we simply use git push
and git pull
when working in the local dev/rails-2
branch.
Also notice, like we manually changed for master, .git/config
has a new entry for this new tracking branch:
[branch "dev/rails-2"] remote = origin merge = refs/heads/dev/rails-2转自