How to convert a normal Git repository to a bare o

问题:

How can I convert a \'normal\' Git repository to a bare one?

The main difference seems to be:

• in the normal git repository you have a .git folder inside the repository containing all relevant data and all other files build your working copy

• in a bare Git repository, there is no working copy and the folder (let\'s call it repo.git) contains the actual repository data

回答1:

In short: replace the contents of repo with the contents of repo/.git, then tell the repository that it is now a bare repository.

To do this, execute the following commands:

cd repo
mv .git ../repo.git # renaming just for clarity
cd ..
rm -fr repo
cd repo.git
git config --bool core.bare true

Note that this is different from doing a git clone --bare to a new location (see below).

回答2:

Your method looks like it would work; the file structure of a bare repository is just what is inside the .git directory. But I don\'t know if any of the files are actually changed, so if that fails, you can just do

git clone --bare /path/to/repo

You\'ll probably need to do it in a different directory to avoid a name conflict, and then you can just move it back to where you want. And you may need to change the config file to point to wherever your origin repo is.

回答3:

I think the following link would be helpful

GitFaq: How do I make existing non-bare repository bare?

$ mv repo/.git repo.git
$ git --git-dir=repo.git config core.bare true
$ rm -rf repo

回答4:

Unless you specifically want or need to twiddle bits on the filesystem, it really is dead simple to create a bare version of a non-bare repository (mentioned in several other posts here). It’s part of git’s core functionality:

git clone --bare reponame bare_reponame

回答5:

Please also consider to use

git clone --mirror path_to_source_repository

From the documentation:

Set up a mirror of the source repository. This implies --bare. Compared to --bare, --mirror not only maps local branches of the source to local branches of the target, it maps all refs (including remote-tracking branches, notes etc.) and sets up a refspec configuration such that all these refs are overwritten by a git remote update in the target repository.

回答6:

I just wanted to push to a repository on a network path but git would not let me do that unless that repository was marked as bare. All I needed was to change its config:

git config --bool core.bare true

No need to fiddle with the files unless you want to keep it clean.

回答7:

i\'ve read the answers and i have done this:

cd repos
mv .git repos.git
cd repos.git
git config --bool core.bare true # from another answer
cd ../
mv repos.git ../
cd ../
rm -rf repos/ # or delete using a file manager if you like

this will leave the contents of repos/.git as the bare repos.git

回答8:

Here\'s what I think is safest and simplest. There is nothing here not stated above. I just want to see an answer that shows a safe step-by-step procedure. You start one folder up from the repository (repo) you want to make bare. I\'ve adopted the convention implied above that bare repository folders have a .git extension.

(1) Backup, just in case.
    (a) > mkdir backup
    (b) > cd backup
    (c) > git clone ../repo
(2) Make it bare, then move it
    (a) > cd ../repo
    (b) > git config --bool core.bare true
    (c) > mv .git ../repo.git
(3) Confirm the bare repository works (optional, since we have a backup)
    (a) > cd ..
    (b) > mkdir test
    (c) > cd test
    (d) > git clone ../repo.git
(4) Clean up
    (a) > rm -Rf repo
    (b) (optional) > rm -Rf backup/repo
    (c) (optional) > rm -Rf test/repo

回答9:

Simply read

Pro Git Book: 4.2 Git on the Server - Getting Git on a Server

which boild down to

$ git clone --bare my_project my_project.git
Cloning into bare repository \'my_project.git\'...
done.

Then put my_project.git to the server

Which mainly is, what answer #42 tried to point out. Shurely one could reinvent the wheel ;-)

回答10:

Here is a little BASH function you can add to your .bashrc or .profile on a UNIX based system. Once added and the shell is either restarted or the file is reloaded via a call to source ~/.profile or source ~/.bashrc.

function gitToBare() {
  if [ -d \".git\" ]; then
    DIR=\"`pwd`\"
    mv .git ..
    rm -fr *
    mv ../.git .
    mv .git/* .
    rmdir .git

    git config --bool core.bare true
    cd ..
    mv \"${DIR}\" \"${DIR}.git\"

    printf \"[\\x1b[32mSUCCESS\\x1b[0m] Git repository converted to \"
    printf \"bare and renamed to\\n  ${DIR}.git\\n\"
    cd \"${DIR}.git\"
  else
    printf \"[\\x1b[31mFAILURE\\x1b[0m] Cannot find a .git directory\\n\"
  fi
}

Once called within a directory containing a .git directory, it will make the appropriate changes to convert the repository. If there is no .git directory present when called, a FAILURE message will appear and no file system changes will happen.

回答11:

The methods that say to remove files and muck about with moving the .git directory are not clean and not using the \"git\" method of doing something that\'s should be simple. This is the cleanest method I have found to convert a normal repo into a bare repo.

First clone /path/to/normal/repo into a bare repo called repo.git

git clone --bare /path/to/normal/repo

Next remove the origin that points to /path/to/normal/repo

cd repo.git
git remote rm origin

Finally you can remove your original repo. You could rename repo.git to repo at that point, but the standard convention to signify a git repository is something.git, so I\'d personally leave it that way.

Once you\'ve done all that, you can clone your new bare repo (which in effect creates a normal repo, and is also how you would convert it from bare to normal)

Of course if you have other upstreams, you\'ll want to make a note of them, and update your bare repo to include it. But again, it can all be done with the git command. Remember the man pages are your friend.

回答12:

In case you have a repository with few local checkedout branches /refs/heads/* and few remote branch branches remotes/origin/* AND if you want to convert this into a BARE repository with all branches in /refs/heads/*

you can do the following to save the history.

1. create a bare repository
2. cd into the local repository which has local checkedout branches and remote branches
3. git push /path/to/bare/repo +refs/remotes/origin/:refs/heads/

回答13:

I used the following script to read a text file that has a list of all my SVN repos and convert them to GIT, and later use git clone --bare to convert to a bare git repo

#!/bin/bash
file=\"list.txt\"
while IFS= read -r repo_name
do
 printf \'%s\\n\' \"$repo_name\"
 sudo git svn clone --shared --preserve-empty-dirs --authors-file=users.txt file:///programs/svn/$repo_name 
 sudo git clone --bare /programs/git/$repo_name $repo_name.git
 sudo chown -R www-data:www-data $repo_name.git
 sudo rm -rf $repo_name
done <\"$file\"

list.txt has the format

repo1_name
repo2_name

and users.txt has the format

(no author) = Prince Rogers <[e-mail]>

www-data is the Apache web server user, permission is needed to push changes over HTTP

回答14:

First, backup your existing repo:

(a)  mkdir backup

(b)  cd backup

(c)  git clone non_bare_repo

Second, run the following:

git clone --bare -l non_bare_repo new_bare_repo

回答15:

Oneliner for doing all of the above operations:

for i in `ls -A .`; do if [ $i != \".git\" ]; then rm -rf $i; fi; done; mv .git/* .; rm -rf .git; git config --bool core.bare true

(don\'t blame me if something blows up and you didn\'t have backups :P)

回答16:

Wow, it\'s simply amazing how many people chimed in on this, especially considering it doesn\'t seem that not a single on stopped to ask why this person is doing what he\'s doing.

The ONLY difference between a bare and non-bare git repository is that the non-bare version has a working copy. The main reason you would need a bare repo is if you wanted to make it available to a third party, you can\'t actually work on it directly so at some point you\'re going to have to clone it at which point you\'re right back to a regular working copy version.

That being said, to convert to a bare repo all you have to do is make sure you have no commits pending and then just :

rm -R * && mv .git/* . && rm -R .git

There ya go, bare repo.