diff --git a/.travis.yml b/.travis.yml
index 5ff9af8..9586c1c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,13 +2,12 @@ language: php
 sudo: false 
 
 php:
-  - 5.4
   - 5.5
   - 5.6
   - 7.0
   - hhvm
   
-before_script: composer install --dev --prefer-source
+before_script: composer install --prefer-source
 
 script: phpunit --debug --coverage-text
 
diff --git a/Client/DownloadableClientInterface.php b/Client/DownloadableClientInterface.php
new file mode 100644
index 0000000..f0d9e01
--- /dev/null
+++ b/Client/DownloadableClientInterface.php
@@ -0,0 +1,12 @@
+<?php
+namespace Dizda\CloudBackupBundle\Client;
+
+interface DownloadableClientInterface
+{
+    /**
+     * Download lastest backup file.
+     *
+     * @return \SplFileInfo
+     */
+    public function download();
+}
diff --git a/Client/DropboxSdkClient.php b/Client/DropboxSdkClient.php
index 9035b08..c21e771 100644
--- a/Client/DropboxSdkClient.php
+++ b/Client/DropboxSdkClient.php
@@ -1,15 +1,18 @@
 <?php
 namespace Dizda\CloudBackupBundle\Client;
 
+use Dizda\CloudBackupBundle\Exception\InvalidConfigurationException;
+use Dizda\CloudBackupBundle\Exception\RestoringNotAvailableException;
 use Dizda\CloudBackupBundle\Exception\UploadException;
 use \Dropbox as Dropbox;
+use Symfony\Component\Filesystem\Filesystem;
 
 /**
  * Class DropboxSdkClient.
  *
  * @author David Fuertes
  */
-class DropboxSdkClient implements ClientInterface
+class DropboxSdkClient implements ClientInterface, DownloadableClientInterface
 {
     /**
      * @var string
@@ -17,10 +20,25 @@ class DropboxSdkClient implements ClientInterface
     private $access_token;
 
     /**
-     * @param array $params user
+     * @var string
+     */
+    private $restoreFolder;
+
+    /**
+     * @var Filesystem
      */
-    public function __construct($params)
+    private $localFilesystem;
+
+    /**
+     *
+     * @param array $params
+     * @param $restoreFolder
+     * @param Filesystem $localFilesystem
+     */
+    public function __construct($params, $restoreFolder = null, Filesystem $localFilesystem = null)
     {
+        $this->restoreFolder = $restoreFolder;
+        $this->localFilesystem = $localFilesystem;
         $params             = $params['dropbox_sdk'];
         $this->access_token = $params['access_token'];
         $this->remotePath   = $params['remote_path'];
@@ -46,6 +64,37 @@ public function upload($archive)
         fclose($fp);
     }
 
+    public function download()
+    {
+        if (!$this->restoreFolder) {
+            throw InvalidConfigurationException::create('$restoreFolder');
+        }
+        $pathError = Dropbox\Path::findErrorNonRoot($this->remotePath);
+        if ($pathError !== null) {
+            throw new UploadException(sprintf('Invalid path "%s".', $this->remotePath));
+        }
+        $client = new Dropbox\Client($this->access_token, 'CloudBackupBundle');
+        $entry = $client->getMetadataWithChildren($this->remotePath);
+        if (!$entry['is_dir']) {
+            throw RestoringNotAvailableException::create();
+        }
+
+        // Fetch the latest file
+        $file = end($entry['contents']);
+        $fileName = substr($file['path'], 1+strrpos($file['path'], '/'));
+        $stream = fopen('php://temp', 'r+');
+        $client->getFile($file['path'], $stream);
+        fseek($stream, 0);
+        $content = stream_get_contents($stream);
+
+        $splFile = new \SplFileInfo($this->restoreFolder . $fileName);
+
+        $this->localFilesystem->dumpFile($splFile->getPathname(), $content);
+
+        return $splFile;
+    }
+
+
     /**
      * {@inheritdoc}
      */
diff --git a/Client/GaufretteClient.php b/Client/GaufretteClient.php
index 625c5f4..02438da 100644
--- a/Client/GaufretteClient.php
+++ b/Client/GaufretteClient.php
@@ -1,8 +1,9 @@
 <?php
 namespace Dizda\CloudBackupBundle\Client;
 
-use Symfony\Component\Console\Output\ConsoleOutput;
+use Dizda\CloudBackupBundle\Exception\InvalidConfigurationException;
 use Gaufrette\Filesystem;
+use Symfony\Component\Filesystem\Filesystem as LocalFilesystem;
 
 /**
  * Class GaufretteClient
@@ -10,10 +11,33 @@
  *
  * @author  Jonathan Dizdarevic <dizda@dizda.fr>
  */
-class GaufretteClient implements ClientInterface
+class GaufretteClient implements ClientInterface, DownloadableClientInterface
 {
+    /**
+     * @var Filesystem[]
+     */
     private $filesystems;
 
+    /**
+     * @var string
+     */
+    private $restoreFolder;
+
+    /**
+     * @var LocalFilesystem
+     */
+    private $localFilesystem;
+
+    /**
+     * @param string $restoreFolder
+     * @param LocalFilesystem $localFilesystem
+     */
+    public function __construct($restoreFolder = null, LocalFilesystem $localFilesystem = null)
+    {
+        $this->restoreFolder = $restoreFolder;
+        $this->localFilesystem = $localFilesystem;
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -35,6 +59,14 @@ public function addFilesystem(Filesystem $filesystem)
         $this->filesystems[] = $filesystem;
     }
 
+    /**
+     * @return Filesystem
+     */
+    private function getFirstFilesystem()
+    {
+        return $this->filesystems[0];
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -42,4 +74,25 @@ public function getName()
     {
         return 'Gaufrette';
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function download()
+    {
+        if (!$this->restoreFolder) {
+            throw InvalidConfigurationException::create('$restoreFolder');
+        }
+        $fileSystem = $this->getFirstFilesystem();
+
+        $files = $fileSystem->keys();
+        $fileName = end($files);
+
+        $content = $fileSystem->get($fileName)->getContent();
+        $splFile = new \SplFileInfo($this->restoreFolder . $fileName);
+
+        $this->localFilesystem->dumpFile($splFile->getPathname(), $content);
+
+        return $splFile;
+    }
 }
diff --git a/Command/RestoreCommand.php b/Command/RestoreCommand.php
new file mode 100644
index 0000000..81a49e5
--- /dev/null
+++ b/Command/RestoreCommand.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Command;
+
+use Dizda\CloudBackupBundle\Manager\RestoreManager;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class RestoreCommand extends Command
+{
+    const RETURN_STATUS_SUCCESS = 0;
+    const RETURN_STATUS_NOT_AVAILABLE = 1;
+    const RETURN_STATUS_MISSING_FORCE_FLAG = 2;
+    const RETURN_STATUS_EXCEPTION_OCCURRED = 3;
+
+    /**
+     * @var bool
+     */
+    protected $doRestore;
+
+    /**
+     * @var RestoreManager
+     */
+    protected $restoreManager;
+
+    /**
+     * @param boolean $doRestore
+     * @param RestoreManager $restoreManager
+     */
+    public function __construct($doRestore, RestoreManager $restoreManager)
+    {
+        $this->doRestore = $doRestore;
+        $this->restoreManager = $restoreManager;
+
+        parent::__construct();
+    }
+
+    /**
+     * Configure the command.
+     */
+    protected function configure()
+    {
+        $this
+            ->setName('dizda:backup:restore')
+            ->setDescription('Download latest backup, uncompress and restore.')
+            ->addOption('force', null, InputOption::VALUE_NONE)
+        ;
+    }
+
+    /**
+     * @param InputInterface  $input
+     * @param OutputInterface $output
+     *
+     * @return int
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        if (!$this->doRestore) {
+            $output->writeln('<error>Restore is not available. Enable by setting dizda_cloud_backup.restore: true in config.yml.</error>');
+
+            return self::RETURN_STATUS_NOT_AVAILABLE;
+        }
+
+        if (!$input->getOption('force')) {
+            $output->writeln('<error>Run command with --force to execute.</error>');
+
+            return self::RETURN_STATUS_MISSING_FORCE_FLAG;
+        }
+
+        $output->writeln('Restoring backup started');
+
+        if ($this->restoreManager->execute()) {
+            $output->writeln('Restoring backup completed');
+
+            return self::RETURN_STATUS_SUCCESS;
+        } else {
+            $output->writeln('<error>Something went wrong</error>');
+
+            return self::RETURN_STATUS_EXCEPTION_OCCURRED;
+        }
+    }
+}
diff --git a/Database/MySQL.php b/Database/MySQL.php
index f048497..7b49a74 100644
--- a/Database/MySQL.php
+++ b/Database/MySQL.php
@@ -1,6 +1,7 @@
 <?php
 namespace Dizda\CloudBackupBundle\Database;
 
+use Dizda\CloudBackupBundle\Exception\InvalidConfigurationException;
 use Symfony\Component\Process\ProcessUtils;
 
 /**
@@ -8,7 +9,7 @@
  *
  * @author  Jonathan Dizdarevic <dizda@dizda.fr>
  */
-class MySQL extends BaseDatabase
+class MySQL extends BaseDatabase implements RestorableDatabaseInterface
 {
     const DB_PATH = 'mysql';
     const CONFIGURATION_FILE_NAME = 'mysql.cnf';
@@ -20,14 +21,20 @@ class MySQL extends BaseDatabase
     private $params;
 
     /**
-     * DB Auth.
-     *
+     * @var string
+     */
+    private $restoreFolder;
+
+    /**
      * @param array $params
      * @param string $basePath
+     * @param string $restoreFolder
      */
-    public function __construct($params, $basePath)
+    public function __construct($params, $basePath, $restoreFolder = null)
     {
         parent::__construct($basePath);
+
+        $this->restoreFolder = $restoreFolder;
         $this->params = $params['mysql'];
     }
 
@@ -135,6 +142,14 @@ public function dump()
         $this->removeConfigurationFile();
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function restore()
+    {
+        $this->execute($this->getRestoreCommand());
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -148,6 +163,35 @@ protected function getCommand()
         );
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    protected function getRestoreCommand()
+    {
+        if (!$this->restoreFolder) {
+            throw InvalidConfigurationException::create('$restoreFolder');
+        }
+
+        $restoreAuth = '';
+        if ($this->params['db_user']) {
+            $restoreAuth = sprintf('-u%s', $this->params['db_user']);
+
+            if ($this->params['db_password']) {
+                $restoreAuth = $restoreAuth . sprintf(" --password=\"%s\"", $this->params['db_password']);
+            }
+        }
+
+        $this->prepareFileName();
+
+        $command = sprintf('mysql %s %s < %s',
+            $restoreAuth,
+            $this->params['database'],
+            ProcessUtils::escapeArgument(sprintf('%smysql/%s', $this->restoreFolder, $this->fileName))
+        );
+
+        return $command;
+    }
+
     /**
      * {@inheritdoc}
      */
diff --git a/Database/RestorableDatabaseInterface.php b/Database/RestorableDatabaseInterface.php
new file mode 100644
index 0000000..e732a8c
--- /dev/null
+++ b/Database/RestorableDatabaseInterface.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Database;
+
+interface RestorableDatabaseInterface
+{
+    /**
+     * Restore the database with a previous dump
+     */
+    public function restore();
+}
diff --git a/DependencyInjection/Configuration.php b/DependencyInjection/Configuration.php
index cc8caf6..b4edb2c 100644
--- a/DependencyInjection/Configuration.php
+++ b/DependencyInjection/Configuration.php
@@ -135,6 +135,7 @@ public function getConfigTreeBuilder()
                     ->end()
                 ->end()
             ->end()
+            ->booleanNode('restore')->defaultFalse()->end()
         ->end();
 
         return $treeBuilder;
diff --git a/DependencyInjection/DizdaCloudBackupExtension.php b/DependencyInjection/DizdaCloudBackupExtension.php
index f01d6de..558242c 100644
--- a/DependencyInjection/DizdaCloudBackupExtension.php
+++ b/DependencyInjection/DizdaCloudBackupExtension.php
@@ -29,6 +29,7 @@ public function load(array $configs, ContainerBuilder $container)
         /* Config output file */
         $container->setParameter('dizda_cloud_backup.root_folder', $container->getParameter('kernel.root_dir').'/../');
         $container->setParameter('dizda_cloud_backup.output_folder', $container->getParameter('kernel.cache_dir').'/backup/');
+        $container->setParameter('dizda_cloud_backup.restore_folder', $container->getParameter('kernel.cache_dir').'/restore/');
 
         /* Assign all config vars */
         foreach ($config as $k => $v) {
diff --git a/Event/RestoreEvent.php b/Event/RestoreEvent.php
new file mode 100644
index 0000000..50c61b0
--- /dev/null
+++ b/Event/RestoreEvent.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Event;
+
+use Symfony\Component\EventDispatcher\Event;
+
+class RestoreEvent extends Event
+{
+    const RESTORE_COMPLETED = 'dizda.cloudbackup.restore_completed';
+
+    /**
+     * @var \SplFileInfo
+     */
+    protected $file;
+
+    /**
+     * @param \SplFileInfo $file
+     */
+    public function __construct(\SplFileInfo $file)
+    {
+        $this->file = $file;
+    }
+
+    /**
+     * @return \SplFileInfo
+     */
+    public function getFile()
+    {
+        return $this->file;
+    }
+}
diff --git a/Event/RestoreFailedEvent.php b/Event/RestoreFailedEvent.php
new file mode 100644
index 0000000..5ff3746
--- /dev/null
+++ b/Event/RestoreFailedEvent.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Event;
+
+use Symfony\Component\EventDispatcher\Event;
+
+class RestoreFailedEvent extends Event
+{
+    const RESTORE_FAILED = 'dizda.cloudbackup.restore_failed';
+
+    /**
+     * @var \Exception
+     */
+    protected $exception;
+
+    /**
+     * @param \Exception $exception
+     */
+    public function __construct(\Exception $exception)
+    {
+        $this->exception = $exception;
+    }
+
+    /**
+     * @return \Exception
+     */
+    public function getException()
+    {
+        return $this->exception;
+    }
+}
diff --git a/Exception/InvalidConfigurationException.php b/Exception/InvalidConfigurationException.php
new file mode 100644
index 0000000..fdd2353
--- /dev/null
+++ b/Exception/InvalidConfigurationException.php
@@ -0,0 +1,13 @@
+<?php
+namespace Dizda\CloudBackupBundle\Exception;
+
+class InvalidConfigurationException extends \LogicException
+{
+    /**
+     * @return InvalidConfigurationException
+     */
+    public static function create($param)
+    {
+        return new self(sprintf('Parameter "%s" is not set.', $param));
+    }
+}
diff --git a/Exception/MissingDownloadableClientsException.php b/Exception/MissingDownloadableClientsException.php
new file mode 100644
index 0000000..82bab74
--- /dev/null
+++ b/Exception/MissingDownloadableClientsException.php
@@ -0,0 +1,13 @@
+<?php
+namespace Dizda\CloudBackupBundle\Exception;
+
+class MissingDownloadableClientsException extends \LogicException
+{
+    /**
+     * @return MissingDownloadableClientsException
+     */
+    public static function create()
+    {
+        return new self('No downloadable client is registered.');
+    }
+}
diff --git a/Exception/MissingRestorableDatabaseException.php b/Exception/MissingRestorableDatabaseException.php
new file mode 100644
index 0000000..5fa10c2
--- /dev/null
+++ b/Exception/MissingRestorableDatabaseException.php
@@ -0,0 +1,13 @@
+<?php
+namespace Dizda\CloudBackupBundle\Exception;
+
+class MissingRestorableDatabaseException extends \LogicException
+{
+    /**
+     * @return MissingRestorableDatabaseException
+     */
+    public static function create()
+    {
+        return new self('No restorable database is registered.');
+    }
+}
diff --git a/Exception/RestoringNotAvailableException.php b/Exception/RestoringNotAvailableException.php
new file mode 100644
index 0000000..24ee8d3
--- /dev/null
+++ b/Exception/RestoringNotAvailableException.php
@@ -0,0 +1,13 @@
+<?php
+namespace Dizda\CloudBackupBundle\Exception;
+
+class RestoringNotAvailableException extends \LogicException
+{
+    /**
+     * @return RestoringNotAvailableException
+     */
+    public static function create()
+    {
+        return new self('Restoring is not available.');
+    }
+}
diff --git a/Exception/UncompressionNotSupportedException.php b/Exception/UncompressionNotSupportedException.php
new file mode 100644
index 0000000..288122b
--- /dev/null
+++ b/Exception/UncompressionNotSupportedException.php
@@ -0,0 +1,6 @@
+<?php
+namespace Dizda\CloudBackupBundle\Exception;
+
+class UncompressionNotSupportedException extends \LogicException
+{
+}
diff --git a/Exception/UploadException.php b/Exception/UploadException.php
index fb9587c..88b02c7 100644
--- a/Exception/UploadException.php
+++ b/Exception/UploadException.php
@@ -7,5 +7,11 @@
  */
 class UploadException extends \Exception
 {
-    protected $message = 'Unable to upload the file.';
+    /**
+     * @return UploadException
+     */
+    public function create()
+    {
+        return new self('Unable to upload the file.');
+    }
 }
diff --git a/Listener/CleanRestoreWorkspaceListener.php b/Listener/CleanRestoreWorkspaceListener.php
new file mode 100644
index 0000000..a183415
--- /dev/null
+++ b/Listener/CleanRestoreWorkspaceListener.php
@@ -0,0 +1,51 @@
+<?php
+namespace Dizda\CloudBackupBundle\Listener;
+
+use Dizda\CloudBackupBundle\Event\RestoreEvent;
+use Dizda\CloudBackupBundle\Event\RestoreFailedEvent;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Filesystem\Filesystem;
+
+class CleanRestoreWorkspaceListener
+{
+    /**
+     * @var string
+     */
+    private $restoreFolder;
+
+    /**
+     * @var Filesystem
+     */
+    private $filesystem;
+
+    /**
+     * @param string $restoreFolder
+     * @param Filesystem $filesystem
+     */
+    public function __construct($restoreFolder, Filesystem $filesystem)
+    {
+        $this->restoreFolder = $restoreFolder;
+        $this->filesystem = $filesystem;
+    }
+
+    /**
+     * @param RestoreEvent $event
+     */
+    public function whenRestoreIsCompleted(RestoreEvent $event)
+    {
+        $this->clean();
+    }
+
+    /**
+     * @param RestoreFailedEvent $event
+     */
+    public function whenRestoreIsFailed(RestoreFailedEvent $event)
+    {
+        $this->clean();
+    }
+
+    private function clean()
+    {
+        $this->filesystem->remove($this->restoreFolder);
+    }
+}
diff --git a/Listener/LogRestoreCompletedListener.php b/Listener/LogRestoreCompletedListener.php
new file mode 100644
index 0000000..0e07387
--- /dev/null
+++ b/Listener/LogRestoreCompletedListener.php
@@ -0,0 +1,29 @@
+<?php
+namespace Dizda\CloudBackupBundle\Listener;
+
+use Dizda\CloudBackupBundle\Event\RestoreEvent;
+use Psr\Log\LoggerInterface;
+
+class LogRestoreCompletedListener
+{
+    /**
+     * @var LoggerInterface
+     */
+    protected $logger;
+
+    /**
+     * @param LoggerInterface $logger
+     */
+    public function __construct(LoggerInterface $logger)
+    {
+        $this->logger = $logger;
+    }
+
+    /**
+     * @param RestoreEvent $event
+     */
+    public function whenRestoreIsCompleted(RestoreEvent $event)
+    {
+        $this->logger->info(sprintf('[dizda-backup] Restoring %s is completed', $event->getFile()->getFilename()));
+    }
+}
diff --git a/Listener/LogRestoreFailedListener.php b/Listener/LogRestoreFailedListener.php
new file mode 100644
index 0000000..a987fe6
--- /dev/null
+++ b/Listener/LogRestoreFailedListener.php
@@ -0,0 +1,29 @@
+<?php
+namespace Dizda\CloudBackupBundle\Listener;
+
+use Dizda\CloudBackupBundle\Event\RestoreFailedEvent;
+use Psr\Log\LoggerInterface;
+
+class LogRestoreFailedListener
+{
+    /**
+     * @var LoggerInterface
+     */
+    protected $logger;
+
+    /**
+     * @param LoggerInterface $logger
+     */
+    public function __construct(LoggerInterface $logger)
+    {
+        $this->logger = $logger;
+    }
+
+    /**
+     * @param RestoreFailedEvent $event
+     */
+    public function whenRestoreIsFailed(RestoreFailedEvent $event)
+    {
+        $this->logger->critical('[dizda-backup] Restoring database failed', ['exception' => $event->getException()]);
+    }
+}
diff --git a/Manager/ClientManager.php b/Manager/ClientManager.php
index 12fb94f..e8fcb1c 100644
--- a/Manager/ClientManager.php
+++ b/Manager/ClientManager.php
@@ -3,6 +3,8 @@
 namespace Dizda\CloudBackupBundle\Manager;
 
 use Dizda\CloudBackupBundle\Client\ClientInterface;
+use Dizda\CloudBackupBundle\Client\DownloadableClientInterface;
+use Dizda\CloudBackupBundle\Exception\MissingDownloadableClientsException;
 use Psr\Log\LoggerInterface;
 
 /**
@@ -70,4 +72,20 @@ public function upload($files)
             throw $exception;
         }
     }
+
+    /**
+     * @return \SplFileInfo
+     *
+     * @throws MissingDownloadableClientsException
+     */
+    public function download()
+    {
+        foreach ($this->children as $child) {
+            if ($child instanceof DownloadableClientInterface) {
+                return $child->download();
+            }
+        }
+
+        throw MissingDownloadableClientsException::create();
+    }
 }
diff --git a/Manager/DatabaseManager.php b/Manager/DatabaseManager.php
index 697c281..de7afbb 100644
--- a/Manager/DatabaseManager.php
+++ b/Manager/DatabaseManager.php
@@ -3,6 +3,8 @@
 namespace Dizda\CloudBackupBundle\Manager;
 
 use Dizda\CloudBackupBundle\Database\DatabaseInterface;
+use Dizda\CloudBackupBundle\Database\RestorableDatabaseInterface;
+use Dizda\CloudBackupBundle\Exception\MissingRestorableDatabaseException;
 use Psr\Log\LoggerInterface;
 
 /**
@@ -52,4 +54,19 @@ public function dump()
             $child->dump();
         }
     }
+
+    /**
+     * @throws MissingRestorableDatabaseException
+     */
+    public function restore()
+    {
+        foreach ($this->children as $child) {
+            if ($child instanceof RestorableDatabaseInterface) {
+                $child->restore();
+                return;
+            }
+        }
+
+        throw MissingRestorableDatabaseException::create();
+    }
 }
diff --git a/Manager/ProcessorManager.php b/Manager/ProcessorManager.php
index 929a8a8..f7ca969 100644
--- a/Manager/ProcessorManager.php
+++ b/Manager/ProcessorManager.php
@@ -2,7 +2,9 @@
 
 namespace Dizda\CloudBackupBundle\Manager;
 
+use Dizda\CloudBackupBundle\Exception\UncompressionNotSupportedException;
 use Dizda\CloudBackupBundle\Processor\ProcessorInterface;
+use Dizda\CloudBackupBundle\Processor\UncompressableProcessorInterface;
 use Dizda\CloudBackupBundle\Splitter\BaseSplitter;
 use Symfony\Component\Filesystem\Filesystem;
 use Symfony\Component\Process\Process;
@@ -66,14 +68,20 @@ class ProcessorManager
      */
     protected $splitter;
 
+    /**
+     * @var string
+     */
+    protected $restoreFolder;
+
     /**
      * @param string $rootPath   Path to root folder
      * @param string $outputPath Path to folder with archived files
      * @param string $filePrefix Prefix for archive file (e.g. sitename)
      * @param array  $properties Date function format
      * @param array  $folders    Array of folders to archive (relative to $rootPath)
+     * @param string $restoreFolder Path to restore folder
      */
-    public function __construct($rootPath, $outputPath, $filePrefix, $properties, array $folders = array())
+    public function __construct($rootPath, $outputPath, $filePrefix, $properties, array $folders = array(), $restoreFolder = null)
     {
         $this->rootPath   = $rootPath;
         $this->outputPath = $outputPath;
@@ -81,6 +89,7 @@ public function __construct($rootPath, $outputPath, $filePrefix, $properties, ar
         $this->folders    = $folders;
         $this->properties = $properties;
         $this->compressedArchivePath = $this->outputPath.'../backup_compressed/';
+        $this->restoreFolder = $restoreFolder;
 
         $this->filesystem = new Filesystem();
     }
@@ -126,6 +135,22 @@ public function compress()
         }
     }
 
+    /**
+     * @param \SplFileInfo $file
+     */
+    public function uncompress(\SplFileInfo $file)
+    {
+        if (!$this->processor instanceof UncompressableProcessorInterface) {
+            throw new UncompressionNotSupportedException(
+                sprintf('Uncompression is not supported for %s.', $this->processor->getName())
+            );
+        }
+
+        $this->archivePath = $this->compressedArchivePath . $this->buildArchiveFilename();
+        $archive = $this->processor->getUncompressCommand($this->restoreFolder, $file->getPathname(), $this->restoreFolder);
+        $this->execute($archive);
+    }
+
     /**
      * Return the archive file name.
      *
diff --git a/Manager/RestoreManager.php b/Manager/RestoreManager.php
new file mode 100644
index 0000000..b13a70d
--- /dev/null
+++ b/Manager/RestoreManager.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Manager;
+
+use Dizda\CloudBackupBundle\Event\RestoreEvent;
+use Dizda\CloudBackupBundle\Event\RestoreFailedEvent;
+use Dizda\CloudBackupBundle\Exception\RestoringNotAvailableException;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\Filesystem\Filesystem;
+
+class RestoreManager
+{
+    /**
+     * @var \Dizda\CloudBackupBundle\Manager\DatabaseManager
+     */
+    private $databaseManager;
+
+    /**
+     * @var \Dizda\CloudBackupBundle\Manager\ClientManager
+     */
+    private $clientManager;
+
+    /**
+     * @var \Dizda\CloudBackupBundle\Manager\ProcessorManager
+     */
+    private $processorManager;
+
+    /**
+     * @var EventDispatcherInterface
+     */
+    private $eventDispatcher;
+
+    /**
+     * @var string
+     */
+    private $restoreFolder;
+
+    /**
+     * @var Filesystem
+     */
+    private $filesystem;
+
+    /**
+     * @var bool
+     */
+    private $doRestore;
+
+    /**
+     * @param DatabaseManager          $databaseManager
+     * @param ClientManager            $clientManager
+     * @param ProcessorManager         $processorManager
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param string                   $restoreFolder
+     * @param boolean                  $doRestore
+     */
+    public function __construct(
+        DatabaseManager $databaseManager,
+        ClientManager $clientManager,
+        ProcessorManager $processorManager,
+        EventDispatcherInterface $eventDispatcher,
+        $restoreFolder,
+        Filesystem $filesystem,
+        $doRestore
+    ) {
+        $this->databaseManager = $databaseManager;
+        $this->clientManager = $clientManager;
+        $this->processorManager = $processorManager;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->restoreFolder = $restoreFolder;
+        $this->filesystem = $filesystem;
+        $this->doRestore = (boolean) $doRestore;
+    }
+
+    /**
+     * @return bool
+     */
+    public function execute()
+    {
+        if (!$this->doRestore) {
+            throw RestoringNotAvailableException::create();
+        }
+
+        try {
+            $this->filesystem->mkdir($this->restoreFolder);
+            $file = $this->clientManager->download();
+            $this->processorManager->uncompress($file);
+            $this->databaseManager->restore();
+            $this->eventDispatcher->dispatch(RestoreEvent::RESTORE_COMPLETED, new RestoreEvent($file));
+
+            return true;
+        } catch (\Exception $e) {
+            $this->eventDispatcher->dispatch(RestoreFailedEvent::RESTORE_FAILED, new RestoreFailedEvent($e));
+        }
+
+        return false;
+    }
+}
diff --git a/Processor/UncompressableProcessorInterface.php b/Processor/UncompressableProcessorInterface.php
new file mode 100644
index 0000000..c29acf0
--- /dev/null
+++ b/Processor/UncompressableProcessorInterface.php
@@ -0,0 +1,16 @@
+<?php
+namespace Dizda\CloudBackupBundle\Processor;
+
+interface UncompressableProcessorInterface
+{
+   /**
+     * Get uncompress command.
+     *
+     * @param string $basePath
+     * @param string $fileName
+     * @param string $uncompressPath
+     *
+     * @return string
+     */
+    public function getUncompressCommand($basePath, $fileName, $uncompressPath);
+}
diff --git a/Processor/ZipProcessor.php b/Processor/ZipProcessor.php
index df2134d..a3a1936 100644
--- a/Processor/ZipProcessor.php
+++ b/Processor/ZipProcessor.php
@@ -2,7 +2,7 @@
 
 namespace Dizda\CloudBackupBundle\Processor;
 
-class ZipProcessor extends BaseProcessor implements ProcessorInterface
+class ZipProcessor extends BaseProcessor implements ProcessorInterface, UncompressableProcessorInterface
 {
     /**
      * {@inheritdoc}
@@ -31,6 +31,14 @@ public function getCompressionCommand($archivePath, $basePath)
         return sprintf('cd %s && zip %s %s .', $basePath, implode(' ', $params), $archivePath);
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function getUncompressCommand($basePath, $fileName, $uncompressPath)
+    {
+        return sprintf('cd %s && unzip -o %s -d %s', $basePath, $fileName, $uncompressPath);
+    }
+
     /**
      * {@inheritdoc}
      */
diff --git a/README.md b/README.md
index d963cce..b03d6a0 100644
--- a/README.md
+++ b/README.md
@@ -82,6 +82,7 @@ dizda_cloud_backup:
     # such as: hostname_2014-01-01_21-08-39.tar
     output_file_prefix: hostname
     timeout: 300
+    restore: false # Set to true to enable restore command
     processor:
         type: tar # Required: tar|zip|7z
         options:
@@ -217,6 +218,14 @@ In addition, using -F or --folder option the folders also will be added to the b
 
 Obviously, if some problems occurs during the backup process, you can configure monolog to send you emails. 
 
+When working locally or on a staging server, you can configure the bundle to enable restoring. Set `restore: true` and
+the following command is available:
+```bash
+$ php app/console dizda:backup:restore --force
+```
+
+Note! Not all processors, clients and databases supports restoring. Backupped files are not restored.
+
 Which archiver do I use?
 ------------------------
 
diff --git a/Resources/config/services.yml b/Resources/config/services.yml
index 3a07aad..33b738b 100644
--- a/Resources/config/services.yml
+++ b/Resources/config/services.yml
@@ -12,6 +12,9 @@ services:
         arguments:
           - '@logger'
 
+    dizda.local_filesystem:
+        class: Symfony\Component\Filesystem\Filesystem
+
     dizda.cloudbackup.client.cloudapp:
         class: Dizda\CloudBackupBundle\Client\CloudAppClient
         arguments:
@@ -37,6 +40,8 @@ services:
         class: Dizda\CloudBackupBundle\Client\DropboxSdkClient
         arguments:
             - '%dizda_cloud_backup.cloud_storages%'
+            - '%dizda_cloud_backup.restore_folder%'
+            - '@dizda.local_filesystem'
         tags:
             -  { name: dizda.cloudbackup.client }
 
@@ -49,6 +54,9 @@ services:
 
     dizda.cloudbackup.client.gaufrette:
         class: Dizda\CloudBackupBundle\Client\GaufretteClient
+        arguments:
+            - '%dizda_cloud_backup.restore_folder%'
+            - '@dizda.local_filesystem'
         tags:
             -  { name: dizda.cloudbackup.client }
 
@@ -72,6 +80,7 @@ services:
         arguments:
             - '%dizda_cloud_backup.databases%'
             - '%dizda_cloud_backup.output_folder%'
+            - '%dizda_cloud_backup.restore_folder%'
         calls:
             - [ setTimeout, [ '%dizda_cloud_backup.timeout%' ] ]
         tags:
@@ -116,6 +125,17 @@ services:
             - '@dizda.cloudbackup.manager.processor'
             - '@event_dispatcher'
 
+    dizda.cloudbackup.manager.restore:
+        class: Dizda\CloudBackupBundle\Manager\RestoreManager
+        arguments:
+            - '@dizda.cloudbackup.manager.database'
+            - '@dizda.cloudbackup.manager.client'
+            - '@dizda.cloudbackup.manager.processor'
+            - '@event_dispatcher'
+            - '%dizda_cloud_backup.restore_folder%'
+            - '@dizda.cloudbackup.filesystem'
+            - '%dizda_cloud_backup.restore%'
+
     dizda.cloudbackup.manager.processor:
         class: Dizda\CloudBackupBundle\Manager\ProcessorManager
         arguments:
@@ -124,3 +144,38 @@ services:
             - '%dizda_cloud_backup.output_file_prefix%'
             - '%dizda_cloud_backup.processor%'
             - '%dizda_cloud_backup.folders%'
+            - '%dizda_cloud_backup.restore_folder%'
+
+    dizda.cloudbackup.filesystem:
+        class: Symfony\Component\Filesystem\Filesystem
+
+    dizda.cloudbackup.listener.log_restore_completed:
+        class: Dizda\CloudBackupBundle\Listener\LogRestoreCompletedListener
+        arguments:
+            - '@logger'
+        tags:
+            - { name: kernel.event_listener, event: dizda.cloudbackup.restore_completed, method: whenRestoreIsCompleted }
+
+    dizda.cloudbackup.listener.log_restore_failed:
+        class: Dizda\CloudBackupBundle\Listener\LogRestoreFailedListener
+        arguments:
+            - '@logger'
+        tags:
+            - { name: kernel.event_listener, event: dizda.cloudbackup.restore_failed, method: whenRestoreIsFailed }
+
+    dizda.cloudbackup.listener.clean_restore_workspace:
+        class: Dizda\CloudBackupBundle\Listener\CleanRestoreWorkspaceListener
+        arguments:
+            - '%dizda_cloud_backup.restore_folder%'
+            - '@dizda.cloudbackup.filesystem'
+        tags:
+            - { name: kernel.event_listener, event: dizda.cloudbackup.restore_completed, method: whenRestoreIsCompleted }
+            - { name: kernel.event_listener, event: dizda.cloudbackup.restore_failed, method: whenRestoreIsFailed }
+
+    dizda.cloudbackup.command.restore:
+        class: Dizda\CloudBackupBundle\Command\RestoreCommand
+        arguments:
+            - '%dizda_cloud_backup.restore%'
+            - '@dizda.cloudbackup.manager.restore'
+        tags:
+            - { name: console.command }
diff --git a/Tests/Client/GaufretteClientTest.php b/Tests/Client/GaufretteClientTest.php
new file mode 100644
index 0000000..8d6842b
--- /dev/null
+++ b/Tests/Client/GaufretteClientTest.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Dizda\CloudBackupBundle\Tests\Client;
+
+use Dizda\CloudBackupBundle\Client\GaufretteClient;
+use Gaufrette\File;
+use Gaufrette\Filesystem;
+use Symfony\Component\Filesystem\Filesystem as LocalFilesystem;
+
+class GaufretteClientTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     */
+    public function shouldDownloadAndSaveContentInANewFile()
+    {
+        $localFilesystemMock = $this->getMock(LocalFilesystem::class);
+        $localFilesystemMock->expects($this->once())->method('dumpFile')
+            ->with('/tmp/restore/db_2016-10-19.zip', 'foo bar');
+        $client = new GaufretteClient('/tmp/restore/', $localFilesystemMock);
+        $fileMock = $this
+            ->getMockBuilder(File::class)
+            ->disableOriginalConstructor()
+            ->setMethods(['getContent'])
+            ->getMock()
+        ;
+        $fileMock->method('getContent')->willReturn('foo bar');
+        $fileSystemMock = $this
+            ->getMockBuilder(Filesystem::class)
+            ->disableOriginalConstructor()
+            ->setMethods(['keys', 'get'])
+            ->getMock();
+        $fileSystemMock->method('keys')->willReturn(['db_2016-10-19.zip']);
+        $fileSystemMock->method('get')->with('db_2016-10-19.zip')->willReturn($fileMock);
+        $client->addFilesystem($fileSystemMock);
+
+        $file = $client->download();
+
+        $this->assertInstanceOf('\SplFileInfo', $file);
+        $this->assertEquals('/tmp/restore/db_2016-10-19.zip', $file->getPathname());
+    }
+
+    /**
+     * @test
+     * @expectedException \Dizda\CloudBackupBundle\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage Parameter "$restoreFolder" is not set.
+     */
+    public function throwExceptionIfRestoreFolderIsNotConfigured()
+    {
+        $client = new GaufretteClient(null, $this->getMock(LocalFilesystem::class));
+        $client->download();
+    }
+}
diff --git a/Tests/Database/MySQLTest.php b/Tests/Database/MySQLTest.php
index a93f209..cedf35e 100644
--- a/Tests/Database/MySQLTest.php
+++ b/Tests/Database/MySQLTest.php
@@ -36,7 +36,7 @@ public function shouldDumpAllDatabases()
                 'db_user'       => 'root',
                 'db_password'   => 'test',
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql->getCommand(), "mysqldump --defaults-extra-file=\"/tmp/backup/mysql/mysql.cnf\" --all-databases  > '/tmp/backup/mysql/all-databases.sql'");
         $this->checkConfigurationFileExistsAndValid('root', 'test', 'localhost', '3306');
@@ -56,7 +56,7 @@ public function shouldDumpSpecifiedDatabase()
                 'db_user'       => 'root',
                 'db_password'   => 'test',
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql1->getCommand(), "mysqldump --defaults-extra-file=\"/tmp/backup/mysql/mysql.cnf\" dizbdd  > '/tmp/backup/mysql/dizbdd.sql'");
         $this->checkConfigurationFileExistsAndValid('root', 'test', 'localhost', '3306');
@@ -70,7 +70,7 @@ public function shouldDumpSpecifiedDatabase()
                 'db_user'       => 'mysql',
                 'db_password'   => 'somepwd',
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql2->getCommand(), "mysqldump --defaults-extra-file=\"/tmp/backup/mysql/mysql.cnf\" somebdd  > '/tmp/backup/mysql/somebdd.sql'");
         $this->checkConfigurationFileExistsAndValid('mysql', 'somepwd', 'somehost', '2222');
@@ -85,7 +85,7 @@ public function shouldDumpSpecifiedDatabase()
                 'db_user'       => null,
                 'db_password'   => null,
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql->getCommand(), 'mysqldump --defaults-extra-file="/tmp/backup/mysql/mysql.cnf" somebdd  > \'/tmp/backup/mysql/somebdd.sql\'');
         $this->checkConfigurationFileExistsAndValid(null, null, 'somehost', '2222');
@@ -106,7 +106,7 @@ public function shouldDumpAllDatabasesWithNoAuth()
                 'db_user'       => null,
                 'db_password'   => null,
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql->getCommand(), 'mysqldump --defaults-extra-file="/tmp/backup/mysql/mysql.cnf" --all-databases  > \'/tmp/backup/mysql/all-databases.sql\'');
         $this->checkConfigurationFileExistsAndValid(null, null, 'somehost', '2222');
@@ -127,7 +127,7 @@ public function shouldIgnoreSpecifiedTablesForSpecifiedDatabase()
                 'db_password'   => 'test',
                 'ignore_tables' => array('table1', 'table2'),
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql->getCommand(), "mysqldump --defaults-extra-file=\"/tmp/backup/mysql/mysql.cnf\" dizbdd --ignore-table=dizbdd.table1 --ignore-table=dizbdd.table2  > '/tmp/backup/mysql/dizbdd.sql'");
         $this->checkConfigurationFileExistsAndValid('root', 'test', 'localhost', '3306');
@@ -148,7 +148,7 @@ public function shouldIgnoreSpecifiedTablesForAllDatabase()
                 'db_password'   => 'test',
                 'ignore_tables' => array('db1.table1', 'db2.table2'),
             ),
-        ), '/tmp/backup/');
+        ));
 
         $this->assertEquals($mysql->getCommand(), "mysqldump --defaults-extra-file=\"/tmp/backup/mysql/mysql.cnf\" --all-databases --ignore-table=db1.table1 --ignore-table=db2.table2  > '/tmp/backup/mysql/all-databases.sql'");
         $this->checkConfigurationFileExistsAndValid('root', 'test', 'localhost', '3306');
@@ -170,17 +170,86 @@ public function shouldThrowExceptionIfDatabaseIsNotSpecifiedForIgnoredTableDumpi
                 'db_password'   => 'test',
                 'ignore_tables' => array('table1'),
             ),
-        ), '/tmp/backup/');
+        ));
 
         $mysql->getCommand();
     }
+
+    /**
+     * @test
+     */
+    public function shouldReturnRestoreCommand()
+    {
+        $mysql = new MySQLDummy([
+            'mysql' => [
+                'all_databases' => false,
+                'db_host'       => 'localhost',
+                'db_port'       => 3306,
+                'database'      => 'dizbdd',
+                'db_user'       => 'root',
+                'db_password'   => null,
+            ],
+        ]);
+
+        $this->assertEquals('mysql -uroot dizbdd < \'/tmp/restore/mysql/dizbdd.sql\'', $mysql->getRestoreCommand());
+    }
+
+    /**
+     * @test
+     */
+    public function shouldReturnRestoreCommandWithPassword()
+    {
+        $mysql = new MySQLDummy([
+            'mysql' => [
+                'all_databases' => false,
+                'db_host'       => 'localhost',
+                'db_port'       => 3306,
+                'database'      => 'dizbdd',
+                'db_user'       => 'root',
+                'db_password'   => 'foobar',
+            ],
+        ]);
+
+        $this->assertEquals('mysql -uroot --password="foobar" dizbdd < \'/tmp/restore/mysql/dizbdd.sql\'', $mysql->getRestoreCommand());
+    }
+
+    /**
+     * @test
+     * @expectedException \Dizda\CloudBackupBundle\Exception\InvalidConfigurationException
+     * @expectedExceptionMessage Parameter "$restoreFolder" is not set.
+     */
+    public function throwExceptionIfRestoreFolderIsNotConfigured()
+    {
+        $mysql = new MySQLDummy([
+            'mysql' => [
+                'all_databases' => false,
+                'db_host'       => 'localhost',
+                'db_port'       => 3306,
+                'database'      => 'dizbdd',
+                'db_user'       => 'root',
+                'db_password'   => 'foobar',
+            ],
+        ], '/tmp/backup/', null);
+
+        $mysql->getRestoreCommand();
+    }
 }
 
 class MySQLDummy extends MySQL
 {
+    public function __construct(array $params, $basePath = '/tmp/backup/', $restoreFolder = '/tmp/restore/')
+    {
+        parent::__construct($params, $basePath, $restoreFolder);
+    }
+
     public function getCommand()
     {
         $this->prepareEnvironment();
         return parent::getCommand();
     }
+
+    public function getRestoreCommand()
+    {
+        return parent::getRestoreCommand();
+    }
 }
diff --git a/Tests/Manager/ClientManagerTest.php b/Tests/Manager/ClientManagerTest.php
new file mode 100644
index 0000000..6386ec3
--- /dev/null
+++ b/Tests/Manager/ClientManagerTest.php
@@ -0,0 +1,44 @@
+<?php
+namespace Dizda\CloudBackupBundle\Tests\Manager;
+
+use Dizda\CloudBackupBundle\Client\ClientInterface;
+use Dizda\CloudBackupBundle\Client\DownloadableClientInterface;
+use Dizda\CloudBackupBundle\Manager\ClientManager;
+use Psr\Log\LoggerInterface;
+
+class ClientManagerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     */
+    public function shouldExecuteDownloadForFirstDownloadableClient()
+    {
+        $clients = [];
+        $clients[] = $this->getMock(ClientInterface::class);
+        $clientMock = $this->getMock(DownloadableClientInterface::class);
+        $fileMock = $this
+            ->getMockBuilder(\SplFileInfo::class)
+            ->setConstructorArgs([tempnam(sys_get_temp_dir(), '')])
+            ->getMock();
+        $clientMock->expects($this->once())->method('download')->willReturn($fileMock);
+        $clients[] = $clientMock;
+
+        $clientManager = new ClientManager($this->getMock(LoggerInterface::class), $clients);
+        $this->assertSame($fileMock, $clientManager->download());
+    }
+
+    /**
+     * @test
+     * @expectedException \Dizda\CloudBackupBundle\Exception\MissingDownloadableClientsException
+     * @expectedExceptionMessage No downloadable client is registered.
+     */
+    public function shouldThrowExceptionIfNoChildIsADownloadableClient()
+    {
+        $clients = [];
+        $clients[] = $this->getMock(ClientInterface::class);
+        $clients[] = $this->getMock(ClientInterface::class);
+
+        $clientManager = new ClientManager($this->getMock(LoggerInterface::class), $clients);
+        $clientManager->download();
+    }
+}
diff --git a/Tests/Manager/RestoreManagerTest.php b/Tests/Manager/RestoreManagerTest.php
new file mode 100644
index 0000000..6a1a5e4
--- /dev/null
+++ b/Tests/Manager/RestoreManagerTest.php
@@ -0,0 +1,111 @@
+<?php
+namespace Dizda\CloudBackupBundle\Tests\Manager;
+
+
+use Dizda\CloudBackupBundle\Event\RestoreEvent;
+use Dizda\CloudBackupBundle\Event\RestoreFailedEvent;
+use Dizda\CloudBackupBundle\Manager\ClientManager;
+use Dizda\CloudBackupBundle\Manager\DatabaseManager;
+use Dizda\CloudBackupBundle\Manager\ProcessorManager;
+use Dizda\CloudBackupBundle\Manager\RestoreManager;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\Filesystem\Filesystem;
+
+class RestoreManagerTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @test
+     */
+    public function shouldRestoreDatabase()
+    {
+        $fileMock = $this
+            ->getMockBuilder(\SplFileInfo::class)
+            ->setConstructorArgs([tempnam(sys_get_temp_dir(), '')])
+            ->getMock();
+
+        $databaseManagerMock = $this->getMockBuilder(DatabaseManager::class)->disableOriginalConstructor()->getMock();
+        $databaseManagerMock->expects($this->once())->method('restore');
+        $clientManagerMock = $this->getMockBuilder(ClientManager::class)->disableOriginalConstructor()->getMock();
+        $clientManagerMock->expects($this->once())->method('download')->willReturn($fileMock);
+        $processorManagerMock = $this->getMockBuilder(ProcessorManager::class)->disableOriginalConstructor()->getMock();
+        $processorManagerMock->expects($this->once())->method('uncompress');
+        $eventDispatcherMock = $this->getMock(EventDispatcherInterface::class);
+        $eventDispatcherMock->expects($this->once())->method('dispatch')->with(RestoreEvent::RESTORE_COMPLETED);
+        $filesystemMock = $this->getMock(Filesystem::class);
+
+        $restoreManager = new RestoreManager(
+            $databaseManagerMock,
+            $clientManagerMock,
+            $processorManagerMock,
+            $eventDispatcherMock,
+            '',
+            $filesystemMock,
+            true
+        );
+
+        $restoreManager->execute();
+    }
+
+    /**
+     * @test
+     * @expectedException \Dizda\CloudBackupBundle\Exception\RestoringNotAvailableException
+     * @expectedExceptionMessage Restoring is not available.
+     */
+    public function shouldNotRestoreDatabase()
+    {
+        $databaseManagerMock = $this->getMockBuilder(DatabaseManager::class)->disableOriginalConstructor()->getMock();
+        $databaseManagerMock->expects($this->never())->method('restore');
+        $clientManagerMock = $this->getMockBuilder(ClientManager::class)->disableOriginalConstructor()->getMock();
+        $clientManagerMock->expects($this->never())->method('download');
+        $processorManagerMock = $this->getMockBuilder(ProcessorManager::class)->disableOriginalConstructor()->getMock();
+        $processorManagerMock->expects($this->never())->method('uncompress');
+        $eventDispatcherMock = $this->getMock(EventDispatcherInterface::class);
+        $eventDispatcherMock->expects($this->never())->method('dispatch');
+        $filesystemMock = $this->getMock(Filesystem::class);
+
+        $restoreManager = new RestoreManager(
+            $databaseManagerMock,
+            $clientManagerMock,
+            $processorManagerMock,
+            $eventDispatcherMock,
+            '',
+            $filesystemMock,
+            false
+        );
+
+        $restoreManager->execute();
+    }
+
+    /**
+     * @test
+     */
+    public function shouldDispachRestoreFailedEventIfExceptionOccur()
+    {
+        $databaseManagerMock = $this->getMockBuilder(DatabaseManager::class)->disableOriginalConstructor()->getMock();
+        $databaseManagerMock->expects($this->never())->method('restore');
+        $clientManagerMock = $this->getMockBuilder(ClientManager::class)->disableOriginalConstructor()->getMock();
+        $clientManagerMock->expects($this->never())->method('download');
+        $processorManagerMock = $this->getMockBuilder(ProcessorManager::class)->disableOriginalConstructor()->getMock();
+        $processorManagerMock->expects($this->never())->method('uncompress');
+        $eventDispatcherMock = $this->getMock(EventDispatcherInterface::class);
+        $eventDispatcherMock->expects($this->any())->method('dispatch')->with(
+            new \PHPUnit_Framework_Constraint_Not(RestoreEvent::RESTORE_COMPLETED)
+        );
+        $eventDispatcherMock->expects($this->once())->method('dispatch')->with(RestoreFailedEvent::RESTORE_FAILED);
+        $filesystemMock = $this->getMock(Filesystem::class);
+        $filesystemMock->expects($this->once())->method('mkdir')->will($this->throwException(new \Exception()));
+
+        $restoreManager = new RestoreManager(
+            $databaseManagerMock,
+            $clientManagerMock,
+            $processorManagerMock,
+            $eventDispatcherMock,
+            '',
+            $filesystemMock,
+            true
+        );
+
+        $restoreManager->execute();
+    }
+}
diff --git a/composer.json b/composer.json
index 71534f3..d2949f5 100644
--- a/composer.json
+++ b/composer.json
@@ -19,8 +19,8 @@
     ],
 
     "require": {
-        "php": "^5.4 || ^7.0",
-        "symfony/framework-bundle": "^2.1 || ^3.0",
+        "php": "^5.5 || ^7.0",
+        "symfony/framework-bundle": "^2.3 || ^3.0",
         "psr/log": "^1.0.1"
     },