Question on (my) workflow migration svn -> git

Brooks Davis brooks at
Thu Sep 24 20:53:28 UTC 2020

On Thu, Sep 24, 2020 at 01:17:15PM -0700, David Wolfskill wrote:
> The migration (of my workflow) from cvs to svn was more "cosmetic"
> than anything else -- the data store changed and the commands
> changed, but the underlying thought processes behind what I was
> doing stayed pretty much the same.
> I have no idea if that will be the case for svn -> git, so I'm
> putting this out for comments and, perhaps, some useful advice from
> folks who are more familiar with git than I am.
> Please note: I am not a FreeBSD committer.  I have no desire (let
> alone requirement) to cause changes to the FreeBSD code base to
> show up with my fingerprints on them.
> Details on the below-described workflow may be found at
>; the current
> state of things may be seen at
> (in case either
> of those is of interest).
> TL; DR:  I sync private local mirrors, update working copies, then make
> the running systems match the working copies.
> Details:
> I have a couple of machines that I consider "development" machines;
> one is the laptop that I use for day-to-day activities; the other
> is a dedicated "build machine" (named "freebeast").  On ecah of
> these machines, I perform a daily update of:
> * FreeBSD stable/${head - 1}  [currently: 12]
> * Locally-installed ports (using the ports "head" branch)
> * FreeBSD head
> Perhaps more significantly, I keep the two machines in lock-step,
> as my activities on my laptop constitute the bulk of my testing of
> what will be installed on my small handful of "production" machines
> each Sunday (as they get the most recent snapshot of stable/${head
> - 1} that freebeast built Sunday morning).
> To keep them in lock-step, the build machine performs a cron-initiated
> "svnsync" to update a local private mirror of the svn repositories
> (src, ports, and doc).  For the laptop, it depends:
> * If I'm away from home, it also does the same sort of svnsync (at
>   the same time).
> * If I'm home, it waits a couple of minutes, then does an rsync
>   from the build machine's private local mirror.
> In any case, each of them has a private local mirror that is only
> updated by the "mirroring" operation -- I don't commit to it.
> For each of stable/${head - 1}, head, and ports, the appopriate svn
> working copy is updated, using the svn repo as a read-only reference.
> Thus (for example), when FreeBSD stable/12 was branched, it was
> straightforward for me to "clone" the slice used for head (to a
> slice that I was not actively using until then), then use "svn
> switch" to change the src working copy to point to stable/12 (vs.
> head) -- there would be little substantitiative change, so the
> behavior should be quite similar to what I had already experienced
> with head.  And once I was comfortable with stable/12, I could
> "clone" that to overlay the old stable/11 slice.
> (I've been doing this -- well, substitute a few references to cvs
> inplace of the svn ones for early days -- since around FreeBSD 3.x
> (I'm pretty sure I skipped 5.x, though).  And it's been working
> pretty well for me so far.  I've evn been able to point out an
> occasional breakage now and then.)
> So: Is doing something ... similar ... to the above feasible using
> git (vs. svn)?  And if so, may I have a pointer or two to get me
> started?  Because it's not at all obvious to me how to accomplish
> it.  (E.g., in my use of git so far, the notions of "repository"
> and "working copy" seem to be conflated, which does not lead to
> warm and fuzzy feelings on my part.)

To continue having the local mirror of the git repo you could use `git
clone --bare <freebsd-repo>` to download a copy and not checkout out
a work tree.  I believe your daily updates updates would just be `git
fetch`, but I haven't worked with bare repos much.  You could then do
a local clone of that (at the cost of two complete copies of FreeBSD

Your laptop situation is more complicated, but I think I see how it
could work.  You'd initially clone from your local buildbox's mirror 
with something like `git clone ssh://freebeast/path/to/freebsd/repo`.
You'd then checkout out whatever branch you wanted and update with `git
pull`.  To handle the away scenario you have two choices, you can change
your url of your remote branch to point to upstream freebsd and update
as usual or your could add a second remote (e.g. freebsd vs the default
origin) and perform a "fast-foward" merge from the corresponding branch
on that remote to your working branch.  This would look something like
the following (totally untested with made up branch names) example:

git clone ssh://freebeast/path/to/freebsd/repo freebsd
cd freebsd
git remote add freebsd <freebsd-repo-url>
git checkout stable/12

So long as you don't commit any local changes your update process at
home would look like:

cd freebsd
git pull

To update while away, you'd so something like:

cd freebsd
git fetch freebsd
git merge --ff-only freebsd/stable/12

I don't see a good way to keep a bare repo on the laptop.

I hope this give you an idea where to start.

-- Brooks
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 455 bytes
Desc: not available
URL: <>

More information about the freebsd-git mailing list