Revonzy Mini Shell

#!/usr/local/cpanel/3rdparty/bin/perl

# cpanel - scripts/backups_create_metadata         Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited

################################################################################

package scripts::backups_create_metadata;

use strict;
use warnings;

use Cpanel::Backup::Config         ();
use Cpanel::Backup::Metadata       ();
use Cpanel::Backup::StreamFileList ();
use Cpanel::Config::LoadCpConf     ();
use Cpanel::ConfigFiles            ();
use Cpanel::FileUtils::Path        ();
use Cpanel::IONice                 ();
use Cpanel::Logger                 ();
use Cpanel::OSSys                  ();
use Cpanel::OSSys::Capabilities    ();
use Cpanel::SafeRun::Simple        ();

use Getopt::Long ();
use File::Glob   ();
use File::Spec   ();

use Try::Tiny;

################################################################################

our $all;
our $backup;
our $user;
our $vacuum;
our $schedule_rebuild;
our $fix_corrupt;

our $logger;

sub _help {
    my ($msg) = @_;

    print qq{$msg

Usage:

--all - Create metadata for all backups in the configured directory.

e.g. $0 --all
This creates metadata for all backups and users.
If metadata exists, it will delete it and create new metadata.
You cannot combine --all with other options.

--vacuum - Defragment the database and release unused space, runs in the background

e.g. $0 --vacuum
This defragments the database and release unused space.
You cannot combine --vacuum with other options.

--backup=monthly/YYYY-MM-DD - Create metadata for all users in the backup directory that you specify.

e.g. $0 --backup=monthly/2017-03-01
This creates metadata for all users in this backup directory.
You can combine this option with the --user option.
e.g. $0 --backup=monthly/2017-03-01 --user=alvin
This creates metadata for this user in this backup directory.

--user=user - Create metadata only for this user.

e.g. $0 --user=alvin
This creates metadata only for this user.
You can combine this option with the --backup=monthly/YYYY-MM-DD option.
e.g. $0 --backup=monthly/2017-03-01 --user=alvin
This creates metadata for this user in this backup directory.

--schedule_rebuild - Rebuild all metadata in the background.

e.g. $0 --schedule_rebuild
This rebuilds all metadata. The script returns to the command line immediately and
continues to rebuild the metadata in a background task.
You can combine this option with the --fix_corrupt option.
e.g. $0 --schedule_rebuild --fix_corrupt
This scans all user metadata and rebuilds corrupt metadata. The script returns to
the command line immediately and continues to rebuild the metadata in a background
task.

--fix_corrupt - Scans all user metadata to identify and rebuild corrupt metadata.
e.g. $0 --fix_corrupt
This scans all user metadata and rebuilds corrupt metadata.
You can combine this option with the --schedule_rebuild option.
e.g. $0 --schedule_rebuild --fix_corrupt
This scans all user metadata and rebuilds corrupt metadata. The script returns to
the command line immediately and continues to rebuild the metadata in a background
task.
};

    exit 0;
}

sub _invalid_parms {
    _help("invalid parameters");
    die "Invalid Command Line Parameters\n";
}

sub _output {
    my ($line) = @_;

    print $line . "\n";

    return;
}

sub clean_old_metadata_files {
    my ($dir) = @_;

    opendir( my $accounts_dir, "$dir/accounts/" );
    foreach my $file ( readdir($accounts_dir) ) {
        if ( ( $file =~ m/\-\=\-meta/ || $file eq '.sql_dump.gz' ) && -f "$dir/accounts/$file" ) {
            print "Removing old metadata file $dir/accounts/$file\n";
            unlink("$dir/accounts/$file");
        }
    }
    closedir($accounts_dir);

    # Clean old version of single sqlitedb
    unlink '/var/cpanel/backups/metadata.sqlite';

    return;
}

sub create_master_meta {
    my ($dir) = @_;

    my $meta_master = $dir . "/accounts/.master.meta";
    if ( !-e $meta_master ) {
        my $ref = Cpanel::Backup::Metadata::introspect_old_backup($dir);
        if ( defined( $ref->{'backup'}->{'backup_type'} ) && $ref->{'backup'}->{'backup_type'} ne 'ERROR' ) {
            Cpanel::Backup::Metadata::create_meta_master_with_users_from_introspect( $dir, $ref );
        }
        else {
            return 0;    # ignore if the directory cannot be determined
        }
    }

    return 1;
}

# Set our "nice" level

sub apply_nice_level_to_process {
    my ($logger) = @_;
    my $cpconf_ref;
    ( %{$cpconf_ref} ) = Cpanel::Config::LoadCpConf::loadcpconf();

    Cpanel::OSSys::nice(18);    # needs to be one higher for cpuwatch
    my $CAPABILITIES = Cpanel::OSSys::Capabilities->load;
    if ( $CAPABILITIES->capable_of('ionice') ) {
        if ( Cpanel::IONice::ionice( 'best-effort', exists $cpconf_ref->{'ionice_cpbackup'} ? $cpconf_ref->{'ionice_cpbackup'} : 6 ) ) {
            $logger->info( "Setting I/O priority to reduce system load: " . Cpanel::IONice::get_ionice() );
        }
    }
    return;
}

sub _run_vacuum {
    require Cpanel::Daemonizer::Tiny;

    Cpanel::Daemonizer::Tiny::run_as_daemon(
        sub {
            require Cpanel::Logger;
            my $logger = Cpanel::Logger->new();
            sleep 15;
            Cpanel::Backup::Metadata::vacuum_metadata($logger);
        },
        ""
    );

    return;
}

sub _get_raw_backup_dirs {
    my ($backup_master_dir) = @_;

    # get all backup dirs under the main backup
    my %backup_dirs_hash;

    foreach my $dir (
        File::Glob::bsd_glob( $backup_master_dir . "/2*/accounts" ),
        File::Glob::bsd_glob( $backup_master_dir . "/monthly/2*/accounts" ),
        File::Glob::bsd_glob( $backup_master_dir . "/weekly/2*/accounts" ),
        File::Glob::bsd_glob( $backup_master_dir . "/incremental/accounts" )
    ) {
        next if ( !-d $dir );
        my ( $xdir, $accounts ) = Cpanel::FileUtils::Path::dir_and_file_from_path($dir);
        $backup_dirs_hash{$xdir} = 1;
    }

    return %backup_dirs_hash;
}

sub _get_all_backup_dirs {
    my ( $backup_master_dir, %backup_dirs_hash ) = @_;

    # sort this in a smart manner so it plays out like it would have had
    # bin/backup done it.

    my @order;
    foreach my $dir ( sort keys %backup_dirs_hash ) {
        my $introspect_ref;
        try {
            $introspect_ref = Cpanel::Backup::Metadata::introspect_old_backup($dir);
        };
        next if !$introspect_ref;                                        # if it dies this is not a valid backup dir, so just move on
        next if !exists $introspect_ref->{'backup'}->{'backup_id'};
        next if $introspect_ref->{'backup'}->{'backup_id'} eq 'ERROR';

        my @users = keys %{ $introspect_ref->{'users'} };
        next if !@users;
        my $user = $users[0];

        my $category_ref = Cpanel::Backup::StreamFileList::categorize_backup( $backup_master_dir, $dir, $user );

        my $sort_path = $category_ref->{'backupID'};
        if ( $sort_path =~ m{^(monthly|weekly)/(.*)$} ) {
            $sort_path = $2 . '/' . $1;
        }
        else {
            $sort_path .= '/a';    # for sorting consistency a is before (m)onthly
        }

        $category_ref->{'sort_path'} = $sort_path;
        push( @order, $category_ref );
    }

    my @dirs = map { $_->{'path'} } sort { $a->{'sort_path'} cmp $b->{'sort_path'} } @order;

    return @dirs;
}

sub fix_corrupt_metadata {
    my ( $backup_master_dir, @users ) = @_;

    # delete the users db's
    foreach my $user (@users) {
        my $user_db_path = Cpanel::Backup::Metadata::get_metadata_filename( $user, 0 );
        unlink $user_db_path if -f $user_db_path;
    }

    my @dirs = _get_all_backup_dirs( $backup_master_dir, _get_raw_backup_dirs($backup_master_dir) );
    foreach my $user (@users) {
        print "Fixing corrupt backup metadata for $user\n";
        foreach my $dir (@dirs) {
            Cpanel::Backup::Metadata::create_metadata_for_backup_user( $dir, $user, $logger );
        }
    }

    return;
}

sub script {    ##no critic qw(ProhibitExcessComplexity)
    my (@args) = @_;

    $ENV{'LANG'} = 'en_US.UTF-8';

    local $| = 1;
    $logger //= Cpanel::Logger->new( { 'alternate_logfile' => '/dev/stdout' } );

    apply_nice_level_to_process($logger);

    my $opts = Getopt::Long::GetOptionsFromArray(
        \@args,
        'all'              => \$all,
        'backup=s'         => \$backup,
        'user=s'           => \$user,
        'vacuum'           => \$vacuum,
        'schedule_rebuild' => \$schedule_rebuild,
        'fix_corrupt'      => \$fix_corrupt,
    ) or _invalid_parms();

    _help("You must provide at least one option to execute the script.") if ( !$all && !$backup && !$vacuum && !$schedule_rebuild && !$user && !$fix_corrupt );

    _help("You cannot combine --all with other options.") if ( $all && ( $backup || $user || $vacuum || $schedule_rebuild || $fix_corrupt ) );

    _help("You cannot combine --vacuum with other options.") if ( $vacuum && ( $all || $backup || $user || $schedule_rebuild || $fix_corrupt ) );

    _help("You can only combine this option with the --user option.")   if ( $backup && ( $all || $schedule_rebuild || $fix_corrupt || $vacuum ) );
    _help("You can only combine this option with the --backup option.") if ( $user   && ( $all || $schedule_rebuild || $fix_corrupt || $vacuum ) );

    _help("You can only combine this option with the --fix_corrupt option.")      if ( $schedule_rebuild && ( $all || $backup || $user || $vacuum ) );
    _help("You can only combine this option with the --schedule_rebuild option.") if ( $fix_corrupt      && ( $all || $backup || $user || $vacuum ) );

    my $conf              = Cpanel::Backup::Config::load();
    my $backup_master_dir = $conf->{'BACKUPDIR'};

    # if --user is on the command line by itself, leverage the --all code to
    # process all the backups but for this user only.

    if ( $user && !$backup ) {
        $all = $backup_master_dir;
    }

    # if disabled do not do anything, unless it is all then allow the
    # cleanup operation to happen, but then fail

    Cpanel::Backup::Metadata::metadata_disabled_check(1) if ( !$all );

    #We use this two places, may as well just get it now
    my @users;

    if ($user) {
        push( @users, $user );
    }
    else {
        @users = Cpanel::Backup::Metadata::get_all_users();
    }

    if ($all) {
        $all = $backup_master_dir;

        foreach my $this_user (@users) {
            my $db = Cpanel::Backup::Metadata::get_metadata_filename($this_user);
            unlink $db if -f $db;
        }

        my %backup_dirs_hash = _get_raw_backup_dirs($backup_master_dir);

        # clean old metadata
        foreach my $dir ( sort keys %backup_dirs_hash ) {
            try {
                clean_old_metadata_files($dir);

                # delete existing master meta, as it may be of an older type
                my $meta_master = $dir . "/accounts/.master.meta";
                unlink $meta_master if -e $meta_master;
            }
            catch {
                $logger->warn("Failed to clean old metadata for $dir :$_:");
            };
        }

        # allow the clean up to take place regardless of disabled or not
        # but then fail if metadata is disabled
        Cpanel::Backup::Metadata::metadata_disabled_check(1);

        my @dirs = _get_all_backup_dirs( $backup_master_dir, %backup_dirs_hash );
        foreach my $dir (@dirs) {
            print "Processing directory “$dir”\n";
            my $ret;

            try {
                $ret = create_master_meta($dir);
            }
            catch {
                $logger->warn("Failed to create metadata for $dir :$_:");
            };

            next if !$ret;    # ignore if the directory cannot be determined

            try {
                if ($user) {
                    Cpanel::Backup::Metadata::create_metadata_for_backup_user( $dir, $user, $logger );
                }
                else {
                    Cpanel::Backup::Metadata::create_metadata_for_backup( $dir, $logger );
                }
            }
            catch {
                $logger->warn("Failed to create metadata for $dir : $! ($_)");
            };
        }

        _run_vacuum();
    }
    elsif ($backup) {
        $backup = $backup_master_dir . "/$backup";

        my $backup_ref = Cpanel::Backup::StreamFileList::categorize_backup( $backup_master_dir, $backup, "dontcare" );
        if ( $backup_ref->{'backupID'} eq "ERROR" ) {
            _help("backup parameter is not a valid backup");
        }

        if ($user) {
            $backup_ref = Cpanel::Backup::StreamFileList::categorize_backup( $backup_master_dir, $backup, $user );
            if ( $backup_ref->{'type'} eq 'unknown' ) {
                _help("user parameter is not a valid backup");
            }

            try {
                if ( !create_master_meta($backup) ) {
                    die "Cannot create backup";    # is caught and warned
                }
                my $master_meta = Cpanel::Backup::Metadata::load_master_meta($backup);
                foreach my $user_ref ( values %{ $master_meta->{'users'} } ) {

                    next if ( $user_ref->{'user'} ne $user );
                    $logger->info("Processing Backup $backup for User $user");
                    Cpanel::Backup::Metadata::create_metadata_for_backup_user( $backup, $user_ref->{'user'}, $logger );
                    last;
                }
            }
            catch {
                $logger->warn("Failed to create metadata for $backup");
            }
        }
        else {
            try {
                if ( !create_master_meta($backup) ) {
                    die "Cannot create backup";    # is caught and warned
                }

                $logger->info("Processing Backup $backup");
                Cpanel::Backup::Metadata::create_metadata_for_backup( $backup, $logger );
            }
            catch {
                $logger->warn("Failed to create metadata for $backup");
            }
        }

        _run_vacuum();
        $logger->info("Processing is complete.");
    }
    elsif ($vacuum) {
        _run_vacuum();
    }
    elsif ($schedule_rebuild) {
        if ($fix_corrupt) {
            print "Fixing corrupted backup metadata in the background\n";
        }
        else {
            print "Creating all backup metadata in the background\n";
        }

        # remove old metadata, and regen with new schema
        require Cpanel::Daemonizer::Tiny;

        Cpanel::Daemonizer::Tiny::run_as_daemon(
            sub {
                # Don't lose output from the script when it detaches from here and goes off on it's own
                open( STDERR, '>>', $Cpanel::ConfigFiles::CPANEL_ROOT . '/logs/error_log' ) or warn "Could not open cPanel Error Log: $!";
                open( STDOUT, '>>', $Cpanel::ConfigFiles::CPANEL_ROOT . '/logs/error_log' ) or warn "Could not open cPanel Error Log: $!";

                if ($fix_corrupt) {
                    Cpanel::SafeRun::Simple::saferun( '/usr/local/cpanel/scripts/backups_create_metadata', '--fix_corrupt' );
                }
                else {
                    Cpanel::SafeRun::Simple::saferun( '/usr/local/cpanel/scripts/backups_create_metadata', '--all' );
                }
            },
            ""
        );
    }
    elsif ($fix_corrupt) {
        my ( $dbs_valid, $broken_users_ar ) = Cpanel::Backup::Metadata::is_database_valid( \@users );
        if ($dbs_valid) {
            print "No user metadata is corrupt\n";
        }
        else {
            try {
                fix_corrupt_metadata( $backup_master_dir, keys %{$broken_users_ar} );
            }
            catch {
                print "Error fixing corrupt backup metadata: $_\n";
            };
        }
    }

    return 1;
}

exit( script(@ARGV) ? 0 : 1 ) unless caller();