def dump(ctx, db_name, s3_file):
config = (
ctx.obj['config']
)
from odooku.backends import get_backend
from odoo.api import Environment
from odoo.service.db import dump_db
s3_backend = get_backend('s3')
with tempfile.TemporaryFile() as t:
with Environment.manage():
dump_db(db_name, t)
t.seek(0)
if s3_file:
s3_backend.client.upload_fileobj(t, s3_backend.bucket, s3_file)
else:
# Pipe to stdout
while True:
chunk = t.read(CHUNK_SIZE)
if not chunk:
break
sys.stdout.write(chunk)
def dump_tmp(self):
"""Dump to a temp file and return it's location to the caller. Later,
copy the dump via scp, then clean_tmp.
"""
t = tempfile.NamedTemporaryFile(suffix='.zip',
prefix='odoo_',
delete=False)
dump_db(self.env.cr.dbname, t)
return t.name
def action_backup(self):
"""Run selected backups."""
backup = None
successful = self.browse()
# Start with local storage
for rec in self.filtered(lambda r: r.method == "local"):
filename = self.filename(datetime.now(), ext=rec.backup_format)
with rec.backup_log():
# Directory must exist
try:
os.makedirs(rec.folder)
except OSError:
pass
with open(os.path.join(rec.folder, filename), "wb") as destiny:
# Copy the cached backup
if backup:
with open(backup) as cached:
shutil.copyfileobj(cached, destiny)
# Generate new backup
else:
db.dump_db(self.env.cr.dbname,
destiny,
backup_format=rec.backup_format)
backup = backup or destiny.name
successful |= rec
# Ensure a local backup exists if we are going to write it remotely
sftp = self.filtered(lambda r: r.method == "sftp")
if sftp:
for rec in sftp:
filename = self.filename(datetime.now(), ext=rec.backup_format)
with rec.backup_log():
cached = db.dump_db(self.env.cr.dbname,
None,
backup_format=rec.backup_format)
with cached:
with rec.sftp_connection() as remote:
# Directory must exist
try:
remote.makedirs(rec.folder)
except pysftp.ConnectionException:
pass
# Copy cached backup to remote server
with remote.open(
os.path.join(rec.folder, filename),
"wb") as destiny:
shutil.copyfileobj(cached, destiny)
successful |= rec
# Remove old files for successful backups
successful.cleanup()
def action_backup(self):
"""Run selected backups."""
backup = None
filename = self.filename(datetime.now())
successful = self.browse()
# Start with local storage
for rec in self.filtered(lambda r: r.method == "local"):
with rec.backup_log():
# Directory must exist
try:
os.makedirs(rec.folder)
except OSError:
pass
with open(os.path.join(rec.folder, filename),
'wb') as destiny:
# Copy the cached backup
if backup:
with open(backup) as cached:
shutil.copyfileobj(cached, destiny)
# Generate new backup
else:
db.dump_db(self.env.cr.dbname, destiny)
backup = backup or destiny.name
successful |= rec
# Ensure a local backup exists if we are going to write it remotely
sftp = self.filtered(lambda r: r.method == "sftp")
if sftp:
if backup:
cached = open(backup)
else:
cached = db.dump_db(self.env.cr.dbname, None)
with cached:
for rec in sftp:
with rec.backup_log():
remote = rec.sftp_connection()
# Directory must exist
try:
remote.mkd(rec.folder)
except ftplib.Error:
pass
remote_path = os.path.join(rec.folder, filename)
res = remote.storbinary('STOR ' + remote_path, cached)
remote.close()
_logger.info("FTP STOR reply: %s", res)
successful |= rec
# Remove old files for successful backups
successful.cleanup()
def iterator():
with tempfile.TemporaryDirectory() as tmp_dir:
filename = tmp_dir + "/backup.zip"
with open(filename, "wb") as f:
dump_db(db_name, f)
with open(filename, "rb") as f:
f.seek(0)
while 1:
data = f.read(16 * 1024)
if not data:
break
yield data
def backup(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"))
if not self.backup_name:
return
self.backup_name = string.replace(self.backup_name,' ', '_')
file = open("%s/%s.zip" % (backup_dir,self.backup_name),"w", 0600)
dump_db(self._cr.dbname,file)
file.close()
def backup(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"))
if not self.backup_name:
return
self.backup_name = self.backup_name.replace(' ', '_')
with open("{}/{}.zip".format(backup_dir, self.backup_name), "wb",
0o600) as file:
dump_db(self._cr.dbname, file)
def client_db_backup(self, db=None, backup_format='zip', **params):
filename = "%s.%s" % (db, backup_format)
headers = [
('Content-Type', 'application/octet-stream; charset=binary'),
('Content-Disposition', http.content_disposition(filename)),
]
try:
stream = tempfile.TemporaryFile()
service_db.dump_db(db, stream, backup_format)
except exceptions.AccessDenied as e:
raise werkzeug.exceptions.Forbidden(description=str(e))
except Exception as e:
_logger.error("Cannot backup db %s", db, exc_info=True)
raise werkzeug.exceptions.InternalServerError(description=str(e))
else:
stream.seek(0)
response = werkzeug.wrappers.Response(stream,
headers=headers,
direct_passthrough=True)
return response
def action_backup(self):
backup = None
filename = self.filename(datetime.now())
successful = self.browse()
for rec in self:
with rec.backup_log():
# Directory must exist
try:
if not os.path.isdir(rec.folder):
os.makedirs(rec.folder)
except ValueError as err:
_LOGGER.exception('%s', err)
raise exceptions.ValidationError(
_('Backup directory must be set!'))
except OSError as err:
_LOGGER.exception('%s', err)
with open(os.path.join(rec.folder, filename), 'wb') as destiny:
# Copy the cached backup
if backup:
with open(backup, 'rb') as cached:
shutil.copyfileobj(cached, destiny)
# Generate new backup
else:
try:
db.dump_db(self.env.cr.dbname, destiny)
backup = backup or destiny.name
except IOError as err:
_LOGGER.exception('%s', err)
successful |= rec
# Remove old files for successful backups
successful.cleanup_old_backups()
return True
def test_exp_database_backup_restore(self):
dispatch_rpc('db', 'create_database', [
MASTER_PASSWORD, "muk_dms_file_create_db_test", False, "en",
"admin", "admin"
])
self.assertTrue('muk_dms_file_create_db_test' in db_list())
dump_stream = dump_db("muk_dms_file_create_db_test", None, 'zip')
with tempfile.NamedTemporaryFile(delete=False) as data_file:
data_file.write(dump_stream.read())
restore_db('muk_dms_file_restore_db_test', data_file.name, True)
self.assertTrue('muk_dms_file_restore_db_test' in db_list())
dispatch_rpc('db', 'drop',
[MASTER_PASSWORD, 'muk_dms_file_restore_db_test'])
dispatch_rpc('db', 'drop',
[MASTER_PASSWORD, 'muk_dms_file_create_db_test'])
self.assertTrue('muk_dms_file_create_db_test' not in db_list())
self.assertTrue('muk_dms_file_restore_db_test' not in db_list())
def action_backup(self):
db_name = self.env.cr.dbname
successful = self.browse()
for rec in self.filtered(
lambda r: r.active and r.nextcall == date.today()):
fname = "{:%Y_%m_%d_%H_%M_%S}-{}-backup.zip".format(
datetime.now(), db_name)
backup_file = db.dump_db(db_name, None)
try:
client = rec._get_client()
client.upload_fileobj(backup_file, rec.bucket_name,
'%s/%s' % (rec.folder, fname))
except ClientError as e:
logging.error(e)
finally:
rec.nextcall += _intervalTypes[rec.periodicity](
INTERVAL_NUMBER)
backup_file.close()
successful |= rec
successful.cleanup()
def dump_db(stream):
return db.dump_db(database_obj.name, stream)
def dump_db(stream):
return db.dump_db(database_obj.name, stream)
def dump_db(stream):
return db.dump_db(self.env.cr.dbname, stream)
def database_backup(self,
bu_type='manual',
backup_format='zip',
backup_name=False,
keep_till_date=False):
"""Returns a dictionary where:
* keys = database name
* value = dictionary with:
* key error and error as value
* key database and database name as value
"""
self.ensure_one()
now = datetime.now()
error = False
# check if bd exists
try:
if not db_ws.exp_db_exist(self.name):
error = "Database %s do not exist" % (self.name)
_logger.warning(error)
except Exception as e:
error = ("Could not check if database %s exists. "
"This is what we get:\n"
"%s" % (self.name, e))
_logger.warning(error)
else:
# crear path para backups si no existe
try:
if not os.path.isdir(self.backups_path):
os.makedirs(self.backups_path)
except Exception as e:
error = ("Could not create folder %s for backups. "
"This is what we get:\n"
"%s" % (self.backups_path, e))
_logger.warning(error)
else:
if not backup_name:
backup_name = '%s_%s_%s.%s' % (
self.name, bu_type, now.strftime('%Y%m%d_%H%M%S'),
backup_format)
backup_path = os.path.join(self.backups_path, backup_name)
if os.path.isfile(backup_path):
return {'error': "File %s already exists" % backup_path}
backup = open(backup_path, 'wb')
# backup
try:
db_ws.dump_db(self.name,
backup,
backup_format=backup_format)
except Exception as e:
error = ('Unable to dump self. '
'If you are working in an instance with '
'"workers" then you can try restarting service.\n'
'This is what we get: %s' % e)
_logger.warning(error)
backup.close()
else:
backup.close()
backup_vals = {
'database_id': self.id,
'name': backup_name,
'path': self.backups_path,
'date': now,
'type': bu_type,
'keep_till_date': keep_till_date,
}
self.backup_ids.create(backup_vals)
_logger.info('Backup %s Created' % backup_name)
if bu_type == 'automatic':
_logger.info('Reconfiguring next backup')
new_date = self.relative_delta(datetime.now(),
self.backup_interval,
self.backup_rule_type)
self.backup_next_date = new_date
# TODO check gdrive backup pat
if self.syncked_backup_path:
# so no existe el path lo creamos
try:
if not os.path.isdir(self.syncked_backup_path):
_logger.info('Creating syncked backup folder')
os.makedirs(self.syncked_backup_path)
except Exception as e:
error = ("Could not create folder %s for backups. "
"This is what we get:\n"
"%s" % (self.syncked_backup_path, e))
_logger.warning(error)
# now we copy the backup
_logger.info('Make backup a copy con syncked path')
try:
syncked_backup = os.path.join(
self.syncked_backup_path,
self.name + '.%s' % backup_format)
shutil.copy2(backup_path, syncked_backup)
except Exception as e:
error = ("Could not copy into syncked folder. "
"This is what we get:\n"
"%s" % (e))
_logger.warning(error)
if error:
return {'error': error}
else:
return {'backup_name': backup_name}
