my $got = read PF, $d, 65536;
die "$ourfn: $!" unless defined $got;
last if !$got;
- print $fh "data-block ".length($d)."\n" or die $!;
- print $fh $d or die $!;
+ print $fh "data-block ".length($d)."\n" or confess $!;
+ print $fh $d or confess $!;
}
PF->error and die "$ourfn $!";
- print $fh "data-end\n" or die $!;
+ print $fh "data-end\n" or confess $!;
close PF;
}
} $fh;
last unless $y;
my $d = protocol_read_bytes $fh, $l;
- print PF $d or die $!;
+ print PF $d or confess $!;
}
- close PF or die $!;
+ close PF or confess $!;
}
#---------- remote protocol support, responder ----------
return unless $we_are_responder;
# called even without $we_are_responder
printdebug ">> $command\n";
- print PO $command, "\n" or die $!;
+ print PO $command, "\n" or confess $!;
}
sub responder_send_file ($$) {
sub progress {
if ($we_are_responder) {
my $m = join '', @_;
- responder_send_command "progress ".length($m) or die $!;
- print PO $m or die $!;
+ responder_send_command "progress ".length($m) or confess $!;
+ print PO $m or confess $!;
} else {
print @_, "\n";
}
}
my $what = $_[$#_];
progress "downloading $what...";
- my $r = $ua->get(@_) or die $!;
+ my $r = $ua->get(@_) or confess $!;
return undef if $r->code == 404;
$r->is_success or fail f_ "failed to fetch %s: %s",
$what, $r->status_line;
END
sub badusage {
- print STDERR f_ "%s: %s\n%s", $us, "@_", __ $helpmsg or die $!;
+ print STDERR f_ "%s: %s\n%s", $us, "@_", __ $helpmsg or confess $!;
finish 8;
}
not_necessarily_a_tree();
}
sub cmd_help () {
- print __ $helpmsg or die $!;
+ print __ $helpmsg or confess $!;
finish 0;
}
return;
} elsif ($protovsn >= 3) {
responder_send_command "supplementary-message ".length($msg)
- or die $!;
- print PO $msg or die $!;
+ or confess $!;
+ print PO $msg or confess $!;
}
}
}
sub parse_dscdata () {
- my $dscfh = new IO::File \$dscdata, '<' or die $!;
+ my $dscfh = new IO::File \$dscdata, '<' or confess $!;
printdebug Dumper($dscdata) if $debuglevel>1;
$dsc = parsecontrolfh($dscfh,$dscurl,1);
printdebug Dumper($dsc) if $debuglevel>1;
access_cfg('mirror'),
$aptsuites,
access_cfg('aptget-components')
- or die $!;
+ or confess $!;
ensuredir "$aptget_base/cache";
ensuredir "$aptget_base/lists";
- open CONF, ">", $aptget_configpath or die $!;
+ open CONF, ">", $aptget_configpath or confess $!;
print CONF <<END;
Debug::NoLocking "true";
APT::Get::List-Cleanup "false";
Dir::Etc::preferencesparts
)) {
ensuredir "$aptget_base/$key";
- print CONF "$key \"$quoted_base/$key\";\n" or die $!;
+ print CONF "$key \"$quoted_base/$key\";\n" or confess $!;
};
- my $oldatime = (time // die $!) - 1;
+ my $oldatime = (time // confess $!) - 1;
foreach my $oldlist (<$aptget_base/lists/*Release>) {
next unless stat_exists $oldlist;
my ($mtime) = (stat _)[9];
my @cmd = (qw(sh -ec), 'cd "$1"; shift'."\n".$rune,
qw(x), $mirror, @$argl);
debugcmd "-|", @cmd;
- open FIA, "-|", @cmd or die $!;
+ open FIA, "-|", @cmd or confess $!;
my $r = $fn->();
close FIA or ($!==0 && $?==141) or die failedcmd @cmd;
return $r;
" export LC_MESSAGES=C; export LC_CTYPE=C;".
" ".shellquote qw(psql -A), $dbname, qw(-c), $sql);
debugcmd "|",@cmd;
- open P, "-|", @cmd or die $!;
+ open P, "-|", @cmd or confess $!;
while (<P>) {
chomp or die;
printdebug(">|$_|\n");
my ($what) = @_;
my @gitscmd = qw(find -name .git -prune -print0);
debugcmd "|",@gitscmd;
- open GITS, "-|", @gitscmd or die $!;
+ open GITS, "-|", @gitscmd or confess $!;
{
local $/="\0";
while (<GITS>) {
new Dpkg::Compression::Process compression => $cname;
@compr_cmd = $compr_proc->get_uncompress_cmdline();
my $compr_fh = new IO::Handle;
- my $compr_pid = open $compr_fh, "-|" // die $!;
+ my $compr_pid = open $compr_fh, "-|" // confess $!;
if (!$compr_pid) {
- open STDIN, "<&", $input or die $!;
+ open STDIN, "<&", $input or confess $!;
exec @compr_cmd;
die "dgit (child): exec $compr_cmd[0]: $!\n";
}
}
rmtree "_unpack-tar";
- mkdir "_unpack-tar" or die $!;
+ mkdir "_unpack-tar" or confess $!;
my @tarcmd = qw(tar -x -f -
--no-same-owner --no-same-permissions
--no-acls --no-xattrs --no-selinux);
- my $tar_pid = fork // die $!;
+ my $tar_pid = fork // confess $!;
if (!$tar_pid) {
- chdir "_unpack-tar" or die $!;
- open STDIN, "<&", $input or die $!;
+ chdir "_unpack-tar" or confess $!;
+ open STDIN, "<&", $input or confess $!;
exec @tarcmd;
die f_ "dgit (child): exec %s: %s", $tarcmd[0], $!;
}
- $!=0; (waitpid $tar_pid, 0) == $tar_pid or die $!;
+ $!=0; (waitpid $tar_pid, 0) == $tar_pid or confess $!;
!$? or failedcmd @tarcmd;
close $input or
(@compr_cmd ? ($?==SIGPIPE || failedcmd @compr_cmd)
- : die $!);
+ : confess $!);
# finally, we have the results in "tarball", but maybe
# with the wrong permissions
printdebug "import main commit\n";
- open C, ">../commit.tmp" or die $!;
- print C <<END or die $!;
+ open C, ">../commit.tmp" or confess $!;
+ print C <<END or confess $!;
tree $tree
END
- print C <<END or die $! foreach @tartrees;
+ print C <<END or confess $! foreach @tartrees;
parent $_->{Commit}
END
- print C <<END or die $!;
+ print C <<END or confess $!;
author $authline
committer $authline
[dgit import $treeimporthow $package $cversion]
END
- close C or die $!;
+ close C or confess $!;
my $rawimport_hash = make_commit qw(../commit.tmp);
if (madformat $dsc->{format}) {
progress f_ "%s: trying slow absurd-git-apply...", $us;
rename "../../gbp-pq-output","../../gbp-pq-output.0"
or $!==ENOENT
- or die $!;
+ or confess $!;
}
eval {
die "forbid absurd git-apply\n" if $use_absurd
Last version pushed with dgit: %s (newer or same)
%s
END
- __ $later_warning_msg or die $!;
+ __ $later_warning_msg or confess $!;
@output = $lastpush_mergeinput;
} else {
# Same version. Use what's in the server git branch,
open F, "<", "$tf" or die "$tf: $!";
$fi->{Digester}->reset();
$fi->{Digester}->addfile(*F);
- F->error and die $!;
+ F->error and confess $!;
$got = $fi->{Digester}->hexdigest();
return $got eq $fi->{Hash};
};
debugcmd "|",@lcmd;
my %wantr;
- open GITLS, "-|", @lcmd or die $!;
+ open GITLS, "-|", @lcmd or confess $!;
while (<GITLS>) {
printdebug "=> ", $_;
m/^(\w+)\s+(\S+)\n/ or die "ls-remote $_ ?";
printdebug "del_lrfetchrefs: $objid $fullrefname\n";
if (!$gur) {
$gur ||= new IO::Handle;
- open $gur, "|-", qw(git update-ref --stdin) or die $!;
+ open $gur, "|-", qw(git update-ref --stdin) or confess $!;
}
printf $gur "delete %s %s\n", $fullrefname, $objid;
}
Last version pushed with dgit: %s
%s
END
- __ $later_warning_msg or die $!;
+ __ $later_warning_msg or confess $!;
@mergeinputs = ($lastpush_mergeinput);
} else {
# Archive has .dsc which is not a descendant of the last dgit
Package not found in the archive, but has allegedly been pushed using dgit.
%s
END
- __ $later_warning_msg or die $!;
+ __ $later_warning_msg or confess $!;
} else {
printdebug "nothing found!\n";
if (defined $skew_warning_vsn) {
- print STDERR f_ <<END, $skew_warning_vsn or die $!;
+ print STDERR f_ <<END, $skew_warning_vsn or confess $!;
Warning: relevant archive skew detected.
Archive allegedly contains %s
my $mcf = dgit_privdir()."/mergecommit";
open MC, ">", $mcf or die "$mcf $!";
- print MC <<END or die $!;
+ print MC <<END or confess $!;
tree $tree
END
my @parents = grep { $_->{Commit} } @mergeinputs;
@parents = reverse @parents if $compat_info->{ReverseParents};
- print MC <<END or die $! foreach @parents;
+ print MC <<END or confess $! foreach @parents;
parent $_->{Commit}
END
- print MC <<END or die $!;
+ print MC <<END or confess $!;
author $author
committer $author
END
if (defined $compat_info->{Message}) {
- print MC $compat_info->{Message} or die $!;
+ print MC $compat_info->{Message} or confess $!;
} else {
- print MC f_ <<END, $package, $cversion, $csuite or die $!;
+ print MC f_ <<END, $package, $cversion, $csuite or confess $!;
Record %s (%s) in archive suite %s
Record that
my ($mi) = (@_);
my $mversion = mergeinfo_version $mi;
printf MC " %-20s %s\n", $mversion, $mi->{Info}
- or die $!;
+ or confess $!;
};
$message_add_info->($mergeinputs[0]);
- print MC __ <<END or die $!;
+ print MC __ <<END or confess $!;
should be treated as descended from
END
$message_add_info->($_) foreach @mergeinputs[1..$#mergeinputs];
}
- close MC or die $!;
+ close MC or confess $!;
$hash = make_commit $mcf;
} else {
$hash = $mergeinputs[0]{Commit};
my $got_vsn = getfield $gotclogp, 'Version';
printdebug "SKEW CHECK GOT $got_vsn\n";
if (version_compare($got_vsn, $skew_warning_vsn) < 0) {
- print STDERR f_ <<END, $skew_warning_vsn, $got_vsn or die $!;
+ print STDERR f_ <<END, $skew_warning_vsn, $got_vsn or confess $!;
Warning: archive skew detected. Using the available version:
Archive allegedly contains %s
while (<ATTRS>) {
chomp;
next if m{^debian/changelog\s};
- print NATTRS $_, "\n" or die $!;
+ print NATTRS $_, "\n" or confess $!;
}
- ATTRS->error and die $!;
+ ATTRS->error and confess $!;
close ATTRS;
}
- print NATTRS "debian/changelog merge=$driver\n" or die $!;
+ print NATTRS "debian/changelog merge=$driver\n" or confess $!;
close NATTRS;
set_local_git_config "$cb.name", __ 'debian/changelog merge driver';
printdebug "is_gitattrs_setup: found old macro\n";
return 0;
}
- $gai->error and die $!;
+ $gai->error and confess $!;
printdebug "is_gitattrs_setup: found nothing\n";
return undef;
}
my $af = "$maindir_gitcommon/info/attributes";
ensuredir "$maindir_gitcommon/info";
- open GAO, "> $af.new" or die $!;
- print GAO <<END, __ <<ENDT or die $! unless defined $already;
+ open GAO, "> $af.new" or confess $!;
+ print GAO <<END, __ <<ENDT or confess $! unless defined $already;
* dgit-defuse-attrs
$new
END
$_ = $new;
}
chomp;
- print GAO $_, "\n" or die $!;
+ print GAO $_, "\n" or confess $!;
}
- $gai->error and die $!;
+ $gai->error and confess $!;
}
- close GAO or die $!;
+ close GAO or confess $!;
rename "$af.new", "$af" or fail f_ "install %s: %s", $af, $!;
}
my @cmd = (@git, qw(ls-tree -lrz --), "${treeish}:");
debugcmd "|",@cmd;
my $gafl = new IO::File;
- open $gafl, "-|", @cmd or die $!;
+ open $gafl, "-|", @cmd or confess $!;
while (<$gafl>) {
chomp or die;
s/^\d+\s+\w+\s+\w+\s+(\d+)\t// or die;
# in child, sets things up, calls $fn->(), and returns undef
# in parent, returns canonical suite name for $tsuite
my $canonsuitefh = IO::File::new_tmpfile;
- my $pid = fork // die $!;
+ my $pid = fork // confess $!;
if (!$pid) {
forkcheck_setup();
$isuite = $tsuite;
$debugprefix .= " ";
progress f_ "fetching %s...", $tsuite;
canonicalise_suite();
- print $canonsuitefh $csuite, "\n" or die $!;
- close $canonsuitefh or die $!;
+ print $canonsuitefh $csuite, "\n" or confess $!;
+ close $canonsuitefh or confess $!;
$fn->();
return undef;
}
- waitpid $pid,0 == $pid or die $!;
+ waitpid $pid,0 == $pid or confess $!;
fail f_ "failed to obtain %s: %s", $tsuite, waitstatusmsg()
if $? && $?!=256*4;
- seek $canonsuitefh,0,0 or die $!;
+ seek $canonsuitefh,0,0 or confess $!;
local $csuite = <$canonsuitefh>;
- die $! unless defined $csuite && chomp $csuite;
+ confess $! unless defined $csuite && chomp $csuite;
if ($? == 256*4) {
printdebug "multisuite $tsuite missing\n";
return $csuite;
}
sub clone_set_head () {
- open H, "> .git/HEAD" or die $!;
- print H "ref: ".lref()."\n" or die $!;
- close H or die $!;
+ open H, "> .git/HEAD" or confess $!;
+ print H "ref: ".lref()."\n" or confess $!;
+ close H or confess $!;
}
sub clone_finish ($) {
my ($dstdir) = @_;
$options{$_} = 1;
}
}
- F->error and die $!;
+ F->error and confess $!;
close F;
} else {
- die $! unless $!==&ENOENT;
+ confess $! unless $!==&ENOENT;
}
if (!open F, "debian/source/format") {
- die $! unless $!==&ENOENT;
+ confess $! unless $!==&ENOENT;
return '';
}
$_ = <F>;
- F->error and die $!;
+ F->error and confess $!;
chomp;
return ($_, \%options);
}
# git rev-list --first-parent DTRT.
my $pmf = dgit_privdir()."/pseudomerge";
open MC, ">", $pmf or die "$pmf $!";
- print MC <<END or die $!;
+ print MC <<END or confess $!;
tree $tree
parent $dgitview
parent $archive_hash
[$msg_cmd]
END
- close MC or die $!;
+ close MC or confess $!;
return make_commit($pmf);
}
$dsc->{$ourdscfield[0]} = join " ",
$tagwants->[0]{Objid}, $declaredistro, $tagwants->[0]{Tag},
$reader_giturl;
- $dsc->save("$dscfn.tmp") or die $!;
+ $dsc->save("$dscfn.tmp") or confess $!;
my $changes = parsecontrol($changesfile,$changesfilewhat);
foreach my $field (qw(Source Distribution Version)) {
my $head = $tw->{Objid};
my $tag = $tw->{Tag};
- open TO, '>', $tfn->('.tmp') or die $!;
- print TO <<END or die $!;
+ open TO, '>', $tfn->('.tmp') or confess $!;
+ print TO <<END or confess $!;
object $head
type commit
tag $tag
print TO f_ <<ENDT, $package, $cversion, $clogsuite, $csuite
%s release %s for %s (%s) [dgit]
ENDT
- or die $!;
- print TO <<END or die $!;
+ or confess $!;
+ print TO <<END or confess $!;
[dgit distro=$declaredistro$delibs]
END
foreach my $ref (sort keys %previously) {
- print TO <<END or die $!;
+ print TO <<END or confess $!;
[dgit previously:$ref=$previously{$ref}]
END
}
(maintainer view tag generated by dgit --quilt=%s)
END
$quilt_mode
- or die $!;
+ or confess $!;
} else {
confess Dumper($tw)."?";
}
- close TO or die $!;
+ close TO or confess $!;
my $tagobjfn = $tfn->('.tmp');
if ($sign) {
if (!defined $keyid) {
$keyid = getfield $clogp, 'Maintainer';
}
- unlink $tfn->('.tmp.asc') or $!==&ENOENT or die $!;
+ unlink $tfn->('.tmp.asc') or $!==&ENOENT or confess $!;
my @sign_cmd = (@gpg, qw(--detach-sign --armor));
push @sign_cmd, qw(-u),$keyid if defined $keyid;
push @sign_cmd, $tfn->('.tmp');
$we_are_responder = 1;
$us .= " (build host)";
- open PI, "<&STDIN" or die $!;
- open STDIN, "/dev/null" or die $!;
- open PO, ">&STDOUT" or die $!;
+ open PI, "<&STDIN" or confess $!;
+ open STDIN, "/dev/null" or confess $!;
+ open PO, ">&STDOUT" or confess $!;
autoflush PO 1;
- open STDOUT, ">&STDERR" or die $!;
+ open STDOUT, ">&STDERR" or confess $!;
autoflush STDOUT 1;
$vsnwant //= 1;
$i_child_pid = undef; # prevents killing some other process with same pid
printdebug "waiting for build host child $pid...\n";
my $got = waitpid $pid, 0;
- die $! unless $got == $pid;
+ confess $! unless $got == $pid;
fail f_ "build host child failed: %s", waitstatusmsg() if $?;
i_cleanup();
pushing();
rpush_handle_protovsn_bothends();
- fail "rpush negotiated protocol version $protovsn".
- " which does not support quilt mode $quilt_mode"
+ fail f_ "rpush negotiated protocol version %s".
+ " which does not support quilt mode %s",
+ $protovsn, $quilt_mode
if quiltmode_splitbrain;
my @localpaths = i_method "i_want", $keyword;
foreach my $localpath (@localpaths) {
protocol_send_file \*RI, $localpath;
}
- print RI "files-end\n" or die $!;
+ print RI "files-end\n" or confess $!;
}
our ($i_clogp, $i_version, $i_dscfn, $i_changesfn, @i_buildinfos);
if (!forceing [qw(buildinfo-changes-mismatch)]) {
files_compare_inputs($bd, $ch);
(getfield $bd, $_) eq (getfield $ch, $_) or
- fail "buildinfo mismatch in field $_"
+ fail f_ "buildinfo mismatch in field %s", $_
foreach qw(Source Version);
!defined $bd->{$_} or
- fail "buildinfo contains forbidden field $_"
+ fail f_ "buildinfo contains forbidden field %s", $_
foreach qw(Changes Changed-by Distribution);
}
push @i_buildinfos, $bi;
return
push_mktags $i_clogp, $i_dscfn,
- $i_changesfn, 'remote changes file',
+ $i_changesfn, (__ 'remote changes file'),
\@tagwants;
}
mkpath '.git/dgit'; # we are in playtree
my $descfn = ".git/dgit/quilt-description.tmp";
- open O, '>', $descfn or die "$descfn: $!";
+ open O, '>', $descfn or confess "$descfn: $!";
$msg =~ s/\n+/\n\n/;
- print O <<END or die $!;
+ print O <<END or confess $!;
From: $author
${xinfo}Subject: $msg
---
END
- close O or die $!;
+ close O or confess $!;
{
local $ENV{'EDITOR'} = cmdoutput qw(realpath --), $0;
if ($unrepres) {
eval {
- die "not a plain file or symlink\n"
+ die __ "not a plain file or symlink\n"
unless $newmode =~ m/^(?:10|12)\d{4}$/ ||
$oldmode =~ m/^(?:10|12)\d{4}$/;
if ($oldmode =~ m/[^0]/ &&
$newmode =~ m/[^0]/) {
# both old and new files exist
- die "mode or type changed\n" if $oldmode ne $newmode;
- die "modified symlink\n" unless $newmode =~ m/^10/;
+ die __ "mode or type changed\n" if $oldmode ne $newmode;
+ die __ "modified symlink\n" unless $newmode =~ m/^10/;
} elsif ($oldmode =~ m/[^0]/) {
# deletion
- die "deletion of symlink\n"
+ die __ "deletion of symlink\n"
unless $oldmode =~ m/^10/;
} else {
# creation
- die "creation with non-default mode\n"
+ die __ "creation with non-default mode\n"
unless $newmode =~ m/^100644$/ or
$newmode =~ m/^120000$/;
}
sub quiltify_splitbrain_needed () {
if (!$split_brain) {
- progress "dgit view: changes are required...";
+ progress __ "dgit view: changes are required...";
runcmd @git, qw(checkout -q -b dgit-view);
$split_brain = 1;
}
my ($x,$y) = @_;
my $cmd = "git diff $x $y -- :/ ':!debian'";
$cmd .= " ':!/.gitignore' ':!*/.gitignore'" if $gitignore_special;
- return "\nFor full diff showing the problem(s), type:\n $cmd\n";
+ return f_ "\nFor full diff showing the problem(s), type:\n %s\n",
+ $cmd;
};
if ($quilt_mode =~ m/gbp|unapplied/ &&
($diffbits->{O2H} & 01)) {
- my $msg =
- "--quilt=$quilt_mode specified, implying patches-unapplied git tree\n".
- " but git tree differs from orig in upstream files.";
+ my $msg = f_
+ "--quilt=%s specified, implying patches-unapplied git tree\n".
+ " but git tree differs from orig in upstream files.",
+ $quilt_mode;
$msg .= $fulldiffhint->($unapplied, 'HEAD');
if (!stat_exists "debian/patches") {
- $msg .=
+ $msg .= __
"\n ... debian/patches is missing; perhaps this is a patch queue branch?";
}
fail $msg;
}
if ($quilt_mode =~ m/dpm/ &&
($diffbits->{H2A} & 01)) {
- fail <<END. $fulldiffhint->($oldtiptree,'HEAD');
---quilt=$quilt_mode specified, implying patches-applied git tree
+ fail +(f_ <<END, $quilt_mode). $fulldiffhint->($oldtiptree,'HEAD');
+--quilt=%s specified, implying patches-applied git tree
but git tree differs from result of applying debian/patches to upstream
END
}
if ($quilt_mode =~ m/gbp|unapplied/ &&
($diffbits->{O2A} & 01)) { # some patches
quiltify_splitbrain_needed();
- progress "dgit view: creating patches-applied version using gbp pq";
+ progress __ "dgit view: creating patches-applied version using gbp pq";
runcmd shell_cmd 'exec >/dev/null', gbp_pq, qw(import);
# gbp pq import creates a fresh branch; push back to dgit-view
runcmd @git, qw(update-ref refs/heads/dgit-view HEAD);
}
if ($quilt_mode =~ m/gbp|dpm/ &&
($diffbits->{O2A} & 02)) {
- fail <<END;
---quilt=$quilt_mode specified, implying that HEAD is for use with a
+ fail f_ <<END, $quilt_mode;
+--quilt=%s specified, implying that HEAD is for use with a
tool which does not create patches for changes to upstream
.gitignores: but, such patches exist in debian/patches.
END
if (($diffbits->{O2H} & 02) && # user has modified .gitignore
!($diffbits->{O2A} & 02)) { # patches do not change .gitignore
quiltify_splitbrain_needed();
- progress "dgit view: creating patch to represent .gitignore changes";
+ progress __
+ "dgit view: creating patch to represent .gitignore changes";
ensuredir "debian/patches";
my $gipatch = "debian/patches/auto-gitignore";
- open GIPATCH, ">>", "$gipatch" or die "$gipatch: $!";
- stat GIPATCH or die "$gipatch: $!";
- fail "$gipatch already exists; but want to create it".
- " to record .gitignore changes" if (stat _)[7];
- print GIPATCH <<END or die "$gipatch: $!";
+ open GIPATCH, ">>", "$gipatch" or confess "$gipatch: $!";
+ stat GIPATCH or confess "$gipatch: $!";
+ fail f_ "%s already exists; but want to create it".
+ " to record .gitignore changes",
+ $gipatch
+ if (stat _)[7];
+ print GIPATCH +(__ <<END).<<ENDU or die "$gipatch: $!";
Subject: Update .gitignore from Debian packaging branch
The Debian packaging git branch contains these updates to the upstream
.gitignore file(s). This patch is autogenerated, to provide these
updates to users of the official Debian archive view of the package.
+END
[dgit ($our_version) update-gitignore]
---
-END
+ENDU
close GIPATCH or die "$gipatch: $!";
runcmd shell_cmd "exec >>$gipatch", @git, qw(diff),
$unapplied, $headref, "--", sort keys %$editedignores;
- open SERIES, "+>>", "debian/patches/series" or die $!;
- defined seek SERIES, -1, 2 or $!==EINVAL or die $!;
+ open SERIES, "+>>", "debian/patches/series" or confess $!;
+ defined seek SERIES, -1, 2 or $!==EINVAL or confess $!;
my $newline;
- defined read SERIES, $newline, 1 or die $!;
- print SERIES "\n" or die $! unless $newline eq "\n";
- print SERIES "auto-gitignore\n" or die $!;
+ defined read SERIES, $newline, 1 or confess $!;
+ print SERIES "\n" or confess $! unless $newline eq "\n";
+ print SERIES "auto-gitignore\n" or confess $!;
close SERIES or die $!;
runcmd @git, qw(add -f -- debian/patches/series), $gipatch;
- commit_admin <<END
+ commit_admin +(__ <<END).<<ENDU
Commit patch to update .gitignore
+END
[dgit ($our_version) update-gitignore-quilt-fixup]
-END
+ENDU
}
my $dgitview = git_rev_parse 'HEAD';
changedir "$playground/work";
- my $saved = maybe_split_brain_save $headref, $dgitview, "converted";
- progress "dgit view: created ($saved)";
+ my $saved = maybe_split_brain_save $headref, $dgitview, __ "converted";
+ progress f_ "dgit view: created (%s)", $saved;
}
sub quiltify ($$$$) {
my $c = shift @todo;
next if $considered{$c->{Commit}}++;
- $not->($c, "maximum search space exceeded") if --$max_work <= 0;
+ $not->($c, __ "maximum search space exceeded") if --$max_work <= 0;
printdebug "quiltify investigate $c->{Commit}\n";
}
my $c_sentinels = quiltify_tree_sentinelfiles $c->{Commit};
- $not->($c, "has $c_sentinels not $t_sentinels")
+ $not->($c, f_ "has %s not %s", $c_sentinels, $t_sentinels)
if $c_sentinels ne $t_sentinels;
my $commitdata = cmdoutput @git, qw(cat-file commit), $c->{Commit};
my @parents = ($commitdata =~ m/^parent (\w+)$/gm);
@parents = map { { Commit => $_, Child => $c } } @parents;
- $not->($c, "root commit") if !@parents;
+ $not->($c, __ "root commit") if !@parents;
foreach my $p (@parents) {
$p->{Nontrivial}= quiltify_trees_differ $p->{Commit},$c->{Commit};
}
my $ndiffers = grep { $_->{Nontrivial} } @parents;
- $not->($c, "merge ($ndiffers nontrivial parents)") if $ndiffers > 1;
+ $not->($c, f_ "merge (%s nontrivial parents)", $ndiffers)
+ if $ndiffers > 1;
foreach my $p (@parents) {
printdebug "considering C=$c->{Commit} P=$p->{Commit}\n";
my $patchstackchange = cmdoutput @cmd;
if (length $patchstackchange) {
$patchstackchange =~ s/\n/,/g;
- $not->($p, "changed $patchstackchange");
+ $not->($p, f_ "changed %s", $patchstackchange);
}
printdebug " search queue P=$p->{Commit} ",
$x =~ s/(.*?[0-9a-z]{8})[0-9a-z]*$/$1/;
return $x;
};
- my $reportnot = sub {
- my ($notp) = @_;
- my $s = $abbrev->($notp);
- my $c = $notp->{Child};
- $s .= "..".$abbrev->($c) if $c;
- $s .= ": ".$notp->{Whynot};
- return $s;
- };
if ($quilt_mode eq 'linear') {
- print STDERR "\n$us: error: quilt fixup cannot be linear. Stopped at:\n";
+ print STDERR f_
+ "\n%s: error: quilt fixup cannot be linear. Stopped at:\n",
+ $us;
my $all_gdr = !!@nots;
foreach my $notp (@nots) {
- print STDERR "$us: ", $reportnot->($notp), "\n";
+ my $c = $notp->{Child};
+ my $cprange = $abbrev->($notp);
+ $cprange .= "..".$abbrev->($c) if $c;
+ print STDERR f_ "%s: %s: %s\n",
+ $us, $cprange, $notp->{Whynot};
$all_gdr &&= $notp->{Child} &&
(git_cat_file $notp->{Child}{Commit}, 'commit')
=~ m{^\[git-debrebase(?! split[: ]).*\]$}m;
[ grep { $_->[0] ne 'quilt-mode' } @$failsuggestion ]
if $all_gdr;
print STDERR "$us: $_->[1]\n" foreach @$failsuggestion;
- fail
+ fail __
"quilt history linearisation failed. Search \`quilt fixup' in dgit(7).\n";
} elsif ($quilt_mode eq 'smash') {
} elsif ($quilt_mode eq 'auto') {
- progress "quilt fixup cannot be linear, smashing...";
+ progress __ "quilt fixup cannot be linear, smashing...";
} else {
- die "$quilt_mode ?";
+ confess "$quilt_mode ?";
}
my $time = $ENV{'GIT_COMMITTER_DATE'} || time;
quiltify_dpkg_commit "auto-$version-$target-$time",
(getfield $clogp, 'Maintainer'),
- "Automatically generated patch ($clogp->{Version})\n".
- "Last (up to) $ncommits git changes, FYI:\n\n". $msg;
+ (f_ "Automatically generated patch (%s)\n".
+ "Last (up to) %s git changes, FYI:\n\n",
+ $clogp->{Version}, $ncommits).
+ $msg;
return;
}
- progress "quiltify linearisation planning successful, executing...";
+ progress __ "quiltify linearisation planning successful, executing...";
for (my $p = $sref_S;
my $c = $p->{Child};
my ($what) = @_;
eval {
- die "contains unexpected slashes\n" if m{//} || m{/$};
- die "contains leading punctuation\n" if m{^\W} || m{/\W};
- die "contains bad character(s)\n" if m{[^-a-z0-9_.+=~/]}i;
- die "is series file\n" if m{$series_filename_re}o;
- die "too long\n" if length > 200;
+ die __ "contains unexpected slashes\n" if m{//} || m{/$};
+ die __ "contains leading punctuation\n" if m{^\W} || m{/\W};
+ die __ "contains bad character(s)\n" if m{[^-a-z0-9_.+=~/]}i;
+ die __ "is series file\n" if m{$series_filename_re}o;
+ die __ "too long\n" if length > 200;
};
return $_ unless $@;
- print STDERR "quiltifying commit $cc:".
- " ignoring/dropping Gbp-Pq $what: $@";
+ print STDERR f_
+ "quiltifying commit %s: ignoring/dropping Gbp-Pq %s: %s",
+ $cc, $what, $@;
return undef;
};
$patchname = $translitname;
};
print STDERR
- "dgit: patch title transliteration error: $@"
+ +(f_ "dgit: patch title transliteration error: %s", $@)
if $@;
$patchname =~ y/ A-Z/-a-z/;
$patchname =~ y/-a-z0-9_.+=~//cd;
for ($index='';
stat "debian/patches/$patchname$index";
$index++) { }
- $!==ENOENT or die "$patchname$index $!";
+ $!==ENOENT or confess "$patchname$index $!";
runcmd @git, qw(checkout -q), $cc;
sub unpack_playtree_mkwork ($) {
my ($headref) = @_;
- mkdir "work" or die $!;
+ mkdir "work" or confess $!;
changedir "work";
mktree_in_ud_here();
runcmd @git, qw(reset -q --hard), $headref;
sub quilt_fixup_delete_pc () {
runcmd @git, qw(rm -rqf .pc);
- commit_admin <<END
+ commit_admin +(__ <<END).<<ENDU
Commit removal of .pc (quilt series tracking data)
+END
[dgit ($our_version) upgrade quilt-remove-pc]
-END
+ENDU
}
sub quilt_fixup_singlepatch ($$$) {
my ($clogp, $headref, $upstreamversion) = @_;
- progress "starting quiltify (single-debian-patch)";
+ progress __ "starting quiltify (single-debian-patch)";
# dpkg-source --commit generates new patches even if
# single-debian-patch is in debian/source/options. In order to
my $fakeversion="$upstreamversion-~~DGITFAKE";
- my $fakedsc=new IO::File 'fake.dsc', '>' or die $!;
- print $fakedsc <<END or die $!;
+ my $fakedsc=new IO::File 'fake.dsc', '>' or confess $!;
+ print $fakedsc <<END or confess $!;
Format: 3.0 (quilt)
Source: $package
Version: $fakeversion
my $md = new Digest::MD5;
my $fh = new IO::File $b, '<' or die "$b $!";
- stat $fh or die $!;
+ stat $fh or confess $!;
my $size = -s _;
$md->addfile($fh);
- print $fakedsc " ".$md->hexdigest." $size $b\n" or die $!;
+ print $fakedsc " ".$md->hexdigest." $size $b\n" or confess $!;
};
unpack_playtree_linkorigs($upstreamversion, $dscaddfile);
runcmd qw(env GZIP=-1n tar -zcf), "./$debtar", qw(-C), $maindir, @files;
$dscaddfile->($debtar);
- close $fakedsc or die $!;
+ close $fakedsc or confess $!;
}
sub quilt_fakedsc2unapplied ($$) {
changedir 'fake';
- remove_stray_gits("source package");
+ remove_stray_gits(__ "source package");
mktree_in_ud_here();
rmtree '.pc';
my $splitbrain_cachekey;
- progress
- "dgit: split brain (separate dgit view) may be needed (--quilt=$quilt_mode).";
+ progress f_
+ "dgit: split brain (separate dgit view) may be needed (--quilt=%s).",
+ $quilt_mode;
# we look in the reflog of dgit-intern/quilt-cache
# we look for an entry whose message is the key for the cache lookup
my @cachekey = (qw(dgit), $our_version);
unpack_playtree_mkwork($headref);
my $saved = maybe_split_brain_save $headref, $cachehit, "cache-hit";
if ($cachehit ne $headref) {
- progress "dgit view: found cached ($saved)";
+ progress f_ "dgit view: found cached (%s)", $saved;
runcmd @git, qw(checkout -q -b dgit-view), $cachehit;
$split_brain = 1;
return ($cachehit, $splitbrain_cachekey);
}
- progress "dgit view: found cached, no changes required";
+ progress __ "dgit view: found cached, no changes required";
return ($headref, $splitbrain_cachekey);
}
sub quilt_fixup_multipatch ($$$) {
my ($clogp, $headref, $upstreamversion) = @_;
- progress "examining quilt state (multiple patches, $quilt_mode mode)";
+ progress f_ "examining quilt state (multiple patches, %s mode)",
+ $quilt_mode;
# Our objective is:
# - honour any existing .pc in case it has any strangeness
$!=0; $?=-1;
if (system @bbcmd) {
failedcmd @bbcmd if $? < 0;
- fail <<END;
+ fail __ <<END;
failed to apply your git tree's patch stack (from debian/patches/) to
the corresponding upstream tarball(s). Your source tree and .orig
are probably too inconsistent. dgit can only fix up certain kinds of
my $mustdeletepc=0;
if (stat_exists ".pc") {
-d _ or die;
- progress "Tree already contains .pc - will use it then delete it.";
+ progress __ "Tree already contains .pc - will use it then delete it.";
$mustdeletepc=1;
} else {
- rename '../fake/.pc','.pc' or die $!;
+ rename '../fake/.pc','.pc' or confess $!;
}
changedir '../fake';
}
printdebug "differences \@dl @dl.\n";
- progress sprintf
-"$us: base trees orig=%.20s o+d/p=%.20s",
- $unapplied, $oldtiptree;
- progress sprintf
-"$us: quilt differences: src: %s orig %s gitignores: %s orig %s\n".
-"$us: quilt differences: HEAD %s o+d/p HEAD %s o+d/p",
- $dl[0], $dl[1], $dl[3], $dl[4],
- $dl[2], $dl[5];
+ progress f_
+"%s: base trees orig=%.20s o+d/p=%.20s",
+ $us, $unapplied, $oldtiptree;
+ progress f_
+"%s: quilt differences: src: %s orig %s gitignores: %s orig %s\n".
+"%s: quilt differences: HEAD %s o+d/p HEAD %s o+d/p",
+ $us, $dl[0], $dl[1], $dl[3], $dl[4],
+ $us, $dl[2], $dl[5];
if (@unrepres) {
- print STDERR "dgit: cannot represent change: $_->[1]: $_->[0]\n"
+ print STDERR f_ "dgit: cannot represent change: %s: %s\n",
+ $_->[1], $_->[0]
foreach @unrepres;
- forceable_fail [qw(unrepresentable)], <<END;
+ forceable_fail [qw(unrepresentable)], __ <<END;
HEAD has changes to .orig[s] which are not representable by `3.0 (quilt)'
END
}
my @failsuggestion;
if (!($diffbits->{O2H} & $diffbits->{O2A})) {
- push @failsuggestion, [ 'unapplied',
- "This might be a patches-unapplied branch." ];
+ push @failsuggestion, [ 'unapplied', __
+ "This might be a patches-unapplied branch." ];
} elsif (!($diffbits->{H2A} & $diffbits->{O2A})) {
- push @failsuggestion, [ 'applied',
- "This might be a patches-applied branch." ];
+ push @failsuggestion, [ 'applied', __
+ "This might be a patches-applied branch." ];
}
- push @failsuggestion, [ 'quilt-mode',
+ push @failsuggestion, [ 'quilt-mode', __
"Maybe you need one of --[quilt=]gbp --[quilt=]dpm --quilt=unapplied ?" ];
- push @failsuggestion, [ 'gitattrs',
+ push @failsuggestion, [ 'gitattrs', __
"Warning: Tree has .gitattributes. See GITATTRIBUTES in dgit(7)." ]
if stat_exists '.gitattributes';
- push @failsuggestion, [ 'origs',
+ push @failsuggestion, [ 'origs', __
"Maybe orig tarball(s) are not identical to git representation?" ];
if (quiltmode_splitbrain()) {
return;
}
- progress "starting quiltify (multiple patches, $quilt_mode mode)";
+ progress f_ "starting quiltify (multiple patches, %s mode)", $quilt_mode;
quiltify($clogp,$headref,$oldtiptree,\@failsuggestion);
if (!open P, '>>', ".pc/applied-patches") {
- $!==&ENOENT or die $!;
+ $!==&ENOENT or confess $!;
} else {
close P;
}
sub quilt_fixup_editor () {
my $descfn = $ENV{$fakeeditorenv};
my $editing = $ARGV[$#ARGV];
- open I1, '<', $descfn or die "$descfn: $!";
- open I2, '<', $editing or die "$editing: $!";
- unlink $editing or die "$editing: $!";
- open O, '>', $editing or die "$editing: $!";
- while (<I1>) { print O or die $!; } I1->error and die $!;
+ open I1, '<', $descfn or confess "$descfn: $!";
+ open I2, '<', $editing or confess "$editing: $!";
+ unlink $editing or confess "$editing: $!";
+ open O, '>', $editing or confess "$editing: $!";
+ while (<I1>) { print O or confess $!; } I1->error and confess $!;
my $copying = 0;
while (<I2>) {
$copying ||= m/^\-\-\- /;
next unless $copying;
- print O or die $!;
+ print O or confess $!;
}
- I2->error and die $!;
+ I2->error and confess $!;
close O or die $1;
finish 0;
}
sub maybe_apply_patches_dirtily () {
return unless $quilt_mode =~ m/gbp|unapplied/;
- print STDERR <<END or die $!;
+ print STDERR __ <<END or confess $!;
dgit: Building, or cleaning with rules target, in patches-unapplied tree.
dgit: Have to apply the patches - making the tree dirty.
}
sub maybe_unapply_patches_again () {
- progress "dgit: Unapplying patches again to tidy up the tree."
+ progress __ "dgit: Unapplying patches again to tidy up the tree."
if $patches_applied_dirtily;
runcmd qw(dpkg-source --after-build .)
if $patches_applied_dirtily & 01;
} elsif ($cleanmode eq 'check') {
my $leftovers = cmdoutput @git, qw(clean -xdn);
if (length $leftovers) {
- print STDERR $leftovers, "\n" or die $!;
- fail "tree contains uncommitted files and --clean=check specified";
+ print STDERR $leftovers, "\n" or confess $!;
+ fail __
+ "tree contains uncommitted files and --clean=check specified";
}
} elsif ($cleanmode eq 'none') {
} else {
}
sub cmd_clean () {
- badusage "clean takes no additional arguments" if @ARGV;
+ badusage __ "clean takes no additional arguments" if @ARGV;
notpushing();
clean_tree();
maybe_unapply_patches_again();
sub build_or_push_prep_early () {
our $build_or_push_prep_early_done //= 0;
return if $build_or_push_prep_early_done++;
- badusage "-p is not allowed with dgit $subcommand" if defined $package;
+ badusage f_ "-p is not allowed with dgit %s", $subcommand
+ if defined $package;
my $clogp = parsechangelog();
$isuite = getfield $clogp, 'Distribution';
$package = getfield $clogp, 'Source';
my $pat = changespat $version;
foreach my $f (glob "$buildproductsdir/$pat") {
if (act_local()) {
- unlink $f or fail "remove old changes file $f: $!";
+ unlink $f or
+ fail f_ "remove old changes file %s: %s", $f, $!;
} else {
- progress "would remove $f";
+ progress f_ "would remove %s", $f;
}
}
}
1;
}) {
print STDERR $@;
- fail
+ fail __
"archive query failed (queried because --since-version not specified)";
}
if (@vsns) {
@vsns = map { $_->[0] } @vsns;
@vsns = sort { -version_compare($a, $b) } @vsns;
$changes_since_version = $vsns[0];
- progress "changelog will contain changes since $vsns[0]";
+ progress f_ "changelog will contain changes since %s", $vsns[0];
} else {
$changes_since_version = '_';
- progress "package seems new, not specifying -v<version>";
+ progress __ "package seems new, not specifying -v<version>";
}
}
if ($changes_since_version ne '_') {
$r |= WANTSRC_SOURCE if grep { s/^full$/binary/ } @d;
$r |= WANTSRC_SOURCE if grep { s/^source$// } @d;
$r |= WANTSRC_BUILDER if grep { m/./ } @d;
- fail "Wanted to build nothing!" unless $r;
+ fail __ "Wanted to build nothing!" unless $r;
$dmode = '--build='. join ',', grep m/./, @d;
} else {
$r =
$dmode =~ m/[S]/ ? WANTSRC_SOURCE :
$dmode =~ y/gGF/ABb/ ? WANTSRC_SOURCE | WANTSRC_BUILDER :
$dmode =~ m/[ABb]/ ? WANTSRC_BUILDER :
- die "$dmode ?";
+ confess "$dmode ?";
}
printdebug "massage done $r $dmode.\n";
push @$cmd, $dmode;
} @changesfiles;
my $result;
if (@changesfiles==1) {
- fail <<END.$msg_if_onlyone if defined $msg_if_onlyone;
-only one changes file from build (@changesfiles)
+ fail +(f_ <<END, "@changesfiles").$msg_if_onlyone
+only one changes file from build (%s)
END
+ if defined $msg_if_onlyone;
$result = $changesfiles[0];
} elsif (@changesfiles==2) {
my $binchanges = parsecontrol($changesfiles[1], "binary changes file");
foreach my $l (split /\n/, getfield $binchanges, 'Files') {
- fail "$l found in binaries changes file $binchanges"
+ fail f_ "%s found in binaries changes file %s", $l, $binchanges
if $l =~ m/\.dsc$/;
}
runcmd_ordryrun_local @mergechanges, @changesfiles;
my $multichanges = changespat $version,'multi';
if (act_local()) {
- stat_exists $multichanges or fail "$multichanges: $!";
+ stat_exists $multichanges or fail f_
+ "%s unexpectedly not created by build", $multichanges;
foreach my $cf (glob $pat) {
next if $cf eq $multichanges;
- rename "$cf", "$cf.inmulti" or fail "$cf\{,.inmulti}: $!";
+ rename "$cf", "$cf.inmulti" or fail f_
+ "install new changes %s\{,.inmulti}: %s", $cf, $!;
}
}
$result = $multichanges;
} else {
- fail "wrong number of different changes files (@changesfiles)";
+ fail f_ "wrong number of different changes files (%s)",
+ "@changesfiles";
}
- printdone "build successful, results in $result\n" or die $!;
+ printdone f_ "build successful, results in %s\n", $result
+ or confess $!;
}
sub midbuild_checkchanges () {
$_ ne changespat $version,'source' and
$_ ne changespat $version,'multi'
} @unwanted;
- fail <<END
-changes files other than source matching $pat already present; building would result in ambiguity about the intended results.
-Suggest you delete @unwanted.
+ fail +(f_ <<END, $pat, "@unwanted")
+changes files other than source matching %s already present; building would result in ambiguity about the intended results.
+Suggest you delete %s.
END
if @unwanted;
}
postbuild_mergechanges(undef);
};
} else {
- printdone "build successful\n";
+ printdone __ "build successful\n";
}
}
sub cmd_build {
build_prep_early();
- $buildproductsdir eq '..' or print STDERR <<END;
-$us: warning: build-products-dir set, but not supported by dpkg-buildpackage
-$us: warning: build-products-dir will be ignored; files will go to ..
+ $buildproductsdir eq '..' or print STDERR +(f_ <<END, $us, $us);
+%s: warning: build-products-dir set, but not supported by dpkg-buildpackage
+%s: warning: build-products-dir will be ignored; files will go to ..
END
$buildproductsdir = '..';
my @dbp = (@dpkgbuildpackage, qw(-us -uc), changesopts_initial(), @ARGV);
if ($gbp_make_orig) {
my $priv = dgit_privdir();
my $ok = "$priv/origs-gen-ok";
- unlink $ok or $!==&ENOENT or die $!;
+ unlink $ok or $!==&ENOENT or confess $!;
my @origs_cmd = @cmd;
push @origs_cmd, qw(--git-cleaner=true);
push @origs_cmd, "--git-prebuild=".
$sourcechanges = changespat $version,'source';
if (act_local()) {
unlink "$buildproductsdir/$sourcechanges" or $!==ENOENT
- or fail "remove $sourcechanges: $!";
+ or fail f_ "remove %s: %s", $sourcechanges, $!;
}
my @cmd = (@dpkgsource, qw(-b --));
my $leafdir;
my ($why, $l) = @_;
printdebug " renaming ($why) $l\n";
rename "$l", bpd_abs()."/$l"
- or fail "put in place new built file ($l): $!";
+ or fail f_ "put in place new built file (%s): %s", $l, $!;
};
foreach my $l (split /\n/, getfield $dsc, 'Files') {
$l =~ m/\S+$/ or next;
}
sub cmd_build_source {
- badusage "build-source takes no additional arguments" if @ARGV;
+ badusage __ "build-source takes no additional arguments" if @ARGV;
build_prep(WANTSRC_SOURCE);
build_source();
maybe_unapply_patches_again();
- printdone "source built, results in $dscfn and $sourcechanges";
+ printdone f_ "source built, results in %s and %s",
+ $dscfn, $sourcechanges;
}
sub cmd_push_source {
prep_push();
- fail "dgit push-source: --include-dirty/--ignore-dirty does not make".
- "sense with push-source!" if $includedirty;
+ fail __
+ "dgit push-source: --include-dirty/--ignore-dirty does not make".
+ "sense with push-source!"
+ if $includedirty;
build_maybe_quilt_fixup();
if ($changesfile) {
my $changes = parsecontrol("$buildproductsdir/$changesfile",
- "source changes file");
+ __ "source changes file");
unless (test_source_only_changes($changes)) {
- fail "user-specified changes file is not source-only";
+ fail __ "user-specified changes file is not source-only";
}
} else {
# Building a source package is very fast, so just do it
build_source();
- die "er, patches are applied dirtily but shouldn't be.."
+ confess "er, patches are applied dirtily but shouldn't be.."
if $patches_applied_dirtily;
$changesfile = $sourcechanges;
}
midbuild_checkchanges();
in_bpd {
if (act_local()) {
- stat_exists $dscfn or fail "$dscfn (in build products dir): $!";
- stat_exists $sourcechanges
- or fail "$sourcechanges (in build products dir): $!";
+ stat_exists $dscfn or fail f_
+ "%s (in build products dir): %s", $dscfn, $!;
+ stat_exists $sourcechanges or fail f_
+ "%s (in build products dir): %s", $sourcechanges, $!;
}
runcmd_ordryrun_local @$bbuilder, @args;
};
sub cmd_sbuild {
build_prep_early();
- binary_builder(\@sbuild, <<END, qw(-d), $isuite, @ARGV, $dscfn);
+ binary_builder(\@sbuild, (__ <<END), qw(-d), $isuite, @ARGV, $dscfn);
perhaps you need to pass -A ? (sbuild's default is to build only
arch-specific binaries; dgit 1.4 used to override that.)
END
# @ARGV is allowed to contain only things that should be passed to
# pbuilder under debbuildopts; just massage those
my $wantsrc = massage_dbp_args \@ARGV;
- fail "you asked for a builder but your debbuildopts didn't ask for".
- " any binaries -- is this really what you meant?"
- unless $wantsrc & WANTSRC_BUILDER;
- fail "we must build a .dsc to pass to the builder but your debbuiltopts".
- " forbids the building of a source package; cannot continue"
+ fail __
+ "you asked for a builder but your debbuildopts didn't ask for".
+ " any binaries -- is this really what you meant?"
+ unless $wantsrc & WANTSRC_BUILDER;
+ fail __
+ "we must build a .dsc to pass to the builder but your debbuiltopts".
+ " forbids the building of a source package; cannot continue"
unless $wantsrc & WANTSRC_SOURCE;
# We do not want to include the verb "build" in @pbuilder because
# the user can customise @pbuilder and they shouldn't be required
}
sub cmd_print_unapplied_treeish {
- badusage "incorrect arguments to dgit print-unapplied-treeish" if @ARGV;
+ badusage __ "incorrect arguments to dgit print-unapplied-treeish"
+ if @ARGV;
my $headref = git_rev_parse('HEAD');
my $clogp = commit_getclogp $headref;
$package = getfield $clogp, 'Source';
my $uv = upstreamversion $version;
quilt_make_fake_dsc($uv);
my $u = quilt_fakedsc2unapplied($headref, $uv);
- print $u, "\n" or die $!;
+ print $u, "\n" or confess $!;
}
sub import_dsc_result {
my ($dstref, $newhash, $what_log, $what_msg) = @_;
my @cmd = (git_update_ref_cmd $what_log, $dstref, $newhash);
runcmd @cmd;
- check_gitattrs($newhash, "source tree");
+ check_gitattrs($newhash, __ "source tree");
- progress "dgit: import-dsc: $what_msg";
+ progress f_ "dgit: import-dsc: %s", $what_msg;
}
sub cmd_import_dsc {
if (m/^--require-valid-signature$/) {
$needsig = 1;
} else {
- badusage "unknown dgit import-dsc sub-option \`$_'";
+ badusage f_ "unknown dgit import-dsc sub-option \`%s'", $_;
}
}
- badusage "usage: dgit import-dsc .../PATH/TO/.DSC BRANCH" unless @ARGV==2;
+ 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();
+ badusage __ "dry run makes no sense with import-dsc"
+ unless act_local();
my $force = $dstbranch =~ s/^\+// ? +1 :
$dstbranch =~ s/^\.\.// ? -1 :
my $chead = cmdoutput_errok @symcmd;
defined $chead or $?==256 or failedcmd @symcmd;
- fail "$dstbranch is checked out - will not update it"
+ fail f_ "%s is checked out - will not update it", $dstbranch
if defined $chead and $chead eq $dstbranch;
my $oldhash = git_get_ref $dstbranch;
- open D, "<", $dscfn or fail "open import .dsc ($dscfn): $!";
+ open D, "<", $dscfn or fail f_ "open import .dsc (%s): %s", $dscfn, $!;
$dscdata = do { local $/ = undef; <D>; };
- D->error and fail "read $dscfn: $!";
+ D->error and fail f_ "read %s: %s", $dscfn, $!;
close C;
# we don't normally need this so import it here
local $SIG{__WARN__} = sub {
print STDERR $_[0];
return unless $needsig;
- fail "import-dsc signature check failed";
+ fail __ "import-dsc signature check failed";
};
if (!$dp->is_signed()) {
- warn "$us: warning: importing unsigned .dsc\n";
+ warn f_ "%s: warning: importing unsigned .dsc\n", $us;
} else {
my $r = $dp->check_signature();
- die "->check_signature => $r" if $needsig && $r;
+ confess "->check_signature => $r" if $needsig && $r;
}
}
$package = getfield $dsc, 'Source';
- parse_dsc_field($dsc, "Dgit metadata in .dsc")
+ parse_dsc_field($dsc, __ "Dgit metadata in .dsc")
unless forceing [qw(import-dsc-with-dgit-field)];
parse_dsc_field_def_dsc_distro();
notpushing();
if (defined $dsc_hash) {
- progress "dgit: import-dsc of .dsc with Dgit field, using git hash";
+ progress __
+ "dgit: import-dsc of .dsc with Dgit field, using git hash";
resolve_dsc_field_commit undef, undef;
}
if (defined $dsc_hash) {
"echo $dsc_hash | git cat-file --batch-check");
my $objgot = cmdoutput @cmd;
if ($objgot =~ m#^\w+ missing\b#) {
- fail <<END
-.dsc contains Dgit field referring to object $dsc_hash
+ fail f_ <<END, $dsc_hash
+.dsc contains Dgit field referring to object %s
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, $dsc_hash) {
if ($force > 0) {
- progress "Not fast forward, forced update.";
+ progress __ "Not fast forward, forced update.";
} else {
- fail "Not fast forward to $dsc_hash";
+ fail f_ "Not fast forward to %s", $dsc_hash;
}
}
import_dsc_result $dstbranch, $dsc_hash,
"dgit import-dsc (Dgit): $info",
- "updated git ref $dstbranch";
+ f_ "updated git ref %s", $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
+ fail f_ <<END, $dstbranch, $specbranch, $specbranch
+Branch %s already exists
+Specify ..%s for a pseudo-merge, binding in existing history
+Specify +%s to overwrite, discarding existing history
END
if $oldhash && !$force;
my $here = "$buildproductsdir/$f";
if (lstat $here) {
next if stat $here;
- fail "lstat $here works but stat gives $! !";
+ fail f_ "lstat %s works but stat gives %s !", $here, $!;
}
- fail "stat $here: $!" unless $! == ENOENT;
+ fail f_ "stat %s: %s", $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!";
+ fail f_
+ "cannot import %s which seems to be inside working tree!",
+ $dscfn;
}
- $there =~ s#/+[^/]+$## or
- fail "import $dscfn requires ../$f, but it does not exist";
+ $there =~ s#/+[^/]+$## or fail f_
+ "import %s requires .../%s, but it does not exist",
+ $dscfn, $f;
$there .= "/$f";
my $test = $there =~ m{^/} ? $there : "../$there";
- stat $test or fail "import $dscfn requires $test, but: $!";
- symlink $there, $here or fail "symlink $there to $here: $!";
- progress "made symlink $here -> $there";
+ stat $test or fail f_
+ "import %s requires %s, but: %s", $dscfn, $test, $!;
+ symlink $there, $here or fail f_
+ "symlink %s to %s: %s", $there, $here, $!;
+ progress f_ "made symlink %s -> %s", $here, $there;
# print STDERR Dumper($fi);
}
my @mergeinputs = generate_commits_from_dsc();
if ($oldhash) {
if ($force > 0) {
- progress "Import, forced update - synthetic orphan git history.";
+ progress __
+ "Import, forced update - synthetic orphan git history.";
} elsif ($force < 0) {
- progress "Import, merging.";
+ progress __ "Import, merging.";
my $tree = cmdoutput @git, qw(rev-parse), "$newhash:";
my $version = getfield $dsc, 'Version';
my $clogp = commit_getclogp $newhash;
my $authline = clogp_authline $clogp;
- $newhash = make_commit_text <<END;
+ $newhash = make_commit_text <<ENDU
tree $tree
parent $newhash
parent $oldhash
author $authline
committer $authline
-Merge $package ($version) import into $dstbranch
+ENDU
+ .(f_ <<END, $package, $version, $dstbranch);
+Merge %s (%s) import into %s
END
} else {
die; # caught earlier
import_dsc_result $dstbranch, $newhash,
"dgit import-dsc: $info",
- "results are in in git ref $dstbranch";
+ f_ "results are in in git ref %s", $dstbranch;
}
sub pre_archive_api_query () {
not_necessarily_a_tree();
}
sub cmd_archive_api_query {
- badusage "need only 1 subpath argument" unless @ARGV==1;
+ badusage __ "need only 1 subpath argument" unless @ARGV==1;
my ($subpath) = @ARGV;
local $isuite = 'DGIT-API-QUERY-CMD';
my @cmd = archive_api_query_cmd($subpath);
push @cmd, qw(-f);
debugcmd ">",@cmd;
- exec @cmd or fail "exec curl: $!\n";
+ exec @cmd or fail f_ "exec curl: %s\n", $!;
}
sub repos_server_url () {
not_necessarily_a_tree();
}
sub cmd_clone_dgit_repos_server {
- badusage "need destination argument" unless @ARGV==1;
+ badusage __ "need destination argument" unless @ARGV==1;
my ($destdir) = @ARGV;
my $url = repos_server_url();
my @cmd = (@git, qw(clone), $url, $destdir);
debugcmd ">",@cmd;
- exec @cmd or fail "exec git clone: $!\n";
+ exec @cmd or fail f_ "exec git clone: %s\n", $!;
}
sub pre_print_dgit_repos_server_source_url () {
not_necessarily_a_tree();
}
sub cmd_print_dgit_repos_server_source_url {
- badusage "no arguments allowed to dgit print-dgit-repos-server-source-url"
+ badusage __
+ "no arguments allowed to dgit print-dgit-repos-server-source-url"
if @ARGV;
my $url = repos_server_url();
- print $url, "\n" or die $!;
+ print $url, "\n" or confess $!;
}
sub pre_print_dpkg_source_ignores {
not_necessarily_a_tree();
}
sub cmd_print_dpkg_source_ignores {
- badusage "no arguments allowed to dgit print-dpkg-source-ignores"
+ badusage __
+ "no arguments allowed to dgit print-dpkg-source-ignores"
if @ARGV;
- print "@dpkg_source_ignores\n" or die $!;
+ print "@dpkg_source_ignores\n" or confess $!;
}
sub cmd_setup_mergechangelogs {
- badusage "no arguments allowed to dgit setup-mergechangelogs" if @ARGV;
+ badusage __ "no arguments allowed to dgit setup-mergechangelogs"
+ if @ARGV;
local $isuite = 'DGIT-SETUP-TREE';
setup_mergechangelogs(1);
}
sub cmd_setup_useremail {
- badusage "no arguments allowed to dgit setup-useremail" if @ARGV;
+ badusage __ "no arguments allowed to dgit setup-useremail" if @ARGV;
local $isuite = 'DGIT-SETUP-TREE';
setup_useremail(1);
}
sub cmd_setup_gitattributes {
- badusage "no arguments allowed to dgit setup-useremail" if @ARGV;
+ badusage __ "no arguments allowed to dgit setup-useremail" if @ARGV;
local $isuite = 'DGIT-SETUP-TREE';
setup_gitattrs(1);
}
sub cmd_setup_new_tree {
- badusage "no arguments allowed to dgit setup-tree" if @ARGV;
+ badusage __ "no arguments allowed to dgit setup-tree" if @ARGV;
local $isuite = 'DGIT-SETUP-TREE';
setup_new_tree();
}
#---------- argument parsing and main program ----------
sub cmd_version {
- print "dgit version $our_version\n" or die $!;
+ print "dgit version $our_version\n" or confess $!;
finish 0;
}
defvalopt '--initiator-tempdir','','.*', sub {
($initiator_tempdir) = (@_);
$initiator_tempdir =~ m#^/# or
- badusage "--initiator-tempdir must be used specify an".
- " absolute, not relative, directory."
+ badusage __ "--initiator-tempdir must be used specify an".
+ " absolute, not relative, directory."
};
sub defoptmodes ($@) {
my ($what) = @_;
@rvalopts = ($_);
if (!defined $val) {
- badusage "$what needs a value" unless @ARGV;
+ badusage f_ "%s needs a value", $what unless @ARGV;
$val = shift @ARGV;
push @rvalopts, $val;
}
- badusage "bad value \`$val' for $what" unless
+ badusage f_ "bad value \`%s' for %s", $val, $what unless
$val =~ m/^$oi->{Re}$(?!\n)/s;
my $how = $oi->{How};
if (ref($how) eq 'SCALAR') {
$_='';
} elsif (m/^--force-/) {
print STDERR
- "$us: warning: ignoring unknown force option $_\n";
+ f_ "%s: warning: ignoring unknown force option %s\n",
+ $us, $_;
$_='';
} elsif (m/^--dgit-tag-format=(old|new)$/s) {
# undocumented, for testing
push @ropts, $_;
$funcopts_long{$_}();
} else {
- badusage "unknown long option \`$_'";
+ badusage f_ "unknown long option \`%s'", $_;
}
} else {
while (m/^-./s) {
$valopt->($oi->{Short});
$_ = '';
} else {
- badusage "unknown short option \`$_'";
+ badusage f_ "unknown short option \`%s'", $_;
}
}
}
sub check_env_sanity () {
my $blocked = new POSIX::SigSet;
- sigprocmask SIG_UNBLOCK, $blocked, $blocked or die $!;
+ sigprocmask SIG_UNBLOCK, $blocked, $blocked or confess $!;
eval {
foreach my $name (qw(PIPE CHLD)) {
my $signame = "SIG$name";
my $signum = eval "POSIX::$signame" // die;
- die "$signame is set to something other than SIG_DFL\n"
+ die f_ "%s is set to something other than SIG_DFL\n",
+ $signame
if defined $SIG{$name} and $SIG{$name} ne 'DEFAULT';
$blocked->ismember($signum) and
- die "$signame is blocked\n";
+ die f_ "%s is blocked\n", $signame;
}
};
return unless $@;
chomp $@;
- fail <<END;
-On entry to dgit, $@
+ fail f_ <<END, $@;
+On entry to dgit, %s
This is a bug produced by something in in your execution environment.
Giving up.
END
my $v = access_cfg("cmd-$k", 'RETURN-UNDEF');
if (defined $v) {
- badcfg "cannot set command for $k"
+ badcfg f_ "cannot set command for %s", $k
unless length $om->[0];
$om->[0] = $v;
}
printdebug "CL $c ", (join " ", map { shellquote } @vl),
"\n" if $debuglevel >= 4;
next unless @vl;
- badcfg "cannot configure options for $k"
+ badcfg f_ "cannot configure options for %s", $k
if $opts_opt_cmdonly{$k};
my $insertpos = $opts_cfg_insertpos{$k};
@$om = ( @$om[0..$insertpos-1],
// access_cfg('quilt-mode', 'RETURN-UNDEF')
// 'linear';
$quilt_mode =~ m/^($quilt_modes_re)$/
- or badcfg "unknown quilt-mode \`$quilt_mode'";
+ or badcfg f_ "unknown quilt-mode \`%s'", $quilt_mode;
$quilt_mode = $1;
}
next if defined $$vr;
$$vr = access_cfg($moc->{Key}, 'RETURN-UNDEF') // $moc->{Default};
my $v = $moc->{Vals}{$$vr};
- badcfg "unknown $moc->{Key} setting \`$$vr'" unless defined $v;
+ badcfg f_ "unknown %s setting \`%s'", $moc->{Key}, $$vr
+ unless defined $v;
$$vr = $v;
}
$cleanmode = access_cfg('clean-mode', 'RETURN-UNDEF');
$cleanmode //= 'dpkg-source';
- badcfg "unknown clean-mode \`$cleanmode'" unless
+ badcfg f_ "unknown clean-mode \`%s'", $cleanmode unless
$cleanmode =~ m/^($cleanmode_re)$(?!\n)/s;
}
parseopts();
check_env_sanity();
-print STDERR "DRY RUN ONLY\n" if $dryrun_level > 1;
-print STDERR "DAMP RUN - WILL MAKE LOCAL (UNSIGNED) CHANGES\n"
+print STDERR __ "DRY RUN ONLY\n" if $dryrun_level > 1;
+print STDERR __ "DAMP RUN - WILL MAKE LOCAL (UNSIGNED) CHANGES\n"
if $dryrun_level == 1;
if (!@ARGV) {
- print STDERR __ $helpmsg or die $!;
+ print STDERR __ $helpmsg or confess $!;
finish 8;
}
$cmd = $subcommand = shift @ARGV;
git_slurp_config();
my $fn = ${*::}{"cmd_$cmd"};
-$fn or badusage "unknown operation $cmd";
+$fn or badusage f_ "unknown operation %s", $cmd;
$fn->();
finish 0;
~ianmdlvl / dgit.git / blobdiff