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')])