iobotis / php-incremental-backup

PHP incremental backup library

php-incremental-backup

PHP incremental backup is a php library designed to support setting incremental backups run by cron scripts. The library is a wrapper to different commands

Tools supported

• Duplicity
• Tar
• Borg backup

These tools are used to perform incremental backups on the directories chosen.

Requirements:

• php 5.4 or greater installed.
• one of the above libraries to be installed in your system.

How to install

1. Using composer

composer require iobotis/php-incremental-backup

2. Download and run composer install Follow the examples in the examples folder

Examples:

1. Simple Duplicity backup.

use Backup\Tools\Factory as ToolFactory;

$settings = array(
    'path_to_backup' => $path_to_backup,
    'destination' => array(
        'type' => 'local',
        'path' => '/path/to/save'
    ),
//    'passphrase' => 'abcdef',
//    'exclude' => array('folder')
);

$backup = ToolFactory::create('Duplicity', $settings);
$backup->execute();

2. Simple Duplicity backup with wrapper class.

use Backup\Tools\Factory as ToolFactory;
use Backup\IncrementalBackup;

use Backup\Tools\Factory as ToolFactory;

$settings = array(
    'path_to_backup' => $path_to_backup,
    'destination' => array(
        'type' => 'local',
        'path' => '/path/to/save'
    ),
//    'passphrase' => 'abcdef',
//    'exclude' => array('folder')
);

$backup = ToolFactory::create('Duplicity', $settings);
$backupClass = new IncrementalBackup ($backup);

$backups = $backupClass->getAllBackups();
foreach ($backups as $time) {
    echo 'There is a backup at ' . $time . "\n";
}

if( $backupClass->isChanged() ) {
    // back me up.
    echo 'Back up initiated' . "\n";
    $backupClass->createBackup();
}
else {
    echo 'No need to backup.' . "\n";
}

3. Simple Duplicity backup restore last backup.

use Backup\Tools\Factory as ToolFactory;
use Backup\IncrementalBackup;

$settings = array(
    'path_to_backup' => $path_to_backup,
    'destination' => array(
        'type' => 'local',
        'path' => '/path/to/save'
    ),
//    'passphrase' => 'abcdef'
);

$duplicity = ToolFactory::create('Duplicity', $settings);
$backupClass = new IncrementalBackup ($duplicity);

// Restore last backup to this directory.
$backupClass->restoreTo(end( $backups ), '/path/to/restore');

4. Simple Tar backup.

use Backup\Tools\Factory as ToolFactory;
use Backup\IncrementalBackup;

$settings = array(
    'path_to_backup' => $path_to_backup,
    'destination' => array(
        'type' => 'local',
        'path' => $path_to_save
    ),
    //'exclude' => array('exclude', 'exclude1')
);

$backup = ToolFactory::create('Tar', $settings);
$backupClass = new IncrementalBackup ($backup);

$backups = $backupClass->getAllBackups();
foreach ($backups as $time) {
    echo 'There is a backup at ' . $time . "\n";
}

if( $backupClass->isChanged() ) {
    // back me up.
    echo 'Back up initiated' . "\n";
    $backupClass->createBackup();
}
else {
    echo 'No need to backup.' . "\n";
}

5. Tar restore last backup.

use Backup\Tools\Factory as ToolFactory;
use Backup\IncrementalBackup;

$settings = array(
    'path_to_backup' => $path_to_backup,
    'destination' => array(
        'type' => 'local',
        'path' => $path_to_save
    ),
);

$backup = ToolFactory::create('Tar', $settings);
$backupClass = new IncrementalBackup ( $backup );

$backups = $backupClass->getAllBackups();

// Restore last backup to this directory.
$backupClass->restoreTo( end( $backups ), '/path/to/restore' );

Advanced usage

1)Duplicity without Factory

use Backup\Binary;
use Backup\FileSystem\Source;
use Backup\Destination\Factory as DesFactory;
use Backup\Tools\Duplicity;
use Backup\FileSystem\Folder;

$binary = new Binary('/usr/bin/duplicity');
$source = new Source('/var/www/example_com');
$destination = DesFactory::create('/var/backups/example_com');

$duplicity = new Duplicity($source,$destination,$binary);

$duplicity->setArchiveDir('/var/www/cache');
$duplicity->setExludedSubDirectories(array('cache', 'logs', 'tmp'));

// check if duplicity is installed.
$duplicity->isInstalled();

// get duplicity version.
$duplicity->getVersion();

// verify backup location.
$duplicity->verify();

// backup if needed.
$duplicity->execute();

// retrieve existing backups.
$backups = $duplicity->getAllBackups();

// restore 1st backup.
$folder = new Folder('/var/www/example_com');
$duplicity->restore($backups[0], $folder);

How to run unit tests

From the root folder run: php {location of phpunit phar}/phpunit.phar

or Install composer dependencies and run the scripts defined in composer.json.

php-incremental-backup's Issues

Create trait for Backup\Destination\AbstractBase

Create a trait for settings for Backup\Destination\AbstractBase.

Create unit tests for Tar class

Create some unit tests for the Tar class.

Support borg in Factory.

Support borg tool generation in Factory class.

Create borg class

• Create a borg class that implements the Command interface.
• Test borg binary and parameters.

Create factory for destinations

• Create a factory class to get destination class from settings

Not found .json (settings) at first run

The first time incrementalbackup is run there is an exception caused by not reading the json file (which does not exist) in the destination folder. I made the example with Tar. I found the error in the getSetting method of the Tar class

It always ($settings_file) true and at the first time _destination->read goes in exception because the .json file will not be found

<?php
/**
     * Get the backup settings, # of backups and backup unix timestamps.
     *
     * @return mixed|object
     */
    public function getSettings()
    {
        //$settings_file = $this->_destination->getPath() . DIRECTORY_SEPARATOR . $this->getSettingsFile();
 $settings_file = $this->_destination->read(DIRECTORY_SEPARATOR . $this->getSettingsFile());
        if ($settings_file) {
            return json_decode($settings_file);
        } // first time to backup.
        else {
            return (object)array(
                "number" => 0,
                "backups" => array()
            );
        }
    }

Support passphrase for borg.

• Create function setPassphrase for borg class.

Extend Readme

• Why use it
• What problems it solves

Support borg excluded directories

Create a class for filesystem operations

• Create a class for filesystem operations
• Inject it to the class that depend on it.

Create an exec wrapper class

• Create a class to wrap the exec function
• Use dependency injection so that the command wrapper can use it.
• Update unit tests.

Support composer.

Create a composer json to the root directory of the project.

Create a factory class

• Create a factory class and use settings to instantiate the Command implementations.

Create unit tests for Factory

Create unit tests for the CommandFactory.

Create unit tests for exceptions

Create new unit tests that throw our newly created exceptions and test their behaviour.

Create Tools folder.

• Create folder Tools.
• Change namespace.
• Move Duplicity, Tar, Borg classes there.

Update readme examples

Update outdated examples in Readme file.

Create exceptions

• Create exception interface
• Create InvalidArgumentException.
• Create BinaryNotFoundException.
• Create RestoreFailedException.
• Create basic RuntimeException.
• Update phpdoc.

Support excluded subdirectories for tar command.

Add a function in Tar class to exclude certain subdirectories from the archive.
setExludedSubDirectories
same way as for Duplicity class.

Tar password support

• Create a function to set password for tar archives

Support different compression for tar

• Create a function to set the tar compression format.