dgit

   1 #!/usr/bin/perl -w
   2 # dgit
   3 # Integration between git and Debian-style archives
   4 #
   5 # Copyright (C)2013 Ian Jackson
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 use strict;
  21
  22 use IO::Handle;
  23 use Data::Dumper;
  24 use LWP::UserAgent;
  25 use Dpkg::Control::Hash;
  26 use File::Path;
  27 use Dpkg::Version;
  28 use POSIX;
  29
  30 our $isuite = 'unstable';
  31 our $idistro;
  32 our $package;
  33
  34 our $sign = 1;
  35 our $dryrun = 0;
  36 our $changesfile;
  37 our $new_package = 0;
  38 our $existing_package = 'dpkg';
  39
  40 our %format_ok = map { $_=>1 } ("1.0","3.0 (native)","3.0 (quilt)");
  41
  42 our (@git) = qw(git);
  43 our (@dget) = qw(dget);
  44 our (@dput) = qw(dput);
  45 our (@debsign) = qw(debsign);
  46 our (@sbuild) = qw(sbuild -A);
  47 our (@dpkgbuildpackage) = qw(dpkg-buildpackage -i\.git/ -I.git);
  48 our (@mergechanges) = qw(mergechanges -f);
  49
  50
  51 our %opts_opt_map = ('dget' => \@dget,
  52                      'dput' => \@dput,
  53                      'debsign' => \@debsign,
  54                      'sbuild' => \@sbuild,
  55                      'dpkg-buildpackage' => \@dpkgbuildpackage,
  56                      'mergechanges' => \@mergechanges);
  57
  58 our $keyid;
  59
  60 our $debug = 0;
  61 open DEBUG, ">/dev/null" or die $!;
  62
  63 our $remotename = 'dgit';
  64 our $ourdscfield = 'Vcs-Dgit-Master';
  65 our $branchprefix = 'dgit';
  66 our $csuite;
  67
  68 sub lbranch () { return "$branchprefix/$csuite"; }
  69 my $lbranch_re = '^refs/heads/'.$branchprefix.'/([^/.]+)$';
  70 sub lref () { return "refs/heads/".lbranch(); }
  71 sub lrref () { return "refs/remotes/$remotename/$branchprefix/$csuite"; }
  72 sub rrref () { return "refs/$branchprefix/$csuite"; }
  73 sub debiantag ($) {
  74     my ($v) = @_;
  75     $v =~ y/~:/_%/;
  76     return "debian/$v";
  77 }
  78
  79 sub dscfn ($) { return "${package}_$_[0].dsc"; }
  80
  81 our $us = 'dgit';
  82
  83 sub fail { die "$us: @_\n"; }
  84
  85 sub badcfg { print STDERR "$us: invalid configuration: @_\n"; exit 12; }
  86
  87 sub no_such_package () {
  88     print STDERR "$us: package $package does not exist in suite $isuite\n";
  89     exit 4;
  90 }
  91
  92 sub fetchspec () {
  93     local $csuite = '*';
  94     return  "+".rrref().":".lrref();
  95 }
  96
  97 our $ua;
  98
  99 sub url_get {
 100     if (!$ua) {
 101         $ua = LWP::UserAgent->new();
 102         $ua->env_proxy;
 103     }
 104     my $what = $_[$#_];
 105     print "downloading $what...\n";
 106     my $r = $ua->get(@_) or die $!;
 107     return undef if $r->code == 404;
 108     $r->is_success or fail "failed to fetch $what: ".$r->status_line;
 109     return $r->decoded_content();
 110 }
 111
 112 our ($dscdata,$dscurl,$dsc);
 113
 114 sub printcmd {
 115     my $fh = shift @_;
 116     my $intro = shift @_;
 117     print $fh $intro or die $!;
 118     local $_;
 119     foreach my $a (@_) {
 120         $_ = $a;
 121         if (s{['\\]}{\\$&}g || m{\s} || m{[^-_./0-9a-z]}i) {
 122             print $fh " '$_'" or die $!;
 123         } else {
 124             print $fh " $_" or die $!;
 125         }
 126     }
 127     print $fh "\n" or die $!;
 128 }
 129
 130 sub failedcmd {
 131     { local ($!); printcmd \*STDERR, "$_[0]: failed command:", @_ or die $!; };
 132     if ($!) {
 133         fail "failed to fork/exec: $!";
 134     } elsif (!($? & 0xff)) {
 135         fail "subprocess failed with error exit status ".($?>>8);
 136     } elsif ($?) {
 137         fail "subprocess crashed (wait status $?)";
 138     } else {
 139         fail "subprocess produced invalid output";
 140     }
 141 }
 142
 143 sub runcmd {
 144     printcmd(\*DEBUG,"+",@_) if $debug>0;
 145     $!=0; $?=0;
 146     failedcmd @_ if system @_;
 147 }
 148
 149 sub printdone {
 150     if (!$dryrun) {
 151         print "dgit ok: @_\n";
 152     } else {
 153         print "would be ok: @_ (but dry run only)\n";
 154     }
 155 }
 156
 157 sub cmdoutput_errok {
 158     die Dumper(\@_)." ?" if grep { !defined } @_;
 159     printcmd(\*DEBUG,"|",@_) if $debug>0;
 160     open P, "-|", @_ or die $!;
 161     my $d;
 162     $!=0; $?=0;
 163     { local $/ = undef; $d = <P>; }
 164     die $! if P->error;
 165     if (!close P) { print DEBUG "=>!$?\n" if $debug>0; return undef; }
 166     chomp $d;
 167     $d =~ m/^.*/;
 168     print DEBUG "=> \`$&'",(length $' ? '...' : ''),"\n" if $debug>0; #';
 169     return $d;
 170 }
 171
 172 sub cmdoutput {
 173     my $d = cmdoutput_errok @_;
 174     defined $d or failedcmd @_;
 175     return $d;
 176 }
 177
 178 sub dryrun_report {
 179     printcmd(\*STDOUT,"#",@_);
 180 }
 181
 182 sub runcmd_ordryrun {
 183     if (!$dryrun) {
 184         runcmd @_;
 185     } else {
 186         dryrun_report @_;
 187     }
 188 }
 189
 190 our $helpmsg = <<END;
 191 main usages:
 192   dgit [dgit-opts] clone [dgit-opts] package [suite] [./dir|/dir]
 193   dgit [dgit-opts] fetch|pull [dgit-opts] [suite]
 194   dgit [dgit-opts] build [git-buildpackage-opts|dpkg-buildpackage-opts]
 195   dgit [dgit-opts] push [dgit-opts] [suite]
 196 important dgit options:
 197   -k<keyid>           sign tag and package with <keyid> instead of default
 198   --dry-run -n        do not change anything, but go through the motions
 199   --new -N            allow introducing a new package
 200   --debug -D          increase debug level
 201   -c<name>=<value>    set git config option (used directly by dgit too)
 202 END
 203
 204 our $later_warning_msg = <<END;
 205 Perhaps the upload is stuck in incoming.  Using the version from git.
 206 END
 207
 208 sub badusage {
 209     print STDERR "$us: @_\n", $helpmsg or die $!;
 210     exit 8;
 211 }
 212
 213 sub helponly () {
 214     print $helpmsg or die $!;
 215     exit 0;
 216 }
 217
 218 our %defcfg = ('dgit.default.distro' => 'debian',
 219                'dgit.default.username' => '',
 220                'dgit.default.archive-query-default-component' => 'main',
 221                'dgit.default.ssh' => 'ssh',
 222                'dgit-distro.debian.git-host' => 'git.debian.org',
 223                'dgit-distro.debian.git-proto' => 'git+ssh://',
 224                'dgit-distro.debian.git-path' => '/git/dgit-repos',
 225                'dgit-distro.debian.git-check' => 'ssh-cmd',
 226                'dgit-distro.debian.git-create' => 'ssh-cmd',
 227                'dgit-distro.debian.sshdakls-host' => 'coccia.debian.org',
 228                'dgit-distro.debian.sshdakls-dir' =>
 229                    '/srv/ftp-master.debian.org/ftp/dists',
 230                'dgit-distro.debian.mirror' => 'http://http.debian.net/debian/');
 231
 232 sub cfg {
 233     foreach my $c (@_) {
 234         return undef if $c =~ /RETURN-UNDEF/;
 235         my @cmd = (@git, qw(config --), $c);
 236         my $v;
 237         {
 238             local ($debug) = $debug-1;
 239             $v = cmdoutput_errok @cmd;
 240         };
 241         if ($?==0) {
 242             return $v;
 243         } elsif ($?!=256) {
 244             failedcmd @cmd;
 245         }
 246         my $dv = $defcfg{$c};
 247         return $dv if defined $dv;
 248     }
 249     badcfg "need value for one of: @_";
 250 }
 251
 252 sub access_distro () {
 253     return cfg("dgit-suite.$isuite.distro",
 254                "dgit.default.distro");
 255 }
 256
 257 sub access_cfg (@) {
 258     my (@keys) = @_;
 259     my $distro = $idistro || access_distro();
 260     my $value = cfg(map { ("dgit-distro.$distro.$_",
 261                            "dgit.default.$_") } @keys);
 262     return $value;
 263 }
 264
 265 sub access_someuserhost ($) {
 266     my ($some) = @_;
 267     my $user = access_cfg("$some-user",'username');
 268     my $host = access_cfg("$some-host");
 269     return length($user) ? "$user\@$host" : $host;
 270 }
 271
 272 sub access_gituserhost () {
 273     return access_someuserhost('git');
 274 }
 275
 276 sub access_giturl () {
 277     my $url = access_cfg('git-url','RETURN-UNDEF');
 278     if (!defined $url) {
 279         $url =
 280             access_cfg('git-proto').
 281             access_gituserhost().
 282             access_cfg('git-path');
 283     }
 284     return "$url/$package.git";
 285 }
 286
 287 sub parsecontrolfh ($$@) {
 288     my ($fh, $desc, @opts) = @_;
 289     my %opts = ('name' => $desc, @opts);
 290     my $c = Dpkg::Control::Hash->new(%opts);
 291     $c->parse($fh) or die "parsing of $desc failed";
 292     return $c;
 293 }
 294
 295 sub parsecontrol {
 296     my ($file, $desc) = @_;
 297     my $fh = new IO::Handle;
 298     open $fh, '<', $file or die "$file: $!";
 299     my $c = parsecontrolfh($fh,$desc);
 300     $fh->error and die $!;
 301     close $fh;
 302     return $c;
 303 }
 304
 305 sub getfield ($$) {
 306     my ($dctrl,$field) = @_;
 307     my $v = $dctrl->{$field};
 308     return $v if defined $v;
 309     fail "missing field $field in ".$v->get_option('name');
 310 }
 311
 312 sub parsechangelog {
 313     my $c = Dpkg::Control::Hash->new();
 314     my $p = new IO::Handle;
 315     my @cmd = (qw(dpkg-parsechangelog));
 316     open $p, '-|', @cmd or die $!;
 317     $c->parse($p);
 318     $?=0; $!=0; close $p or failedcmd @cmd;
 319     return $c;
 320 }
 321
 322 our %rmad;
 323
 324 sub archive_query ($) {
 325     my ($method) = @_;
 326     my $query = access_cfg('archive-query','RETURN-UNDEF');
 327     if (!defined $query) {
 328         my $distro = access_distro();
 329         if ($distro eq 'debian') {
 330             $query = "sshdakls:".
 331                 access_someuserhost('sshdakls').':'.
 332                 access_cfg('sshdakls-dir');
 333         } else {
 334             $query = "madison:$distro";
 335         }
 336     }
 337     $query =~ s/^(\w+):// or badcfg "invalid archive-query method \`$query'";
 338     my $proto = $1;
 339     my $data = $'; #';
 340     { no strict qw(refs); &{"${method}_${proto}"}($proto,$data); }
 341 }
 342
 343 sub archive_query_madison ($$) {
 344     my ($proto,$data) = @_;
 345     die unless $proto eq 'madison';
 346     $rmad{$package} ||= cmdoutput
 347         qw(rmadison -asource),"-s$isuite","-u$data",$package;
 348     my $rmad = $rmad{$package};
 349     return madison_parse($rmad);
 350 }
 351
 352 sub archive_query_sshdakls ($$) {
 353     my ($proto,$data) = @_;
 354     $data =~ s/:.*// or badcfg "invalid sshdakls method string \`$data'";
 355     my $dakls = cmdoutput
 356         access_cfg('ssh'), $data, qw(dak ls -asource),"-s$isuite",$package;
 357     return madison_parse($dakls);
 358 }
 359
 360 sub canonicalise_suite_sshdakls ($$) {
 361     my ($proto,$data) = @_;
 362     $data =~ m/:/ or badcfg "invalid sshdakls method string \`$data'";
 363     my @cmd =
 364         (access_cfg('ssh'), $`,
 365          "set -e; cd $';".
 366          " if test -h $isuite; then readlink $isuite; exit 0; fi;".
 367          " if test -d $isuite; then echo $isuite; exit 0; fi;".
 368          " exit 1");
 369     my $dakls = cmdoutput @cmd;
 370     failedcmd @cmd unless $dakls =~ m/^\w/;
 371     return $dakls;
 372 }
 373
 374 sub madison_parse ($) {
 375     my ($rmad) = @_;
 376     my @out;
 377     foreach my $l (split /\n/, $rmad) {
 378         $l =~ m{^ \s*( [^ \t|]+ )\s* \|
 379                   \s*( [^ \t|]+ )\s* \|
 380                   \s*( [^ \t|/]+ )(?:/([^ \t|/]+))? \s* \|
 381                   \s*( [^ \t|]+ )\s* }x or die "$rmad $?";
 382         $1 eq $package or die "$rmad $package ?";
 383         my $vsn = $2;
 384         my $newsuite = $3;
 385         my $component;
 386         if (defined $4) {
 387             $component = $4;
 388         } else {
 389             $component = access_cfg('archive-query-default-component');
 390         }
 391         $5 eq 'source' or die "$rmad ?";
 392         my $prefix = substr($package, 0, $package =~ m/^l/ ? 4 : 1);
 393         my $subpath = "/pool/$component/$prefix/$package/${package}_$vsn.dsc";
 394         push @out, [$vsn,$subpath,$newsuite];
 395     }
 396     return sort { -version_compare_string($a->[0],$b->[0]); } @out;
 397 }
 398
 399 sub canonicalise_suite_madison ($$) {
 400     my @r = archive_query_madison($_[0],$_[1]);
 401     @r or fail
 402         "unable to canonicalise suite using package $package".
 403         " which does not appear to exist in suite $isuite;".
 404         " --existing-package may help";
 405     return $r[0][2];
 406 }
 407
 408 sub canonicalise_suite () {
 409     $csuite = archive_query('canonicalise_suite');
 410     if ($isuite ne $csuite) {
 411         # madison canonicalises for us
 412         print "canonical suite name for $isuite is $csuite\n";
 413     }
 414 }
 415
 416 sub get_archive_dsc () {
 417     canonicalise_suite();
 418     my @vsns = archive_query('archive_query');
 419     foreach my $vinfo (@vsns) {
 420         my ($vsn,$subpath) = @$vinfo;
 421         $dscurl = access_cfg('mirror').$subpath;
 422         $dscdata = url_get($dscurl);
 423         next unless defined $dscdata;
 424         $dscurl = access_cfg('mirror').$subpath;
 425         $dscdata = url_get($dscurl);
 426         my $dscfh = new IO::File \$dscdata, '<' or die $!;
 427         print DEBUG Dumper($dscdata) if $debug>1;
 428         $dsc = parsecontrolfh($dscfh,$dscurl, allow_pgp=>1);
 429         print DEBUG Dumper($dsc) if $debug>1;
 430         my $fmt = getfield $dsc, 'Format';
 431         fail "unsupported source format $fmt, sorry" unless $format_ok{$fmt};
 432         return $dsc;
 433     }
 434     return undef;
 435 }
 436
 437 sub check_for_git () {
 438     # returns 0 or 1
 439     my $how = access_cfg('git-check');
 440     if ($how eq 'ssh-cmd') {
 441         my @cmd =
 442             (access_cfg('ssh'),access_gituserhost(),
 443              " set -e; cd ".access_cfg('git-path').";".
 444              " if test -d $package.git; then echo 1; else echo 0; fi");
 445         my $r= cmdoutput @cmd;
 446         failedcmd @cmd unless $r =~ m/^[01]$/;
 447         return $r+0;
 448     } else {
 449         badcfg "unknown git-check \`$how'";
 450     }
 451 }
 452
 453 sub create_remote_git_repo () {
 454     my $how = access_cfg('git-create');
 455     if ($how eq 'ssh-cmd') {
 456         runcmd_ordryrun
 457             (access_cfg('ssh'),access_gituserhost(),
 458              "set -e; cd ".access_cfg('git-path').";".
 459              " mkdir -p $package.git;".
 460              " cd $package.git;".
 461              " if ! test -d objects; then git init --bare; fi");
 462     } else {
 463         badcfg "unknown git-create \`$how'";
 464     }
 465 }
 466
 467 our ($dsc_hash,$upload_hash);
 468
 469 our $ud = '.git/dgit/unpack';
 470
 471 sub prep_ud () {
 472     rmtree($ud);
 473     mkpath '.git/dgit';
 474     mkdir $ud or die $!;
 475 }
 476
 477 sub mktree_in_ud_from_only_subdir () {
 478     # changes into the subdir
 479     my (@dirs) = <*/.>;
 480     die unless @dirs==1;
 481     $dirs[0] =~ m#^([^/]+)/\.$# or die;
 482     my $dir = $1;
 483     chdir $dir or die "$dir $!";
 484     die if stat '.git';
 485     die $! unless $!==&ENOENT;
 486     runcmd qw(git init -q);
 487     rmtree('.git/objects');
 488     symlink '../../../../objects','.git/objects' or die $!;
 489     runcmd @git, qw(add -Af);
 490     my $tree = cmdoutput @git, qw(write-tree);
 491     $tree =~ m/^\w+$/ or die "$tree ?";
 492     return ($tree,$dir);
 493 }
 494
 495 sub dsc_files () {
 496     my $field = $dsc->{'Checksums-Sha256'} || $dsc->{Files};
 497     defined $field or
 498         fail "missing both Checksums-Sha256 and Files in ".
 499         $dsc->get_option('name');
 500     map {
 501         m/^\w+ \d+ (\S+)$/ or
 502             fail "could not parse .dsc Files/Checksums line \`$_'";
 503         $1;
 504     } grep m/\S/, split /\n/, $field;
 505 }
 506
 507 sub is_orig_file ($) {
 508     local ($_) = @_;
 509     m/\.orig(?:-\w+)?\.tar\.\w+$/;
 510 }
 511
 512 sub make_commit ($) {
 513     my ($file) = @_;
 514     return cmdoutput @git, qw(hash-object -w -t commit), $file;
 515 }
 516
 517 sub generate_commit_from_dsc () {
 518     prep_ud();
 519     chdir $ud or die $!;
 520     my @files;
 521     foreach my $f (dsc_files()) {
 522         die "$f ?" if $f =~ m#/|^\.|\.dsc$|\.tmp$#;
 523         push @files, $f;
 524         link "../../../$f", $f
 525             or $!==&ENOENT
 526             or die "$f $!";
 527     }
 528     runcmd @dget, qw(--), $dscurl;
 529     foreach my $f (grep { is_orig_file($_) } @files) {
 530         link $f, "../../../../$f"
 531             or $!==&EEXIST
 532             or die "$f $!";
 533     }
 534     my ($tree,$dir) = mktree_in_ud_from_only_subdir();
 535     runcmd qw(sh -ec), 'dpkg-parsechangelog >../changelog.tmp';
 536     my $clogp = parsecontrol('../changelog.tmp',"commit's changelog");
 537     my $date = cmdoutput qw(date), '+%s %z', qw(-d), getfield($clogp,'Date');
 538     my $author = getfield $clogp, 'Maintainer';
 539     $author =~ s#,.*##ms;
 540     my $authline = "$author $date";
 541     $authline =~ m/^[^<>]+ \<\S+\> \d+ [-+]\d+$/ or
 542         fail "unexpected commit author line format \`$authline'".
 543             " (was generated from changelog Maintainer field)";
 544     my $changes = getfield $clogp, 'Changes';
 545     open C, ">../commit.tmp" or die $!;
 546     print C <<END or die $!;
 547 tree $tree
 548 author $authline
 549 committer $authline
 550
 551 $changes
 552
 553 # imported from the archive
 554 END
 555     close C or die $!;
 556     my $outputhash = make_commit qw(../commit.tmp);
 557     my $cversion = getfield $clogp, 'Version';
 558     print "synthesised git commit from .dsc $cversion\n";
 559     if ($upload_hash) {
 560         runcmd @git, qw(reset --hard), $upload_hash;
 561         runcmd qw(sh -ec), 'dpkg-parsechangelog >>../changelogold.tmp';
 562         my $oldclogp = parsecontrol('../changelogold.tmp','previous changelog');
 563         my $oversion = getfield $oldclogp, 'Version';
 564         my $vcmp =
 565             version_compare_string($oversion, $cversion);
 566         if ($vcmp < 0) {
 567             # git upload/ is earlier vsn than archive, use archive
 568             open C, ">../commit2.tmp" or die $!;
 569             print C <<END or die $!;
 570 tree $tree
 571 parent $upload_hash
 572 parent $outputhash
 573 author $authline
 574 committer $authline
 575
 576 Record $package ($cversion) in archive suite $csuite
 577 END
 578             $outputhash = make_commit qw(../commit2.tmp);
 579         } elsif ($vcmp > 0) {
 580             print STDERR <<END or die $!;
 581
 582 Version actually in archive:    $cversion (older)
 583 Last allegedly pushed/uploaded: $oversion (newer or same)
 584 $later_warning_msg
 585 END
 586             $outputhash = $upload_hash;
 587         } elsif ($outputhash ne $upload_hash) {
 588             fail "version in archive ($cversion)".
 589                 " is same as version in git".
 590                 " to-be-uploaded (upload/) branch ($oversion)".
 591                 " but archive version hash no commit hash?!";
 592         }
 593     }
 594     chdir '../../../..' or die $!;
 595     runcmd @git, qw(update-ref -m),"dgit fetch import $cversion",
 596             'DGIT_ARCHIVE', $outputhash;
 597     cmdoutput @git, qw(log -n2), $outputhash;
 598     # ... gives git a chance to complain if our commit is malformed
 599     rmtree($ud);
 600     return $outputhash;
 601 }
 602
 603 sub ensure_we_have_orig () {
 604     foreach my $f (dsc_files()) {
 605         next unless is_orig_file($f);
 606         if (stat "../$f") {
 607             die "$f ?" unless -f _;
 608         } else {
 609             die "$f $!" unless $!==&ENOENT;
 610         }
 611         my $origurl = $dscurl;
 612         $origurl =~ s{/[^/]+$}{};
 613         $origurl .= "/$f";
 614         die "$f ?" unless $f =~ m/^${package}_/;
 615         die "$f ?" if $f =~ m#/#;
 616         runcmd_ordryrun qw(sh -ec),'cd ..; exec "$@"','x',
 617             @dget,'--',$origurl;
 618     }
 619 }
 620
 621 sub rev_parse ($) {
 622     return cmdoutput @git, qw(rev-parse), "$_[0]~0";
 623 }
 624
 625 sub is_fast_fwd ($$) {
 626     my ($ancestor,$child) = @_;
 627     my $mb = cmdoutput @git, qw(merge-base), $ancestor, $child;
 628     return rev_parse($mb) eq rev_parse($ancestor);
 629 }
 630
 631 sub git_fetch_us () {
 632     badusage "cannot dry run with fetch" if $dryrun;
 633     runcmd @git, qw(fetch),access_giturl(),fetchspec();
 634 }
 635
 636 sub fetch_from_archive () {
 637     # ensures that lrref() is what is actually in the archive,
 638     #  one way or another
 639     get_archive_dsc() or return 0;
 640     $dsc_hash = $dsc->{$ourdscfield};
 641     if (defined $dsc_hash) {
 642         $dsc_hash =~ m/\w+/ or fail "invalid hash in .dsc \`$dsc_hash'";
 643         $dsc_hash = $&;
 644         print "last upload to archive specified git hash\n";
 645     } else {
 646         print "last upload to archive has NO git hash\n";
 647     }
 648
 649     my $lrref_fn = ".git/".lrref();
 650     if (open H, $lrref_fn) {
 651         $upload_hash = <H>;
 652         chomp $upload_hash;
 653         die "$lrref_fn $upload_hash ?" unless $upload_hash =~ m/^\w+$/;
 654     } elsif ($! == &ENOENT) {
 655         $upload_hash = '';
 656     } else {
 657         die "$lrref_fn $!";
 658     }
 659     print DEBUG "previous reference hash=$upload_hash\n";
 660     my $hash;
 661     if (defined $dsc_hash) {
 662         fail "missing git history even though dsc has hash -".
 663             " could not find commit $dsc_hash".
 664             " (should be in ".access_giturl()."#".rref().")"
 665             unless $upload_hash;
 666         $hash = $dsc_hash;
 667         ensure_we_have_orig();
 668         if (is_fast_fwd($dsc_hash,$upload_hash)) {
 669             print STDERR <<END or die $!;
 670
 671 Git commit in archive is behind the last version allegedly pushed/uploaded.
 672 Commit referred to by archive:  $dsc_hash
 673 Last allegedly pushed/uploaded: $upload_hash
 674 $later_warning_msg
 675 END
 676             $hash = $upload_hash;
 677         }
 678     } else {
 679         $hash = generate_commit_from_dsc();
 680     }
 681     print DEBUG "current hash=$hash\n";
 682     if ($upload_hash) {
 683         fail "not fast forward on last upload branch!".
 684             " (archive's version left in DGIT_ARCHIVE)"
 685             unless is_fast_fwd($upload_hash, $hash);
 686     }
 687     if ($upload_hash ne $hash) {
 688         my @upd_cmd = (@git, qw(update-ref -m), 'dgit fetch', lrref(), $hash);
 689         if (!$dryrun) {
 690             cmdoutput @upd_cmd;
 691         } else {
 692             dryrun_report @upd_cmd;
 693         }
 694     }
 695     return 1;
 696 }
 697
 698 sub clone ($) {
 699     my ($dstdir) = @_;
 700     canonicalise_suite();
 701     badusage "dry run makes no sense with clone" if $dryrun;
 702     mkdir $dstdir or die "$dstdir $!";
 703     chdir "$dstdir" or die "$dstdir $!";
 704     runcmd @git, qw(init -q);
 705     runcmd @git, qw(config), "remote.$remotename.fetch", fetchspec();
 706     open H, "> .git/HEAD" or die $!;
 707     print H "ref: ".lref()."\n" or die $!;
 708     close H or die $!;
 709     runcmd @git, qw(remote add), 'origin', access_giturl();
 710     if (check_for_git()) {
 711         print "fetching existing git history\n";
 712         git_fetch_us();
 713         runcmd @git, qw(fetch origin);
 714     } else {
 715         print "starting new git history\n";
 716     }
 717     fetch_from_archive() or no_such_package;
 718     runcmd @git, qw(reset --hard), lrref();
 719     printdone "ready for work in $dstdir";
 720 }
 721
 722 sub fetch () {
 723     if (check_for_git()) {
 724         git_fetch_us();
 725     }
 726     fetch_from_archive() or no_such_package();
 727     printdone "fetched into ".lrref();
 728 }
 729
 730 sub pull () {
 731     fetch();
 732     runcmd_ordryrun @git, qw(merge -m),"Merge from $csuite [dgit]",
 733         lrref();
 734     printdone "fetched to ".lrref()." and merged into HEAD";
 735 }
 736
 737 sub check_not_dirty () {
 738     my @cmd = (@git, qw(diff --quiet HEAD));
 739     printcmd(\*DEBUG,"+",@cmd) if $debug>0;
 740     $!=0; $?=0; system @cmd;
 741     return if !$! && !$?;
 742     if (!$! && $?==256) {
 743         fail "working tree is dirty (does not match HEAD)";
 744     } else {
 745         failedcmd @cmd;
 746     }
 747 }
 748
 749 sub commit_quilty_patch ($) {
 750     my ($vsn) = @_;
 751     my $output = cmdoutput @git, qw(status --porcelain);
 752     my %fixups = map {$_=>1}
 753         (".pc/debian-changes-$vsn/","debian/patches/debian-changes-$vsn");
 754     my @files;
 755     foreach my $l (split /\n/, $output) {
 756         next unless $l =~ s/^\?\? //;
 757         next unless $fixups{$l};
 758         push @files, $l;
 759     }
 760     print DEBUG "checking for quilty\n", Dumper(\@files);
 761     if (@files == 2) {
 762         my $m = "Commit Debian 3.0 (quilt) metadata";
 763         print "$m\n";
 764         runcmd_ordryrun @git, qw(add), @files;
 765         runcmd_ordryrun @git, qw(commit -m), $m;
 766     }
 767 }
 768
 769 sub dopush () {
 770     print DEBUG "actually entering push\n";
 771     my $clogp = parsechangelog();
 772     $package = getfield $clogp, 'Source';
 773     my $cversion = getfield $clogp, 'Version';
 774     my $dscfn = dscfn($cversion);
 775     stat "../$dscfn" or
 776         fail "looked for .dsc $dscfn, but $!;".
 777             " maybe you forgot to build";
 778     $dsc = parsecontrol("../$dscfn","$dscfn");
 779     my $dscpackage = getfield $dsc, 'Source';
 780     my $format = getfield $dsc, 'Format';
 781     my $dversion = getfield $dsc, 'Version';
 782     ($dscpackage eq $package && $dversion eq $cversion) or
 783         fail "$dsc is for $dscpackage $dversion".
 784             " but debian/changelog is for $package $cversion";
 785     print DEBUG "format $format\n";
 786     if ($format eq '3.0 (quilt)') {
 787         print "Format \`$format', urgh\n";
 788         commit_quilty_patch($dversion);
 789     }
 790     check_not_dirty();
 791     prep_ud();
 792     chdir $ud or die $!;
 793     print "checking that $dscfn corresponds to HEAD\n";
 794     runcmd qw(dpkg-source -x --), "../../../../$dscfn";
 795     my ($tree,$dir) = mktree_in_ud_from_only_subdir();
 796     chdir '../../../..' or die $!;
 797     printcmd \*DEBUG,"+",@_;
 798     my @diffcmd = (@git, qw(diff --exit-code), $tree);
 799     $!=0; $?=0;
 800     if (system @diffcmd) {
 801         if ($! && $?==256) {
 802             fail "$dscfn specifies a different tree to your HEAD commit;".
 803                 " perhaps you forgot to build";
 804         } else {
 805             failedcmd @diffcmd;
 806         }
 807     }
 808 #fetch from alioth
 809 #do fast forward check and maybe fake merge
 810 #    if (!is_fast_fwd(mainbranch
 811 #    runcmd @git, qw(fetch -p ), "$alioth_git/$package.git",
 812 #        map { lref($_).":".rref($_) }
 813 #        (uploadbranch());
 814     $dsc->{$ourdscfield} = rev_parse('HEAD');
 815     $dsc->save("../$dscfn.tmp") or die $!;
 816     if (!$changesfile) {
 817         my $multi = "../${package}_${cversion}_multi.changes";
 818         if (stat "$multi") {
 819             $changesfile = $multi;
 820         } else {
 821             $!==&ENOENT or die "$multi: $!";
 822             my $pat = "${package}_${cversion}_*.changes";
 823             my @cs = glob "../$pat";
 824             fail "failed to find unique changes file".
 825                 " (looked for $pat in .., or $multi);".
 826                 " perhaps you need to use dgit -C"
 827                 unless @cs==1;
 828             ($changesfile) = @cs;
 829         }
 830     }
 831     my $tag = debiantag($dversion);
 832     if (!check_for_git()) {
 833         create_remote_git_repo();
 834     }
 835     runcmd_ordryrun @git, qw(push),access_giturl(),"HEAD:".rrref();
 836     if (!$dryrun) {
 837         rename "../$dscfn.tmp","../$dscfn" or die "$dscfn $!";
 838     } else {
 839         print "[new .dsc left in $dscfn.tmp]\n";
 840     }
 841     if ($sign) {
 842         if (!defined $keyid) {
 843             $keyid = access_cfg('keyid','RETURN-UNDEF');
 844         }
 845         my @tag_cmd = (@git, qw(tag -s -m),
 846                        "Release $dversion for $csuite [dgit]");
 847         push @tag_cmd, qw(-u),$keyid if defined $keyid;
 848         push @tag_cmd, $tag;
 849         runcmd_ordryrun @tag_cmd;
 850         my @debsign_cmd = @debsign;
 851         push @debsign_cmd, "-k$keyid" if defined $keyid;
 852         push @debsign_cmd, $changesfile;
 853         runcmd_ordryrun @debsign_cmd;
 854     }
 855     runcmd_ordryrun @git, qw(push),access_giturl(),"refs/tags/$tag";
 856     my $host = access_cfg('upload-host','RETURN-UNDEF');
 857     my @hostarg = defined($host) ? ($host,) : ();
 858     runcmd_ordryrun @dput, @hostarg, $changesfile;
 859     printdone "pushed and uploaded $dversion";
 860 }
 861
 862 sub cmd_clone {
 863     parseopts();
 864     my $dstdir;
 865     badusage "-p is not allowed with clone; specify as argument instead"
 866         if defined $package;
 867     if (@ARGV==1) {
 868         ($package) = @ARGV;
 869     } elsif (@ARGV==2 && $ARGV[1] =~ m#^\w#) {
 870         ($package,$isuite) = @ARGV;
 871     } elsif (@ARGV==2 && $ARGV[1] =~ m#^[./]#) {
 872         ($package,$dstdir) = @ARGV;
 873     } elsif (@ARGV==3) {
 874         ($package,$isuite,$dstdir) = @ARGV;
 875     } else {
 876         badusage "incorrect arguments to dgit clone";
 877     }
 878     $dstdir ||= "$package";
 879     clone($dstdir);
 880 }
 881
 882 sub branchsuite () {
 883     my $branch = cmdoutput_errok @git, qw(symbolic-ref HEAD);
 884     if ($branch =~ m#$lbranch_re#o) {
 885         return $1;
 886     } else {
 887         return undef;
 888     }
 889 }
 890
 891 sub fetchpullargs () {
 892     if (!defined $package) {
 893         my $sourcep = parsecontrol('debian/control','debian/control');
 894         $package = getfield $sourcep, 'Source';
 895     }
 896     if (@ARGV==0) {
 897 #       $isuite = branchsuite();  # this doesn't work because dak hates canons
 898         if (!$isuite) {
 899             my $clogp = parsechangelog();
 900             $isuite = getfield $clogp, 'Distribution';
 901         }
 902         canonicalise_suite();
 903         print "fetching from suite $csuite\n";
 904     } elsif (@ARGV==1) {
 905         ($isuite) = @ARGV;
 906         canonicalise_suite();
 907     } else {
 908         badusage "incorrect arguments to dgit fetch or dgit pull";
 909     }
 910 }
 911
 912 sub cmd_fetch {
 913     parseopts();
 914     fetchpullargs();
 915     fetch();
 916 }
 917
 918 sub cmd_pull {
 919     parseopts();
 920     fetchpullargs();
 921     pull();
 922 }
 923
 924 sub cmd_push {
 925     parseopts();
 926     badusage "-p is not allowed with dgit push" if defined $package;
 927     runcmd @git, qw(diff --quiet HEAD);
 928     my $clogp = parsechangelog();
 929     $package = getfield $clogp, 'Source';
 930     if (@ARGV==0) {
 931         $isuite = getfield $clogp, 'Distribution';
 932         if ($new_package) {
 933             local ($package) = $existing_package; # this is a hack
 934             canonicalise_suite();
 935         }
 936     } else {
 937         badusage "incorrect arguments to dgit push";
 938     }
 939     if (fetch_from_archive()) {
 940         is_fast_fwd(lrref(), 'HEAD') or die;
 941     } else {
 942         $new_package or
 943             fail "package appears to be new in this suite;".
 944                 " if this is intentional, use --new";
 945     }
 946     dopush();
 947 }
 948
 949 sub cmd_build {
 950     # we pass further options and args to git-buildpackage
 951     badusage "-p is not allowed with dgit build" if defined $package;
 952     my $clogp = parsechangelog();
 953     $isuite = getfield $clogp, 'Distribution';
 954     $package = getfield $clogp, 'Source';
 955     my @cmd =
 956         (qw(git-buildpackage -us -uc --git-no-sign-tags),
 957          "--git-builder=@dpkgbuildpackage");
 958     unless (grep { m/^--git-debian-branch/ } @ARGV) {
 959         canonicalise_suite();
 960         push @cmd, "--git-debian-branch=".lbranch();
 961     }
 962     runcmd_ordryrun @cmd, @ARGV;
 963     printdone "build successful\n";
 964 }
 965
 966 sub cmd_sbuild {
 967     check_not_dirty();
 968     badusage "-p is not allowed with dgit sbuild" if defined $package;
 969     my $clogp = parsechangelog();
 970     $package = getfield $clogp, 'Source';
 971     my $isuite = getfield $clogp, 'Distribution';
 972     my $version = getfield $clogp, 'Version';
 973     runcmd_ordryrun (@dpkgbuildpackage, qw(-us -uc -S));
 974     chdir ".." or die $!;
 975     my $sourcechanges = "${package}_${version}_source.changes";
 976     my $dscfn = dscfn($version);
 977     my $pat = "${package}_${version}_*.changes";
 978     if (!$dryrun) {
 979         stat $dscfn or fail "$dscfn (in parent directory): $!";
 980         stat $sourcechanges or fail "$sourcechanges (in parent directory): $!";
 981         foreach my $cf (glob $pat) {
 982             next if $cf eq $sourcechanges;
 983             unlink $cf or fail "remove $cf: $!";
 984         }
 985     }
 986     runcmd_ordryrun @sbuild, @ARGV, qw(-d), $isuite, $dscfn;
 987     runcmd_ordryrun @mergechanges, glob $pat;
 988     my $multichanges = "${package}_${version}_multi.changes";
 989     if (!$dryrun) {
 990         stat $multichanges or fail "$multichanges: $!";
 991     }
 992     printdone "build successful, results in $multichanges\n" or die $!;
 993 }
 994
 995 sub cmd_quilt_fixup {
 996     badusage "incorrect arguments to dgit quilt-fixup";
 997     my $clogp = parsechangelog();
 998     commit_quilty_patch((getfield $clogp, 'Version'));
 999 }
1000
1001 sub parseopts () {
1002     my $om;
1003     while (@ARGV) {
1004         last unless $ARGV[0] =~ m/^-/;
1005         $_ = shift @ARGV;
1006         last if m/^--?$/;
1007         if (m/^--/) {
1008             if (m/^--dry-run$/) {
1009                 $dryrun=1;
1010             } elsif (m/^--no-sign$/) {
1011                 $sign=0;
1012             } elsif (m/^--help$/) {
1013                 helponly();
1014             } elsif (m/^--new$/) {
1015                 $new_package=1;
1016             } elsif (m/^--(\w+)=(.*)/s && ($om = $opts_opt_map{$1})) {
1017                 $om->[0] = $2;
1018             } elsif (m/^--(\w+):(.*)/s && ($om = $opts_opt_map{$1})) {
1019                 push @$om, $2;
1020             } elsif (m/^--existing-package=(.*)/s) {
1021                 $existing_package = $1;
1022             } elsif (m/^--distro=(.*)/s) {
1023                 $idistro = $1;
1024             } else {
1025                 badusage "unknown long option \`$_'";
1026             }
1027         } else {
1028             while (m/^-./s) {
1029                 if (s/^-n/-/) {
1030                     $dryrun=1;
1031                 } elsif (s/^-h/-/) {
1032                     helponly();
1033                 } elsif (s/^-D/-/) {
1034                     open DEBUG, ">&STDERR" or die $!;
1035                     $debug++;
1036                 } elsif (s/^-N/-/) {
1037                     $new_package=1;
1038                 } elsif (s/^-c(.*=.*)//s) {
1039                     push @git, '-c', $1;
1040                 } elsif (s/^-d(.*)//s) {
1041                     $idistro = $1;
1042                 } elsif (s/^-C(.*)//s) {
1043                     $changesfile = $1;
1044                 } elsif (s/^-k(.*)//s) {
1045                     $keyid=$1;
1046                 } else {
1047                     badusage "unknown short option \`$_'";
1048                 }
1049             }
1050         }
1051     }
1052 }
1053
1054 parseopts();
1055 print STDERR "DRY RUN ONLY\n" if $dryrun;
1056 if (!@ARGV) {
1057     print STDERR $helpmsg or die $!;
1058     exit 8;
1059 }
1060 my $cmd = shift @ARGV;
1061 $cmd =~ y/-/_/;
1062 { no strict qw(refs); &{"cmd_$cmd"}(); }