def get_database(name, env):
query_params = {'name': name}
environments = Environment.prod_envs()\
if env in Environment.prod_envs() else Environment.dev_envs()
query_params['environment__name__in'] = environments
return Database.objects.filter(**query_params).exclude(
is_in_quarantine=True)[0]
def last_database_create(database_name, env):
"""This function returns the most recent DatabaseCreate's task.
Parameters:
database_name (str): Name of the database
env (str): It represents the database environment (prod or dev)
Returns:
DatabaseCreate: DatabaseCreate object
"""
environments = Environment.prod_envs()\
if env in Environment.prod_envs() else Environment.dev_envs()
return DatabaseCreate.objects.filter(
name=database_name, environment__name__in=environments).last()
def database_name_evironment_constraint(database_name, environment_name):
from logical.models import Database
from system.models import Configuration
databases = Database.objects.filter(name=database_name)
if not databases:
return False
dev_envs = Configuration.get_by_name_as_list('dev_envs')
if environment_name in dev_envs:
return False
prod_envs = Environment.prod_envs()
return any(
(database.environment.name in prod_envs for database in databases))
def get(self, request, format=None):
''' list all plans in the same
stage that environment
'''
if not validate_environment(request):
return Response("Invalid environment", status=403)
stage = Environment.DEV if\
get_url_env(request) in Environment.dev_envs() else\
Environment.PROD
hard_plans = Plan.objects.filter(
environments__stage=stage,
is_active=True,
environments__tsuru_deploy=True
).values(
'name', 'description',
'environments__name', 'environments__location_description'
)
return Response(get_plans_dict(hard_plans))
def validate_environment(request):
return get_url_env(request) in\
(list(Environment.prod_envs()) + list(Environment.dev_envs()))
def make_databases_backup(self):
LOG.info("Making databases backups")
worker_name = get_worker_name()
task_history = TaskHistory.register(
request=self.request, worker_name=worker_name, user=None
)
task_history.relevance = TaskHistory.RELEVANCE_ERROR
backup_group_interval = Configuration.get_by_name_as_int(
'backup_group_interval', default=1
)
waiting_msg = "\nWaiting {} minute(s) to start the next backup group".format(
backup_group_interval
)
status = TaskHistory.STATUS_SUCCESS
environments = Environment.objects.all()
prod_envs = Environment.prod_envs()
dev_envs = Environment.dev_envs()
env_names_order = list(prod_envs) + list(dev_envs)
if not env_names_order:
env_names_order = [env.name for env in environments]
current_time = datetime.now()
current_hour = current_time.hour
# Get all infras with a backup today until the current hour
infras_with_backup_today = DatabaseInfra.objects.filter(
instances__backup_instance__status=Snapshot.SUCCESS,
backup_hour__lt=current_hour,
plan__has_persistence=True,
instances__backup_instance__end_at__year=current_time.year,
instances__backup_instance__end_at__month=current_time.month,
instances__backup_instance__end_at__day=current_time.day).distinct()
# Get all infras with pending backups based on infras_with_backup_today
infras_pending_backup = DatabaseInfra.objects.filter(
backup_hour__lt=current_hour,
plan__has_persistence=True,
).exclude(pk__in=[infra.pk for infra in infras_with_backup_today])
# Get all infras to backup on the current hour
infras_current_hour = DatabaseInfra.objects.filter(
plan__has_persistence=True,
backup_hour=current_time.hour
)
# Merging pending and current infras to backup list
infras = infras_current_hour | infras_pending_backup
for env_name in env_names_order:
try:
env = environments.get(name=env_name)
except Environment.DoesNotExist:
continue
msg = '\nStarting Backup for env {}'.format(env.name)
task_history.update_details(persist=True, details=msg)
databaseinfras_by_env = infras.filter(environment=env)
error = {}
backup_number = 0
backups_per_group = len(infras) / 12
for infra in databaseinfras_by_env:
if not infra.databases.first():
continue
if backups_per_group > 0:
if backup_number < backups_per_group:
backup_number += 1
else:
backup_number = 0
task_history.update_details(waiting_msg, True)
sleep(backup_group_interval*60)
group = BackupGroup()
group.save()
instances_backup = infra.instances.filter(
read_only=False, is_active=True
)
for instance in instances_backup:
try:
driver = instance.databaseinfra.get_driver()
is_eligible = driver.check_instance_is_eligible_for_backup(
instance
)
if not is_eligible:
LOG.info(
'Instance {} is not eligible for backup'.format(
instance
)
)
continue
except Exception as e:
status = TaskHistory.STATUS_ERROR
msg = "Backup for %s was unsuccessful. Error: %s" % (
str(instance), str(e))
LOG.error(msg)
time_now = str(strftime("%m/%d/%Y %H:%M:%S"))
start_msg = "\n{} - Starting backup for {} ...".format(
time_now, instance
)
task_history.update_details(persist=True, details=start_msg)
try:
snapshot = make_instance_snapshot_backup(
instance=instance, error=error, group=group,
current_hour=current_hour
)
if snapshot and snapshot.was_successful:
msg = "Backup for %s was successful" % (str(instance))
LOG.info(msg)
elif snapshot and snapshot.was_error:
status = TaskHistory.STATUS_ERROR
msg = "Backup for %s was unsuccessful. Error: %s" % (
str(instance), error['errormsg'])
LOG.error(msg)
else:
status = TaskHistory.STATUS_WARNING
msg = "Backup for %s has warning" % (str(instance))
LOG.info(msg)
LOG.info(msg)
except Exception as e:
status = TaskHistory.STATUS_ERROR
msg = "Backup for %s was unsuccessful. Error: %s" % (
str(instance), str(e))
LOG.error(msg)
time_now = str(strftime("%m/%d/%Y %H:%M:%S"))
msg = "\n{} - {}".format(time_now, msg)
task_history.update_details(persist=True, details=msg)
task_history.update_status_for(status, details="\nBackup finished")
return
def is_k8s_env(self):
k8s_envs = Environment.k8s_envs()
return self.env_param in k8s_envs
def update_environment(self, data):
env_name = data.get('environment', '')
k8s_envs = Environment.k8s_envs()
env = Environment.objects.get(
name=env_name if env_name else k8s_envs[0])
data['environment'] = env
def stage(self):
return Environment.PROD if\
self.env_param in Environment.prod_envs() else\
Environment.DEV