0

This seems so dumb, but I can't figure it out. Tons of instructions out there for cloning or adding a remote server, or pushing to a cloned repository. But I'm trying to figure out how to set up a git repository in a shared directory on a server, and let other people collaborate from clones in their personal directories.

This is what I've tried:

abalter@U1:~$ mkdir mainrepo
abalter@U1:~$ cd mainrepo/
abalter@U1:~/mainrepo$ echo "inital entry" > text.txt
abalter@U1:~/mainrepo$ git init
Initialized empty Git repository in /home/abalter/mainrepo/.git/
abalter@U1:~/mainrepo$ git add text.txt 
abalter@U1:~/mainrepo$ git commit -m "initial commit"
[master (root-commit) fb829d6] initial commit
 1 file changed, 1 insertion(+)
 create mode 100644 text.txt
abalter@U1:~/mainrepo$ cd ..
abalter@U1:~$ git clone mainrepo/ userrepo
Cloning into 'userrepo'...
done.
abalter@U1:~$ cd userrepo/
abalter@U1:~/userrepo$ echo "users addition" >> text.txt 
abalter@U1:~/userrepo$ git commit -am "users addition"
[master 3d4ea94] users addition
 1 file changed, 1 insertion(+)
abalter@U1:~/userrepo$ git add remote origin ../mainrepo/
fatal: ../mainrepo/: '../mainrepo/' is outside repository
abalter@U1:~/userrepo$ git push origin master
Counting objects: 5, done.
Writing objects: 100% (3/3), 267 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
remote: error: refusing to update checked out branch: refs/heads/master
remote: error: By default, updating the current branch in a non-bare repository
remote: error: is denied, because it will make the index and work tree inconsistent
remote: error: with what you pushed, and will require 'git reset --hard' to match
remote: error: the work tree to HEAD.
remote: error: 
remote: error: You can set 'receive.denyCurrentBranch' configuration variable to
remote: error: 'ignore' or 'warn' in the remote repository to allow pushing into
remote: error: its current branch; however, this is not recommended unless you
remote: error: arranged to update its work tree to match what you pushed in some
remote: error: other way.
remote: error: 
remote: error: To squelch this message and still keep the default behaviour, set
remote: error: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To /home/abalter/mainrepo/
 ! [remote rejected] master -> master (branch is currently checked out)
error: failed to push some refs to '/home/abalter/mainrepo/'
abalter@U1:~/userrepo$

I'm clearly missing a step, but I don't know what it is.

EDIT I realize it should have been git remote add origin ../mainrepo. But 

abalter@U1:~/userrepo$ git remote add origin ../mainrepo
fatal: remote origin already exists.
abalter@U1:~/userrepo$

If it already exists, why can't I push to it?

abalter
  • 9,663
  • 17
  • 90
  • 145

2 Answers2

2

The answer here is no different than the setup on actual remote machines: a repository you push to should1 be a --bare clone. For instance, to set things whole thing up you start by making a user repository (so that you can make some initial commits):2

$ mkdir set-it-up && cd set-it-up
$ git init
[create and add files as usual and then]
$ git commit

Then move to the place you want the bare master repo, and, e.g.:

$ mkdir master-repo.git; cd master-repo.git; git init --bare

(you may want to add --shared or --shared=all, etc.; see the git init documentation). Now you have a bare—no work directory—repository, suitable for both cloning-from and pushing-to.

To fill it in, you may now fetch (manually) everything from your "set-it-up" repo:

git fetch /path/to/set-it-up 'refs/*:refs/*'

At this point it's safe to remove your "set-it-up" copy: cloning the master-repo.git directory will get you a fresh clone in which to work, with the clone's origin set to the path of the master-repo.git directory.

Alternatively, in your set-it-up repo, you can now add the master-repo.git directory as the "origin" URL, then push.

1Since git 2.5, it's possible to make sensible things (for some value of sensible) happen with a non-shared repository, but this is a bit more complex to describe.

2You can make the initial bare repository completely empty, if you prefer. When cloning an empty repository, git gripes a bit, but you can then work in the clone and push back to fill in the bare repository.

torek
  • 448,244
  • 59
  • 642
  • 775
0

I found this, which says "Shared Repositories Should Be Bare Repositories." So I was going about it the wrong way. This works:

abalter@U1:~$ git init --bare baremain.git
Initialized empty Git repository in /home/abalter/baremain.git/
abalter@U1:~$ git clone /home/abalter/baremain.git/ alicecopy
Cloning into 'alicecopy'...
warning: You appear to have cloned an empty repository.
done.
abalter@U1:~$ cd alicecopy/
abalter@U1:~/alicecopy$ echo "alice created this" > alice.txt
abalter@U1:~/alicecopy$ git add alice.txt 
abalter@U1:~/alicecopy$ git commit -m "alice created file"
[master (root-commit) 20b15da] alice created file
 1 file changed, 1 insertion(+)
 create mode 100644 alice.txt
abalter@U1:~/alicecopy$ git push origin master
Counting objects: 3, done.
Writing objects: 100% (3/3), 229 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To /home/abalter/baremain.git/
 * [new branch]      master -> master
abalter@U1:~/alicecopy$ cd ..
abalter@U1:~$ git clone /home/abalter/baremain.git/ bobcopy
Cloning into 'bobcopy'...
done.
abalter@U1:~$ cd bobcopy/
abalter@U1:~/bobcopy$ echo "bob added this" >> alice.txt 
abalter@U1:~/bobcopy$ git add alice.txt 
abalter@U1:~/bobcopy$ git commit -m "bob added stuff"
[master b7b2e2a] bob added stuff
 1 file changed, 1 insertion(+)
abalter@U1:~/bobcopy$ git push origin master
Counting objects: 5, done.
Writing objects: 100% (3/3), 266 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To /home/abalter/baremain.git/
   20b15da..b7b2e2a  master -> master
abalter@U1:~/bobcopy$ cd ../alicecopy/
abalter@U1:~/alicecopy$ git pull
remote: Counting objects: 5, done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From /home/abalter/baremain
   20b15da..b7b2e2a  master     -> origin/master
Updating 20b15da..b7b2e2a
Fast-forward
 alice.txt | 1 +
 1 file changed, 1 insertion(+)
abalter@U1:~/alicecopy$ cat alice.txt 
alice created this
bob added this
abalter@U1:~/alicecopy$

EDIT: Method 2 for if you already have a directory full of stuff you want to use.

abalter@U1:~$ mkdir bobsstuff 
abalter@U1:~$ cd bobsstuff/
abalter@U1:~/bobsstuff$ echo "this is bob's existing file" > bob.txt
abalter@U1:~/bobsstuff$ cd ..
abalter@U1:~$ git init --bare mainrepo.git
Initialized empty Git repository in /home/abalter/mainrepo.git/
abalter@U1:~$ cd bobsstuff/
abalter@U1:~/bobsstuff$ git remote add origin../mainrepo.git/
fatal: Not a git repository (or any of the parent directories): .git
abalter@U1:~/bobsstuff$ echo "oops--not yet a repo"
oops--not yet a repo
abalter@U1:~/bobsstuff$ git init
Initialized empty Git repository in /home/abalter/bobsstuff/.git/
abalter@U1:~/bobsstuff$ git remote add origin ../mainrepo.git/ 
abalter@U1:~/bobsstuff$ git add bob.txt 
abalter@U1:~/bobsstuff$ git add .
abalter@U1:~/bobsstuff$ git commit -m "initial commit of all my files"
[master (root-commit) 02a3d2e] initial commit of all my files
 1 file changed, 1 insertion(+)
 create mode 100644 bob.txt
abalter@U1:~/bobsstuff$ git push origin master
Counting objects: 3, done.
Writing objects: 100% (3/3), 244 bytes | 0 bytes/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ../mainrepo.git/
 * [new branch]      master -> master
abalter@U1:~/bobsstuff$ cd ..
abalter@U1:~$ git clone mainrepo.git/ alicesstuff
Cloning into 'alicesstuff'...
done.
abalter@U1:~$ cd alicesstuff/
abalter@U1:~/alicesstuff$ cat bob.txt 
this is bob's existing file
abalter@U1:~/alicesstuff$ echo "alice added this" >> bob.txt 
abalter@U1:~/alicesstuff$ cat bob.txt 
this is bob's existing file
alice added this
abalter@U1:~/alicesstuff$ echo "alice created this" > alice.txt
abalter@U1:~/alicesstuff$ git add .
abalter@U1:~/alicesstuff$ git status
On branch master
Your branch is up-to-date with 'origin/master'.

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   alice.txt
    modified:   bob.txt

abalter@U1:~/alicesstuff$ git commit -m "alice's initial commit"
[master 2b9d332] alice's initial commit
 2 files changed, 2 insertions(+)
 create mode 100644 alice.txt
abalter@U1:~/alicesstuff$ git push origin master
Counting objects: 6, done.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (4/4), 341 bytes | 0 bytes/s, done.
Total 4 (delta 0), reused 0 (delta 0)
To /home/abalter/mainrepo.git/
   02a3d2e..2b9d332  master -> master
abalter@U1:~/alicesstuff$ cd ../bobsstuff/
abalter@U1:~/bobsstuff$ git pull origin master
remote: Counting objects: 6, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 4 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (4/4), done.
From ../mainrepo
 * branch            master     -> FETCH_HEAD
   02a3d2e..2b9d332  master     -> origin/master
Updating 02a3d2e..2b9d332
Fast-forward
 alice.txt | 1 +
 bob.txt   | 1 +
 2 files changed, 2 insertions(+)
 create mode 100644 alice.txt
abalter@U1:~/bobsstuff$ cat bob.txt 
this is bob's existing file
alice added this
abalter@U1:~/bobsstuff$ cat alice.txt 
alice created this
abalter
  • 9,663
  • 17
  • 90
  • 145