quickstart
as some_user@example.com:
on the server that will host the git repos,
sudo aptitude install gitosis
sudo -H -u gitosis gitosis-init < ~/.ssh/id_rsa.pub
git clone gitosis@localhost:gitosis-admin.git
cd gitosis-admin
scp newuser@example.net:.ssh/id_rsa.pub keydir/newuser@example.net.pub
vim gitosis.conf #:tabnew /usr/share/doc/gitosis/examples/example.conf
#add newuser@example.net to project_foo_group, make project_foo writable, close
git add .
git ci -m "add newuser@example.net to project_foo_group, make project_foo writable"
git push origin master
example gitosis.conf pushed back to gitosis-admin.git:
[gitosis]
[group gitosis-admin]
writable = gitosis-admin
members = some_user@example.com
[group project_foo_group]
members = some_user@example.com new_user@example.net
writable = project_foo
then as newuser at example.net:
cd project_foo
git remote add origin gitosis@example.com:project_foo.git
git push origin master
again, but cluttered with explanations
as some_user@example.com
sudo aptitude install gitosisturns out there's a gitosis package in ubuntu. but it was unclear what installing it did. after reading some docs, such as
/usr/share/doc/gitosis/README.rst.gz (installed with the gitosis package) and a blog post about
hosting git, i was ready to guess. i found that the gitosis user had already been set up. finding its home directory was a matter of
sudo su gitosis -;cd;pwd. this let me know first, that there was indeed a user named gitosis and second, that its home directory was at
/srv/gitosis. this turns out to be irrelevant because the gitosis package already knows this. that directory was empty, iirc. so i guessed that i needed to pick up at
gitosis-init.
sudo -H -u gitosis gitosis-init < ~/.ssh/id_rsa.pub
tell gitosis whom to trust for its administration. make the user
gitosis run
gitosis-init and give it the public key of whomever will admin the gitosis server (in this case it's the public rsa key of the current user). gitosis-init takes care of putting this file in the right place with the right name(
/srv/gitosis/repositories/gitosis-admin.git/gitosis-export/keydir/some_user@example.com.pub). the exact place doesn't matter. it just matters that gitosis knows about it and will refer to it to verify requests, like cloning:
git clone gitosis@localhost:gitosis-admin.git
the current user (some_user@example.com) wants to clone from the user
gitosis at localhost the gitosis-admin git repository. the user gitosis sees this request and needs to verify that it should fulfill that request. it uses the key (some_user@example.com.pub) that was just set up in the
gitosis-init step. ssh magic happens here. the user gitosis trusts the incoming request and pushes out the repository to the requester, some_user@example.com. now some_user@example.com can modify the repository and write it back (all of these permissions and configurations are set up by
gitosis-init.
cd gitosis-admin
when you clone the repo, its contents are put into a folder in the current directory, so go into it.
scp newuser@example.net:.ssh/id_rsa.pub keydir/newuser@example.net.pub
copy yet another public key into the key directory. this is the public key of newuser at example.net. copy it to the directory keydir with the filename user@host.pub. gitosis knows to look in this directory for files named like this for the public key.
vim gitosis.conf #:tabnew /usr/share/doc/gitosis/examples/example.conf
#add newuser@example.net to project_foo_group, make project_foo writable, close
modify gitosis.conf to add the relevant sections. scroll up a bit to see gitosis.conf. there is an example configuration at the location specified. in my example i create a group called new_project_group for the repository new_project. it says that the users some_user@example.com and newuser@example.net can write (which implies read and write) to the project new_project.
git add .
git ci -m "add newuser@example.net to project_foo_group, make project_foo writable"
save those changes! the public key and the configuration change! very important. but remember, this is just saving locally. you haven't told anyone else about this.
git push origin master
put those changes back up to the repository that gitosis@example.com knows about! gitosis will check its current configuration and see that it accepts changes from some_user@example.com to the gitosis-admin.git repository. gitosis has some kind of hook magic going on here. i'm not sure if it's a post-commit, or post-applypatch or what. but something black box happens here. the result of the black box is that changes you just pushed back to the gitosis-admin repo are now reflected by gitosis@example.com. it now knows about a new_project_group group, and the public key of newuser@example.net (for more ssh magic), and about the new_project repository.
as newuser@example.net
so now that the server has been set up and configured and doodadded, it's time to go put some content in it, other than the content that determines the configuration and the doodadding.
cd project_foo
newuser@example.net already has a project with some commits in it. so go into that directory.
git remote add origin gitosis@example.com:project_foo.git
tell that git repo about the new git server! gitosis on example.com knows about the project_foo git repo from the configuration file pushed to it earlier.
git push origin master
and the finish! this will push the master branch to the location nicknamed origin. origin is the nickname for gitosis@example.com:new_project.git. gitosis receives this request, does more ssh magic by looking at the public key pushed in gitosis-admin/keydir/newuser@example.net.pub. hooray! gitosis@example.com will see that the repo doesn't already exist, and accept the push, creating and populating the repo in one swoop! hooray!
