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