def test_best_for_without_plan_and_environment_options_returns_None(self): plan = factory.PlanFactory() environment = plan.environments.all()[0] self.assertIsNone( DatabaseInfra.best_for(plan=plan, environment=environment, name="test"))
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 clean(self): cleaned_data = super(DatabaseForm, self).clean() databaseinfra = DatabaseInfra.best_for(cleaned_data['plan']) if not databaseinfra: raise forms.ValidationError(_("Sorry. I have no infra-structure to allocate this database. Try select another plan.")) cleaned_data['databaseinfra'] = databaseinfra return cleaned_data
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 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, 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 provision(cls, name, plan): # create new databaseinfra LOG.debug("provisioning databaseinfra with plan: %s | name: %s", plan, name) database = Database() database.databaseinfra = DatabaseInfra.best_for(plan) database.name = name database.save() return database
def clean(self): cleaned_data = super(DatabaseForm, self).clean() # if there is an instance, that means that we are in a edit page and therefore # it should return the default cleaned_data if self.instance and self.instance.id: return cleaned_data # TODO: change model field to blank=False if 'team' in cleaned_data: team = cleaned_data['team'] LOG.debug("team: %s" % team) if not team: LOG.warning("No team specified in database form") self._errors["team"] = self.error_class([_("Team: This field is required.")]) if not self.is_valid(): raise forms.ValidationError(self.errors) if len(cleaned_data['name']) > 64: self._errors["name"] = self.error_class([_("Database name too long")]) if 'plan' in cleaned_data: plan = cleaned_data.get('plan', None) if not plan: self._errors["plan"] = self.error_class([_("Plan: This field is required.")]) if 'environment' in cleaned_data: environment = cleaned_data.get('environment', None) if not environment or environment not in plan.environments.all(): raise forms.ValidationError(_("Invalid plan for selected environment.")) #validate if the team has available resources dbs = team.databases_in_use_for(environment) database_alocation_limit = team.database_alocation_limit LOG.debug("dbs: %s | type: %s" % (dbs, type(dbs))) if (database_alocation_limit != 0 and len(dbs) >= database_alocation_limit): LOG.warning("The database alocation limit of %s has been exceeded for the selected team %s => %s" % (database_alocation_limit, team, list(dbs))) self._errors["team"] = self.error_class([_("The database alocation limit of %s has been exceeded for the selected team: %s") % (database_alocation_limit, list(dbs))]) cleaned_data['databaseinfra'] = DatabaseInfra.best_for(plan, environment) if not cleaned_data['databaseinfra']: raise forms.ValidationError(_("Sorry. I have no infra-structure to allocate this database. Try select another plan.")) for infra in DatabaseInfra.objects.filter(environment=environment,plan=plan): if infra.databases.filter(name=cleaned_data['name']): self._errors["name"] = self.error_class([_("this name already exists in the selected environment")]) del cleaned_data["name"] if 'name' in cleaned_data and cleaned_data['name'] in cleaned_data['databaseinfra'].get_driver().RESERVED_DATABASES_NAME: raise forms.ValidationError(_("%s is a reserved database name" % cleaned_data['name'])) return cleaned_data
def test_best_for_with_only_one_datainfra_per_plan_and_environment(self): plan = factory.PlanFactory() environment = plan.environments.all()[0] datainfra = factory.DatabaseInfraFactory(plan=plan, environment=environment) factory.InstanceFactory(address="127.0.0.1", port=27017, databaseinfra=datainfra) self.assertEqual( datainfra, DatabaseInfra.best_for(plan=plan, environment=environment, name="test"))
def test_best_for_with_only_over_capacity_datainfra_returns_None(self): """tests database infra capacity""" NUMBER_OF_DATABASES_TO_TEST = 4 plan = factory.PlanFactory() environment = plan.environments.all()[0] datainfra = factory.DatabaseInfraFactory( plan=plan, environment=environment, capacity=NUMBER_OF_DATABASES_TO_TEST) factory.InstanceFactory(address="127.0.0.1", port=27017, databaseinfra=datainfra) for i in range(NUMBER_OF_DATABASES_TO_TEST): self.assertEqual( datainfra, DatabaseInfra.best_for(plan=plan, environment=environment, name="test")) factory_logical.DatabaseFactory(databaseinfra=datainfra) self.assertIsNone( DatabaseInfra.best_for(plan=plan, environment=environment, name="test"))
def create(self, request): serializer = self.get_serializer(data=request.DATA, files=request.FILES) if serializer.is_valid(): self.pre_save(serializer.object) data = serializer.restore_fields(request.DATA, request.FILES) LOG.info("Plano %s" % data['plan']) plan = data['plan'] if plan.provider == plan.CLOUDSTACK: from notification.tasks import create_database result = create_database.delay(data['name'], data['plan'], data['environment'], data['team'], data['project'], data['description'], request.user) #data = serializer.to_native(self.object) #self.post_save(self.object, created=True) headers = self.get_success_headers(data) task_url = Site.objects.get_current().domain + '/api/task?task_id=%s' % str(result.id) return Response({"task":task_url}, status=status.HTTP_201_CREATED, headers=headers) else: self.pre_save(serializer.object) data = serializer.restore_fields(request.DATA, request.FILES) databaseinfra = DatabaseInfra.best_for(data['plan'], data['environment'], data['name']) self.object = models.Database.provision(data['name'], databaseinfra) self.object.team = data['team'] self.object.project = data['project'] self.object.description = data['description'] self.object.save() data = serializer.to_native(self.object) self.post_save(self.object, created=True) headers = self.get_success_headers(data) return Response(data, status=status.HTTP_201_CREATED, headers=headers) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def clean(self): cleaned_data = super(DatabaseForm, self).clean() # TODO: change model field to blank=False if 'team' in cleaned_data: team = cleaned_data['team'] LOG.debug("team: %s" % team) if not team: LOG.warning = "No team specified in database form" self._errors["team"] = self.error_class([_("Team: This field is required.")]) # if there is an instance, that it means that we are in a edit page and therefore # it should return the default cleaned_data if self.instance and self.instance.id: return cleaned_data if not self.is_valid(): raise forms.ValidationError(self.errors) if len(cleaned_data['name']) > 64: self._errors["name"] = self.error_class([_("Database name too long")]) plan = cleaned_data['plan'] environment = cleaned_data.get('environment', None) if not environment or environment not in plan.environments.all(): raise forms.ValidationError(_("Invalid plan for selected environment.")) cleaned_data['databaseinfra'] = DatabaseInfra.best_for(plan, environment) if not cleaned_data['databaseinfra']: raise forms.ValidationError(_("Sorry. I have no infra-structure to allocate this database. Try select another plan.")) for infra in DatabaseInfra.objects.filter(environment=environment,plan=plan): if infra.databases.filter(name=cleaned_data['name']): self._errors["name"] = self.error_class([_("this name already exists in the selected environment")]) del cleaned_data["name"] if 'name' in cleaned_data and cleaned_data['name'] in cleaned_data['databaseinfra'].get_driver().RESERVED_DATABASES_NAME: raise forms.ValidationError(_("%s is a reserved database name" % cleaned_data['name'])) return cleaned_data
def make_infra(plan, environment, name,task=None): if not plan.provider == plan.CLOUDSTACK: dbinfra = DatabaseInfra.best_for(plan= plan, environment= environment, name= name) if dbinfra: return build_dict(databaseinfra= dbinfra, created=True) return build_dict(databaseinfra=None, created= False) workflow_dict = build_dict(name= name, plan= plan, environment= environment, steps= get_engine_steps(engine= str(plan.engine_type)), qt= get_vm_qt(plan= plan, ), MYSQL = MYSQL, MONGODB = MONGODB, enginecod = get_engine(engine= str(plan.engine_type)) ) start_workflow(workflow_dict= workflow_dict, task=task) return workflow_dict
def provision(cls, name, plan, environment): # create new databaseinfra LOG.debug("provisioning databaseinfra with name %s, plan %s and environment %s", name, plan, environment) if not isinstance(plan, Plan): raise ValidationError('Invalid plan type %s - %s' % (type(plan), plan)) if not isinstance(environment, Environment): raise ValidationError('Invalid environment type %s - %s' % (type(environment), environment)) datainfra = DatabaseInfra.best_for(plan, environment) if not datainfra: raise NoDatabaseInfraCapacity() database = Database() database.databaseinfra = datainfra database.name = name database.full_clean() database.save() # refresh object from database database = Database.objects.get(pk=database.pk) return database
def make_infra(plan, environment, name,task=None): if not plan.provider == plan.CLOUDSTACK: dbinfra = DatabaseInfra.best_for(plan= plan, environment= environment, name= name) if dbinfra: return build_dict(databaseinfra= dbinfra, created=True) return build_dict(databaseinfra=None, created= False) workflow_dict = build_dict(name= slugify(name), plan= plan, environment= environment, steps= get_engine_steps(engine= str(plan.engine_type)), qt= get_vm_qt(plan= plan, ), MYSQL = MYSQL, MONGODB = MONGODB, REDIS = REDIS, enginecod = get_engine(engine= str(plan.engine_type)) ) start_workflow(workflow_dict= workflow_dict, task=task) return workflow_dict
def test_best_for_with_only_two_datainfra_per_plan_and_environment_returns_rounding_robin_them( self): plan = factory.PlanFactory() environment = plan.environments.all()[0] datainfra1 = factory.DatabaseInfraFactory(plan=plan, environment=environment, capacity=10) factory.InstanceFactory(address="127.0.0.1", port=27017, databaseinfra=datainfra1) datainfra2 = factory.DatabaseInfraFactory(plan=plan, environment=environment, capacity=10) factory.InstanceFactory(address="127.0.0.2", port=27017, databaseinfra=datainfra2) for i in range(10): should_choose = (datainfra1, datainfra2)[i % 2] choosed = DatabaseInfra.best_for(plan=plan, environment=environment, name="test") self.assertEqual(should_choose, choosed) database = factory_logical.DatabaseFactory(databaseinfra=choosed) self.assertEqual(choosed, database.databaseinfra)