rt/lib/RT/Handle.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 =head1 NAME
  50
  51 RT::Handle - RT's database handle
  52
  53 =head1 SYNOPSIS
  54
  55     use RT;
  56     BEGIN { RT::LoadConfig() };
  57     use RT::Handle;
  58
  59 =head1 DESCRIPTION
  60
  61 C<RT::Handle> is RT specific wrapper over one of L<DBIx::SearchBuilder::Handle>
  62 classes. As RT works with different types of DBs we subclass repsective handler
  63 from L<DBIx::SerachBuilder>. Type of the DB is defined by C<DatabasseType> RT's
  64 config option. You B<must> load this module only when the configs have been
  65 loaded.
  66
  67 =cut
  68
  69 package RT::Handle;
  70
  71 use strict;
  72 use warnings;
  73
  74 use File::Spec;
  75
  76 =head1 METHODS
  77
  78 =head2 FinalizeDatabaseType
  79
  80 Sets RT::Handle's superclass to the correct subclass of
  81 L<DBIx::SearchBuilder::Handle>, using the C<DatabaseType> configuration.
  82
  83 =cut
  84
  85 sub FinalizeDatabaseType {
  86     eval {
  87         use base "DBIx::SearchBuilder::Handle::". RT->Config->Get('DatabaseType');
  88     };
  89
  90     if ($@) {
  91         die "Unable to load DBIx::SearchBuilder database handle for '". RT->Config->Get('DatabaseType') ."'.\n".
  92             "Perhaps you've picked an invalid database type or spelled it incorrectly.\n".
  93             $@;
  94     }
  95 }
  96
  97 =head2 Connect
  98
  99 Connects to RT's database using credentials and options from the RT config.
 100 Takes nothing.
 101
 102 =cut
 103
 104 sub Connect {
 105     my $self = shift;
 106     my %args = (@_);
 107
 108     my $db_type = RT->Config->Get('DatabaseType');
 109     if ( $db_type eq 'Oracle' ) {
 110         $ENV{'NLS_LANG'} = "AMERICAN_AMERICA.AL32UTF8";
 111         $ENV{'NLS_NCHAR'} = "AL32UTF8";
 112     }
 113
 114     $self->SUPER::Connect(
 115         User => RT->Config->Get('DatabaseUser'),
 116         Password => RT->Config->Get('DatabasePassword'),
 117         %args,
 118     );
 119
 120     if ( $db_type eq 'mysql' ) {
 121         my $version = $self->DatabaseVersion;
 122         ($version) = $version =~ /^(\d+\.\d+)/;
 123         $self->dbh->do("SET NAMES 'utf8'") if $version >= 4.1;
 124     }
 125
 126
 127     if ( $db_type eq 'Pg' ) {
 128         my $version = $self->DatabaseVersion;
 129         ($version) = $version =~ /^(\d+\.\d+)/;
 130         $self->dbh->do("SET bytea_output = 'escape'") if $version >= 9.0;
 131     }
 132
 133
 134
 135     $self->dbh->{'LongReadLen'} = RT->Config->Get('MaxAttachmentSize');
 136 }
 137
 138 =head2 BuildDSN
 139
 140 Build the DSN for the RT database. Doesn't take any parameters, draws all that
 141 from the config.
 142
 143 =cut
 144
 145
 146 sub BuildDSN {
 147     my $self = shift;
 148     # Unless the database port is a positive integer, we really don't want to pass it.
 149     my $db_port = RT->Config->Get('DatabasePort');
 150     $db_port = undef unless (defined $db_port && $db_port =~ /^(\d+)$/);
 151     my $db_host = RT->Config->Get('DatabaseHost');
 152     $db_host = undef unless $db_host;
 153     my $db_name = RT->Config->Get('DatabaseName');
 154     my $db_type = RT->Config->Get('DatabaseType');
 155     $db_name = File::Spec->catfile($RT::VarPath, $db_name)
 156         if $db_type eq 'SQLite' && !File::Spec->file_name_is_absolute($db_name);
 157
 158     my %args = (
 159         Host       => $db_host,
 160         Database   => $db_name,
 161         Port       => $db_port,
 162         Driver     => $db_type,
 163         RequireSSL => RT->Config->Get('DatabaseRequireSSL'),
 164         DisconnectHandleOnDestroy => 1,
 165     );
 166     if ( $db_type eq 'Oracle' && $db_host ) {
 167         $args{'SID'} = delete $args{'Database'};
 168     }
 169     $self->SUPER::BuildDSN( %args );
 170 }
 171
 172 =head2 DSN
 173
 174 Returns the DSN for this handle. In order to get correct value you must
 175 build DSN first, see L</BuildDSN>.
 176
 177 This is method can be called as class method, in this case creates
 178 temporary handle object, L</BuildDSN builds DSN> and returns it.
 179
 180 =cut
 181
 182 sub DSN {
 183     my $self = shift;
 184     return $self->SUPER::DSN if ref $self;
 185
 186     my $handle = $self->new;
 187     $handle->BuildDSN;
 188     return $handle->DSN;
 189 }
 190
 191 =head2 SystemDSN
 192
 193 Returns a DSN suitable for database creates and drops
 194 and user creates and drops.
 195
 196 Gets RT's DSN first (see L<DSN>) and then change it according
 197 to requirements of a database system RT's using.
 198
 199 =cut
 200
 201 sub SystemDSN {
 202     my $self = shift;
 203
 204     my $db_name = RT->Config->Get('DatabaseName');
 205     my $db_type = RT->Config->Get('DatabaseType');
 206
 207     my $dsn = $self->DSN;
 208     if ( $db_type eq 'mysql' ) {
 209         # with mysql, you want to connect sans database to funge things
 210         $dsn =~ s/dbname=\Q$db_name//;
 211     }
 212     elsif ( $db_type eq 'Pg' ) {
 213         # with postgres, you want to connect to template1 database
 214         $dsn =~ s/dbname=\Q$db_name/dbname=template1/;
 215     }
 216     return $dsn;
 217 }
 218
 219 =head2 Database compatibility and integrity checks
 220
 221
 222
 223 =cut
 224
 225 sub CheckIntegrity {
 226     my $self = shift;
 227     $self = new $self unless ref $self;
 228
 229     unless ($RT::Handle and $RT::Handle->dbh) {
 230         local $@;
 231         unless ( eval { RT::ConnectToDatabase(); 1 } ) {
 232             return (0, 'no connection', "$@");
 233         }
 234     }
 235
 236     require RT::CurrentUser;
 237     my $test_user = RT::CurrentUser->new;
 238     $test_user->Load('RT_System');
 239     unless ( $test_user->id ) {
 240         return (0, 'no system user', "Couldn't find RT_System user in the DB '". $self->DSN ."'");
 241     }
 242
 243     $test_user = RT::CurrentUser->new;
 244     $test_user->Load('Nobody');
 245     unless ( $test_user->id ) {
 246         return (0, 'no nobody user', "Couldn't find Nobody user in the DB '". $self->DSN ."'");
 247     }
 248
 249     return $RT::Handle->dbh;
 250 }
 251
 252 sub CheckCompatibility {
 253     my $self = shift;
 254     my $dbh = shift;
 255     my $state = shift || 'post';
 256
 257     my $db_type = RT->Config->Get('DatabaseType');
 258     if ( $db_type eq "mysql" ) {
 259         # Check which version we're running
 260         my $version = ($dbh->selectrow_array("show variables like 'version'"))[1];
 261         return (0, "couldn't get version of the mysql server")
 262             unless $version;
 263
 264         ($version) = $version =~ /^(\d+\.\d+)/;
 265         return (0, "RT is unsupported on MySQL versions before 4.1.  Your version is $version.")
 266             if $version < 4.1;
 267
 268         # MySQL must have InnoDB support
 269         local $dbh->{FetchHashKeyName} = 'NAME_lc';
 270         my $innodb = lc($dbh->selectall_hashref("SHOW ENGINES", "engine")->{InnoDB}{support} || "no");
 271         if ( $innodb eq "no" ) {
 272             return (0, "RT requires that MySQL be compiled with InnoDB table support.\n".
 273                 "See <http://dev.mysql.com/doc/mysql/en/innodb-storage-engine.html>\n".
 274                 "and check that there are no 'skip-innodb' lines in your my.cnf.");
 275         } elsif ( $innodb eq "disabled" ) {
 276             return (0, "RT requires that MySQL InnoDB table support be enabled.\n".
 277                 "Remove the 'skip-innodb' or 'innodb = OFF' line from your my.cnf file, restart MySQL, and try again.\n");
 278         }
 279
 280         if ( $state eq 'post' ) {
 281             my $create_table = $dbh->selectrow_arrayref("SHOW CREATE TABLE Tickets")->[1];
 282             unless ( $create_table =~ /(?:ENGINE|TYPE)\s*=\s*InnoDB/i ) {
 283                 return (0, "RT requires that all its tables be of InnoDB type. Upgrade RT tables.");
 284             }
 285
 286             $create_table = $dbh->selectrow_arrayref("SHOW CREATE TABLE Attachments")->[1];
 287             unless ( $create_table =~ /\bContent\b[^,]*BLOB/i ) {
 288                 return (0, "RT since version 3.8 has new schema for MySQL versions after 4.1.0\n"
 289                     ."Follow instructions in the UPGRADING.mysql file.");
 290             }
 291         }
 292
 293         my $max_packet = ($dbh->selectrow_array("show variables like 'max_allowed_packet'"))[1];
 294         if ($state =~ /^(create|post)$/ and $max_packet <= (1024 * 1024)) {
 295             my $max_packet = sprintf("%.1fM", $max_packet/1024/1024);
 296             warn "max_allowed_packet is set to $max_packet, which limits the maximum attachment or email size that RT can process.  Consider adjusting MySQL's max_allowed_packet setting.\n";
 297         }
 298     }
 299     return (1)
 300 }
 301
 302 sub CheckSphinxSE {
 303     my $self = shift;
 304
 305     my $dbh = $RT::Handle->dbh;
 306     local $dbh->{'RaiseError'} = 0;
 307     local $dbh->{'PrintError'} = 0;
 308     my $has = ($dbh->selectrow_array("show variables like 'have_sphinx'"))[1];
 309     $has ||= ($dbh->selectrow_array(
 310         "select 'yes' from INFORMATION_SCHEMA.PLUGINS where PLUGIN_NAME = 'sphinx' AND PLUGIN_STATUS='active'"
 311     ))[0];
 312
 313     return 0 unless lc($has||'') eq "yes";
 314     return 1;
 315 }
 316
 317 =head2 Database maintanance
 318
 319 =head3 CreateDatabase $DBH
 320
 321 Creates a new database. This method can be used as class method.
 322
 323 Takes DBI handle. Many database systems require special handle to
 324 allow you to create a new database, so you have to use L<SystemDSN>
 325 method during connection.
 326
 327 Fetches type and name of the DB from the config.
 328
 329 =cut
 330
 331 sub CreateDatabase {
 332     my $self = shift;
 333     my $dbh  = shift or return (0, "No DBI handle provided");
 334     my $db_type = RT->Config->Get('DatabaseType');
 335     my $db_name = RT->Config->Get('DatabaseName');
 336
 337     my $status;
 338     if ( $db_type eq 'SQLite' ) {
 339         return (1, 'Skipped as SQLite doesn\'t need any action');
 340     }
 341     elsif ( $db_type eq 'Oracle' ) {
 342         my $db_user = RT->Config->Get('DatabaseUser');
 343         my $db_pass = RT->Config->Get('DatabasePassword');
 344         $status = $dbh->do(
 345             "CREATE USER $db_user IDENTIFIED BY $db_pass"
 346             ." default tablespace USERS"
 347             ." temporary tablespace TEMP"
 348             ." quota unlimited on USERS"
 349         );
 350         unless ( $status ) {
 351             return $status, "Couldn't create user $db_user identified by $db_pass."
 352                 ."\nError: ". $dbh->errstr;
 353         }
 354         $status = $dbh->do( "GRANT connect, resource TO $db_user" );
 355         unless ( $status ) {
 356             return $status, "Couldn't grant connect and resource to $db_user."
 357                 ."\nError: ". $dbh->errstr;
 358         }
 359         return (1, "Created user $db_user. All RT's objects should be in his schema.");
 360     }
 361     elsif ( $db_type eq 'Pg' ) {
 362         $status = $dbh->do("CREATE DATABASE $db_name WITH ENCODING='UNICODE' TEMPLATE template0");
 363     }
 364     else {
 365         $status = $dbh->do("CREATE DATABASE $db_name");
 366     }
 367     return ($status, $DBI::errstr);
 368 }
 369
 370 =head3 DropDatabase $DBH
 371
 372 Drops RT's database. This method can be used as class method.
 373
 374 Takes DBI handle as first argument. Many database systems require
 375 a special handle to allow you to drop a database, so you may have
 376 to use L<SystemDSN> when acquiring the DBI handle.
 377
 378 Fetches the type and name of the database from the config.
 379
 380 =cut
 381
 382 sub DropDatabase {
 383     my $self = shift;
 384     my $dbh  = shift or return (0, "No DBI handle provided");
 385
 386     my $db_type = RT->Config->Get('DatabaseType');
 387     my $db_name = RT->Config->Get('DatabaseName');
 388
 389     if ( $db_type eq 'Oracle' ) {
 390         my $db_user = RT->Config->Get('DatabaseUser');
 391         my $status = $dbh->do( "DROP USER $db_user CASCADE" );
 392         unless ( $status ) {
 393             return 0, "Couldn't drop user $db_user."
 394                 ."\nError: ". $dbh->errstr;
 395         }
 396         return (1, "Successfully dropped user '$db_user' with his schema.");
 397     }
 398     elsif ( $db_type eq 'SQLite' ) {
 399         my $path = $db_name;
 400         $path = "$RT::VarPath/$path" unless substr($path, 0, 1) eq '/';
 401         unlink $path or return (0, "Couldn't remove '$path': $!");
 402         return (1);
 403     } else {
 404         $dbh->do("DROP DATABASE ". $db_name)
 405             or return (0, $DBI::errstr);
 406     }
 407     return (1);
 408 }
 409
 410 =head2 InsertACL
 411
 412 =cut
 413
 414 sub InsertACL {
 415     my $self      = shift;
 416     my $dbh       = shift;
 417     my $base_path = shift || $RT::EtcPath;
 418
 419     my $db_type = RT->Config->Get('DatabaseType');
 420     return (1) if $db_type eq 'SQLite';
 421
 422     $dbh = $self->dbh if !$dbh && ref $self;
 423     return (0, "No DBI handle provided") unless $dbh;
 424
 425     return (0, "'$base_path' doesn't exist") unless -e $base_path;
 426
 427     my $path;
 428     if ( -d $base_path ) {
 429         $path = File::Spec->catfile( $base_path, "acl.$db_type");
 430         $path = $self->GetVersionFile($dbh, $path);
 431
 432         $path = File::Spec->catfile( $base_path, "acl")
 433             unless $path && -e $path;
 434         return (0, "Couldn't find ACLs for $db_type")
 435             unless -e $path;
 436     } else {
 437         $path = $base_path;
 438     }
 439
 440     local *acl;
 441     do $path || return (0, "Couldn't load ACLs: " . $@);
 442     my @acl = acl($dbh);
 443     foreach my $statement (@acl) {
 444         my $sth = $dbh->prepare($statement)
 445             or return (0, "Couldn't prepare SQL query:\n $statement\n\nERROR: ". $dbh->errstr);
 446         unless ( $sth->execute ) {
 447             return (0, "Couldn't run SQL query:\n $statement\n\nERROR: ". $sth->errstr);
 448         }
 449     }
 450     return (1);
 451 }
 452
 453 =head2 InsertSchema
 454
 455 =cut
 456
 457 sub InsertSchema {
 458     my $self = shift;
 459     my $dbh  = shift;
 460     my $base_path = (shift || $RT::EtcPath);
 461
 462     $dbh = $self->dbh if !$dbh && ref $self;
 463     return (0, "No DBI handle provided") unless $dbh;
 464
 465     my $db_type = RT->Config->Get('DatabaseType');
 466
 467     my $file;
 468     if ( -d $base_path ) {
 469         $file = $base_path . "/schema." . $db_type;
 470     } else {
 471         $file = $base_path;
 472     }
 473
 474     $file = $self->GetVersionFile( $dbh, $file );
 475     unless ( $file ) {
 476         return (0, "Couldn't find schema file(s) '$file*'");
 477     }
 478     unless ( -f $file && -r $file ) {
 479         return (0, "File '$file' doesn't exist or couldn't be read");
 480     }
 481
 482     my (@schema);
 483
 484     open( my $fh_schema, '<', $file ) or die $!;
 485
 486     my $has_local = 0;
 487     open( my $fh_schema_local, "<" . $self->GetVersionFile( $dbh, $RT::LocalEtcPath . "/schema." . $db_type ))
 488         and $has_local = 1;
 489
 490     my $statement = "";
 491     foreach my $line ( <$fh_schema>, ($_ = ';;'), $has_local? <$fh_schema_local>: () ) {
 492         $line =~ s/\#.*//g;
 493         $line =~ s/--.*//g;
 494         $statement .= $line;
 495         if ( $line =~ /;(\s*)$/ ) {
 496             $statement =~ s/;(\s*)$//g;
 497             push @schema, $statement;
 498             $statement = "";
 499         }
 500     }
 501     close $fh_schema; close $fh_schema_local;
 502
 503     if ( $db_type eq 'Oracle' ) {
 504         my $db_user = RT->Config->Get('DatabaseUser');
 505         my $status = $dbh->do( "ALTER SESSION SET CURRENT_SCHEMA=$db_user" );
 506         unless ( $status ) {
 507             return $status, "Couldn't set current schema to $db_user."
 508                 ."\nError: ". $dbh->errstr;
 509         }
 510     }
 511
 512     local $SIG{__WARN__} = sub {};
 513     my $is_local = 0;
 514     $dbh->begin_work or return (0, "Couldn't begin transaction: ". $dbh->errstr);
 515     foreach my $statement (@schema) {
 516         if ( $statement =~ /^\s*;$/ ) {
 517             $is_local = 1; next;
 518         }
 519
 520         my $sth = $dbh->prepare($statement)
 521             or return (0, "Couldn't prepare SQL query:\n$statement\n\nERROR: ". $dbh->errstr);
 522         unless ( $sth->execute or $is_local ) {
 523             return (0, "Couldn't run SQL query:\n$statement\n\nERROR: ". $sth->errstr);
 524         }
 525     }
 526     $dbh->commit or return (0, "Couldn't commit transaction: ". $dbh->errstr);
 527     return (1);
 528 }
 529
 530 =head1 GetVersionFile
 531
 532 Takes base name of the file as argument, scans for <base name>-<version> named
 533 files and returns file name with closest version to the version of the RT DB.
 534
 535 =cut
 536
 537 sub GetVersionFile {
 538     my $self = shift;
 539     my $dbh = shift;
 540     my $base_name = shift;
 541
 542     my $db_version = ref $self
 543         ? $self->DatabaseVersion
 544         : do {
 545             my $tmp = RT::Handle->new;
 546             $tmp->dbh($dbh);
 547             $tmp->DatabaseVersion;
 548         };
 549
 550     require File::Glob;
 551     my @files = File::Glob::bsd_glob("$base_name*");
 552     return '' unless @files;
 553
 554     my %version = map { $_ =~ /\.\w+-([-\w\.]+)$/; ($1||0) => $_ } @files;
 555     my $version;
 556     foreach ( reverse sort cmp_version keys %version ) {
 557         if ( cmp_version( $db_version, $_ ) >= 0 ) {
 558             $version = $_;
 559             last;
 560         }
 561     }
 562
 563     return defined $version? $version{ $version } : undef;
 564 }
 565
 566 { my %word = (
 567     a     => -4,
 568     alpha => -4,
 569     b     => -3,
 570     beta  => -3,
 571     pre   => -2,
 572     rc    => -1,
 573     head  => 9999,
 574 );
 575 sub cmp_version($$) {
 576     my ($a, $b) = (@_);
 577     my @a = grep defined, map { /^[0-9]+$/? $_ : /^[a-zA-Z]+$/? $word{$_}|| -10 : undef }
 578         split /([^0-9]+)/, $a;
 579     my @b = grep defined, map { /^[0-9]+$/? $_ : /^[a-zA-Z]+$/? $word{$_}|| -10 : undef }
 580         split /([^0-9]+)/, $b;
 581     @a > @b
 582         ? push @b, (0) x (@a-@b)
 583         : push @a, (0) x (@b-@a);
 584     for ( my $i = 0; $i < @a; $i++ ) {
 585         return $a[$i] <=> $b[$i] if $a[$i] <=> $b[$i];
 586     }
 587     return 0;
 588 }
 589
 590 sub version_words {
 591     return keys %word;
 592 }
 593
 594 }
 595
 596
 597 =head2 InsertInitialData
 598
 599 Inserts system objects into RT's DB, like system user or 'nobody',
 600 internal groups and other records required. However, this method
 601 doesn't insert any real users like 'root' and you have to use
 602 InsertData or another way to do that.
 603
 604 Takes no arguments. Returns status and message tuple.
 605
 606 It's safe to call this method even if those objects already exist.
 607
 608 =cut
 609
 610 sub InsertInitialData {
 611     my $self    = shift;
 612
 613     my @warns;
 614
 615     # create RT_System user and grant him rights
 616     {
 617         require RT::CurrentUser;
 618
 619         my $test_user = RT::User->new( RT::CurrentUser->new() );
 620         $test_user->Load('RT_System');
 621         if ( $test_user->id ) {
 622             push @warns, "Found system user in the DB.";
 623         }
 624         else {
 625             my $user = RT::User->new( RT::CurrentUser->new() );
 626             my ( $val, $msg ) = $user->_BootstrapCreate(
 627                 Name     => 'RT_System',
 628                 RealName => 'The RT System itself',
 629                 Comments => 'Do not delete or modify this user. '
 630                     . 'It is integral to RT\'s internal database structures',
 631                 Creator  => '1',
 632                 LastUpdatedBy => '1',
 633             );
 634             return ($val, $msg) unless $val;
 635         }
 636         DBIx::SearchBuilder::Record::Cachable->FlushCache;
 637     }
 638
 639     # init RT::SystemUser and RT::System objects
 640     RT::InitSystemObjects();
 641     unless ( RT->SystemUser->id ) {
 642         return (0, "Couldn't load system user");
 643     }
 644
 645     # grant SuperUser right to system user
 646     {
 647         my $test_ace = RT::ACE->new( RT->SystemUser );
 648         $test_ace->LoadByCols(
 649             PrincipalId   => ACLEquivGroupId( RT->SystemUser->Id ),
 650             PrincipalType => 'Group',
 651             RightName     => 'SuperUser',
 652             ObjectType    => 'RT::System',
 653             ObjectId      => 1,
 654         );
 655         if ( $test_ace->id ) {
 656             push @warns, "System user has global SuperUser right.";
 657         } else {
 658             my $ace = RT::ACE->new( RT->SystemUser );
 659             my ( $val, $msg ) = $ace->_BootstrapCreate(
 660                 PrincipalId   => ACLEquivGroupId( RT->SystemUser->Id ),
 661                 PrincipalType => 'Group',
 662                 RightName     => 'SuperUser',
 663                 ObjectType    => 'RT::System',
 664                 ObjectId      => 1,
 665             );
 666             return ($val, $msg) unless $val;
 667         }
 668         DBIx::SearchBuilder::Record::Cachable->FlushCache;
 669     }
 670
 671     # system groups
 672     # $self->loc('Everyone'); # For the string extractor to get a string to localize
 673     # $self->loc('Privileged'); # For the string extractor to get a string to localize
 674     # $self->loc('Unprivileged'); # For the string extractor to get a string to localize
 675     foreach my $name (qw(Everyone Privileged Unprivileged)) {
 676         my $group = RT::Group->new( RT->SystemUser );
 677         $group->LoadSystemInternalGroup( $name );
 678         if ( $group->id ) {
 679             push @warns, "System group '$name' already exists.";
 680             next;
 681         }
 682
 683         $group = RT::Group->new( RT->SystemUser );
 684         my ( $val, $msg ) = $group->_Create(
 685             Type        => $name,
 686             Domain      => 'SystemInternal',
 687             Description => 'Pseudogroup for internal use',  # loc
 688             Name        => '',
 689             Instance    => '',
 690         );
 691         return ($val, $msg) unless $val;
 692     }
 693
 694     # nobody
 695     {
 696         my $user = RT::User->new( RT->SystemUser );
 697         $user->Load('Nobody');
 698         if ( $user->id ) {
 699             push @warns, "Found 'Nobody' user in the DB.";
 700         }
 701         else {
 702             my ( $val, $msg ) = $user->Create(
 703                 Name     => 'Nobody',
 704                 RealName => 'Nobody in particular',
 705                 Comments => 'Do not delete or modify this user. It is integral '
 706                     .'to RT\'s internal data structures',
 707                 Privileged => 0,
 708             );
 709             return ($val, $msg) unless $val;
 710         }
 711
 712         if ( $user->HasRight( Right => 'OwnTicket', Object => $RT::System ) ) {
 713             push @warns, "User 'Nobody' has global OwnTicket right.";
 714         } else {
 715             my ( $val, $msg ) = $user->PrincipalObj->GrantRight(
 716                 Right => 'OwnTicket',
 717                 Object => $RT::System,
 718             );
 719             return ($val, $msg) unless $val;
 720         }
 721     }
 722
 723     # rerun to get init Nobody as well
 724     RT::InitSystemObjects();
 725
 726     # system role groups
 727     foreach my $name (qw(Owner Requestor Cc AdminCc)) {
 728         my $group = RT::Group->new( RT->SystemUser );
 729         $group->LoadSystemRoleGroup( $name );
 730         if ( $group->id ) {
 731             push @warns, "System role '$name' already exists.";
 732             next;
 733         }
 734
 735         $group = RT::Group->new( RT->SystemUser );
 736         my ( $val, $msg ) = $group->_Create(
 737             Type        => $name,
 738             Domain      => 'RT::System-Role',
 739             Description => 'SystemRolegroup for internal use',  # loc
 740             Name        => '',
 741             Instance    => '',
 742         );
 743         return ($val, $msg) unless $val;
 744     }
 745
 746     push @warns, "You appear to have a functional RT database."
 747         if @warns;
 748
 749     return (1, join "\n", @warns);
 750 }
 751
 752 =head2 InsertData
 753
 754 Load some sort of data into the database, takes path to a file.
 755
 756 =cut
 757
 758 sub InsertData {
 759     my $self     = shift;
 760     my $datafile = shift;
 761     my $root_password = shift;
 762     my %args     = (
 763         disconnect_after => 1,
 764         @_
 765     );
 766
 767     # Slurp in stuff to insert from the datafile. Possible things to go in here:-
 768     our (@Groups, @Users, @ACL, @Queues, @ScripActions, @ScripConditions,
 769            @Templates, @CustomFields, @Scrips, @Attributes, @Initial, @Final);
 770     local (@Groups, @Users, @ACL, @Queues, @ScripActions, @ScripConditions,
 771            @Templates, @CustomFields, @Scrips, @Attributes, @Initial, @Final);
 772
 773     local $@;
 774     $RT::Logger->debug("Going to load '$datafile' data file");
 775     eval { require $datafile }
 776       or return (0, "Couldn't load data from '$datafile' for import:\n\nERROR:". $@);
 777
 778     if ( @Initial ) {
 779         $RT::Logger->debug("Running initial actions...");
 780         foreach ( @Initial ) {
 781             local $@;
 782             eval { $_->(); 1 } or return (0, "One of initial functions failed: $@");
 783         }
 784         $RT::Logger->debug("Done.");
 785     }
 786     if ( @Groups ) {
 787         $RT::Logger->debug("Creating groups...");
 788         foreach my $item (@Groups) {
 789             my $new_entry = RT::Group->new( RT->SystemUser );
 790             my $member_of = delete $item->{'MemberOf'};
 791             my ( $return, $msg ) = $new_entry->_Create(%$item);
 792             unless ( $return ) {
 793                 $RT::Logger->error( $msg );
 794                 next;
 795             } else {
 796                 $RT::Logger->debug($return .".");
 797             }
 798             if ( $member_of ) {
 799                 $member_of = [ $member_of ] unless ref $member_of eq 'ARRAY';
 800                 foreach( @$member_of ) {
 801                     my $parent = RT::Group->new(RT->SystemUser);
 802                     if ( ref $_ eq 'HASH' ) {
 803                         $parent->LoadByCols( %$_ );
 804                     }
 805                     elsif ( !ref $_ ) {
 806                         $parent->LoadUserDefinedGroup( $_ );
 807                     }
 808                     else {
 809                         $RT::Logger->error(
 810                             "(Error: wrong format of MemberOf field."
 811                             ." Should be name of user defined group or"
 812                             ." hash reference with 'column => value' pairs."
 813                             ." Use array reference to add to multiple groups)"
 814                         );
 815                         next;
 816                     }
 817                     unless ( $parent->Id ) {
 818                         $RT::Logger->error("(Error: couldn't load group to add member)");
 819                         next;
 820                     }
 821                     my ( $return, $msg ) = $parent->AddMember( $new_entry->Id );
 822                     unless ( $return ) {
 823                         $RT::Logger->error( $msg );
 824                     } else {
 825                         $RT::Logger->debug( $return ."." );
 826                     }
 827                 }
 828             }
 829         }
 830         $RT::Logger->debug("done.");
 831     }
 832     if ( @Users ) {
 833         $RT::Logger->debug("Creating users...");
 834         foreach my $item (@Users) {
 835             if ( $item->{'Name'} eq 'root' && $root_password ) {
 836                 $item->{'Password'} = $root_password;
 837             }
 838             my $new_entry = RT::User->new( RT->SystemUser );
 839             my ( $return, $msg ) = $new_entry->Create(%$item);
 840             unless ( $return ) {
 841                 $RT::Logger->error( $msg );
 842             } else {
 843                 $RT::Logger->debug( $return ."." );
 844             }
 845         }
 846         $RT::Logger->debug("done.");
 847     }
 848     if ( @Queues ) {
 849         $RT::Logger->debug("Creating queues...");
 850         for my $item (@Queues) {
 851             my $new_entry = RT::Queue->new(RT->SystemUser);
 852             my ( $return, $msg ) = $new_entry->Create(%$item);
 853             unless ( $return ) {
 854                 $RT::Logger->error( $msg );
 855             } else {
 856                 $RT::Logger->debug( $return ."." );
 857             }
 858         }
 859         $RT::Logger->debug("done.");
 860     }
 861     if ( @CustomFields ) {
 862         $RT::Logger->debug("Creating custom fields...");
 863         for my $item ( @CustomFields ) {
 864             my $new_entry = RT::CustomField->new( RT->SystemUser );
 865             my $values    = delete $item->{'Values'};
 866
 867             my @queues;
 868             # if ref then it's list of queues, so we do things ourself
 869             if ( exists $item->{'Queue'} && ref $item->{'Queue'} ) {
 870                 $item->{'LookupType'} ||= 'RT::Queue-RT::Ticket';
 871                 @queues = @{ delete $item->{'Queue'} };
 872             }
 873
 874             if ( $item->{'BasedOn'} ) {
 875                 if ( $item->{'LookupType'} ) {
 876                     my $basedon = RT::CustomField->new($RT::SystemUser);
 877                     my ($ok, $msg ) = $basedon->LoadByCols( Name => $item->{'BasedOn'},
 878                                                             LookupType => $item->{'LookupType'} );
 879                     if ($ok) {
 880                         $item->{'BasedOn'} = $basedon->Id;
 881                     } else {
 882                         $RT::Logger->error("Unable to load $item->{BasedOn} as a $item->{LookupType} CF.  Skipping BasedOn: $msg");
 883                         delete $item->{'BasedOn'};
 884                     }
 885                 } else {
 886                     $RT::Logger->error("Unable to load CF $item->{BasedOn} because no LookupType was specified.  Skipping BasedOn");
 887                     delete $item->{'BasedOn'};
 888                 }
 889
 890             }
 891
 892             my ( $return, $msg ) = $new_entry->Create(%$item);
 893             unless( $return ) {
 894                 $RT::Logger->error( $msg );
 895                 next;
 896             }
 897
 898             foreach my $value ( @{$values} ) {
 899                 my ( $return, $msg ) = $new_entry->AddValue(%$value);
 900                 $RT::Logger->error( $msg ) unless $return;
 901             }
 902
 903             # apply by default
 904             if ( !@queues && !exists $item->{'Queue'} && $item->{LookupType} ) {
 905                 my $ocf = RT::ObjectCustomField->new(RT->SystemUser);
 906                 $ocf->Create( CustomField => $new_entry->Id );
 907             }
 908
 909             for my $q (@queues) {
 910                 my $q_obj = RT::Queue->new(RT->SystemUser);
 911                 $q_obj->Load($q);
 912                 unless ( $q_obj->Id ) {
 913                     $RT::Logger->error("Could not find queue ". $q );
 914                     next;
 915                 }
 916                 my $OCF = RT::ObjectCustomField->new(RT->SystemUser);
 917                 ( $return, $msg ) = $OCF->Create(
 918                     CustomField => $new_entry->Id,
 919                     ObjectId    => $q_obj->Id,
 920                 );
 921                 $RT::Logger->error( $msg ) unless $return and $OCF->Id;
 922             }
 923         }
 924
 925         $RT::Logger->debug("done.");
 926     }
 927     if ( @ACL ) {
 928         $RT::Logger->debug("Creating ACL...");
 929         for my $item (@ACL) {
 930
 931             my ($princ, $object);
 932
 933             # Global rights or Queue rights?
 934             if ( $item->{'CF'} ) {
 935                 $object = RT::CustomField->new( RT->SystemUser );
 936                 my @columns = ( Name => $item->{'CF'} );
 937                 push @columns, Queue => $item->{'Queue'} if $item->{'Queue'} and not ref $item->{'Queue'};
 938                 $object->LoadByName( @columns );
 939             } elsif ( $item->{'Queue'} ) {
 940                 $object = RT::Queue->new(RT->SystemUser);
 941                 $object->Load( $item->{'Queue'} );
 942             } else {
 943                 $object = $RT::System;
 944             }
 945
 946             $RT::Logger->error("Couldn't load object") and next unless $object and $object->Id;
 947
 948             # Group rights or user rights?
 949             if ( $item->{'GroupDomain'} ) {
 950                 $princ = RT::Group->new(RT->SystemUser);
 951                 if ( $item->{'GroupDomain'} eq 'UserDefined' ) {
 952                   $princ->LoadUserDefinedGroup( $item->{'GroupId'} );
 953                 } elsif ( $item->{'GroupDomain'} eq 'SystemInternal' ) {
 954                   $princ->LoadSystemInternalGroup( $item->{'GroupType'} );
 955                 } elsif ( $item->{'GroupDomain'} eq 'RT::System-Role' ) {
 956                   $princ->LoadSystemRoleGroup( $item->{'GroupType'} );
 957                 } elsif ( $item->{'GroupDomain'} eq 'RT::Queue-Role' &&
 958                           $item->{'Queue'} )
 959                 {
 960                   $princ->LoadQueueRoleGroup( Type => $item->{'GroupType'},
 961                                               Queue => $object->id);
 962                 } else {
 963                   $princ->Load( $item->{'GroupId'} );
 964                 }
 965                 unless ( $princ->Id ) {
 966                     RT->Logger->error("Unable to load Group: GroupDomain => $item->{GroupDomain}, GroupId => $item->{GroupId}, Queue => $item->{Queue}");
 967                     next;
 968                 }
 969             } else {
 970                 $princ = RT::User->new(RT->SystemUser);
 971                 my ($ok, $msg) = $princ->Load( $item->{'UserId'} );
 972                 unless ( $ok ) {
 973                     RT->Logger->error("Unable to load user: $item->{UserId} : $msg");
 974                     next;
 975                 }
 976             }
 977
 978             # Grant it
 979             my ( $return, $msg ) = $princ->PrincipalObj->GrantRight(
 980                 Right => $item->{'Right'},
 981                 Object => $object
 982             );
 983             unless ( $return ) {
 984                 $RT::Logger->error( $msg );
 985             }
 986             else {
 987                 $RT::Logger->debug( $return ."." );
 988             }
 989         }
 990         $RT::Logger->debug("done.");
 991     }
 992
 993     if ( @ScripActions ) {
 994         $RT::Logger->debug("Creating ScripActions...");
 995
 996         for my $item (@ScripActions) {
 997             my $new_entry = RT::ScripAction->new(RT->SystemUser);
 998             my ( $return, $msg ) = $new_entry->Create(%$item);
 999             unless ( $return ) {
1000                 $RT::Logger->error( $msg );
1001             }
1002             else {
1003                 $RT::Logger->debug( $return ."." );
1004             }
1005         }
1006
1007         $RT::Logger->debug("done.");
1008     }
1009
1010     if ( @ScripConditions ) {
1011         $RT::Logger->debug("Creating ScripConditions...");
1012
1013         for my $item (@ScripConditions) {
1014             my $new_entry = RT::ScripCondition->new(RT->SystemUser);
1015             my ( $return, $msg ) = $new_entry->Create(%$item);
1016             unless ( $return ) {
1017                 $RT::Logger->error( $msg );
1018             }
1019             else {
1020                 $RT::Logger->debug( $return ."." );
1021             }
1022         }
1023
1024         $RT::Logger->debug("done.");
1025     }
1026
1027     if ( @Templates ) {
1028         $RT::Logger->debug("Creating templates...");
1029
1030         for my $item (@Templates) {
1031             my $new_entry = RT::Template->new(RT->SystemUser);
1032             my ( $return, $msg ) = $new_entry->Create(%$item);
1033             unless ( $return ) {
1034                 $RT::Logger->error( $msg );
1035             }
1036             else {
1037                 $RT::Logger->debug( $return ."." );
1038             }
1039         }
1040         $RT::Logger->debug("done.");
1041     }
1042     if ( @Scrips ) {
1043         $RT::Logger->debug("Creating scrips...");
1044
1045         for my $item (@Scrips) {
1046             my $new_entry = RT::Scrip->new(RT->SystemUser);
1047
1048             my @queues = ref $item->{'Queue'} eq 'ARRAY'? @{ $item->{'Queue'} }: $item->{'Queue'} || 0;
1049             push @queues, 0 unless @queues; # add global queue at least
1050
1051             foreach my $q ( @queues ) {
1052                 my ( $return, $msg ) = $new_entry->Create( %$item, Queue => $q );
1053                 unless ( $return ) {
1054                     $RT::Logger->error( $msg );
1055                 }
1056                 else {
1057                     $RT::Logger->debug( $return ."." );
1058                 }
1059             }
1060         }
1061         $RT::Logger->debug("done.");
1062     }
1063     if ( @Attributes ) {
1064         $RT::Logger->debug("Creating attributes...");
1065         my $sys = RT::System->new(RT->SystemUser);
1066
1067         for my $item (@Attributes) {
1068             my $obj = delete $item->{Object}; # XXX: make this something loadable
1069             $obj ||= $sys;
1070             my ( $return, $msg ) = $obj->AddAttribute (%$item);
1071             unless ( $return ) {
1072                 $RT::Logger->error( $msg );
1073             }
1074             else {
1075                 $RT::Logger->debug( $return ."." );
1076             }
1077         }
1078         $RT::Logger->debug("done.");
1079     }
1080     if ( @Final ) {
1081         $RT::Logger->debug("Running final actions...");
1082         for ( @Final ) {
1083             local $@;
1084             eval { $_->(); };
1085             $RT::Logger->error( "Failed to run one of final actions: $@" )
1086                 if $@;
1087         }
1088         $RT::Logger->debug("done.");
1089     }
1090
1091     # XXX: This disconnect doesn't really belong here; it's a relict from when
1092     # this method was extracted from rt-setup-database.  However, too much
1093     # depends on it to change without significant testing.  At the very least,
1094     # we can provide a way to skip the side-effect.
1095     if ( $args{disconnect_after} ) {
1096         my $db_type = RT->Config->Get('DatabaseType');
1097         $RT::Handle->Disconnect() unless $db_type eq 'SQLite';
1098     }
1099
1100     $RT::Logger->debug("Done setting up database content.");
1101
1102 # TODO is it ok to return 1 here? If so, the previous codes in this sub
1103 # should return (0, $msg) if error happens instead of just warning.
1104 # anyway, we need to return something here to tell if everything is ok
1105     return( 1, 'Done inserting data' );
1106 }
1107
1108 =head2 ACLEquivGroupId
1109
1110 Given a userid, return that user's acl equivalence group
1111
1112 =cut
1113
1114 sub ACLEquivGroupId {
1115     my $id = shift;
1116
1117     my $cu = RT->SystemUser;
1118     unless ( $cu ) {
1119         require RT::CurrentUser;
1120         $cu = RT::CurrentUser->new;
1121         $cu->LoadByName('RT_System');
1122         warn "Couldn't load RT_System user" unless $cu->id;
1123     }
1124
1125     my $equiv_group = RT::Group->new( $cu );
1126     $equiv_group->LoadACLEquivalenceGroup( $id );
1127     return $equiv_group->Id;
1128 }
1129
1130 =head2 QueryHistory
1131
1132 Returns the SQL query history associated with this handle. The top level array
1133 represents a lists of request. Each request is a hash with metadata about the
1134 request (such as the URL) and a list of queries. You'll probably not be using this.
1135
1136 =cut
1137
1138 sub QueryHistory {
1139     my $self = shift;
1140
1141     return $self->{QueryHistory};
1142 }
1143
1144 =head2 AddRequestToHistory
1145
1146 Adds a web request to the query history. It must be a hash with keys Path (a
1147 string) and Queries (an array reference of arrays, where elements are time,
1148 sql, bind parameters, and duration).
1149
1150 =cut
1151
1152 sub AddRequestToHistory {
1153     my $self    = shift;
1154     my $request = shift;
1155
1156     push @{ $self->{QueryHistory} }, $request;
1157 }
1158
1159 =head2 Quote
1160
1161 Returns the parameter quoted by DBI. B<You almost certainly do not need this.>
1162 Use bind parameters (C<?>) instead. This is used only outside the scope of interacting
1163 with the database.
1164
1165 =cut
1166
1167 sub Quote {
1168     my $self = shift;
1169     my $value = shift;
1170
1171     return $self->dbh->quote($value);
1172 }
1173
1174 =head2 FillIn
1175
1176 Takes a SQL query and an array reference of bind parameters and fills in the
1177 query's C<?> parameters.
1178
1179 =cut
1180
1181 sub FillIn {
1182     my $self = shift;
1183     my $sql  = shift;
1184     my $bind = shift;
1185
1186     my $b = 0;
1187
1188     # is this regex sufficient?
1189     $sql =~ s{\?}{$self->Quote($bind->[$b++])}eg;
1190
1191     return $sql;
1192 }
1193
1194 # log a mason stack trace instead of a Carp::longmess because it's less painful
1195 # and uses mason component paths properly
1196 sub _LogSQLStatement {
1197     my $self = shift;
1198     my $statement = shift;
1199     my $duration = shift;
1200     my @bind = @_;
1201
1202     require HTML::Mason::Exceptions;
1203     push @{$self->{'StatementLog'}} , ([Time::HiRes::time(), $statement, [@bind], $duration, HTML::Mason::Exception->new->as_string]);
1204 }
1205
1206 __PACKAGE__->FinalizeDatabaseType;
1207
1208 RT::Base->_ImportOverlays();
1209
1210 1;