sbin/rt-setup-database

   1 #!/usr/bin/perl
   2 # BEGIN BPS TAGGED BLOCK {{{
   3 #
   4 # COPYRIGHT:
   5 #
   6 # This software is Copyright (c) 1996-2014 Best Practical Solutions, LLC
   7 #                                          <sales@bestpractical.com>
   8 #
   9 # (Except where explicitly superseded by other copyright notices)
  10 #
  11 #
  12 # LICENSE:
  13 #
  14 # This work is made available to you under the terms of Version 2 of
  15 # the GNU General Public License. A copy of that license should have
  16 # been provided with this software, but in any event can be snarfed
  17 # from www.gnu.org.
  18 #
  19 # This work is distributed in the hope that it will be useful, but
  20 # WITHOUT ANY WARRANTY; without even the implied warranty of
  21 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22 # General Public License for more details.
  23 #
  24 # You should have received a copy of the GNU General Public License
  25 # along with this program; if not, write to the Free Software
  26 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  27 # 02110-1301 or visit their web page on the internet at
  28 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
  29 #
  30 #
  31 # CONTRIBUTION SUBMISSION POLICY:
  32 #
  33 # (The following paragraph is not intended to limit the rights granted
  34 # to you to modify and distribute this software under the terms of
  35 # the GNU General Public License and is only of importance to you if
  36 # you choose to contribute your changes and enhancements to the
  37 # community by submitting them to Best Practical Solutions, LLC.)
  38 #
  39 # By intentionally submitting any modifications, corrections or
  40 # derivatives to this work, or any other work intended for use with
  41 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
  42 # you are the copyright holder for those contributions and you grant
  43 # Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
  44 # royalty-free, perpetual, license to use, copy, create derivative
  45 # works based on those contributions, and sublicense and distribute
  46 # those contributions and any derivatives thereof.
  47 #
  48 # END BPS TAGGED BLOCK }}}
  49 use strict;
  50 use warnings;
  51
  52 use vars qw($Nobody $SystemUser $item);
  53
  54 # fix lib paths, some may be relative
  55 BEGIN { # BEGIN RT CMD BOILERPLATE
  56     require File::Spec;
  57     require Cwd;
  58     my @libs = ("lib", "local/lib");
  59     my $bin_path;
  60
  61     for my $lib (@libs) {
  62         unless ( File::Spec->file_name_is_absolute($lib) ) {
  63             $bin_path ||= ( File::Spec->splitpath(Cwd::abs_path(__FILE__)) )[1];
  64             $lib = File::Spec->catfile( $bin_path, File::Spec->updir, $lib );
  65         }
  66         unshift @INC, $lib;
  67     }
  68
  69 }
  70
  71 use Term::ReadKey;
  72 use Getopt::Long;
  73 use Data::GUID;
  74
  75 $| = 1; # unbuffer all output.
  76
  77 my %args = (
  78     package => 'RT',
  79 );
  80 GetOptions(
  81     \%args,
  82     'action=s',
  83     'force', 'debug',
  84     'dba=s', 'dba-password=s', 'prompt-for-dba-password', 'package=s',
  85     'datafile=s', 'datadir=s', 'skip-create', 'root-password-file=s',
  86     'package=s', 'ext-version=s',
  87     'upgrade-from=s', 'upgrade-to=s',
  88     'help|h',
  89 );
  90
  91 no warnings 'once';
  92 if ( $args{help} || ! $args{'action'} ) {
  93     require Pod::Usage;
  94     Pod::Usage::pod2usage({ verbose => 2 });
  95     exit;
  96 }
  97
  98 require RT;
  99 RT->LoadConfig();
 100 RT->InitClasses();
 101
 102 # Force warnings to be output to STDERR if we're not already logging
 103 # them at a higher level
 104 RT->Config->Set( LogToSTDERR => 'warning')
 105     unless ( RT->Config->Get( 'LogToSTDERR' )
 106              && RT->Config->Get( 'LogToSTDERR' ) =~ /^(debug|info|notice)$/ );
 107 RT::InitLogging();
 108
 109 # get customized root password
 110 my $root_password;
 111 if ( $args{'root-password-file'} ) {
 112     open( my $fh, '<', $args{'root-password-file'} )
 113       or die "Couldn't open 'args{'root-password-file'}' for reading: $!";
 114     $root_password = <$fh>;
 115     chomp $root_password;
 116     my $min_length = RT->Config->Get('MinimumPasswordLength');
 117     if ($min_length) {
 118         die
 119 "password needs to be at least $min_length long, please check file '$args{'root-password-file'}'"
 120           if length $root_password < $min_length;
 121     }
 122     close $fh;
 123 }
 124
 125
 126 # check and setup @actions
 127 my @actions = grep $_, split /,/, $args{'action'};
 128 if ( @actions > 1 && $args{'datafile'} ) {
 129     print STDERR "You can not use --datafile option with multiple actions.\n";
 130     exit(-1);
 131 }
 132 foreach ( @actions ) {
 133     unless ( /^(?:init|create|drop|schema|acl|indexes|coredata|insert|upgrade)$/ ) {
 134         print STDERR "$0 called with an invalid --action parameter.\n";
 135         exit(-1);
 136     }
 137     if ( /^(?:init|drop|upgrade)$/ && @actions > 1 ) {
 138         print STDERR "You can not mix init, drop or upgrade action with any action.\n";
 139         exit(-1);
 140     }
 141 }
 142
 143 # convert init to multiple actions
 144 my $init = 0;
 145 if ( $actions[0] eq 'init' ) {
 146     if ($args{'skip-create'}) {
 147         @actions = qw(schema coredata insert);
 148     } else {
 149         @actions = qw(create schema acl coredata insert);
 150     }
 151     $init = 1;
 152 }
 153
 154 # set options from environment
 155 foreach my $key(qw(Type Host Name User Password)) {
 156     next unless exists $ENV{ 'RT_DB_'. uc $key };
 157     print "Using Database$key from RT_DB_". uc($key) ." environment variable.\n";
 158     RT->Config->Set( "Database$key", $ENV{ 'RT_DB_'. uc $key });
 159 }
 160
 161 my $db_type = RT->Config->Get('DatabaseType') || '';
 162 my $db_host = RT->Config->Get('DatabaseHost') || '';
 163 my $db_port = RT->Config->Get('DatabasePort') || '';
 164 my $db_name = RT->Config->Get('DatabaseName') || '';
 165 my $db_user = RT->Config->Get('DatabaseUser') || '';
 166 my $db_pass = RT->Config->Get('DatabasePassword') || '';
 167
 168 # load it here to get error immidiatly if DB type is not supported
 169 require RT::Handle;
 170
 171 if ( $db_type eq 'SQLite' && !File::Spec->file_name_is_absolute($db_name) ) {
 172     $db_name = File::Spec->catfile($RT::VarPath, $db_name);
 173     RT->Config->Set( DatabaseName => $db_name );
 174 }
 175
 176 my $dba_user = $args{'dba'} || $ENV{'RT_DBA_USER'} || RT->Config->Get('DatabaseAdmin') || '';
 177 my $dba_pass = $args{'dba-password'} || $ENV{'RT_DBA_PASSWORD'};
 178
 179 if ($args{'skip-create'}) {
 180     $dba_user = $db_user;
 181     $dba_pass = $db_pass;
 182 } else {
 183     if ( !$args{force} && ( !defined $dba_pass || $args{'prompt-for-dba-password'} ) ) {
 184         $dba_pass = get_dba_password();
 185         chomp $dba_pass if defined($dba_pass);
 186     }
 187 }
 188
 189 my $version_word_regex = join '|', RT::Handle->version_words;
 190 my $version_dir = qr/^\d+\.\d+\.\d+(?:$version_word_regex)?\d*$/;
 191
 192 print "Working with:\n"
 193     ."Type:\t$db_type\nHost:\t$db_host\nPort:\t$db_port\nName:\t$db_name\n"
 194     ."User:\t$db_user\nDBA:\t$dba_user" . ($args{'skip-create'} ? ' (No DBA)' : '') . "\n";
 195
 196 my $package = $args{'package'} || 'RT';
 197 my $ext_version = $args{'ext-version'};
 198 my $full_id = Data::GUID->new->as_string;
 199
 200 my $log_actions = 0;
 201 if ($args{'package'} ne 'RT') {
 202     RT->ConnectToDatabase();
 203     RT->InitSystemObjects();
 204     $log_actions = 1;
 205 }
 206
 207 foreach my $action ( @actions ) {
 208     no strict 'refs';
 209     my ($status, $msg) = *{ 'action_'. $action }{'CODE'}->( %args );
 210     error($action, $msg) unless $status;
 211     print $msg .".\n" if $msg;
 212     print "Done.\n";
 213 }
 214
 215 sub action_create {
 216     my %args = @_;
 217     my $dbh = get_system_dbh();
 218     my ($status, $msg) = RT::Handle->CheckCompatibility( $dbh, 'create' );
 219     return ($status, $msg) unless $status;
 220
 221     print "Now creating a $db_type database $db_name for RT.\n";
 222     return RT::Handle->CreateDatabase( $dbh );
 223 }
 224
 225 sub action_drop {
 226     my %args = @_;
 227
 228     print "Dropping $db_type database $db_name.\n";
 229     unless ( $args{'force'} ) {
 230         print <<END;
 231
 232 About to drop $db_type database $db_name on $db_host (port '$db_port').
 233 WARNING: This will erase all data in $db_name.
 234
 235 END
 236         exit(-2) unless _yesno();
 237     }
 238
 239     my $dbh = get_system_dbh();
 240     return RT::Handle->DropDatabase( $dbh );
 241 }
 242
 243 sub action_schema {
 244     my %args = @_;
 245     my $dbh = get_admin_dbh();
 246     my ($status, $msg) = RT::Handle->CheckCompatibility( $dbh, 'schema' );
 247     return ($status, $msg) unless $status;
 248
 249     my $individual_id = Data::GUID->new->as_string();
 250     my %upgrade_data = (
 251         action   => 'schema',
 252         filename => Cwd::abs_path($args{'datafile'} || $args{'datadir'} || ''),
 253         stage    => 'before',
 254         full_id  => $full_id,
 255         individual_id => $individual_id,
 256     );
 257     $upgrade_data{'ext_version'} = $ext_version if $ext_version;
 258     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 259
 260     print "Now populating database schema.\n";
 261     my @ret = RT::Handle->InsertSchema( $dbh, $args{'datafile'} || $args{'datadir'} );
 262
 263     %upgrade_data = (
 264         stage         => 'after',
 265         individual_id => $individual_id,
 266         return_value  => [ @ret ],
 267     );
 268     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 269
 270     return @ret;
 271 }
 272
 273 sub action_acl {
 274     my %args = @_;
 275     my $dbh = get_admin_dbh();
 276     my ($status, $msg) = RT::Handle->CheckCompatibility( $dbh, 'acl' );
 277     return ($status, $msg) unless $status;
 278
 279     my $individual_id = Data::GUID->new->as_string();
 280     my %upgrade_data = (
 281         action   => 'acl',
 282         filename => Cwd::abs_path($args{'datafile'} || $args{'datadir'} || ''),
 283         stage    => 'before',
 284         full_id  => $full_id,
 285         individual_id => $individual_id,
 286     );
 287     $upgrade_data{'ext_version'} = $ext_version if $ext_version;
 288     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 289
 290     print "Now inserting database ACLs.\n";
 291     my @ret = RT::Handle->InsertACL( $dbh, $args{'datafile'} || $args{'datadir'} );
 292
 293     %upgrade_data = (
 294         stage         => 'after',
 295         individual_id => $individual_id,
 296         return_value  => [ @ret ],
 297     );
 298     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 299
 300     return @ret;
 301 }
 302
 303 sub action_indexes {
 304     my %args = @_;
 305     RT->ConnectToDatabase;
 306     my $individual_id = Data::GUID->new->as_string();
 307     my %upgrade_data = (
 308         action   => 'indexes',
 309         filename => Cwd::abs_path($args{'datafile'} || $args{'datadir'} || ''),
 310         stage    => 'before',
 311         full_id  => $full_id,
 312         individual_id => $individual_id,
 313     );
 314     $upgrade_data{'ext_version'} = $ext_version if $ext_version;
 315     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 316
 317     my $dbh = get_admin_dbh();
 318     $RT::Handle = RT::Handle->new;
 319     $RT::Handle->dbh( $dbh );
 320     RT::InitLogging();
 321
 322     print "Now inserting database indexes.\n";
 323     my @ret = RT::Handle->InsertIndexes( $dbh, $args{'datafile'} || $args{'datadir'} );
 324
 325     $RT::Handle = RT::Handle->new;
 326     $RT::Handle->dbh( undef );
 327     RT->ConnectToDatabase;
 328     %upgrade_data = (
 329         stage         => 'after',
 330         individual_id => $individual_id,
 331         return_value  => [ @ret ],
 332     );
 333     RT->System->AddUpgradeHistory($package => \%upgrade_data) if $log_actions;
 334
 335     return @ret;
 336 }
 337
 338 sub action_coredata {
 339     my %args = @_;
 340     $RT::Handle = RT::Handle->new;
 341     $RT::Handle->dbh( undef );
 342     RT::ConnectToDatabase();
 343     my ($status, $msg) = RT::Handle->CheckCompatibility( $RT::Handle->dbh, 'coredata' );
 344     return ($status, $msg) unless $status;
 345
 346     print "Now inserting RT core system objects.\n";
 347     return $RT::Handle->InsertInitialData;
 348 }
 349
 350 sub action_insert {
 351     my %args = @_;
 352     $RT::Handle = RT::Handle->new;
 353     RT::Init();
 354     $log_actions = 1;
 355
 356     my ($status, $msg) = RT::Handle->CheckCompatibility( $RT::Handle->dbh, 'insert' );
 357     return ($status, $msg) unless $status;
 358
 359     print "Now inserting data.\n";
 360     my $file = $args{'datafile'};
 361     $file = $RT::EtcPath . "/initialdata" if $init && !$file;
 362     $file ||= $args{'datadir'}."/content";
 363
 364     my $individual_id = Data::GUID->new->as_string();
 365     my %upgrade_data = (
 366         action   => 'insert',
 367         filename => Cwd::abs_path($file),
 368         stage    => 'before',
 369         full_id  => $full_id,
 370         individual_id => $individual_id
 371     );
 372     $upgrade_data{'ext_version'} = $ext_version if $ext_version;
 373
 374     open my $handle, '<', $file or warn "Unable to open $file: $!";
 375     $upgrade_data{content} = do {local $/; <$handle>} if $handle;
 376
 377     RT->System->AddUpgradeHistory($package => \%upgrade_data);
 378
 379     my @ret;
 380
 381     my $upgrade = sub { @ret = $RT::Handle->InsertData( $file, $root_password ) };
 382
 383     for my $file (@{$args{backcompat} || []}) {
 384         my $lines = do {local $/; local @ARGV = ($file); <>};
 385         my $sub = eval "sub {\n# line 1 $file\n$lines\n}";
 386         unless ($sub) {
 387             warn "Failed to load backcompat $file: $@";
 388             next;
 389         }
 390         my $current = $upgrade;
 391         $upgrade = sub { $sub->($current) };
 392     }
 393
 394     $upgrade->();
 395
 396     # XXX Reconnecting to insert the history entry
 397     # until we can sort out removing
 398     # the disconnect at the end of InsertData.
 399     RT->ConnectToDatabase();
 400
 401     %upgrade_data = (
 402         stage         => 'after',
 403         individual_id => $individual_id,
 404         return_value  => [ @ret ],
 405     );
 406
 407     RT->System->AddUpgradeHistory($package => \%upgrade_data);
 408
 409     my $db_type = RT->Config->Get('DatabaseType');
 410     $RT::Handle->Disconnect() unless $db_type eq 'SQLite';
 411
 412     return @ret;
 413 }
 414
 415 sub action_upgrade {
 416     my %args = @_;
 417     my $base_dir = $args{'datadir'} || "./etc/upgrade";
 418     return (0, "Couldn't read dir '$base_dir' with upgrade data")
 419         unless -d $base_dir || -r _;
 420
 421     my $upgrading_from = undef;
 422     do {
 423         if ( defined $upgrading_from ) {
 424             print "Doesn't match #.#.#: ";
 425         } else {
 426             print "Enter $args{package} version you're upgrading from: ";
 427         }
 428         $upgrading_from = $args{'upgrade-from'} || scalar <STDIN>;
 429         chomp $upgrading_from;
 430         $upgrading_from =~ s/\s+//g;
 431     } while $upgrading_from !~ /$version_dir/;
 432
 433     my $upgrading_to = $RT::VERSION;
 434     return (0, "The current version $upgrading_to is lower than $upgrading_from")
 435         if RT::Handle::cmp_version( $upgrading_from, $upgrading_to ) > 0;
 436
 437     return (1, "The version $upgrading_to you're upgrading to is up to date")
 438         if RT::Handle::cmp_version( $upgrading_from, $upgrading_to ) == 0;
 439
 440     my @versions = get_versions_from_to($base_dir, $upgrading_from, undef);
 441     return (1, "No DB changes since $upgrading_from")
 442         unless @versions;
 443
 444     if (RT::Handle::cmp_version($versions[-1], $upgrading_to) > 0) {
 445         print "\n***** There are upgrades for $versions[-1], which is later than $upgrading_to,\n";
 446         print   "***** which you are nominally upgrading to.  Upgrading to $versions[-1] instead.\n";
 447         $upgrading_to = $versions[-1];
 448     }
 449
 450     print "\nGoing to apply following upgrades:\n";
 451     print map "* $_\n", @versions;
 452
 453     {
 454         my $custom_upgrading_to = undef;
 455         do {
 456             if ( defined $custom_upgrading_to ) {
 457                 print "Doesn't match #.#.#: ";
 458             } else {
 459                 print "\nEnter $args{package} version if you want to stop upgrade at some point,\n";
 460                 print "  or leave it blank if you want apply above upgrades: ";
 461             }
 462             $custom_upgrading_to = $args{'upgrade-to'} || scalar <STDIN>;
 463             chomp $custom_upgrading_to;
 464             $custom_upgrading_to =~ s/\s+//g;
 465             last unless $custom_upgrading_to;
 466         } while $custom_upgrading_to !~ /$version_dir/;
 467
 468         if ( $custom_upgrading_to ) {
 469             return (
 470                 0, "The version you entered ($custom_upgrading_to) is lower than\n"
 471                 ."version you're upgrading from ($upgrading_from)"
 472             ) if RT::Handle::cmp_version( $upgrading_from, $custom_upgrading_to ) > 0;
 473
 474             return (1, "The version you're upgrading to is up to date")
 475                 if RT::Handle::cmp_version( $upgrading_from, $custom_upgrading_to ) == 0;
 476
 477             if ( RT::Handle::cmp_version( $RT::VERSION, $custom_upgrading_to ) < 0 ) {
 478                 print "Version you entered is greater than installed ($RT::VERSION).\n";
 479                 _yesno() or exit(-2);
 480             }
 481             # ok, checked everything no let's refresh list
 482             $upgrading_to = $custom_upgrading_to;
 483             @versions = get_versions_from_to($base_dir, $upgrading_from, $upgrading_to);
 484
 485             return (1, "No DB changes between $upgrading_from and $upgrading_to")
 486                 unless @versions;
 487
 488             print "\nGoing to apply following upgrades:\n";
 489             print map "* $_\n", @versions;
 490         }
 491     }
 492
 493     unless ( $args{'force'} ) {
 494         print "\nIT'S VERY IMPORTANT TO BACK UP BEFORE THIS STEP\n\n";
 495         _yesno() or exit(-2);
 496     }
 497
 498     RT->ConnectToDatabase();
 499     RT->InitSystemObjects();
 500     $log_actions = 1;
 501
 502     RT->System->AddUpgradeHistory($package => {
 503         type      => 'full upgrade',
 504         action    => 'upgrade',
 505         stage     => 'before',
 506         from      => $upgrading_from,
 507         to        => $upgrading_to,
 508         versions  => [@versions],
 509         full_id => $full_id,
 510         individual_id => $full_id
 511     });
 512
 513     # Ensure that the Attributes column is big enough to hold the
 514     # upgrade steps we're going to add; this step exists in 4.0.6 for
 515     # mysql, but that may be too late.  Run it as soon as possible.
 516     if (RT->Config->Get('DatabaseType') eq 'mysql'
 517             and RT::Handle::cmp_version( $upgrading_from, '4.0.6') < 0) {
 518         my $dbh = get_admin_dbh();
 519         # Before the binary switch in 3.7.87, we want to alter text ->
 520         # longtext, not blob -> longblob
 521         if (RT::Handle::cmp_version( $upgrading_from, '3.7.87') < 0) {
 522             $dbh->do("ALTER TABLE Attributes MODIFY Content LONGTEXT")
 523         } else {
 524             $dbh->do("ALTER TABLE Attributes MODIFY Content LONGBLOB")
 525         }
 526     }
 527
 528     my $previous = $upgrading_from;
 529     my ( $ret, $msg );
 530     foreach my $n ( 0..$#versions ) {
 531         my $v = $versions[$n];
 532         my $individual_id = Data::GUID->new->as_string();
 533
 534         my @back = grep {-e $_} map {"$base_dir/$versions[$_]/backcompat"} $n+1..$#versions;
 535         print "Processing $v\n";
 536
 537         RT->System->AddUpgradeHistory($package => {
 538             action => 'upgrade',
 539             type   => 'individual upgrade',
 540             stage  => 'before',
 541             from   => $previous,
 542             to     => $v,
 543             full_id => $full_id,
 544             individual_id => $individual_id,
 545         });
 546
 547         my %tmp = (%args, datadir => "$base_dir/$v", datafile => undef, backcompat => \@back);
 548
 549         if ( -e "$base_dir/$v/schema.$db_type" ) {
 550             ( $ret, $msg ) = action_schema( %tmp );
 551             return ( $ret, $msg ) unless $ret;
 552         }
 553         if ( -e "$base_dir/$v/acl.$db_type" ) {
 554             ( $ret, $msg ) = action_acl( %tmp );
 555             return ( $ret, $msg ) unless $ret;
 556         }
 557         if ( -e "$base_dir/$v/indexes" ) {
 558             ( $ret, $msg ) = action_indexes( %tmp );
 559             return ( $ret, $msg ) unless $ret;
 560         }
 561         if ( -e "$base_dir/$v/content" ) {
 562             ( $ret, $msg ) = action_insert( %tmp );
 563             return ( $ret, $msg ) unless $ret;
 564         }
 565
 566         # XXX: Another connect since the insert called
 567         # previous to this step will disconnect.
 568
 569         RT->ConnectToDatabase();
 570
 571         RT->System->AddUpgradeHistory($package => {
 572             stage         => 'after',
 573             individual_id => $individual_id,
 574         });
 575
 576         $previous = $v;
 577     }
 578
 579     RT->System->AddUpgradeHistory($package => {
 580         stage         => 'after',
 581         individual_id => $full_id,
 582     });
 583
 584     return 1;
 585 }
 586
 587 sub get_versions_from_to {
 588     my ($base_dir, $from, $to) = @_;
 589
 590     opendir( my $dh, $base_dir ) or die "couldn't open dir: $!";
 591     my @versions = grep -d "$base_dir/$_" && /$version_dir/, readdir $dh;
 592     closedir $dh;
 593
 594     die "\nERROR: No upgrade data found in '$base_dir'!  Perhaps you specified the wrong --datadir?\n"
 595         unless @versions;
 596
 597     return
 598         grep defined $to ? RT::Handle::cmp_version($_, $to) <= 0 : 1,
 599         grep RT::Handle::cmp_version($_, $from) > 0,
 600         sort RT::Handle::cmp_version @versions;
 601 }
 602
 603 sub error {
 604     my ($action, $msg) = @_;
 605     print STDERR "Couldn't finish '$action' step.\n\n";
 606     print STDERR "ERROR: $msg\n\n";
 607     exit(-1);
 608 }
 609
 610 sub get_dba_password {
 611     print "In order to create or update your RT database,"
 612         . " this script needs to connect to your "
 613         . " $db_type instance on $db_host (port '$db_port') as $dba_user\n";
 614     print "Please specify that user's database password below. If the user has no database\n";
 615     print "password, just press return.\n\n";
 616     print "Password: ";
 617     ReadMode('noecho');
 618     my $password = ReadLine(0);
 619     ReadMode('normal');
 620     print "\n";
 621     return ($password);
 622 }
 623
 624 #   get_system_dbh
 625 #   Returns L<DBI> database handle connected to B<system> with DBA credentials.
 626 #   See also L<RT::Handle/SystemDSN>.
 627
 628
 629 sub get_system_dbh {
 630     return _get_dbh( RT::Handle->SystemDSN, $dba_user, $dba_pass );
 631 }
 632
 633 sub get_admin_dbh {
 634     return _get_dbh( RT::Handle->DSN, $dba_user, $dba_pass );
 635 }
 636
 637 # get_rt_dbh [USER, PASSWORD]
 638
 639 # Returns L<DBI> database handle connected to RT database,
 640 # you may specify credentials(USER and PASSWORD) to connect
 641 # with. By default connects with credentials from RT config.
 642
 643 sub get_rt_dbh {
 644     return _get_dbh( RT::Handle->DSN, $db_user, $db_pass );
 645 }
 646
 647 sub _get_dbh {
 648     my ($dsn, $user, $pass) = @_;
 649     my $dbh = DBI->connect(
 650         $dsn, $user, $pass,
 651         { RaiseError => 0, PrintError => 0 },
 652     );
 653     unless ( $dbh ) {
 654         my $msg = "Failed to connect to $dsn as user '$user': ". $DBI::errstr;
 655         if ( $args{'debug'} ) {
 656             require Carp; Carp::confess( $msg );
 657         } else {
 658             print STDERR $msg; exit -1;
 659         }
 660     }
 661     return $dbh;
 662 }
 663
 664 sub _yesno {
 665     print "Proceed [y/N]:";
 666     my $x = scalar(<STDIN>);
 667     $x =~ /^y/i;
 668 }
 669
 670 1;
 671
 672 __END__
 673
 674 =head1 NAME
 675
 676 rt-setup-database - Set up RT's database
 677
 678 =head1 SYNOPSIS
 679
 680     rt-setup-database --action ...
 681
 682 =head1 OPTIONS
 683
 684 =over
 685
 686 =item action
 687
 688 Several actions can be combined using comma separated list.
 689
 690 =over
 691
 692 =item init
 693
 694 Initialize the database. This is combination of multiple actions listed below.
 695 Create DB, schema, setup acl, insert core data and initial data.
 696
 697 =item upgrade
 698
 699 Apply all needed schema/acl/content updates (will ask for version to upgrade
 700 from)
 701
 702 =item create
 703
 704 Create the database.
 705
 706 =item drop
 707
 708 Drop the database.  This will B<ERASE ALL YOUR DATA>.
 709
 710 =item schema
 711
 712 Initialize only the database schema
 713
 714 To use a local or supplementary datafile, specify it using the '--datadir'
 715 option below.
 716
 717 =item acl
 718
 719 Initialize only the database ACLs
 720
 721 To use a local or supplementary datafile, specify it using the '--datadir'
 722 option below.
 723
 724 =item coredata
 725
 726 Insert data into RT's database. This data is required for normal functioning of
 727 any RT instance.
 728
 729 =item insert
 730
 731 Insert data into RT's database.  By default, will use RT's installation data.
 732 To use a local or supplementary datafile, specify it using the '--datafile'
 733 option below.
 734
 735 =back
 736
 737 =item datafile
 738
 739 file path of the data you want to action on
 740
 741 e.g. C<--datafile /path/to/datafile>
 742
 743 =item datadir
 744
 745 Used to specify a path to find the local database schema and acls to be
 746 installed.
 747
 748 e.g. C<--datadir /path/to/>
 749
 750 =item dba
 751
 752 dba's username
 753
 754 =item dba-password
 755
 756 dba's password
 757
 758 =item prompt-for-dba-password
 759
 760 Ask for the database administrator's password interactively
 761
 762 =item skip-create
 763
 764 for 'init': skip creating the database and the user account, so we don't need
 765 administrator privileges
 766
 767 =item root-password-file
 768
 769 for 'init' and 'insert': rather than using the default administrative password
 770 for RT's "root" user, use the password in this file.
 771
 772 =item package
 773
 774 the name of the entity performing a create or upgrade. Used for logging changes
 775 in the DB. Defaults to RT, otherwise it should be the fully qualified package name
 776 of the extension or plugin making changes to the DB.
 777
 778 =item ext-version
 779
 780 current version of extension making a change. Not needed for RT since RT has a
 781 more elaborate system to track upgrades across multiple versions.
 782
 783 =item upgrade-from
 784
 785 for 'upgrade': specifies the version to upgrade from, and do not prompt
 786 for it if it appears to be a valid version.
 787
 788 =item upgrade-to
 789
 790 for 'upgrade': specifies the version to upgrade to, and do not prompt
 791 for it if it appears to be a valid version.
 792
 793 =back
 794
 795 =cut