our $split_brain = 0;
our $do_split_brain = 0;
+# Interactions between quilt mode and split brain
+# (currently, split brain only implemented iff
+# madformat_wantfixup && quiltmode_splitbrain)
+#
+# source format sane `3.0 (quilt)'
+# madformat_wantfixup()
+#
+# quilt mode normal quiltmode
+# (eg linear) _splitbrain
+#
+# ------------ ------------------------------------------------
+#
+# no split no q cache no q cache forbidden,
+# brain PM on master q fixup on master prevented
+# !$do_split_brain PM on master
+#
+# split brain no q cache q fixup cached, to dgit view
+# PM in dgit view PM in dgit view
+#
+# PM = pseudomerge to make ff, due to overwrite (or split view)
+# "no q cache" = do not record in cache on build, do not check cache
+# `3.0 (quilt)' with --quilt=nocheck is treated as sane format
+
END {
local ($@, $?);
return unless forkcheck_mainprocess();
if (madformat_wantfixup($format)) {
# user might have not used dgit build, so maybe do this now:
if (quiltmode_splitbrain()) {
+ $do_split_brain = 1;
+ }
+ if ($do_split_brain) {
changedir $playground;
- quilt_make_fake_dsc($upstreamversion);
my $cachekey;
($dgithead, $cachekey) =
quilt_check_splitbrain_cache($actualhead, $upstreamversion);
"--quilt=%s but no cached dgit view:
perhaps HEAD changed since dgit build[-source] ?",
$quilt_mode;
- $split_brain = 1;
- $dgithead = splitbrain_pseudomerge($clogp,
- $actualhead, $dgithead,
- $archive_hash);
- $maintviewhead = $actualhead;
- changedir $maindir;
- prep_ud(); # so _only_subdir() works, below
- } else {
+ }
+ if (!$do_split_brain) {
+ # In split brain mode, do not attempt to incorporate dirty
+ # stuff from the user's working tree. That would be mad.
commit_quilty_patch();
}
}
+ if ($do_split_brain) {
+ $split_brain = 1;
+ $dgithead = splitbrain_pseudomerge($clogp,
+ $actualhead, $dgithead,
+ $archive_hash);
+ $maintviewhead = $actualhead;
+ changedir $maindir;
+ prep_ud(); # so _only_subdir() works, below
+ }
if (defined $overwrite_version && !defined $maintviewhead
&& $archive_hash) {
local $ENV{GIT_AUTHOR_EMAIL} = $authline[1];
local $ENV{GIT_AUTHOR_DATE} = $authline[2];
- die if $split_brain;
die unless $do_split_brain;
- runcmd @git, qw(checkout -q -b dgit-view);
- $split_brain = 1;
my $fulldiffhint = sub {
my ($x,$y) = @_;
my $headref = git_rev_parse('HEAD');
my $symref = git_get_symref();
- if ($quilt_mode eq 'linear'
- && !$fopts->{'single-debian-patch'}
- && branch_is_gdr($headref)) {
- # This is much faster. It also makes patches that gdr
- # likes better for future updates without laundering.
- #
- # However, it can fail in some casses where we would
- # succeed: if there are existing patches, which correspond
- # to a prefix of the branch, but are not in gbp/gdr
- # format, gdr will fail (exiting status 7), but we might
- # be able to figure out where to start linearising. That
- # will be slower so hopefully there's not much to do.
- my @cmd = (@git_debrebase,
- qw(--noop-ok -funclean-mixed -funclean-ordering
- make-patches --quiet-would-amend));
- # We tolerate soe snags that gdr wouldn't, by default.
- if (act_local()) {
- debugcmd "+",@cmd;
- $!=0; $?=-1;
- failedcmd @cmd
- if system @cmd
- and not ($? == 7*256 or
- $? == -1 && $!==ENOENT);
- } else {
- dryrun_report @cmd;
- }
- $headref = git_rev_parse('HEAD');
- }
-
prep_ud();
changedir $playground;
my $upstreamversion = upstreamversion $version;
if ($fopts->{'single-debian-patch'}) {
+ fail f_
+ "quilt mode %s does not make sense (or is not supported) with single-debian-patch",
+ $quilt_mode
+ if quiltmode_splitbrain();
quilt_fixup_singlepatch($clogp, $headref, $upstreamversion);
} else {
quilt_fixup_multipatch($clogp, $headref, $upstreamversion);
}
}
-sub unpack_playtree_mkwork ($) {
+sub unpack_playtree_need_cd_work ($) {
my ($headref) = @_;
- mkdir "work" or confess "$!";
- changedir "work";
- mktree_in_ud_here();
+ # prep_ud() must have been called already.
+ if (!chdir "work") {
+ # Check in the filesystem because sometimes we run prep_ud
+ # in between multiple calls to unpack_playtree_need_cd_work.
+ confess "$!" unless $!==ENOENT;
+ mkdir "work" or confess "$!";
+ changedir "work";
+ mktree_in_ud_here();
+ }
runcmd @git, qw(reset -q --hard), $headref;
}
# necessary to build the source package.
unpack_playtree_linkorigs($upstreamversion, sub { });
- unpack_playtree_mkwork($headref);
+ unpack_playtree_need_cd_work($headref);
rmtree("debian/patches");
commit_quilty_patch();
}
-sub quilt_make_fake_dsc ($) {
+sub quilt_need_fake_dsc ($) {
+ # cwd should be playground
my ($upstreamversion) = @_;
+ return if stat_exists "fake.dsc";
+ # ^ OK to test this as a sentinel because if we created it
+ # we must either have done the rest too, or crashed.
+
my $fakeversion="$upstreamversion-~~DGITFAKE";
my $fakedsc=new IO::File 'fake.dsc', '>' or confess "$!";
sub quilt_fakedsc2unapplied ($$) {
my ($headref, $upstreamversion) = @_;
# must be run in the playground
- # quilt_make_fake_dsc must have been called
+ # quilt_need_fake_dsc must have been called
+ quilt_need_fake_dsc($upstreamversion);
runcmd qw(sh -ec),
'exec dpkg-source --no-check --skip-patches -x fake.dsc >/dev/null';
# Computes the cache key and looks in the cache.
# Returns ($dgit_view_commitid, $cachekey) or (undef, $cachekey)
+ quilt_need_fake_dsc($upstreamversion);
+
my $splitbrain_cachekey;
progress f_
"refs/$splitbraincache", $splitbrain_cachekey;
if ($cachehit) {
- unpack_playtree_mkwork($headref);
+ unpack_playtree_need_cd_work($headref);
my $saved = maybe_split_brain_save $headref, $cachehit, "cache-hit";
if ($cachehit ne $headref) {
progress f_ "dgit view: found cached (%s)", $saved;
my $splitbrain_cachekey;
- quilt_make_fake_dsc($upstreamversion);
+ if ($quilt_mode eq 'linear'
+ && branch_is_gdr($headref)) {
+ # This is much faster. It also makes patches that gdr
+ # likes better for future updates without laundering.
+ #
+ # However, it can fail in some casses where we would
+ # succeed: if there are existing patches, which correspond
+ # to a prefix of the branch, but are not in gbp/gdr
+ # format, gdr will fail (exiting status 7), but we might
+ # be able to figure out where to start linearising. That
+ # will be slower so hopefully there's not much to do.
- if (quiltmode_splitbrain()) {
+ unpack_playtree_need_cd_work $headref;
+
+ my @cmd = (@git_debrebase,
+ qw(--noop-ok -funclean-mixed -funclean-ordering
+ make-patches --quiet-would-amend));
+ # We tolerate soe snags that gdr wouldn't, by default.
+ if (act_local()) {
+ debugcmd "+",@cmd;
+ $!=0; $?=-1;
+ failedcmd @cmd
+ if system @cmd
+ and not ($? == 7*256 or
+ $? == -1 && $!==ENOENT);
+ } else {
+ dryrun_report @cmd;
+ }
+ $headref = git_rev_parse('HEAD');
+
+ chdir '..';
+ }
+
+ if ($do_split_brain) {
my $cachehit;
($cachehit, $splitbrain_cachekey) =
quilt_check_splitbrain_cache($headref, $upstreamversion);
changedir '..';
- unpack_playtree_mkwork($headref);
+ unpack_playtree_need_cd_work($headref);
my $mustdeletepc=0;
if (stat_exists ".pc") {
push @failsuggestion, [ 'origs', __
"Maybe orig tarball(s) are not identical to git representation?" ];
+ if ($do_split_brain) {
+ runcmd @git, qw(checkout -q -b dgit-view);
+ die if $split_brain;
+ $split_brain = 1;
+ }
if (quiltmode_splitbrain()) {
quiltify_splitbrain($clogp, $unapplied, $headref, $oldtiptree,
$diffbits, \%editedignores,
unless ($split_brain) {
my $upstreamversion = upstreamversion $version;
unpack_playtree_linkorigs($upstreamversion, sub { });
- unpack_playtree_mkwork($headref);
+ unpack_playtree_need_cd_work($headref);
changedir '..';
}
} else {
prep_ud();
changedir $playground;
my $uv = upstreamversion $version;
- quilt_make_fake_dsc($uv);
my $u = quilt_fakedsc2unapplied($headref, $uv);
print $u, "\n" or confess "$!";
}
~ianmdlvl / dgit.git / blobdiff