rt/lib/RT/Migrate/Importer.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2015 Best Practical Solutions, LLC
   6 #                                          <sales@bestpractical.com>
   7 #
   8 # (Except where explicitly superseded by other copyright notices)
   9 #
  10 #
  11 # LICENSE:
  12 #
  13 # This work is made available to you under the terms of Version 2 of
  14 # the GNU General Public License. A copy of that license should have
  15 # been provided with this software, but in any event can be snarfed
  16 # from www.gnu.org.
  17 #
  18 # This work is distributed in the hope that it will be useful, but
  19 # WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 # General Public License for more details.
  22 #
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program; if not, write to the Free Software
  25 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  26 # 02110-1301 or visit their web page on the internet at
  27 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
  28 #
  29 #
  30 # CONTRIBUTION SUBMISSION POLICY:
  31 #
  32 # (The following paragraph is not intended to limit the rights granted
  33 # to you to modify and distribute this software under the terms of
  34 # the GNU General Public License and is only of importance to you if
  35 # you choose to contribute your changes and enhancements to the
  36 # community by submitting them to Best Practical Solutions, LLC.)
  37 #
  38 # By intentionally submitting any modifications, corrections or
  39 # derivatives to this work, or any other work intended for use with
  40 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
  41 # you are the copyright holder for those contributions and you grant
  42 # Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
  43 # royalty-free, perpetual, license to use, copy, create derivative
  44 # works based on those contributions, and sublicense and distribute
  45 # those contributions and any derivatives thereof.
  46 #
  47 # END BPS TAGGED BLOCK }}}
  48
  49 package RT::Migrate::Importer;
  50
  51 use strict;
  52 use warnings;
  53
  54 use Storable qw//;
  55 use File::Spec;
  56 use Carp qw/carp/;
  57
  58 sub new {
  59     my $class = shift;
  60     my $self = bless {}, $class;
  61     $self->Init(@_);
  62     return $self;
  63 }
  64
  65 sub Init {
  66     my $self = shift;
  67     my %args = (
  68         OriginalId  => undef,
  69         Progress    => undef,
  70         Statefile   => undef,
  71         DumpObjects => undef,
  72         HandleError => undef,
  73         @_,
  74     );
  75
  76     # Should we attempt to preserve record IDs as they are created?
  77     $self->{OriginalId} = $args{OriginalId};
  78
  79     $self->{Progress} = $args{Progress};
  80
  81     $self->{HandleError} = sub { 0 };
  82     $self->{HandleError} = $args{HandleError}
  83         if $args{HandleError} and ref $args{HandleError} eq 'CODE';
  84
  85     if ($args{DumpObjects}) {
  86         require Data::Dumper;
  87         $self->{DumpObjects} = { map { $_ => 1 } @{$args{DumpObjects}} };
  88     }
  89
  90     # Objects we've created
  91     $self->{UIDs} = {};
  92
  93     # Columns we need to update when an object is later created
  94     $self->{Pending} = {};
  95
  96     # Objects missing from the source database before serialization
  97     $self->{Invalid} = [];
  98
  99     # What we created
 100     $self->{ObjectCount} = {};
 101
 102     # To know what global CFs need to be unglobal'd and applied to what
 103     $self->{NewQueues} = [];
 104     $self->{NewCFs} = [];
 105 }
 106
 107 sub Metadata {
 108     my $self = shift;
 109     return $self->{Metadata};
 110 }
 111
 112 sub LoadMetadata {
 113     my $self = shift;
 114     my ($data) = @_;
 115
 116     return if $self->{Metadata};
 117     $self->{Metadata} = $data;
 118
 119     die "Incompatible format version: ".$data->{Format}
 120         if $data->{Format} ne "0.8";
 121
 122     $self->{Organization} = $data->{Organization};
 123     $self->{Clone}        = $data->{Clone};
 124     $self->{Incremental}  = $data->{Incremental};
 125     $self->{Files}        = $data->{Files} if $data->{Final};
 126 }
 127
 128 sub InitStream {
 129     my $self = shift;
 130
 131     die "Stream initialized after objects have been recieved!"
 132         if keys %{ $self->{UIDs} };
 133
 134     die "Cloning does not support importing the Original Id separately\n"
 135         if $self->{OriginalId} and $self->{Clone};
 136
 137     die "RT already contains data; overwriting will not work\n"
 138         if ($self->{Clone} and not $self->{Incremental})
 139             and RT->SystemUser->Id;
 140
 141     # Basic facts of life, as a safety net
 142     $self->Resolve( RT->System->UID => ref RT->System, RT->System->Id );
 143     $self->SkipTransactions( RT->System->UID );
 144
 145     if ($self->{OriginalId}) {
 146         # Where to shove the original ticket ID
 147         my $cf = RT::CustomField->new( RT->SystemUser );
 148         $cf->LoadByName( Name => $self->{OriginalId}, LookupType => RT::Ticket->CustomFieldLookupType, ObjectId => 0 );
 149         unless ($cf->Id) {
 150             warn "Failed to find global CF named $self->{OriginalId} -- creating one";
 151             $cf->Create(
 152                 Queue => 0,
 153                 Name  => $self->{OriginalId},
 154                 Type  => 'FreeformSingle',
 155             );
 156         }
 157     }
 158 }
 159
 160 sub Resolve {
 161     my $self = shift;
 162     my ($uid, $class, $id) = @_;
 163     $self->{UIDs}{$uid} = [ $class, $id ];
 164     return unless $self->{Pending}{$uid};
 165
 166     for my $ref (@{$self->{Pending}{$uid}}) {
 167         my ($pclass, $pid) = @{ $self->Lookup( $ref->{uid} ) };
 168         my $obj = $pclass->new( RT->SystemUser );
 169         $obj->LoadByCols( Id => $pid );
 170         $obj->__Set(
 171             Field => $ref->{column},
 172             Value => $id,
 173         ) if defined $ref->{column};
 174         $obj->__Set(
 175             Field => $ref->{classcolumn},
 176             Value => $class,
 177         ) if defined $ref->{classcolumn};
 178         $obj->__Set(
 179             Field => $ref->{uri},
 180             Value => $self->LookupObj($uid)->URI,
 181         ) if defined $ref->{uri};
 182     }
 183     delete $self->{Pending}{$uid};
 184 }
 185
 186 sub Lookup {
 187     my $self = shift;
 188     my ($uid) = @_;
 189     unless (defined $uid) {
 190         carp "Tried to lookup an undefined UID";
 191         return;
 192     }
 193     return $self->{UIDs}{$uid};
 194 }
 195
 196 sub LookupObj {
 197     my $self = shift;
 198     my ($uid) = @_;
 199     my $ref = $self->Lookup( $uid );
 200     return unless $ref;
 201     my ($class, $id) = @{ $ref };
 202
 203     my $obj = $class->new( RT->SystemUser );
 204     $obj->Load( $id );
 205     return $obj;
 206 }
 207
 208 sub Postpone {
 209     my $self = shift;
 210     my %args = (
 211         for         => undef,
 212         uid         => undef,
 213         column      => undef,
 214         classcolumn => undef,
 215         uri         => undef,
 216         @_,
 217     );
 218     my $uid = delete $args{for};
 219
 220     if (defined $uid) {
 221         push @{$self->{Pending}{$uid}}, \%args;
 222     } else {
 223         push @{$self->{Invalid}}, \%args;
 224     }
 225 }
 226
 227 sub SkipTransactions {
 228     my $self = shift;
 229     my ($uid) = @_;
 230     return if $self->{Clone};
 231     $self->{SkipTransactions}{$uid} = 1;
 232 }
 233
 234 sub ShouldSkipTransaction {
 235     my $self = shift;
 236     my ($uid) = @_;
 237     return exists $self->{SkipTransactions}{$uid};
 238 }
 239
 240 sub MergeValues {
 241     my $self = shift;
 242     my ($obj, $data) = @_;
 243     for my $col (keys %{$data}) {
 244         next if defined $obj->__Value($col) and length $obj->__Value($col);
 245         next unless defined $data->{$col} and length $data->{$col};
 246
 247         if (ref $data->{$col}) {
 248             my $uid = ${ $data->{$col} };
 249             my $ref = $self->Lookup( $uid );
 250             if ($ref) {
 251                 $data->{$col} = $ref->[1];
 252             } else {
 253                 $self->Postpone(
 254                     for => $obj->UID,
 255                     uid => $uid,
 256                     column => $col,
 257                 );
 258                 next;
 259             }
 260         }
 261         $obj->__Set( Field => $col, Value => $data->{$col} );
 262     }
 263 }
 264
 265 sub SkipBy {
 266     my $self = shift;
 267     my ($column, $class, $uid, $data) = @_;
 268
 269     my $obj = $class->new( RT->SystemUser );
 270     $obj->Load( $data->{$column} );
 271     return unless $obj->Id;
 272
 273     $self->SkipTransactions( $uid );
 274
 275     $self->Resolve( $uid => $class => $obj->Id );
 276     return $obj;
 277 }
 278
 279 sub MergeBy {
 280     my $self = shift;
 281     my ($column, $class, $uid, $data) = @_;
 282
 283     my $obj = $self->SkipBy(@_);
 284     return unless $obj;
 285     $self->MergeValues( $obj, $data );
 286     return 1;
 287 }
 288
 289 sub Qualify {
 290     my $self = shift;
 291     my ($string) = @_;
 292     return $string if $self->{Clone};
 293     return $string if not defined $self->{Organization};
 294     return $string if $self->{Organization} eq $RT::Organization;
 295     return $self->{Organization}.": $string";
 296 }
 297
 298 sub Create {
 299     my $self = shift;
 300     my ($class, $uid, $data) = @_;
 301
 302     # Use a simpler pre-inflation if we're cloning
 303     if ($self->{Clone}) {
 304         $class->RT::Record::PreInflate( $self, $uid, $data );
 305     } else {
 306         # Non-cloning always wants to make its own id
 307         delete $data->{id};
 308         return unless $class->PreInflate( $self, $uid, $data );
 309     }
 310
 311     my $obj = $class->new( RT->SystemUser );
 312     my ($id, $msg) = eval {
 313         # catch and rethrow on the outside so we can provide more info
 314         local $SIG{__DIE__};
 315         $obj->DBIx::SearchBuilder::Record::Create(
 316             %{$data}
 317         );
 318     };
 319     if (not $id or $@) {
 320         $msg ||= ''; # avoid undef
 321         my $err = "Failed to create $uid: $msg $@\n" . Data::Dumper::Dumper($data) . "\n";
 322         if (not $self->{HandleError}->($self, $err)) {
 323             die $err;
 324         } else {
 325             return;
 326         }
 327     }
 328
 329     $self->{ObjectCount}{$class}++;
 330     $self->Resolve( $uid => $class, $id );
 331
 332     # Load it back to get real values into the columns
 333     $obj = $class->new( RT->SystemUser );
 334     $obj->Load( $id );
 335     $obj->PostInflate( $self );
 336
 337     return $obj;
 338 }
 339
 340 sub ReadStream {
 341     my $self = shift;
 342     my ($fh) = @_;
 343
 344     no warnings 'redefine';
 345     local *RT::Ticket::Load = sub {
 346         my $self = shift;
 347         my $id   = shift;
 348         $self->LoadById( $id );
 349         return $self->Id;
 350     };
 351
 352     my $loaded = Storable::fd_retrieve($fh);
 353
 354     # Metadata is stored at the start of the stream as a hashref
 355     if (ref $loaded eq "HASH") {
 356         $self->LoadMetadata( $loaded );
 357         $self->InitStream;
 358         return;
 359     }
 360
 361     my ($class, $uid, $data) = @{$loaded};
 362
 363     if ($self->{Incremental}) {
 364         my $obj = $class->new( RT->SystemUser );
 365         $obj->Load( $data->{id} );
 366         if (not $uid) {
 367             # undef $uid means "delete it"
 368             $obj->Delete;
 369             $self->{ObjectCount}{$class}++;
 370         } elsif ( $obj->Id ) {
 371             # If it exists, update it
 372             $class->RT::Record::PreInflate( $self, $uid, $data );
 373             $obj->__Set( Field => $_, Value => $data->{$_} )
 374                 for keys %{ $data };
 375             $self->{ObjectCount}{$class}++;
 376         } else {
 377             # Otherwise, make it
 378             $obj = $self->Create( $class, $uid, $data );
 379         }
 380         $self->{Progress}->($obj) if $obj and $self->{Progress};
 381         return;
 382     } elsif ($self->{Clone}) {
 383         my $obj = $self->Create( $class, $uid, $data );
 384         $self->{Progress}->($obj) if $obj and $self->{Progress};
 385         return;
 386     }
 387
 388     # If it's a queue, store its ID away, as we'll need to know
 389     # it to split global CFs into non-global across those
 390     # fields.  We do this before inflating, so that queues which
 391     # got merged still get the CFs applied
 392     push @{$self->{NewQueues}}, $uid
 393         if $class eq "RT::Queue";
 394
 395     my $origid = $data->{id};
 396     my $obj = $self->Create( $class, $uid, $data );
 397     return unless $obj;
 398
 399     # If it's a ticket, we might need to create a
 400     # TicketCustomField for the previous ID
 401     if ($class eq "RT::Ticket" and $self->{OriginalId}) {
 402         my ($id, $msg) = $obj->AddCustomFieldValue(
 403             Field             => $self->{OriginalId},
 404             Value             => $self->Organization . ":$origid",
 405             RecordTransaction => 0,
 406         );
 407         warn "Failed to add custom field to $uid: $msg"
 408             unless $id;
 409     }
 410
 411     # If it's a CF, we don't know yet if it's global (the OCF
 412     # hasn't been created yet) to store away the CF for later
 413     # inspection
 414     push @{$self->{NewCFs}}, $uid
 415         if $class eq "RT::CustomField"
 416             and $obj->LookupType =~ /^RT::Queue/;
 417
 418     $self->{Progress}->($obj) if $self->{Progress};
 419 }
 420
 421 sub CloseStream {
 422     my $self = shift;
 423
 424     $self->{Progress}->(undef, 'force') if $self->{Progress};
 425
 426     return if $self->{Clone};
 427
 428     # Take global CFs which we made and make them un-global
 429     my @queues = grep {$_} map {$self->LookupObj( $_ )} @{$self->{NewQueues}};
 430     for my $obj (map {$self->LookupObj( $_ )} @{$self->{NewCFs}}) {
 431         my $ocf = $obj->IsGlobal or next;
 432         $ocf->Delete;
 433         $obj->AddToObject( $_ ) for @queues;
 434     }
 435     $self->{NewQueues} = [];
 436     $self->{NewCFs} = [];
 437 }
 438
 439
 440 sub ObjectCount {
 441     my $self = shift;
 442     return %{ $self->{ObjectCount} };
 443 }
 444
 445 sub Missing {
 446     my $self = shift;
 447     return wantarray ? sort keys %{ $self->{Pending} }
 448         : keys %{ $self->{Pending} };
 449 }
 450
 451 sub Invalid {
 452     my $self = shift;
 453     return wantarray ? sort { $a->{uid} cmp $b->{uid} } @{ $self->{Invalid} }
 454                      : $self->{Invalid};
 455 }
 456
 457 sub Organization {
 458     my $self = shift;
 459     return $self->{Organization};
 460 }
 461
 462 sub Progress {
 463     my $self = shift;
 464     return defined $self->{Progress} unless @_;
 465     return $self->{Progress} = $_[0];
 466 }
 467
 468 1;