mirror of
https://github.com/YunoHost/moulinette.git
synced 2024-09-03 20:06:31 +02:00
520 lines
19 KiB
Python
520 lines
19 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
""" License
|
|
|
|
Copyright (C) 2013 YunoHost
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published
|
|
by the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program; if not, see http://www.gnu.org/licenses
|
|
|
|
"""
|
|
|
|
""" yunohost_backup.py
|
|
|
|
Manage backups
|
|
"""
|
|
import os
|
|
import re
|
|
import sys
|
|
import json
|
|
import errno
|
|
import time
|
|
import tarfile
|
|
import shutil
|
|
import subprocess
|
|
from collections import OrderedDict
|
|
|
|
from moulinette.core import MoulinetteError
|
|
from moulinette.utils import filesystem
|
|
from moulinette.utils.log import getActionLogger
|
|
|
|
backup_path = '/home/yunohost.backup'
|
|
archives_path = '%s/archives' % backup_path
|
|
|
|
logger = getActionLogger('yunohost.backup')
|
|
|
|
|
|
def backup_create(name=None, description=None, output_directory=None,
|
|
no_compress=False, ignore_hooks=False, hooks=[],
|
|
ignore_apps=False, apps=[]):
|
|
"""
|
|
Create a backup local archive
|
|
|
|
Keyword arguments:
|
|
name -- Name of the backup archive
|
|
description -- Short description of the backup
|
|
output_directory -- Output directory for the backup
|
|
no_compress -- Do not create an archive file
|
|
hooks -- List of backup hooks names to execute
|
|
ignore_hooks -- Do not execute backup hooks
|
|
apps -- List of application names to backup
|
|
ignore_apps -- Do not backup apps
|
|
|
|
"""
|
|
# TODO: Add a 'clean' argument to clean output directory
|
|
from yunohost.hook import hook_callback, hook_exec
|
|
|
|
tmp_dir = None
|
|
|
|
# Validate what to backup
|
|
if ignore_hooks and ignore_apps:
|
|
raise MoulinetteError(errno.EINVAL,
|
|
m18n.n('backup_action_required'))
|
|
|
|
# Validate and define backup name
|
|
timestamp = int(time.time())
|
|
if not name:
|
|
name = str(timestamp)
|
|
if name in backup_list()['archives']:
|
|
raise MoulinetteError(errno.EINVAL,
|
|
m18n.n('backup_archive_name_exists'))
|
|
|
|
# Validate additional arguments
|
|
if no_compress and not output_directory:
|
|
raise MoulinetteError(errno.EINVAL,
|
|
m18n.n('backup_output_directory_required'))
|
|
if output_directory:
|
|
output_directory = os.path.abspath(output_directory)
|
|
|
|
# Check for forbidden folders
|
|
if output_directory.startswith(archives_path) or \
|
|
re.match(r'^/(|(bin|boot|dev|etc|lib|root|run|sbin|sys|usr|var)(|/.*))$',
|
|
output_directory):
|
|
logger.error("forbidden output directory '%'", output_directory)
|
|
raise MoulinetteError(errno.EINVAL,
|
|
m18n.n('backup_output_directory_forbidden'))
|
|
|
|
# Create the output directory
|
|
if not os.path.isdir(output_directory):
|
|
logger.info("creating output directory '%s'", output_directory)
|
|
os.makedirs(output_directory, 0750)
|
|
# Check that output directory is empty
|
|
elif no_compress and os.listdir(output_directory):
|
|
logger.error("not empty output directory '%'", output_directory)
|
|
raise MoulinetteError(errno.EIO,
|
|
m18n.n('backup_output_directory_not_empty'))
|
|
|
|
# Define temporary directory
|
|
if no_compress:
|
|
tmp_dir = output_directory
|
|
else:
|
|
output_directory = archives_path
|
|
|
|
# Create temporary directory
|
|
if not tmp_dir:
|
|
tmp_dir = "%s/tmp/%s" % (backup_path, name)
|
|
if os.path.isdir(tmp_dir):
|
|
logger.warning("temporary directory for backup '%s' already exists",
|
|
tmp_dir)
|
|
filesystem.rm(tmp_dir, recursive=True)
|
|
filesystem.mkdir(tmp_dir, 0750, parents=True, uid='admin')
|
|
|
|
def _clean_tmp_dir(retcode=0):
|
|
ret = hook_callback('post_backup_create', args=[tmp_dir, retcode])
|
|
if not ret['failed']:
|
|
filesystem.rm(tmp_dir, True, True)
|
|
else:
|
|
msignals.display(m18n.n('backup_cleaning_failed'), 'warning')
|
|
|
|
# Initialize backup info
|
|
info = {
|
|
'description': description or '',
|
|
'created_at': timestamp,
|
|
'apps': {},
|
|
'hooks': {},
|
|
}
|
|
|
|
# Run system hooks
|
|
if not ignore_hooks:
|
|
msignals.display(m18n.n('backup_running_hooks'))
|
|
hooks_ret = hook_callback('backup', hooks, args=[tmp_dir])
|
|
info['hooks'] = hooks_ret['succeed']
|
|
|
|
# Backup apps
|
|
if not ignore_apps:
|
|
from yunohost.app import app_info
|
|
|
|
# Filter applications to backup
|
|
apps_list = set(os.listdir('/etc/yunohost/apps'))
|
|
apps_filtered = set()
|
|
if apps:
|
|
for a in apps:
|
|
if a not in apps_list:
|
|
logger.warning("app '%s' not found", a)
|
|
msignals.display(m18n.n('unbackup_app', a), 'warning')
|
|
else:
|
|
apps_filtered.add(a)
|
|
else:
|
|
apps_filtered = apps_list
|
|
|
|
# Run apps backup scripts
|
|
tmp_script = '/tmp/backup_' + str(timestamp)
|
|
for app_id in apps_filtered:
|
|
app_setting_path = '/etc/yunohost/apps/' + app_id
|
|
|
|
tmp_app_dir = '{:s}/apps/{:s}'.format(tmp_dir, app_id)
|
|
|
|
# Check if the app has a backup script
|
|
app_script = app_setting_path + '/scripts/backup'
|
|
if not os.path.isfile(app_script):
|
|
logger.warning("backup script '%s' not found", app_script)
|
|
msignals.display(m18n.n('unbackup_app', app_id),
|
|
'warning')
|
|
continue
|
|
|
|
# Copy the app restore script
|
|
app_restore_script = app_setting_path + '/scripts/restore'
|
|
if os.path.isfile(app_script):
|
|
try:
|
|
filesystem.mkdir(tmp_app_dir, 0750, True, uid='admin')
|
|
shutil.copy(app_restore_script, tmp_app_dir)
|
|
except:
|
|
logger.exception("error while copying restore script of '%s'", app_id)
|
|
msignals.display(m18n.n('restore_app_copy_failed', app=app_id),
|
|
'warning')
|
|
else:
|
|
logger.warning("restore script '%s' not found", app_script)
|
|
msignals.display(m18n.n('unrestorable_app', app_id),
|
|
'warning')
|
|
|
|
tmp_app_bkp_dir = tmp_app_dir + '/backup'
|
|
msignals.display(m18n.n('backup_running_app_script', app_id))
|
|
try:
|
|
# Prepare backup directory for the app
|
|
filesystem.mkdir(tmp_app_bkp_dir, 0750, True, uid='admin')
|
|
shutil.copytree(app_setting_path, tmp_app_dir + '/settings')
|
|
|
|
# Copy app backup script in a temporary folder and execute it
|
|
subprocess.call(['install', '-Dm555', app_script, tmp_script])
|
|
hook_exec(tmp_script, args=[tmp_app_bkp_dir, app_id])
|
|
except:
|
|
logger.exception("error while executing backup of '%s'", app_id)
|
|
msignals.display(m18n.n('backup_app_failed', app=app_id),
|
|
'error')
|
|
# Cleaning app backup directory
|
|
shutil.rmtree(tmp_app_dir, ignore_errors=True)
|
|
else:
|
|
# Add app info
|
|
i = app_info(app_id)
|
|
info['apps'][app_id] = {
|
|
'version': i['version'],
|
|
'name': i['name'],
|
|
'description': i['description'],
|
|
}
|
|
finally:
|
|
filesystem.rm(tmp_script, force=True)
|
|
|
|
# Check if something has been saved
|
|
if ignore_hooks and not info['apps']:
|
|
_clean_tmp_dir(1)
|
|
raise MoulinetteError(errno.EINVAL, m18n.n('backup_nothings_done'))
|
|
|
|
# Create backup info file
|
|
with open("%s/info.json" % tmp_dir, 'w') as f:
|
|
f.write(json.dumps(info))
|
|
|
|
# Create the archive
|
|
if not no_compress:
|
|
msignals.display(m18n.n('backup_creating_archive'))
|
|
archive_file = "%s/%s.tar.gz" % (output_directory, name)
|
|
try:
|
|
tar = tarfile.open(archive_file, "w:gz")
|
|
except:
|
|
tar = None
|
|
|
|
# Create the archives directory and retry
|
|
if not os.path.isdir(archives_path):
|
|
os.mkdir(archives_path, 0750)
|
|
try:
|
|
tar = tarfile.open(archive_file, "w:gz")
|
|
except:
|
|
logger.exception("unable to open '%s' for writing "
|
|
"after creating directory '%s'",
|
|
archive_file, archives_path)
|
|
tar = None
|
|
else:
|
|
logger.exception("unable to open the archive '%s' for writing",
|
|
archive_file)
|
|
if tar is None:
|
|
_clean_tmp_dir(2)
|
|
raise MoulinetteError(errno.EIO,
|
|
m18n.n('backup_archive_open_failed'))
|
|
tar.add(tmp_dir, arcname='')
|
|
tar.close()
|
|
|
|
# Move info file
|
|
os.rename(tmp_dir + '/info.json',
|
|
'{:s}/{:s}.info.json'.format(archives_path, name))
|
|
|
|
# Clean temporary directory
|
|
if tmp_dir != output_directory:
|
|
_clean_tmp_dir()
|
|
|
|
msignals.display(m18n.n('backup_complete'), 'success')
|
|
|
|
# Return backup info
|
|
info['name'] = name
|
|
return { 'archive': info }
|
|
|
|
|
|
def backup_restore(name, hooks=[], apps=[], ignore_apps=False, ignore_hooks=False, force=False):
|
|
"""
|
|
Restore from a local backup archive
|
|
|
|
Keyword argument:
|
|
name -- Name of the local backup archive
|
|
hooks -- List of restoration hooks names to execute
|
|
apps -- List of application names to restore
|
|
ignore_apps -- Do not restore apps
|
|
force -- Force restauration on an already installed system
|
|
|
|
"""
|
|
from yunohost.hook import hook_add
|
|
from yunohost.hook import hook_callback
|
|
from yunohost.hook import hook_exec
|
|
|
|
# Retrieve and open the archive
|
|
info = backup_info(name)
|
|
archive_file = info['path']
|
|
try:
|
|
tar = tarfile.open(archive_file, "r:gz")
|
|
except:
|
|
logger.exception("unable to open the archive '%s' for reading",
|
|
archive_file)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_archive_open_failed'))
|
|
|
|
# Check temporary directory
|
|
tmp_dir = "%s/tmp/%s" % (backup_path, name)
|
|
if os.path.isdir(tmp_dir):
|
|
logger.warning("temporary directory for restoration '%s' already exists",
|
|
tmp_dir)
|
|
os.system('rm -rf %s' % tmp_dir)
|
|
|
|
# Extract the tarball
|
|
msignals.display(m18n.n('backup_extracting_archive'))
|
|
tar.extractall(tmp_dir)
|
|
tar.close()
|
|
|
|
# Retrieve backup info
|
|
try:
|
|
with open("%s/info.json" % tmp_dir, 'r') as f:
|
|
info = json.load(f)
|
|
except IOError:
|
|
logger.error("unable to retrieve backup info from '%s/info.json'",
|
|
tmp_dir)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
|
|
else:
|
|
logger.info("restoring from backup '%s' created on %s", name,
|
|
time.ctime(info['created_at']))
|
|
|
|
# Check if YunoHost is installed
|
|
if os.path.isfile('/etc/yunohost/installed'):
|
|
msignals.display(m18n.n('yunohost_already_installed'), 'warning')
|
|
if not force:
|
|
try:
|
|
# Ask confirmation for restoring
|
|
i = msignals.prompt(m18n.n('restore_confirm_yunohost_installed',
|
|
answers='y/N'))
|
|
except NotImplemented:
|
|
pass
|
|
else:
|
|
if i == 'y' or i == 'Y':
|
|
force = True
|
|
if not force:
|
|
raise MoulinetteError(errno.EEXIST, m18n.n('restore_failed'))
|
|
else:
|
|
from yunohost.tools import tools_postinstall
|
|
|
|
# Retrieve the domain from the backup
|
|
try:
|
|
with open("%s/yunohost/current_host" % tmp_dir, 'r') as f:
|
|
domain = f.readline().rstrip()
|
|
except IOError:
|
|
logger.error("unable to retrieve domain from '%s/yunohost/current_host'",
|
|
tmp_dir)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
|
|
|
|
logger.info("executing the post-install...")
|
|
tools_postinstall(domain, 'yunohost', True)
|
|
|
|
# Run hooks
|
|
if not ignore_hooks:
|
|
if hooks is None or len(hooks)==0:
|
|
hooks=info['hooks'].keys()
|
|
|
|
hooks_filtered=list(set(hooks) & set(info['hooks'].keys()))
|
|
hooks_unexecuted=set(hooks) - set(info['hooks'].keys())
|
|
for hook in hooks_unexecuted:
|
|
logger.warning("hook '%s' not in this backup", hook)
|
|
msignals.display(m18n.n('backup_hook_unavailable', hook), 'warning')
|
|
msignals.display(m18n.n('restore_running_hooks'))
|
|
hook_callback('restore', hooks_filtered, args=[tmp_dir])
|
|
|
|
# Add apps restore hook
|
|
if not ignore_apps:
|
|
# Filter applications to restore
|
|
apps_list = set(info['apps'].keys())
|
|
apps_filtered = set()
|
|
if not apps:
|
|
apps=apps_list
|
|
|
|
from yunohost.app import _is_installed
|
|
for app_id in apps:
|
|
if app_id not in apps_list:
|
|
logger.warning("app '%s' not found", app_id)
|
|
msignals.display(m18n.n('unrestore_app', app_id), 'warning')
|
|
elif _is_installed(app_id):
|
|
logger.warning("app '%s' already installed", app_id)
|
|
msignals.display(m18n.n('restore_already_installed_app', app=app_id), 'warning')
|
|
elif not os.path.isfile('{:s}/apps/{:s}/restore'.format(tmp_dir, app_id)):
|
|
logger.warning("backup for '%s' doesn't contain a restore script", app_id)
|
|
msignals.display(m18n.n('no_restore_script', app=app_id), 'warning')
|
|
else:
|
|
apps_filtered.add(app_id)
|
|
|
|
for app_id in apps_filtered:
|
|
app_bkp_dir='{:s}/apps/{:s}'.format(tmp_dir, app_id)
|
|
try:
|
|
# Copy app settings
|
|
app_setting_path = '/etc/yunohost/apps/' + app_id
|
|
shutil.copytree(app_bkp_dir + '/settings', app_setting_path )
|
|
|
|
# Execute app restore script
|
|
app_restore_script=app_bkp_dir+'/restore'
|
|
tmp_script = '/tmp/restore_%s_%s' % (name,app_id)
|
|
subprocess.call(['install', '-Dm555', app_restore_script, tmp_script])
|
|
hook_exec(tmp_script, args=[app_bkp_dir+'/backup', app_id])
|
|
|
|
except:
|
|
logger.exception("error while restoring backup of '%s'", app_id)
|
|
msignals.display(m18n.n('restore_app_failed', app=app_id),
|
|
'error')
|
|
# Cleaning settings directory
|
|
shutil.rmtree(app_setting_path + '/settings', ignore_errors=True)
|
|
|
|
|
|
# Remove temporary directory
|
|
os.system('rm -rf %s' % tmp_dir)
|
|
|
|
msignals.display(m18n.n('restore_complete'), 'success')
|
|
|
|
|
|
def backup_list(with_info=False, human_readable=False):
|
|
"""
|
|
List available local backup archives
|
|
|
|
Keyword arguments:
|
|
with_info -- Show backup information for each archive
|
|
human_readable -- Print sizes in human readable format
|
|
|
|
"""
|
|
result = []
|
|
|
|
try:
|
|
# Retrieve local archives
|
|
archives = os.listdir(archives_path)
|
|
except OSError as e:
|
|
logger.info("unable to iterate over local archives: %s", str(e))
|
|
else:
|
|
# Iterate over local archives
|
|
for f in archives:
|
|
try:
|
|
name = f[:f.rindex('.tar.gz')]
|
|
except ValueError:
|
|
continue
|
|
result.append(name)
|
|
result.sort()
|
|
|
|
if result and with_info:
|
|
d = OrderedDict()
|
|
for a in result:
|
|
d[a] = backup_info(a, human_readable=human_readable)
|
|
result = d
|
|
|
|
return { 'archives': result }
|
|
|
|
|
|
def backup_info(name, with_details=False, human_readable=False):
|
|
"""
|
|
Get info about a local backup archive
|
|
|
|
Keyword arguments:
|
|
name -- Name of the local backup archive
|
|
with_details -- Show additional backup information
|
|
human_readable -- Print sizes in human readable format
|
|
|
|
"""
|
|
from yunohost.monitor import binary_to_human
|
|
|
|
archive_file = '%s/%s.tar.gz' % (archives_path, name)
|
|
if not os.path.isfile(archive_file):
|
|
logger.error("no local backup archive found at '%s'", archive_file)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_archive_name_unknown',name))
|
|
|
|
info_file = "%s/%s.info.json" % (archives_path, name)
|
|
try:
|
|
with open(info_file) as f:
|
|
# Retrieve backup info
|
|
info = json.load(f)
|
|
except:
|
|
# TODO: Attempt to extract backup info file from tarball
|
|
logger.exception("unable to retrive backup info file '%s'",
|
|
info_file)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_invalid_archive'))
|
|
|
|
size = os.path.getsize(archive_file)
|
|
if human_readable:
|
|
size = binary_to_human(size) + 'B'
|
|
|
|
result = {
|
|
'path': archive_file,
|
|
'created_at': time.strftime(m18n.n('format_datetime_short'),
|
|
time.gmtime(info['created_at'])),
|
|
'description': info['description'],
|
|
'size': size,
|
|
}
|
|
|
|
if with_details:
|
|
for d in ['apps', 'hooks']:
|
|
result[d] = info[d]
|
|
return result
|
|
|
|
|
|
def backup_delete(name):
|
|
"""
|
|
Delete a backup
|
|
|
|
Keyword arguments:
|
|
name -- Name of the local backup archive
|
|
|
|
"""
|
|
from yunohost.hook import hook_callback
|
|
hook_callback('pre_backup_delete', args=[name])
|
|
|
|
archive_file = '%s/%s.tar.gz' % (archives_path, name)
|
|
|
|
info_file = "%s/%s.info.json" % (archives_path, name)
|
|
for backup_file in [archive_file,info_file]:
|
|
if not os.path.isfile(backup_file):
|
|
logger.error("no local backup archive found at '%s'", backup_file)
|
|
raise MoulinetteError(errno.EIO, m18n.n('backup_archive_name_unknown', backup_file))
|
|
try:
|
|
os.remove(backup_file)
|
|
except:
|
|
logger.exception("unable to delete '%s'", backup_file)
|
|
raise MoulinetteError(errno.EIO,
|
|
m18n.n('backup_delete_error',backup_file))
|
|
|
|
hook_callback('post_backup_delete', args=[name])
|
|
|
|
msignals.display(m18n.n('backup_deleted'), 'success')
|