HyperVM

<?php 

include_once "htmllib/lib/include.php";

include_once "lib/vpsbackuplib.php";

exit_if_another_instance_running();

$vpb = new vpsbackup();

try { 

        $vpb->main();

} catch( Exception $e ) {

        print("Program Did not Complete because of error {$e->getMessage()}\n");

        exit;

}

class vpsbackup {

public $bserver_list;

public $global_list;

function main()

{

        global $gbl, $sgbl, $login, $ghtml; 

        global $argv;

        initProgram('admin');

        $login->loadAllObjects('vps');

        $this->bserver_l = $login->getList('centralbackupserver');

        $list = $login->getList('vps');

        foreach($this->bserver_l as $bso) {

                $bso->setMyselfUp();

        }

        $opt = parse_opt($argv);

        if (!isset($opt['newarg'])) {

                $mess = "\n\nThe architecture of centalized backup has been completely rewritten, and now we have per slave backup-server; you will need to supply --newarg=true for this to work. ";

                $mess .= "Please see http://lxlabs.com/software/hypervm/backup/ for more info.";

                print($mess);

                log_log("centralbackup_flag", $mess);

                send_mail_to_admin("Central Backup Failed", $mess);

                exit;

        }

        $this->stopvps = opt_get_single_flag($opt, 'stopvps');

        //$stopxen = opt_get_single_flag($opt, 'stopxen');

        //$stopopenvz = opt_get_single_flag($opt, 'stopopenvz');

        foreach($list as $l) {

                $this->backup_one_vps($l);

        }

        foreach((array) $this->global_list as $k => $s) {

                //$res = rl_exec_get(null, $k, 'remove_scpid', array($backupiddsa));

        }

}

function backup_one_vps($l)

{

        if (!$l->priv->isOn('centralbackup_flag')) {

                print("Central Backup flag is off for vps $l->nname... skipping...\n");

                return;

        }

        $l->truehostname = getInternalNetworkIp($l->syncserver);

        $bserver = $l->getBackupServer();

        if (is_disabled_or_null($bserver)) {

                $msg = "Backup server for $l->syncserver is disabled.. Skipping $l->nname\n";

                print($msg);

                log_log("centralbackup_error", $msg);

                return;

        }

        if (!isset($this->bserver_l[$bserver])) {

                print("The backup server $bserver doesn't exist\n");

                return;

        }

        $bs = $this->bserver_l[$bserver];

        if (!isset($this->global_list[$l->syncserver])) {

                try {

                        $res = rl_exec_get(null, $l->syncserver,  'setup_scpid', array($bs->backupiddsa));

                } catch( Exception $e ) {

                        $msg = "Could not connect to $l->syncserver Skipping $l->nname: {$e->getMessage()}\n";

                        log_log("centralbackup_error", $msg);

                        print($msg);

                        return;

                }

                $this->addknownHost($bs, "$l->truehostname $res");

                $this->global_list[$l->syncserver] = $l->truehostname;

        } else {

        }

        $msg = "Backing Up $l->nname on $l->truehostname to $bs->nname($bs->ssh_port):$bs->snapshotdir \n";

        log_log("centralbackup", $msg);

        print($msg);

        $l->setUpdateSubaction('top_level_central_back');

        $l->__var_bc_backupextra_stopvpsflag = ($this->stopvps? 'on': 'off');

        if ($l->isWindows()) {

                // 2010-07-13 LN: Add a flag to indicate central backup - not sure if the old code is used for scheduled backups.

                $l->isCentralBackup = true;

        }

        try {

                $res = rl_exec_set(null, $l->syncserver,  $l);

        } catch( Exception $e ) {

                $msg = "Failed Preparing... Skipping $l->nname on $l->syncserver: {$e->getMessage()}\n";

                log_log("centralbackup_error", $msg);

                print($msg);

                return;

        }

        $l->subaction = null;

        if ($res['savelist']) foreach($res['savelist'] as $k => $v) {

                $l->$k = $v;

        }

        $l->__save_bc = $res['back'];

        if ($l->isXen()) {

                $localdir = $l->nname;

        } else {

                $localdir = "$l->vpsid-$l->nname";

        }

        $ssh_port_for_slave = db_get_value("sshconfig", $l->syncserver, "ssh_port");

        if (!$ssh_port_for_slave) { $ssh_port_for_slave = "22"; }

        $l->__var_ssh_port_for_slave = $ssh_port_for_slave;

        if ($l->isWindows()) {

                $snapshotAndPartitions = $res['back'];

                $this->run_ntfsclone($bs, $l);

                $l->setUpdateSubaction('top_level_central_back_clean');

                $res = rl_exec_set(null, $l->syncserver,  $l);

        } else {

                $l->__var_remotedir = $res['back'][0];

                $this->run_rsnapshot($bs, $l);

                $l->setUpdateSubaction('top_level_central_back_clean');

                $res = rl_exec_set(null, $l->syncserver,  $l);

        }

}

/**

 * Backup Windows VPS using ntfsclone.

 * ntfsclone is executed via the backup server to re-use the key based login established by the existing code,

 * but since rsnapshot is not used, ntfsclone could run directly on the slave. Running it on the slave would simplify the code,

 * but requires key based login from the slave servers to the backup server.

 * Disk space requirement on the backup server:

 *    Used blocks on the Windows VPS x gzip compression ratio

 * There's no need for temporary storage, the data is streamed to the backup server immediately.

 * Example: Windows VPS, 100GB LVM, 37GB used, backup size 20GB

 * @param centralbackupserver $bs Backup server

 * @param Vps $vps VPS VPS to backup

 * @return void The backups should be rotated and the new backup be placed in daily.0

 */

function run_ntfsclone($bs, $vps)

{

        $machine = $vps->truehostname;

        $corerootdir = $bs->snapshotdir; 

        $vmtype =  $vps->ttype;

        $template = $vps->ostemplate;

        $vmname = $vps->nname;

        $ssh_port_for_slave = $vps->__var_ssh_port_for_slave;

        $backup_ssh_port_string = $bs->ssh_port_string;

        $backupserver = $bs->nname;

        $partitions = $vps->__save_bc->partitions;

   $backupRoot = "$corerootdir/vps/$vmtype/$vmname";

   $sshCmd = "ssh $backup_ssh_port_string $backupserver";

        // Create backup root

        //--------------------

   exec("$sshCmd '[ ! -d $backupRoot ] && mkdir -p $backupRoot'");

        // Rotate backups,

        // should be done only on successful backup, but that would require more disk space.

        //-----------------------------------------------------------------------------------

   $day = $bs->backup_num - 1;

   exec("$sshCmd '[ -d $backupRoot/daily.$day ] && rm -Rf $backupRoot/daily.$day'");

   for (; $day > 0; $day--) {

      $src = "$backupRoot/daily." . ($day - 1);

      $dst = "$backupRoot/daily." . $day;

      exec("$sshCmd '[ -d $src ] && rm -Rf $dst && mv $src $dst'");

   }

   exec("$sshCmd '[ ! -d $backupRoot/daily.0 ] && mkdir -p $backupRoot/daily.0'");

        // Backup MBR

        //------------

        $runOnSyncServer = "ssh -p$ssh_port_for_slave root@$machine 'dd if={$vps->__save_bc->snapshot} bs=512 count=1'";

        $runOnBackupServer = "$sshCmd \"$runOnSyncServer | cat > $backupRoot/daily.0/$vmname.mbr\"";

        exec($runOnBackupServer, $output, $returnvalue);

   log_log("centralbackup", implode("\n", $output));

        // Backup partitions

        //-------------------

        $n = 1;

        print_time('ntfsclone');

        foreach ($partitions as $partition) {

                $runOnSyncServer = "ssh -p$ssh_port_for_slave root@$machine 'ntfsclone -o - -s $partition | nice -n19 gzip -c'";

                $runOnBackupServer = "$sshCmd \"$runOnSyncServer | cat > $backupRoot/daily.0/$vmname.part$n.gz\"";

                $n++;

                exec($runOnBackupServer, $output, $returnvalue);

      log_log("centralbackup", implode("\n", $output));

        }

        $msg = print_time("ntfsclone", "ntfsclone of $vmname@$machine took:", -1);

        print("\n$msg\n");

        log_log("centralbackup", $msg);

        return;

}

function run_rsnapshot($bs, $vps)

{

        $machine = $vps->truehostname;

        $corerootdir = $bs->snapshotdir; 

        $vmtype =  $vps->ttype;

        $template = $vps->ostemplate;

        $vmname = $vps->nname;

        $ssh_port_for_slave = $vps->__var_ssh_port_for_slave;

        $remotedir = $vps->__var_remotedir;

        $backup_ssh_port_string = $bs->ssh_port_string;

        $backupserver = $bs->nname;

        if (!$remotedir) {

                print("Critical Error, no remotedir set for $vmname\n");

                return;

        }

        print_time('rsnapshot');

        if (!lxfile_exists("../file/rsnapshot.conf")) {

                lxfile_cp("../file/rsnapshot.conf.dist", "../file/rsnapshot.conf");

        }

        $string  = lfile_get_contents("../file/rsnapshot.conf");

        $string .= "\n";

        $string .= "ssh_args        -p $ssh_port_for_slave\n";

        $string .= "interval        daily        $bs->backup_num\n";

        $string .= "logfile        $corerootdir/rsnapshot.log\n";

        $string .= "lockfile        $corerootdir/rsnapshot.pid\n";

        $string .= "snapshot_root        $corerootdir/vps/$vmtype/$vmname\n";

        $string .= "backup        root@$machine:$remotedir/*        ./\n";

        $cmd = "ssh $backup_ssh_port_string $backupserver '(tmpnm=/tmp/rsnapshot_config.$$ ; cat > \$tmpnm ; sh ./lxvpsbackupserver.sh $corerootdir $vmtype $template $vmname \$tmpnm ; )'";

        $cmd = "echo '$string' | $cmd";

        print("Execing rsnapshot\n");

        exec($cmd, $output, $returnvalue);

        $msg = print_time("rsnapshot", "Rsnaphost of $machine $remotedir took:", -1);

        print("\n$msg\n");

        log_log("centralbackup", $msg);

        log_log("rsnapshot_log", implode("\n", $output));

}

function addknownHost($bs, $rsakey)

{

        $backup_ssh_port_string = $bs->ssh_port_string;

        $server = $bs->nname;

        $rsakey = trim($rsakey);

        print("Adding known host...\n");

        $cmd = "ssh $backup_ssh_port_string $bs->nname \"(if ! grep -i '$rsakey' ~/.ssh/known_hosts ; then  echo '$rsakey' >> ~/.ssh/known_hosts; fi)\"";

        //dprint($cmd);

        exec($cmd);

}

}