diff options
Diffstat (limited to 'lib/Sbuild/Build.pm')
| -rw-r--r-- | lib/Sbuild/Build.pm | 3686 |
1 files changed, 3686 insertions, 0 deletions
diff --git a/lib/Sbuild/Build.pm b/lib/Sbuild/Build.pm new file mode 100644 index 0000000..cca1c89 --- /dev/null +++ b/lib/Sbuild/Build.pm @@ -0,0 +1,3686 @@ +# +# Build.pm: build library for sbuild +# Copyright © 2005 Ryan Murray <rmurray@debian.org> +# Copyright © 2005-2010 Roger Leigh <rleigh@debian.org> +# Copyright © 2008 Simon McVittie <smcv@debian.org> +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. +# +####################################################################### + +package Sbuild::Build; + +use strict; +use warnings; + +use English; +use POSIX; +use Errno qw(:POSIX); +use Fcntl; +use File::Temp qw(mkdtemp); +use File::Basename qw(basename dirname); +use File::Path qw(make_path); +use FileHandle; +use File::Copy qw(); # copy is already exported from Sbuild, so don't export + # anything. +use Dpkg::Arch; +use Dpkg::Control; +use Dpkg::Index; +use Dpkg::Version; +use Dpkg::Deps qw(deps_concat deps_parse); +use Dpkg::Changelog::Debian; +use Scalar::Util 'refaddr'; + +use MIME::Lite; +use Term::ANSIColor; + +use Sbuild qw($devnull binNMU_version copy isin debug send_mail + dsc_files dsc_pkgver strftime_c); +use Sbuild::Base; +use Sbuild::ChrootInfoSchroot; +use Sbuild::ChrootInfoUnshare; +use Sbuild::ChrootInfoSudo; +use Sbuild::ChrootInfoAutopkgtest; +use Sbuild::ChrootRoot; +use Sbuild::Sysconfig qw($version $release_date); +use Sbuild::Sysconfig; +use Sbuild::Resolver qw(get_resolver); +use Sbuild::Exception; + +use version; + +BEGIN { + use Exporter (); + our (@ISA, @EXPORT); + + @ISA = qw(Exporter Sbuild::Base); + + @EXPORT = qw(); +} + +our $saved_stdout = undef; +our $saved_stderr = undef; + +sub new { + my $class = shift; + my $dsc = shift; + my $conf = shift; + + my $self = $class->SUPER::new($conf); + bless($self, $class); + + $self->set('ABORT', undef); + $self->set('Job', $dsc); + $self->set('Build Dir', ''); + $self->set('Max Lock Trys', 120); + $self->set('Lock Interval', 5); + $self->set('Pkg Status', 'pending'); + $self->set('Pkg Status Trigger', undef); + $self->set('Pkg Start Time', 0); + $self->set('Pkg End Time', 0); + $self->set('Pkg Fail Stage', 'init'); + $self->set('Build Start Time', 0); + $self->set('Build End Time', 0); + $self->set('Install Start Time', 0); + $self->set('Install End Time', 0); + $self->set('This Time', 0); + $self->set('This Space', 0); + $self->set('Sub Task', 'initialisation'); + $self->set('Host', Sbuild::ChrootRoot->new($self->get('Config'))); + # Host execution defaults + my $host_defaults = $self->get('Host')->get('Defaults'); + $host_defaults->{'USER'} = $self->get_conf('USERNAME'); + $host_defaults->{'DIR'} = $self->get_conf('HOME'); + $host_defaults->{'STREAMIN'} = $devnull; + $host_defaults->{'ENV'}->{'LC_ALL'} = 'C.UTF-8'; + $host_defaults->{'ENV'}->{'SHELL'} = '/bin/sh'; + $host_defaults->{'ENV_FILTER'} = $self->get_conf('ENVIRONMENT_FILTER'); + # Note, this should never fail. But, we should handle failure anyway. + $self->get('Host')->begin_session(); + + $self->set('Session', undef); + $self->set('Dependency Resolver', undef); + $self->set('Log File', undef); + $self->set('Log Stream', undef); + $self->set('Summary Stats', {}); + $self->set('dpkg-buildpackage pid', undef); + $self->set('Dpkg Version', undef); + + # DSC, package and version information: + $self->set_dsc($dsc); + + # If the job name contains an underscore then it is either the filename of + # a dsc or a pkgname_version string. In both cases we can already extract + # the version number. Otherwise it is a bare source package name and the + # version will initially be unknown. + if ($dsc =~ m/_/) { + $self->set_version($dsc); + } else { + $self->set('Package', $dsc); + } + + return $self; +} + +sub request_abort { + my $self = shift; + my $reason = shift; + + $self->log_error("ABORT: $reason (requesting cleanup and shutdown)\n"); + $self->set('ABORT', $reason); + + # Send signal to dpkg-buildpackage immediately if it's running. + if (defined $self->get('dpkg-buildpackage pid')) { + # Handling ABORT in the loop reading from the stdout/stderr output of + # dpkg-buildpackage is suboptimal because then the ABORT signal would + # only be handled once the build process writes to stdout or stderr + # which might not be immediately. + my $pid = $self->get('dpkg-buildpackage pid'); + # Sending the pid negated to send to the whole process group. + kill "TERM", -$pid; + } +} + +sub check_abort { + my $self = shift; + + if ($self->get('ABORT')) { + Sbuild::Exception::Build->throw(error => "Aborting build: " . + $self->get('ABORT'), + failstage => "abort"); + } +} + +sub set_dsc { + my $self = shift; + my $dsc = shift; + + debug("Setting DSC: $dsc\n"); + + $self->set('DSC', $dsc); + $self->set('Source Dir', dirname($dsc)); + $self->set('DSC Base', basename($dsc)); + + debug("DSC = " . $self->get('DSC') . "\n"); + debug("Source Dir = " . $self->get('Source Dir') . "\n"); + debug("DSC Base = " . $self->get('DSC Base') . "\n"); +} + +sub set_version { + my $self = shift; + my $pkgv = shift; + + debug("Setting package version: $pkgv\n"); + + my ($pkg, $version); + if (-f $pkgv && -r $pkgv) { + ($pkg, $version) = dsc_pkgver($pkgv); + } else { + ($pkg, $version) = split /_/, $pkgv; + } + my $pver = Dpkg::Version->new($version, check => 1); + return if (!defined($pkg) || !defined($version) || !defined($pver)); + my ($o_version); + $o_version = $pver->version(); + + # Original version (no binNMU or other addition) + my $oversion = $version; + # Original version with stripped epoch + my $osversion = $o_version; + $osversion .= '-' . $pver->revision() unless $pver->{'no_revision'}; + + # Add binNMU to version if needed. + if ($self->get_conf('BIN_NMU') || $self->get_conf('APPEND_TO_VERSION') + || defined $self->get_conf('BIN_NMU_CHANGELOG')) { + if (defined $self->get_conf('BIN_NMU_CHANGELOG')) { + # extract the binary version from the custom changelog entry + open(CLOGFH, '<', \$self->get_conf('BIN_NMU_CHANGELOG')); + my $changes = Dpkg::Changelog::Debian->new(); + $changes->parse(*CLOGFH, "descr"); + my @data = $changes->get_range({count => 1}); + $version = $data[0]->get_version(); + close(CLOGFH); + } else { + # compute the binary version from the original version and the + # requested binNMU and append-to-version parameters + $version = binNMU_version($version, + $self->get_conf('BIN_NMU_VERSION'), + $self->get_conf('APPEND_TO_VERSION')); + } + } + + my $bver = Dpkg::Version->new($version, check => 1); + return if (!defined($bver)); + my ($b_epoch, $b_version, $b_revision); + $b_epoch = $bver->epoch(); + $b_epoch = "" if $bver->{'no_epoch'}; + $b_version = $bver->version(); + $b_revision = $bver->revision(); + $b_revision = "" if $bver->{'no_revision'}; + + # Version with binNMU or other additions and stripped epoch + my $sversion = $b_version; + $sversion .= '-' . $b_revision if $b_revision ne ''; + + $self->set('Package', $pkg); + $self->set('Version', $version); + $self->set('Package_Version', "${pkg}_$version"); + $self->set('Package_OVersion', "${pkg}_$oversion"); + $self->set('Package_OSVersion', "${pkg}_$osversion"); + $self->set('Package_SVersion', "${pkg}_$sversion"); + $self->set('OVersion', $oversion); + $self->set('OSVersion', $osversion); + $self->set('SVersion', $sversion); + $self->set('VersionEpoch', $b_epoch); + $self->set('VersionUpstream', $b_version); + $self->set('VersionDebian', $b_revision); + $self->set('DSC File', "${pkg}_${osversion}.dsc"); + if (length $self->get_conf('DSC_DIR')) { + $self->set('DSC Dir', $self->get_conf('DSC_DIR')); + } else { + $self->set('DSC Dir', "${pkg}-${b_version}"); + } + + debug("Package = " . $self->get('Package') . "\n"); + debug("Version = " . $self->get('Version') . "\n"); + debug("Package_Version = " . $self->get('Package_Version') . "\n"); + debug("Package_OVersion = " . $self->get('Package_OVersion') . "\n"); + debug("Package_OSVersion = " . $self->get('Package_OSVersion') . "\n"); + debug("Package_SVersion = " . $self->get('Package_SVersion') . "\n"); + debug("OVersion = " . $self->get('OVersion') . "\n"); + debug("OSVersion = " . $self->get('OSVersion') . "\n"); + debug("SVersion = " . $self->get('SVersion') . "\n"); + debug("VersionEpoch = " . $self->get('VersionEpoch') . "\n"); + debug("VersionUpstream = " . $self->get('VersionUpstream') . "\n"); + debug("VersionDebian = " . $self->get('VersionDebian') . "\n"); + debug("DSC File = " . $self->get('DSC File') . "\n"); + debug("DSC Dir = " . $self->get('DSC Dir') . "\n"); +} + +sub set_status { + my $self = shift; + my $status = shift; + + $self->set('Pkg Status', $status); + if (defined($self->get('Pkg Status Trigger'))) { + $self->get('Pkg Status Trigger')->($self, $status); + } +} + +sub get_status { + my $self = shift; + + return $self->get('Pkg Status'); +} + +# This function is the main entry point into the package build. It +# provides a top-level exception handler and does the initial setup +# including initiating logging and creating host chroot. The nested +# run_ functions it calls are separate in order to permit running +# cleanup tasks in a strict order. +sub run { + my $self = shift; + + eval { + $self->check_abort(); + + $self->set_status('building'); + + $self->set('Pkg Start Time', time); + $self->set('Pkg End Time', $self->get('Pkg Start Time')); + + # Acquire the architectures we're building for and on. + $self->set('Host Arch', $self->get_conf('HOST_ARCH')); + $self->set('Build Arch', $self->get_conf('BUILD_ARCH')); + $self->set('Build Profiles', $self->get_conf('BUILD_PROFILES')); + + # Acquire the build type in the nomenclature used by the --build + # argument of dpkg-buildpackage + my $buildtype; + if ($self->get_conf('BUILD_SOURCE')) { + if ($self->get_conf('BUILD_ARCH_ANY')) { + if ($self->get_conf('BUILD_ARCH_ALL')) { + $buildtype = "full"; + } else { + $buildtype = "source,any"; + } + } else { + if ($self->get_conf('BUILD_ARCH_ALL')) { + $buildtype = "source,all"; + } else { + $buildtype = "source"; + } + } + } else { + if ($self->get_conf('BUILD_ARCH_ANY')) { + if ($self->get_conf('BUILD_ARCH_ALL')) { + $buildtype = "binary"; + } else { + $buildtype = "any"; + } + } else { + if ($self->get_conf('BUILD_ARCH_ALL')) { + $buildtype = "all"; + } else { + Sbuild::Exception::Build->throw(error => "Neither architecture specific nor architecture independent or source package specified to be built.", + failstage => "init"); + } + } + } + $self->set('Build Type', $buildtype); + + my $dist = $self->get_conf('DISTRIBUTION'); + if (!defined($dist) || !$dist) { + Sbuild::Exception::Build->throw(error => "No distribution defined", + failstage => "init"); + } + + # TODO: Get package name from build object + if (!$self->open_build_log()) { + Sbuild::Exception::Build->throw(error => "Failed to open build log", + failstage => "init"); + } + + # Set a chroot to run commands in host + my $host = $self->get('Host'); + + # Host execution defaults (set streams) + my $host_defaults = $host->get('Defaults'); + $host_defaults->{'STREAMIN'} = $devnull; + $host_defaults->{'STREAMOUT'} = $self->get('Log Stream'); + $host_defaults->{'STREAMERR'} = $self->get('Log Stream'); + + $self->check_abort(); + $self->run_chroot(); + }; + + debug("Error run(): $@") if $@; + + my $e; + if ($e = Exception::Class->caught('Sbuild::Exception::Build')) { + if ($e->status) { + $self->set_status($e->status); + } else { + $self->set_status("failed"); + } + $self->set('Pkg Fail Stage', $e->failstage); + $e->rethrow(); + } +} + +# Pack up source if needed and then run the main chroot session. +# Close log during return/failure. +sub run_chroot { + my $self = shift; + + eval { + $self->check_abort(); + $self->run_chroot_session(); + }; + + debug("Error run_chroot(): $@") if $@; + + # Log exception info and set status and fail stage prior to + # closing build log. + my $e; + if ($e = Exception::Class->caught('Sbuild::Exception::Build')) { + $self->log_error("$e\n"); + $self->log_info($e->info."\n") + if ($e->info); + if ($e->status) { + $self->set_status($e->status); + } else { + $self->set_status("failed"); + } + $self->set('Pkg Fail Stage', $e->failstage); + } + + $self->close_build_log(); + + if ($e) { + $e->rethrow(); + } +} + +# Create main chroot session and package resolver. Creates a lock in +# the chroot to prevent concurrent chroot usage (only important for +# non-snapshot chroots). Ends chroot session on return/failure. +sub run_chroot_session { + my $self=shift; + + eval { + $self->check_abort(); + my $chroot_info; + if ($self->get_conf('CHROOT_MODE') eq 'schroot') { + $chroot_info = Sbuild::ChrootInfoSchroot->new($self->get('Config')); + } elsif ($self->get_conf('CHROOT_MODE') eq 'autopkgtest') { + $chroot_info = Sbuild::ChrootInfoAutopkgtest->new($self->get('Config')); + } elsif ($self->get_conf('CHROOT_MODE') eq 'unshare') { + $chroot_info = Sbuild::ChrootInfoUnshare->new($self->get('Config')); + } else { + $chroot_info = Sbuild::ChrootInfoSudo->new($self->get('Config')); + } + + my $host = $self->get('Host'); + + my $session = $chroot_info->create('chroot', + $self->get_conf('DISTRIBUTION'), + $self->get_conf('CHROOT'), + $self->get_conf('BUILD_ARCH')); + if (!defined $session) { + Sbuild::Exception::Build->throw(error => "Error creating chroot", + failstage => "create-session"); + } + + $self->check_abort(); + if (!$session->begin_session()) { + Sbuild::Exception::Build->throw(error => "Error creating chroot session: skipping " . + $self->get('Package'), + failstage => "create-session"); + } + + $self->set('Session', $session); + + $self->check_abort(); + my $chroot_arch = $self->chroot_arch(); + if ($self->get_conf('BUILD_ARCH') ne $chroot_arch) { + Sbuild::Exception::Build->throw( + error => "Requested build architecture (" . + $self->get_conf('BUILD_ARCH') . + ") and chroot architecture (" . $chroot_arch . + ") do not match. Skipping build.", + info => "Please specify the correct architecture with --build, or use a chroot of the correct architecture", + failstage => "create-session"); + } + + if (length $self->get_conf('BUILD_PATH')) { + my $build_path = $self->get_conf('BUILD_PATH'); + $self->set('Build Dir', $build_path); + if (!($session->test_directory($build_path))) { + if (!$session->mkdir($build_path, { PARENTS => 1})) { + Sbuild::Exception::Build->throw( + error => "Buildpath: " . $build_path . " cannot be created", + failstage => "create-session"); + } + } else { + my $isempty = <<END; +if (opendir my \$dfh, "$build_path") { + while (defined(my \$file=readdir \$dfh)) { + next if \$file eq "." or \$file eq ".."; + closedir \$dfh; + exit 1 + } + closedir \$dfh; + exit 0 +} +exit 2 +END + $session->run_command({ + COMMAND => ['perl', '-e', $isempty], + USER => 'root', + DIR => '/' + }); + if ($? == 1) { + Sbuild::Exception::Build->throw( + error => "Buildpath: " . $build_path . " is not empty", + failstage => "create-session"); + } + elsif ($? == 2) { + Sbuild::Exception::Build->throw( + error => "Buildpath: " . $build_path . " cannot be read. Insufficient permissions?", + failstage => "create-session"); + } + } + } else { + # we run mktemp within the chroot instead of using File::Temp::tempdir because the user + # running sbuild might not have permissions creating a directory in /build. This happens + # when the chroot was extracted in a different user namespace than the outer user + $self->check_abort(); + my $tmpdir = $session->mktemp({ + TEMPLATE => "/build/" . $self->get('Package') . '-XXXXXX', + DIRECTORY => 1}); + if (!$tmpdir) { + $self->log_error("unable to mktemp\n"); + Sbuild::Exception::Build->throw(error => "unable to mktemp", + failstage => "create-build-dir"); + } + $self->check_abort(); + $self->set('Build Dir', $tmpdir); + } + + # Copy in external solvers if we are cross-building + if ($self->get('Host Arch') ne $self->get('Build Arch')) { + if (!$session->test_directory("/usr/lib/apt/solvers")) { + if (!$session->mkdir("/usr/lib/apt/solvers", { PARENTS => 1})) { + Sbuild::Exception::Build->throw( + error => "/usr/lib/apt/solvers cannot be created", + failstage => "create-session"); + } + } + foreach my $solver ('apt', 'sbuild-cross-resolver') { + if ($session->test_regular_file_readable("/usr/lib/apt/solvers/$solver")) { + next; + } + if (! -e "/usr/lib/apt/solvers/$solver") { + Sbuild::Exception::Build->throw( + error => "/usr/lib/apt/solvers/$solver is missing", + failstage => "create-session"); + } + if (! $session->copy_to_chroot("/usr/lib/apt/solvers/$solver", "/usr/lib/apt/solvers/$solver")) { + Sbuild::Exception::Build->throw( + error => "/usr/lib/apt/solvers/$solver cannot be copied", + failstage => "create-session"); + } + if (! $session->chmod("/usr/lib/apt/solvers/$solver", "0755")) { + Sbuild::Exception::Build->throw( + error => "/usr/lib/apt/solvers/$solver cannot chmod", + failstage => "create-session"); + } + } + } + + # Run pre build external commands + $self->check_abort(); + if(!$self->run_external_commands("pre-build-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute pre-build-commands", + failstage => "run-pre-build-commands"); + } + + # Log colouring + $self->build_log_colour('red', '^E: '); + $self->build_log_colour('yellow', '^W: '); + $self->build_log_colour('green', '^I: '); + $self->build_log_colour('red', '^Status:'); + $self->build_log_colour('green', '^Status: successful$'); + $self->build_log_colour('yellow', '^Keeping session: '); + $self->build_log_colour('red', '^Lintian:'); + $self->build_log_colour('yellow', '^Lintian: warn$'); + $self->build_log_colour('green', '^Lintian: pass$'); + $self->build_log_colour('green', '^Lintian: info$'); + $self->build_log_colour('red', '^Piuparts:'); + $self->build_log_colour('green', '^Piuparts: pass$'); + $self->build_log_colour('red', '^Autopkgtest:'); + $self->build_log_colour('yellow', '^Autopkgtest: no tests$'); + $self->build_log_colour('green', '^Autopkgtest: pass$'); + + # Log filtering + my $filter; + $filter = $session->get('Location'); + $filter =~ s;^/;;; + $self->build_log_filter($filter , 'CHROOT'); + + # Need tempdir to be writable and readable by sbuild group. + $self->check_abort(); + if (!$session->chown($self->get('Build Dir'), $self->get_conf('BUILD_USER'), 'sbuild')) { + Sbuild::Exception::Build->throw(error => "Failed to set sbuild group ownership on chroot build dir", + failstage => "create-build-dir"); + } + $self->check_abort(); + if (!$session->chmod($self->get('Build Dir'), "ug=rwx,o=,a-s")) { + Sbuild::Exception::Build->throw(error => "Failed to set sbuild group ownership on chroot build dir", + failstage => "create-build-dir"); + } + + $self->check_abort(); + # Needed so chroot commands log to build log + $session->set('Log Stream', $self->get('Log Stream')); + $host->set('Log Stream', $self->get('Log Stream')); + + # Chroot execution defaults + my $chroot_defaults = $session->get('Defaults'); + $chroot_defaults->{'DIR'} = $self->get('Build Dir'); + $chroot_defaults->{'STREAMIN'} = $devnull; + $chroot_defaults->{'STREAMOUT'} = $self->get('Log Stream'); + $chroot_defaults->{'STREAMERR'} = $self->get('Log Stream'); + $chroot_defaults->{'ENV'}->{'LC_ALL'} = 'C.UTF-8'; + $chroot_defaults->{'ENV'}->{'SHELL'} = '/bin/sh'; + $chroot_defaults->{'ENV'}->{'HOME'} = '/sbuild-nonexistent'; + $chroot_defaults->{'ENV_FILTER'} = $self->get_conf('ENVIRONMENT_FILTER'); + + my $resolver = get_resolver($self->get('Config'), $session, $host); + $resolver->set('Log Stream', $self->get('Log Stream')); + $resolver->set('Arch', $self->get_conf('ARCH')); + $resolver->set('Host Arch', $self->get_conf('HOST_ARCH')); + $resolver->set('Build Arch', $self->get_conf('BUILD_ARCH')); + $resolver->set('Build Profiles', $self->get_conf('BUILD_PROFILES')); + $resolver->set('Build Dir', $self->get('Build Dir')); + $self->set('Dependency Resolver', $resolver); + + # Lock chroot so it won't be tampered with during the build. + $self->check_abort(); + my $jobname; + # the version might not yet be known if the user only passed a package + # name without a version to sbuild + if ($self->get('Package_SVersion')) { + $jobname = $self->get('Package_SVersion'); + } else { + $jobname = $self->get('Package'); + } + if (!$session->lock_chroot($jobname, $$, $self->get_conf('USERNAME'))) { + Sbuild::Exception::Build->throw(error => "Error locking chroot session: skipping " . + $self->get('Package'), + failstage => "lock-session"); + } + + $self->check_abort(); + $self->run_chroot_session_locked(); + }; + + debug("Error run_chroot_session(): $@") if $@; + + if ($self->get('Pkg Status') ne "successful") { + if(!$self->run_external_commands("post-build-failed-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute post-build-commands", + failstage => "run-post-build-failed-commands"); + } + } + + # End chroot session + my $session = $self->get('Session'); + if (defined $session) { + my $end_session = + ($self->get_conf('PURGE_SESSION') eq 'always' || + ($self->get_conf('PURGE_SESSION') eq 'successful' && + $self->get_status() eq 'successful')) ? 1 : 0; + if ($end_session) { + $session->end_session(); + } else { + $self->log("Keeping session: " . $session->get('Session ID') . "\n"); + } + $session = undef; + } + $self->set('Session', $session); + + my $e; + if ($e = Exception::Class->caught('Sbuild::Exception::Build')) { + $e->rethrow(); + } +} + +# Run tasks in a *locked* chroot. Update and upgrade packages. +# Unlocks chroot on return/failure. +sub run_chroot_session_locked { + my $self = shift; + + eval { + my $session = $self->get('Session'); + my $resolver = $self->get('Dependency Resolver'); + + # Run specified chroot setup commands + $self->check_abort(); + if(!$self->run_external_commands("chroot-setup-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute chroot-setup-commands", + failstage => "run-chroot-setup-commands"); + } + + $self->check_abort(); + + + $self->check_abort(); + if (!$resolver->setup()) { + Sbuild::Exception::Build->throw(error => "resolver setup failed", + failstage => "resolver setup"); + } + + my $filter; + $filter = $resolver->get('Dummy package path'); + $filter =~ s;^/;;; + $self->build_log_filter($filter , 'RESOLVERDIR'); + + $self->check_abort(); + $self->run_chroot_update(); + + $self->check_abort(); + $self->run_fetch_install_packages(); + }; + + debug("Error run_chroot_session_locked(): $@") if $@; + + my $session = $self->get('Session'); + my $resolver = $self->get('Dependency Resolver'); + + $resolver->cleanup(); + # Unlock chroot now it's cleaned up and ready for other users. + $session->unlock_chroot(); + + my $e; + if ($e = Exception::Class->caught('Sbuild::Exception::Build')) { + $e->rethrow(); + } +} + +sub run_chroot_update { + my $self = shift; + my $resolver = $self->get('Dependency Resolver'); + + eval { + if ($self->get_conf('APT_CLEAN') || $self->get_conf('APT_UPDATE') || + $self->get_conf('APT_DISTUPGRADE') || $self->get_conf('APT_UPGRADE')) { + $self->log_subsection('Update chroot'); + } + + # Clean APT cache. + $self->check_abort(); + if ($self->get_conf('APT_CLEAN')) { + if ($resolver->clean()) { + # Since apt-clean was requested specifically, fail on + # error when not in buildd mode. + $self->log_error("apt-get clean failed\n"); + if ($self->get_conf('SBUILD_MODE') ne 'buildd') { + Sbuild::Exception::Build->throw(error => "apt-get clean failed", + failstage => "apt-get-clean"); + } + } + } + + # Update APT cache. + $self->check_abort(); + if ($self->get_conf('APT_UPDATE')) { + if ($resolver->update()) { + # Since apt-update was requested specifically, fail on + # error when not in buildd mode. + if ($self->get_conf('SBUILD_MODE') ne 'buildd') { + Sbuild::Exception::Build->throw(error => "apt-get update failed", + failstage => "apt-get-update"); + } + } + } else { + # If it was requested not to do an apt update, the build and host + # architecture must already be part of the chroot. If they are not + # and thus added during the sbuild run, issue a warning because + # then the package build dependencies will likely fail to be + # installable. + # + # The logic which checks which architectures are needed is in + # ResolverBase.pm, so we just check whether any architectures + # where added with 'dpkg --add-architecture' because if any were + # added an update is most likely needed. + if (keys %{$resolver->get('Added Foreign Arches')}) { + $self->log_warning("Additional architectures were added but apt update was disabled. Build dependencies might not be satisfiable.\n"); + } + } + + # Upgrade using APT. + $self->check_abort(); + if ($self->get_conf('APT_DISTUPGRADE')) { + if ($resolver->distupgrade()) { + # Since apt-distupgrade was requested specifically, fail on + # error when not in buildd mode. + if ($self->get_conf('SBUILD_MODE') ne 'buildd') { + Sbuild::Exception::Build->throw(error => "apt-get dist-upgrade failed", + failstage => "apt-get-dist-upgrade"); + } + } + } elsif ($self->get_conf('APT_UPGRADE')) { + if ($resolver->upgrade()) { + # Since apt-upgrade was requested specifically, fail on + # error when not in buildd mode. + if ($self->get_conf('SBUILD_MODE') ne 'buildd') { + Sbuild::Exception::Build->throw(error => "apt-get upgrade failed", + failstage => "apt-get-upgrade"); + } + } + } + }; + + debug("Error run_chroot_update(): $@") if $@; + + my $e = Exception::Class->caught('Sbuild::Exception::Build'); + if ($e) { + $self->run_external_commands("chroot-update-failed-commands"); + $e->rethrow(); + } +} + +# Fetch sources, run setup, fetch and install core and package build +# deps, then run build. Cleans up build directory and uninstalls +# build depends on return/failure. +sub run_fetch_install_packages { + my $self = shift; + + $self->check_abort(); + eval { + my $session = $self->get('Session'); + my $resolver = $self->get('Dependency Resolver'); + + $self->check_abort(); + if (!$self->fetch_source_files()) { + Sbuild::Exception::Build->throw(error => "Failed to fetch source files", + failstage => "fetch-src"); + } + + # Display message about chroot setup script option use being deprecated + if ($self->get_conf('CHROOT_SETUP_SCRIPT')) { + my $msg = "setup-hook option is deprecated. It has been superseded by "; + $msg .= "the chroot-setup-commands feature. setup-hook script will be "; + $msg .= "run via chroot-setup-commands.\n"; + $self->log_warning($msg); + } + + $self->check_abort(); + $self->set('Install Start Time', time); + $self->set('Install End Time', $self->get('Install Start Time')); + my @coredeps = @{$self->get_conf('CORE_DEPENDS')}; + if ($self->get('Host Arch') ne $self->get('Build Arch')) { + my $crosscoredeps = $self->get_conf('CROSSBUILD_CORE_DEPENDS'); + if (defined($crosscoredeps->{$self->get('Host Arch')})) { + push(@coredeps, @{$crosscoredeps->{$self->get('Host Arch')}}); + } else { + push(@coredeps, 'crossbuild-essential-' . $self->get('Host Arch') . ':native'); + # Also add the following to work around bug #815172 + push(@coredeps, 'libc-dev:' . $self->get('Host Arch'), + 'libstdc++-dev:' . $self->get('Host Arch')); + } + } + + my @snapshot = (); + @snapshot = ("gcc-snapshot") if ($self->get_conf('GCC_SNAPSHOT')); + + $resolver->add_dependencies('MAIN', + join(", ", $self->get('Build Depends') // (), + @{$self->get_conf('MANUAL_DEPENDS')}, @snapshot, @coredeps), + join(", ", $self->get('Build Depends Arch') // (), + @{$self->get_conf('MANUAL_DEPENDS_ARCH')}), + join(", ", $self->get('Build Depends Indep') // (), + @{$self->get_conf('MANUAL_DEPENDS_INDEP')}), + join(", ", $self->get('Build Conflicts') // (), + @{$self->get_conf('MANUAL_CONFLICTS')}), + join(", ", $self->get('Build Conflicts Arch') // (), + @{$self->get_conf('MANUAL_CONFLICTS_ARCH')}), + join(", ", $self->get('Build Conflicts Indep') // (), + @{$self->get_conf('MANUAL_CONFLICTS_INDEP')})); + + $self->log_subsection("Install package build dependencies"); + + $self->check_abort(); + if (!$resolver->install_deps('main', 'MAIN')) { + Sbuild::Exception::Build->throw(error => "Package build dependencies not satisfied; skipping", + failstage => "install-deps"); + } + $self->check_abort(); + if ($self->get_conf('PURGE_EXTRA_PACKAGES')) { + if (!$resolver->purge_extra_packages($self->get('Package'))) { + Sbuild::Exception::Build->throw(error => "Chroot could not be cleaned of extra packages", + failstage => "install-deps"); + } + } + $self->set('Install End Time', time); + + # the architecture check has to be done *after* build-essential is + # installed because as part of the architecture check a perl script is + # run inside the chroot which requires the Dpkg::Arch module which is + # in libdpkg-perl which might not exist in the chroot but will get + # installed by the build-essential package + if(!$self->check_architectures()) { + Sbuild::Exception::Build->throw(error => "Architecture check failed", + failstage => "check-architecture"); + } + + $self->check_abort(); + my $dpkg_version = $resolver->dump_build_environment(); + $self->set('Dpkg Version',Dpkg::Version->new($dpkg_version)); + + $self->check_abort(); + if ($self->build()) { + $self->set_status('successful'); + } else { + $self->set('Pkg Fail Stage', "build"); + $self->set_status('failed'); + } + + # We run it here and not inside build() because otherwise, we cannot + # set the overall status to failed due to lintian errors + if ($self->get('Pkg Status') eq "successful") { + # Run lintian. + $self->check_abort(); + my $ret = $self->run_lintian(); + if (!$ret && $self->get_conf('LINTIAN_REQUIRE_SUCCESS')) { + $self->set('Pkg Fail Stage', "post-build"); + $self->set_status("failed"); + } + } + + # Run specified chroot cleanup commands + $self->check_abort(); + if (!$self->run_external_commands("chroot-cleanup-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute chroot-cleanup-commands", + failstage => "run-chroot-cleanup-commands"); + } + + # piuparts and autopkgtest must be run while the chroot is still open + # because they might need files that are not available on the host, + # for example the .dsc which might have been downloaded + if ($self->get('Pkg Status') eq "successful") { + $self->log_subsection("Post Build"); + + # Run piuparts. + $self->check_abort(); + my $ret = $self->run_piuparts(); + if (!$ret && $self->get_conf('PIUPARTS_REQUIRE_SUCCESS')) { + $self->set('Pkg Fail Stage', "post-build"); + $self->set_status("failed"); + } + + # Run autopkgtest. + $self->check_abort(); + $ret = $self->run_autopkgtest(); + if (!$ret && $self->get_conf('AUTOPKGTEST_REQUIRE_SUCCESS')) { + $self->set('Pkg Fail Stage', "post-build"); + $self->set_status("failed"); + } + + # Run post build external commands + $self->check_abort(); + if(!$self->run_external_commands("post-build-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute post-build-commands", + failstage => "run-post-build-commands"); + } + + } + }; + + # If 'This Time' is still zero, then build() raised an exception and thus + # the end time was never set. Thus, setting it here. + # If we would set 'This Time' here unconditionally, then it would also + # possibly include the times to run piuparts and autopkgtest. + if ($self->get('This Time') == 0) { + $self->set('This Time', $self->get('Pkg End Time') - $self->get('Pkg Start Time')); + $self->set('This Time', 0) if $self->get('This Time') < 0; + } + # Same for 'This Space' which we must set here before everything gets + # cleaned up. + if ($self->get('This Space') == 0) { + # Since the build apparently failed, we pass an empty list of the + # build artifacts + $self->set('This Space', $self->check_space()); + } + + debug("Error run_fetch_install_packages(): $@") if $@; + + # I catch the exception here and trigger the hook, if needed. Normally I'd + # do this at the end of the function, but I want the hook to fire before we + # clean up the environment. I re-throw the exception at the end, as usual + my $e = Exception::Class->caught('Sbuild::Exception::Build'); + if ($e) { + if ($e->status) { + $self->set_status($e->status); + } else { + $self->set_status("failed"); + } + $self->set('Pkg Fail Stage', $e->failstage); + } + if (!$self->get('ABORT') && defined $self->get('Pkg Fail Stage')) { + if ($self->get('Pkg Fail Stage') eq 'build' ) { + if(!$self->run_external_commands("build-failed-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute build-failed-commands", + failstage => "run-build-failed-commands"); + } + } elsif($self->get('Pkg Fail Stage') eq 'install-deps' ) { + my $could_not_explain = undef; + + if (defined $self->get_conf('BD_UNINSTALLABLE_EXPLAINER') + && $self->get_conf('BD_UNINSTALLABLE_EXPLAINER') ne '' + && $self->get_conf('BD_UNINSTALLABLE_EXPLAINER') ne 'none') { + if (!$self->explain_bd_uninstallable()) { + $could_not_explain = 1; + } + } + + if(!$self->run_external_commands("build-deps-failed-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute build-deps-failed-commands", + failstage => "run-build-deps-failed-commands"); + } + + if( $could_not_explain ) { + Sbuild::Exception::Build->throw(error => "Failed to explain bd-uninstallable", + failstage => "explain-bd-uninstallable"); + } + } + } + + $self->log_subsection("Cleanup"); + my $session = $self->get('Session'); + my $resolver = $self->get('Dependency Resolver'); + + my $purge_build_directory = + ($self->get_conf('PURGE_BUILD_DIRECTORY') eq 'always' || + ($self->get_conf('PURGE_BUILD_DIRECTORY') eq 'successful' && + $self->get_status() eq 'successful')) ? 1 : 0; + my $purge_build_deps = + ($self->get_conf('PURGE_BUILD_DEPS') eq 'always' || + ($self->get_conf('PURGE_BUILD_DEPS') eq 'successful' && + $self->get_status() eq 'successful')) ? 1 : 0; + my $is_cloned_session = (defined ($session->get('Session Purged')) && + $session->get('Session Purged') == 1) ? 1 : 0; + + if ($purge_build_directory) { + # Purge package build directory + $self->log("Purging " . $self->get('Build Dir') . "\n"); + if (!$self->get('Session')->unlink($self->get('Build Dir'), { RECURSIVE => 1 })) { + $self->log_error("unable to remove build directory\n"); + } + } + + # Purge non-cloned session + if ($is_cloned_session) { + $self->log("Not cleaning session: cloned chroot in use\n"); + } else { + if ($purge_build_deps) { + # Removing dependencies + $resolver->uninstall_deps(); + } else { + $self->log("Not removing build depends: as requested\n"); + } + } + + + # re-throw the previously-caught exception + if ($e) { + $e->rethrow(); + } +} + +sub copy_to_chroot { + my $self = shift; + my $source = shift; + my $chrootdest = shift; + + my $session = $self->get('Session'); + + $self->check_abort(); + if(!$session->copy_to_chroot($source, $chrootdest)) { + $self->log_error("Failed to copy $source to $chrootdest\n"); + return 0; + } + + if (!$session->chown($chrootdest, $self->get_conf('BUILD_USER'), 'sbuild')) { + $self->log_error("Failed to set sbuild group ownership on $chrootdest\n"); + return 0; + } + if (!$session->chmod($chrootdest, "ug=rw,o=r,a-s")) { + $self->log_error("Failed to set 0644 permissions on $chrootdest\n"); + return 0; + } + + return 1; +} +sub fetch_source_files { + my $self = shift; + + my $build_dir = $self->get('Build Dir'); + my $host_arch = $self->get('Host Arch'); + my $resolver = $self->get('Dependency Resolver'); + + my ($dscarchs, $dscpkg, $dscver, $dsc); + + my $build_depends = ""; + my $build_depends_arch = ""; + my $build_depends_indep = ""; + my $build_conflicts = ""; + my $build_conflicts_arch = ""; + my $build_conflicts_indep = ""; + local( *F ); + + $self->log_subsection("Fetch source files"); + + $self->check_abort(); + if ($self->get('DSC Base') =~ m/\.dsc$/) { + my $dir = $self->get('Source Dir'); + + # Work with a .dsc file. + my $file = $self->get('DSC'); + $dsc = $self->get('DSC File'); + if (! -f $file || ! -r $file) { + $self->log_error("Could not find $file\n"); + return 0; + } + my @cwd_files = dsc_files($file); + + # Copy the local source files into the build directory. + $self->log_subsubsection("Local sources"); + $self->log("$file exists in $dir; copying to chroot\n"); + if (! $self->copy_to_chroot("$file", "$build_dir/$dsc")) { + $self->log_error("Could not copy $file to $build_dir/$dsc\n"); + return 0; + } + foreach (@cwd_files) { + if (! $self->copy_to_chroot("$dir/$_", "$build_dir/$_")) { + $self->log_error("Could not copy $dir/$_ to $build_dir/$_\n"); + return 0; + } + } + } else { + my $pkg = $self->get('DSC'); + my $ver; + + if ($pkg =~ m/_/) { + ($pkg, $ver) = split /_/, $pkg; + } + + # Use apt to download the source files + $self->log_subsubsection("Check APT"); + + my $indextargets; + { + my $pipe = $self->get('Session')->pipe_command( + { + COMMAND => [ 'apt-get', 'indextargets' ], + USER => $self->get_conf('BUILD_USER'), + } + ); + if ( !$pipe ) { + $self->log_error("Can't open pipe to apt-get: $!\n"); + return 0; + } + $indextargets = + Dpkg::Index->new( get_key_func => sub { return $_[0]->{URI}; } ); + + if ( !$indextargets->parse( $pipe, 'apt-get indextargets' ) ) { + $self->log_error( + "Cannot parse output of apt-get indextargets: $!\n"); + return 0; + } + close($pipe); + + if ($?) { + $self->log_error("apt-get indextargets exit status $?: $!\n"); + return 0; + } + } + my $found_sources_entry = 0; + my $num_packages_entries = 0; + my $entry_uri = undef; + my $entry_codename = undef; + my $entry_component = undef; + foreach my $key ( $indextargets->get_keys() ) { + my $cdata = $indextargets->get_by_key($key); + my $createdby = $cdata->{"Created-By"} // ""; + my $targetof = $cdata->{"Target-Of"} // ""; + my $identifier = $cdata->{"Identifier"} // ""; + if ( $createdby eq "Sources" + and $identifier eq "Sources" + and $targetof eq "deb-src" ) + { + $found_sources_entry = 1; + } + if ( $createdby eq 'Packages' + and $identifier eq 'Packages' + and $targetof eq 'deb' + and length $cdata->{"Repo-URI"} > 0 + and length $cdata->{"Codename"} > 0 + and length $cdata->{"Label"} > 0 + and length $cdata->{"Origin"} > 0 + and length $cdata->{"Suite"} > 0 + and $cdata->{"Repo-URI"} =~ /^file:\// + and $cdata->{"Codename"} eq 'invalid-sbuild-codename' + and $cdata->{'Label'} eq 'sbuild-build-depends-archive' + and $cdata->{'Origin'} eq 'sbuild-build-depends-archive' + and $cdata->{'Suite'} eq 'invalid-sbuild-suite' ) + { + # do not count the sbuild dummy repository created by any + # --extra-package options + next; + } + if ( $createdby eq 'Packages' + and $identifier eq 'Packages' + and $targetof eq 'deb' + and length $cdata->{"Repo-URI"} > 0 + and length $cdata->{"Codename"} > 0 + and length $cdata->{"Component"} > 0 ) + { + $num_packages_entries += 1; + $entry_uri = $cdata->{"Repo-URI"}; + $entry_codename = $cdata->{"Codename"}; + $entry_component = $cdata->{"Component"}; + } + } + if ( !$found_sources_entry ) { + $self->log("There are no deb-src lines in your sources.list\n"); + if ( $num_packages_entries == 0 ) { + $self->log("Cannot generate deb-src entry without deb entry\n"); + } + elsif ( $num_packages_entries > 1 ) { + $self->log( "Cannot generate deb-src entry " + . "with more than one deb entry\n" ); + } + else { + my $entry = + "deb-src $entry_uri $entry_codename $entry_component"; + $self->log( + "Automatically adding to EXTRA_REPOSITORIES: $entry\n"); + push @{ $self->get_conf('EXTRA_REPOSITORIES') }, $entry; + $resolver->add_extra_repositories(); + $self->run_chroot_update(); + } + } + + $self->log("Checking available source versions...\n"); + + # We would like to call apt-cache with --only-source so that the + # result only contains source packages with the given name but this + # feature was only introduced in apt 1.1~exp10 so it is only available + # in Debian Stretch and later + my $pipe = $self->get('Dependency Resolver')->pipe_apt_command( + { COMMAND => [$self->get_conf('APT_CACHE'), + '-q', 'showsrc', $pkg], + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0, + DIR => '/'}); + if (!$pipe) { + $self->log_error("Can't open pipe to ".$self->get_conf('APT_CACHE').": $!\n"); + return 0; + } + + my $key_func = sub { + return $_[0]->{Package} . '_' . $_[0]->{Version}; + }; + + my $index = Dpkg::Index->new(get_key_func=>$key_func); + + if (!$index->parse($pipe, 'apt-cache showsrc')) { + $self->log_error("Cannot parse output of apt-cache showsrc: $!\n"); + return 0; + } + + close($pipe); + + if ($?) { + $self->log_error($self->get_conf('APT_CACHE') . " exit status $?: $!\n"); + return 0; + } + + my $highestversion; + my $highestdsc; + + foreach my $key ($index->get_keys()) { + my $cdata = $index->get_by_key($key); + my $pkgname = $cdata->{"Package"}; + if (not defined($pkgname)) { + $self->log_warning("apt-cache output without Package field\n"); + next; + } + # Since we cannot run apt-cache with --only-source because that + # feature was only introduced with apt 1.1~exp10, the result can + # contain source packages that we didn't ask for (but which + # contain binary packages of the name we specified). Since we only + # are interested in source packages of the given name, we skip + # everything that is a different source package. + if ($pkg ne $pkgname) { + next; + } + my $pkgversion = $cdata->{"Version"}; + if (not defined($pkgversion)) { + $self->log_warning("apt-cache output without Version field\n"); + next; + } + if (defined($ver) and $ver ne $pkgversion) { + next; + } + my $checksums = Dpkg::Checksums->new(); + $checksums->add_from_control($cdata, use_files_for_md5 => 1); + my @files = grep {/\.dsc$/} $checksums->get_files(); + if (scalar @files != 1) { + $self->log_warning("apt-cache output with more than one .dsc\n"); + next; + } + if (!defined $highestdsc) { + $highestdsc = $files[0]; + $highestversion = $pkgversion; + } else { + if (version_compare($highestversion, $pkgversion) < 0) { + $highestdsc = $files[0]; + $highestversion = $pkgversion; + } + } + } + + if (!defined $highestdsc) { + $self->log_error($self->get_conf('APT_CACHE') . + " returned no information about $pkg source\n"); + $self->log_error("Are there any deb-src lines in your /etc/apt/sources.list?\n"); + return 0; + } + + $self->set_dsc($highestdsc); + $dsc = $highestdsc; + + $self->log_subsubsection("Download source files with APT"); + + my $pipe2 = $self->get('Dependency Resolver')->pipe_apt_command( + { COMMAND => [$self->get_conf('APT_GET'), '--only-source', '-q', '-d', 'source', "$pkg=$highestversion"], + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0}) || return 0; + + while(<$pipe2>) { + $self->log($_); + } + close($pipe2); + if ($?) { + $self->log_error($self->get_conf('APT_GET') . " for sources failed\n"); + return 0; + } + } + + my $pipe = $self->get('Session')->get_read_file_handle("$build_dir/$dsc"); + if (!$pipe) { + $self->log_error("unable to open pipe\n"); + return 0; + } + + my $pdsc = Dpkg::Control->new(type => CTRL_PKG_SRC); + $pdsc->set_options(allow_pgp => 1); + if (!$pdsc->parse($pipe, "$build_dir/$dsc")) { + $self->log_error("Error parsing $build_dir/$dsc\n"); + return 0; + } + + close($pipe); + + $build_depends = $pdsc->{'Build-Depends'}; + $build_depends_arch = $pdsc->{'Build-Depends-Arch'}; + $build_depends_indep = $pdsc->{'Build-Depends-Indep'}; + $build_conflicts = $pdsc->{'Build-Conflicts'}; + $build_conflicts_arch = $pdsc->{'Build-Conflicts-Arch'}; + $build_conflicts_indep = $pdsc->{'Build-Conflicts-Indep'}; + $dscarchs = $pdsc->{'Architecture'}; + $dscpkg = $pdsc->{'Source'}; + $dscver = $pdsc->{'Version'}; + + $self->set_version("${dscpkg}_${dscver}"); + + $build_depends =~ s/\n\s+/ /g if defined $build_depends; + $build_depends_arch =~ s/\n\s+/ /g if defined $build_depends_arch; + $build_depends_indep =~ s/\n\s+/ /g if defined $build_depends_indep; + $build_conflicts =~ s/\n\s+/ /g if defined $build_conflicts; + $build_conflicts_arch =~ s/\n\s+/ /g if defined $build_conflicts_arch; + $build_conflicts_indep =~ s/\n\s+/ /g if defined $build_conflicts_indep; + + $self->set('Build Depends', $build_depends); + $self->set('Build Depends Arch', $build_depends_arch); + $self->set('Build Depends Indep', $build_depends_indep); + $self->set('Build Conflicts', $build_conflicts); + $self->set('Build Conflicts Arch', $build_conflicts_arch); + $self->set('Build Conflicts Indep', $build_conflicts_indep); + + $self->set('Dsc Architectures', $dscarchs); + + # we set up the following filters this late because the user might only + # have specified a source package name to build without a version in which + # case we only get to know the final build directory now + my $filter; + $filter = $self->get('Build Dir') . '/' . $self->get('DSC Dir'); + $filter =~ s;^/;;; + $self->build_log_filter($filter, 'PKGBUILDDIR'); + $filter = $self->get('Build Dir'); + $filter =~ s;^/;;; + $self->build_log_filter($filter, 'BUILDDIR'); + + return 1; +} + +sub check_architectures { + my $self = shift; + my $resolver = $self->get('Dependency Resolver'); + my $dscarchs = $self->get('Dsc Architectures'); + my $build_arch = $self->get('Build Arch'); + my $host_arch = $self->get('Host Arch'); + my $session = $self->get('Session'); + + $self->log_subsection("Check architectures"); + # Check for cross-arch dependencies + # parse $build_depends* for explicit :arch and add the foreign arches, as needed + # + # This check only looks at the immediate build dependencies. This could + # fail in a future where a foreign architecture direct build dependency of + # architecture X depends on another foreign architecture package of + # architecture Y. Architecture Y would not be added through this check as + # sbuild will not traverse the dependency graph. Doing so would be very + # complicated as new architectures would have to be added to a dependency + # solver like dose3 as the graph is traversed and new architectures are + # found. + sub get_explicit_arches + { + my $visited_deps = pop; + my @deps = @_; + + my %set; + for my $dep (@deps) + { + # Break any recursion in the deps data structure (is this overkill?) + next if !defined $dep; + my $id = ref($dep) ? refaddr($dep) : "str:$dep"; + next if $visited_deps->{$id}; + $visited_deps->{$id} = 1; + + if ( exists( $dep->{archqual} ) ) + { + if ( $dep->{archqual} ) + { + $set{$dep->{archqual}} = 1; + } + } + else + { + for my $key (get_explicit_arches($dep->get_deps, + $visited_deps)) { + $set{$key} = 1; + } + } + } + + return keys %set; + } + + # we don't need to look at build conflicts here because conflicting with a + # package of an explicit architecture does not mean that we need to enable + # that architecture in the chroot + my $build_depends_concat = + deps_concat( grep {defined $_} ($self->get('Build Depends'), + $self->get('Build Depends Arch'), + $self->get('Build Depends Indep'))); + my $merged_depends = deps_parse( $build_depends_concat, + reduce_arch => 1, + host_arch => $self->get('Host Arch'), + build_arch => $self->get('Build Arch'), + build_dep => 1, + reduce_profiles => 1, + build_profiles => [ split / /, $self->get('Build Profiles') ]); + if( !defined $merged_depends ) { + my $msg = "Error! deps_parse() couldn't parse the Build-Depends '$build_depends_concat'"; + $self->log_error("$msg\n"); + return 0; + } + + my @explicit_arches = get_explicit_arches($merged_depends, {}); + my @foreign_arches = grep {$_ !~ /any|all|native/} @explicit_arches; + my $added_any_new; + for my $foreign_arch(@foreign_arches) + { + $resolver->add_foreign_architecture($foreign_arch); + $added_any_new = 1; + } + + my @keylist=keys %{$resolver->get('Initial Foreign Arches')}; + $self->log('Initial Foreign Architectures: ' . join ' ', @keylist, "\n") + if @keylist; + $self->log('Foreign Architectures in build-deps: '. join ' ', @foreign_arches, "\n\n") + if @foreign_arches; + + $self->run_chroot_update() if $added_any_new; + + # At this point, all foreign architectures should have been added to dpkg. + # Thus, we now examine, whether the packages passed via --extra-package + # can even be considered by dpkg inside the chroot with respect to their + # architecture. + + # Retrieve all foreign architectures from the chroot. We need to do this + # step because the user might've added more foreign arches to the chroot + # beforehand. + my @all_foreign_arches = split /\s+/, $session->read_command({ + COMMAND => ['dpkg', '--print-foreign-architectures'], + USER => $self->get_conf('USERNAME'), + }); + # we use an anonymous subroutine so that the referenced variables are + # automatically rebound to their current values + my $check_deb_arch = sub { + my $pkg = shift; + # Investigate the Architecture field of the binary package + my $arch = $self->get('Host')->read_command({ + COMMAND => ['dpkg-deb', '--field', Cwd::abs_path($pkg), 'Architecture'], + USER => $self->get_conf('USERNAME') + }); + if (!defined $arch) { + $self->log_warning("Failed to run dpkg-deb on $pkg. Skipping...\n"); + next; + } + chomp $arch; + # Only packages that are Architecture:all, the native architecture or + # one of the configured foreign architectures are allowed. + if ($arch ne 'all' and $arch ne $build_arch + and !isin($arch, @all_foreign_arches)) { + $self->log_warning("Extra package $pkg of architecture $arch cannot be installed in the chroot\n"); + } + }; + for my $deb (@{$self->get_conf('EXTRA_PACKAGES')}) { + if (-f $deb) { + &$check_deb_arch($deb); + } elsif (-d $deb) { + opendir(D, $deb); + while (my $f = readdir(D)) { + next if (! -f "$deb/$f"); + next if ("$deb/$f" !~ /\.deb$/); + &$check_deb_arch("$deb/$f"); + } + closedir(D); + } else { + $self->log_warning("$deb is neither a regular file nor a directory. Skipping...\n"); + } + } + + # Check package arch makes sense to build + if (!$dscarchs) { + $self->log_warning("dsc has no Architecture: field -- skipping arch check!\n"); + } elsif ($self->get_conf('BUILD_SOURCE')) { + # If the source package is to be built, then we do not need to check + # if any of the source package's architectures can be built given the + # current host architecture because then no matter the Architectures + # field, at least the source package will end up getting built. + } else { + my $valid_arch; + for my $a (split(/\s+/, $dscarchs)) { + # Check architecture wildcard matching with dpkg inside the chroot + # to avoid situations in which dpkg outside the chroot doesn't + # know about a new architecture yet + my $command = <<"EOF"; + use strict; + use warnings; + use Dpkg::Arch; + if (Dpkg::Arch::debarch_is('$host_arch', '$a')) { + exit 0; + } + exit 1; +EOF + $session->run_command( + { COMMAND => ['perl', + '-e', + $command], + USER => 'root', + PRIORITY => 0, + DIR => '/' }); + if ($? == 0) { + $valid_arch = 1; + last; + } + } + if ($dscarchs ne "any" && !($valid_arch) && + !($dscarchs =~ /\ball\b/ && $self->get_conf('BUILD_ARCH_ALL')) ) { + my $msg = "dsc: $host_arch not in arch list or does not match any arch wildcards: $dscarchs -- skipping"; + $self->log_error("$msg\n"); + Sbuild::Exception::Build->throw(error => $msg, + status => "skipped", + failstage => "arch-check"); + return 0; + } + } + + $self->log("Arch check ok ($host_arch included in $dscarchs)\n"); + + return 1; +} + +# Subroutine that runs any command through the system (i.e. not through the +# chroot. It takes a string of a command with arguments to run along with +# arguments whether to save STDOUT and/or STDERR to the log stream +sub run_command { + my $self = shift; + my $command = shift; + my $log_output = shift; + my $log_error = shift; + my $chroot = shift; + + # Used to determine if we are to log from commands + my ($out, $err, $defaults); + + # Run the command and save the exit status + if (!$chroot) + { + $defaults = $self->get('Host')->{'Defaults'}; + $out = $defaults->{'STREAMOUT'} if ($log_output); + $err = $defaults->{'STREAMERR'} if ($log_error); + + my %args = (PRIORITY => 0, + STREAMOUT => $out, + STREAMERR => $err); + if(ref $command) { + $args{COMMAND} = \@{$command}; + $args{COMMAND_STR} = "@{$command}"; + } else { + $args{COMMAND} = [split('\s+', $command)]; + $args{COMMAND_STR} = $command; + } + + $self->get('Host')->run_command( \%args ); + } else { + $defaults = $self->get('Session')->{'Defaults'}; + $out = $defaults->{'STREAMOUT'} if ($log_output); + $err = $defaults->{'STREAMERR'} if ($log_error); + + my %args = (USER => 'root', + PRIORITY => 0, + STREAMOUT => $out, + STREAMERR => $err); + if(ref $command) { + $args{COMMAND} = \@{$command}; + $args{COMMAND_STR} = "@{$command}"; + } else { + $args{COMMAND} = [split('\s+', $command)]; + $args{COMMAND_STR} = $command; + } + + $self->get('Session')->run_command( \%args ); + } + my $status = $?; + + # Check if the command failed + if ($status != 0) { + return 0; + } + return 1; +} + +# Subroutine that processes external commands to be run during various stages of +# an sbuild run. We also ask if we want to log any output from the commands +sub run_external_commands { + my $self = shift; + my $stage = shift; + + my $log_output = $self->get_conf('LOG_EXTERNAL_COMMAND_OUTPUT'); + my $log_error = $self->get_conf('LOG_EXTERNAL_COMMAND_ERROR'); + + # Return success now unless there are commands to run + return 1 unless (${$self->get_conf('EXTERNAL_COMMANDS')}{$stage}); + + # Determine which set of commands to run based on the parameter $stage + my @commands = @{${$self->get_conf('EXTERNAL_COMMANDS')}{$stage}}; + return 1 if !(@commands); + + # Create appropriate log message and determine if the commands are to be + # run inside the chroot or not, and as root or not. + my $chroot = 0; + if ($stage eq "pre-build-commands") { + $self->log_subsection("Pre Build Commands"); + } elsif ($stage eq "chroot-setup-commands") { + $self->log_subsection("Chroot Setup Commands"); + $chroot = 1; + } elsif ($stage eq "chroot-update-failed-commands") { + $self->log_subsection("Chroot-update Install Failed Commands"); + $chroot = 1; + } elsif ($stage eq "build-deps-failed-commands") { + $self->log_subsection("Build-Deps Install Failed Commands"); + $chroot = 1; + } elsif ($stage eq "build-failed-commands") { + $self->log_subsection("Generic Build Failed Commands"); + $chroot = 1; + } elsif ($stage eq "starting-build-commands") { + $self->log_subsection("Starting Timed Build Commands"); + $chroot = 1; + } elsif ($stage eq "finished-build-commands") { + $self->log_subsection("Finished Timed Build Commands"); + $chroot = 1; + } elsif ($stage eq "chroot-cleanup-commands") { + $self->log_subsection("Chroot Cleanup Commands"); + $chroot = 1; + } elsif ($stage eq "post-build-commands") { + $self->log_subsection("Post Build Commands"); + } elsif ($stage eq "post-build-failed-commands") { + $self->log_subsection("Post Build Failed Commands"); + } + + # Run each command, substituting the various percent escapes (like + # %SBUILD_DSC) from the commands to run with the appropriate subsitutions. + my $hostarch = $self->get('Host Arch'); + my $buildarch = $self->get('Build Arch'); + my $build_dir = $self->get('Build Dir'); + my $shell_cmd = "bash -i </dev/tty >/dev/tty 2>/dev/tty"; + my %percent = ( + "%" => "%", + "a" => $hostarch, "SBUILD_HOST_ARCH" => $hostarch, + "SBUILD_BUILD_ARCH" => $buildarch, + "b" => $build_dir, "SBUILD_BUILD_DIR" => $build_dir, + "s" => $shell_cmd, "SBUILD_SHELL" => $shell_cmd, + ); + if ($self->get('Changes File')) { + my $changes = $self->get('Changes File'); + $percent{c} = $changes; + $percent{SBUILD_CHANGES} = $changes; + } + # In case set_version has not been run yet, we do not know the dsc file or + # directory yet. This can happen if the user only specified a source + # package name without a version on the command line. + if ($self->get('DSC Dir')) { + my $dsc = $self->get('DSC'); + $percent{d} = $dsc; + $percent{SBUILD_DSC} = $dsc; + my $pkgbuild_dir = $build_dir . '/' . $self->get('DSC Dir'); + $percent{p} = $pkgbuild_dir; + $percent{SBUILD_PKGBUILD_DIR} = $pkgbuild_dir; + } + if ($chroot == 0) { + my $chroot_dir = $self->get('Session')->get('Location'); + $percent{r} = $chroot_dir; + $percent{SBUILD_CHROOT_DIR} = $chroot_dir; + # the %SBUILD_CHROOT_EXEC escape is only defined when the command is + # to be run outside the chroot + my $exec_string = $self->get('Session')->get_internal_exec_string(); + $percent{e} = $exec_string; + $percent{SBUILD_CHROOT_EXEC} = $exec_string; + } + # Our escapes pattern, with longer escapes first, then sorted lexically. + my $keyword_pat = join("|", + sort {length $b <=> length $a || $a cmp $b} keys %percent); + my $returnval = 1; + foreach my $command (@commands) { + + my $substitute = sub { + foreach(@_) { + if (/\%SBUILD_CHROOT_DIR/ || /\%r/) { + $self->log_warning("The %SBUILD_CHROOT_DIR and %r percentage escapes are deprecated and should not be used anymore. Please use %SBUILD_CHROOT_EXEC or %e instead."); + } + s{ + # Match a percent followed by a valid keyword + \%($keyword_pat) + }{ + # Substitute with the appropriate value only if it's defined + $percent{$1} || $& + }msxge; + } + }; + + my $command_str; + if( ref $command ) { + $substitute->(@{$command}); + $command_str = join(" ", @{$command}); + } else { + $substitute->($command); + $command_str = $command; + } + + $self->log_subsubsection("$command_str"); + + $returnval = $self->run_command($command, $log_output, $log_error, $chroot); + $self->log("\n"); + if (!$returnval) { + $self->log_error("Command '$command_str' failed to run.\n"); + # do not run any other commands of this type after the first + # failure + last; + } else { + $self->log_info("Finished running '$command_str'.\n"); + } + } + $self->log("\nFinished processing commands.\n"); + $self->log_sep(); + return $returnval; +} + +sub run_lintian { + my $self = shift; + my $session = $self->get('Session'); + + return 1 unless ($self->get_conf('RUN_LINTIAN')); + $self->set('Lintian Reason', 'error'); + + if (!defined($session)) { + $self->log_error("Session is undef. Cannot run lintian.\n"); + return 0; + } + + $self->log_subsubsection("lintian"); + + my $build_dir = $self->get('Build Dir'); + my $resolver = $self->get('Dependency Resolver'); + my $lintian = $self->get_conf('LINTIAN'); + my $changes = $self->get_changes(); + if (!defined($changes)) { + $self->log_error(".changes is undef. Cannot run lintian.\n"); + return 0; + } + + my @lintian_command = ($lintian); + push @lintian_command, @{$self->get_conf('LINTIAN_OPTIONS')} if + ($self->get_conf('LINTIAN_OPTIONS')); + push @lintian_command, $changes; + + # If the source package was not instructed to be built, then it will not + # be part of the .changes file and thus, the .dsc has to be passed to + # lintian in addition to the .changes file. + if (!$self->get_conf('BUILD_SOURCE')) { + my $dsc = $self->get('DSC File'); + push @lintian_command, $dsc; + } + + $resolver->add_dependencies('LINTIAN', 'lintian:native', "", "", "", "", ""); + return 1 unless $resolver->install_deps('lintian', 'LINTIAN'); + + $self->log("Running lintian...\n"); + + # we are not using read_command() because we also need the output for + # non-zero exit codes + my $pipe = $session->pipe_command( + { COMMAND => \@lintian_command, + PRIORITY => 0, + DIR => $self->get('Build Dir'), + PIPE => "in" + }); + if (!$pipe) { + $self->log_error("Failed to exec Lintian: $!\n"); + return 0; + } + my $lintian_output = ""; + while (my $line = <$pipe>) { + $self->log($line); + $lintian_output .= $line; + } + close $pipe; + + $self->log("\n"); + if ($?) { + my $status = $? >> 8; + my $why = "unknown reason"; + $self->set('Lintian Reason', 'fail') if ($status == 1); + $why = "runtime error" if ($status == 2); + $why = "policy violation" if ($status == 1); + $why = "received signal " . $? & 127 if ($? & 127); + $self->log_error("Lintian run failed ($why)\n"); + + return 0; + } else { + $self->set('Lintian Reason', 'pass'); + if ($lintian_output =~ m/^I: /m) { + $self->set('Lintian Reason', 'info'); + } + if ($lintian_output =~ m/^W: /m) { + $self->set('Lintian Reason', 'warn'); + } + } + + $self->log_info("Lintian run was successful.\n"); + return 1; +} + +sub run_piuparts { + my $self = shift; + + return 1 unless ($self->get_conf('RUN_PIUPARTS')); + $self->set('Piuparts Reason', 'fail'); + + $self->log_subsubsection("piuparts"); + + my $piuparts = $self->get_conf('PIUPARTS'); + my @piuparts_command; + # The default value is the empty array. + # If the value is the default (empty array) prefix with 'sudo --' + # If the value is a non-empty array, prefix with its values except if the + # first value is an empty string in which case, prefix with nothing + # If the value is not an array, prefix with that scalar except if the + # scalar is the empty string in which case, prefix with nothing + if (ref($self->get_conf('PIUPARTS_ROOT_ARGS')) eq "ARRAY") { + if (scalar(@{$self->get_conf('PIUPARTS_ROOT_ARGS')})) { + if (@{$self->get_conf('PIUPARTS_ROOT_ARGS')}[0] ne '') { + push @piuparts_command, @{$self->get_conf('PIUPARTS_ROOT_ARGS')}; + } + } else { + push @piuparts_command, 'sudo', '--'; + } + } else { + if ($self->get_conf('PIUPARTS_ROOT_ARGS') ne '') { + push @piuparts_command, $self->get_conf('PIUPARTS_ROOT_ARGS'); + } + } + push @piuparts_command, $piuparts; + push @piuparts_command, @{$self->get_conf('PIUPARTS_OPTIONS')} if + ($self->get_conf('PIUPARTS_OPTIONS')); + push @piuparts_command, $self->get('Changes File'); + $self->get('Host')->run_command( + { COMMAND => \@piuparts_command, + PRIORITY => 0, + }); + my $status = $? >> 8; + + # We must check for Ctrl+C (and other aborting signals) directly after + # running the command so that we do not mark the piuparts run as successful + # (the exit status will be zero) + $self->check_abort(); + + $self->log("\n"); + + if ($status == 0) { + $self->set('Piuparts Reason', 'pass'); + } else { + $self->log_error("Piuparts run failed.\n"); + return 0; + } + + $self->log_info("Piuparts run was successful.\n"); + return 1; +} + +sub run_autopkgtest { + my $self = shift; + + return 1 unless ($self->get_conf('RUN_AUTOPKGTEST')); + + $self->set('Autopkgtest Reason', 'fail'); + + $self->log_subsubsection("autopkgtest"); + + my $session = $self->get('Session'); + + # sbuild used to check whether debian/tests/control exists and would not + # run autopkgtest at all if it didn't. This is wrong behaviour because + # even packages without a debian/tests/control or packages without a + # Testsuite: field in debian/control might still have autopkgtests as they + # are generated by autodep8. We will not attempt to recreate the autodep8 + # heuristics here and thus we will always run autopkgtest if + # RUN_AUTOPKGTEST was set to true. Also see + # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916924 + + my $autopkgtest = $self->get_conf('AUTOPKGTEST'); + my @autopkgtest_command; + # The default value is the empty array. + # If the value is the default (empty array) prefix with 'sudo --' + # If the value is a non-empty array, prefix with its values except if the + # first value is an empty string in which case, prefix with nothing + # If the value is not an array, prefix with that scalar except if the + # scalar is the empty string in which case, prefix with nothing + if (ref($self->get_conf('AUTOPKGTEST_ROOT_ARGS')) eq "ARRAY") { + if (scalar(@{$self->get_conf('AUTOPKGTEST_ROOT_ARGS')}) == 0) { + push @autopkgtest_command, 'sudo', '--'; + } elsif (@{$self->get_conf('AUTOPKGTEST_ROOT_ARGS')}[0] eq '') { + # do nothing if the first array element is the empty string + } else { + push @autopkgtest_command, @{$self->get_conf('AUTOPKGTEST_ROOT_ARGS')}; + } + } elsif ($self->get_conf('AUTOPKGTEST_ROOT_ARGS') eq '') { + # do nothing if the configuration value is the empty string + } else { + push @autopkgtest_command, $self->get_conf('AUTOPKGTEST_ROOT_ARGS'); + } + push @autopkgtest_command, $autopkgtest; + my $tmpdir; + my @cwd_files; + # If the source package was not instructed to be built, then it will not + # be part of the .changes file and thus, the .dsc has to be passed to + # autopkgtest in addition to the .changes file. + if (!$self->get_conf('BUILD_SOURCE')) { + my $dsc = $self->get('DSC'); + # If the source package was downloaded by sbuild, then the .dsc + # and the files it references have to be made available to the + # host + if (! -f $dsc || ! -r $dsc) { + my $build_dir = $self->get('Build Dir'); + $tmpdir = mkdtemp("/tmp/tmp.sbuild.XXXXXXXXXX"); + if (!$session->copy_from_chroot("$build_dir/$dsc", "$tmpdir/$dsc")) { + $self->log_error("cannot copy .dsc from chroot\n"); + rmdir $tmpdir; + return 0; + } + @cwd_files = dsc_files("$tmpdir/$dsc"); + foreach (@cwd_files) { + if (!$session->copy_from_chroot("$build_dir/$_", "$tmpdir/$_")) { + $self->log_error("cannot copy $_ from chroot\n"); + unlink "$tmpdir/$.dsc"; + foreach (@cwd_files) { + unlink "$tmpdir/$_" if -f "$tmpdir/$_"; + } + rmdir $tmpdir; + return 0; + } + } + $dsc = "$tmpdir/$dsc"; + } + push @autopkgtest_command, $dsc; + } + push @autopkgtest_command, $self->get('Changes File'); + if (scalar(@{$self->get_conf('AUTOPKGTEST_OPTIONS')})) { + push @autopkgtest_command, @{$self->get_conf('AUTOPKGTEST_OPTIONS')}; + } else { + push @autopkgtest_command, '--', 'null'; + } + $self->get('Host')->run_command( + { COMMAND => \@autopkgtest_command, + PRIORITY => 0, + }); + my $status = $? >> 8; + # if the source package wasn't built and also initially downloaded by + # sbuild, then the temporary directory that was created must be removed + if (defined $tmpdir) { + my $dsc = $self->get('DSC'); + unlink "$tmpdir/$dsc"; + foreach (@cwd_files) { + unlink "$tmpdir/$_"; + } + rmdir $tmpdir; + } + + # We must check for Ctrl+C (and other aborting signals) directly after + # running the command so that we do not mark the autopkgtest as successful + # (the exit status will be zero) + # But we must check only after the temporary directory has been removed. + $self->check_abort(); + + $self->log("\n"); + + if ($status == 0 || $status == 2) { # 2 is "at least one test was skipped (or at least one flaky test failed)" + $self->set('Autopkgtest Reason', 'pass'); + } elsif ($status == 8) { + $self->set('Autopkgtest Reason', 'no tests'); + } else { + # fail if neither all tests passed nor was the package without tests + $self->log_error("Autopkgtest run failed.\n"); + return 0; + } + + $self->log_info("Autopkgtest run was successful.\n"); + return 1; +} + +sub explain_bd_uninstallable { + my $self = shift; + + my $resolver = $self->get('Dependency Resolver'); + + my $dummy_pkg_name = $resolver->get_sbuild_dummy_pkg_name('main'); + + if (!defined $self->get_conf('BD_UNINSTALLABLE_EXPLAINER')) { + return 0; + } elsif ($self->get_conf('BD_UNINSTALLABLE_EXPLAINER') eq '') { + return 0; + } elsif ($self->get_conf('BD_UNINSTALLABLE_EXPLAINER') eq 'apt') { + my (@instd, @rmvd); + my @apt_args = ('--simulate', \@instd, \@rmvd, 'install', $dummy_pkg_name, + '-oDebug::pkgProblemResolver=true', '-oDebug::pkgDepCache::Marker=1', + '-oDebug::pkgDepCache::AutoInstall=1', '-oDebug::BuildDeps=1' + ); + $resolver->run_apt(@apt_args); + } elsif ($self->get_conf('BD_UNINSTALLABLE_EXPLAINER') eq 'dose3') { + # To retrieve all Packages files apt knows about we use "apt-get + # indextargets" and "apt-helper cat-file". The former is able to + # report the filesystem path of all input Packages files. The latter + # is able to decompress the files if necessary. + # + # We do not use "apt-cache dumpavail" or convert the EDSP output to a + # Packages file because that would make the package selection subject + # to apt pinning. This limitation would be okay if there was only the + # apt resolver but since there also exists the aptitude and aspcud + # resolvers which are able to find solution without pinning + # restrictions, we don't want to limit ourselves by it. In cases where + # apt cannot find a solution, this check is supposed to allow the user + # to know that choosing a different resolver might fix the problem. + $resolver->add_dependencies('DOSE3', 'dose-distcheck:native', "", "", "", "", ""); + if (!$resolver->install_deps('dose3', 'DOSE3')) { + return 0; + } + + my $session = $self->get('Session'); + my $pipe_apt = $session->pipe_command({ + COMMAND => [ 'apt-get', 'indextargets', '--format', '$(FILENAME)', 'Created-By: Packages' ], + USER => $self->get_conf('BUILD_USER'), + }); + if (!$pipe_apt) { + $self->log_error("cannot open reading pipe from apt-get indextargets\n"); + return 0; + } + + my $host = $self->get_conf('HOST_ARCH'); + my $build = $self->get_conf('BUILD_ARCH'); + my @debforeignarg = (); + if ($build ne $host) { + @debforeignarg = ('--deb-foreign-archs', $host); + } + + # - We run dose-debcheck instead of dose-builddebcheck because we want + # to check the dummy binary package created by sbuild instead of the + # original source package Build-Depends. + # - We use dose-debcheck instead of dose-distcheck because we cannot + # use the deb:// prefix on data from standard input. + my $pipe_dose = $session->pipe_command({ + COMMAND => ['dose-debcheck', + '--checkonly', "$dummy_pkg_name:$host", '--verbose', + '--failures', '--successes', '--explain', + '--deb-native-arch', $self->get_conf('BUILD_ARCH'), @debforeignarg ], + PRIORITY => 0, + USER => $self->get_conf('BUILD_USER'), + PIPE => 'out' + }); + if (!$pipe_dose) { + $self->log_error("cannot open writing pipe to dose-debcheck\n"); + return 0; + } + + # We parse file by file instead of concatenating all files because if + # there are many files, we might exceed the maximum command length and + # it avoids having to have the data from all Packages files in memory + # all at once. Working with a smaller Dpkg::Index structure should + # also result in faster store and retrieval times. + while (my $fname = <$pipe_apt>) { + chomp $fname; + my $pipe_cat = $session->pipe_command({ + COMMAND => [ '/usr/lib/apt/apt-helper', 'cat-file', $fname ], + USER => $self->get_conf('BUILD_USER'), + }); + if (!$pipe_cat) { + $self->log_error("cannot open reading pipe from apt-helper\n"); + return 0; + } + + # For native compilation we just pipe the output of apt-helper to + # dose3. For cross compilation we need to filter foreign + # architecture packages that are Essential:yes or + # Multi-Arch:foreign or otherwise dose3 might present a solution + # that installs foreign architecture Essential:yes or + # Multi-Arch:foreign packages. + if ($build eq $host) { + File::Copy::copy $pipe_cat, $pipe_dose; + } else { + my $key_func = sub { + return $_[0]->{Package} . ' ' . $_[0]->{Version} . ' ' . $_[0]->{Architecture}; + }; + + my $index = Dpkg::Index->new(get_key_func=>$key_func); + + if (!$index->parse($pipe_cat, 'apt-helper cat-file')) { + $self->log_error("Cannot parse output of apt-helper cat-file: $!\n"); + return 0; + } + + foreach my $key ($index->get_keys()) { + my $cdata = $index->get_by_key($key); + my $arch = $cdata->{'Architecture'} // ''; + my $ess = $cdata->{'Essential'} // ''; + my $ma = $cdata->{'Multi-Arch'} // ''; + if ($arch ne 'all' && $arch ne $build + && ($ess eq 'yes' || $ma eq 'foreign')) { + next; + } + $cdata->output($pipe_dose); + print $pipe_dose "\n"; + } + } + + close($pipe_cat); + if (($? >> 8) != 0) { + $self->log_error("apt-helper failed\n"); + return 0; + } + } + + close $pipe_dose; + # - We expect an exit code of less than 64 of dose-debcheck. Any other + # exit code indicates abnormal program termination. + if (($? >> 8) >= 64) { + $self->log_error("dose-debcheck failed\n"); + return 0; + } + + close $pipe_apt; + if (($? >> 8) != 0) { + $self->log_error("apt-get indextargets failed\n"); + return 0; + } + + + } + + return 1; +} + +sub build { + my $self = shift; + + my $dscfile = $self->get('DSC File'); + my $dscdir = $self->get('DSC Dir'); + my $pkg = $self->get('Package'); + my $build_dir = $self->get('Build Dir'); + my $host_arch = $self->get('Host Arch'); + my $build_arch = $self->get('Build Arch'); + my $session = $self->get('Session'); + + my( $rv, $changes ); + local( *PIPE, *F, *F2 ); + + $self->log_subsection("Build"); + $self->set('This Space', 0); + + my $tmpunpackdir = $dscdir; + $tmpunpackdir =~ s/-.*$/.orig.tmp-nest/; + $tmpunpackdir =~ s/_/-/; + $tmpunpackdir = "$build_dir/$tmpunpackdir"; + + $dscdir = "$build_dir/$dscdir"; + + $self->log_subsubsection("Unpack source"); + if ($session->test_directory($dscdir) && $session->test_symlink($dscdir)) { + # if the package dir already exists but is a symlink, complain + $self->log_error("Cannot unpack source: a symlink to a directory with the\n". + "same name already exists.\n"); + return 0; + } + my $dsccontent = $session->read_file("$build_dir/$dscfile"); + if (!$dsccontent) { + $self->log_error("Cannot read $build_dir/$dscfile\n"); + } else { + $self->log($dsccontent); + $self->log("\n"); + } + if (!$session->test_directory($dscdir)) { + $self->set('Sub Task', "dpkg-source"); + $session->run_command({ + COMMAND => [$self->get_conf('DPKG_SOURCE'), + '-x', $dscfile, $dscdir], + USER => $self->get_conf('BUILD_USER'), + DIR => $build_dir, + PRIORITY => 0}); + if ($?) { + $self->log_error("FAILED [dpkg-source died]\n"); + Sbuild::Exception::Build->throw(error => "FAILED [dpkg-source died]", + failstage => "unpack"); + } + + if (!$session->chmod($dscdir, 'g-s,go+rX', { RECURSIVE => 1 })) { + $self->log_error("chmod -R g-s,go+rX $dscdir failed.\n"); + Sbuild::Exception::Build->throw(error => "chmod -R g-s,go+rX $dscdir failed", + failstage => "unpack"); + } + } + else { + $self->log_subsubsection("Check unpacked source"); + # check if the unpacked tree is really the version we need + my $clog = $session->read_command( + { COMMAND => ['dpkg-parsechangelog'], + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0, + DIR => $dscdir}); + if (!$clog) { + $self->log_error("unable to read from dpkg-parsechangelog\n"); + Sbuild::Exception::Build->throw(error => "unable to read from dpkg-parsechangelog", + failstage => "check-unpacked-version"); + } + $self->set('Sub Task', "dpkg-parsechangelog"); + + if ($clog !~ /^Version:\s*(.+)\s*$/mi) { + $self->log_error("dpkg-parsechangelog didn't print Version:\n"); + Sbuild::Exception::Build->throw(error => "dpkg-parsechangelog didn't print Version:", + failstage => "check-unpacked-version"); + } + } + + $self->log_subsubsection("Check disk space"); + chomp(my $current_usage = $session->read_command({ COMMAND => ["du", "-k", "-s", "$dscdir"]})); + if ($?) { + $self->log_error("du exited with non-zero exit status $?\n"); + Sbuild::Exception::Build->throw(error => "du exited with non-zero exit status $?", failstage => "check-space"); + } + $current_usage =~ /^(\d+)/; + $current_usage = $1; + if ($current_usage) { + my $pipe = $session->pipe_command({ COMMAND => ["df", "-k", "$dscdir"]}); + my $free; + while (<$pipe>) { + $free = (split /\s+/)[3]; + } + close $pipe; + if ($?) { + $self->log_error("df exited with non-zero exit status $?\n"); + Sbuild::Exception::Build->throw(error => "df exited with non-zero exit status $?", failstage => "check-space"); + } + if ($free < 2*$current_usage && $self->get_conf('CHECK_SPACE')) { + Sbuild::Exception::Build->throw(error => "Disk space is probably not sufficient for building.", + info => "Source needs $current_usage KiB, while $free KiB is free.)", + failstage => "check-space"); + } else { + $self->log("Sufficient free space for build\n"); + } + } + + my $clogpipe = $session->pipe_command( + { COMMAND => ['dpkg-parsechangelog'], + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0, + DIR => $dscdir }); + if (!$clogpipe) { + $self->log_error("unable to read from dpkg-parsechangelog\n"); + Sbuild::Exception::Build->throw(error => "unable to read from dpkg-parsechangelog", + failstage => "check-unpacked-version"); + } + + my $clog = Dpkg::Control->new(type => CTRL_CHANGELOG); + if (!$clog->parse($clogpipe, "$dscdir/debian/changelog")) { + $self->log_error("unable to parse debian/changelog\n"); + Sbuild::Exception::Build->throw(error => "unable to parse debian/changelog", + failstage => "check-unpacked-version"); + } + + close($clogpipe); + + my $name = $clog->{Source}; + my $version = $clog->{Version}; + my $dists = $clog->{Distribution}; + my $urgency = $clog->{Urgency}; + + if ($dists ne $self->get_conf('DISTRIBUTION')) { + $self->build_log_colour('yellow', + "^Distribution: " . $self->get_conf('DISTRIBUTION') . "\$"); + } + + if ($self->get_conf('BIN_NMU') || $self->get_conf('APPEND_TO_VERSION') + || defined $self->get_conf('BIN_NMU_CHANGELOG')) { + $self->log_subsubsection("Hack binNMU version"); + + my $text = $session->read_file("$dscdir/debian/changelog"); + + if (!$text) { + $self->log_error("Can't open debian/changelog -- no binNMU hack!\n"); + Sbuild::Exception::Build->throw(error => "Can't open debian/changelog -- no binNMU hack: $!!", + failstage => "hack-binNMU"); + } + + my $NMUversion = $self->get('Version'); + + my $clogpipe = $session->get_write_file_handle("$dscdir/debian/changelog"); + + if (!$clogpipe) { + $self->log_error("Can't open debian/changelog for binNMU hack: $!\n"); + Sbuild::Exception::Build->throw(error => "Can't open debian/changelog for binNMU hack: $!", + failstage => "hack-binNMU"); + } + if (defined $self->get_conf('BIN_NMU_CHANGELOG')) { + my $clogentry = $self->get_conf('BIN_NMU_CHANGELOG'); + # trim leading and trailing whitespace and linebreaks + $clogentry =~ s/^\s+|\s+$//g; + print $clogpipe $clogentry . "\n\n"; + } else { + if (!$self->get_conf('MAINTAINER_NAME')) { + Sbuild::Exception::Build->throw(error => "No maintainer specified.", + info => 'When making changelog additions for a binNMU or appending a version suffix, a maintainer must be specified for the changelog entry e.g. using $maintainer_name, $uploader_name or $key_id, (or the equivalent command-line options)', + failstage => "check-space"); + } + + $dists = $self->get_conf('DISTRIBUTION'); + + print $clogpipe "$name ($NMUversion) $dists; urgency=low, binary-only=yes\n\n"; + if ($self->get_conf('APPEND_TO_VERSION')) { + print $clogpipe " * Append ", $self->get_conf('APPEND_TO_VERSION'), + " to version number; no source changes\n"; + } + if ($self->get_conf('BIN_NMU')) { + print $clogpipe " * Binary-only non-maintainer upload for $host_arch; ", + "no source changes.\n"; + print $clogpipe " * ", join( " ", split( "\n", $self->get_conf('BIN_NMU') )), "\n"; + } + print $clogpipe "\n"; + + # Earlier implementations used the date of the last changelog + # entry for the new entry so that Multi-Arch:same packages would + # be co-installable (their shared changelogs had to match). This + # is not necessary anymore as binNMU changelogs are now written + # into architecture specific paths. Re-using the date of the last + # changelog entry has the disadvantage that this will effect + # SOURCE_DATE_EPOCH which in turn will make the timestamps of the + # files in the new package equal to the last version which can + # confuse backup programs. By using the build date for the new + # binNMU changelog timestamp we make sure that the timestamps of + # changed files inside the new package advanced in comparison to + # the last version. + # + # The timestamp format has to follow Debian Policy §4.4 + # https://www.debian.org/doc/debian-policy/ch-source.html#s-dpkgchangelog + # which is the same format as `date -R` + my $date; + if (defined $self->get_conf('BIN_NMU_TIMESTAMP')) { + if ($self->get_conf('BIN_NMU_TIMESTAMP') =~ /^\+?[1-9]\d*$/) { + $date = strftime_c "%a, %d %b %Y %H:%M:%S +0000", + gmtime($self->get_conf('BIN_NMU_TIMESTAMP')); + } else { + $date = $self->get_conf('BIN_NMU_TIMESTAMP'); + } + } else { + $date = strftime_c "%a, %d %b %Y %H:%M:%S +0000", gmtime(); + } + print $clogpipe " -- " . $self->get_conf('MAINTAINER_NAME') . " $date\n\n"; + } + print $clogpipe $text; + close($clogpipe); + $self->log("Created changelog entry for binNMU version $NMUversion\n"); + } + + if ($session->test_regular_file("$dscdir/debian/files")) { + local( *FILES ); + my @lines; + my $FILES = $session->get_read_file_handle("$dscdir/debian/files"); + chomp( @lines = <$FILES> ); + close( $FILES ); + + $self->log_warning("After unpacking, there exists a file debian/files with the contents:\n"); + + $self->log_sep(); + foreach (@lines) { + $self->log($_); + } + $self->log_sep(); + $self->log("\n"); + + $self->log_info("This should be reported as a bug.\n"); + $self->log_info("The file has been removed to avoid dpkg-genchanges errors.\n"); + + unlink "$dscdir/debian/files"; + } + + # Build tree not writable during build (except for the sbuild + # user performing the build). + if (!$session->chmod($self->get('Build Dir'), 'go-w', { RECURSIVE => 1 })) { + $self->log_error("chmod og-w " . $self->get('Build Dir') . " failed.\n"); + return 0; + } + + if (!$self->run_external_commands("starting-build-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute starting-build-commands", + failstage => "run-starting-build-commands"); + } + + $self->set('Build Start Time', time); + $self->set('Build End Time', $self->get('Build Start Time')); + + if ($session->test_regular_file("/etc/ld.so.conf") && + ! $session->test_regular_file_readable("/etc/ld.so.conf")) { + $session->chmod('/etc/ld.so.conf', 'a+r'); + + $self->log_subsubsection("Fix ld.so"); + $self->log("ld.so.conf was not readable! Fixed.\n"); + } + + my $buildcmd = []; + if (length $self->get_conf('BUILD_ENV_CMND') ) { + push( @{$buildcmd}, $self->get_conf('BUILD_ENV_CMND') ); + } + push (@{$buildcmd}, 'dpkg-buildpackage'); + + my $dpkgversion = version->new(0); + { + # we use pipe_command instead of read_command because we want to + # ignore non-zero exit code without printing an error message from + # dpkg versions before 1.20 which didn't have --robot + my $pipe = $session->pipe_command( + { + COMMAND => [ 'dpkg', '--robot', '--version' ], + STREAMERR => $devnull + } + ); + chomp( + my $content = do { local $/; <$pipe> } + ); + close $pipe; + if ( $? == 0 and $content =~ /^([0-9.]+)( .*)?$/ ) { + # dpkg is new enough for the --robot option + $dpkgversion = version->new($1); + } + } + # since dpkg 1.20.0 + # will reset environment and umask to their vendor specific defaults + if ($dpkgversion >= "1.20.0") { + push (@{$buildcmd}, '--sanitize-env'); + } + + if ($host_arch ne $build_arch) { + push (@{$buildcmd}, '-a' . $host_arch); + } + + if (length $self->get_conf('BUILD_PROFILES')) { + my $profiles = $self->get_conf('BUILD_PROFILES'); + $profiles =~ tr/ /,/; + push (@{$buildcmd}, '-P' . $profiles); + } + + if (defined $self->get_conf('PGP_OPTIONS')) { + if (ref($self->get_conf('PGP_OPTIONS')) eq 'ARRAY') { + push (@{$buildcmd}, @{$self->get_conf('PGP_OPTIONS')}); + } elsif (length $self->get_conf('PGP_OPTIONS')) { + push (@{$buildcmd}, $self->get_conf('PGP_OPTIONS')); + } + } + + if (defined $self->get_conf('SIGNING_OPTIONS')) { + if (ref($self->get_conf('SIGNING_OPTIONS')) eq 'ARRAY') { + push (@{$buildcmd}, @{$self->get_conf('SIGNING_OPTIONS')}); + } elsif (length $self->get_conf('SIGNING_OPTIONS')) { + push (@{$buildcmd}, $self->get_conf('SIGNING_OPTIONS')); + } + } + + use constant dpkgopt => [[["", "-B"], ["-A", "-b" ]], [["-S", "-G"], ["-g", ""]]]; + my $binopt = dpkgopt->[$self->get_conf('BUILD_SOURCE')] + [$self->get_conf('BUILD_ARCH_ALL')] + [$self->get_conf('BUILD_ARCH_ANY')]; + push (@{$buildcmd}, $binopt) if $binopt; + push (@{$buildcmd}, "-r" . $self->get_conf('FAKEROOT')); + + if ($self->get_conf('DPKG_FILE_SUFFIX')) { + my $dpkg_version_ok = Dpkg::Version->new("1.18.11"); + if ($self->get('Dpkg Version') >= $dpkg_version_ok) { + my $changes = $self->get_changes(); + push (@{$buildcmd}, "--changes-option=-O../$changes"); + my $buildinfo = $self->get_buildinfo(); + push (@{$buildcmd}, "--buildinfo-option=-O../$buildinfo"); + } else { + $self->log("Ignoring dpkg file suffix: dpkg version too old\n"); + $self->set_conf('DPKG_FILE_SUFFIX',undef); + } + } + + if (defined $self->get_conf('DPKG_BUILDPACKAGE_USER_OPTIONS')) { + push (@{$buildcmd}, @{$self->get_conf('DPKG_BUILDPACKAGE_USER_OPTIONS')}); + } + + # Set up additional build environment variables. + my %buildenv = %{$self->get_conf('BUILD_ENVIRONMENT')}; + $buildenv{'PATH'} = $self->get_conf('PATH'); + $buildenv{'LD_LIBRARY_PATH'} = $self->get_conf('LD_LIBRARY_PATH') + if defined($self->get_conf('LD_LIBRARY_PATH')); + + # Add cross environment config + if ($host_arch ne $build_arch) { + $buildenv{'CONFIG_SITE'} = "/etc/dpkg-cross/cross-config." . $host_arch; + # when cross-building, only set "nocheck" if DEB_BUILD_OPTIONS + # was not already set. This allows overwriting the default by + # setting the DEB_BUILD_OPTIONS environment variable + if (!defined($ENV{'DEB_BUILD_OPTIONS'})) { + $ENV{'DEB_BUILD_OPTIONS'} = "nocheck"; + } + } + + # Explicitly add any needed environment to the environment filter + # temporarily for dpkg-buildpackage. + my @env_filter; + foreach my $envvar (keys %buildenv) { + push(@env_filter, "^$envvar\$"); + } + + # Dump build environment + $self->log_subsubsection("User Environment"); + { + my $envcmd = $session->read_command( + { COMMAND => ['env'], + ENV => \%buildenv, + ENV_FILTER => \@env_filter, + USER => $self->get_conf('BUILD_USER'), + SETSID => 1, + PRIORITY => 0, + DIR => $dscdir + }); + if (!$envcmd) { + $self->log_error("unable to open pipe\n"); + Sbuild::Exception::Build->throw(error => "unable to open pipe", + failstage => "dump-build-env"); + } + + my @lines=sort(split /\n/, $envcmd); + foreach my $line (@lines) { + $self->log("$line\n"); + } + } + + $self->log_subsubsection("dpkg-buildpackage"); + $self->log("Command: " . join(' ', @{$buildcmd}) . "\n"); + + my $command = { + COMMAND => $buildcmd, + ENV => \%buildenv, + ENV_FILTER => \@env_filter, + USER => $self->get_conf('BUILD_USER'), + SETSID => 1, + PRIORITY => 0, + DIR => $dscdir, + STREAMERR => \*STDOUT, + DISABLE_NETWORK => 1, + }; + + my $pipe = $session->pipe_command($command); + if (!$pipe) { + $self->log_error("unable to open pipe\n"); + Sbuild::Exception::Build->throw(error => "unable to open pipe", + failstage => "dpkg-buildpackage"); + } + + $self->set('dpkg-buildpackage pid', $command->{'PID'}); + $self->set('Sub Task', "dpkg-buildpackage"); + + my $timeout = $self->get_conf('INDIVIDUAL_STALLED_PKG_TIMEOUT')->{$pkg} || + $self->get_conf('STALLED_PKG_TIMEOUT'); + $timeout *= 60; + my $timed_out = 0; + my(@timeout_times, @timeout_sigs, $last_time); + + local $SIG{'ALRM'} = sub { + my $pid = $self->get('dpkg-buildpackage pid'); + my $signal = ($timed_out > 0) ? "KILL" : "TERM"; + # negative pid to send to whole process group + kill "$signal", -$pid; + + $timeout_times[$timed_out] = time - $last_time; + $timeout_sigs[$timed_out] = $signal; + $timed_out++; + $timeout = 5*60; # only wait 5 minutes until next signal + }; + + alarm($timeout); + # We do not use a while(<$pipe>) {} loop because that one would only read + # full lines (until $/ is reached). But we do not want to tie "activity" + # to receiving complete lines on standard output and standard error. + # Receiving any data should be sufficient for a process to signal that it + # is still active. Thus, instead of reading lines, we use sysread() which + # will return us data once it is available even if the data is not + # terminated by a newline. To still print correctly to the log, we collect + # unterminated strings into an accumulator and print them to the log once + # the newline shows up. This has the added advantage that we can now not + # only treat \n as producing new lines ($/ is limited to a single + # character) but can also produce new lines when encountering a \r as it + # is common for progress-meter output of long-running processes. + my $acc = ""; + while(1) { + alarm($timeout); + $last_time = time; + # The buffer size is really arbitrary and just makes sure not to call + # this function too often if lots of data is produced by the build. + # The function will immediately return even with less data than the + # buffer size once it is available. + my $ret = sysread($pipe, my $buf, 1024); + # sysread failed - this for example happens when the build timeouted + # and is killed as a result + if (!defined $ret) { + last; + } + # A return value of 0 signals EOF + if ($ret == 0) { + last; + } + # We choose that lines shall not only be terminated by \n but that new + # log lines are also produced after encountering a \r. + # A negative limit is used to also produce trailing empty fields if + # required (think of multiple trailing empty lines). + my @parts = split /\r|\n/, $buf, -1; + my $numparts = scalar @parts; + if ($numparts == 1) { + # line terminator was not found + $acc .= $buf; + } elsif ($numparts >= 2) { + # first match needs special treatment as it needs to be + # concatenated with $acc + my $first = shift @parts; + $self->log($acc . $first . "\n"); + my $last = pop @parts; + for (my $i = 0; $i < $numparts - 2; $i++) { + $self->log($parts[$i] . "\n"); + } + # the last part is put into the accumulator. This might + # just be the empty string if $buf ended in a line + # terminator + $acc = $last; + } + } + # If the output didn't end with a line terminator, just print out the rest + # as we have it. + if ($acc ne "") { + $self->log($acc . "\n"); + } + close($pipe); + alarm(0); + $rv = $?; + $self->set('dpkg-buildpackage pid', undef); + + my $i; + for( $i = 0; $i < $timed_out; ++$i ) { + $self->log_error("Build killed with signal " . $timeout_sigs[$i] . + " after " . int($timeout_times[$i]/60) . + " minutes of inactivity\n"); + } + $self->set('Build End Time', time); + $self->set('Pkg End Time', time); + $self->set('This Time', $self->get('Pkg End Time') - $self->get('Pkg Start Time')); + $self->set('This Time', 0) if $self->get('This Time') < 0; + + $self->write_stats('build-time', + $self->get('Build End Time')-$self->get('Build Start Time')); + $self->write_stats('install-download-time', + $self->get('Install End Time')-$self->get('Install Start Time')); + my $finish_date = strftime_c "%FT%TZ", gmtime($self->get('Build End Time')); + $self->log_sep(); + $self->log("Build finished at $finish_date\n"); + + + if (!$self->run_external_commands("finished-build-commands")) { + Sbuild::Exception::Build->throw(error => "Failed to execute finished-build-commands", + failstage => "run-finished-build-commands"); + } + + my @space_files = (); + + $self->log_subsubsection("Finished"); + if ($rv) { + Sbuild::Exception::Build->throw(error => "Build failure (dpkg-buildpackage died)", + failstage => "build"); + } else { + $self->log_info("Built successfully\n"); + + if ($session->test_regular_file_readable("$dscdir/debian/files")) { + my @files = $self->debian_files_list("$dscdir/debian/files"); + + foreach (@files) { + if (!$session->test_regular_file("$build_dir/$_")) { + $self->log_error("Package claims to have built ".basename($_).", but did not. This is a bug in the packaging.\n"); + next; + } + if (/_all.u?deb$/ and not $self->get_conf('BUILD_ARCH_ALL')) { + $self->log_error("Package builds ".basename($_)." when binary-indep target is not called. This is a bug in the packaging.\n"); + $session->unlink("$build_dir/$_"); + next; + } + } + } + + # Restore write access to build tree now build is complete. + if (!$session->chmod($self->get('Build Dir'), 'g+w', { RECURSIVE => 1 })) { + $self->log_error("chmod g+w " . $self->get('Build Dir') . " failed.\n"); + return 0; + } + + $self->log_subsection("Changes"); + + # we use an anonymous subroutine so that the referenced variables are + # automatically rebound to their current values + my $copy_changes = sub { + my $changes = shift; + + my $F = $session->get_read_file_handle("$build_dir/$changes"); + if (!$F) { + $self->log_error("cannot get read file handle for $build_dir/$changes\n"); + Sbuild::Exception::Build->throw(error => "cannot get read file handle for $build_dir/$changes", + failstage => "parse-changes"); + } + my $pchanges = Dpkg::Control->new(type => CTRL_FILE_CHANGES); + if (!$pchanges->parse($F, "$build_dir/$changes")) { + $self->log_error("cannot parse $build_dir/$changes\n"); + Sbuild::Exception::Build->throw(error => "cannot parse $build_dir/$changes", + failstage => "parse-changes"); + } + close($F); + + + if ($self->get_conf('OVERRIDE_DISTRIBUTION')) { + $pchanges->{Distribution} = $self->get_conf('DISTRIBUTION'); + } + + my $sys_build_dir = $self->get_conf('BUILD_DIR'); + my $F2 = $session->get_write_file_handle("$build_dir/$changes.new"); + if (!$F2) { + $self->log("Cannot create $build_dir/$changes.new\n"); + $self->log("Distribution field may be wrong!!!\n"); + if ($build_dir) { + if(!$session->copy_from_chroot("$build_dir/$changes", ".")) { + $self->log_error("Could not copy $build_dir/$changes to .\n"); + } + } + } else { + $pchanges->output(\*STDOUT); + $pchanges->output(\*$F2); + + close( $F2 ); + + $session->rename("$build_dir/$changes.new", "$build_dir/$changes"); + if ($?) { + $self->log("$build_dir/$changes.new could not be " . + "renamed to $build_dir/$changes: $?\n"); + $self->log("Distribution field may be wrong!!!"); + } + if ($build_dir) { + if (!$session->copy_from_chroot("$build_dir/$changes", "$sys_build_dir")) { + $self->log("Could not copy $build_dir/$changes to $sys_build_dir"); + } + } + } + + return $pchanges; + }; + + $changes = $self->get_changes(); + if (!defined($changes)) { + $self->log_error(".changes is undef. Cannot copy build results.\n"); + return 0; + } + my @cfiles; + if ($session->test_regular_file_readable("$build_dir/$changes")) { + my(@do_dists, @saved_dists); + $self->log_subsubsection("$changes:"); + + my $pchanges = &$copy_changes($changes); + $self->set('Changes File', $self->get_conf('BUILD_DIR') . "/$changes"); + + my $checksums = Dpkg::Checksums->new(); + $checksums->add_from_control($pchanges); + + push(@cfiles, $checksums->get_files()); + + } + else { + $self->log_error("Can't find $changes -- can't dump info\n"); + } + + if ($self->get_conf('SOURCE_ONLY_CHANGES')) { + my $so_changes = $self->get('Package_SVersion') . "_source.changes"; + $self->log_subsubsection("$so_changes:"); + my $genchangescmd = ['dpkg-genchanges', '--build=source']; + if (defined $self->get_conf('SIGNING_OPTIONS')) { + if (ref($self->get_conf('SIGNING_OPTIONS')) eq 'ARRAY') { + push (@{$genchangescmd}, @{$self->get_conf('SIGNING_OPTIONS')}); + } elsif (length $self->get_conf('SIGNING_OPTIONS')) { + push (@{$genchangescmd}, $self->get_conf('SIGNING_OPTIONS')); + } + } + my $changes_opts = $self->get_changes_opts(); + if ($changes_opts) { + push (@{$genchangescmd}, @{$changes_opts}); + } + my $cfile = $session->read_command( + { COMMAND => $genchangescmd, + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0, + DIR => $dscdir}); + if (!$cfile) { + $self->log_error("dpkg-genchanges --build=source failed\n"); + Sbuild::Exception::Build->throw(error => "dpkg-genchanges --build=source failed", + failstage => "source-only-changes"); + } + if (!$session->write_file("$build_dir/$so_changes", $cfile)) { + $self->log_error("cannot write content to $build_dir/$so_changes\n"); + Sbuild::Exception::Build->throw(error => "cannot write content to $build_dir/$so_changes", + failstage => "source-only-changes"); + } + + my $pchanges = &$copy_changes($so_changes); + } + + $self->log_subsection("Buildinfo"); + + foreach (@cfiles) { + my $deb = "$build_dir/$_"; + next if $deb !~ /\.buildinfo$/; + my $buildinfo = $session->read_file($deb); + if (!$buildinfo) { + $self->log_error("Cannot read $deb\n"); + } else { + $self->log($buildinfo); + $self->log("\n"); + } + } + + $self->log_subsection("Package contents"); + + my @debcfiles = @cfiles; + foreach (@debcfiles) { + my $deb = "$build_dir/$_"; + next if $deb !~ /(\Q$host_arch\E|all)\.(udeb|deb)$/; + + $self->log_subsubsection("$_"); + my $dpkg_info = $session->read_command({COMMAND => ["dpkg", "--info", $deb]}); + if (!$dpkg_info) { + $self->log_error("Can't spawn dpkg: $! -- can't dump info\n"); + } + else { + $self->log($dpkg_info); + } + $self->log("\n"); + my $dpkg_contents = $session->read_command({COMMAND => ["sh", "-c", "dpkg --contents $deb 2>&1 | sort -k6"]}); + if (!$dpkg_contents) { + $self->log_error("Can't spawn dpkg: $! -- can't dump info\n"); + } + else { + $self->log($dpkg_contents); + } + $self->log("\n"); + } + + foreach (@cfiles) { + push( @space_files, $self->get_conf('BUILD_DIR') . "/$_"); + if (!$session->copy_from_chroot("$build_dir/$_", $self->get_conf('BUILD_DIR'))) { + $self->log_error("Could not copy $build_dir/$_ to " . $self->get_conf('BUILD_DIR') . "\n"); + } + } + } + + $self->set('This Space', $self->check_space(@space_files)); + + return $rv == 0 ? 1 : 0; +} + +# Produce a hash suitable for ENV export +sub get_env ($$) { + my $self = shift; + my $prefix = shift; + + sub _env_loop ($$$$) { + my ($env,$ref,$keysref,$prefix) = @_; + + foreach my $key (keys( %{ $keysref } )) { + my $value = $ref->get($key); + next if (!defined($value)); + next if (ref($value)); + my $name = "${prefix}${key}"; + $name =~ s/ /_/g; + $env->{$name} = $value; + } + } + + my $envlist = {}; + _env_loop($envlist, $self, $self, $prefix); + _env_loop($envlist, $self->get('Config'), $self->get('Config')->{'KEYS'}, "${prefix}CONF_"); + return $envlist; +} + +sub get_build_filename { + my $self=shift; + my $filetype=shift; + my $changes = $self->get('Package_SVersion'); + + if ($self->get_conf('BUILD_ARCH_ANY')) { + $changes .= '_' . $self->get('Host Arch'); + } elsif ($self->get_conf('BUILD_ARCH_ALL')) { + $changes .= "_all"; + } elsif ($self->get_conf('BUILD_SOURCE')) { + $changes .= "_source"; + } + + my $suffix = $self->get_conf('DPKG_FILE_SUFFIX'); + $changes .= $suffix if ($suffix); + + $changes .= '.' . $filetype; + + return $changes; +} + +sub get_changes { + my $self=shift; + return $self->get_build_filename("changes"); +} + +sub get_buildinfo { + my $self=shift; + return $self->get_build_filename("buildinfo"); +} + +sub check_space { + my $self = shift; + my @files = @_; + my $sum = 0; + + my $dscdir = $self->get('DSC Dir'); + return -1 unless (defined $dscdir); + + my $build_dir = $self->get('Build Dir'); + my $pkgbuilddir = "$build_dir/$dscdir"; + + # if the source package was not yet unpacked, we will not attempt to compute + # the required space. + return -1 unless ($self->get('Session')->test_directory($pkgbuilddir)); + + my ($space, $spacenum); + + # get the required space for the unpacked source package in the chroot + $space = $self->get('Session')->read_command( + { COMMAND => ['du', '-k', '-s', $pkgbuilddir], + USER => $self->get_conf('USERNAME'), + PRIORITY => 0, + DIR => '/'}); + + if (!$space) { + $self->log_error("Cannot determine space needed for $pkgbuilddir (du failed)\n"); + return -1; + } + # remove the trailing path from the du output + if (($spacenum) = $space =~ /^(\d+)/) { + $sum += $spacenum; + } else { + $self->log_error("Cannot determine space needed for $pkgbuilddir (unexpected du output): $space\n"); + return -1; + } + + # get the required space for all produced build artifacts on the host + # running sbuild + foreach my $file (@files) { + $space = $self->get('Host')->read_command( + { COMMAND => ['du', '-k', '-s', $file], + USER => $self->get_conf('USERNAME'), + PRIORITY => 0, + DIR => '/'}); + + if (!$space) { + $self->log_error("Cannot determine space needed for $file (du failed): $!\n"); + return -1; + } + # remove the trailing path from the du output + if (($spacenum) = $space =~ /^(\d+)/) { + $sum += $spacenum; + } else { + $self->log_error("Cannot determine space needed for $file (unexpected du output): $space\n"); + return -1; + } + } + + return $sum; +} + +sub lock_file { + my $self = shift; + my $file = shift; + my $for_srcdep = shift; + my $lockfile = "$file.lock"; + my $try = 0; + + repeat: + if (!sysopen( F, $lockfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644 )){ + if ($! == EEXIST) { + # lock file exists, wait + goto repeat if !open( F, "<$lockfile" ); + my $line = <F>; + my ($pid, $user); + close( F ); + if ($line !~ /^(\d+)\s+([\w\d.-]+)$/) { + $self->log_warning("Bad lock file contents ($lockfile) -- still trying\n"); + } + else { + ($pid, $user) = ($1, $2); + if (kill( 0, $pid ) == 0 && $! == ESRCH) { + # process doesn't exist anymore, remove stale lock + $self->log_warning("Removing stale lock file $lockfile ". + "(pid $pid, user $user)\n"); + unlink( $lockfile ); + goto repeat; + } + } + ++$try; + if (!$for_srcdep && $try > $self->get_conf('MAX_LOCK_TRYS')) { + $self->log_warning("Lockfile $lockfile still present after " . + $self->get_conf('MAX_LOCK_TRYS') * + $self->get_conf('LOCK_INTERVAL') . + " seconds -- giving up\n"); + return; + } + $self->log("Another sbuild process ($pid by $user) is currently installing or removing packages -- waiting...\n") + if $for_srcdep && $try == 1; + sleep $self->get_conf('LOCK_INTERVAL'); + goto repeat; + } + $self->log_warning("Can't create lock file $lockfile: $!\n"); + } + + my $username = $self->get_conf('USERNAME'); + F->print("$$ $username\n"); + F->close(); +} + +sub unlock_file { + my $self = shift; + my $file = shift; + my $lockfile = "$file.lock"; + + unlink( $lockfile ); +} + +sub add_stat { + my $self = shift; + my $key = shift; + my $value = shift; + + $self->get('Summary Stats')->{$key} = $value; +} + +sub generate_stats { + my $self = shift; + my $resolver = $self->get('Dependency Resolver'); + + $self->add_stat('Job', $self->get('Job')); + $self->add_stat('Package', $self->get('Package')); + # If the package fails early, then the version might not yet be known. + # This can happen if the user only specified a source package name on the + # command line and then the version will only be known after the source + # package was successfully downloaded. + if ($self->get('Version')) { + $self->add_stat('Version', $self->get('Version')); + } + if ($self->get('OVersion')) { + $self->add_stat('Source-Version', $self->get('OVersion')); + } + $self->add_stat('Machine Architecture', $self->get_conf('ARCH')); + $self->add_stat('Host Architecture', $self->get('Host Arch')); + $self->add_stat('Build Architecture', $self->get('Build Arch')); + $self->add_stat('Build Profiles', $self->get('Build Profiles')) + if $self->get('Build Profiles'); + $self->add_stat('Build Type', $self->get('Build Type')); + my @keylist; + if (defined $resolver) { + @keylist=keys %{$resolver->get('Initial Foreign Arches')}; + push @keylist, keys %{$resolver->get('Added Foreign Arches')}; + } + my $foreign_arches = join ' ', @keylist; + $self->add_stat('Foreign Architectures', $foreign_arches ) + if $foreign_arches; + $self->add_stat('Distribution', $self->get_conf('DISTRIBUTION')); + if ($self->get('This Space') >= 0) { + $self->add_stat('Space', $self->get('This Space')); + } else { + $self->add_stat('Space', "n/a"); + } + $self->add_stat('Build-Time', + $self->get('Build End Time')-$self->get('Build Start Time')); + $self->add_stat('Install-Time', + $self->get('Install End Time')-$self->get('Install Start Time')); + $self->add_stat('Package-Time', + $self->get('Pkg End Time')-$self->get('Pkg Start Time')); + if ($self->get('This Space') >= 0) { + $self->add_stat('Build-Space', $self->get('This Space')); + } else { + $self->add_stat('Build-Space', "n/a"); + } + $self->add_stat('Status', $self->get_status()); + $self->add_stat('Fail-Stage', $self->get('Pkg Fail Stage')) + if ($self->get_status() ne "successful"); + $self->add_stat('Lintian', $self->get('Lintian Reason')) + if $self->get('Lintian Reason'); + $self->add_stat('Piuparts', $self->get('Piuparts Reason')) + if $self->get('Piuparts Reason'); + $self->add_stat('Autopkgtest', $self->get('Autopkgtest Reason')) + if $self->get('Autopkgtest Reason'); +} + +sub log_stats { + my $self = shift; + foreach my $stat (sort keys %{$self->get('Summary Stats')}) { + $self->log("${stat}: " . $self->get('Summary Stats')->{$stat} . "\n"); + } +} + +sub print_stats { + my $self = shift; + foreach my $stat (sort keys %{$self->get('Summary Stats')}) { + print STDOUT "${stat}: " . $self->get('Summary Stats')->{$stat} . "\n"; + } +} + +sub write_stats { + my $self = shift; + + return if (!$self->get_conf('BATCH_MODE')); + + my $stats_dir = $self->get_conf('STATS_DIR'); + + return if not defined $stats_dir; + + if (! -d $stats_dir && + !mkdir $stats_dir) { + $self->log_warning("Could not create $stats_dir: $!\n"); + return; + } + + my ($cat, $val) = @_; + local( *F ); + + $self->lock_file($stats_dir, 0); + open( F, ">>$stats_dir/$cat" ); + print F "$val\n"; + close( F ); + $self->unlock_file($stats_dir); +} + +sub debian_files_list { + my $self = shift; + my $files = shift; + + my @list; + + debug("Parsing $files\n"); + my $session = $self->get('Session'); + + my $pipe = $session->get_read_file_handle($files); + if ($pipe) { + while (<$pipe>) { + chomp; + my $f = (split( /\s+/, $_ ))[0]; + push( @list, "$f" ); + debug(" $f\n"); + } + close( $pipe ) or $self->log_error("Failed to close $files\n") && return 1; + } + + return @list; +} + +# Figure out chroot architecture +sub chroot_arch { + my $self = shift; + + chomp(my $chroot_arch = $self->get('Session')->read_command( + { COMMAND => ['dpkg', '--print-architecture'], + USER => $self->get_conf('BUILD_USER'), + PRIORITY => 0, + DIR => '/' })); + + if (!$chroot_arch) { + Sbuild::Exception::Build->throw(error => "Can't determine architecture of chroot: $!", + failstage => "chroot-arch") + } + + return $chroot_arch; +} + +sub build_log_filter { + my $self = shift; + my $text = shift; + my $replacement = shift; + + if ($self->get_conf('LOG_FILTER')) { + $self->log($self->get('FILTER_PREFIX') . $text . ':' . $replacement . "\n"); + } +} + +sub build_log_colour { + my $self = shift; + my $regex = shift; + my $colour = shift; + + if ($self->get_conf('LOG_COLOUR')) { + $self->log($self->get('COLOUR_PREFIX') . $colour . ':' . $regex . "\n"); + } +} + +sub open_build_log { + my $self = shift; + + my $date = strftime_c "%FT%TZ", gmtime($self->get('Pkg Start Time')); + + my $filter_prefix = '__SBUILD_FILTER_' . $$ . ':'; + $self->set('FILTER_PREFIX', $filter_prefix); + my $colour_prefix = '__SBUILD_COLOUR_' . $$ . ':'; + $self->set('COLOUR_PREFIX', $colour_prefix); + + my $filename = $self->get_conf('LOG_DIR') . '/'; + # we might not know the pkgname_ver string if the user only specified a + # package name without version + if ($self->get('Package_SVersion')) { + $filename .= $self->get('Package_SVersion'); + } else { + $filename .= $self->get('Package'); + } + $filename .= '_' . $self->get('Host Arch') . "-$date"; + $filename .= ".build" if $self->get_conf('SBUILD_MODE') ne 'buildd'; + + open($saved_stdout, ">&STDOUT") or warn "Can't redirect stdout\n"; + open($saved_stderr, ">&STDERR") or warn "Can't redirect stderr\n"; + + my $PLOG; + + my $pid; + ($pid = open($PLOG, "|-")); + if (!defined $pid) { + warn "Cannot open pipe to '$filename': $!\n"; + } elsif ($pid == 0) { + $SIG{'INT'} = 'IGNORE'; + $SIG{'TERM'} = 'IGNORE'; + $SIG{'QUIT'} = 'IGNORE'; + $SIG{'PIPE'} = 'IGNORE'; + + $saved_stdout->autoflush(1); + if (!$self->get_conf('NOLOG') && + $self->get_conf('LOG_DIR_AVAILABLE')) { + unlink $filename; # To prevent opening symlink to elsewhere + open( CPLOG, ">$filename" ) or + Sbuild::Exception::Build->throw(error => "Failed to open build log $filename: $!", + failstage => "init"); + CPLOG->autoflush(1); + + # Create 'current' symlinks + if ($self->get_conf('SBUILD_MODE') eq 'buildd') { + $self->log_symlink($filename, + $self->get_conf('BUILD_DIR') . '/current-' . + $self->get_conf('DISTRIBUTION')); + } else { + my $symlinktarget = $filename; + # if symlink target is in the same directory as the symlink + # itself, make it a relative link instead of an absolute one + if (Cwd::abs_path($self->get_conf('BUILD_DIR')) eq Cwd::abs_path(dirname($filename))) { + $symlinktarget = basename($filename) + } + my $symlinkname = $self->get_conf('BUILD_DIR') . '/'; + # we might not know the pkgname_ver string if the user only specified a + # package name without version + if ($self->get('Package_SVersion')) { + $symlinkname .= $self->get('Package_SVersion'); + } else { + $symlinkname .= $self->get('Package'); + } + $symlinkname .= '_' . $self->get('Host Arch') . ".build"; + $self->log_symlink($symlinktarget, $symlinkname); + } + } + + # Cache vars to avoid repeated hash lookups. + my $nolog = $self->get_conf('NOLOG'); + my $log = $self->get_conf('LOG_DIR_AVAILABLE'); + my $verbose = $self->get_conf('VERBOSE'); + my $log_colour = $self->get_conf('LOG_COLOUR'); + my @filter = (); + my @colour = (); + my ($text, $replacement); + my $filter_regex = "^$filter_prefix(.*):(.*)\$"; + my $colour_regex = "^$colour_prefix(.*):(.*)\$"; + my @ignore = (); + + while (<STDIN>) { + # Add a replacement pattern to filter (sent from main + # process in log stream). + if (m/$filter_regex/) { + ($text,$replacement)=($1,$2); + $replacement = "<<$replacement>>"; + push (@filter, [$text, $replacement]); + $_ = "I: NOTICE: Log filtering will replace '$text' with '$replacement'\n"; + } elsif (m/$colour_regex/) { + my ($colour, $regex); + ($colour,$regex)=($1,$2); + push (@colour, [$colour, $regex]); +# $_ = "I: NOTICE: Log colouring will colour '$regex' in $colour\n"; + next; + } else { + # Filter out any matching patterns + foreach my $pattern (@filter) { + ($text,$replacement) = @{$pattern}; + s/\Q$text\E/$replacement/g; + } + } + if (m/Deprecated key/ || m/please update your configuration/) { + my $skip = 0; + foreach my $ignore (@ignore) { + $skip = 1 if ($ignore eq $_); + } + next if $skip; + push(@ignore, $_); + } + + if ($nolog || $verbose) { + my $colour = 'reset'; + if (-t $saved_stdout && $log_colour) { + foreach my $pattern (@colour) { + if (m/$$pattern[0]/) { + $colour = $$pattern[1]; + } + } + if ($colour ne 'reset') { + print $saved_stdout color $colour; + } + } + + print $saved_stdout $_; + if (-t $saved_stdout && $log_colour && $colour ne 'reset') { + print $saved_stdout color 'reset'; + } + } + if (!$nolog && $log) { + print CPLOG $_; + } + } + + close CPLOG; + exit 0; + } + + $PLOG->autoflush(1); + open(STDOUT, '>&', $PLOG) or warn "Can't redirect stdout\n"; + open(STDERR, '>&', $PLOG) or warn "Can't redirect stderr\n"; + $self->set('Log File', $filename); + $self->set('Log Stream', $PLOG); + + my $hostname = $self->get_conf('HOSTNAME'); + $self->log("sbuild (Debian sbuild) $version ($release_date) on $hostname\n"); + + my $arch_string = $self->get('Host Arch'); + my $head1 = $self->get('Package'); + if ($self->get('Version')) { + $head1 .= ' ' . $self->get('Version'); + } + $head1 .= ' (' . $arch_string . ') '; + my $head2 = strftime_c "%a, %d %b %Y %H:%M:%S +0000", + gmtime($self->get('Pkg Start Time')); + my $head = $head1; + # If necessary, insert spaces so that $head1 is left aligned and $head2 is + # right aligned. If the sum of the length of both is greater than the + # available space of 76 characters, then no additional padding is + # inserted. + if (length($head1) + length($head2) <= 76) { + $head .= ' ' x (76 - length($head1) - length($head2)); + } + $head .= $head2; + $self->log_section($head); + + $self->log("Package: " . $self->get('Package') . "\n"); + if (defined $self->get('Version')) { + $self->log("Version: " . $self->get('Version') . "\n"); + } + if (defined $self->get('OVersion')) { + $self->log("Source Version: " . $self->get('OVersion') . "\n"); + } + $self->log("Distribution: " . $self->get_conf('DISTRIBUTION') . "\n"); + $self->log("Machine Architecture: " . $self->get_conf('ARCH') . "\n"); + $self->log("Host Architecture: " . $self->get('Host Arch') . "\n"); + $self->log("Build Architecture: " . $self->get('Build Arch') . "\n"); + $self->log("Build Profiles: " . $self->get('Build Profiles') . "\n") if $self->get('Build Profiles'); + $self->log("Build Type: " . $self->get('Build Type') . "\n"); + $self->log("\n"); +} + +sub close_build_log { + my $self = shift; + + my $time = $self->get('Pkg End Time'); + if ($time == 0) { + $time = time; + } + my $date = strftime_c "%FT%TZ", gmtime($time); + + my $hours = int($self->get('This Time')/3600); + my $minutes = int(($self->get('This Time')%3600)/60), + my $seconds = int($self->get('This Time')%60), + my $space = "no"; + if ($self->get('This Space') >= 0) { + $space = sprintf("%dk", $self->get('This Space')); + } + + my $filename = $self->get('Log File'); + + # building status at this point means failure. + if ($self->get_status() eq "building") { + $self->set_status('failed'); + } + + $self->log_subsection('Summary'); + $self->generate_stats(); + $self->log_stats(); + + $self->log_sep(); + $self->log("Finished at ${date}\n"); + $self->log(sprintf("Build needed %02d:%02d:%02d, %s disk space\n", + $hours, $minutes, $seconds, $space)); + + if ($self->get_status() eq "successful") { + if (length $self->get_conf('KEY_ID')) { + my $key_id = $self->get_conf('KEY_ID'); + my $build_dir = $self->get_conf('BUILD_DIR'); + my $changes; + $self->log(sprintf("Signature with key '%s' requested:\n", $key_id)); + $changes = $self->get_changes(); + if (!defined($changes)) { + $self->log_error(".changes is undef. Cannot sign .changes.\n"); + } else { + system('debsign', '--re-sign', "-k$key_id", '--', "$build_dir/$changes"); + } + if ($self->get_conf('SOURCE_ONLY_CHANGES')) { + # We would like to run debsign with --no-re-sign so that a file + # referenced by the normal changes file and was already signed + # there does not get changed here by re-signing. Otherwise, the + # checksum from the normal changes file might not match + # anymore. https://bugs.debian.org/977674 + # + # The problem is, that with --no-re-sign, debsign will see a + # signed buildinfo file and skip signing the dsc. + # https://bugs.debian.org/981021 + my $so_changes = $build_dir . '/' . $self->get('Package_SVersion') . "_source.changes"; + if (-r $so_changes) { + system('debsign', '--re-sign', "-k$key_id", '--', "$so_changes"); + } else { + $self->log_error("$so_changes unreadable. Cannot sign .changes.\n"); + } + } + } + } + + my $subject = "Log for " . $self->get_status() . " build of "; + if ($self->get('Package_Version')) { + $subject .= $self->get('Package_Version'); + } else { + $subject .= $self->get('Package'); + } + + if ($self->get_conf('BUILD_SOURCE') && !$self->get_conf('BUILD_ARCH_ALL') && !$self->get_conf('BUILD_ARCH_ANY')) { + $subject .= " source"; + } + if ($self->get_conf('BUILD_ARCH_ALL') && !$self->get_conf('BUILD_ARCH_ANY')) { + $subject .= " on all"; + } elsif ($self->get('Host Arch')) { + $subject .= " on " . $self->get('Host Arch'); + } + if ($self->get_conf('ARCHIVE')) { + $subject .= " (" . $self->get_conf('ARCHIVE') . "/" . $self->get_conf('DISTRIBUTION') . ")"; + } + else { + $subject .= " (dist=" . $self->get_conf('DISTRIBUTION') . ")"; + } + + open(STDERR, '>&', $saved_stderr) or warn "Can't redirect stderr\n" + if defined($saved_stderr); + open(STDOUT, '>&', $saved_stdout) or warn "Can't redirect stdout\n" + if defined($saved_stdout); + $saved_stderr->close(); + undef $saved_stderr; + $saved_stdout->close(); + undef $saved_stdout; + $self->set('Log File', undef); + if (defined($self->get('Log Stream'))) { + $self->get('Log Stream')->close(); # Close child logger process + $self->set('Log Stream', undef); + } + + $self->send_build_log($self->get_conf('MAILTO'), $subject, $filename) + if (defined($filename) && -f $filename && + $self->get_conf('MAILTO')); +} + +sub send_build_log { + my $self = shift; + my $to = shift; + my $subject = shift; + my $filename = shift; + + my $conf = $self->get('Config'); + + if ($conf->get('MIME_BUILD_LOG_MAILS')) { + return $self->send_mime_build_log($to, $subject, $filename); + } else { + return send_mail($conf, $to, $subject, $filename); + } +} + +sub send_mime_build_log { + my $self = shift; + my $to = shift; + my $subject = shift; + my $filename = shift; + + my $conf = $self->get('Config'); + my $tmp; # Needed for gzip, here for proper scoping. + + my $msg = MIME::Lite->new( + From => $conf->get('MAILFROM'), + To => $to, + Subject => $subject, + Type => 'multipart/mixed' + ); + + # Add the GPG key ID to the mail if present so that it's clear if the log + # still needs signing or not. + if (length $self->get_conf('KEY_ID')) { + $msg->add('Key-ID', $self->get_conf('KEY_ID')); + } + + if (!$conf->get('COMPRESS_BUILD_LOG_MAILS')) { + my $log_part = MIME::Lite->new( + Type => 'text/plain', + Path => $filename, + Filename => basename($filename) + ); + $log_part->attr('content-type.charset' => 'UTF-8'); + $msg->attach($log_part); + } else { + local( *F, *GZFILE ); + + if (!open( F, "<$filename" )) { + warn "Cannot open $filename for mailing: $!\n"; + return 0; + } + + $tmp = File::Temp->new(); + tie *GZFILE, 'IO::Zlib', $tmp->filename, 'wb'; + + while( <F> ) { + print GZFILE $_; + } + untie *GZFILE; + + close F; + close GZFILE; + + $msg->attach( + Type => 'application/x-gzip', + Path => $tmp->filename, + Filename => basename($filename) . '.gz' + ); + } + my $build_dir = $self->get_conf('BUILD_DIR'); + my $changes = $self->get_changes(); + if ($self->get_status() eq 'successful' && -r "$build_dir/$changes") { + my $log_part = MIME::Lite->new( + Type => 'text/plain', + Path => "$build_dir/$changes", + Filename => basename($changes) + ); + $log_part->attr('content-type.charset' => 'UTF-8'); + $msg->attach($log_part); + } + + my $stats = ''; + foreach my $stat (sort keys %{$self->get('Summary Stats')}) { + $stats .= sprintf("%s: %s\n", $stat, $self->get('Summary Stats')->{$stat}); + } + $msg->attach( + Type => 'text/plain', + Filename => basename($filename) . '.summary', + Data => $stats + ); + + local $SIG{'PIPE'} = 'IGNORE'; + + if (!open( MAIL, "|" . $conf->get('MAILPROG') . " -oem $to" )) { + warn "Could not open pipe to " . $conf->get('MAILPROG') . ": $!\n"; + close( F ); + return 0; + } + + $msg->print(\*MAIL); + + if (!close( MAIL )) { + warn $conf->get('MAILPROG') . " failed (exit status $?)\n"; + return 0; + } + return 1; +} + +sub log_symlink { + my $self = shift; + my $log = shift; + my $dest = shift; + + unlink $dest; # Don't return on failure, since the symlink will fail. + symlink $log, $dest; +} + +sub get_changes_opts { + my $self = shift; + my @changes_opts = (); + foreach (@{$self->get_conf('DPKG_BUILDPACKAGE_USER_OPTIONS')}) { + if (/^--changes-option=(.*)$/) { + push @changes_opts, $1; + } elsif (/^-s[iad]$/) { + push @changes_opts, $_; + } elsif (/^--build=.*$/) { + push @changes_opts, $_; + } elsif (/^-m.*$/) { + push @changes_opts, $_; + } elsif (/^-e.*$/) { + push @changes_opts, $_; + } elsif (/^-v.*$/) { + push @changes_opts, $_; + } elsif (/^-C.*$/) { + push @changes_opts, $_; + } + } + + return \@changes_opts; +} + +1; |