[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

how do you manage your external source?

Debian packages are, by far and large, a combination of external source
archives, and various patches.  These patches can be further sub-divided into
debian-specific(both new features and fixes), and upstream changes(ones
imported from upstream, or not yet sent upstream).

As package development progresses, these changes:

 * get ported to newer upstreams
 * get reimplemented
 * get broken/fixed

All these modifications to these changes don't all happen at once, and several
changesets can even be modified in parallel.

As these changesets get modified, it's best to keep each discreet change
separate, and not all mingled into one, so that
removing/exporting/forward-porting is easier to do.

    For instance, I have done cvs imports of upstream source, and then
    modified that source as needed for the project at hand.  Several fixes and
    features get implemented, as do lots of modifications that are local to
    the project(html design changes, database configuration, etc).  At the
    end, I get a single large diff(cvs diff with a tag or date), and would
    like to split each change into a separate changeset.  Dealing with just
    changeset files(like dbs and dpatch do) is not the best way of doing work.

In debian, there are several tools to make all this management easier(a
non-inclusive list includes cvs-buildpackage, tla-buildpackage, dbs, cdbs,
dpatch, uupdate).  However, these tools are generally geared towards use in
making debian packages, and not for stand-alone external source management.
Plus, they tend to require a unix system.

My question that I pose to this list, is what best practices are there, for
doing this kind of source/feature/changeset management?  In detail, I have
a source repository under revision control, that has several changes to
several files(some changes to the same files), but would like to have those
changes in discreet chunks.  However, I still want to have the full
upstream source in a single revision control system.

I'm either looking for a tool that can do this already, or I'm looking to
write such a tool.

Reply to: