def drop_dbs(self, db_list=None):
if not db_list:
db_list = []
db_list += [DB_TEMPLATE_1, DB_TEMPLATE_2, 'template_database']
for i in db_list:
if i in db.list_dbs():
db.exp_drop(i)
def new_dump_db(db_name, stream, backup_format='zip', anonymized=True):
if anonymized:
with RegistryManager.new(db_name).cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, {})
anon_query = env['ir.model.fields'].get_anonymization_query()
if not anon_query:
db._logger.info("No data to anonymize in database `%s`.", db_name)
else:
db._logger.info('Anonymize and dump database `%s`.', db_name)
anon_db_name = '%s_anon_%s' % (db_name,
time.strftime('%Y%m%d_%H%M%S'))
db.exp_duplicate_database(db_name, anon_db_name)
try:
if backup_format == 'zip':
# To avoid to archive filestore
# with non-anonymized attachments
anon_fs = tools.config.filestore(anon_db_name)
shutil.rmtree(anon_fs, ignore_errors=True)
with RegistryManager.new(anon_db_name).cursor() as cr:
db._logger.info('ANONYMIZE DB: %s', anon_db_name)
cr.execute(anon_query)
except Exception:
db.exp_drop(anon_db_name)
return NewDbDump(anon_db_name, stream, backup_format)
return native_dump_db(db_name, stream, backup_format)
def _drop_db(self, db_name):
if not self:
return
elif self.type != 'local':
raise NotImplementedError()
db.exp_drop(db_name)
def unlink(self):
db_to_remove = self.filtered(lambda s: s.ondelete_removedb).mapped(
'db_name')
res = super(StoreDatabaseList, self).unlink()
# if store delete then delete database related to store
for db_name in db_to_remove:
database.exp_drop(db_name)
return res
def restore(self):
self.ensure_one()
if not self.env.user._is_superuser() and not self.env.user.has_group('base.group_system'):
raise AccessError(_("Only administrators can change the settings"))
dbname = self._cr.dbname
restore_name = self.restore_name
request.session.logout()
request.disable_db = True
request._cr = None
exp_drop(dbname)
restore_db(dbname, restore_name)
return {
'type': 'ir.actions.act_url',
'url': '/web/login',
'target': 'self',
}
def delete_database(self):
for record in self:
db.exp_drop(self.name)
self.write({'state': 'deleted'})
def _drop_db(self, db_name):
for r in self:
if r.type != 'local':
continue
db.exp_drop(db_name)
def client_db_drop(self, db=None, **params):
if not service_db.exp_drop(db):
raise werkzeug.exceptions.Forbidden(
description="It is not allowed to drop database %s" % db)
return Response('OK', status=200)
def __next__(self):
try:
return next(self._iterator)
except StopIteration:
db.exp_drop(self._db_name)
raise
def drop_db(self, db_name):
db.exp_drop(db_name)
def restore_db(
self, admin_pass, db_name, file_path, file_name,
backups_state, remote_server=False, overwrite=False):
_logger.info(
"Starting restore process with data:\n"
"* db_name: %s\n"
"* file_path: %s\n"
"* file_name: %s\n"
"* backups_state: %s\n"
"* remote_server: %s\n" % (
db_name, file_path, file_name, backups_state, remote_server))
database_file = os.path.join(file_path, file_name)
if remote_server:
local_path = '/opt/odoo/backups/tmp/'
user_name = remote_server.get('user_name')
password = remote_server.get('password')
host_string = remote_server.get('host_string')
port = remote_server.get('port')
if not user_name or not password or not host_string or not port:
return {'error': (
'You need user_name, password, host_string'
'and port in order to use remote_server')}
env.user = user_name
env.password = password
env.host_string = host_string
env.port = port
_logger.info("Getting file '%s' from '%s:%s' with user %s" % (
database_file, host_string, port, user_name))
res = get(
remote_path=database_file,
local_path=local_path,
use_sudo=True)
if not res.succeeded:
return {'error': 'Could not copy file from remote server'}
database_file = os.path.join(local_path, file_name)
_logger.info(
"Restoring database %s from %s" % (db_name, database_file))
error = False
if overwrite:
if db_name not in db_ws.exp_list(True):
_logger.info(
"Overwrite argument passed but db %s not found, "
"avoiding db drop" % db_name)
else:
# if overwrite, then we delete actual db first
_logger.info(
"Overwrite argument passed, deleting db %s" % db_name)
if zipfile.is_zipfile(database_file):
# if zip, then we just use dropd
db_ws.exp_drop(db_name)
_logger.info("Db %s deleted completely" % db_name)
else:
# if not zip, we keep filestore
exp_drop_only_db(db_name)
_logger.info(
"Db %s deleted (only db, no filestore)" % db_name)
try:
_logger.info("Reading file for restore")
f = file(database_file, 'r')
data_b64 = base64.encodestring(f.read())
f.close()
except Exception as e:
error = (_(
'Unable to read file %s\n'
'This is what we get: \n %s') % (
database_file, e))
return {'error': error}
try:
_logger.info("Restoring....")
db_ws.exp_restore(db_name, data_b64)
except Exception as e:
# TODO ver si odoo arreglo esto si el error contiene "error 1" y
# no es un zip, entonces es un error de odoo pero que no es error
# en realidad
if not zipfile.is_zipfile(database_file):
_logger.info(
"We found an error restoring pg_dump but it seams to be an"
"Please check database created correctly. Error:\n%s" % (
e))
else:
error = (_(
'Unable to restore bd %s, this is what we get: \n %s') % (
db_name, e))
return {'error': error}
_logger.info("Databse %s restored succesfully!" % db_name)
# # disable or enable backups
# TODO unificar con la que esta en database
registry = odoo.modules.registry.Registry.get(db_name)
_logger.info("Disable/Enable Backups on %s!" % db_name)
with registry.cursor() as db_cr:
registry['ir.config_parameter'].set_param(
db_cr, 1, 'database.backups.enable', str(backups_state))
return {}
def test_template_operator(self):
# FIXME: that check needed when last tests didn't pass, not sure that it is correct way to drop db
if DB_TEMPLATE_1 in db.list_dbs():
db.exp_drop(DB_TEMPLATE_1)
if DB_TEMPLATE_2 in db.list_dbs():
db.exp_drop(DB_TEMPLATE_2)
if 'template_database' in db.list_dbs():
db.exp_drop('template_database')
# Template 1
self.saas_template_operator_1.preparing_template_next()
# Tests that template db created correctly
self.assertTrue(self.saas_template_operator_1.operator_db_id.name)
self.assertEqual(self.saas_template_operator_1.operator_db_id.name,
DB_TEMPLATE_1)
self.assertIn(DB_TEMPLATE_1, db.list_dbs())
self.assert_no_error_in_db(DB_TEMPLATE_1)
# Check that module from template_module_ids is installed
self.assert_modules_is_installed(DB_TEMPLATE_1, MODULE_TO_INSTALL)
self.assert_record_is_created(
DB_TEMPLATE_1, 'mail.message',
[('subject', '=', TEMPLATE_TEST_SUBJECT)])
# Template 2. Actually second template is done by calling preparing_template_next first time but that call
# is needed to emulate calling by crone every few minutes. This is done to make sure that the repeated method
# call does not cause errors.
self.saas_template_operator_2.preparing_template_next()
# Tests that template db created correctly
self.assertTrue(self.saas_template_operator_2.operator_db_id.name)
self.assertEqual(self.saas_template_operator_2.operator_db_id.name,
DB_TEMPLATE_2)
self.assertIn(DB_TEMPLATE_2, db.list_dbs())
self.assert_no_error_in_db(DB_TEMPLATE_2)
# Check that module from template_module_ids is installed
self.assert_modules_is_installed(DB_TEMPLATE_2, MODULE_TO_INSTALL)
self.assert_record_is_created(
DB_TEMPLATE_2, 'mail.message',
[('subject', '=', TEMPLATE_TEST_SUBJECT)])
# Check that database instance created correctly
if DB_INSTANCE_1 in db.list_dbs():
db.exp_drop(DB_INSTANCE_1)
if DB_INSTANCE_2 in db.list_dbs():
db.exp_drop(DB_INSTANCE_2)
self.saas_template_operator_1.create_db(DB_INSTANCE_1,
self.build_post_init_line_1)
self.assertIn(DB_INSTANCE_1, db.list_dbs())
self.assert_no_error_in_db(DB_INSTANCE_1)
self.assert_record_is_created(DB_INSTANCE_1, 'ir.config_parameter',
[('key', '=', 'auth_quick.master')])
self.assert_record_is_created(DB_INSTANCE_1, 'ir.config_parameter',
[('key', '=', 'auth_quick.build')])
self.assert_record_is_created(DB_INSTANCE_1, 'mail.message',
[('subject', '=', BUILD_TEST_SUBJECT)])
self.saas_template_operator_2.create_db(DB_INSTANCE_2,
self.build_post_init_line_2)
self.assertIn(DB_INSTANCE_2, db.list_dbs())
self.assert_no_error_in_db(DB_INSTANCE_2)
self.assert_record_is_created(DB_INSTANCE_2, 'ir.config_parameter',
[('key', '=', 'auth_quick.master')])
self.assert_record_is_created(DB_INSTANCE_2, 'ir.config_parameter',
[('key', '=', 'auth_quick.build')])
