How to pull one commit at a time from a remote git

问题:

I'm trying to set up a darcs mirror of a git repository. I have something that works OK, but there's a significant problem: if I push a whole bunch of commits to the git repo, those commits get merged into a single darcs patchset. I really want to make sure each git commit gets set up as a single darcs patchset. I bet this is possible by doing some kind of git fetch followed by interrogation of the local copy of the remote branch, but my git fu is not up to the job.

Here's the (ksh) code I'm using now, more or less:

git pull -v # pulls all the commits from remote --- bad!

# gets information about only the last commit pulled -- bad!
author="$(git log HEAD^..HEAD --pretty=format:"%an <%ae>")"
logfile=$(mktemp)
git log HEAD^..HEAD --pretty=format:"%s%n%b%n" > $logfile

# add all new files to darcs and record a patchset. this part is OK
darcs add -q --umask=0002 -r .
darcs record -a -A "$author" --logfile="$logfile"
darcs push -a
rm -f $logfile

My idea is

1. Try git fetch to get local copy of the remote branch (not sure exactly what arguments are needed)
2. Somehow interrogate the local copy to get a hash for every commit since the last mirroring operation (I have no idea how to do this)
3. Loop through all the hashes, pulling just that commit and recording the associated patchset (I'm pretty sure I know how to do this if I get my hands on the hash)

I'd welcome either help fleshing out the scenario above or suggestions about something else I should try.

Ideas?

回答1:

Have you tried looking at some existing solutions for moving changesets between version control systems, such as Tailor, which says that it includes support for git and darcs? (There are suggestions for similar systems on that page as well.)

Otherwise, if you want to use your suggested approach, you could use git checkout on each commit after HEAD to origin/master to checkout that commit in "detached HEAD" mode. For example, to modify the example you give (and in bourne shell, I'm afraid, since I don't use ksh):

# Update all remote-tracking branches from origin
git fetch origin

for c in `git log --pretty=format:"%h" HEAD..origin/master`
do
     git checkout $c
     author=$(git log -1 --pretty=format:"%an <%ae>")
     logfile=$(mktemp)
     git log -1 --pretty=format:"%s%n%n%b%n" > $logfile

     darcs add -q --umask=0002 -r .
     darcs record -a -A "$author" --logfile="$logfile"
     darcs push -a
     rm -f $logfile         
done

# Now go back to master, and merge to keep your master branch up to date:
git checkout master
git merge origin/master

Note that this will linearize the history from git, which wouldn't be what I wanted, personally. :) I think it's best to use an existing tool for this, but the above approach could be made to work.

回答2:

You could do something like this:

#!/bin/bash
git fetch
count=$(git log --pretty=oneline | wc -l)
git merge origin/master
git reset --hard HEAD~$((count-1))

I created a repository for this script and tried it out. The following is before and after merge:

Now I didn't have a remote repository so I faked the git fetch and the remote branch with a local (named kalle), but you get the idea. Just do the complete merge and then back up the HEAD pointer until you reach the first commit from origin/master.

回答3:

git remote update # fetch all remotes I like it better than just fetch

git log origin/master # can be any remote/branch

git cherry-pick origin/master # example remote/branch you can also specify a sha1

cherry-pick will pick the top patch by default.

for the third part I think you'll have to write a script to do it for you. there are other ways to get the hashes and lots of options for log. Actually there might be a hook for cherry-pick or maybe just post commit... to run the darcs code. check out git hooks.

in fact on that note each patch applied in a rebase might call a git commit hook so you might be able to write that and then do a git pull --rebase and have that code nailed on each apply...

回答4:

Use this to retrieve hashes from a branch:

git log --pretty=format:"%h" HEAD..origin/master

Then use git cherry-pick -n <hash> to apply each one.

Another option, as cited by @xenoterracide, is using githooks.