lib/Debbugs/DB/Load.pm

   1 # This module is part of debbugs, and is released
   2 # under the terms of the GPL version 2, or any later version. See the
   3 # file README and COPYING for more information.
   4 # Copyright 2013 by Don Armstrong <don@donarmstrong.com>.
   5
   6 package Debbugs::DB::Load;
   7
   8 =head1 NAME
   9
  10 Debbugs::DB::Load -- Utility routines for loading the database
  11
  12 =head1 SYNOPSIS
  13
  14
  15 =head1 DESCRIPTION
  16
  17
  18 =head1 BUGS
  19
  20 None known.
  21
  22 =cut
  23
  24 use warnings;
  25 use strict;
  26 use v5.10;
  27 use vars qw($VERSION $DEBUG %EXPORT_TAGS @EXPORT_OK @EXPORT);
  28 use base qw(Exporter);
  29
  30 BEGIN{
  31      ($VERSION) = q$Revision$ =~ /^Revision:\s+([^\s+])/;
  32      $DEBUG = 0 unless defined $DEBUG;
  33
  34      @EXPORT = ();
  35      %EXPORT_TAGS = (load_bug    => [qw(load_bug handle_load_bug_queue load_bug_log)],
  36                      load_debinfo => [qw(load_debinfo)],
  37                      load_package => [qw(load_packages)],
  38                      load_suite => [qw(load_suite)],
  39                     );
  40      @EXPORT_OK = ();
  41      Exporter::export_ok_tags(keys %EXPORT_TAGS);
  42      $EXPORT_TAGS{all} = [@EXPORT_OK];
  43 }
  44
  45 use Params::Validate qw(validate_with :types);
  46 use List::AllUtils qw(natatime);
  47
  48 use Debbugs::Status qw(read_bug split_status_fields);
  49 use Debbugs::DB;
  50 use DateTime;
  51 use Debbugs::Common qw(make_list getparsedaddrs);
  52 use Debbugs::Config qw(:config);
  53 use Debbugs::MIME qw(parse_to_mime_entity decode_rfc1522);
  54 use DateTime::Format::Mail;
  55 use Carp;
  56
  57 =head2 Bug loading
  58
  59 Routines to load bug; exported with :load_bug
  60
  61 =over
  62
  63 =item load_bug
  64
  65      load_bug(db => $schema,
  66               data => split_status_fields($data),
  67               tags => \%tags,
  68               queue => \%queue);
  69
  70 Loads a bug's metadata into the database. (Does not load any messages)
  71
  72 =over
  73
  74 =item db -- Debbugs::DB object
  75
  76 =item data -- Bug data (from read_bug) which has been split with split_status_fields
  77
  78 =item tags -- tag cache (hashref); optional
  79
  80 =item queue -- queue of operations to perform after bug is loaded; optional.
  81
  82 =back
  83
  84 =cut
  85
  86 sub load_bug {
  87     my %param = validate_with(params => \@_,
  88                               spec => {db => {type => OBJECT,
  89                                              },
  90                                        data => {type => HASHREF,
  91                                                 optional => 1,
  92                                                },
  93                                        bug => {type => SCALAR,
  94                                                optional => 1,
  95                                               },
  96                                        tags => {type => HASHREF,
  97                                                 default => sub {return {}},
  98                                                 optional => 1},
  99                                        severities => {type => HASHREF,
 100                                                       default => sub {return {}},
 101                                                       optional => 1,
 102                                                      },
 103                                        queue => {type => HASHREF,
 104                                                  optional => 1},
 105                                        packages => {type => HASHREF,
 106                                                     default => sub {return {}},
 107                                                     optional => 1,
 108                                                    },
 109                                       });
 110     my $s = $param{db};
 111     if (not exists $param{data} and not exists $param{bug}) {
 112         croak "One of data or bug must be provided to load_bug";
 113     }
 114     if (not exists $param{data}) {
 115         $param{data} = read_bug(bug => $param{bug});
 116     }
 117     my $data = $param{data};
 118     my $tags = $param{tags};
 119     my $queue = $param{queue};
 120     my $severities = $param{severities};
 121     my $can_queue = 1;
 122     if (not defined $queue) {
 123         $can_queue = 0;
 124         $queue = {};
 125     }
 126     my %tags;
 127     $data = split_status_fields($data);
 128     for my $tag (make_list($data->{keywords})) {
 129         next unless defined $tag and length $tag;
 130         # this allows for invalid tags. But we'll use this to try to
 131         # find those bugs and clean them up
 132         if (not exists $tags->{$tag}) {
 133             $tags->{$tag} = $s->resultset('Tag')->
 134             find_or_create({tag => $tag});
 135         }
 136         $tags{$tag} = $tags->{$tag};
 137     }
 138     my $severity = length($data->{severity}) ? $data->{severity} :
 139         $config{default_severity};
 140     if (not exists $severities->{$severity}) {
 141         $severities->{$severity} =
 142             $s->resultset('Severity')->
 143             find_or_create({severity => $severity},
 144                           );
 145     }
 146     $severity = $severities->{$severity};
 147     my $bug =
 148         {id => $data->{bug_num},
 149          creation => DateTime->from_epoch(epoch => $data->{date}),
 150          log_modified => DateTime->from_epoch(epoch => $data->{log_modified}),
 151          last_modified => DateTime->from_epoch(epoch => $data->{last_modified}),
 152          archived => $data->{archived},
 153          (defined $data->{unarchived} and length($data->{unarchived}))?
 154          (unarchived => DateTime->from_epoch(epoch => $data->{unarchived})):(),
 155          forwarded => $data->{forwarded} // '',
 156          summary => $data->{summary} // '',
 157          outlook => $data->{outlook} // '',
 158          subject => $data->{subject} // '',
 159          done_full => $data->{done} // '',
 160          severity => $severity,
 161          owner_full => $data->{owner} // '',
 162          submitter_full => $data->{originator} // '',
 163         };
 164     my %addr_map =
 165         (done => 'done',
 166          owner => 'owner',
 167          submitter => 'originator',
 168         );
 169     for my $addr_type (keys %addr_map) {
 170         $bug->{$addr_type} = undef;
 171         next unless defined $data->{$addr_map{$addr_type}} and
 172             length($data->{$addr_map{$addr_type}});
 173         $bug->{$addr_type} =
 174             $s->resultset('Correspondent')->
 175             get_correspondent_id($data->{$addr_map{$addr_type}})
 176     }
 177     my $b = $s->resultset('Bug')->update_or_create($bug) or
 178         die "Unable to update or create bug $bug->{id}";
 179     $s->txn_do(sub {
 180                    my @unknown_packages;
 181                    my @unknown_affects_packages;
 182                    push @unknown_packages,
 183                        $b->set_related_packages('binpackages',
 184                                                 [grep {defined $_ and
 185                                                            length $_ and $_ !~ /^src:/}
 186                                                  make_list($data->{package})],
 187                                                 $param{packages},
 188                                                );
 189                    push @unknown_packages,
 190                        $b->set_related_packages('srcpackages',
 191                                                 [map {s/src://;
 192                                                       $_}
 193                                                  grep {defined $_ and
 194                                                            $_ =~ /^src:/}
 195                                                  make_list($data->{package})],
 196                                                 $param{packages},
 197                                                );
 198                    push @unknown_affects_packages,
 199                        $b->set_related_packages('affects_binpackages',
 200                                                 [grep {defined $_ and
 201                                                            length $_ and $_ !~ /^src:/}
 202                                                  make_list($data->{affects})
 203                                                 ],
 204                                                 $param{packages},
 205                                                );
 206                    push @unknown_affects_packages,
 207                        $b->set_related_packages('affects_srcpackages',
 208                                                 [map {s/src://;
 209                                                       $_}
 210                                                  grep {defined $_ and
 211                                                            $_ =~ /^src:/}
 212                                                  make_list($data->{affects})],
 213                                                 $param{packages},
 214                                                );
 215                    $b->unknown_packages(join(', ',@unknown_packages));
 216                    $b->unknown_affects(join(', ',@unknown_affects_packages));
 217                    $b->update();
 218                    for my $ff (qw(found fixed)) {
 219                        my @elements = $s->resultset('BugVer')->search({bug => $data->{bug_num},
 220                                                                        found  => $ff eq 'found'?1:0,
 221                                                                       });
 222                        my %elements_to_delete = map {($elements[$_]->ver_string(),
 223                                                       $elements[$_])} 0..$#elements;
 224                        my %elements_to_add;
 225                        my @elements_to_keep;
 226                        for my $version (@{$data->{"${ff}_versions"}}) {
 227                            if (exists $elements_to_delete{$version}) {
 228                                push @elements_to_keep,$version;
 229                            } else {
 230                                $elements_to_add{$version} = 1;
 231                            }
 232                        }
 233                        for my $version (@elements_to_keep) {
 234                            delete $elements_to_delete{$version};
 235                        }
 236                        for my $element (keys %elements_to_delete) {
 237                            $elements_to_delete{$element}->delete();
 238                        }
 239                        for my $element (keys %elements_to_add) {
 240                            # find source package and source version id
 241                            my $ne = $s->resultset('BugVer')->new_result({bug => $data->{bug_num},
 242                                                                          ver_string => $element,
 243                                                                          found => $ff eq 'found'?1:0,
 244                                                                         }
 245                                                                        );
 246                            if (my ($src_pkg,$src_ver) = $element =~ m{^([^\/]+)/(.+)$}) {
 247                                my $src_pkg_e = $s->resultset('SrcPkg')->single({pkg => $src_pkg});
 248                                if (defined $src_pkg_e) {
 249                                    $ne->src_pkg($src_pkg_e->id());
 250                                    my $src_ver_e = $s->resultset('SrcVer')->single({src_pkg => $src_pkg_e->id(),
 251                                                                                     ver => $src_ver
 252                                                                                    });
 253                                    $ne->src_ver($src_ver_e->id()) if defined $src_ver_e;
 254                                }
 255                            }
 256                            $ne->insert();
 257                        }
 258                    }
 259                });
 260     ### set bug tags
 261     $s->txn_do(sub {$b->set_tags([values %tags ] )});
 262     # because these bugs reference other bugs which might not exist
 263     # yet, we can't handle them until we've loaded all bugs. queue
 264     # them up.
 265     for my $merge_block (qw(mergedwith blocks)) {
 266         my $count = 0;
 267         if (@{$data->{$merge_block}}) {
 268             $count =
 269                 $s->resultset('Bug')->
 270                 search({id => [@{$data->{$merge_block}}]})->
 271                 count();
 272         }
 273         # if all of the bugs exist, immediately fix the merge/blocks
 274         if ($count == @{$data->{$merge_block}}) {
 275             handle_load_bug_queue(db=>$s,
 276                                   queue => {$merge_block,
 277                                            {$data->{bug_num},[@{$data->{$merge_block}}]}
 278                                            });
 279         } else {
 280             $queue->{$merge_block}{$data->{bug_num}} = [@{$data->{$merge_block}}];
 281         }
 282     }
 283
 284     if (not $can_queue and keys %{$queue}) {
 285         handle_load_bug_queue(db => $s,queue => $queue);
 286     }
 287
 288     # still need to handle merges, versions, etc.
 289 }
 290
 291 =item handle_load_bug_queue
 292
 293      handle_load_bug_queue(db => $schema,queue => $queue);
 294
 295 Handles a queue of operations created by load bug. [These operations
 296 are used to handle cases where a bug referenced by a loaded bug may
 297 not exist yet. In cases where the bugs should exist, the queue is
 298 cleared automatically by load_bug if queue is undefined.
 299
 300 =cut
 301
 302 sub handle_load_bug_queue{
 303     my %param = validate_with(params => \@_,
 304                               spec => {db => {type => OBJECT,
 305                                              },
 306                                        queue => {type => HASHREF,
 307                                                 },
 308                                       });
 309     my $s = $param{db};
 310     my $queue = $param{queue};
 311     my %queue_types =
 312         (mergedwith => {set => 'BugMerged',
 313                         columns => [qw(bug merged)],
 314                         bug => 'bug',
 315                        },
 316          blocks => {set => 'BugBlock',
 317                     columns => [qw(bug blocks)],
 318                     bug => 'bug',
 319                    },
 320         );
 321     for my $queue_type (keys %queue_types) {
 322         my $qt = $queue_types{$queue_type};
 323         my @bugs = keys %{$queue->{$queue_type}};
 324         next unless @bugs;
 325         my @entries;
 326         for my $bug (@bugs) {
 327             push @entries,
 328                 map {[$bug,$_]}
 329                 @{$queue->{$queue_type}{$bug}};
 330         }
 331         $s->txn_do(sub {
 332                        $s->resultset($qt->{set})->
 333                            search({$qt->{bug}=>\@bugs})->delete();
 334                        $s->resultset($qt->{set})->
 335                            populate([[@{$qt->{columns}}],
 336                                      @entries]) if @entries;
 337                        }
 338                   );
 339     }
 340 }
 341
 342 =item load_bug_log -- load bug logs
 343
 344        load_bug_log(db  => $s,
 345                     bug => $bug);
 346
 347
 348 =over
 349
 350 =item db -- database
 351
 352 =item bug -- bug whose log should be loaded
 353
 354 =back
 355
 356 =cut
 357
 358 sub load_bug_log {
 359     my %param = validate_with(params => \@_,
 360                               spec => {db => {type => OBJECT,
 361                                              },
 362                                        bug => {type => SCALAR,
 363                                               },
 364                                        queue => {type => HASHREF,
 365                                                  optional => 1},
 366                                       });
 367     my $s = $param{db};
 368     my $msg_num=0;
 369     my %seen_msg_ids;
 370     my $log = Debbugs::Log->new(bug_num => $param{bug}) or
 371         die "Unable to open log for $param{bug} for reading: $!";
 372     while (my $record = $log->read_record()) {
 373         next unless $record->{type} eq 'incoming-recv';
 374         my ($msg_id) = $record->{text} =~ /^Message-Id:\s+<(.+)>/im;
 375         next if defined $msg_id and exists $seen_msg_ids{$msg_id};
 376         $seen_msg_ids{$msg_id} = 1 if defined $msg_id;
 377         next if defined $msg_id and $msg_id =~ /handler\..+\.ack(?:info)?\@/;
 378         my $entity = parse_to_mime_entity($record);
 379         # search for a message with this message id in the database
 380         $msg_id = $entity->head->get('Message-Id') //
 381             $entity->head->get('Resent-Message-ID') //
 382             '';
 383         $msg_id =~ s/^\s*\<//;
 384         $msg_id =~ s/>\s*$//;
 385         # check to see if the subject, to, and from match. if so, it's
 386         # probably the same message.
 387         my $subject = decode_rfc1522($entity->head->get('Subject')//'');
 388         $subject =~ s/\n(?:(\s)\s*|\s*$)//g;
 389         my $to = decode_rfc1522($entity->head->get('To')//'');
 390         $to =~ s/\n(?:(\s)\s*|\s*$)//g;
 391         my $from = decode_rfc1522($entity->head->get('From')//'');
 392         $from =~ s/\n(?:(\s)\s*|\s*$)//g;
 393         my $m = $s->resultset('Message')->
 394             find({msgid => $msg_id,
 395                   from_complete => $from,
 396                   to_complete => $to,
 397                   subject => $subject
 398                  });
 399         if (not defined $m) {
 400             # if not, create a new message
 401             $m = $s->resultset('Message')->
 402                 find_or_create({msgid => $msg_id,
 403                                 from_complete => $from,
 404                                 to_complete => $to,
 405                                 subject => $subject
 406                                });
 407             eval {
 408                 my $date = DateTime::Format::Mail->
 409                     parse_datetime($entity->head->get('Date',0));
 410                 if (abs($date->offset) >= 60 * 60 * 12) {
 411                     $date = $date->set_time_zone('UTC');
 412                 }
 413                 $m->sent_date($date);
 414             };
 415             my $spam = $entity->head->get('X-Spam-Status',0)//'';
 416             if ($spam=~ /score=([\d\.]+)/) {
 417                 $m->spam_score($1);
 418             }
 419             my %corr;
 420             @{$corr{from}} = getparsedaddrs($from);
 421             @{$corr{to}} = getparsedaddrs($to);
 422             @{$corr{cc}} = getparsedaddrs($entity->head->get('Cc'));
 423             # add correspondents if necessary
 424             my @cors;
 425             for my $type (keys %corr) {
 426                 for my $addr (@{$corr{$type}}) {
 427                     my $cor = $s->resultset('Correspondent')->
 428                         get_correspondent_id($addr);
 429                     next unless defined $cor;
 430                     push @cors,
 431                         {correspondent => $cor,
 432                          correspondent_type => $type,
 433                         };
 434                 }
 435             }
 436             $m->update();
 437             $s->txn_do(sub {
 438                            $m->message_correspondents()->delete();
 439                            $m->add_to_message_correspondents(@cors) if
 440                                @cors;
 441                        }
 442                       );
 443         }
 444         my $recv;
 445         if ($entity->head->get('Received',0)
 446             =~ /via spool by (\S+)/) {
 447             $recv = $s->resultset('Correspondent')->
 448                 get_correspondent_id($1);
 449             $m->add_to_message_correspondents({correspondent=>$recv,
 450                                                correspondent_type => 'recv'});
 451         }
 452         # link message to bugs if necessary
 453         $m->find_or_create_related('bug_messages',
 454                                   {bug=>$param{bug},
 455                                    message_number => $msg_num});
 456     }
 457
 458 }
 459
 460 =back
 461
 462 =head2 Debinfo
 463
 464 Commands to handle src and package version loading from debinfo files
 465
 466 =over
 467
 468 =item load_debinfo
 469
 470      load_debinfo($schema,$binname, $binver, $binarch, $srcname, $srcver);
 471
 472
 473
 474 =cut
 475
 476 sub load_debinfo {
 477     my ($s,$binname, $binver, $binarch, $srcname, $srcver,$ct_date,$cache) = @_;
 478     $cache //= {};
 479     my $sp;
 480     if (not defined $cache->{sp}{$srcname}) {
 481         $cache->{sp}{$srcname} =
 482             $s->resultset('SrcPkg')->find_or_create({pkg => $srcname});
 483     }
 484     $sp = $cache->{sp}{$srcname};
 485     # update the creation date if the data we have is earlier
 486     if (defined $ct_date and
 487         (not defined $sp->creation or
 488          $ct_date < $sp->creation)) {
 489         $sp->creation($ct_date);
 490         $sp->last_modified(DateTime->now);
 491         $sp->update;
 492     }
 493     my $sv;
 494     if (not defined $cache->{sv}{$srcname}{$srcver}) {
 495         $cache->{sv}{$srcname}{$srcver} =
 496             $s->resultset('SrcVer')->
 497             find_or_create({src_pkg =>$sp->id(),
 498                             ver => $srcver});
 499     }
 500     $sv = $cache->{sv}{$srcname}{$srcver};
 501     if (defined $ct_date and
 502         (not defined $sv->upload_date() or $ct_date < $sv->upload_date())) {
 503         $sv->upload_date($ct_date);
 504         $sv->update;
 505     }
 506     my $arch;
 507     if (not defined $cache->{arch}{$binarch}) {
 508         $cache->{arch}{$binarch} =
 509             $s->resultset('Arch')->
 510             find_or_create({arch => $binarch},
 511                           )->id();
 512     }
 513     $arch = $cache->{arch}{$binarch};
 514     my $bp;
 515     if (not defined $cache->{bp}{$binname}) {
 516         $cache->{bp}{$binname} =
 517             $s->resultset('BinPkg')->
 518             get_or_create_bin_pkg_id($binname);
 519     }
 520     $bp = $cache->{bp}{$binname};
 521     $s->resultset('BinVer')->
 522         get_bin_ver_id($bp,$binver,$arch,$sv->id());
 523 }
 524
 525
 526 =back
 527
 528 =head2 Packages
 529
 530 =over
 531
 532 =item load_package
 533
 534      load_package($schema,$suite,$component,$arch,$pkg)
 535
 536 =cut
 537
 538 sub load_packages {
 539     my ($schema,$suite,$pkgs,$p) = @_;
 540     my $suite_id = $schema->resultset('Suite')->
 541         find_or_create({codename => $suite})->id;
 542     my %maint_cache;
 543     my %arch_cache;
 544     my %source_cache;
 545     my $src_max_last_modified = $schema->resultset('SrcAssociation')->
 546         search_rs({suite => $suite_id},
 547                  {order_by => {-desc => ['me.modified']},
 548                   rows => 1,
 549                   page => 1
 550                  }
 551                  )->single();
 552     my $bin_max_last_modified = $schema->resultset('BinAssociation')->
 553         search_rs({suite => $suite_id},
 554                  {order_by => {-desc => ['me.modified']},
 555                   rows => 1,
 556                   page => 1
 557                  }
 558                  )->single();
 559     my %maints;
 560     my %sources;
 561     my %bins;
 562     for my $pkg_tuple (@{$pkgs}) {
 563         my ($arch,$component,$pkg) = @{$pkg_tuple};
 564         $maints{$pkg->{Maintainer}} = $pkg->{Maintainer};
 565         if ($arch eq 'source') {
 566             my $source = $pkg->{Package};
 567             my $source_ver = $pkg->{Version};
 568             $sources{$source}{$source_ver} = $pkg->{Maintainer};
 569         } else {
 570             my $source = $pkg->{Source} // $pkg->{Package};
 571             my $source_ver = $pkg->{Version};
 572             if ($source =~ /^\s*(\S+) \(([^\)]+)\)\s*$/) {
 573                 ($source,$source_ver) = ($1,$2);
 574             }
 575             $sources{$source}{$source_ver} = $pkg->{Maintainer};
 576             $bins{$arch}{$pkg->{Package}} =
 577                {arch => $arch,
 578                 bin => $pkg->{Package},
 579                 bin_ver => $pkg->{Version},
 580                 src_ver => $source_ver,
 581                 source  => $source,
 582                 maint   => $pkg->{Maintainer},
 583                };
 584         }
 585     }
 586     # Retrieve and Insert new maintainers
 587     my $maints =
 588         $schema->resultset('Maintainer')->
 589         get_maintainers(keys %maints);
 590     my $archs =
 591         $schema->resultset('Arch')->
 592         get_archs(keys %bins);
 593     # We want all of the source package/versions which are in this suite to
 594     # start with
 595     my @sa_to_add;
 596     my @sa_to_del;
 597     my %included_sa;
 598     # Calculate which source packages are no longer in this suite
 599     for my $s ($schema->resultset('SrcPkg')->
 600                src_pkg_and_ver_in_suite($suite)) {
 601         if (not exists $sources{$s->{pkg}} or
 602             not exists $sources{$s->{pkg}}{$s->{src_vers}{ver}}
 603            ) {
 604             push @sa_to_del,
 605                 $s->{src_associations}{id};
 606         }
 607         $included_sa{$s->{pkg}}{$s->{src_vers}} = 1;
 608     }
 609     # Calculate which source packages are newly in this suite
 610     for my $s (keys %sources) {
 611         for my $v (keys %{$sources{$s}}) {
 612             if (not exists $included_sa{$s} and
 613                 not $included_sa{$s}{$v}) {
 614                 push @sa_to_add,
 615                     [$s,$v,$sources{$s}{$v}];
 616             } else {
 617                 $p->update() if defined $p;
 618             }
 619         }
 620     }
 621     # add new source packages
 622     my $it = natatime 100, @sa_to_add;
 623     while (my @v = $it->()) {
 624         $schema->txn_do(
 625             sub {
 626                 for my $svm (@_) {
 627                     my $s_id = $schema->resultset('SrcPkg')->
 628                         get_or_create_src_pkg_id($svm->[0]);
 629                     my $sv_id = $schema->resultset('SrcVer')->
 630                         get_src_ver_id($s_id,$svm->[1],$maints->{$svm->[2]});
 631                     $schema->resultset('SrcAssociation')->
 632                         insert_suite_src_ver_association($suite_id,$sv_id);
 633                 }
 634             },
 635                         @v
 636                        );
 637         $p->update($p->last_update()+
 638                    scalar @v) if defined $p;
 639     }
 640     # remove associations for packages not in this suite
 641     if (@sa_to_del) {
 642         $it = natatime 1000, @sa_to_del;
 643         while (my @v = $it->()) {
 644             $schema->
 645                 txn_do(sub {
 646                            $schema->resultset('SrcAssociation')->
 647                                search_rs({id => \@v})->
 648                                delete();
 649                        });
 650         }
 651     }
 652     # update packages in this suite to have a modification time of now
 653     $schema->resultset('SrcAssociation')->
 654         search_rs({suite => $suite_id})->
 655         update({modified => 'NOW()'});
 656     ## Handle binary packages
 657     my @bin_to_del;
 658     my @bin_to_add;
 659     my %included_bin;
 660     # calculate which binary packages are no longer in this suite
 661     for my $b ($schema->resultset('BinPkg')->
 662                bin_pkg_and_ver_in_suite($suite)) {
 663         if (not exists $bins{$b->{arch}{arch}} or
 664             not exists $bins{$b->{arch}{arch}}{$b->{pkg}} or
 665             ($bins{$b->{arch}{arch}}{$b->{pkg}}{bin_ver} ne
 666              $b->{bin_vers}{ver}
 667             )
 668            ) {
 669             push @bin_to_del,
 670                 $b->{bin_associations}{id};
 671         }
 672         $included_bin{$b->{arch}{arch}}{$b->{pkg}} =
 673             $b->{bin_vers}{ver};
 674     }
 675     # calculate which binary packages are newly in this suite
 676     for my $a (keys %bins) {
 677         for my $pkg (keys %{$bins{$a}}) {
 678             if (not exists $included_bin{$a} or
 679                 not exists $included_bin{$a}{$pkg} or
 680                 $bins{$a}{$pkg}{bin_ver} ne
 681                 $included_bin{$a}{$pkg}) {
 682                 push @bin_to_add,
 683                     $bins{$a}{$pkg};
 684             } else {
 685                 $p->update() if defined $p;
 686             }
 687         }
 688     }
 689     $it = natatime 100, @bin_to_add;
 690     while (my @v = $it->()) {
 691         $schema->txn_do(
 692         sub {
 693             for my $bvm (@_) {
 694                 my $s_id = $schema->resultset('SrcPkg')->
 695                     get_or_create_src_pkg_id($bvm->{source});
 696                 my $sv_id = $schema->resultset('SrcVer')->
 697                     get_src_ver_id($s_id,$bvm->{src_ver},$maints->{$bvm->{maint}});
 698                 my $b_id = $schema->resultset('BinPkg')->
 699                     get_or_create_bin_pkg_id($bvm->{bin});
 700                 my $bv_id = $schema->resultset('BinVer')->
 701                     get_bin_ver_id($b_id,$bvm->{bin_ver},
 702                                    $archs->{$bvm->{arch}},$sv_id);
 703                 $schema->resultset('BinAssociation')->
 704                     insert_suite_bin_ver_association($suite_id,$bv_id);
 705             }
 706         },
 707                         @v
 708                        );
 709         $p->update($p->last_update()+
 710                    scalar @v) if defined $p;
 711     }
 712     if (@bin_to_del) {
 713         $it = natatime 1000, @bin_to_del;
 714         while (my @v = $it->()) {
 715             $schema->
 716                 txn_do(sub {
 717                            $schema->resultset('BinAssociation')->
 718                                search_rs({id => \@v})->
 719                                delete();
 720                        });
 721         }
 722     }
 723     $schema->resultset('BinAssociation')->
 724         search_rs({suite => $suite_id})->
 725         update({modified => 'NOW()'});
 726
 727 }
 728
 729
 730 =back
 731
 732 =cut
 733
 734 =head2 Suites
 735
 736 =over
 737
 738 =item load_suite
 739
 740      load_suite($schema,$codename,$suite,$version,$active);
 741
 742 =cut
 743
 744 sub load_suite {
 745     my ($schema,$codename,$suite,$version,$active) = @_;
 746     if (ref($codename)) {
 747         ($codename,$suite,$version) =
 748             @{$codename}{qw(Codename Suite Version)};
 749         $active = 1;
 750     }
 751     my $s = $schema->resultset('Suite')->find_or_create({codename => $codename});
 752     $s->suite_name($suite);
 753     $s->version($version);
 754     $s->active($active);
 755     $s->update();
 756     return $s;
 757
 758 }
 759
 760 =back
 761
 762 =cut
 763
 764 1;
 765
 766
 767 __END__
 768 # Local Variables:
 769 # indent-tabs-mode: nil
 770 # cperl-indent-level: 4
 771 # End: