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)],
  35                     );
  36      @EXPORT_OK = ();
  37      Exporter::export_ok_tags(keys %EXPORT_TAGS);
  38      $EXPORT_TAGS{all} = [@EXPORT_OK];
  39 }
  40
  41 use Params::Validate qw(validate_with :types);
  42
  43 use Debbugs::Status qw(read_bug split_status_fields);
  44 use Debbugs::DB;
  45 use DateTime;
  46 use Debbugs::Common qw(make_list);
  47 use Debbugs::Config qw(:config);
  48
  49 =head2 Bug loading
  50
  51 Routines to load bug; exported with :load_bug
  52
  53 =over
  54
  55 =item load_bug
  56
  57      load_bug(db => $schema,
  58               data => split_status_fields($data),
  59               tags => \%tags,
  60               queue => \%queue);
  61
  62 Loads a bug's metadata into the database. (Does not load any messages)
  63
  64 =over
  65
  66 =item db -- Debbugs::DB object
  67
  68 =item data -- Bug data (from read_bug) which has been split with split_status_fields
  69
  70 =item tags -- tag cache (hashref); optional
  71
  72 =item queue -- queue of operations to perform after bug is loaded; optional.
  73
  74 =back
  75
  76 =cut
  77
  78 sub load_bug {
  79      my %param = validate_with(params => \@_,
  80                               spec => {db => {type => OBJECT,
  81                                              },
  82                                        data => {type => HASHREF},
  83                                        tags => {type => HASHREF,
  84                                                 default => sub {return {}},
  85                                                 optional => 1},
  86                                        queue => {type => HASHREF,
  87                                                  optional => 1},
  88                                       });
  89     my $s = $param{db};
  90     my $data = $param{data};
  91     my $tags = $param{tags};
  92     my $queue = $param{queue};
  93     my $can_queue = 1;
  94     if (not defined $queue) {
  95         $can_queue = 0;
  96         $queue = {};
  97     }
  98     my $s_data = split_status_fields($data);
  99     my @tags;
 100     for my $tag (make_list($s_data->{keywords})) {
 101         next unless defined $tag and length $tag;
 102         # this allows for invalid tags. But we'll use this to try to
 103         # find those bugs and clean them up
 104         if (not exists $tags->{$tag}) {
 105             $tags->{$tag} = $s->resultset('Tag')->find_or_create({tag => $tag});
 106         }
 107         push @tags, $tags->{$tag};
 108     }
 109     my $bug = {id => $data->{bug_num},
 110                creation => DateTime->from_epoch(epoch => $data->{date}),
 111                log_modified => DateTime->from_epoch(epoch => $data->{log_modified}),
 112                last_modified => DateTime->from_epoch(epoch => $data->{last_modified}),
 113                archived => $data->{archived},
 114                (defined $data->{unarchived} and length($data->{unarchived}))?(unarchived => DateTime->from_epoch(epoch => $data->{unarchived})):(),
 115                forwarded => $data->{forwarded} // '',
 116                summary => $data->{summary} // '',
 117                outlook => $data->{outlook} // '',
 118                subject => $data->{subject} // '',
 119                done => $data->{done} // '',
 120                owner => $data->{owner} // '',
 121                submitter => $data->{submitter} // '',
 122                severity => length($data->{severity}) ? $data->{severity} : $config{default_severity},
 123               };
 124     $s->resultset('Bug')->update_or_create($bug);
 125     $s->txn_do(sub {
 126                    for my $ff (qw(found fixed)) {
 127                        my @elements = $s->resultset('BugVer')->search({bug_id => $data->{bug_num},
 128                                                                        found  => $ff eq 'found'?1:0,
 129                                                                       });
 130                        my %elements_to_delete = map {($elements[$_]->ver_string(),$_)} 0..$#elements;
 131                        my @elements_to_add;
 132                        for my $version (@{$data->{"${ff}_versions"}}) {
 133                            if (exists $elements_to_delete{$version}) {
 134                                delete $elements_to_delete{$version};
 135                            } else {
 136                                push @elements_to_add,$version;
 137                            }
 138                        }
 139                        for my $element (keys %elements_to_delete) {
 140                            $elements_to_delete{$element}->delete();
 141                        }
 142                        for my $element (@elements_to_add) {
 143                            # find source package and source version id
 144                            my $ne = $s->resultset('BugVer')->new_result({bug_id => $data->{bug_num},
 145                                                                          ver_string => $element,
 146                                                                          found => $ff eq 'found'?1:0,
 147                                                                         }
 148                                                                        );
 149                            if (my ($src_pkg,$src_ver) = $element =~ m{^([^\/]+)/(.+)$}) {
 150                                my $src_pkg_e = $s->resultset('SrcPkg')->single({pkg => $src_pkg});
 151                                if (defined $src_pkg_e) {
 152                                    $ne->src_pkg_id($src_pkg_e->id());
 153                                    my $src_ver_e = $s->resultset('SrcVer')->single({src_pkg_id => $src_pkg_e->id(),
 154                                                                                     ver => $src_ver
 155                                                                                    });
 156                                    $ne->src_ver_id($src_ver_e->id()) if defined $src_ver_e;
 157                                }
 158                            }
 159                            $ne->insert();
 160                        }
 161                    }
 162                });
 163     $s->txn_do(sub {
 164                    $s->resultset('BugTag')->search({bug_id => $data->{bug_num}})->delete();
 165                    $s->populate(BugTag => [[qw(bug_id tag_id)], map {[$data->{bug_num}, $_->id()]} @tags]);
 166                });
 167     # because these bugs reference other bugs which might not exist
 168     # yet, we can't handle them until we've loaded all bugs. queue
 169     # them up.
 170     $queue->{merged}{$data->{bug_num}} = [@{$data->{mergedwith}}];
 171     $queue->{blocks}{$data->{bug_num}} = [@{$data->{blocks}}];
 172
 173     if (not $can_queue) {
 174         handle_load_bug_queue(db => $s,queue => $queue);
 175     }
 176
 177     print STDERR "Handled $data->{bug_num}\n";
 178     # still need to handle merges, versions, etc.
 179 }
 180
 181 =item handle_load_bug_queue
 182
 183      handle_load_bug_queue(db => $schema,queue => $queue);
 184
 185 Handles a queue of operations created by load bug. [These operations
 186 are used to handle cases where a bug referenced by a loaded bug may
 187 not exist yet. In cases where the bugs should exist, the queue is
 188 cleared automatically by load_bug if queue is undefined.
 189
 190 =cut
 191
 192 sub handle_load_bug_queue{
 193     my %param = validate_with(params => \@_,
 194                               spec => {db => {type => OBJECT,
 195                                              },
 196                                        queue => {type => HASHREF,
 197                                                 },
 198                                       });
 199     my $s = $param{db};
 200     my $queue = $param{queue};
 201     my %queue_types =
 202         (merged => {set => 'BugMerged',
 203                     columns => [qw(bug_id merged)],
 204                     bug_id => 'bug_id',
 205                    },
 206          blocks => {set => 'BugBlock',
 207                     columns => [qw(bug_id blocks)],
 208                     bug_id => 'bug_id',
 209                    },
 210         );
 211     for my $queue_type (keys %queue_types) {
 212         for my $bug (%{$queue->{$queue_type}}) {
 213             my $qt = $queue_types{$queue_type};
 214             $s->txn_do(sub {
 215                            $s->resultset($qt->{set})->search({$qt->{bug_id},$bug})->delete();
 216                            $s->populate($qt->{set},[[@{$qt->{columns}}],map {[$bug,$_]} @{$queue->{$queue_type}{$bug}}]) if
 217                                @{$queue->{$queue_type}{$bug}};
 218                        }
 219                       );
 220         }
 221     }
 222 }
 223
 224 =back
 225
 226 =head2 Debinfo
 227
 228 Commands to handle src and package version loading from debinfo files
 229
 230 =item load_debinfo
 231
 232      load_debinfo($schema,$binname, $binver, $binarch, $srcname, $srcver);
 233
 234
 235
 236 =cut
 237
 238 sub load_debinfo {
 239     my ($schema,$binname, $binver, $binarch, $srcname, $srcver) = @_;
 240     my $sp = $schema->resultset('SrcPkg')->find_or_create({pkg => $srcname});
 241     my $sv = $schema->resultset('SrcVer')->find_or_create({src_pkg_id=>$sp->id(),
 242                                                            ver => $srcver});
 243     my $arch = $schema->resultset('Arch')->find_or_create({arch => $binarch});
 244     my $bp = $schema->resultset('BinPkg')->find_or_create({pkg => $binname});
 245     $schema->resultset('BinVer')->find_or_create({bin_pkg_id => $bp->id(),
 246                                                   src_ver_id => $sv->id(),
 247                                                   arch_id    => $arch->id(),
 248                                                   ver        => $binver,
 249                                                  });
 250 }
 251
 252 1;
 253
 254
 255 __END__