← Back to branch summary

~ubuntu-branches/ubuntu/karmic/sbuild/karmic-proposed

« back to all changes in this revision

Viewing changes to bin/buildd-uploader

  • Committer: Bazaar Package Importer
  • Author(s): Roger Leigh, Roger Leigh
  • Date: 2009-05-17 15:52:53 UTC
  • mfrom: (8.1.7 upstream) (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090517155253-fbxadfsyaf940ete
Tags: 0.58.3-1
http://bugs.debian.org/475777
http://bugs.debian.org/523670
http://bugs.debian.org/524564
http://bugs.debian.org/520158
[ Roger Leigh ]
* New release.
* debian/control:
  - Update to Standards Version 3.8.1.
  - Add buildd package.
  - Add libsbuild-perl package.
  - All packages depend upon libsbuild-perl.
* Add support for appending a tag to version numbers (Closes: #475777).
  Thanks to Timothy G Abbott for this patch.
* When using the --help or --version options, don't abort if not
  in the sbuild group (Closes: #523670).  Group membership is now
  only performed after options parsing, and only if required.
* Allow config files to use $HOME (Closes: #524564).  Thanks to
  James Vega for this patch.
* Restore buildd package.
* Split common library functions into new libsbuild-perl package.
* debian/sbuild.(preinst|postinst|postrm):
  - Remove special cases for versions older than oldstable.  Update
    addition and removal of sbuild group to use return value of getent
    rather than parsing getent output.
  - Use addgroup/delgroup in place of adduser/deluser.
  - Use --system when adding and deleting group, to ensure creation
    of a system group.  Migrate existing non-system group and group
    members if the system group is not present.
  - Handle removal of 50sbuild setup script.
* debian/buildd.(preinst|postinst|postrm): Add maintainer scripts for
  buildd package.  Move configuration file from /etc/buildd.conf to
  /etc/buildd/buildd.conf if present.  Also create buildd user and
  group for running the buildd daemon.
* Sbuild::Conf: Don't default MAINTAINER_NAME to $DEBEMAIL if unset
  in the configuration file (Closes: #520158).
* /etc/schroot/setup.d/50sbuild: Remove.  The setup tasks performed by
  this script are now handled internally by sbuild.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bin/buildd-uploader
2
2
#
3
3
# buildd-uploader: upload finished packages for buildd
4
4
# Copyright © 1998 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
 
5
# Copyright © 2009 Roger Leigh <rleigh@debian.org>
5
6
# Copyright © 2005 Ryan Murray <rmurray@debian.org>
6
7
#
7
8
# This program is free software: you can redistribute it and/or modify
20
21
#
21
22
#######################################################################
22
23
 
23
 
BEGIN {
24
 
    ($main::HOME = $ENV{'HOME'})
25
 
        or die "HOME not defined in environment!\n";
26
 
}
27
 
 
28
24
use strict;
29
25
use warnings;
30
 
use Buildd;
 
26
 
 
27
use Buildd qw(open_log close_log lock_file unlock_file);
31
28
use Buildd::Conf;
32
 
 
33
 
Buildd::Conf::init();
34
 
 
35
 
sub uploaded ($@);
36
 
sub upload ($$);
37
 
sub do_dupload ($@);
38
 
 
39
 
unset_env();
40
 
 
41
 
$Buildd::Conf::dupload_to ||= "anonymous-ftp-master";
42
 
$Buildd::Conf::dupload_to_security ||= "security";
43
 
 
44
 
my $log_locked = 0;
45
 
my $locked = 0;
46
 
END { unlock_file( "$main::HOME/daemon.log" ) if $log_locked;
47
 
      unlock_file( "$main::HOME/buildd-uploader" ) if $locked; }
48
 
 
49
 
lock_file( "$main::HOME/daemon.log" );
50
 
$log_locked = 1;
51
 
 
52
 
open_log();
53
 
 
54
 
if (lock_file( "$main::HOME/buildd-uploader", 1 ) == 0) {
55
 
    logger( "exiting; another buildd-uploader is still running" );
56
 
    exit 1;
57
 
}
58
 
$locked = 1;
59
 
 
60
 
my %uploaded_pkgs;
61
 
 
62
 
upload( "upload-security", $Buildd::Conf::dupload_to_security );
63
 
upload( "upload", $Buildd::Conf::dupload_to );
64
 
 
65
 
foreach my $dist (keys %uploaded_pkgs) {
66
 
    logger( "Set to Uploaded($dist):$uploaded_pkgs{$dist}" );
67
 
}
68
 
 
69
 
exit 0;
70
 
 
71
 
sub uploaded ($@) {
72
 
    my $pkg = shift;
73
 
    my @propagated_pkgs = ();
74
 
    foreach my $dist (@_) {
75
 
        my $msgs = "";
76
 
        if (open( PIPE, "$Buildd::Conf::sshcmd wanna-build --uploaded --user=$Buildd::Conf::wanna_build_user ".
77
 
                  ($Buildd::Conf::wanna_build_dbbase?"--database=$Buildd::Conf::wanna_build_dbbase ":"").
78
 
                  "--no-down-propagation --dist=$dist ".
79
 
                  "$pkg 2>&1 |" )) {
80
 
            while( <PIPE> ) {
81
 
                if (/^(\S+): Propagating new state /) {
82
 
                    push( @propagated_pkgs, $1 );
83
 
                }
84
 
                elsif (/^(\S+): already uploaded/ &&
85
 
                       Buildd::isin( $1, @propagated_pkgs )) {
86
 
                    # be quiet on this
87
 
                }
88
 
                else {
89
 
                    $msgs .= $_;
90
 
                }
91
 
            }
92
 
            close( PIPE );
93
 
            if ($msgs or $?) {
94
 
                lock_file( "$main::HOME/daemon.log" );
95
 
                $log_locked = 1;
96
 
                logger( $msgs ) if $msgs;
97
 
                logger( "uploaded-build failed with status ", exitstatus($?), "\n" )
98
 
                    if $?;
99
 
                unlock_file( "$main::HOME/daemon.log" );
100
 
                $log_locked = 0;
101
 
            } else {
102
 
                $uploaded_pkgs{$dist} .= " $pkg";
103
 
            }
104
 
        }
105
 
        else {
106
 
            lock_file( "$main::HOME/daemon.log" );
107
 
            $log_locked = 1;
108
 
            logger( "Cannot spawn uploaded-build: $!\n" );
109
 
            unlock_file( "$main::HOME/daemon.log" );
110
 
            $log_locked = 0;
111
 
        }
112
 
    }
113
 
}
114
 
 
115
 
sub upload ($$) {
116
 
    my $udir = shift;
117
 
    my $upload_to = shift;
118
 
 
119
 
    chdir( "$main::HOME/$udir" ) || return;
120
 
    lock_file( "$main::HOME/$udir" );
121
 
 
122
 
    my( $f, $g, @before, @after );
123
 
    foreach $f (<*.changes>) {
124
 
        ($g = $f) =~ s/\.changes$/\.upload/;
125
 
        push( @before, $f ) if ! -f $g;
126
 
    }
127
 
 
128
 
    unlock_file( "$main::HOME/$udir" );
129
 
 
130
 
    if (!@before) {
131
 
        logger( "Nothing to do for $udir\n" );
132
 
        return;
133
 
    }
134
 
 
135
 
    logger( scalar(@before), " jobs to upload in $udir: @before\n" );
136
 
    unlock_file( "$main::HOME/daemon.log" );
137
 
    $log_locked = 0;
138
 
 
139
 
    foreach $f (@before) {
140
 
        ($g = $f) =~ s/\.changes$/\.upload/;
141
 
        my $logref = do_dupload( $upload_to, $f );
142
 
 
143
 
        if (defined $logref and scalar(@$logref) > 0) {
144
 
            my $line;
145
 
 
146
 
            lock_file( "$main::HOME/daemon.log" );
147
 
            $log_locked = 1;
148
 
 
149
 
            foreach $line (@$logref) {
150
 
                logger $line;
151
 
            }
152
 
            unlock_file( "$main::HOME/daemon.log" );
153
 
            $log_locked = 0;
154
 
        }
155
 
 
156
 
        if ( -f $g ) {
157
 
            if (!open( F, "<$f" )) {
158
 
                logger( "Cannot open $f: $!\n" );
159
 
                next;
160
 
            }
161
 
            my $text;
162
 
            { local($/); undef $/; $text = <F>; }
163
 
            close( F );
164
 
            if ($text !~ /^Distribution:\s*(.*)\s*$/m) {
165
 
                lock_file( "$main::HOME/daemon.log" );
166
 
                $log_locked = 1;
167
 
                logger( "$f doesn't have a Distribution: field\n" );
168
 
                unlock_file( "$main::HOME/daemon.log" );
169
 
                $log_locked = 0;
170
 
                next;
171
 
            }
172
 
            my @dists = split( /\s+/, $1 );
173
 
            my ($version,$source,$pkg);
174
 
            if ($text =~ /^Version:\s*(\S+)\s*$/m) {
175
 
                $version = $1;
176
 
            }
177
 
            if ($text =~ /^Source:\s*(\S+)(?:\s+\(\S+\))?\s*$/m) {
178
 
                $source = $1;
179
 
            }
180
 
            if (defined($version) and defined($source)) {
181
 
                $pkg = "${source}_$version";
182
 
            } else {
183
 
                ($pkg = $f) =~ s/_\S+\.changes$//;
184
 
            }
185
 
            uploaded($pkg,@dists);
186
 
        } else {
187
 
            push (@after, $f);
188
 
        }
189
 
    }
190
 
 
191
 
    lock_file( "$main::HOME/daemon.log" );
192
 
    $log_locked = 1;
193
 
    if (@after) {
194
 
        logger( "The following jobs were not processed (successfully):\n".
195
 
                "@after\n" );
196
 
    }
197
 
    else {
198
 
        logger( "dupload successful.\n" );
199
 
    }
200
 
    write_stats( "uploads", scalar(@before) - scalar(@after) );
201
 
}
202
 
 
203
 
sub do_dupload ($@) {
204
 
    my $upload_to = shift;
205
 
    my @jobs = @_;
206
 
    my @log;
207
 
    local( *PIPE );
208
 
    my( $current_job, $current_file, @failed, $errs );
209
 
 
210
 
    if (!open( PIPE, "dupload -k --to $upload_to @jobs </dev/null 2>&1 |" )) {
211
 
        return "Cannot spawn dupload: $!";
212
 
    }
213
 
 
214
 
    my $dup_log = "";
215
 
    while( <PIPE> ) {
216
 
        $dup_log .= $_;
217
 
        chomp;
218
 
        if (/^\[ job \S+ from (\S+\.changes)$/) {
219
 
            $current_job = $1;
220
 
        }
221
 
        elsif (/^warning: MD5sum mismatch for (\S+), skipping/i) {
222
 
            my $f = $1;
223
 
            push( @log, "dupload error: md5sum mismatch for $f\n" );
224
 
            $errs .= "md5sum mismatch on file $f ($current_job)\n";
225
 
            push( @failed, $current_job );
226
 
        }
227
 
        elsif (/^\[ Uploading job (\S+)$/) {
228
 
            $current_job = "$1.changes";
229
 
        }
230
 
        elsif (/dupload fatal error: Can't upload (\S+)/i ||
231
 
               /^\s(\S+).*scp: (.*)$/) {
232
 
            my($f, $e) = ($1, $2);
233
 
            push( @log, "dupload error: upload error for $f\n" );
234
 
            push( @log, "($e)\n" ) if $e;
235
 
            $errs .= "upload error on file $f ($current_job)\n";
236
 
            push( @failed, $current_job );
237
 
        }
238
 
        elsif (/Timeout at [\S]+ line [\d]+$/) {
239
 
            $errs .= "upload timeout on file $current_job\n";
240
 
            push( @failed, $current_job );
241
 
        }
242
 
        elsif (/^\s(\S+)\s+[\d.]+ kB /) {
243
 
            $current_file = $1;
244
 
        }
245
 
    }
246
 
    close( PIPE );
247
 
    if ($?) {
248
 
        if (($? >> 8) == 141) {
249
 
            push( @log, "dupload error: SIGPIPE (broken connection)\n" );
250
 
            $errs .= "upload error (broken connection) during ".
251
 
                "file $current_file ($current_job)\n";
252
 
            push( @failed, $current_job );
253
 
        }
254
 
        else {
255
 
            push( @log, "dupload exit status ". exitstatus($?)  );
256
 
            $errs .= "dupload exit status ".exitstatus($?)."\n";
257
 
            push( @failed, $current_job );
258
 
        }
259
 
    }
260
 
 
261
 
    foreach (@failed) {
262
 
        my $u;
263
 
        ($u = $_) =~ s/\.changes$/\.upload/;
264
 
        unlink( $u );
265
 
        push( @log, "Removed $u due to upload errors.\n" );
266
 
        $errs .= "Removed $u to reupload later.\n";
267
 
    }
268
 
 
269
 
    if ($errs) {
270
 
        $errs .= "\nComplete output from dupload:\n\n$dup_log";
271
 
        send_mail( $Buildd::Conf::admin_mail, "dupload errors", $errs );
272
 
    }
273
 
    return \@log;
 
29
use Buildd::Uploader;
 
30
use Sbuild::OptionsBase;
 
31
 
 
32
my $conf = Buildd::Conf->new();
 
33
exit 1 if !defined($conf);
 
34
my $options = Sbuild::OptionsBase->new($conf, "buildd-uploader", "1");
 
35
exit 1 if !defined($options);
 
36
my $uploader = Buildd::Uploader->new($conf);
 
37
exit 1 if !defined($uploader);
 
38
 
 
39
my $log = open_log($uploader->get('Config'));
 
40
$uploader->set('Log Stream', $log);
 
41
 
 
42
my $status = $uploader->run();
 
43
 
 
44
close_log($conf);
 
45
 
 
46
exit $status;
 
47
 
 
48
END {
 
49
    unlock_file($conf->get('HOME') . "/buildd-uploader")
 
50
        if (defined($conf) &&
 
51
            defined($uploader) &&
 
52
            defined($uploader->get('Uploader Lock')));
274
53
}