subversion / local - remote repository juggling

 

 

I'm relatively new to Subversion (< 3 years) and have not
worked in an
environment where I would like to keep certain
customizations separate
from changes committed to a remote repository.

 

My specific configuration: I have a local subversion
repository where I
am storing customized libraries and Bricolage hacks that
might not make
it to a committed state, but are hacks that I nonetheless
might want to
use myself in a production installation.

 

That means I have a bit of a versioning problem.  I need to
manage my
local changes as well as keep my installation relatively
up-to-date by
periodically grabbing committed changes from the remote
bricolage
repository and applying them to my installation.

 

This is all a rehash of a previous question I posed to this
list, but
now that I have cobbled together a "workable"
solution to my problem, I
thought I would

 

(a) post it in case others needed a solution to this problem
and 

(b) ask you all to poke holes in it or offer a cleaner,
easier to use
solution based on your experience with this same problem

 

 

Here's a process that works (at least for two iterations
anyway):

 

1)    commit any working file changes to local repository

2)    update a separate working copy with latest from
bricolage remote
repository

3)    export that working copy into another working copy
that is tied to
a rev_x_x branch of local repository.  Commit it

4)    svn diff to create a patch that represents all
bricolage commits
since the last time I updated from remote site

5)    use a merge tool to apply the unified diff to my local
development
working copy. Commit the changes and hope everything still
works

 

 

Thoughts / experience?

 

 

 

------------------------------------------------------------
------------
-----------

Dave Beaudet

d-beaudetnga.gov

(202) 312-2755

------------------------------------------------------------
------------
-----------

"Computers are useless.  They can only give you
answers." 

    - Pablo Picasso 

 

 

"Beaudet, David P." <D-BeaudetNGA.GOV> writes:
> Here's a process that works (at least for two
iterations anyway):
>
> 1)    commit any working file changes to local
repository
>
> 2)    update a separate working copy with latest from
bricolage remote
> repository
>
> 3)    export that working copy into another working
copy that is tied to
> a rev_x_x branch of local repository.  Commit it
>
> 4)    svn diff to create a patch that represents all
bricolage commits
> since the last time I updated from remote site
>
> 5)    use a merge tool to apply the unified diff to my
local development
> working copy. Commit the changes and hope everything
still works

I'm not sure, was it you, who already described a similar
scenario? 
Anyway, some weeks ago I suggested someone to have a look at
SVK.

  http://svk.bestpractical
.com

Follow the examples in "svk help intro" with some
dummy repositories
to understand the philosophy. It will show you how to set up
a local
mirror of a projects ("//mirror" in the examples),
then a local
repository ("//local") that "mirrors the
mirror" and a local checkout
you work on (based on "//local").

Every "svk commit" commits to your
"//local" and you can pull the
original repository changes into you project with "svk
pull".

If you had write access to the original repository, then
"svk push"
would be for writing all your collected commits back through
the whole
chain.

It was originally meant for working offline, but it matches
your
scenario too. If I understood it right.

GreetinX
Steffen 
-- 
Steffen Schwigon <schwigonwebit.de>
Dresden Perl Mongers <http://dresden-pm.org/>

Deutscher Perl-Workshop <http://www.perl-work
shop.de/>