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 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 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 _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 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))