lib/Fedora/Rebuild/Package.pm

   1 package Fedora::Rebuild::Package;
   2 use strict;
   3 use warnings;
   4 use threads;
   5 use threads::shared;
   6 use Moose;
   7 use File::Path::Tiny;
   8 use File::Spec;
   9 use Fedora::Rebuild::Package::StateLock;
  10 use Fedora::Rebuild::RPM;
  11 use Fedora::Rebuild::Mock;
  12 use Data::Dumper;
  13 use namespace::clean;
  14
  15 use version 0.77; our $VERSION = version->declare("v0.12.1");
  16
  17 has 'name' => (is => 'ro', isa => 'Str', required => 1);
  18 # Build-time dependencies
  19 has 'requires' => (is => 'rw', isa => 'HashRef', lazy_build => 1,
  20     init_arg => undef);
  21 # Run-time dependencies hashed by binary package ENVR.
  22 has 'runrequires' => (is => 'rw', isa => 'HashRef', lazy_build => 1,
  23     init_arg => undef);
  24 # Run-time provides hashes by binary package ENVR.
  25 has 'provides' => (is => 'rw', isa => 'HashRef', lazy_build => 1,
  26     init_arg => undef);
  27 has 'workdir' => (is => 'ro', isa => 'Str', required => 1);
  28 # Git branch name
  29 # "f14", "f15" etc. Use "rawhide" for latest one.
  30 has 'dist' => (is => 'ro', isa => 'Str', required => 1);
  31 # Fedpkg dist name identifier. This is required only if git branch name is not
  32 # an offical one (e.g. a private branch).
  33 # "f14", "f15" etc. Use "f18" for the latest one.
  34 has 'pkgdist' => (is => 'ro', isa => 'Maybe[Str]', required => 0,
  35     default => undef);
  36 # Build target name
  37 # "dist-f14", "dist-f15" etc. Use "rawhide" for latest one.
  38 has 'target' => (is => 'ro', isa => 'Str', required => 1);
  39 has 'message' => (is => 'ro', isa => 'Str', required => 1);
  40
  41 has 'packagedir' => (is => 'ro', isa => 'Str', lazy_build => 1,
  42     init_arg => undef);
  43 has 'repodir' => (is => 'ro', isa => 'Str', lazy_build => 1,
  44     init_arg => undef);
  45 has 'mockdir' => (is => 'ro', isa => 'Str', lazy_build => 1,
  46     init_arg => undef);
  47 has 'rpmdir' => (is => 'ro', isa => 'Str', lazy_build => 1,
  48     init_arg => undef);
  49 has 'requiresstore' => (is => 'ro', isa => 'Str', lazy_build => 1,
  50     init_arg => undef);
  51 has 'runrequiresstore' => (is => 'ro', isa => 'Str', lazy_build => 1,
  52     init_arg => undef);
  53 has 'providesstore' => (is => 'ro', isa => 'Str', lazy_build => 1,
  54     init_arg => undef);
  55 has 'taskstore' => (is => 'ro', isa => 'Str', lazy_build => 1,
  56     init_arg => undef);
  57 has 'branch' => (is => 'ro', isa => 'Str', lazy_build => 1,
  58     init_arg => undef);
  59
  60 # Make object shared between threads.
  61 # XXX: Not all attributes are shared automatically.
  62 around 'new' => sub {
  63     my $orig = shift;
  64     my $class = shift;
  65     return shared_clone($class->$orig(@_));
  66 };
  67
  68 # Clean package locks bound to attributes
  69 sub BUILD {
  70     my $self = shift;
  71     for my $state ('buildrequires', 'runrequires', 'provides') {
  72         Fedora::Rebuild::Package::StateLock->new(package => $self,
  73             state => $state)->mark_failed;
  74     }
  75 }
  76
  77 # BuildRequires. Shared.
  78 # Initialize to empty hash. Call get_buildrequires() to populate.
  79 sub _build_requires {
  80     my $self = shift;
  81     my $requires :shared = shared_clone({});
  82     return $requires;
  83 }
  84
  85 # Run-time Requires. Shared.
  86 # Initialize to empty hash. Call get_runrequires() to populate.
  87 sub _build_runrequires {
  88     my $self = shift;
  89     my $runrequires :shared = shared_clone({});
  90     return $runrequires;
  91 }
  92
  93 # Run-time provides. Shared.
  94 # Initialize to empty hash. Call rebuild() or get_binaryprovides() to populate.
  95 sub _build_provides {
  96     my $self = shift;
  97     my $provides :shared = shared_clone({});
  98     return $provides;
  99 }
 100
 101 sub _build_packagedir {
 102     my $self = shift;
 103     my $directory = File::Spec->catfile($self->workdir, $self->name);
 104     if (! -d $directory) {
 105         File::Path::Tiny::mk($directory) or
 106             die "Could not create directory $directory: $!";
 107     }
 108     return $directory;
 109 }
 110
 111 sub _build_repodir {
 112     my $self = shift;
 113     return File::Spec->catfile($self->packagedir, 'repository');
 114 }
 115
 116 sub _build_mockdir {
 117     my $self = shift;
 118     return File::Spec->catfile($self->packagedir, 'mock');
 119 }
 120
 121 sub _build_rpmdir {
 122     my $self = shift;
 123     return File::Spec->catfile($self->packagedir, 'RPMS');
 124 }
 125
 126 sub _build_requiresstore {
 127     my $self = shift;
 128     return File::Spec->catfile($self->packagedir, 'buildrequires.store');
 129 }
 130
 131 sub _build_runrequiresstore {
 132     my $self = shift;
 133     return File::Spec->catfile($self->packagedir, 'runrequires.store');
 134 }
 135
 136 sub _build_providesstore {
 137     my $self = shift;
 138     return File::Spec->catfile($self->packagedir, 'provides.store');
 139 }
 140
 141 sub _build_taskstore {
 142     my $self = shift;
 143     return File::Spec->catfile($self->packagedir, 'task.store');
 144 }
 145
 146 sub _build_branch {
 147     my $self = shift;
 148     if ($self->dist eq 'rawhide') {
 149         return 'master';
 150     } else {
 151         return $self->dist;
 152     }
 153 }
 154
 155
 156 # Clones package repository and switch to proper branch if not yet done.
 157 # First argument is anonymous clone boolean.
 158 # Second argument is Fedora::Rebuild::Package::Config object.
 159 # Return true on success.
 160 sub clone {
 161     my ($self, $anonymous, $build_config) = @_;
 162     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 163        state => 'clone');
 164     if ($lock->is_done) { return 1; }
 165
 166     # XXX: pyrpkg creates subdirectory named like package. The package name
 167     # could clash with our file structure. Thus we need to clone into secure
 168     # directory and move repository content to fixed name $self->repodir after
 169     # that.
 170
 171     if (-d $self->repodir) { File::Path::Tiny::rm($self->repodir); }
 172     my $tempdir = File::Spec->catfile($self->packagedir, 'tmp');
 173     my $temprepodir = File::Spec->catfile($tempdir, $self->name);
 174     if (-d $tempdir) { File::Path::Tiny::rm($tempdir); }
 175     if (!File::Path::Tiny::mk($tempdir)) {
 176         $lock->log("Could not create directory `" . $tempdir . "': $!\n");
 177         return $lock->mark_failed;
 178     }
 179
 180     if (!$lock->do($tempdir, $build_config->pyrpkg(), 'clone',
 181             ($anonymous) ? '-a': (), $self->name)) {
 182         $lock->log("Could not clone `" . $self->name . "' repository.\n");
 183         return $lock->mark_failed;
 184     }
 185
 186     if (!rename($temprepodir, $self->repodir)) {
 187         $lock->log("Could not move `" . $temprepodir . "' content to to `" .
 188             $self->repodir . "'.\n");
 189         return $lock->mark_failed;
 190     }
 191     File::Path::Tiny::rm($tempdir);
 192
 193     if (!$lock->do($self->repodir, $build_config->pyrpkg(),
 194             'switch-branch', $self->branch)) {
 195         $lock->log("Could not switch `" . $self->name .
 196             "' repository to branch `" . $self->branch . "'.\n");
 197         return $lock->mark_failed;
 198     }
 199
 200     return $lock->mark_done;
 201 }
 202
 203
 204 # Reset git repository and pull new changes.
 205 # First argument is a state lock.
 206 # XXX: The state is not marked as failed in case of error,
 207 # Return true on success.
 208 # Needs `clone'.
 209 sub refreshgit {
 210     my ($self, $lock) = @_;
 211     if (!defined $lock) {
 212         return 0;
 213     }
 214
 215     # Reset git repository
 216     if (!$lock->do($self->repodir, 'git', 'reset', '--hard',
 217             'origin/' .  $self->branch)) {
 218         $lock->log("Could not reset git repository in `" . $self->repodir .
 219             "'.\n");
 220         return 0;
 221     }
 222
 223     # Pull git repository
 224     if (!$lock->do($self->repodir, 'git', 'pull')) {
 225         $lock->log("Could not pull git repository in `" . $self->repodir .
 226             "'.\n");
 227         return 0;
 228     }
 229
 230     return 1;
 231 }
 232
 233
 234 # Increase package revision with proper changelog entry. Do not commit nor
 235 # push the changes.
 236 # First argument is a state lock.
 237 # XXX: The state is not marked as failed in case of error,
 238 # Return true on success.
 239 # Needs `clone'.
 240 sub updatespec {
 241     my ($self, $lock) = @_;
 242     if (!defined $lock) {
 243         return 0;
 244     }
 245
 246     # Reset and pull git repository
 247     if (!$self->refreshgit($lock)) {
 248         return 0;
 249     }
 250
 251     # Increase revision number
 252     my $specfile = File::Spec->catfile($self->repodir, $self->name . '.spec');
 253     if (!$lock->do(undef, 'rpmdev-bumpspec', '-c', $self->message, $specfile)) {
 254         $lock->log("Could not increase revison number in `" . $specfile .
 255             "' specfile.\n");
 256         return 0;
 257     }
 258
 259     return 1;
 260 }
 261
 262
 263 # Check if git repository is modifed (has uncommited changes).
 264 # First arugument is a state lock.
 265 # Second argument is a mode.
 266 # Return -1 on an internal error.
 267 # Return true if modifer, false otherwise.
 268 # Needs `clone'.
 269 sub gitismodified {
 270     my ($self, $lock) = @_;
 271
 272     my $output;
 273     if (!$lock->dooutput($self->repodir, \$output, 'git', 'status',
 274             '--porcelain', '--untracked-files=no')) {
 275         return -1;
 276     }
 277     if (defined $output and $output ne '') {
 278         return 1;
 279     }
 280
 281     return 0;
 282 }
 283
 284
 285 # Commit changes. And push them only if first argument is "koji".
 286 # First arugument is a state lock.
 287 # Second argument is a mode.
 288 # Return true on success.
 289 # Needs `clone'.
 290 sub commitandpush {
 291     my ($self, $lock, $mode) = @_;
 292
 293     # Commit changes
 294     if (!$lock->do($self->repodir, 'git', 'commit', '-a',
 295             '-m', $self->message)) {
 296         $lock->log("Could not commit changes into git repository `" .
 297             $self->repodir . "'.\n");
 298         return 0;
 299     }
 300
 301     if ($mode eq 'koji') {
 302         # Push changes
 303         if (!$lock->do($self->repodir, 'git', 'push')) {
 304             $lock->log("Could not push changes from repository `" .
 305                 $self->repodir . "' to server.\n");
 306             return 0;
 307         }
 308     } else {
 309         $lock->log("Not pushing changes because of local build mode.\n");
 310     }
 311
 312     return 1;
 313 }
 314
 315
 316 # Remove all state locks except `clone'.
 317 # XXX: The state is not marked as failed in case of error.
 318 # Returns true.
 319 sub reset {
 320     my ($self) = @_;
 321
 322     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 323        state => 'reset');
 324
 325     for my $state ('srpm', 'buildrequiresstore', 'edit', 'update',
 326         'is_rebuildable', 'submitbuild', 'build', 'rpms', 'providesstore',
 327         'runrequiresstore', 'rotate', 'buildrequires', 'runrequires',
 328         'provides') {
 329         $lock->log("Removing state lock $state\n");
 330
 331         if ($state eq 'rotate') {
 332             $self->reset_rotate;
 333         } else {
 334             my $state_lock = Fedora::Rebuild::Package::StateLock->new(
 335                 package => $self, state => $state);
 336             $state_lock->mark_failed;
 337             $state_lock->remove_log;
 338         }
 339     }
 340     $lock->log("States reset done.\n");
 341
 342     # The lock is for logging only
 343     $lock->mark_failed;
 344     return 1;
 345 }
 346
 347
 348 # Test if remote GIT repository HEAD differs from local clone. If the package
 349 # has been changed in the remote repository, it will reset all package
 350 # states up to (excluding) `clone'.
 351 # Return false on failure, 1 for no change (repositories equals),
 352 # 2 for detected change.
 353 # Needs `clone'.
 354 sub reset_remotly_updated {
 355     my ($self) = @_;
 356
 357     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 358        state => 'checkremote');
 359
 360     if (!-d $self->repodir) {
 361         $lock->log("Missing repository directory `" . $self->repodir . "\n");
 362         return $lock->mark_failed;
 363     }
 364
 365     # Expected output for "git show-ref origin/master"
 366     # bb7f5790c2ef49087abe175e8b9560acce4ae15d refs/remotes/origin/master
 367     my $local_id;
 368     my $branch_name = $self->branch;
 369     if (!$lock->dooutput($self->repodir, \$local_id, 'git', 'show-ref',
 370             'origin/' .  $self->branch)) {
 371         $lock->log("Could not get HEAD of local origin branch.\n");
 372         return $lock->mark_failed;
 373     }
 374     if (!defined $local_id or $local_id !~
 375             s|\A(\S+)\s+refs/remotes/origin/\Q$branch_name\E\n\z|$1|) {
 376         $lock->log("Could not parse local origin reference ID: `$local_id'\n");
 377         return $lock->mark_failed;
 378     }
 379
 380     # Expected output for "git ls-remote origin heads/master"
 381     # 8d021a3956bbb1762ae52a04a5bc425a77c8a3ad        refs/heads/master
 382     # XXX: git ls-remote --heads ... handles master as a wildcard and returns
 383     # entry for rc/master branch too.
 384     my $remote_id;
 385     if (!$lock->dooutput($self->repodir, \$remote_id, 'git', 'ls-remote',
 386             'origin', 'heads/' . $self->branch)) {
 387         $lock->log("Could not get HEAD of remote origin branch.\n");
 388         return $lock->mark_failed;
 389     }
 390     if (!defined $remote_id or $remote_id !~
 391             s|\A(\S+)\s+refs/heads/\Q$branch_name\E\n\z|$1|) {
 392         $lock->log("Could not parse remote origin reference ID: `$remote_id'\n");
 393         return $lock->mark_failed;
 394     }
 395
 396     my $changed = $local_id ne $remote_id;
 397     if ($changed) {
 398         $lock->log("Remote repository has changed.\n");
 399         $self->reset();
 400     } else {
 401         $lock->log("Remote repository has not changed.\n");
 402     }
 403
 404     # The lock is for logging only
 405     $lock->mark_failed;
 406
 407     if ($changed) {
 408         return 2;
 409     }
 410     return 1;
 411 }
 412
 413
 414 # Builds SRPM. Return true on success.
 415 # If first argument is true, recreate SRPM forcefully.
 416 # Second argument is Fedora::Rebuild::Package::Config object.
 417 # Third argument is Mock object to use instead of fresh one (value undef).
 418 # (This is safe only in single-threaded run. This is limitation of mock.)
 419 # Needs `clone'.
 420 sub srpm {
 421     my ($self, $force, $build_config, $mock) = @_;
 422     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 423        state => 'srpm');
 424     if ($force) { $lock->remove_lock; }
 425     if ($lock->is_done) { return 1; }
 426
 427     # We need do the update spec now to get the same NEVRA as in rebuild. We do
 428     # update without pushing to prevent from repetitive NEVRA bumps in case of
 429     # failed builds.
 430     if (!Fedora::Rebuild::Package::StateLock->new(package => $self,
 431        state => 'update')->is_done) {
 432         if (!$self->updatespec($lock)) {
 433             $lock->log("Could not update spec file in order to create new " .
 434                 "SRPM for `" . $self->name . "' package.\n");
 435             return $lock->mark_failed;
 436         }
 437     }
 438
 439     if ($build_config->mode() eq 'local') {
 440         if (!$lock->do($self->repodir, $build_config->pyrpkg(),
 441                 (defined $self->pkgdist) ? ('--dist', $self->pkgdist) : (),
 442                 'srpm')) {
 443             $lock->log("Could not build SRPM for `" . $self->name .
 444                 "' package locally.\n");
 445             return $lock->mark_failed;
 446         }
 447     } elsif ($build_config->mode() eq 'koji' or
 448             $build_config->mode() eq 'mock') {
 449         # Prepare spec file and sources
 450         my $specname = File::Spec->catfile($self->repodir,
 451             $self->name . '.spec');
 452         if (!$lock->do($self->repodir, $build_config->pyrpkg(),
 453                 (defined $self->pkgdist) ? ('--dist', $self->pkgdist) : (),
 454                 'sources')) {
 455             $lock->log("Could not download sources for `" . $self->name .
 456                 "' package.\n");
 457             return $lock->mark_failed;
 458         }
 459
 460         # Build SRPM in mock
 461         if (!replace_directory($lock, $self->mockdir)) {
 462             return $lock->mark_failed;
 463         }
 464         my ($mock_config_dir, $mock_config_root);
 465         eval {
 466             if (!defined $mock) {
 467                 $mock = Fedora::Rebuild::Mock->new(
 468                         architecture => $build_config->architecture(),
 469                         repositories => $build_config->repositories(),
 470                         install_packages =>
 471                             $build_config->mock_install_packages(),
 472                 );
 473                 $mock->make_configuration;
 474             }
 475             $mock_config_dir = $mock->config_dir;
 476             $mock_config_root = $mock->config_root;
 477         };
 478         if ($@) {
 479             $lock->log("Could not configure mock: $@\n");
 480             File::Path::Tiny::rm($mock_config_dir);
 481             return $lock->mark_failed;
 482         }
 483         if ($mock->shared) {
 484             # Mock stopped to pruning _topdir and accumulates built SRPMs now
 485             # and die on final check for number of SRPM files.
 486             # Let clean it manually.
 487             if (!$lock->do(undef, 'mock', '--resultdir', $self->mockdir,
 488                     '--configdir', $mock_config_dir,
 489                     '--root', $mock_config_root,
 490                     '--no-clean', '--no-cleanup-after',
 491                     '--chroot',
 492                     q[find "$(rpm -E '%{_topdir}')" -mindepth 2 -maxdepth 2 -exec rm -r {} \;])) {
 493                 $lock->log("Could not prune _topdir for `" . $self->name .
 494                     "' in mock.\n");
 495                 return $lock->mark_failed;
 496             }
 497         }
 498         if (!$lock->do(undef, 'mock', '--resultdir', $self->mockdir,
 499                 '--configdir', $mock_config_dir, '--root', $mock_config_root,
 500                 ($mock->shared) ? ('--no-clean', '--no-cleanup-after') : (),
 501                 '--buildsrpm',
 502                 '--spec', $specname, '--sources', $self->repodir)) {
 503             $lock->log("Could not build SRPM for `" . $self->name .
 504                 "' in mock.\n");
 505             if (!$mock->shared) {
 506                 File::Path::Tiny::rm($mock_config_dir);
 507             }
 508             return $lock->mark_failed;
 509         }
 510         if (!$mock->shared) {
 511             File::Path::Tiny::rm($mock_config_dir);
 512         }
 513
 514         # Move SRPM from mockdir to repodir
 515         my @srpms = glob(File::Spec->catfile($self->mockdir, '*.src.rpm'));
 516         if ($#srpms < 0) {
 517             $lock->log("No SRPM package found under `" .
 518                 $self->mockdir . "'\n");
 519             return $lock->mark_failed;
 520         }
 521         if ($#srpms > 0) {
 522             $lock->log("More SRPM packages found under `" .
 523                 $self->mockdir . "'. This should not happen.\n");
 524             return $lock->mark_failed;
 525         }
 526         if (!copy_files_into_directory($lock, $self->repodir, @srpms)) {
 527             return $lock->mark_failed;
 528         }
 529     } else {
 530         $lock->log("Could not build SRPM for `" . $self->name .
 531             "' because of unknown building mode `" . $build_config->mode() .
 532             "'.\n");
 533         return $lock->mark_failed;
 534     }
 535
 536     return $lock->mark_done;
 537 }
 538
 539 # Get current package NEVRA from sources in repository.
 540 # First argument is state lock where process of getting NEVRA including
 541 # potential failure is logged.
 542 # Second argument is Fedora::Rebuild::Package::Config object.
 543 # XXX: The state is not marked as failed in case of error,
 544 # Return NEVRA string or undef in case of error.
 545 sub get_nevra_from_git {
 546     my ($self, $lock, $build_config) = @_;
 547
 548     my $nevra;
 549     if (!$lock->dooutput($self->repodir, \$nevra, $build_config->pyrpkg(),
 550         (defined $self->pkgdist) ? ('--dist', $self->pkgdist) : (),
 551         'verrel') ||
 552             $nevra eq '') {
 553         $lock->log("Could not get NEVRA from `" . $self->name .
 554             "' git repository package.\n");
 555         return undef;
 556     }
 557     chomp $nevra;
 558     # Consider last line only becuase of bug in pyrpkg
 559     # <https://bugzilla.redhat.com/show_bug.cgi?id=721389>.
 560     my @lines = (split qr{$/}, $nevra);
 561     $nevra = pop @lines;
 562     return $nevra;
 563 }
 564
 565
 566 # Get current package SRPM name.
 567 # If the SRPM file does not exist, it will be re-created.
 568 # First argument is state lock where process of building SRPM including
 569 # potential failure is logged.
 570 # Second argument is Fedora::Rebuild::Package::Config object. If mode value is:
 571 #   "local"             build SRPM locally using pyrpkg,
 572 #   "koji" or "mock"    build SRPM using mock.
 573 # Third argument is Mock object to use instead of fresh one (value undef).
 574 # XXX: The state is not marked as failed in case of error,
 575 # Return SRPM file name string or undef in case of error.
 576 sub get_srpm_name {
 577     my ($self, $lock, $build_config, $mock) = @_;
 578
 579     my $nevra = $self->get_nevra_from_git($lock, $build_config);
 580     if (! defined $nevra) {
 581         return undef;
 582     }
 583
 584     my $srpmname = File::Spec->catfile($self->repodir, $nevra . '.src.rpm');
 585     if (! -f $srpmname ) {
 586         $lock->log("SRPM package `" . $srpmname . "' is missing, " .
 587             "trying to create SRPM again...\n");
 588         if (!$self->srpm(1, $build_config, $mock)
 589                 || ! -f $srpmname) {
 590             $lock->log("`Could not recreate SRPM package '" . $srpmname .
 591                 "'.\n");
 592             return undef;
 593         }
 594     }
 595     return $srpmname;
 596 }
 597
 598 # Remove a directory recursively, if it exists.
 599 # First argument is the directory, second argument is lock to log errors into.
 600 # Return true, false in case of error.
 601 # XXX: This is not a method
 602 sub remove_directory {
 603     my ($lock, $directory) = @_;
 604     if (!File::Path::Tiny::rm($directory)) {
 605         $lock->log("Could not remove directory `" . $directory . "': $!\n");
 606         return 0;
 607     }
 608     return 1;
 609 }
 610
 611 # Create a directory. If it exists, it will remove it before.
 612 # First argument is the directory, second argument is lock to log errors into.
 613 # Return true, false in case of error.
 614 # XXX: This is not a method
 615 sub replace_directory {
 616     my ($lock, $directory) = @_;
 617     remove_directory($lock, $directory);
 618     if (!File::Path::Tiny::mk($directory)) {
 619         $lock->log("Could not create directory `" . $directory . "': $!\n");
 620         return 0;
 621     }
 622     return 1;
 623 }
 624
 625 # Copy files into existing directory.
 626 # First argument lock for logggin,
 627 # second argument is destinatinon directory,
 628 # The last is list of files to be copied.
 629 # Return true in sucesss, false in case of error.
 630 # XXX: This is not a method
 631 sub copy_files_into_directory {
 632     my ($lock, $directory, @files) = @_;
 633     for my $file (@files) {
 634         use File::Copy;
 635         if (!copy($file, $directory)) {
 636             $lock->log("Could not copy `". $file . "' into `". $directory .
 637                 "'\n");
 638             return 0;
 639         }
 640         $lock->log("`" . $file . "' copied into `" . $directory . "'\n");
 641     }
 642     return 1;
 643 }
 644
 645 # Destile BuildRequires from local SRPM and serialize them into file.
 646 # First argument is Fedora::Rebuild::Package::Config object. If mode member is:
 647 #   "local"             build SRPM locally using pyrpkg,
 648 #   "koji" or "mock"    build SRPM using mock.
 649 # Second argument is Mock object to use instead of fresh one (value undef).
 650 # Return true on success.
 651 # Needs `srpm'.
 652 # FIXME: does not work after cleaning clone or doing update.
 653 sub storebuildrequires {
 654     my ($self, $build_config, $mock) = @_;
 655     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 656        state => 'buildrequiresstore');
 657     if ($lock->is_done) { return 1; }
 658
 659     my $nevra = $self->get_nevra_from_git($lock, $build_config);
 660     if (! defined $nevra) {
 661         return $lock->mark_failed;
 662     }
 663
 664     my $srpmname = File::Spec->catfile($self->repodir, $nevra . '.src.rpm');
 665     if (! -f $srpmname ) {
 666         $lock->log("SRPM package `" . $srpmname . "' is missing, " .
 667             "trying to create SRPM again...\n");
 668         if (!$self->srpm(1, $build_config, $mock) || ! -f $srpmname) {
 669             $lock->log("`Could not recreate SRPM package '" . $srpmname .
 670                 "'.\n");
 671             return $lock->mark_failed;
 672         }
 673     }
 674
 675     my $rpm = Fedora::Rebuild::RPM->new(name => $srpmname);
 676     my ($requires, $envra) = $rpm->requires;
 677     if (! defined $requires) {
 678         $lock->log("Could not get requires of SRPM `" . $srpmname . "': ". $@
 679             . "\n");
 680         return $lock->mark_failed;
 681     }
 682
 683     if (! $lock->nstorereference($requires, $self->requiresstore)) {
 684         $lock->log("Could not store requires of SRPM `". $srpmname .
 685             "' into `" . $self->requiresstore . "' file: $@\n");
 686         return $lock->mark_failed;
 687     }
 688
 689     $lock->log(Data::Dumper::Dumper($requires) . "\n");
 690     return $lock->mark_done;
 691 }
 692
 693 # Destile BuildRequires from local SRPM. Return true on success.
 694 # Needs `buildrequiresstore'.
 695 sub buildrequires {
 696     my $self = shift;
 697     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 698        state => 'buildrequires');
 699     if ($lock->is_done) { return 1; }
 700
 701     my $requires = $lock->retrievereference($self->requiresstore);
 702     if (! $requires) {
 703         $lock->log("Could not load requires of `". $self->name .
 704             "' package from `" . $self->requiresstore . "' file: $@\n");
 705         return $lock->mark_failed;
 706     }
 707     $self->requires(shared_clone($requires));
 708
 709     $lock->log(Data::Dumper::Dumper($self->requires) . "\n");
 710     return $lock->mark_done;
 711 }
 712
 713 # Record verdict from dependency solver whether the package is rebuildable.
 714 # This step is always redone.
 715 sub log_is_rebuildable {
 716     my ($self, $is_rebuildable, $message) = @_;
 717     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 718        state => 'is_rebuildable');
 719     $lock->remove_lock;
 720
 721     if (defined $message) {
 722         $lock->log("Solver result for possibility of rebuilding SRPM for `" .
 723             $self->name . "': $message\n");
 724     }
 725     if (! $is_rebuildable) {
 726         $lock->log("According dependency solver, this package is not " .
 727             "rebuildable now.\n");
 728         return $lock->mark_failed;
 729     }
 730
 731     $lock->log("According dependency solver, this package is " .
 732         "rebuildable now.\n");
 733     return $lock->mark_done;
 734 }
 735
 736 # Get binary RPM packages for the source package.
 737 # First argument is Fedora::Rebuild::Package::Config object. If mode member is:
 738 #   'koji'  download them from Koji,
 739 #   'local' from local build,
 740 #   'mock'  from mock result directory.
 741 # noarch packages are colletected automatically.
 742 # Requires `clone'. Sould be called after `build'.
 743 # Return true on success.
 744 sub binaryrpm {
 745     my ($self, $build_config) = @_;
 746     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 747        state => 'rpms');
 748     if ($lock->is_done) { return 1; }
 749
 750     if (!replace_directory($lock, $self->rpmdir)) {
 751         return $lock->mark_failed;
 752     }
 753
 754     my @archs = ($build_config->architecture(), 'noarch');
 755     if ($build_config->mode eq 'koji') {
 756         $lock->log("Getting binary RPM packages from Koji:\n");
 757
 758         my $nevra = $self->get_nevra_from_git($lock, $build_config);
 759         if (! defined $nevra) {
 760             return $lock->mark_failed;
 761         }
 762
 763         # TODO: Get all archs, remove SRPM
 764         if (!$lock->do($self->rpmdir, $build_config->koji(), 'download-build',
 765                 (map {'--arch=' . $_ } @archs), $nevra)) {
 766             $lock->log("Could not get binary RPM packages for `" . $nevra .
 767                 "'\n");
 768             return $lock->mark_failed;
 769         }
 770     } elsif ($build_config->mode() eq 'local') {
 771         $lock->log("Getting binary RPM packages from local build:\n");
 772
 773         my @rpms = map { glob(File::Spec->catfile($self->repodir, $_,
 774             '*.rpm')) } @archs;
 775         if ($#rpms < 0) {
 776             $lock->log("No binary RPM packages found under `" .
 777                 $self->repodir . "'\n");
 778             return $lock->mark_failed;
 779         }
 780
 781         if (!copy_files_into_directory($lock, $self->rpmdir, @rpms)) {
 782             return $lock->mark_failed;
 783         }
 784     } elsif ($build_config->mode() eq 'mock') {
 785         $lock->log("Getting binary RPM packages from mock build:\n");
 786
 787         my @rpms = map { glob(File::Spec->catfile($self->mockdir,
 788             ('*.' . $_ . '.rpm'))) } @archs;
 789         if ($#rpms < 0) {
 790             $lock->log("No binary RPM packages found under `" .
 791                 $self->mockdir . "'\n");
 792             return $lock->mark_failed;
 793         }
 794
 795         if (!copy_files_into_directory($lock, $self->rpmdir, @rpms)) {
 796             return $lock->mark_failed;
 797         }
 798     } else {
 799         $lock->log("Could get binary RPM packages for `" . $self->name .
 800             "' source package because of unknown building mode `" .
 801             $build_config->mode() . "'\n");
 802         return $lock->mark_failed;
 803     }
 804
 805     return $lock->mark_done;
 806 }
 807
 808 # Return list of binary RPM files relative to current working directory.
 809 # XXX: Should be called after colleting the files from build process by
 810 # binaryrpm().
 811 sub listbinaryrpmfiles {
 812     my $self = shift;
 813     return (glob(File::Spec->catfile($self->rpmdir, '*.rpm')));
 814 }
 815
 816 # Distill Requires from rebuilt binary packages and serialize them into file.
 817 # Return true on success.
 818 # Needs `rpms'.
 819 sub storebinaryrequires {
 820     my $self = shift;
 821     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 822        state => 'runrequiresstore');
 823     if ($lock->is_done) { return 1; }
 824
 825     my @rpms = glob(File::Spec->catfile($self->rpmdir, '*.rpm'));
 826     if ($#rpms < 0) {
 827         $lock->log("No binary RPM packages found in `" . $self->rpmdir
 828             . "'\n");
 829         return $lock->mark_failed;
 830     }
 831
 832     my $allrequires = {};
 833     for my $rpmname (@rpms) {
 834         my $rpm = Fedora::Rebuild::RPM->new(name => $rpmname);
 835
 836         my ($requires, $envr) = $rpm->requires;
 837
 838         if (! defined $requires || ! defined $envr) {
 839             $lock->log("Could not get run-time requires of RPM `" . $rpmname .
 840                 "': " .  $@ ."\n");
 841             return $lock->mark_failed;
 842         }
 843         $$allrequires{$envr} = $requires;
 844     }
 845
 846     if (! $lock->nstorereference($allrequires, $self->runrequiresstore)) {
 847         $lock->log("Could not store run-time requires of RPM `". $self->name .
 848             "' into `" . $self->runrequiresstore . "' file: $@\n");
 849         return $lock->mark_failed;
 850     }
 851
 852     $lock->log(Data::Dumper::Dumper($allrequires));
 853     return $lock->mark_done;
 854 }
 855
 856 # Distill Provides from rebuilt binary packages and serialize them into file.
 857 # Return true on success.
 858 # Needs `rpms'.
 859 sub storebinaryprovides {
 860     my $self = shift;
 861     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 862        state => 'providesstore');
 863     if ($lock->is_done) { return 1; }
 864
 865     my @rpms = glob(File::Spec->catfile($self->rpmdir, '*.rpm'));
 866     if ($#rpms < 0) {
 867         $lock->log("No binary RPM packages found in `" . $self->rpmdir
 868             . "'\n");
 869         return $lock->mark_failed;
 870     }
 871
 872     my $allprovides = {};
 873     for my $rpmname (@rpms) {
 874         my $rpm = Fedora::Rebuild::RPM->new(name => $rpmname);
 875
 876         my ($provides, $envr) = $rpm->provides;
 877
 878         if (! defined $provides || !defined $envr) {
 879             $lock->log("Could not get provides of RPM `" . $rpmname . "': " .
 880                 $@ ."\n");
 881             return $lock->mark_failed;
 882         }
 883         $$allprovides{$envr} = $provides;
 884     }
 885
 886     if (! $lock->nstorereference($allprovides, $self->providesstore)) {
 887         $lock->log("Could not store provides of RPM `". $self->name .
 888             "' into `" . $self->providesstore . "' file: $@\n");
 889         return $lock->mark_failed;
 890     }
 891
 892     $lock->log(Data::Dumper::Dumper($allprovides));
 893     return $lock->mark_done;
 894 }
 895
 896 # Load run-time requires of already rebuilt binary packages from file.
 897 # Return true on success.
 898 # Needs `storebinaryrequires'.
 899 sub loadbinaryrequires {
 900     my $self = shift;
 901     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 902        state => 'runrequires');
 903     if ($lock->is_done) { return 1; }
 904
 905     my $runrequires = $lock->retrievereference($self->runrequiresstore);
 906     if (! $runrequires) {
 907         $lock->log("Could not load run-time requires of `". $self->name .
 908             "' package from `" . $self->runrequiresstore . "' file: $@\n");
 909         return $lock->mark_failed;
 910     }
 911     $self->runrequires(shared_clone($runrequires));
 912
 913     $lock->log(Data::Dumper::Dumper($self->runrequires));
 914     return $lock->mark_done;
 915 }
 916
 917 # Load provides of already rebuilt binary packages from file.
 918 # Return true on success.
 919 # Needs `storebinaryprovides'.
 920 sub loadbinaryprovides {
 921     my $self = shift;
 922     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 923        state => 'provides');
 924     if ($lock->is_done) { return 1; }
 925
 926     my $provides = $lock->retrievereference($self->providesstore);
 927     if (! $provides) {
 928         $lock->log("Could not load provides of `". $self->name .
 929             "' package from `" . $self->providesstore . "' file: $@\n");
 930         return $lock->mark_failed;
 931     }
 932     $self->provides(shared_clone($provides));
 933
 934     $lock->log(Data::Dumper::Dumper($self->provides));
 935     return $lock->mark_done;
 936 }
 937
 938 # Edit git repository by an external tool if not yet done. Does not increase
 939 # package revisions.
 940 # First argument is mode. Only in "koji" mode pushes the changes.
 941 # Second argument is an external editor command. The command is expressed as
 942 # an array reference. Its working directory will be the git repository
 943 # directory. Its last argument will be the spec file name. The command can
 944 # abort edition by non-zero exit code.
 945 # Return true on success.
 946 # Needs `clone'.
 947 sub edit {
 948     my ($self, $mode, $editor) = @_;
 949     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
 950        state => 'edit');
 951     if ($lock->is_done) { return 1; }
 952
 953     if (ref $editor ne 'ARRAY') {
 954         $lock->log("The editor argument (" . "$editor" .
 955             ") is not an array reference.\n");
 956         return $lock->mark_failed;
 957     }
 958
 959     if (!@{$editor}) {
 960         $lock->log("The editor command is an empty list.\n");
 961         return $lock->mark_failed;
 962     }
 963
 964     # Reset repository
 965     if (!$self->refreshgit($lock)) {
 966         return $lock->mark_failed;
 967     }
 968
 969     # Execute external editor
 970     if (!$lock->do($self->repodir, @{$editor}, $self->name . '.spec')) {
 971         $lock->log("Could not edit spec file for `" . $self->name .
 972             "' package.\n");
 973         return $lock->mark_failed;
 974     }
 975
 976     # Commit and push changes only if editor has changed anything
 977     my $modified = $self->gitismodified($lock);
 978     if (-1 == $modified) {
 979         $lock->log("Could not check status of changes in git repository `" .
 980             $self->repodir . "'.\n");
 981         return $lock->mark_failed;
 982     } elsif ($modified) {
 983         $lock->log("Editor did changes." .
 984             " They will be committed and possibly pushed.\n");
 985         if (!$self->commitandpush($lock, $mode)) {
 986             return $lock->mark_failed;
 987         }
 988     } else {
 989         $lock->log("Editor did not change anything." .
 990             " Nothing to commit and push.\n");
 991     }
 992     return $lock->mark_done;
 993 }
 994
 995
 996 # Increase package revision if not yet done. Commit change if first argument
 997 # is "koji".
 998 # Return true on success.
 999 # Needs `clone'.
1000 sub update {
1001     my ($self, $mode) = @_;
1002     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
1003        state => 'update');
1004     if ($lock->is_done) { return 1; }
1005
1006     # Update spec file
1007     if (!$self->updatespec($lock)) {
1008         $lock->log("Could not update spec file in order to create new " .
1009             "update for `" . $self->name . "' package.\n");
1010         return $lock->mark_failed;
1011     }
1012
1013     # Commit and push changes
1014     if (!$self->commitandpush($lock, $mode)) {
1015         return $lock->mark_failed;
1016     }
1017
1018     return $lock->mark_done;
1019 }
1020
1021
1022 # Submit package for building into Koji and store task ID.
1023 # This is pointless in local build mode.
1024 # First argument is Fedora::Rebuild::Package::Config object.
1025 # Requires `clone'. Sould be called after `update'.
1026 # Return true on success.
1027 sub submitbuild {
1028     my ($self, $build_config) = @_;
1029     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
1030        state => 'submitbuild');
1031     if ($lock->is_done) { return 1; }
1032
1033     # Get NEVRA of intended build
1034     my $nevra = $self->get_nevra_from_git($lock, $build_config);
1035     if (! defined $nevra) {
1036         return $lock->mark_failed;
1037     }
1038
1039     # Check the build is not already in Koji (e.g. by concurrent packager
1040     # or after this program restart) but do not conclude anything.
1041     my $buildinfo;
1042     if (!$lock->dooutput($self->repodir, \$buildinfo, $build_config->koji(),
1043             'buildinfo', $nevra)) {
1044         $lock->log("Could not ask Koji for `" . $nevra . "' status " .
1045             "before submitting new build.\n");
1046         return $lock->mark_failed;
1047     }
1048     if ($buildinfo =~ /No such build/m) {
1049         $lock->log("Package not yet submitted for building as expected.\n");
1050     } else {
1051         # Get task ID of already building package
1052         if ($buildinfo =~ /Task:\s*(\d+)/m) {
1053             # TODO: We could compare task target and consider as submitted if
1054             # equaled to intended target.
1055             my $task_id = $1;
1056             $lock->log("Package `$nevra' already submitted as task " .
1057                 "`$task_id'. Previous build failed or somebody builds the " .
1058                 "package concurrently.\n");
1059         } else {
1060             $lock->log("Package `$nevra' already in Koji, but task ID " .
1061                 "could not been determined.\n");
1062         }
1063         $lock->log("Re-submitting the package.\n")
1064     }
1065
1066     # Submit into Koji
1067     my $task_id;
1068     if (!$lock->dooutput($self->repodir, \$task_id, $build_config->pyrpkg(),
1069             (defined $self->pkgdist) ? ('--dist', $self->pkgdist) : (),
1070             'build', '--nowait', '--target', $self->target)) {
1071         $lock->log("Could not submit `" . $nevra . "' into Koji.\n");
1072         return $lock->mark_failed;
1073     }
1074     if (not $task_id =~ /Created task:\s*(\d+)/) {
1075         $lock->log("Could not parse Koji task ID for `$nevra' build\n");
1076         return $lock->mark_failed;
1077     }
1078     $task_id = $1;
1079
1080     # Store task ID
1081     if (! $lock->nstorereference(\$task_id, $self->taskstore)) {
1082         $lock->log("Could not store task ID `" . $task_id . "' of `" . $nevra .
1083             "' package into `" . $self->taskstore . "' file: $@\n");
1084         return $lock->mark_failed;
1085     } else {
1086         $lock->log("Task ID `" . $task_id . "' stored into `" .
1087             $self->taskstore . "' file sucessfully.\n");
1088     }
1089
1090     return $lock->mark_done;
1091 }
1092
1093
1094 # First argument is Fedora::Rebuild::Package::Config module. If mode member is:
1095 #   "koji"      wait for package build in Koji,
1096 #   "local"     build locally using pyrpkg.
1097 #   "mock"      build locally using mock.
1098 # Second argument is Mock object to use instead of fresh one (value undef).
1099 # (This is safe only in single-threaded run. This is limitation of mock.)
1100 # Requires `clone'. Sould be called after `update' or `submitbuild'.
1101 # Third argument is Mock object to use instead of fresh one (value undef) for
1102 # building missing SRPMs.
1103 # Return true on success.
1104 sub build {
1105     my ($self, $build_config, $mock, $src_mock) = @_;
1106     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
1107        state => 'build');
1108     if ($lock->is_done) { return 1; }
1109
1110     my $nevra = $self->get_nevra_from_git($lock, $build_config);
1111     if (! defined $nevra) {
1112         return $lock->mark_failed;
1113     }
1114
1115     if ($build_config->mode() eq 'local') {
1116         if (!$lock->do($self->repodir, $build_config->pyrpkg(),
1117                 (defined $self->pkgdist) ? ('--dist', $self->pkgdist) : (),
1118                 'local')) {
1119             $lock->log("Could not build `" . $nevra . "' locally.\n");
1120             return $lock->mark_failed;
1121         }
1122     } elsif ($build_config->mode() eq 'koji') {
1123         # Retrieve task ID of submitted build
1124         my $task_id = $lock->retrievereference($self->taskstore);
1125         if (! $task_id) {
1126             $lock->log("Could not load task ID for `". $nevra .
1127                 "' build from `" . $self->taskstore . "' file: $@\n");
1128             return $lock->mark_failed;
1129         }
1130         $task_id = $$task_id;
1131
1132         # Wait for build task result
1133         # TODO: How to recognize the process died for other reason
1134         # than build failure?
1135         if (!$lock->do($self->repodir, $build_config->koji(),
1136                 'watch-task', $task_id)) {
1137             $lock->log("Could not get status of Koji task `" . $task_id .
1138                 "' for `$nevra' build, or the task failed.\n");
1139             return $lock->mark_failed;
1140         }
1141     } elsif ($build_config->mode() eq 'mock') {
1142         my $srpm_name = $self->get_srpm_name($lock, $build_config, $src_mock);
1143         if (! defined $srpm_name) {
1144             return $lock->mark_failed;
1145         }
1146         if (!replace_directory($lock, $self->mockdir)) {
1147             return $lock->mark_failed;
1148         }
1149         my ($mock_config_dir, $mock_config_root);
1150         eval {
1151             if (!defined $mock) {
1152                 $mock = Fedora::Rebuild::Mock->new(
1153                     architecture => $build_config->architecture(),
1154                     repositories => $build_config->repositories(),
1155                     install_packages => $build_config->mock_install_packages(),
1156                 );
1157                 $mock->make_configuration;
1158             }
1159             $mock_config_dir = $mock->config_dir;
1160             $mock_config_root = $mock->config_root;
1161         };
1162         if ($@) {
1163             $lock->log("Could not configure mock: $@\n");
1164             File::Path::Tiny::rm($mock_config_dir);
1165             return $lock->mark_failed;
1166         }
1167         my $success = $lock->do(undef, 'mock', '--resultdir', $self->mockdir,
1168                 '--configdir', $mock_config_dir, '--root', $mock_config_root,
1169                 '--rebuild', $srpm_name);
1170         if (defined $mock && !$mock->shared) {
1171             File::Path::Tiny::rm($mock_config_dir);
1172         }
1173         if (!$success) {
1174             $lock->log("Could not build `" . $nevra . "' in mock.\n");
1175             return $lock->mark_failed;
1176         }
1177     } else {
1178         $lock->log("Could not build `" . $nevra .
1179             "' because of unknown building mode `" . $build_config->mode() .
1180             "'.\n");
1181         return $lock->mark_failed;
1182     }
1183
1184     return $lock->mark_done;
1185 }
1186
1187
1188 # Waits for build root rotation. Just built package will be available for
1189 # other packages at build time after returning from this fuction.
1190 # First argument is Fedora::Rebuild::Package::Config object.
1191 # If the mode is "koji", it will wait for the Koji rotation.
1192 # If the mode is "mock", it will create yum repository in directory with
1193 # binary packages.
1194 # If the mode is "local", this function is void.
1195 # Requires `update'. Sould be called after `build'.
1196 # Return true on success.
1197 sub dowaitforbuildroot {
1198     my ($self, $build_config) = @_;
1199     my $lock = Fedora::Rebuild::Package::StateLock->new(package => $self,
1200        state => 'rotate');
1201     if ($lock->is_done) { return 1; }
1202
1203     my $nevra = $self->get_nevra_from_git($lock, $build_config);
1204     if (! defined $nevra) {
1205         return $lock->mark_failed;
1206     }
1207
1208     if ($build_config->mode() eq 'koji') {
1209         if (!$lock->do($self->repodir, $build_config->koji(), 'wait-repo',
1210                 '--build=' . $nevra, '--target', $self->target)) {
1211             $lock->log("Koji does not contain `" . $nevra .
1212                 "' package in build root for `" . $self->target .
1213                 "' build target yet.\n");
1214             return $lock->mark_failed;
1215         }
1216     } elsif ($build_config->mode() eq 'mock') {
1217         $lock->log("`" . $nevra .
1218             "' built in mock, creating yum repository...\n");
1219         if (!$lock->do($self->rpmdir, 'createrepo_c', '.')) {
1220             $lock->log("Could not create yum repository for `" . $nevra .
1221                 "' package.\n");
1222             return $lock->mark_failed;
1223         }
1224         $lock->log("`" . $nevra .
1225             "' yum repository created successfully.\n");
1226     } else {
1227         $lock->log("`" . $nevra .
1228             "' built locally, not waiting on Koji rotation.\n");
1229     }
1230
1231     return $lock->mark_done;
1232 }
1233
1234
1235 # Reset 'rotate' state by removing directory with binary packages produced by
1236 # the package.
1237 # TODO: Untag package from koji?
1238 # Return true on success, otherwise false.
1239 sub reset_rotate {
1240     my ($self) = @_;
1241
1242     my $lock = Fedora::Rebuild::Package::StateLock->new(
1243         package => $self, state => 'rotate');
1244     $lock->log("Reseting state...\n");
1245     if (!remove_directory($lock, $self->rpmdir)) {
1246         return $lock->mark_failed;
1247     }
1248     $lock->mark_failed;
1249     $lock->remove_log;
1250     return 1;
1251 }
1252
1253
1254 # Set hash of build-time dependencies (requires attribute).
1255 # First argument is Fedora::Rebuild::Package::Config object. If mode member is:
1256 #   "local"             build SRPM locally using pyrpkg,
1257 #   "koji" or "mock"    build SRPM using mock.
1258 # Second argument is anonymous clone boolean.
1259 # Third argument is Mock object to use instead of fresh one (value undef).
1260 # (This is safe only in single-threaded run. This is limitation of mock.)
1261 # Fourth argument is Mock object to use instead of fresh one (value undef).
1262 # Return undef in case of failure.
1263 sub get_buildrequires {
1264     my ($self, $build_config, $anonymous, $mock, $src_mock) = @_;
1265     my $ok;
1266     print "Getting BuildRequires for `" . $self->name . "'...\n";
1267
1268     # Procede all steps, each must be re-doable
1269     $ok = $self->clone($anonymous, $build_config);
1270     $ok = $self->srpm(0, $build_config, $mock) if $ok;
1271     $ok = $self->storebuildrequires($build_config, $src_mock) if $ok;
1272     $ok = $self->buildrequires if $ok;
1273
1274     if ($ok) {
1275         print "BuildRequires for `" . $self->name .
1276             "' package distilled successfully.\n";
1277         return 1;
1278     } else {
1279         print "Could not get BuildRequires for `" . $self->name .
1280             "' package.\n";
1281         return undef;
1282     }
1283 }
1284
1285 # Set hash of run-time requires (Requires attribute).
1286 # Return true on success, undef in case of failure.
1287 # XXX: Requires `runrequiresstore'
1288 sub get_binaryrequires {
1289     my $self = shift;
1290     my $ok;
1291     print "Getting run-time requires for `" . $self->name . "'...\n";
1292
1293     $ok = $self->storebinaryrequires;
1294     $ok = $self->loadbinaryrequires if $ok;
1295
1296     if ($ok) {
1297         print "Run-time requires for `" . $self->name .
1298             "' package distilled successfully.\n";
1299         return 1;
1300     } else {
1301         print "Could not get run-time requires for `" . $self->name .
1302             "' package.\n";
1303         return undef;
1304     }
1305 }
1306
1307 # Set hash of run-time provides (provides attribute).
1308 # Return true on success, undef in case of failure.
1309 # XXX: Requires `providesstore'
1310 sub get_binaryprovides {
1311     my $self = shift;
1312     my $ok;
1313     print "Getting binary provides for `" . $self->name . "'...\n";
1314
1315     $ok = $self->storebinaryprovides;
1316     $ok = $self->loadbinaryprovides if $ok;
1317
1318     if ($ok) {
1319         print "Provides for `" . $self->name .
1320             "' package distilled successfully.\n";
1321         return 1;
1322     } else {
1323         print "Could not get Provides for `" . $self->name . "' package.\n";
1324         return undef;
1325     }
1326 }
1327
1328 # Set hash of run-time requires (Requires attribute) and provides
1329 # (provides attribute). Common wrapper for getbinaryrequires() and
1330 # getbinaryprovides().
1331 # Return true on success, undef in case of failure.
1332 # XXX: Requires `runrequiresstore' and `providesstore'
1333 sub get_binarydependencies {
1334     my $self = shift;
1335     my $ok;
1336     print "Getting binary dependencies for `" . $self->name . "'...\n";
1337
1338     $ok = $self->get_binaryrequires;
1339     $ok = $self->get_binaryprovides if $ok;
1340
1341     if ($ok) {
1342         print "Binary dependencies for `" . $self->name .
1343             "' package distilled successfully.\n";
1344         return 1;
1345     } else {
1346         print "Could not get binary dependencies for `" . $self->name .
1347             "' package.\n";
1348         return undef;
1349     }
1350 }
1351
1352 # Edit a package. It clones it, edit it and push the changes.
1353 # Unchanged packages are not pushed, but still reported as successfully
1354 # processed.
1355 # First argument is Fedora::Rebuild::Package::Config object. mode member
1356 # defines build mode:
1357 #   "koji"      publish commit,
1358 #   "local"     without pushing commits to server,
1359 # Second argument is anonymous clone boolean.
1360 # Third argument is a program to execute as the editor as an array reference.
1361 sub cloneeditpush {
1362     my ($self, $build_config, $anonymous, $editor) = @_;
1363     my $ok;
1364     print "Editing `" . $self->name . "'...\n";
1365
1366     # Proceed all steps, each must be re-doable
1367     $ok = $self->clone($anonymous, $build_config);
1368     $ok = $self->edit($build_config->mode(), $editor) if $ok;
1369
1370     if ($ok) {
1371         print "`" . $self->name . "' edit finished successfully.\n";
1372     } else {
1373         print "`" . $self->name . "' edit failed.\n";
1374     }
1375     return $ok;
1376 }
1377
1378 # Rebuild a package without waiting for propagation to next build root.
1379 # First argument is Fedora::Rebuild::Package::Config object. mode member
1380 # defines build mode:
1381 #   "koji"      publish commit and build in Koji,
1382 #   "local"     build locally without pushing commits to server,
1383 #   "mock"      build in mock without pushing commits to server.
1384 # Second argument is anonymous clone boolean.
1385 # Third argument is Mock object to use instead of fresh one (value undef).
1386 # (This is safe only in single-threaded run. This is limitation of mock.)
1387 sub rebuild {
1388     my ($self, $build_config, $anonymous, $mock) = @_;
1389     my $ok;
1390     print "Rebuilding `" . $self->name . "'...\n";
1391
1392     # Proceed all steps, each must be re-doable
1393     $ok = $self->clone($anonymous, $build_config);
1394     $ok = $self->update($build_config->mode()) if $ok;
1395     $ok = $self->submitbuild($build_config)
1396         if ($ok and $build_config->mode() eq 'koji');
1397     $ok = $self->build($build_config, $mock) if $ok;
1398     $ok = $self->binaryrpm($build_config) if $ok;
1399     $ok = $self->get_binaryprovides if $ok;
1400     $ok = $self->get_binaryrequires if $ok;
1401
1402     if ($ok) {
1403         print "`" . $self->name . "' rebuild finished successfully.\n";
1404     } else {
1405         print "`" . $self->name . "' rebuild failed.\n";
1406     }
1407     return $ok;
1408 }
1409
1410 # Wait for the package propagated into new build root.
1411 # First argument is Fedora::Rebuild::Package::Config object.
1412 # If the mode is "koji", waits for Koji build root rotation,
1413 # Otherwise waits locally (no-op).
1414 # XXX: Requires `update', should be called after rebuilding package.
1415 sub waitforbuildroot {
1416     my ($self, $build_config) = @_;
1417     my $ok;
1418     print "Waiting for `" . $self->name . "' to get to build root...\n";
1419
1420     $ok = $self->dowaitforbuildroot($build_config);
1421
1422     if ($ok) {
1423         print "`" . $self->name . "' propagated successfully.\n";
1424     } else {
1425         print "`" . $self->name . "' propagation failed.\n";
1426     }
1427     return $ok;
1428 }
1429
1430 1;