lib/RT/Migrate/Importer.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2013 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( Queue => 0, Name => $self->{OriginalId} );
 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 $self->{Organization}.": $string";
 295 }
 296
 297 sub Create {
 298     my $self = shift;
 299     my ($class, $uid, $data) = @_;
 300
 301     # Use a simpler pre-inflation if we're cloning
 302     if ($self->{Clone}) {
 303         $class->RT::Record::PreInflate( $self, $uid, $data );
 304     } else {
 305         # Non-cloning always wants to make its own id
 306         delete $data->{id};
 307         return unless $class->PreInflate( $self, $uid, $data );
 308     }
 309
 310     my $obj = $class->new( RT->SystemUser );
 311     my ($id, $msg) = eval {
 312         # catch and rethrow on the outside so we can provide more info
 313         local $SIG{__DIE__};
 314         $obj->DBIx::SearchBuilder::Record::Create(
 315             %{$data}
 316         );
 317     };
 318     if (not $id or $@) {
 319         $msg ||= ''; # avoid undef
 320         my $err = "Failed to create $uid: $msg $@\n" . Data::Dumper::Dumper($data) . "\n";
 321         if (not $self->{HandleError}->($self, $err)) {
 322             die $err;
 323         } else {
 324             return;
 325         }
 326     }
 327
 328     $self->{ObjectCount}{$class}++;
 329     $self->Resolve( $uid => $class, $id );
 330
 331     # Load it back to get real values into the columns
 332     $obj = $class->new( RT->SystemUser );
 333     $obj->Load( $id );
 334     $obj->PostInflate( $self );
 335
 336     return $obj;
 337 }
 338
 339 sub ReadStream {
 340     my $self = shift;
 341     my ($fh) = @_;
 342
 343     no warnings 'redefine';
 344     local *RT::Ticket::Load = sub {
 345         my $self = shift;
 346         my $id   = shift;
 347         $self->LoadById( $id );
 348         return $self->Id;
 349     };
 350
 351     my $loaded = Storable::fd_retrieve($fh);
 352
 353     # Metadata is stored at the start of the stream as a hashref
 354     if (ref $loaded eq "HASH") {
 355         $self->LoadMetadata( $loaded );
 356         $self->InitStream;
 357         return;
 358     }
 359
 360     my ($class, $uid, $data) = @{$loaded};
 361
 362     if ($self->{Incremental}) {
 363         my $obj = $class->new( RT->SystemUser );
 364         $obj->Load( $data->{id} );
 365         if (not $uid) {
 366             # undef $uid means "delete it"
 367             $obj->Delete;
 368             $self->{ObjectCount}{$class}++;
 369         } elsif ( $obj->Id ) {
 370             # If it exists, update it
 371             $class->RT::Record::PreInflate( $self, $uid, $data );
 372             $obj->__Set( Field => $_, Value => $data->{$_} )
 373                 for keys %{ $data };
 374             $self->{ObjectCount}{$class}++;
 375         } else {
 376             # Otherwise, make it
 377             $obj = $self->Create( $class, $uid, $data );
 378         }
 379         $self->{Progress}->($obj) if $obj and $self->{Progress};
 380         return;
 381     } elsif ($self->{Clone}) {
 382         my $obj = $self->Create( $class, $uid, $data );
 383         $self->{Progress}->($obj) if $obj and $self->{Progress};
 384         return;
 385     }
 386
 387     # If it's a queue, store its ID away, as we'll need to know
 388     # it to split global CFs into non-global across those
 389     # fields.  We do this before inflating, so that queues which
 390     # got merged still get the CFs applied
 391     push @{$self->{NewQueues}}, $uid
 392         if $class eq "RT::Queue";
 393
 394     my $origid = $data->{id};
 395     my $obj = $self->Create( $class, $uid, $data );
 396     return unless $obj;
 397
 398     # If it's a ticket, we might need to create a
 399     # TicketCustomField for the previous ID
 400     if ($class eq "RT::Ticket" and $self->{OriginalId}) {
 401         my ($id, $msg) = $obj->AddCustomFieldValue(
 402             Field             => $self->{OriginalId},
 403             Value             => $self->Organization . ":$origid",
 404             RecordTransaction => 0,
 405         );
 406         warn "Failed to add custom field to $uid: $msg"
 407             unless $id;
 408     }
 409
 410     # If it's a CF, we don't know yet if it's global (the OCF
 411     # hasn't been created yet) to store away the CF for later
 412     # inspection
 413     push @{$self->{NewCFs}}, $uid
 414         if $class eq "RT::CustomField"
 415             and $obj->LookupType =~ /^RT::Queue/;
 416
 417     $self->{Progress}->($obj) if $self->{Progress};
 418 }
 419
 420 sub CloseStream {
 421     my $self = shift;
 422
 423     $self->{Progress}->(undef, 'force') if $self->{Progress};
 424
 425     return if $self->{Clone};
 426
 427     # Take global CFs which we made and make them un-global
 428     my @queues = grep {$_} map {$self->LookupObj( $_ )} @{$self->{NewQueues}};
 429     for my $obj (map {$self->LookupObj( $_ )} @{$self->{NewCFs}}) {
 430         my $ocf = $obj->IsApplied( 0 ) or next;
 431         $ocf->Delete;
 432         $obj->AddToObject( $_ ) for @queues;
 433     }
 434     $self->{NewQueues} = [];
 435     $self->{NewCFs} = [];
 436 }
 437
 438
 439 sub ObjectCount {
 440     my $self = shift;
 441     return %{ $self->{ObjectCount} };
 442 }
 443
 444 sub Missing {
 445     my $self = shift;
 446     return wantarray ? sort keys %{ $self->{Pending} }
 447         : keys %{ $self->{Pending} };
 448 }
 449
 450 sub Invalid {
 451     my $self = shift;
 452     return wantarray ? sort { $a->{uid} cmp $b->{uid} } @{ $self->{Invalid} }
 453                      : $self->{Invalid};
 454 }
 455
 456 sub Organization {
 457     my $self = shift;
 458     return $self->{Organization};
 459 }
 460
 461 sub Progress {
 462     my $self = shift;
 463     return defined $self->{Progress} unless @_;
 464     return $self->{Progress} = $_[0];
 465 }
 466
 467 1;