def database(self):
from logical.models import Database
if self.infra.databases.exists():
return self.infra.databases.first()
database = Database()
database.name = self.infra.databases_create.last().name
return database
def _disk_resize(request, database):
try:
check_is_database_enabled(database.id, 'disk resize')
except DisabledDatabase as err:
messages.add_message(request, messages.ERROR, err.message)
return
disk_offering = DiskOffering.objects.get(
id=request.POST.get('disk_offering')
)
current_used = round(database.used_size_in_gb, 2)
offering_size = round(disk_offering.size_gb(), 2)
if current_used >= offering_size:
messages.add_message(
request, messages.ERROR,
'Your database has {} GB, please choose a bigger disk'.format(
current_used
)
)
return
Database.disk_resize(
database=database,
new_disk_offering=disk_offering.id,
user=request.user
)
def database_disk_resize_view(self, request, database_id):
try:
database = check_is_database_enabled(database_id, 'disk resize')
offerings = DiskOffering.objects.all().exclude(
id=database.databaseinfra.disk_offering.id)
check_resize_options(database_id, offerings)
except (DisabledDatabase, NoResizeOption) as err:
self.message_user(request, err.message, messages.ERROR)
return HttpResponseRedirect(err.url)
form = None
if request.method == 'POST':
form = DiskResizeDatabaseForm(database=database, data=request.POST)
if form.is_valid():
Database.disk_resize(
database=database,
new_disk_offering=request.POST.get('target_offer'),
user=request.user)
url = reverse('admin:notification_taskhistory_changelist')
return HttpResponseRedirect("{}?user={}".format(
url, request.user.username))
else:
form = DiskResizeDatabaseForm(database=database)
return render_to_response("logical/database/disk_resize.html",
locals(),
context_instance=RequestContext(request))
def test_create_database(self):
database = Database(name="blabla", databaseinfra=self.databaseinfra,
environment=self.environment)
database.save()
self.assertTrue(database.pk)
def test_create_database(self):
database = Database(name="blabla", databaseinfra=self.databaseinfra,
environment=self.environment)
database.save()
self.assertTrue(database.pk)
def _disk_resize(request, database):
try:
check_is_database_enabled(database.id, 'disk resize')
except DisabledDatabase as err:
messages.add_message(request, messages.ERROR, err.message)
return
disk_offering = DiskOffering.objects.get(
id=request.POST.get('disk_offering')
)
current_used = round(database.used_size_in_gb, 2)
offering_size = round(disk_offering.size_gb(), 2)
if current_used >= offering_size:
messages.add_message(
request, messages.ERROR,
'Your database has {} GB, please choose a bigger disk'.format(
current_used
)
)
return
Database.disk_resize(
database=database,
new_disk_offering=disk_offering.id,
user=request.user
)
def database(self):
from logical.models import Database
if self.infra.databases.exists():
return self.infra.databases.first()
database = Database()
step_manager = self.infra.databases_create.last()
database.name = (step_manager.name
if step_manager else self.step_manager.name)
return database
def _clone_database(request, database):
can_be_cloned, error = database.can_be_cloned()
if error:
messages.add_message(request, messages.ERROR, error)
return
if 'clone_name' not in request.POST:
messages.add_message(request, messages.ERROR, 'Destination is required')
return
if 'clone_env' not in request.POST:
messages.add_message(request, messages.ERROR, 'Environment is required')
return
if 'clone_plan' not in request.POST:
messages.add_message(request, messages.ERROR, 'Plan is required')
return
name = request.POST['clone_name']
environment = Environment.objects.get(id=request.POST['clone_env'])
plan = Plan.objects.get(id=request.POST['clone_plan'])
current = len(database.team.databases_in_use_for(environment))
if current >= database.team.database_alocation_limit:
messages.add_message(
request, messages.ERROR,
'The database allocation limit of %s has been exceeded for the '
'team: {} => {}'.format(
current, database.team.database_alocation_limit
)
)
return
if name in database.infra.get_driver().RESERVED_DATABASES_NAME:
messages.add_message(
request, messages.ERROR,
'{} is a reserved database name'.format(name)
)
return
if len(name) > 40:
messages.add_message(request, messages.ERROR, 'Database name too long')
return
if Database.objects.filter(name=name, environment=environment):
messages.add_message(
request, messages.ERROR,
'There is already a database called {} on {}'.format(
name, environment
)
)
return
Database.clone(
database=database, clone_name=name, plan=plan,
environment=environment, user=request.user
)
def _clone_database(request, database):
can_be_cloned, error = database.can_be_cloned()
if error:
messages.add_message(request, messages.ERROR, error)
return
if 'clone_name' not in request.POST:
messages.add_message(request, messages.ERROR, 'Destination is required')
return
if 'clone_env' not in request.POST:
messages.add_message(request, messages.ERROR, 'Environment is required')
return
if 'clone_plan' not in request.POST:
messages.add_message(request, messages.ERROR, 'Plan is required')
return
name = request.POST['clone_name']
environment = Environment.objects.get(id=request.POST['clone_env'])
plan = Plan.objects.get(id=request.POST['clone_plan'])
current = len(database.team.databases_in_use_for(environment))
if current >= database.team.database_alocation_limit:
messages.add_message(
request, messages.ERROR,
'The database allocation limit of %s has been exceeded for the '
'team: {} => {}'.format(
current, database.team.database_alocation_limit
)
)
return
if name in database.infra.get_driver().RESERVED_DATABASES_NAME:
messages.add_message(
request, messages.ERROR,
'{} is a reserved database name'.format(name)
)
return
if len(name) > 40:
messages.add_message(request, messages.ERROR, 'Database name too long')
return
if Database.objects.filter(name=name, environment=environment):
messages.add_message(
request, messages.ERROR,
'There is already a database called {} on {}'.format(
name, environment
)
)
return
Database.clone(
database=database, clone_name=name, plan=plan,
environment=environment, user=request.user
)
def test_create_duplicate_database_error(self):
database = Database(name="bleble", databaseinfra=self.databaseinfra,
environment=self.environment)
database.save()
self.assertTrue(database.pk)
self.assertRaises(IntegrityError, Database(name="bleble",
databaseinfra=self.databaseinfra,
environment=self.environment).save)
def _restore_database(request, database):
can_be_restored, error = database.can_be_restored()
if error:
messages.add_message(request, messages.ERROR, error)
return
if 'restore_snapshot' not in request.POST:
messages.add_message(request, messages.ERROR, 'Snapshot is required')
return
snapshot = request.POST.get('restore_snapshot')
Database.restore(database=database, snapshot=snapshot, user=request.user)
def _restore_database(request, database):
can_be_restored, error = database.can_be_restored()
if error:
messages.add_message(request, messages.ERROR, error)
return
if 'restore_snapshot' not in request.POST:
messages.add_message(request, messages.ERROR, 'Snapshot is required')
return
snapshot = request.POST.get('restore_snapshot')
Database.restore(database=database, snapshot=snapshot, user=request.user)
def test_create_duplicate_database_error(self):
database = Database(name="bleble", databaseinfra=self.databaseinfra,
environment=self.environment)
database.save()
self.assertTrue(database.pk)
self.assertRaises(IntegrityError, Database(name="bleble",
databaseinfra=self.databaseinfra,
environment=self.environment).save)
def _vm_resize(request, database):
try:
check_is_database_dead(database.id, 'VM resize')
check_is_database_enabled(database.id, 'VM resize')
except DisabledDatabase as err:
messages.add_message(request, messages.ERROR, err.message)
else:
offering = Offering.objects.get(id=request.POST.get('vm_offering'))
Database.resize(
database=database,
offering=offering,
user=request.user,
)
def database_resize_view(self, request, database_id):
try:
check_is_database_dead(database_id, 'VM resize')
database = check_is_database_enabled(database_id, 'VM resize')
from dbaas_cloudstack.models import CloudStackPack
offerings = CloudStackPack.objects.filter(
offering__region__environment=database.environment,
engine_type__name=database.engine_type).exclude(
offering__serviceofferingid=database.offering_id)
check_resize_options(database_id, offerings)
except (DisabledDatabase, NoResizeOption) as err:
self.message_user(request, err.message, messages.ERROR)
return HttpResponseRedirect(err.url)
form = None
if request.method == 'POST': # If the form has been submitted...
form = ResizeDatabaseForm(
request.POST,
initial={
"database_id": database_id,
"original_offering_id": database.offering_id
},
) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
cloudstackpack = CloudStackPack.objects.get(
id=request.POST.get('target_offer'))
Database.resize(
database=database,
cloudstackpack=cloudstackpack,
user=request.user,
)
url = reverse('admin:notification_taskhistory_changelist')
# Redirect after POST
return HttpResponseRedirect(url +
"?user=%s" % request.user.username)
else:
form = ResizeDatabaseForm(initial={
"database_id":
database_id,
"original_offering_id":
database.offering_id
}, ) # An unbound form
return render_to_response("logical/database/resize.html",
locals(),
context_instance=RequestContext(request))
def _vm_resize(request, database):
try:
check_is_database_dead(database.id, 'VM resize')
check_is_database_enabled(database.id, 'VM resize')
except DisabledDatabase as err:
messages.add_message(request, messages.ERROR, err.message)
else:
cloudstack_pack = CloudStackPack.objects.get(
id=request.POST.get('vm_offering'))
Database.resize(
database=database,
cloudstackpack=cloudstack_pack,
user=request.user,
)
def _vm_resize(request, database):
try:
check_is_database_dead(database.id, 'VM resize')
check_is_database_enabled(database.id, 'VM resize')
except DisabledDatabase as err:
messages.add_message(request, messages.ERROR, err.message)
else:
offering = Offering.objects.get(
id=request.POST.get('vm_offering')
)
Database.resize(
database=database,
offering=offering,
user=request.user,
)
def clone_infra(plan, environment, name, team, project, description, task=None, clone=None):
if not plan.provider == plan.CLOUDSTACK:
dbinfra = DatabaseInfra.best_for(
plan=plan, environment=environment, name=name)
if dbinfra:
database = Database.provision(databaseinfra=dbinfra, name=name)
database.team = team
database.description = description
database.project = project
database.save()
return build_dict(databaseinfra=dbinfra, database=database, created=True)
return build_dict(databaseinfra=None, created=False)
workflow_dict = build_dict(name=slugify(name),
plan=plan,
environment=environment,
steps=get_clone_settings(plan.engine_type.name),
qt=get_vm_qt(plan=plan, ),
dbtype=str(plan.engine_type),
team=team,
project=project,
description=description,
clone=clone
)
start_workflow(workflow_dict=workflow_dict, task=task)
return workflow_dict
def do(self, workflow_dict):
try:
if not workflow_dict['team'] or not workflow_dict[
'description'] or not workflow_dict['databaseinfra']:
return False
LOG.info("Creating Database...")
database = Database.provision(
name=workflow_dict['name'],
databaseinfra=workflow_dict['databaseinfra'])
LOG.info("Database %s created!" % database)
workflow_dict['database'] = database
LOG.info("Updating database team")
database.team = workflow_dict['team']
if 'project' in workflow_dict:
LOG.info("Updating database project")
database.project = workflow_dict['project']
LOG.info("Updating database description")
database.description = workflow_dict['description']
database.save()
return True
except Exception, e:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0003)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def make_infra(
plan, environment, name, team, project, description,
subscribe_to_email_events=True, task=None, is_protected=False
):
if not plan.provider == plan.CLOUDSTACK:
dbinfra = DatabaseInfra.best_for(
plan=plan, environment=environment, name=name
)
if dbinfra:
database = Database.provision(databaseinfra=dbinfra, name=name)
database.team = team
database.description = description
database.project = project
database.subscribe_to_email_events = subscribe_to_email_events
database.save()
return build_dict(
databaseinfra=dbinfra, database=database, created=True
)
return build_dict(databaseinfra=None, created=False)
workflow_dict = build_dict(
name=slugify(name), plan=plan, environment=environment,
steps=get_deploy_settings(
plan.replication_topology.class_path
), qt=get_vm_qt(plan=plan, ), dbtype=str(plan.engine_type),
team=team, project=project, description=description,
subscribe_to_email_events=subscribe_to_email_events,
is_protected=is_protected
)
start_workflow(workflow_dict=workflow_dict, task=task)
return workflow_dict
def clone_infra(plan, environment, name, team, project, description, task=None, clone=None):
if not plan.provider == plan.CLOUDSTACK:
dbinfra = DatabaseInfra.best_for(plan= plan, environment= environment, name= name)
if dbinfra:
database = Database.provision(databaseinfra=dbinfra, name=name)
database.team = team
database.description = description
database.project = project
database.save()
return build_dict(databaseinfra= dbinfra, database= database, created= True)
return build_dict(databaseinfra=None, created= False)
workflow_dict = build_dict(name= slugify(name),
plan= plan,
environment= environment,
steps= get_clone_settings(plan.engine_type.name),
qt= get_vm_qt(plan= plan, ),
dbtype = str(plan.engine_type),
team= team,
project= project,
description= description,
clone= clone
)
start_workflow(workflow_dict= workflow_dict, task=task)
return workflow_dict
def do(self, workflow_dict):
try:
if not workflow_dict['team'] or not workflow_dict['description'] or not workflow_dict['databaseinfra']:
return False
LOG.info("Creating Database...")
database = Database.provision(name=workflow_dict['name'], databaseinfra=workflow_dict['databaseinfra'])
LOG.info("Database %s created!" % database)
workflow_dict['database'] = database
LOG.info("Updating database team")
database.team = workflow_dict['team']
if 'project' in workflow_dict:
LOG.info("Updating database project")
database.project = workflow_dict['project']
LOG.info("Updating database description")
database.description = workflow_dict['description']
database.save()
return True
except Exception, e:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0003)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def create_database(self, name, plan, environment, team, project, description, user=None):
# register History
task_history = TaskHistory.register(request=self.request, user=user)
LOG.info("id: %s | task: %s | kwargs: %s | args: %s" % (
self.request.id, self.request.task, self.request.kwargs, str(self.request.args)))
task_history.update_details(persist=True, details="Loading Process...")
result = make_infra(plan=plan, environment=environment, name=name, task=task_history)
if result['created']==False:
if 'exceptions' in result:
error = "\n\n".join(": ".join(err) for err in result['exceptions']['error_codes'])
traceback = "\nException Traceback\n".join(result['exceptions']['traceback'])
error = "{}\n{}".format(error, traceback)
else:
error = "There is not any infra-structure to allocate this database."
task_history.update_status_for(TaskHistory.STATUS_ERROR, details=error)
return
database = Database.provision(name, result['databaseinfra'])
database.team = team
database.project = project
database.description = description
database.save()
task_history.update_dbid(db=database)
task_history.update_status_for(TaskHistory.STATUS_SUCCESS, details='Database created successfully')
return
def clone_infra(plan,
environment,
name,
team,
backup_hour,
maintenance_window,
maintenance_day,
project,
description,
subscribe_to_email_events,
task=None,
clone=None):
if not plan.provider == plan.CLOUDSTACK:
infra = DatabaseInfra.best_for(
plan=plan,
environment=environment,
name=name,
backup_hour=backup_hour,
maintenance_window=maintenance_window,
maintenance_day=maintenance_day,
)
if infra:
database = Database.provision(databaseinfra=infra, name=name)
database.team = team
database.description = description
database.project = project
database.save()
return build_dict(
databaseinfra=infra,
database=database,
created=True,
subscribe_to_email_events=subscribe_to_email_events)
return build_dict(databaseinfra=None,
created=False,
subscribe_to_email_events=subscribe_to_email_events)
workflow_dict = build_dict(
name=slugify(name),
plan=plan,
environment=environment,
steps=get_clone_settings(plan.replication_topology.class_path),
qt=get_vm_qt(plan=plan),
dbtype=str(plan.engine_type),
team=team,
backup_hour=backup_hour,
maintenance_window=maintenance_window,
maintenance_day=maintenance_day,
project=project,
description=description,
clone=clone,
subscribe_to_email_events=subscribe_to_email_events,
)
start_workflow(workflow_dict=workflow_dict, task=task)
return workflow_dict
def clone_view(self, request, database_id):
database = Database.objects.get(id=database_id)
can_be_cloned, error = database.can_be_cloned()
if not can_be_cloned:
self.message_user(request, error, level=messages.ERROR)
url = reverse('admin:logical_database_changelist')
return HttpResponseRedirect(url)
if database.is_beeing_used_elsewhere():
self.message_user(
request,
"Database cannot be cloned because it is in use by another task.",
level=messages.ERROR)
url = reverse('admin:logical_database_changelist')
return HttpResponseRedirect(url)
form = None
if request.method == 'POST': # If the form has been submitted...
# A form bound to the POST data
form = CloneDatabaseForm(request.POST)
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
database_clone = form.cleaned_data['database_clone']
plan = form.cleaned_data['plan']
environment = form.cleaned_data['environment']
Database.clone(database=database,
clone_name=database_clone,
plan=plan,
environment=environment,
user=request.user)
url = reverse('admin:notification_taskhistory_changelist')
# Redirect after POST
return HttpResponseRedirect(url +
"?user=%s" % request.user.username)
else:
form = CloneDatabaseForm(
initial={"origin_database_id": database_id}) # An unbound form
return render_to_response("logical/database/clone.html",
locals(),
context_instance=RequestContext(request))
def create_database(self, name, plan, environment, team, project, description, user=None):
# register History
AuditRequest.new_request("create_database", self.request.args[-1], "localhost")
try:
task_history = TaskHistory.register(request=self.request, user=user)
LOG.info("id: %s | task: %s | kwargs: %s | args: %s" % (
self.request.id, self.request.task, self.request.kwargs, str(self.request.args)))
task_history.update_details(persist=True, details="Loading Process...")
result = make_infra(plan=plan, environment=environment, name=name, task=task_history)
if result['created']==False:
if 'exceptions' in result:
error = "\n".join(": ".join(err) for err in result['exceptions']['error_codes'])
traceback = "\nException Traceback\n".join(result['exceptions']['traceback'])
error = "{}\n{}\n{}".format(error, traceback, error)
else:
error = "There is not any infra-structure to allocate this database."
task_history.update_status_for(TaskHistory.STATUS_ERROR, details=error)
return
database = Database.provision(name, result['databaseinfra'])
database.team = team
database.project = project
database.description = description
database.save()
task_history.update_dbid(db=database)
from util import laas
#laas.register_database_laas(database)
task_history.update_status_for(TaskHistory.STATUS_SUCCESS, details='Database created successfully')
return
except Exception, e:
traceback = full_stack()
LOG.error("Ops... something went wrong: %s" % e)
LOG.error(traceback)
if 'database' in locals() and database.id:
task_history.update_status_for(TaskHistory.STATUS_WARNING, details=traceback)
else:
if 'result' in locals() and result['created']:
destroy_infra(databaseinfra = result['databaseinfra'])
task_history.update_status_for(TaskHistory.STATUS_ERROR, details=traceback)
return
def do(self, workflow_dict):
try:
team_nin_wfd = 'team' not in workflow_dict
description_nin_wfd = 'description' not in workflow_dict
dbinfra_nin_wfd = 'databaseinfra' not in workflow_dict
if team_nin_wfd or description_nin_wfd or dbinfra_nin_wfd:
return False
LOG.info("Creating Database...")
database = Database.provision(
name=workflow_dict['name'],
databaseinfra=workflow_dict['databaseinfra'])
LOG.info("Database {} created!".format(database))
LOG.info("Updating database team")
database.team = workflow_dict['team']
if 'project' in workflow_dict:
LOG.info("Updating database project")
database.project = workflow_dict['project']
LOG.info("Updating database description")
database.description = workflow_dict['description']
LOG.info("Updating database subscribe_to_email_events")
database.subscribe_to_email_events = workflow_dict[
'subscribe_to_email_events']
LOG.info("Updating database contacts")
database.contacts = workflow_dict['contacts']
database.save()
workflow_dict['database'] = database
driver = workflow_dict['databaseinfra'].get_driver()
if driver.check_status():
LOG.info("Database is ok...")
database.status = database.ALIVE
database.save()
return True
except Exception:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0003)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def do(self):
creating = self.creating
if creating.database:
return
database = Database.provision(creating.name, self.infra)
database.team = creating.team
database.description = creating.description
database.subscribe_to_email_events = creating.subscribe_to_email_events
database.is_protected = creating.is_protected
if creating.project:
database.project = creating.project
database.save()
creating.database = database
creating.save()
def do(self, workflow_dict):
try:
if 'team' not in workflow_dict or \
'description' not in workflow_dict or \
'databaseinfra' not in workflow_dict:
return False
LOG.info("Creating Database...")
database = Database.provision(
name=workflow_dict['name'],
databaseinfra=workflow_dict['databaseinfra'])
LOG.info("Database %s created!" % database)
LOG.info("Updating database team")
database.team = workflow_dict['team']
if 'project' in workflow_dict:
LOG.info("Updating database project")
database.project = workflow_dict['project']
LOG.info("Updating database description")
database.description = workflow_dict['description']
database.save()
workflow_dict['database'] = database
driver = workflow_dict['databaseinfra'].get_driver()
if driver.check_status():
LOG.info("Database is ok...")
database.status = database.ALIVE
database.save()
return True
except Exception:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0003)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def do(self):
creating = self.create
if creating.database:
return
database = Database.provision(creating.name, self.infra)
database.team = creating.team
database.description = creating.description
database.subscribe_to_email_events = creating.subscribe_to_email_events
database.is_protected = creating.is_protected
if creating.project:
database.project = creating.project
database.save()
creating.database = database
creating.save()
database.pin_task(self.create.task)
def do(self, workflow_dict):
try:
if 'team' not in workflow_dict or \
'description' not in workflow_dict or \
'databaseinfra' not in workflow_dict:
return False
LOG.info("Creating Database...")
database = Database.provision(name=workflow_dict['name'], databaseinfra=workflow_dict['databaseinfra'])
LOG.info("Database %s created!" % database)
LOG.info("Updating database team")
database.team = workflow_dict['team']
if 'project' in workflow_dict:
LOG.info("Updating database project")
database.project = workflow_dict['project']
LOG.info("Updating database description")
database.description = workflow_dict['description']
database.save()
workflow_dict['database'] = database
driver = workflow_dict['databaseinfra'].get_driver()
if driver.check_status():
LOG.info("Database is ok...")
database.status=database.ALIVE
database.save()
return True
except Exception:
traceback = full_stack()
workflow_dict['exceptions']['error_codes'].append(DBAAS_0003)
workflow_dict['exceptions']['traceback'].append(traceback)
return False
def do(self):
if self.step_manager.database:
return
origin_database = self.step_manager.origin_database
database = Database.provision(self.step_manager.name, self.infra)
database.team = origin_database.team
database.description = origin_database.description
database.subscribe_to_email_events = (
origin_database.subscribe_to_email_events)
database.is_protected = origin_database.is_protected
if origin_database.project:
database.project = origin_database.project
database.save()
self.step_manager.database = database
self.step_manager.save()
database.pin_task(self.step_manager.task)
def setUp(self):
self.fake_database_create = DatabaseCreate()
self.fake_database_create.task = TaskHistoryFactory.build()
self.fake_database = Database()
def handle(self, *args, **options):
Database.purge_quarantine()
def purge_quarantine():
Database.purge_quarantine()
return
def database(self):
from logical.models import Database
database = Database()
database.name = self.infra.databases_create.last().name
return database
def handle(self, *args, **options):
Database.purge_quarantine()
def restore_snapshot(self, request, database_id):
database = Database.objects.get(id=database_id)
url = reverse('admin:logical_database_change', args=[database.id])
if not database.restore_allowed():
self.message_user(
request,
"Restore is not allowed. Please, contact DBaaS team for more information",
level=messages.WARNING)
return HttpResponseRedirect(url)
if database.is_in_quarantine:
self.message_user(request,
"Database in quarantine and cannot be restored",
level=messages.ERROR)
return HttpResponseRedirect(url)
if database.status != Database.ALIVE or not database.database_status.is_alive:
self.message_user(request,
"Database is dead and cannot be restored",
level=messages.ERROR)
return HttpResponseRedirect(url)
if database.is_beeing_used_elsewhere():
self.message_user(
request,
"Database is beeing used by another task, please check your tasks",
level=messages.ERROR)
return HttpResponseRedirect(url)
if database.has_flipperfox_migration_started():
self.message_user(
request,
"Database {} cannot be restored because it is beeing migrated."
.format(database.name),
level=messages.ERROR)
url = reverse('admin:logical_database_changelist')
return HttpResponseRedirect(url)
form = None
if request.method == 'POST':
form = RestoreDatabaseForm(
request.POST,
initial={"database_id": database_id},
)
if form.is_valid():
target_snapshot = request.POST.get('target_snapshot')
task_history = TaskHistory()
task_history.task_name = "restore_snapshot"
task_history.task_status = task_history.STATUS_WAITING
task_history.arguments = "Restoring {} to an older version.".format(
database.name)
task_history.user = request.user
task_history.save()
Database.recover_snapshot(database=database,
snapshot=target_snapshot,
user=request.user,
task_history=task_history.id)
url = reverse('admin:notification_taskhistory_changelist')
return HttpResponseRedirect(url +
"?user=%s" % request.user.username)
else:
form = RestoreDatabaseForm(initial={
"database_id": database_id,
})
return render_to_response("logical/database/restore.html",
locals(),
context_instance=RequestContext(request))
