From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Sun, 30 Oct 2016 23:56:29 +0000 (+0000)
Subject: Merge branch 'wip.tutorials' into wip
X-Git-Tag: archive/debian/2.9~12
X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=commitdiff_plain;h=cb809d942c58dea5dfba6ad8b7e3298338ebb24e;hp=6e7c6b8b8305f162cea9e3da85c24b3f21888a1a

Merge branch 'wip.tutorials' into wip
---

diff --git a/debian/changelog b/debian/changelog
index dac3dbe4..a67a2051 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,31 @@
 dgit (2.9~) unstable; urgency=low
 
+  * Split brain mode: Fix --new.  Closes:#842354.
+  * During push, automatically calculate which .origs are required,
+    so user never needs [--ch:]-sa or [--ch:]-sd.  Closes:#829116.
+  * Properly look for .origs etc. in .., fetching them less often.
+    Closes:#842386.
+  * New import-dsc feature.
+  * Test suite: Explicitly configure user.name and user.email, so
+    that tests work when environment doesn't have defaults.
+    Closes:#842279 (I hope).
+  * New option --dgit-view-save= for split view quilt modes.
+    In particular, means that the output of a split view quilt-fixup
+    is left somewhere useful.
+  * dgit clone: Set timestamps in cloned tree to a single unified time.
+    This makes it less likely that the user will trip over any
+    timestamp-dependent FTBFS bugs (eg #842452).
+  * Support dgit --delayed= push (with a warning in the manpage
+    about possible skew).
+  * dgit gbp-build will arrange to let gbp buildpackage generate
+    .orig tarballs if it seems applicable.  Closes:#841094.
+  * Reject `dgit pull' in split view quilt modes, to avoid
+    creating unfortunate wreckage on non-dgit-view branches.
+    Closes:#842608.
+  * Cope when cloning suite which doesn't receive uploads,
+    like testing.  Closes:#842621.
+  * Properly fetch all archive dgit view tags, as we intended.
+  * Actually provide a -p (--package=) option (!)
   * dgit-*(7).  Many new tutorial manpages, several written and many
     improved by Sean Whitton.
   * dgit(7): Substantial updates, including documenting split view.
diff --git a/debian/tests/control b/debian/tests/control
index b4c278db..a9f66649 100644
--- a/debian/tests/control
+++ b/debian/tests/control
@@ -21,7 +21,7 @@ Tests-Directory: tests/tests
 Depends: dgit, dgit-infrastructure, devscripts, debhelper (>=8)
 Restrictions: x-dgit-git-only
 
-Tests: absurd-gitapply build-modes build-modes-asplit build-modes-gbp-asplit clone-clogsigpipe clone-gitnosuite clone-nogit debpolicy-dbretry debpolicy-newreject debpolicy-quilt-gbp distropatches-reject drs-clone-nogit drs-push-masterupdate drs-push-rejects dsd-clone-nogit dsd-divert fetch-localgitonly fetch-somegit-notlast gitconfig import-native import-nonnative inarchivecopy mismatches-contents mismatches-dscchanges newtag-clone-nogit oldnewtagalt oldtag-clone-nogit overwrite-chkclog overwrite-junk overwrite-splitbrains overwrite-version push-buildproductsdir push-newpackage push-nextdgit quilt quilt-gbp quilt-gbp-build-modes quilt-singlepatch quilt-splitbrains rpush tag-updates test-list-uptodate trustingpolicy-replay unrepresentable version-opt
+Tests: absurd-gitapply build-modes build-modes-asplit build-modes-gbp-asplit clone-clogsigpipe clone-gitnosuite clone-nogit debpolicy-dbretry debpolicy-newreject debpolicy-quilt-gbp distropatches-reject drs-clone-nogit drs-push-masterupdate drs-push-rejects dsd-clone-nogit dsd-divert fetch-localgitonly fetch-somegit-notlast gbp-orig gitconfig import-dsc import-native import-nonnative inarchivecopy mismatches-contents mismatches-dscchanges newtag-clone-nogit oldnewtagalt oldtag-clone-nogit orig-include-exclude orig-include-exclude-chkquery overwrite-chkclog overwrite-junk overwrite-splitbrains overwrite-version push-buildproductsdir push-newpackage push-nextdgit quilt quilt-gbp quilt-gbp-build-modes quilt-singlepatch quilt-splitbrains rpush tag-updates test-list-uptodate trustingpolicy-replay unrepresentable version-opt
 Tests-Directory: tests/tests
 Depends: dgit, dgit-infrastructure, devscripts, debhelper (>=8)
 
diff --git a/dgit b/dgit
index 7508fe15..8264f3e5 100755
--- a/dgit
+++ b/dgit
@@ -67,6 +67,7 @@ our $rmchanges;
 our $overwrite_version; # undef: not specified; '': check changelog
 our $quilt_mode;
 our $quilt_modes_re = 'linear|smash|auto|nofix|nocheck|gbp|dpm|unapplied';
+our $split_brain_save;
 our $we_are_responder;
 our $initiator_tempdir;
 our $patches_applied_dirtily = 00;
@@ -76,9 +77,10 @@ our $tagformatfn;
 
 our %forceopts = map { $_=>0 }
     qw(unrepresentable unsupported-source-format
-       dsc-changes-mismatch
+       dsc-changes-mismatch changes-origs-exactly
        import-gitapply-absurd
-       import-gitapply-no-absurd);
+       import-gitapply-no-absurd
+       import-dsc-with-dgit-field);
 
 our %format_ok = map { $_=>1 } ("1.0","3.0 (native)","3.0 (quilt)");
 
@@ -220,6 +222,12 @@ sub changespat ($;$) {
     return "${package}_".(stripepoch $vsn)."_".($arch//'*').".changes";
 }
 
+sub upstreamversion ($) {
+    my ($vsn) = @_;
+    $vsn =~ s/-[^-]+$//;
+    return $vsn;
+}
+
 our $us = 'dgit';
 initdebug('');
 
@@ -619,7 +627,7 @@ our %defcfg = ('dgit.default.distro' => 'debian',
 	       'dgit-distro.test-dummy.git-url' => "$td/git",
 	       'dgit-distro.test-dummy.git-host' => "git",
 	       'dgit-distro.test-dummy.git-path' => "$td/git",
-	       'dgit-distro.test-dummy.archive-query' => "ftpmasterapi:",
+	       'dgit-distro.test-dummy.archive-query' => "dummycatapi:",
 	       'dgit-distro.test-dummy.archive-query-url' => "file://$td/aq/",
 	       'dgit-distro.test-dummy.mirror' => "file://$td/mirror/",
 	       'dgit-distro.test-dummy.upload-host' => 'test-dummy',
@@ -960,15 +968,22 @@ sub must_getcwd () {
     return $d;
 }
 
+sub parse_dscdata () {
+    my $dscfh = new IO::File \$dscdata, '<' or die $!;
+    printdebug Dumper($dscdata) if $debuglevel>1;
+    $dsc = parsecontrolfh($dscfh,$dscurl,1);
+    printdebug Dumper($dsc) if $debuglevel>1;
+}
+
 our %rmad;
 
-sub archive_query ($) {
-    my ($method) = @_;
+sub archive_query ($;@) {
+    my ($method) = shift @_;
     my $query = access_cfg('archive-query','RETURN-UNDEF');
     $query =~ s/^(\w+):// or badcfg "invalid archive-query method \`$query'";
     my $proto = $1;
     my $data = $'; #';
-    { no strict qw(refs); &{"${method}_${proto}"}($proto,$data); }
+    { no strict qw(refs); &{"${method}_${proto}"}($proto,$data,@_); }
 }
 
 sub pool_dsc_subpath ($$) {
@@ -1009,9 +1024,9 @@ sub archive_api_query_cmd ($) {
     return @cmd;
 }
 
-sub api_query ($$) {
+sub api_query ($$;$) {
     use JSON;
-    my ($data, $subpath) = @_;
+    my ($data, $subpath, $ok404) = @_;
     badcfg "ftpmasterapi archive query method takes no data part"
 	if length $data;
     my @cmd = archive_api_query_cmd($subpath);
@@ -1023,12 +1038,13 @@ sub api_query ($$) {
 	fail "curl failed to print 3-digit HTTP code";
     }
     my $code = $&;
+    return undef if $code eq '404' && $ok404;
     fail "fetch of $url gave HTTP code $code"
 	unless $url =~ m#^file://# or $code =~ m/^2/;
     return decode_json($json);
 }
 
-sub canonicalise_suite_ftpmasterapi () {
+sub canonicalise_suite_ftpmasterapi {
     my ($proto,$data) = @_;
     my $suites = api_query($data, 'suites');
     my @matched;
@@ -1052,7 +1068,7 @@ sub canonicalise_suite_ftpmasterapi () {
     return $cn;
 }
 
-sub archive_query_ftpmasterapi () {
+sub archive_query_ftpmasterapi {
     my ($proto,$data) = @_;
     my $info = api_query($data, "dsc_in_suite/$isuite/$package");
     my @rows;
@@ -1079,6 +1095,42 @@ sub archive_query_ftpmasterapi () {
     return @rows;
 }
 
+sub file_in_archive_ftpmasterapi {
+    my ($proto,$data,$filename) = @_;
+    my $pat = $filename;
+    $pat =~ s/_/\\_/g;
+    $pat = "%/$pat";
+    $pat =~ s#[^-+_.0-9a-z/]# sprintf '%%%02x', ord $& #ge;
+    my $info = api_query($data, "file_in_archive/$pat", 1);
+}
+
+#---------- `dummyapicat' archive query method ----------
+
+sub archive_query_dummycatapi { archive_query_ftpmasterapi @_; }
+sub canonicalise_suite_dummycatapi { canonicalise_suite_ftpmasterapi @_; }
+
+sub file_in_archive_dummycatapi ($$$) {
+    my ($proto,$data,$filename) = @_;
+    my $mirror = access_cfg('mirror');
+    $mirror =~ s#^file://#/# or die "$mirror ?";
+    my @out;
+    my @cmd = (qw(sh -ec), '
+            cd "$1"
+            find -name "$2" -print0 |
+            xargs -0r sha256sum
+        ', qw(x), $mirror, $filename);
+    debugcmd "-|", @cmd;
+    open FIA, "-|", @cmd or die $!;
+    while (<FIA>) {
+	chomp or die;
+	printdebug "| $_\n";
+	m/^(\w+)  (\S+)$/ or die "$_ ?";
+	push @out, { sha256sum => $1, filename => $2 };
+    }
+    close FIA or die failedcmd @cmd;
+    return \@out;
+}
+
 #---------- `madison' archive query method ----------
 
 sub archive_query_madison {
@@ -1127,6 +1179,8 @@ sub canonicalise_suite_madison {
     return $r[0][2];
 }
 
+sub file_in_archive_madison { return undef; }
+
 #---------- `sshpsql' archive query method ----------
 
 sub sshpsql ($$$) {
@@ -1202,6 +1256,8 @@ END
     return $rows[0];
 }
 
+sub file_in_archive_sshpsql ($$$) { return undef; }
+
 #---------- `dummycat' archive query method ----------
 
 sub canonicalise_suite_dummycat ($$) {
@@ -1243,6 +1299,8 @@ sub archive_query_dummycat ($$) {
     return sort { -version_compare($a->[0],$b->[0]); } @rows;
 }
 
+sub file_in_archive_dummycat () { return undef; }
+
 #---------- tag format handling ----------
 
 sub access_cfg_tagformats () {
@@ -1315,10 +1373,7 @@ sub get_archive_dsc () {
 		fail "$dscurl has hash $got but".
 		    " archive told us to expect $digest";
 	}
-	my $dscfh = new IO::File \$dscdata, '<' or die $!;
-	printdebug Dumper($dscdata) if $debuglevel>1;
-	$dsc = parsecontrolfh($dscfh,$dscurl,1);
-	printdebug Dumper($dsc) if $debuglevel>1;
+	parse_dscdata();
 	my $fmt = getfield $dsc, 'Format';
 	$format_ok{$fmt} or forceable_fail [qw(unsupported-source-format)],
 	    "unsupported source format $fmt, sorry";
@@ -1464,9 +1519,9 @@ sub mktree_in_ud_from_only_subdir (;$) {
 }
 
 our @files_csum_info_fields = 
-    (['Checksums-Sha256','Digest::SHA', 'new(256)'],
-     ['Checksums-Sha1',  'Digest::SHA', 'new(1)'],
-     ['Files',           'Digest::MD5', 'new()']);
+    (['Checksums-Sha256','Digest::SHA', 'new(256)', 'sha256sum'],
+     ['Checksums-Sha1',  'Digest::SHA', 'new(1)',   'sha1sum'],
+     ['Files',           'Digest::MD5', 'new()',    'md5sum']);
 
 sub dsc_files_info () {
     foreach my $csumi (@files_csum_info_fields) {
@@ -1572,6 +1627,101 @@ sub is_orig_file_of_vsn ($$) {
     return 1;
 }
 
+sub changes_update_origs_from_dsc ($$$$) {
+    my ($dsc, $changes, $upstreamvsn, $changesfile) = @_;
+    my %changes_f;
+    printdebug "checking origs needed ($upstreamvsn)...\n";
+    $_ = getfield $changes, 'Files';
+    m/^\w+ \d+ (\S+ \S+) \S+$/m or
+	fail "cannot find section/priority from .changes Files field";
+    my $placementinfo = $1;
+    my %changed;
+    printdebug "checking origs needed placement '$placementinfo'...\n";
+    foreach my $l (split /\n/, getfield $dsc, 'Files') {
+	$l =~ m/\S+$/ or next;
+	my $file = $&;
+	printdebug "origs $file | $l\n";
+	next unless is_orig_file_of_vsn $file, $upstreamvsn;
+	printdebug "origs $file is_orig\n";
+	my $have = archive_query('file_in_archive', $file);
+	if (!defined $have) {
+	    print STDERR <<END;
+archive does not support .orig check; hope you used --ch:--sa/-sd if needed
+END
+	    return;
+	}
+	my $found_same = 0;
+	my @found_differ;
+	printdebug "origs $file \$#\$have=$#$have\n";
+	foreach my $h (@$have) {
+	    my $same = 0;
+	    my @differ;
+	    foreach my $csumi (@files_csum_info_fields) {
+		my ($fname, $module, $method, $archivefield) = @$csumi;
+		next unless defined $h->{$archivefield};
+		$_ = $dsc->{$fname};
+		next unless defined;
+		m/^(\w+) .* \Q$file\E$/m or
+		    fail ".dsc $fname missing entry for $file";
+		if ($h->{$archivefield} eq $1) {
+		    $same++;
+		} else {
+		    push @differ,
+ "$archivefield: $h->{$archivefield} (archive) != $1 (local .dsc)";
+		}
+	    }
+	    die "$file ".Dumper($h)." ?!" if $same && @differ;
+	    $found_same++
+		if $same;
+	    push @found_differ, "archive $h->{filename}: ".join "; ", @differ
+		if @differ;
+	}
+	print "origs $file f.same=$found_same #f._differ=$#found_differ\n";
+	if (@found_differ && !$found_same) {
+	    fail join "\n",
+		"archive contains $file with different checksum",
+		@found_differ;
+	}
+	# Now we edit the changes file to add or remove it
+	foreach my $csumi (@files_csum_info_fields) {
+	    my ($fname, $module, $method, $archivefield) = @$csumi;
+	    next unless defined $changes->{$fname};
+	    if ($found_same) {
+		# in archive, delete from .changes if it's there
+		$changed{$file} = "removed" if
+		    $changes->{$fname} =~ s/^.* \Q$file\E$(?:)\n//m;
+	    } elsif ($changes->{$fname} =~ m/^.* \Q$file\E$(?:)\n/m) {
+		# not in archive, but it's here in the .changes
+	    } else {
+		my $dsc_data = getfield $dsc, $fname;
+		$dsc_data =~ m/^(.* \Q$file\E$)\n/m or die "$dsc_data $file ?";
+		my $extra = $1;
+		$extra =~ s/ \d+ /$&$placementinfo /
+		    or die "$fname $extra >$dsc_data< ?"
+		    if $fname eq 'Files';
+		$changes->{$fname} .= "\n". $extra;
+		$changed{$file} = "added";
+	    }
+	}
+    }
+    if (%changed) {
+	foreach my $file (keys %changed) {
+	    progress sprintf
+		"edited .changes for archive .orig contents: %s %s",
+		$changed{$file}, $file;
+	}
+	my $chtmp = "$changesfile.tmp";
+	$changes->save($chtmp);
+	if (act_local()) {
+	    rename $chtmp,$changesfile or die "$changesfile $!";
+	} else {
+	    progress "[new .changes left in $changesfile]";
+	}
+    } else {
+	progress "$changesfile already has appropriate .orig(s) (if any)";
+    }
+}
+
 sub make_commit ($) {
     my ($file) = @_;
     return cmdoutput @git, qw(hash-object -w -t commit), $file;
@@ -1686,10 +1836,15 @@ sub generate_commits_from_dsc () {
 	my $f = $fi->{Filename};
 	die "$f ?" if $f =~ m#/|^\.|\.dsc$|\.tmp$#;
 
-	link_ltarget "../../../$f", $f
+	printdebug "considering linking $f: ";
+
+	link_ltarget "../../../../$f", $f
+	    or ((printdebug "($!) "), 0)
 	    or $!==&ENOENT
 	    or die "$f $!";
 
+	printdebug "linked.\n";
+
 	complete_file_from_dsc('.', $fi)
 	    or next;
 
@@ -1706,8 +1861,7 @@ sub generate_commits_from_dsc () {
     # from the debian/changelog, so we record the tree objects now and
     # make them into commits later.
     my @tartrees;
-    my $upstreamv = $dsc->{version};
-    $upstreamv =~ s/-[^-]+$//;
+    my $upstreamv = upstreamversion $dsc->{version};
     my $orig_f_base = srcfn $upstreamv, '';
 
     foreach my $fi (@dfi) {
@@ -2068,6 +2222,7 @@ sub complete_file_from_dsc ($$) {
     if (stat_exists $tf) {
 	progress "using existing $f";
     } else {
+	printdebug "$tf does not exist, need to fetch\n";
 	my $furl = $dscurl;
 	$furl =~ s{/[^/]+$}{};
 	$furl .= "/$f";
@@ -2137,6 +2292,8 @@ sub git_fetch_us () {
     # git fetch to try to generate it.  If we don't manage to generate
     # the target state, we try again.
 
+    printdebug "git_fetch_us specs @specs\n";
+
     my $specre = join '|', map {
 	my $x = $_;
 	$x =~ s/\W/\\$&/g;
@@ -2152,6 +2309,7 @@ sub git_fetch_us () {
     my $fetch_iteration = 0;
     FETCH_ITERATION:
     for (;;) {
+	printdebug "git_fetch_us iteration $fetch_iteration\n";
         if (++$fetch_iteration > 10) {
 	    fail "too many iterations trying to get sane fetch!";
 	}
@@ -2179,10 +2337,12 @@ END
 
 	# OK, now %want is exactly what we want for refs in @specs
 	my @fspecs = map {
-	    return () if !m/\*$/ && !exists $wantr{"refs/$_"};
+	    !m/\*$/ && !exists $wantr{"refs/$_"} ? () :
 	    "+refs/$_:".lrfetchrefs."/$_";
 	} @specs;
 
+	printdebug "git_fetch_us fspecs @fspecs\n";
+
 	my @fcmd = (@git, qw(fetch -p -n -q), access_giturl(), @fspecs);
 	runcmd_ordryrun_local @git, qw(fetch -p -n -q), access_giturl(),
 	    @fspecs;
@@ -2416,11 +2576,8 @@ sub fetch_from_archive () {
     };
 
     if (defined $dsc_hash) {
-	fail "missing remote git history even though dsc has hash -".
-	    " could not find ref ".rref()." at ".access_giturl()
-	    unless $lastpush_hash;
 	ensure_we_have_orig();
-	if ($dsc_hash eq $lastpush_hash) {
+	if (!$lastpush_hash || $dsc_hash eq $lastpush_hash) {
 	    @mergeinputs = $dsc_mergeinput
 	} elsif (is_fast_fwd($dsc_hash,$lastpush_hash)) {
 	    print STDERR <<END or die $!;
@@ -2587,7 +2744,8 @@ END
 	die "$lasth $hash $what ?" unless is_fast_fwd($lasth, $hash);
     };
 
-    $chkff->($lastpush_hash, 'dgit repo server tip (last push)');
+    $chkff->($lastpush_hash, 'dgit repo server tip (last push)')
+	if $lastpush_hash;
     $chkff->($lastfetch_hash, 'local tracking tip (last fetch)');
 
     runcmd @git, qw(update-ref -m), "dgit fetch $csuite",
@@ -2719,6 +2877,11 @@ sub clone ($) {
     }
     setup_new_tree();
     runcmd @git, qw(reset --hard), lrref();
+    runcmd qw(bash -ec), <<'END';
+        set -o pipefail
+        git ls-tree -r --name-only -z HEAD | \
+        xargs -0r touch -r . --
+END
     printdone "ready for work in $dstdir";
 }
 
@@ -2832,6 +2995,18 @@ sub madformat_wantfixup ($) {
     return 1;
 }
 
+sub maybe_split_brain_save ($$$) {
+    my ($headref, $dgitview, $msg) = @_;
+    # => message fragment "$saved" describing disposition of $dgitview
+    return "commit id $dgitview" unless defined $split_brain_save;
+    my @cmd = (shell_cmd "cd ../../../..",
+	       @git, qw(update-ref -m),
+	       "dgit --dgit-view-save $msg HEAD=$headref",
+	       $split_brain_save, $dgitview);
+    runcmd @cmd;
+    return "and left in $split_brain_save";
+}
+
 # An "infopair" is a tuple [ $thing, $what ]
 # (often $thing is a commit hash; $what is a description)
 
@@ -2950,12 +3125,12 @@ sub splitbrain_pseudomerge ($$$$) {
     #   this:                                   $dgitview'
     #
 
+    return $dgitview unless defined $archive_hash;
+
     printdebug "splitbrain_pseudomerge...\n";
 
     my $i_arch_v = pseudomerge_version_check($clogp, $archive_hash);
 
-    return $dgitview unless defined $archive_hash;
-
     if (!defined $overwrite_version) {
 	progress "Checking that HEAD inciudes all changes in archive...";
     }
@@ -2992,6 +3167,8 @@ END_OVERWR
 Make fast forward from $i_arch_v->[0]
 END_MAKEFF
 
+    maybe_split_brain_save $maintview, $r, "pseudomerge";
+
     progress "Made pseudo-merge of $i_arch_v->[0] into dgit view.";
     return $r;
 }	
@@ -3023,7 +3200,10 @@ sub push_parse_changelog ($) {
     my $clogp = Dpkg::Control::Hash->new();
     $clogp->load($clogpfn) or die;
 
-    $package = getfield $clogp, 'Source';
+    my $clogpackage = getfield $clogp, 'Source';
+    $package //= $clogpackage;
+    fail "-p specified $package but changelog specified $clogpackage"
+	unless $package eq $clogpackage;
     my $cversion = getfield $clogp, 'Version';
     my $tag = debiantag($cversion, access_basedistro);
     runcmd @git, qw(check-ref-format), $tag;
@@ -3220,11 +3400,11 @@ END
     my $dgithead = $actualhead;
     my $maintviewhead = undef;
 
+    my $upstreamversion = upstreamversion $clogp->{Version};
+
     if (madformat_wantfixup($format)) {
 	# user might have not used dgit build, so maybe do this now:
 	if (quiltmode_splitbrain()) {
-	    my $upstreamversion = $clogp->{Version};
-	    $upstreamversion =~ s/-[^-]*$//;
 	    changedir $ud;
 	    quilt_make_fake_dsc($upstreamversion);
 	    my $cachekey;
@@ -3308,9 +3488,15 @@ END
 
     # Check that changes and .dsc agree enough
     $changesfile =~ m{[^/]*$};
-    files_compare_inputs($dsc, parsecontrol($changesfile,$&))
+    my $changes = parsecontrol($changesfile,$&);
+    files_compare_inputs($dsc, $changes)
 	unless forceing [qw(dsc-changes-mismatch)];
 
+    # Perhaps adjust .dsc to contain right set of origs
+    changes_update_origs_from_dsc($dsc, $changes, $upstreamversion,
+				  $changesfile)
+	unless forceing [qw(changes-origs-exactly)];
+
     # Checks complete, we're going to try and go ahead:
 
     responder_send_file('changes',$changesfile);
@@ -3502,6 +3688,12 @@ sub cmd_fetch {
 sub cmd_pull {
     parseopts();
     fetchpullargs();
+    if (quiltmode_splitbrain()) {
+	my ($format, $fopts) = get_source_format();
+	madformat($format) and fail <<END
+dgit pull not yet supported in split view mode (--quilt=$quilt_mode)
+END
+    }
     pull();
 }
 
@@ -4003,9 +4195,10 @@ END
     runcmd @git, qw(update-ref -m), $cachekey, "refs/$splitbraincache",
 	$dgitview;
 
-    progress "dgit view: created (commit id $dgitview)";
-
     changedir '.git/dgit/unpack/work';
+
+    my $saved = maybe_split_brain_save $headref, $dgitview, "converted";
+    progress "dgit view: created ($saved)";
 }
 
 sub quiltify ($$$$) {
@@ -4304,8 +4497,7 @@ END
     prep_ud();
     changedir $ud;
 
-    my $upstreamversion=$version;
-    $upstreamversion =~ s/-[^-]*$//;
+    my $upstreamversion = upstreamversion $version;
 
     if ($fopts->{'single-debian-patch'}) {
 	quilt_fixup_singlepatch($clogp, $headref, $upstreamversion);
@@ -4475,8 +4667,9 @@ sub quilt_check_splitbrain_cache ($$) {
 	    
 	my $cachehit = $1;
 	quilt_fixup_mkwork($headref);
+	my $saved = maybe_split_brain_save $headref, $cachehit, "cache-hit";
 	if ($cachehit ne $headref) {
-	    progress "dgit view: found cached (commit id $cachehit)";
+	    progress "dgit view: found cached ($saved)";
 	    runcmd @git, qw(checkout -q -b dgit-view), $cachehit;
 	    $split_brain = 1;
 	    return ($cachehit, $splitbrain_cachekey);
@@ -4782,15 +4975,21 @@ sub cmd_clean () {
     maybe_unapply_patches_again();
 }
 
-sub build_prep () {
+sub build_prep_early () {
+    our $build_prep_early_done //= 0;
+    return if $build_prep_early_done++;
     notpushing();
     badusage "-p is not allowed when building" if defined $package;
-    check_not_dirty();
-    clean_tree();
     my $clogp = parsechangelog();
     $isuite = getfield $clogp, 'Distribution';
     $package = getfield $clogp, 'Source';
     $version = getfield $clogp, 'Version';
+    check_not_dirty();
+}
+
+sub build_prep () {
+    build_prep_early();
+    clean_tree();
     build_maybe_quilt_fixup();
     if ($rmchanges) {
 	my $pat = changespat $version;
@@ -4989,6 +5188,24 @@ sub pre_gbp_build {
 }
 
 sub cmd_gbp_build {
+    build_prep_early();
+
+    # gbp can make .origs out of thin air.  In my tests it does this
+    # even for a 1.0 format package, with no origs present.  So I
+    # guess it keys off just the version number.  We don't know
+    # exactly what .origs ought to exist, but let's assume that we
+    # should run gbp if: the version has an upstream part and the main
+    # orig is absent.
+    my $upstreamversion = upstreamversion $version;
+    my $origfnpat = srcfn $upstreamversion, '.orig.tar.*';
+    my $gbp_make_orig = $version =~ m/-/ && !(() = glob "../$origfnpat");
+
+    if ($gbp_make_orig) {
+	clean_tree();
+	$cleanmode = 'none'; # don't do it again
+	$need_split_build_invocation = 1;
+    }
+
     my @dbp = @dpkgbuildpackage;
 
     my $wantsrc = massage_dbp_args \@dbp, \@ARGV;
@@ -5004,6 +5221,24 @@ sub cmd_gbp_build {
 
     push @cmd, (qw(-us -uc --git-no-sign-tags), "--git-builder=@dbp");
 
+    if ($gbp_make_orig) {
+	ensuredir '.git/dgit';
+	my $ok = '.git/dgit/origs-gen-ok';
+	unlink $ok or $!==&ENOENT or die $!;
+	my @origs_cmd = @cmd;
+	push @origs_cmd, qw(--git-cleaner=true);
+	push @origs_cmd, "--git-prebuild=touch $ok .git/dgit/no-such-dir/ok";
+	push @origs_cmd, @ARGV;
+	if (act_local()) {
+	    debugcmd @origs_cmd;
+	    system @origs_cmd;
+	    do { local $!; stat_exists $ok; }
+		or failedcmd @origs_cmd;
+	} else {
+	    dryrun_report @origs_cmd;
+	}
+    }
+
     if ($wantsrc > 0) {
 	build_source();
 	midbuild_checkchanges_vanilla $wantsrc;
@@ -5119,6 +5354,157 @@ sub cmd_quilt_fixup {
     build_maybe_quilt_fixup();
 }
 
+sub cmd_import_dsc {
+    my $needsig = 0;
+
+    while (@ARGV) {
+	last unless $ARGV[0] =~ m/^-/;
+	$_ = shift @ARGV;
+	last if m/^--?$/;
+	if (m/^--require-valid-signature$/) {
+	    $needsig = 1;
+	} else {
+	    badusage "unknown dgit import-dsc sub-option \`$_'";
+	}
+    }
+
+    badusage "usage: dgit import-dsc .../PATH/TO/.DSC BRANCH" unless @ARGV==2;
+    my ($dscfn, $dstbranch) = @ARGV;
+
+    badusage "dry run makes no sense with import-dsc" unless act_local();
+
+    my $force = $dstbranch =~ s/^\+//   ? +1 :
+	        $dstbranch =~ s/^\.\.// ? -1 :
+                                           0;
+    my $info = $force ? " $&" : '';
+    $info = "$dscfn$info";
+
+    my $specbranch = $dstbranch;
+    $dstbranch = "refs/heads/$dstbranch" unless $dstbranch =~ m#^refs/#;
+    $dstbranch = cmdoutput @git, qw(check-ref-format --normalize), $dstbranch;
+
+    my @symcmd = (@git, qw(symbolic-ref -q HEAD));
+    my $chead = cmdoutput_errok @symcmd;
+    defined $chead or $?==256 or failedcmd @symcmd;
+
+    fail "$dstbranch is checked out - will not update it"
+	if defined $chead and $chead eq $dstbranch;
+
+    my $oldhash = git_get_ref $dstbranch;
+
+    open D, "<", $dscfn or fail "open import .dsc ($dscfn): $!";
+    $dscdata = do { local $/ = undef; <D>; };
+    D->error and fail "read $dscfn: $!";
+    close C;
+
+    # we don't normally need this so import it here
+    use Dpkg::Source::Package;
+    my $dp = new Dpkg::Source::Package filename => $dscfn,
+	require_valid_signature => $needsig;
+    {
+	local $SIG{__WARN__} = sub {
+	    print STDERR $_[0];
+	    return unless $needsig;
+	    fail "import-dsc signature check failed";
+	};
+	if (!$dp->is_signed()) {
+	    warn "$us: warning: importing unsigned .dsc\n";
+	} else {
+	    my $r = $dp->check_signature();
+	    die "->check_signature => $r" if $needsig && $r;
+	}
+    }
+
+    parse_dscdata();
+
+    my $dgit_commit = $dsc->{$ourdscfield[0]};
+    if (defined $dgit_commit && 
+	!forceing [qw(import-dsc-with-dgit-field)]) {
+	$dgit_commit =~ m/\w+/ or fail "invalid hash in .dsc";
+	progress "dgit: import-dsc of .dsc with Dgit field, using git hash";
+	my @cmd = (qw(sh -ec),
+		   "echo $dgit_commit | git cat-file --batch-check");
+	my $objgot = cmdoutput @cmd;
+	if ($objgot =~ m#^\w+ missing\b#) {
+	    fail <<END
+.dsc contains Dgit field referring to object $dgit_commit
+Your git tree does not have that object.  Try `git fetch' from a
+plausible server (browse.dgit.d.o? alioth?), and try the import-dsc again.
+END
+	}
+	if ($oldhash && !is_fast_fwd $oldhash, $dgit_commit) {
+	    if ($force > 0) {
+		progress "Not fast forward, forced update.";
+	    } else {
+		fail "Not fast forward to $dgit_commit";
+	    }
+	}
+	@cmd = (@git, qw(update-ref -m), "dgit import-dsc (Dgit): $info",
+		$dstbranch, $dgit_commit);
+	runcmd @cmd;
+	progress "dgit: import-dsc updated git ref $dstbranch";
+	return 0;
+    }
+
+    fail <<END
+Branch $dstbranch already exists
+Specify ..$specbranch for a pseudo-merge, binding in existing history
+Specify  +$specbranch to overwrite, discarding existing history
+END
+	if $oldhash && !$force;
+
+    $package = getfield $dsc, 'Source';
+    my @dfi = dsc_files_info();
+    foreach my $fi (@dfi) {
+	my $f = $fi->{Filename};
+	my $here = "../$f";
+	next if lstat $here;
+	fail "stat $here: $!" unless $! == ENOENT;
+	my $there = $dscfn;
+	if ($dscfn =~ m#^(?:\./+)?\.\./+#) {
+	    $there = $';
+	} elsif ($dscfn =~ m#^/#) {
+	    $there = $dscfn;
+	} else {
+	    fail "cannot import $dscfn which seems to be inside working tree!";
+	}
+	$there =~ s#/+[^/]+$## or
+	    fail "cannot import $dscfn which seems to not have a basename";
+	$there .= "/$f";
+	symlink $there, $here or fail "symlink $there to $here: $!";
+	progress "made symlink $here -> $there";
+	print STDERR Dumper($fi);
+    }
+    my @mergeinputs = generate_commits_from_dsc();
+    die unless @mergeinputs == 1;
+
+    my $newhash = $mergeinputs[0]{Commit};
+
+    if ($oldhash) {
+	if ($force > 0) {
+	    progress "Import, forced update - synthetic orphan git history.";
+	} elsif ($force < 0) {
+	    progress "Import, merging.";
+	    my $tree = cmdoutput @git, qw(rev-parse), "$newhash:";
+	    my $version = getfield $dsc, 'Version';
+	    $newhash = make_commit_text <<END;
+tree $tree
+parent $newhash
+parent $oldhash
+
+Merge $package ($version) import into $dstbranch
+END
+	} else {
+	    die; # caught earlier
+	}
+    }
+
+    my @cmd = (@git, qw(update-ref -m), "dgit import-dsc: $info",
+	       $dstbranch, $newhash);
+    runcmd @cmd;
+    progress "dgit: import-dsc results are in in git ref $dstbranch";
+}
+
 sub cmd_archive_api_query {
     badusage "need only 1 subpath argument" unless @ARGV==1;
     my ($subpath) = @ARGV;
@@ -5179,6 +5565,7 @@ defvalopt '',                '-k', '.+',      \$keyid;
 defvalopt '--existing-package','', '.*',      \$existing_package;
 defvalopt '--build-products-dir','','.*',     \$buildproductsdir;
 defvalopt '--clean',       '', $cleanmode_re, \$cleanmode;
+defvalopt '--package',   '-p',   $package_re, \$package;
 defvalopt '--quilt',     '', $quilt_modes_re, \$quilt_mode;
 
 defvalopt '', '-C', '.+', sub {
@@ -5274,6 +5661,13 @@ sub parseopts () {
 	    } elsif (m/^--overwrite=(.+)$/s) {
 		push @ropts, $_;
 		$overwrite_version = $1;
+	    } elsif (m/^--delayed=(\d+)$/s) {
+		push @ropts, $_;
+		push @dput, $_;
+	    } elsif (m/^--dgit-view-save=(.+)$/s) {
+		push @ropts, $_;
+		$split_brain_save = $1;
+		$split_brain_save =~ s#^(?!refs/)#refs/heads/#;
 	    } elsif (m/^--(no-)?rm-old-changes$/s) {
 		push @ropts, $_;
 		$rmchanges = !$1;
diff --git a/dgit.1 b/dgit.1
index bbe7bd66..a26f6bc0 100644
--- a/dgit.1
+++ b/dgit.1
@@ -159,6 +159,9 @@ the built source package not being identical to the git tree.
 
 In more detail: dgit push checks that the current HEAD corresponds to
 the .dsc.  It then pushes the HEAD to the suite's dgit-repos branch,
+adjusts the .changes to include any .origs which the archive lacks
+and exclude .origs which the archive has
+(so -sa and -sd are not needed when building for dgit push),
 makes a signed git tag, edits the .dsc to contain the dgit metadata
 field, runs debsign to sign the upload (.dsc and .changes), pushes the
 signed tag, and finally uses dput to upload the .changes to the
@@ -241,6 +244,60 @@ other kinds of more exotic history.  If dgit can't find a suitable
 linearisation of your history, by default it will fail, but you can
 ask it to generate a single squashed patch instead.
 .TP
+\fBdgit import-dsc\fR [\fIsub-options\fR] \fI../path/to/.dsc\fR [\fB+\fR|\fB..\fR]branch
+Import a Debian-format source package,
+specified by its .dsc,
+into git,
+the way dgit fetch would do.
+
+This does about half the work of dgit fetch:
+it will convert the .dsc into a new, orphan git branch.
+Since dgit has no access to a corresponding source package archive
+or knowledge of the history
+it does not consider whether this version is newer
+than any previous import
+or corresponding git branches;
+and it therefore does not
+make a pseudomerge to bind the import
+into any existing git history.
+
+There is only only sub-option:
+
+.B --require-valid-signature
+causes dgit to insist that the signature on the .dsc is valid
+(using the same criteria as dpkg-source -x).
+Otherwise, dgit tries to verify the signature but
+the outcome is reported only as messages to stderr.
+
+If
+.I branch
+is prefixed with
+.B +
+then if it already exists, it will be simply ovewritten,
+no matter its existing contents.
+If
+.I branch
+is prefixed with
+.B ..
+then if it already exists
+and dgit actually imports the dsc
+(rather than simply reading the git commit out of the Dgit field),
+dgit will make a pseudomerge
+so that the result is necessarily fast forward
+from the existing branch.
+Otherwise, if branch already exists,
+dgit will stop with an error message.
+
+If
+.I branch
+does not start with refs/, refs/heads/ is prepended.
+The specified branch is unconditionally updated.
+
+If the specified .dsc contains a Dgit field,
+dgit will simply make a branch of that commit.
+If you cannot manage to find that commit anywhere,
+consider --force-import-dsc-with-dgit-field.
+.TP
 .B dgit version
 Prints version information and exits.
 .TP
@@ -376,6 +433,45 @@ git history, so that your push is a fast forward from the archive.
 implying a split between the dgit view and the
 maintainer view, the pseudo-merge will appear only in the dgit view.)
 .TP
+.BR --delayed =\fIdays\fR
+Upload to a DELAYED queue.
+
+.B WARNING:
+If the maintainer responds by cancelling
+your upload from the queue,
+and does not make an upload of their own,
+this will not rewind the git branch on the dgit git server.
+Other dgit users will then see your push
+(with a warning message from dgit)
+even though the maintainer wanted to abolish it.
+Such users might unwittingly reintroduce your changes.
+
+If this situation arises,
+someone should make a suitable dgit push
+to update the contents of dgit-repos
+to a version without the controversial changes.
+.TP
+.BR --dgit-view-save= \fIbranch\fR|\fIref\fR
+Specifies that when a split view quilt mode is in operation,
+and dgit calculates
+(or looks up in its cache)
+a dgit view corresponding to your HEAD,
+the dgit view will be left in
+.IR ref .
+The specified ref is unconditionally overwritten,
+so don't specify a branch you want to keep.
+
+This option is effective only with the following operations:
+quilt-fixup; push; all builds.
+And it is only effective with
+--[quilt=]gbp,
+--[quilt=]dpm,
+--quilt=unpatched.
+
+If ref does not start with refs/
+it is taken to to be a branch -
+i.e. refs/heads/ is prepended.
+.TP
 .BI --deliberately- something
 Declare that you are deliberately doing
 .IR something .
@@ -595,7 +691,11 @@ Specifies a single additional option to pass, eventually, to
 dpkg-genchanges.
 
 Options which are safe to pass include
-.BR "-si -sa -sd -C" .
+.BR -C
+(and also
+.BR "-si -sa -sd"
+although these should never be necessary with Debian since dgit
+automatically calculates whether .origs need to be uploaded.)
 
 For other options the caveat below applies.
 .TP
@@ -734,6 +834,13 @@ These options are provided as an escape hatch,
 in case dgit is confused.
 (They might also be useful for testing error cases.)
 .TP
+.B --import-dsc-with-dgit-field
+Tell dgit import-dsc to treat a .dsc with a Dgit field
+like one without it.
+The result is a fresh import,
+discarding the git history
+that the person who pushed that .dsc was working with.
+.TP
 .B --force-unrepresentable
 Carry on even if
 dgit thinks that your git tree contains changes
@@ -741,6 +848,11 @@ dgit thinks that your git tree contains changes
 which dpkg-source is not able to represent.
 Your build or push will probably fail later.
 .TP
+.B --force-changes-origs-exactly
+Use the set of .origs specified in your .changes, exactly,
+without regard to what is in the archive already.
+The archive may well reject your upload.
+.TP
 .B --force-unsupported-source-format
 Carry on despite dgit not understanding your source package format.
 dgit will probably mishandle it.
diff --git a/tests/lib b/tests/lib
index 5d8e742d..23daeace 100644
--- a/tests/lib
+++ b/tests/lib
@@ -188,6 +188,8 @@ t-git-merge-base () {
 }
 
 t-has-ancestor () {
+	# t-has-ancestor ANCESTOR
+	# (CHILD is implicit, HEAD)
 	local now=`git rev-parse HEAD`
 	local ancestor=`git rev-parse $1^{}`
 	local mbase=`t-git-merge-base $ancestor $now`
@@ -196,6 +198,18 @@ t-has-ancestor () {
 	fi
 }
 
+t-has-parent-or-is () {
+	# t-has-parent-or-is CHILD PARENT
+	local child=$1
+	local parent=$2
+	local parents=$(git show --pretty=format:' %P %H ' "$child")
+	parent=$(git rev-parse "$parent~0")
+	case "$parents" in
+	*" $parent "*)	;;
+	*)	fail "child $child lacks parent $parent" ;;
+	esac
+}
+
 t-prep-newpackage () {
 	t-select-package $1
 	v=$2
@@ -278,7 +292,7 @@ t-archive-updated () {
 
 t-archive-process-incoming () {
 	local suite=$1
-	mv $tmp/incoming/${p}_${v}[._]* $tmp/mirror/pool/main/
+	mv $tmp/incoming/${p}_* $tmp/mirror/pool/main/
 	t-archive-query "$suite"
 }
 
@@ -475,17 +489,19 @@ t-ref-head () {
 t-ref-same-val () {
 	local name="$1"
 	local val=$2
-	case "$t_ref_val" in
-	'')		;;
+	case "${t_ref_val-unset}" in
+	unset)		;;
 	"$val")		;;
-	*)		fail "ref varies: $name:\
- ${val:-nothing} != ${t_ref_val:-nothing}" ;;
+	*)		fail "ref varies: ($name)\
+ ${val:-nothing} != ${t_ref_val:-nothing} (${t_ref_names[*]})" ;;
 	esac
 	t_ref_val="$val"
+	t_ref_names+=("$name")
 }
 
 t-refs-same-start () {
-	t_ref_val=''
+	unset t_ref_val
+	t_ref_names=()
 }
 
 t-refs-same () {
@@ -573,6 +589,7 @@ t-splitbrain-pushed-good--unpack () {
 	mkdir t-unpack
 	cd t-unpack
 	ln -s $tmp/mirror/pool/main/*.orig*.tar* .
+	ln -s $tmp/incoming/*.orig*.tar* . ||:
 	ln -s $incoming_dsc .
 	ln -s ${incoming_dsc/.dsc/.debian.tar}* .
 	dpkg-source "$@" -x *.dsc
@@ -602,6 +619,13 @@ t-splitbrain-pushed-good-start () {
 	git merge-base --is-ancestor $dep14tag $dgittag
 
 	t-refs-same-start
+	t-ref-same refs/heads/split.p
+	case "$(t-git-get-ref refs/heads/split.b)" in
+	"$t_ref_val") ;;
+	"$(git rev-parse refs/heads/split.p^0)") ;;
+	"$(git rev-parse refs/heads/split.p^1)") ;;
+	*) fail 'bad b/p' ;;
+	esac
 	t-pushed-good-core
 
 	t-incoming-dsc
diff --git a/tests/lib-core b/tests/lib-core
index 056a1bc1..7ed27619 100644
--- a/tests/lib-core
+++ b/tests/lib-core
@@ -20,6 +20,8 @@ t-set-using-tmp () {
 	export DGIT_TEST_DUMMY_DIR=$tmp
 	export DGIT_TEST_TMP=$tmp
 	export GNUPGHOME=$tmp/nonexistent
+	git config --global user.email 'dgit-test@debian.example.net'
+	git config --global user.name 'dgit test git user'
 }
 
 t-filter-out-git-hyphen-dir () {
diff --git a/tests/lib-orig-include-exclude b/tests/lib-orig-include-exclude
new file mode 100644
index 00000000..75a96563
--- /dev/null
+++ b/tests/lib-orig-include-exclude
@@ -0,0 +1,62 @@
+# designed to be .'d
+
+t-tstunt-parsechangelog
+
+t-archive example 1.0-1
+t-git-none
+
+t-dgit clone $p
+
+origs='orig orig-docs'
+usvsns='1.0 1.1'
+
+for o in $origs; do
+	cp ${p}_{1.0,1.1}.${o}.tar.gz
+done
+
+mkdir -p "$tmp/aq/file_in_archive/%"
+
+cd $p
+
+test-push-1 () {
+	v=$1
+	ch=$2
+	suite=$3
+
+	t-commit $v $v $suite
+	t-dgit $ch build
+}
+
+test-push-2 () {
+	$test_push_2_hook
+	t-dgit $ch "$@" push
+}
+
+test-push-1 1.0-2 --ch:-sa
+
+grep orig ../${p}_${v}_*.changes
+
+test-push-2
+
+# check that dgit stripped out the orig update
+find $tmp/mirror -name '*orig*' -ls >../before
+
+t-archive-process-incoming sid
+
+find $tmp/mirror -name '*orig*' -ls >../after
+diff -u ../before ../after
+
+test-push-1 1.1-1.2 --ch:-sd
+
+test-push-2
+
+t-archive-process-incoming sid
+
+cd ..
+mkdir get
+cd get
+
+t-dgit clone $p
+# ^ checks that all the origs are there, ie that dgit added the origs
+
+cd ..
diff --git a/tests/setup/examplegit b/tests/setup/examplegit
index 924113fc..98900d09 100755
--- a/tests/setup/examplegit
+++ b/tests/setup/examplegit
@@ -2,7 +2,7 @@
 set -e
 . tests/lib
 
-suitespecs+=' stable'
+suitespecs+=' stable testing'
 
 t-tstunt-parsechangelog
 
diff --git a/tests/tests/gbp-orig b/tests/tests/gbp-orig
new file mode 100755
index 00000000..ffc145f3
--- /dev/null
+++ b/tests/tests/gbp-orig
@@ -0,0 +1,75 @@
+#!/bin/bash
+set -e
+. tests/lib
+
+t-tstunt-parsechangelog
+
+t-archive-none example
+t-git-none
+t-worktree 1.0
+
+cd $p
+
+: '----- construct an unpatched branch with patches -----'
+
+git checkout patch-queue/quilt-tip
+gbp pq export
+: 'now on quilt-tip'
+git add debian/patches
+git commit -m 'Commit patch queue'
+
+: '----- construct an upstream branch -----'
+
+git checkout --orphan upstream
+git reset --hard
+git clean -xdf
+
+tar --strip-components=1 -xf $troot/pkg-srcs/${p}_1.0.orig.tar.gz
+
+mkdir docs
+cd docs
+tar --strip-components=1 -xf $troot/pkg-srcs/${p}_1.0.orig-docs.tar.gz
+cd ..
+
+git add -Af .
+git commit -m 'Import 1.0'
+git tag upstream/1.0
+
+git checkout quilt-tip
+t-git-pseudo-merge upstream
+
+v=1.0-1
+
+: '----- let gbp build a .orig for comparison -----'
+
+gbp buildpackage --git-ignore-branch --git-no-sign-tags -us -uc
+
+mkdir ../gbp-output
+mv ../*1.0* ../gbp-output/.
+rm -f ../*.changes
+
+: '----- now do it ourselves -----'
+
+t-dgit -wgf --dgit-view-save=split.b gbp-build --git-ignore-branch
+
+t-dgit -wgf --quilt=gbp clean # gbp leaves dirty trees :-/
+
+t-dgit -wgf --dgit-view-save=split.p --quilt=gbp push --new
+
+t-gbp-pushed-good
+
+: '----- check .origs are the same -----'
+
+# if gbp weren't weird about .gitignore we could just debdiff the .dscs
+
+for d in . gbp-output; do
+	cd $tmp/$d
+	mkdir tar-x
+	cd tar-x
+	tar zxf ../${p}_${v%-*}.orig.tar.gz
+done
+
+cd $tmp
+diff -ruN gbp-output/tar-x tar-x
+
+echo done.
diff --git a/tests/tests/import-dsc b/tests/tests/import-dsc
new file mode 100755
index 00000000..9d3d9b79
--- /dev/null
+++ b/tests/tests/import-dsc
@@ -0,0 +1,99 @@
+#!/bin/bash
+set -e
+. tests/lib
+
+t-setup-import examplegit
+
+p=example
+
+check-import () {
+	path=$1
+	v=$2
+	opts=$3
+	branch=t.$v
+
+	dsc=${path}/${p}_${v}.dsc
+	t-dgit $opts import-dsc $dsc $branch
+
+	git checkout $branch
+
+	check-imported $dsc
+}
+
+check-imported () {
+	local dsc=$1
+	(
+	rm -rf ../t.unpack
+	mkdir ../t.unpack
+	cd ../t.unpack
+	dpkg-source -x $dsc
+	)
+
+	git checkout HEAD~0
+	git branch -D u.$v ||:
+	git checkout -b u.$v $branch
+	git rm -rf .
+	git clean -xdf
+	cp -al ../t.unpack/*/. .
+	git add -Af .
+
+	git diff --stat --exit-code
+}
+
+cd $p
+
+check-import ../mirror/pool/main 1.2
+
+dgit12=`git rev-parse HEAD`
+
+dsc2=../mirror/pool/main/${p}_2.0.dsc
+
+git checkout $branch
+t-expect-fail 'is checked out - will not update' \
+t-dgit import-dsc $dsc2 $branch
+
+git checkout HEAD~0
+
+t-expect-fail 'Not fast forward' \
+t-dgit import-dsc $dsc2 $branch
+
+t-expect-fail 'Not fast forward' \
+t-dgit import-dsc $dsc2 ..$branch
+
+t-dgit import-dsc $dsc2 +$branch
+check-imported $dsc2
+
+cd ..
+mkdir $p.2
+cd $p.2
+
+git init
+
+check-import ../../../pkg-srcs 1.0-1
+
+t-expect-fail "Your git tree does not have that object" \
+check-import ../mirror/pool/main 1.2
+
+check-import ../mirror/pool/main 1.2 --force-import-dsc-with-dgit-field
+
+v=1.0-1.100
+dsc2=../../../pkg-srcs/${p}_${v}.dsc
+
+t-expect-fail E:'Branch.*already exists' \
+t-dgit import-dsc $dsc2 $branch
+
+git branch merge-reset
+t-dgit import-dsc $dsc2 ..$branch
+t-has-ancestor merge-reset $branch
+
+git push . +merge-reset:$branch
+
+t-dgit import-dsc $dsc2 +$branch
+
+mb=$(t-git-merge-base merge-reset $branch)
+test "x$mb" = x
+
+t-expect-fail 'signature check failed' \
+t-dgit import-dsc --require-valid-signature $dsc2 +$branch
+
+echo ok.
diff --git a/tests/tests/inarchivecopy b/tests/tests/inarchivecopy
index e87baaf3..632d4206 100755
--- a/tests/tests/inarchivecopy
+++ b/tests/tests/inarchivecopy
@@ -14,34 +14,34 @@ t-inarchive-copy () {
 	local from=${2:-sid}
 	local to=${3:-stable}
 	egrep "^${vm//./\\.}" aq/package.$from.$p >>aq/package.$to.$p
-	t-archive-updated stable $p
+	t-archive-updated $to $p
 }
 
 copy-check-good () {
 	git diff $vtag
-	t-refs-same refs/remotes/dgit/dgit/stable
+	t-refs-same refs/remotes/dgit/dgit/$tosuite
 	t-ref-head
+	t-has-parent-or-is HEAD $vtag
 }
 
 copy-check () {
 	local vm=$1
-	t-inarchive-copy $vm
+	local tosuite=${2:-stable}
+	t-inarchive-copy $vm '' $tosuite
 
 	vtag=$(v=$vm t-v-tag)
 
 	cd $p
 	 t-refs-same-start
-	 t-ref-same $vtag^1
-
-	 t-dgit fetch stable
-	 git merge --ff-only dgit/dgit/stable
+	 t-dgit fetch $tosuite
+	 git merge --ff-only dgit/dgit/$tosuite
 
 	 copy-check-good
 	 local fetched=$(t-sametree-parent HEAD)
 	cd ..
 
 	rm -rf example.cloned
-	t-dgit clone $p stable example.cloned
+	t-dgit clone $p $tosuite example.cloned
 
 	cd example.cloned
 	 t-refs-same-start
@@ -49,13 +49,31 @@ copy-check () {
 	 local cloned=$(t-sametree-parent HEAD)	 
 	cd ..
 
+	rm -rf example.initd
+	mkdir example.initd
+	cd example.initd
+	 git init
+	 t-refs-same-start
+	 t-dgit -p $p fetch $tosuite
+	 git reset --hard refs/remotes/dgit/dgit/$tosuite
+	 copy-check-good
+	 local initd=$(t-sametree-parent HEAD)
+	cd ..
+
 	t-refs-same-start
 	t-ref-same-val fetched $fetched
 	t-ref-same-val cloned $cloned
+	t-ref-same-val initd $initd
 }
 
 copy-check 2.0
 
 copy-check 2.1
 
+cd $p
+git checkout -b dgit/testing $(v=1.1 t-v-tag)
+cd ..
+
+copy-check 2.1 testing
+
 echo ok.
diff --git a/tests/tests/orig-include-exclude b/tests/tests/orig-include-exclude
new file mode 100755
index 00000000..96bf4f21
--- /dev/null
+++ b/tests/tests/orig-include-exclude
@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+. tests/lib
+
+suitespecs+=' stable'
+
+. $troot/lib-orig-include-exclude
+
+ofb=example_1.1.orig.tar
+zcat $ofb.gz >$ofb.SPONG
+gzip -1Nv $ofb.SPONG
+mv $ofb.SPONG.gz $ofb.gz
+
+#suite=stable
+#t-archive-none $p
+#t-archive-updated stable $p
+
+cd $p
+
+test-push-1 1.1-1.3 '' stable
+
+t-expect-fail E:'archive contains .* with different checksum' \
+test-push-2 --new
+
+echo done.
diff --git a/tests/tests/orig-include-exclude-chkquery b/tests/tests/orig-include-exclude-chkquery
new file mode 100755
index 00000000..59fc80f0
--- /dev/null
+++ b/tests/tests/orig-include-exclude-chkquery
@@ -0,0 +1,33 @@
+#!/bin/bash
+set -e
+. tests/lib
+
+t-git-config dgit-distro.test-dummy.archive-query ftpmasterapi:
+# ^ that will crash if it gets unexpected file_in_archive queries
+
+# orig-include-exclude will set origs and usvsns
+update-files_in_archive () {
+	for o in $origs; do for usvsn in $usvsns; do \
+		of=${p}_${v%-*}.${o}.tar.gz
+		pat="%/${of//_/\\_}"
+		# curl url-decodes these things so we have to have literals
+		find $tmp/mirror -name $of | \
+			xargs -r sha256sum | \
+			perl -pe '
+				BEGIN { print "["; }
+				chomp;
+				s/^/{"sha256sum":"/;
+				s/  /","filename":"/;
+				s/$/"}$delim/;
+				$delim=",";
+				END { print "]\n"; }
+			' \
+			>$tmp/aq/"file_in_archive/$pat"
+	done; done
+}
+
+test_push_2_hook=update-files_in_archive
+
+. $troot/lib-orig-include-exclude
+
+echo done.
diff --git a/tests/tests/overwrite-splitbrains b/tests/tests/overwrite-splitbrains
index c0c7470d..725357d0 100755
--- a/tests/tests/overwrite-splitbrains
+++ b/tests/tests/overwrite-splitbrains
@@ -7,7 +7,7 @@ t-tstunt-parsechangelog
 t-gbp-example-prep-no-ff
 t-newtag
 
-t-dgit --quilt=gbp build-source
+t-dgit --quilt=gbp --dgit-view-save=split.b build-source
 
 t-dgit fetch
 
@@ -15,12 +15,12 @@ t-refs-same-start
 t-ref-head
 
 t-expect-fail 'check failed (maybe --overwrite is needed' \
-t-dgit --quilt=gbp push
+t-dgit --quilt=gbp --dgit-view-save=split.p push
 
 t-refs-same-start
 t-ref-head
 
-t-dgit --quilt=gbp --overwrite push
+t-dgit --quilt=gbp --dgit-view-save=split.p --overwrite push
 
 t-gbp-pushed-good
 
diff --git a/tests/tests/quilt-gbp b/tests/tests/quilt-gbp
index 21e396bc..38d2489b 100755
--- a/tests/tests/quilt-gbp
+++ b/tests/tests/quilt-gbp
@@ -14,7 +14,8 @@ t-expect-fail 'requires split view so server needs to support' \
 t-dgit -wgf --quilt=gbp build-source
 t-newtag
 
-t-dgit --quilt=gbp build-source
+t-dgit --quilt=gbp --dgit-view-save=split.b1 build-source
+git rev-parse split.b1
 
 t-dgit --quilt=gbp --gbp-pq=no-such-command-gbp build-source
 
@@ -31,14 +32,14 @@ test-push-1 () {
 }
 
 test-push-2 () {
-	t-dgit --quilt=gbp push
+	t-dgit --quilt=gbp --dgit-view-save=split.p push
 
 	t-gbp-pushed-good
 }
 
 test-push-1
 
-t-dgit --quilt=gbp --clean=git build-source
+t-dgit --quilt=gbp --clean=git --dgit-view-save=split.b build-source
 
 t-expect-fail "HEAD specifies a different tree to $p" \
   t-dgit push
@@ -53,7 +54,7 @@ t-commit 'Check pseudomerge' 1.0-3
 
 test-push-1
 
-t-dgit --quilt=gbp --clean=git build-source
+t-dgit --quilt=gbp --clean=git --dgit-view-save=split.b build-source
 
 test-push-2
 
diff --git a/tests/tests/quilt-splitbrains b/tests/tests/quilt-splitbrains
index 1e853f31..112bc39e 100755
--- a/tests/tests/quilt-splitbrains
+++ b/tests/tests/quilt-splitbrains
@@ -2,6 +2,8 @@
 set -e
 . tests/lib
 
+suitespecs+=' stable'
+
 # This test script tests each of the split brain quilt modes, and
 # --quilt=linear, with a tree suitable for each of those, and pushes
 # them in sequence.  The idea is to check that each tree is rejected
@@ -24,9 +26,9 @@ want-success () {
 	t-refs-same-start
 	t-ref-head
 
-	t-dgit "$@" --quilt=$qmode build-source
+	t-dgit "$@" --quilt=$qmode --dgit-view-save=split.b build-source
 
-	t-dgit "$@" --quilt=$qmode push
+	t-dgit "$@" --quilt=$qmode --dgit-view-save=split.p push
 	t-$qmode-pushed-good
 }
 
@@ -130,5 +132,9 @@ t-dgit -wgf build-source
 
 want-success dpm
 
+suite=stable
+t-commit dpmish-stable 1.0-6 $suite
+
+want-success dpm --new
 
 echo ok.